Why stop at just Images?

In this post, I will dig into a set of classes I created to help extend support for adding in any type of extension item support for Commerce Server 2007.  I will define an extension item as anything that can be related to Products or Categories in CS 2007 that does not come prepackaged with the install.  This includes images, videos and general file attachments.

I will assume you have read Max Akbar's 5 part series on adding Image Management support to CS 2007 before taking a look at this. Reading hs series isn't required, but much of what I'm implemented stemmed from his ideas and much of my data model matches what he recommended as a set up.

The Goal

Create fully functional tabs within Product and Category property settings in the Product Catalog Manager application that comes with Commerce Server 2007.  These tabs will give the user the ability to associate Images, Videos and Attachments to a Product or Category.  On the backend, these items will be saved to disk and their assocations maintained in the SQL Server database for the Product Catalog.

The Code

As I mentioned, this code basically follows what Max originally demonstrated.  It makes use of the Bridge Design pattern which I happen to like, however it does make compilation tricky when a Web Service is involved due to the quazi circular reference that is created by having a Class Library have a Web Reference to a Web Service that in turn directly references that same Class Library.  During coding of this, I found myself "stubbing" out methods just so I could get the code to compile. I would then fill in the details after the successful compilation.

Continuing on with that point, another thing that I did not want to have to work with was the DataTable class. I absolutely HATE DataTables and use them only when absolutely necessary which seems to be less and less frequently nowadays.  However, in this scenario, the DataTable must stay around because of the quazi circular reference. If you try and create a custom class in the Class Library project. The WebService will generate a proxy class (with another namespace) that will cause your code to never compile (without doing some hacking of the proxy class).   So I decided to work with the DataTables in favor of upholding the Bridge pattern and created some custom classes that inherited from DataTable and set their necessary columns upon instantiation.

Finally, I might end up refactoring some of the code that I will paste below since the project I am using this code on is still in progress.  I will certainly make sure to update the revisions on Code Project.  I might not put all the code up here, but I will eventually have it all up on Code Project after my postings.  (Probably 3 total, this being #1)

Anyway, let's get to the code!

CommerceServerExtensions Project

This class library project will contain the base classes and interfaces for defining management support entities.  This project will also contain some built in implementations of these classes for images, videos and attachments.

Let's take a look at the base classes and interfaces:

ExtensionImplementor

    /// <summary>
    /// Defines the contract for accessing Extension items in Commerce Server.
    /// </summary>
    publicinterface ExtensionImplementor
    {
        /// <summary>
        /// Removes the extension items in the passed in records ExtensionDataTable.
        /// </summary>
        /// <param name="records">An ExtensionDataTable containing extension items to be removed.</param>
        void Remove(DataTable records);

        /// <summary>
        /// Saves the extension items in the passed in records ExtensionDataTable.
        /// </summary>
        /// <param name="records">An ExtensionDataTable containing extension items to be saved.</param>
        void Save(DataTable records);

        /// <summary>
        /// Resequences the extension items in the passed in records ExtensionDataTable.
        /// </summary>
        /// <param name="records">An ExtensionDataTable containing extension items to be saved.</param>
        void Resequence(DataTable records);

        /// <summary>
        /// Retrieves the extension items based on the passed in Commerce Server entity name and type.
        /// </summary>
        /// <param name="entityName">The Commerce Server entity name (ProductId or CategoryId)</param>
        /// <param name="type">The extension item type.</param>
        /// <returns>An ExtensionDataTable containing the retrieved extension items.</returns>
        DataTable Retrieve(string entityName, string type);

        /// <summary>
        /// Searches for extension items based on the extension item id, keyword and number of records.
        /// </summary>
        /// <param name="id">The extension item id</param>
        /// <param name="keyword">The keyword to search on</param>
        /// <param name="numRecords">The number of recrods to return</param>
        /// <returns>An ExtensionDataTable containing the search resulting extension items.</returns>
        DataTable Search(int id, string keyword, int numRecords);

        /// <summary>
        /// Retrieves all the available Extension item types.
        /// </summary>
        /// <returns>A String Array of all the available Extension item types.</returns>
        string[] RetrieveTypes();

        /// <summary>
        /// Retrieves the Extension Item contents based off the passed in extension item id and file name.
        /// </summary>
        /// <param name="id">The extension item id</param>
        /// <param name="fileName">The extension item file name</param>
        /// <returns>A Byte Array of the Extension Item contents</returns>
        byte[] GetBytes(int id, string fileName);

    }

ExtensionSiteAgent 

    /// <summary>
    /// Sets the information to connect to the Product Catalog database for extension item tables.
    /// </summary>
    publicclass ExtensionSiteAgent
    {
        /// <summary>
        /// Gets or sets the path to the Authorization Policy.
        /// </summary>
        publicstring AuthorizationPolicyPath { get; set; }

        /// <summary>
        /// Gets or sets the name of the Commerce Server Site.
        /// </summary>
        publicstring SiteName { get; set; }
    }

          
            
              ExtensionServiceAgent
            
          
        

            
               ///
<summary>
              ///
Sets the information to connect to the WebService for a Extension item objects.
              ///
</summary>
              public
              class ExtensionServiceAgent
{ ///
<summary>///
Gets or sets the credentials for accessing the WebService.///
</summary>public ICredentials
Credentials { get; set; } ///
<summary>///
Gets or sets the WebService Uri.///
</summary>public Uri
ServiceUri { get; set; } }
          

            
              
                ExtensionWebServiceAccess
              
            
          

              
                 ///
<summary>
                ///
Controls action to WebServices implementing the ExtensionImplementor Interface.
                ///
</summary>
                public
                abstract
                class ExtensionWebServiceAccess<T>:ExtensionImplementor
where T : ExtensionImplementor { ///
<summary>///
Returns an instance of a WebService proxy implementing the ExtensionImplementor Interface.///
</summary>protectedabstract T
WebService { get; } /////
<summary>/////
Calls the WebService object and removes the items represented by the passed in DataTable./////
</summary>publicvirtualvoid Remove(DataTable
records) { WebService.Remove(records); } /////
<summary>/////
Calls the WebService and saves the records in the passed in DataTable./////
</summary>publicvirtualvoid Save(DataTable
records) { WebService.Save(records); } /////
<summary>/////
Calls the WebService to resequence the records contained in the passed in DataTable./////
</summary>///
<param name="records">An ExtensionDataTable containing rows of extension items
to resequence</param>publicvirtualvoid Resequence(DataTable
records) { WebService.Resequence(records); } ///
<summary>///
Calls the WebService to retrieve the records represented by the passed in id and type.///
</summary>///
<param name="id">The Commerce Server id which can be a product or category id
of the items to retrieve.</param>///
<param name="type">The Extension type of the items to retrieve.</param>///
<returns>An ExtensionDataTable containing rows of extension items retrieved</returns>publicvirtual DataTable
Retrieve(string id, string type)
{ return WebService.Retrieve(id,
type); } /////
<summary>/////
Calls the WebService to search items by the passed in id and keyword and number of
records./////
</summary>/////
<param name="id">The Extension item id</param>/////
<param name="keyword">The keyword to search on.</param>/////
<param name="numRecords">The number of recrods to return.</param>/////
<returns>An ExtensionDataTable containing the rows of extension items retrieved</returns>publicvirtual DataTable
Search(int id, string keyword, int numRecords)
{ return WebService.Search(id,
keyword, numRecords); } ///
<summary>///
Returns all the available extension item types.///
</summary>///
<returns>A string array of all the available extension item types</returns>publicvirtualstring[]
RetrieveTypes() { return WebService.RetrieveTypes();
} ///
<summary>///
Returns a byte array of the extension item represented by the passed in id and file
name.///
</summary>///
<param name="id">The Extension item id</param>///
<param name="fileName"></param>///
<returns>A byte array of the Extension item objects.</returns>publicbyte[]
GetBytes(int id, string fileName)
{ return WebService.GetBytes(id,fileName);
} }
            

              
               ExtensionContext

              
                
                  
                  
                
                ///
<summary>///
Provides access to the ExtensionImplementor as well as security credentials and site
name.///
</summary>///
<typeparam name="T">Any ExtensionImplementor class</typeparam>publicclass ExtensionContext<T>
where T: ExtensionImplementor { ///
<summary>///
Creates a new ExtensionContext instance using the passed in ExtensionSiteAgent class.///
</summary>///
<param name="siteAgent"></param>public ExtensionContext(ExtensionSiteAgent
siteAgent) { this.SiteAgent = siteAgent;
} ///
<summary>///
Creates a new ExtensionContext instance using the passed in ExtensionServiceAgent
class.///
</summary>///
<param name="serviceAgent"></param>public ExtensionContext(ExtensionServiceAgent
serviceAgent) { this.ServiceAgent = serviceAgent;
} ///
<summary>///
Gets or sets the ExtensionImplementor class to be used with this ExtensionContext.///
</summary>public T
Implementor { get; set; } ///
<summary>///
Gets or sets the ExtensionServiceAgent class to be used with this ExtensionContext.///
</summary>public ExtensionServiceAgent
ServiceAgent { get; private set;
} ///
<summary>///
Gets or sets the ExtensionSiteAgent class to be used with this ExtensionContext.///
</summary>public ExtensionSiteAgent
SiteAgent { get; private set;
} }

            
             ExtensionCommerceModule

            
              
              
              ///
<summary>///
Provides access to the Extension Item Context for use in the Extension Item WebServices.///
</summary>///
<typeparam name="T">A class implementing a typed ExtensionImplementor</typeparam>publicclass ExtensionCommerceModule<T>
: CommerceModule where T : ExtensionImplementor { private ExtensionContext<T>
_context; privatebool disposed =false; ///
<summary>///
Returns a unique resource key based on the extension item type.///
</summary>///
<returns>The unique resource key</returns>publicstaticstring GetResourceKey()
{ returnstring.Format("{0}_{1}", typeof(T), "key");
} ///
<summary>///
Creates a new context based off the object type of T using the passed in ExtensionSiteAgent.///
</summary>///
<param name="agent"></param>///
<returns>A typed ExtensionContext providing access to typed Extension items.</returns>protected ExtensionContext<T>
CreateContext(ExtensionSiteAgent agent) { returnnew ExtensionContext<T>(agent);
} ///
<summary>///
Gets the typed Extension Item Context.///
</summary>public ExtensionContext<T>
Context { get { //
Create the singleton instance of the resourceif (_context
== null)
{ //
Lock to prevent race conditions and ensure that exactly one//
instance of the resource is createdlock (typeof(ExtensionContext<T>))
{ //now
it is safe to create a new image contextif (_context
== null)
{ ExtensionSiteAgent agent =new ExtensionSiteAgent();
agent.SiteName = CommerceContext.Current.SiteName; //
TODO: See if we need to have authorization enabled? _context = CreateContext(agent);
} } } return _context;
} } ///
<param name="disposing">true if this was called from the Dispose method, false
if called from the finalizer.</param>protectedoverridevoid Dispose(bool disposing)
{ //
Check to see if Dispose has already been called.if (!this.disposed)
{ this.disposed =true; //
If disposing equals true, dispose all managed //
and unmanaged resources.if (disposing)
{ //
Dispose managed resources. } //
Release unmanaged resources. If disposing is false, //
only the following code is executed.//
...//
Now call the base class's dispose:base.Dispose(disposing);
} } ///
<param name="appInstance">The current Application instance (ASP.Net maintains
a pool of these for every ASP.Net application</param>publicoverridevoid Init(HttpApplication
appInstance) { //
First declare module and resource dependencies using the//
CommerceModule protected helper methods. These will throw//
CommerceResourceDependencyExceptions or//
CommerceModuleDependencyExceptions if the dependencies don’t exist//
This module depends on the CatalogModule having been initialized//
in the pipeline before this module. We need the Catalog Module //
to be intialized in order to get the connection string to access //
the image SQL objects.//DeclareModuleDependency(typeof(CommerceCatalogModule),
this.GetType());//
subscribe to BeginRequest events appInstance.BeginRequest += new EventHandler(OnBeginRequest); //make
sure to call the base versionbase.Init(appInstance);
} ///
<summary>///
BeginRequest event handler///
</summary>///
<param name="sender"></param>///
<param name="e"></param>publicvoid OnBeginRequest(Object
sender, EventArgs e) { HttpContext ctx = HttpContext.Current; if (ctx
!=null)
ctx.Items[GetResourceKey()] = Context;
} } 

              
                 ///
<summary>
                ///
A DataTable containing columns specific to an Extension item type.
                ///
</summary>
                public
                abstract
                class ExtensionDataTable
: DataTable { ///
<summary>///
Gets the name of this ExtensionDataTable.///
</summary>protectedabstractstring Name
{ get; } ///
<summary>///
Creates a new instance of this class setting the appropriate columns for Extension
Management.///
</summary>public ExtensionDataTable()
{ base.TableName =this.Name; this.Columns.Add(Constants.Type); this.Columns.Add(Constants.FileId, typeof(int)); this.Columns.Add(Constants.HierarchyId, typeof(int)); this.Columns.Add(Constants.FeatureId, typeof(int)); this.Columns.Add(Constants.Sequence, typeof(int)); this.Columns.Add(Constants.ProductId); this.Columns.Add(Constants.VariantId); this.Columns.Add(Constants.CategoryName); this.Columns.Add(Constants.CatalogName); this.Columns.Add(Constants.DisplayName); this.Columns.Add(Constants.Name); this.Columns.Add(Constants.ClientFileName); this.Columns.Add(Constants.Height, typeof(int)); this.Columns.Add(Constants.Width, typeof(int)); this.Columns.Add(Constants.Bytes, typeof(byte[]));
} ///
<summary>///
Provides the look up values for the different columns represented in the parent class.///
</summary>publicstaticclass Constants
{ publicconststring Type ="Type"; publicconststring FileId ="FileId"; publicconststring FeatureId ="FeatureId"; publicconststring Sequence ="Sequence"; publicconststring ProductId ="ProductId"; publicconststring VariantId ="VariantId"; publicconststring CategoryName ="CategoryName"; publicconststring CatalogName ="CatalogName"; publicconststring DisplayName ="DisplayName"; publicconststring HierarchyId ="HierarchyId"; publicconststring Name ="Name"; publicconststring ClientFileName ="ClientFileName"; publicconststring Height ="Height"; publicconststring Width ="Width"; publicconststring Bytes ="Bytes";
} } 

              
                ImageImplementor
               

ImageWebServiceAccess 

 ///
<summary>///
Controls action to WebServices implementing the ImageImplementor Interface.///
</summary>publicclass ImageWebServiceAccess
: ExtensionWebServiceAccess<ImageWebService.ImageWebService>, ImageImplementor
{ ImageWebService.ImageWebService _imageWebService =new ImageWebService.ImageWebService(); ///
<summary>///
Returns the instance of the Image Web Service///
</summary>protectedoverride ImageWebService.ImageWebService
WebService { get { return _imageWebService;
} } } 

ImageDataTable 

 ///
<summary>///
A DataTable containing columns specific to a Image item type.///
</summary>publicclass ImageDataTable
: ExtensionDataTable { protectedoverridestring Name
{ get { return"Images";
} } } 

ImageWebService 

///
<summary>///
Implements the ImageImplementor interface to provide external access to image extension
items in Commerce Server.///
</summary> [WebService(Namespace ="http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)] publicclass ImageWebService
: System.Web.Services.WebService,ImageImplementor { ExtensionContext<ImageImplementor>
_context =null; ///
<summary>///
Default constructor retrieves and sets the ImageImplementor from the ExtensionCommerceModule.///
</summary>public ImageWebService()
{ _context = ((ExtensionContext<ImageImplementor>)HttpContext.Current.Items[ExtensionCommerceModule<ImageImplementor>.GetResourceKey()]);
_context.Implementor =new ImageDirector(_context.SiteAgent);
} ///
<summary>///
Retrieves all Image records related to the passed in ProductID.///
</summary>///
<param name="id"></param>///
<returns></returns> [WebMethod] public DataTable
Retrieve(string entityName, string imageType)
{ return _context.Implementor.Retrieve(entityName,
imageType); } ///
<summary>///
Removes all the images represented by the passed in DataTable.///
</summary>///
<param name="imageDataTable"></param> [WebMethod] publicvoid Remove(DataTable
imageDataTable) { _context.Implementor.Remove(imageDataTable); } ///
<summary>///
Changes the sequence order of the images represented by the passed in DataTable.///
</summary>///
<param name="imageDataTable"></param> [WebMethod] publicvoid Resequence(DataTable
imageDataTable) { _context.Implementor.Resequence(imageDataTable); } ///
<summary>///
Creates or Updates images represented by the passed in DataTable.///
</summary>///
<param name="imageDataTable"></param> [WebMethod] publicvoid Save(DataTable
imageDataTable) { _context.Implementor.Save(imageDataTable); } ///
<summary>///
Returns the images based on the imageFileId and keyword passed in.///
</summary>///
<param name="imageFileId"></param>///
<param name="keyword"></param>///
<param name="numRecords"></param>///
<returns></returns> [WebMethod] public DataTable
Search(int id, string keyword, int numRecords)
{ return _context.Implementor.Search(id,
keyword, numRecords); } ///
<summary>///
Returns the byte array of the passed in imageFileId and filename.///
</summary>///
<param name="imageFileId"></param>///
<param name="fileName"></param>///
<returns></returns> [WebMethod] publicbyte[]
GetBytes(int imageFileId, string fileName)
{ return _context.Implementor.GetBytes(imageFileId,
fileName); } [WebMethod] publicstring[]
RetrieveTypes() { return _context.Implementor.RetrieveTypes();
} 

Here is the data access layer class I created for Image support:

ImageDatabaseAccess

   ///
<summary>///
Controls all database access for correlating Images to Commerce Server 2007 entities.///
</summary>publicclass ImageDatabaseAccess
{ Database db =null; ///
<summary>///
Creates an instance of this class and sets site information based on the passed in
ImageSiteAgent instance.///
</summary>///
<param name="imageSiteAgent"></param>public ImageDatabaseAccess(ExtensionSiteAgent
imageSiteAgent) { //
TODO: Cache the Connection string//
get the connection string for the databasestring siteName = imageSiteAgent.SiteName;
CommerceResourceCollection cs =new CommerceResourceCollection(siteName);
OleDbConnectionStringBuilder builder1 =new OleDbConnectionStringBuilder(cs["Product
Catalog"]["connstr_db_Catalog"].ToString());
builder1.Remove("Provider");
db =new SqlDatabase(builder1.ConnectionString);
} ///
<summary>///
Resequences the images in the passed in ImageDataTable in the database.///
</summary>///
<param name="imageDataTable"></param>publicvoid ResequenceImageRecords(DataTable
imageDataTable) { DbCommand dbCommand = db.GetStoredProcCommand("img_Resequence"); foreach (DataRow
record in imageDataTable.Rows)
{ db.AddInParameter(dbCommand, "@ImageHierarchyID",
DbType.Int32, record[ImageDataTable.Constants.HierarchyId]); db.AddInParameter(dbCommand, "@ImageFileID",
DbType.Int32, record[ImageDataTable.Constants.FileId]); db.AddInParameter(dbCommand, "@ProductID",
DbType.String, record[ImageDataTable.Constants.ProductId]); db.AddInParameter(dbCommand, "@Sequence",
DbType.Int32, record[ImageDataTable.Constants.Sequence]); db.ExecuteNonQuery(dbCommand);
} } ///
<summary>///
Saves the images in the passed in ImageDataTable to the database.///
</summary>///
<param name="imageDataTable"></param>publicvoid SaveImageRecords(DataTable
imageDataTable) { DbCommand dbCommand = db.GetStoredProcCommand("img_CreateImage");
db.DiscoverParameters(dbCommand); foreach (DataRow
record in imageDataTable.Rows)
{ dbCommand.Parameters["@FeatureID"].Value = record[ImageDataTable.Constants.FeatureId];
dbCommand.Parameters["@Sequence"].Value = record[ImageDataTable.Constants.Sequence];
dbCommand.Parameters["@ProductID"].Value = record[ImageDataTable.Constants.ProductId];
dbCommand.Parameters["@VariantID"].Value = record[ImageDataTable.Constants.VariantId];
dbCommand.Parameters["@CategoryName"].Value = record[ImageDataTable.Constants.CategoryName];
dbCommand.Parameters["@CatalogName"].Value = record[ImageDataTable.Constants.CatalogName];
dbCommand.Parameters["@DisplayName"].Value = record[ImageDataTable.Constants.DisplayName];
dbCommand.Parameters["@ImageName"].Value = record[ImageDataTable.Constants.Name];
dbCommand.Parameters["@Height"].Value = record[ImageDataTable.Constants.Height];
dbCommand.Parameters["@Width"].Value = record[ImageDataTable.Constants.Width]; if (record[ImageDataTable.Constants.FileId]
!= DBNull.Value)
dbCommand.Parameters["@ImageFileID"].Value = record[ImageDataTable.Constants.FileId];
record[ImageDataTable.Constants.FileId] = (int)db.ExecuteScalar(dbCommand);
} } ///
<summary>///
Returns the images from the database based on the passed in ImageFileId and keyword.///
</summary>///
<param name="imageFileId"></param>///
<param name="keyword"></param>///
<param name="numRecords"></param>///
<returns></returns>public DataTable
SearchImageRecords(int imageFileId, string keyword, int numRecords)
{ DbCommand dbCommand = db.GetStoredProcCommand("img_Search");
db.DiscoverParameters(dbCommand); dbCommand.Parameters["@ImageFileId"].Value = imageFileId; if (keyword
!=null)
dbCommand.Parameters["@keyword"].Value = keyword;
dbCommand.Parameters["@RecordsReturned"].Value = numRecords; return PopulateProductImageDataTableFromDbCommand(db,
dbCommand); } ///
<summary>///
Retrieves the image records from the database for the passed in ProductID.///
</summary>///
<param name="entityName"></param>///
<param name="imageType"></param>///
<returns></returns>public DataTable
RetrieveImageRecords(string entityName, string imageType)
{ string spName = imageType
== "ProductImage" ? "img_GetImageProduct" : "img_GetImageCategory";
DbCommand dbCommand = db.GetStoredProcCommand(spName);
db.DiscoverParameters(dbCommand); if (imageType
== "ProductImage")
dbCommand.Parameters["@ProductID"].Value = entityName; else dbCommand.Parameters["@CategoryName"].Value = entityName; return PopulateProductImageDataTableFromDbCommand(db,
dbCommand); } ///
<summary>///
Removes all image records in the database contained in the passed in ImageDataTable.///
</summary>///
<param name="imageDataTable"></param>publicvoid RemoveImageRecords(DataTable
imageDataTable) { if (imageDataTable.Rows.Count
> 0) { string imageType = (string)imageDataTable.Rows[0][ImageDataTable.Constants.Type]; string spName = imageType
== "ProductImage" ? "img_DeleteProduct" : "img_DeleteCategory";
DbCommand dbCommand = db.GetStoredProcCommand(spName);
db.DiscoverParameters(dbCommand); foreach (DataRow
dr in imageDataTable.Rows)
{ dbCommand.Parameters["@ImageFileId"].Value = (int)dr[ImageDataTable.Constants.FileId]; if (imageType
== "ProductImage")
dbCommand.Parameters["@ProductId"].Value = (string)dr[ImageDataTable.Constants.ProductId]; else dbCommand.Parameters["@CategoryName"].Value = (string)dr[ImageDataTable.Constants.CategoryName];
db.ExecuteNonQuery(dbCommand); } } } ///
<summary>///
Populates an ImageDataTable with Image information obtained from executing the passed
in DdCommand and Database objects.///
</summary>///
<param name="db"></param>///
<param name="dbCommand"></param>///
<returns></returns>private DataTable
PopulateProductImageDataTableFromDbCommand(Database db, DbCommand dbCommand) { DataTable
imageDataTable =new ImageDataTable(); using (IDataReader
reader = db.ExecuteReader(dbCommand))
{ while (reader.Read())
{ DataRow record = imageDataTable.NewRow();
record[ImageDataTable.Constants.Sequence] = reader["Sequence"];
record[ImageDataTable.Constants.DisplayName] = reader["DisplayName"];
record[ImageDataTable.Constants.Name] = reader["ImageName"];
record[ImageDataTable.Constants.Height] = reader["Height"];
record[ImageDataTable.Constants.Width] = reader["Width"];
record[ImageDataTable.Constants.ProductId] = reader["ProductID"];
record[ImageDataTable.Constants.VariantId] = reader["VariantID"];
record[ImageDataTable.Constants.FileId] = reader["ImageFileID"];
imageDataTable.Rows.Add(record); } } imageDataTable.AcceptChanges(); return imageDataTable;
} } 

Finally I had to create a Partial class on the ImageWebService proxy class so it could implement the ImageImplementor interface. This code lives in the CommerceServerExtensions project.

   ///
<summary>  ///
Extends the ImageWebService web service proxy so it implements the ImageImplementor
interface.  ///
</summary>  public  partial  class  ImageWebService:ImageImplementor
{ } 

That's all the backend code for images. The data model is nearly identical to what was in Max Akbar's blog posting with only a few adjustments. Again, I will post this along with all the code on Code Project after my final post regarding this topic.

What's Next

In my next posting, I will show the code for Videos and Attachments and then get into the CatalogManager WinForm code.

Welcome to my first blog post in many years!  

I am working on a project to develop a product catalog website for a client of Triton-Tek.

In this post I will continue where Max Akbar left off on creating Image Management within your Commerce Server 2007 website.  Max's 5 part series was an extremely helpful starting point to allow users to correlate images with products and categories inside the Product Catalog Manager application. That series is certainly a prerequisite to what I will be showing in my upcoming posts.

What's Left To Show

I will demonstrate how I finished implementing the functionality. This was done mostly by using what Max started off with, but then modifying some of the database changes as well as the ImageWebService from his postings.  I will additionally add in support to correlate media with products and categories in the form of an additional new tab alongside the "Image" tab.  Finally I will show how to hook everything up on your Commerce Server website.

Much more to come....