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: Create the base data provider class

After you Custom Products module: Create the data persistent class, you create the base data provider class.

Sitefinity CMS modules are based on the provider pattern. They use data providers for their data access layer. A good practice, when creating a data provider, is to create a base abstract class that provides a common implementation for the provider. Then use the base class to implement concrete data providers for the different data stores. This spares you the writing of the common part of the code for each of the concrete implementations. Even if you intend to have only one data provider in your module, consider using this base provider class.

To create the abstract base class for the data provider, perform the following:

  1. In Visual Studio, expand the ProductsModule project, open the context menu of the Data folder and click Add » Class.
  2. Name the class file ProductsDataProvider.cs and click Add.
  3. Open the file ProductsDataProvider.cs and add the following using statements:
  4. using ProductCatalogSample.Model;
    using Telerik.Sitefinity.Configuration;
    using Telerik.Sitefinity.Data.Linq.Dynamic;
    using Telerik.Sitefinity.GenericContent.Model;
    using Telerik.Sitefinity.Model;
    using Telerik.Sitefinity.Modules.GenericContent;
    using Telerik.Sitefinity.Security;
    using Telerik.Sitefinity.Security.Configuration;
    using Telerik.Sitefinity.Security.Model;
    using System.Collections.Generic;
    using Telerik.Sitefinity.Data;
    using Telerik.Sitefinity.Lifecycle;
    using Telerik.Sitefinity.Data.Linq;
  5. Make the ProductsDataProvider class inherit the ContentDataProviderBase class and the ILanguageDataProvider and IOpenAccessDataProviderinterfaces:
    public abstract class ProductsDataProvider : ContentDataProviderBase, ILanguageDataProvider, IOpenAccessDataProvider
    {
    }
  6. Implement the ContentDataProviderBase class.

    To implement the class, you must have the following members in the ProductsDataProvider class:

    • RootKey - in this property you store an identifier for the provider.
    • GetParentTypeFor - this method is used for modules with parent-child relationships, such as Lists and List Items, and Blogs and Blog Posts. If the module does not have such relationship, you must return null.
    • GetUrlTypeFor - in this method, you return the UrlData implementation created for the persistent class.
    • GetKnownTypes - in this method you return a list of types that your provider handles.
    • GetItemsByTaxon - this method allows you to retrieve the ProductItem objects by tag or category using the Sitefinity CMS taxonomy system.

    Following is the code for the implementation of these members:

    public override IEnumerable GetItemsByTaxon(Guid taxonId, bool isSingleTaxon, string propertyName, Type itemType, string filterExpression, string orderExpression, int skip, int take, ref int? totalCount)
    {
        if (itemType == typeof(ProductItem))
        {
            this.CurrentTaxonomyProperty = propertyName;
     
            IQueryable<ProductItem> query = this.GetProducts();
            if (!String.IsNullOrWhiteSpace(filterExpression))
                query = query.Where(filterExpression);
            if (!String.IsNullOrWhiteSpace(orderExpression))
                query = query.OrderBy(orderExpression);
            if (isSingleTaxon)
            {
                var query0 = from i in query
                                where i.GetValue<Guid>(this.CurrentTaxonomyProperty) == taxonId
                                select i;
     
                query = query0;
            }
            else
            {
     
                var query1 = from i in query
                                where (i.GetValue<IList<Guid>>(this.CurrentTaxonomyProperty)).Any(t => t == taxonId)
                                select i;
                query = query1;
            }
     
            if (totalCount.HasValue)
            {
                totalCount = query.Count();
            }
     
            if (skip > 0)
                query = query.Skip(skip);
            if (take > 0)
                query = query.Take(take);
            return query;
        }
     
        throw GetInvalidItemTypeException(itemType, this.GetKnownTypes());
    }
     
    public override Type GetParentTypeFor(Type contentType)
    {
        return null;
    }
     
    public override Type GetUrlTypeFor(Type itemType)
    {
        if (itemType == typeof(ProductItem))
        {
            return typeof(ProductItemUrlData);
        }
     
        throw GetInvalidItemTypeException(itemType, this.GetKnownTypes());
    }
     
    private static Type[] knownTypes;
     
    public override Type[] GetKnownTypes()
    {
        if (knownTypes == null)
        {
            knownTypes = new Type[]
            {
                typeof(ProductItem)
            };
        }
     
        return knownTypes;
    }
     
    public override string RootKey
    {
        get { return "ProductsDataProvider"; }
    }
  7. Create abstract methods and implement the following operations:
    • Create product
    • Get product
    • Get products
    • Delete products
    • Create language data
    • Get language data

    Following are the definitions for the methods:

    [MethodPermission(ProductsConstants.Security.PermissionSetName, ProductsConstants.Security.Create)]
    public abstract ProductItem CreateProduct();
      
    [MethodPermission(ProductsConstants.Security.PermissionSetName, ProductsConstants.Security.Create)]
    public abstract ProductItem CreateProduct(Guid id);
      
    [ValuePermission(ProductsConstants.Security.PermissionSetName, ProductsConstants.Security.View)]
    public abstract ProductItem GetProduct(Guid id);
      
    [EnumeratorPermission(ProductsConstants.Security.PermissionSetName, ProductsConstants.Security.View)]
    public abstract IQueryable<ProductItem> GetProducts();
      
    [ParameterPermission("product", ProductsConstants.Security.PermissionSetName, ProductsConstants.Security.Delete)]
    public abstract void DeleteProduct(ProductItem product);
      
    public Telerik.Sitefinity.Lifecycle.LanguageData CreateLanguageData()
    {
        return this.CreateLanguageData(Guid.NewGuid());
    }
     
    public Telerik.Sitefinity.Lifecycle.LanguageData CreateLanguageData(Guid id)
    {
        var languageData = new LanguageData(this.ApplicationName, id);
        ((IDataItem)languageData).Provider = this;
     
        if (id != Guid.Empty)
        {
            this.GetContext().Add(languageData);
        }
        return languageData;
    }
     
    public Telerik.Sitefinity.Lifecycle.LanguageData GetLanguageData(Guid id)
    {
        if (id == Guid.Empty)
            throw new ArgumentException("Argument 'id' cannot be empty GUID.");
     
        var languageData = this.GetContext().GetItemById<LanguageData>(id.ToString());
        ((IDataItem)languageData).Provider = this;
        return languageData;
    }
     
    public IQueryable<Telerik.Sitefinity.Lifecycle.LanguageData> GetLanguageData()
    {
        var appName = this.ApplicationName;
        return SitefinityQuery.Get<LanguageData>(this).Where(c => c.ApplicationName == appName);
    }

    In the code above, you mark the methods with permission attributes to specify the permissions for the respective method, when Sitefinity CMS invokes it.

  8. Override the respective methods of the ContentDataProviderBase class and call the abstract methods from them:
    public override object CreateItem(Type itemType, Guid id)
    {
        if (itemType == null)
        {
            throw new ArgumentNullException("itemType");
        }
     
        if (itemType == typeof(ProductItem))
        {
            return this.CreateProduct(id);
        }
     
        throw GetInvalidItemTypeException(itemType, this.GetKnownTypes());
    }
     
    public override object GetItem(Type itemType, Guid id)
    {
        if (itemType == typeof(Comment))
        {
            return this.GetComment(id);
        }
     
        if (itemType == typeof(ProductItem) || itemType == null)
        {
            return this.GetProduct(id);
        }
     
        return base.GetItem(itemType, id);
    }
     
    public override object GetItemOrDefault(Type itemType, Guid id)
    {
        if (itemType == typeof(Comment))
        {
            return this.GetComments().Where(c => c.Id == id).FirstOrDefault();
        }
     
        if (itemType == typeof(ProductItem))
        {
            return this.GetProducts().Where(n => n.Id == id).FirstOrDefault();
        }
     
        return base.GetItemOrDefault(itemType, id);
    }
     
    public override IEnumerable GetItems(Type itemType, string filterExpression, string orderExpression, int skip, int take, ref int? totalCount)
    {
        if (itemType == null)
        {
            throw new ArgumentNullException("itemType");
        }
     
        if (itemType == typeof(Comment))
        {
            return SetExpressions(this.GetComments(), filterExpression, orderExpression, skip, take, ref totalCount);
        }
     
        if (itemType == typeof(ProductItem))
        {
            return SetExpressions(this.GetProducts(), filterExpression, orderExpression, skip, take, ref totalCount);
        }
     
        throw GetInvalidItemTypeException(itemType, this.GetKnownTypes());
    }
     
    public override void DeleteItem(object item)
    {
        if (item == null)
        {
            throw new ArgumentNullException("item");
        }
     
        var itemType = item.GetType();
        this.providerDecorator.DeletePermissions(item);
     
        if (itemType == typeof(Comment))
        {
            this.Delete((Comment)item);
            return;
        }
     
        if (itemType == typeof(ProductItem))
        {
            this.DeleteProduct((ProductItem)item);
            return;
        }
     
        throw GetInvalidItemTypeException(item.GetType(), this.GetKnownTypes());
    }

    In the code above, when overriding the methods, you must check whether the item type is Comment.

  9. Override the CommitTransaction method and mark it with the TransactionPermission attribute in the following way:

    [TransactionPermission(typeof(ProductItem), ProductsConstants.Security.PermissionSetName, SecurityConstants.TransactionActionType.Updated, ProductsConstants.Security.Modify)]
    public override void CommitTransaction()
    {
        base.CommitTransaction();
    }
  10. Implement the IOpenAccessDataProvider:
    public Telerik.Sitefinity.Data.OpenAccessProviderContext Context
            {
                get;
                set;
            }
     
            public Telerik.OpenAccess.Metadata.MetadataSource GetMetaDataSource(IDatabaseMappingContext context)
            {
                return new ProductsFluentMetadataSource(context);
            }

Back To Top

Next: Custom Products module: Implement the OpenAccess data provider