Select a site

IMPORTANT: This version of Sitefinity CMS is out of support and the respective product documentation is no longer maintained and can be outdated. Use the version selector to view a supported product version.

Custom Products module: Implement the manager class

After Custom Products module: Implement the configuration class, you implement a manager class:

  1. Expand the ProductsModule project, open the context menu of the Data folder and  click Add » Class.
  2. Name the class file ProductsManager.cs and click Add.
  3. Open the ProductsManager.cs file and add the following using statements:
    using ProductCatalogSample.Configuration;
    using ProductCatalogSample.Model;
    using Telerik.Sitefinity;
    using Telerik.Sitefinity.Configuration;
    using Telerik.Sitefinity.Data;
    using Telerik.Sitefinity.Data.ContentLinks;
    using Telerik.Sitefinity.GenericContent.Model;
    using Telerik.Sitefinity.Lifecycle;
    using Telerik.Sitefinity.Modules;
    using Telerik.Sitefinity.Modules.GenericContent;
  4. Make the ProductsManager class inherit the ContentManagerBase<ProductsDataProvider> class and the 

    IContentLifecycleManager<ProductItem>interface and to implement the ILifecycleManager interface:

    public class ProductsManager : ContentManagerBase<ProductsDataProvider>, IContentLifecycleManager<ProductItem>, ILifecycleManager
    {
    }
  5. Create the following constructors in the class:
    public ProductsManager()
        : this(null)
    {
    }
     
    public ProductsManager(string providerName)
        : base(providerName)
    {
    }
     
    public ProductsManager(string providerName, string transactionName)
        : base(providerName, transactionName)
    {
    }
  6. Create the following static methods:
    public static ProductsManager GetManager()
    {
        return ManagerBase<ProductsDataProvider>.GetManager<ProductsManager>();
    }
     
    public static ProductsManager GetManager(string providerName)
    {
        return ManagerBase<ProductsDataProvider>.GetManager<ProductsManager>(providerName);
    }
     
    public static ProductsManager GetManager(string providerName, string transactionName)
    {
        return ManagerBase<ProductsDataProvider>.GetManager<ProductsManager>(providerName, transactionName);
    }
  7. Wire up the manager class to the data provider class by creating the following methods:
    public ProductItem CreateProduct()
    {
        return this.Provider.CreateProduct();
    }
       
    public ProductItem CreateProduct(Guid id)
    {
        return this.Provider.CreateProduct(id);
    }
       
    public virtual ProductItem CheckOut(ProductItem productItem)
    {
        return (ProductItem)this.Lifecycle.CheckOut(productItem);
    }
      
    public Telerik.Sitefinity.GenericContent.Model.Content CheckOut(Telerik.Sitefinity.GenericContent.Model.Content item)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.CheckOut(product);
        throw new NotSupportedException();
    }
       
    public virtual ProductItem CheckIn(ProductItem productItem)
    {
        return (ProductItem)this.Lifecycle.CheckIn(productItem);
    }
     
    public Telerik.Sitefinity.GenericContent.Model.Content CheckIn(Telerik.Sitefinity.GenericContent.Model.Content item)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.CheckIn(product);
        throw new NotSupportedException();
    }
       
    public ProductItem GetProduct(Guid id)
    {
        return this.Provider.GetProduct(id);
    }
       
    public IQueryable<ProductItem> GetProducts()
    {
        return this.Provider.GetProducts();
    }
       
    public void DeleteProduct(ProductItem product)
    {
        this.Provider.DeleteProduct(product);
    }
      
    public ILifecycleDecorator Lifecycle
    {
        get
        {
            return LifecycleFactory.CreateLifecycle<ProductItem>(this, this.Copy);
        }
    }
      
    public void Copy(ProductItem source, ProductItem destination)
    {
        destination.Urls.ClearDestinationUrls(source.Urls, this.Delete);
        source.Urls.CopyTo(destination.Urls, destination);
       
        ContentLinksExtensions.CopyContentLink("ProductImage", source, destination);
       
        destination.Price = source.Price;
        destination.QuantityInStock = source.QuantityInStock;
    }
       
    public void Copy(Telerik.Sitefinity.GenericContent.Model.Content source, Telerik.Sitefinity.GenericContent.Model.Content destination)
    {
        if (source == null)
        {
            throw new ArgumentNullException("source");
        }
       
        if (destination == null)
        {
            throw new ArgumentNullException("destination");
        }
       
        var productSource = source as ProductItem;
        var productDestination = destination as ProductItem;
        if (productSource == null || productDestination == null)
        {
            throw new ArgumentException("Source and destination must be of the same type");
        }
       
        this.Copy(productSource, productDestination);
    }
       
    public ProductItem Edit(ProductItem item)
    {
        return (ProductItem)this.Lifecycle.Edit(item);
    }
      
    public Telerik.Sitefinity.GenericContent.Model.Content Edit(Telerik.Sitefinity.GenericContent.Model.Content item)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.Edit(product);
        throw new NotSupportedException();
    }
      
    public Guid GetCheckedOutBy(ProductItem item)
    {
        return this.Lifecycle.GetCheckedOutBy(item);
    }
      
    public Guid GetCheckedOutBy(Telerik.Sitefinity.GenericContent.Model.Content item)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.GetCheckedOutBy(product);
        throw new NotSupportedException();
    }
      
    public ProductItem GetLive(ProductItem cnt)
    {
        return (ProductItem)(this.Lifecycle).GetLive(cnt);
    }
      
    public Telerik.Sitefinity.GenericContent.Model.Content GetLive(Telerik.Sitefinity.GenericContent.Model.Content cnt)
    {
        var product = cnt as ProductItem;
        if (product != null)
            return this.GetLive(product);
        throw new NotSupportedException();
    }
      
    public ProductItem GetMaster(ProductItem cnt)
    {
        return (ProductItem)(this.Lifecycle).GetMaster(cnt);
    }
      
    public Telerik.Sitefinity.GenericContent.Model.Content GetMaster(Telerik.Sitefinity.GenericContent.Model.Content cnt)
    {
        var product = cnt as ProductItem;
        if (product != null)
            return this.GetMaster(product);
        throw new NotSupportedException();
    }
      
    public ProductItem GetTemp(ProductItem cnt)
    {
        return (ProductItem)(this.Lifecycle).GetTemp(cnt);
    }
      
    public Telerik.Sitefinity.GenericContent.Model.Content GetTemp(Telerik.Sitefinity.GenericContent.Model.Content cnt)
    {
        var product = cnt as ProductItem;
        if (product != null)
            return this.GetTemp(product);
        throw new NotSupportedException();
    }
      
    public bool IsCheckedOut(ProductItem item)
    {
        return this.Lifecycle.IsCheckedOut(item);
    }
      
    public bool IsCheckedOut(Telerik.Sitefinity.GenericContent.Model.Content item)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.IsCheckedOut(product);
        throw new NotSupportedException();
    }
      
    public bool IsCheckedOutBy(ProductItem item, Guid userId)
    {
        return this.Lifecycle.IsCheckedOutBy(item, userId);
    }
      
    public bool IsCheckedOutBy(Telerik.Sitefinity.GenericContent.Model.Content item, Guid userId)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.IsCheckedOutBy(product, userId);
        throw new NotSupportedException();
    }
      
    public ProductItem Publish(ProductItem item)
    {
        return (ProductItem)this.Lifecycle.Publish(item);
    }
      
    public Telerik.Sitefinity.GenericContent.Model.Content Publish(Telerik.Sitefinity.GenericContent.Model.Content item)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.Publish(product);
        throw new NotSupportedException();
    }
      
    public ProductItem Schedule(ProductItem item, DateTime publicationDate, DateTime? expirationDate)
    {
        return this.Provider.Schedule(item, publicationDate, expirationDate, this.Copy, this.GetProducts());
    }
      
    public Telerik.Sitefinity.GenericContent.Model.Content Schedule(Telerik.Sitefinity.GenericContent.Model.Content item, DateTime publicationDate, DateTime? expirationDate)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.Schedule(product, publicationDate, expirationDate);
        throw new NotSupportedException();
    }
      
    public ProductItem Unpublish(ProductItem item)
    {
        return (ProductItem)this.Lifecycle.Unpublish(item);
    }
      
    public Telerik.Sitefinity.GenericContent.Model.Content Unpublish(Telerik.Sitefinity.GenericContent.Model.Content item)
    {
        var product = item as ProductItem;
        if (product != null)
            return this.Unpublish(product);
        throw new NotSupportedException();
    }
  8. Implement the abstract methods of the ContentManagerBase class in the following way:
    public override IQueryable<TItem> GetItems<TItem>()
    {
        if (typeof(ProductItem).IsAssignableFrom(typeof(TItem)))
        {
            return this.GetProducts() as IQueryable<TItem>;
        }
     
        if (typeof(TItem) == typeof(UrlData) || typeof(TItem) == typeof(ProductItemUrlData))
        {
            return this.GetUrls<ProductItemUrlData>() as IQueryable<TItem>;
        }
     
        if (typeof(TItem) == typeof(Comment))
        {
            return this.GetComments() as IQueryable<TItem>;
        }
     
        throw new NotSupportedException();
    }
     
    protected override GetDefaultProvider DefaultProviderDelegate
    {
        get
        {
            return () => Config.Get<ProductsConfig>().DefaultProvider;
        }
    }
     
    public override string ModuleName
    {
        get
        {
            return ProductsModule.ModuleName;
        }
    }
     
    protected override ConfigElementDictionary<string, DataProviderSettings> ProvidersSettings
    {
        get
        {
            return Config.Get<ProductsConfig>().Providers;
        }
    }
    public LanguageData CreateLanguageData()
    {
        return this.Provider.CreateLanguageData();
    }
     
    public LanguageData CreateLanguageData(Guid id)
    {
        return this.Provider.CreateLanguageData(id);
    }
     
    public LanguageData GetLanguageData(Guid id)
    {
        return this.Provider.GetLanguageData(id);
    }

    NOTE: You will implement the ModuleName constant in the module class later in this tutorial. For more information, see Custom Products module: Implement the module class.

Back To Top

Next: Custom Products module: Define the permissions