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 data persistent class

After you Custom Products module: Prepare the project, you implement the data persistent class. A data persistent class is a class that is used for storage in the context of Sitefinity CMS. Such classes are also called model classes. Depending on the design, you can create more than one model class.

Because the Products module is a content-based module, the data persistent class must be derived from the Content class. To create your class:

  1. In Visual Studio, in the ProductsModule project, open the context menu of the Model folder and click Add » Class.
  2. Name the class file ProductItem.cs and click Add.
  3. Open the ProductItem.cs and add the following using statements:
    using System.Runtime.Serialization;
    using Telerik.OpenAccess;
    using Telerik.Sitefinity;
    using Telerik.Sitefinity.ContentViewAttributes;
    using Telerik.Sitefinity.GenericContent.Model;
    using Telerik.Sitefinity.Lifecycle;
    using Telerik.Sitefinity.Model;
    using Telerik.Sitefinity.Model.ContentLinks;
    using Telerik.Sitefinity.Security;
    using Telerik.Sitefinity.Security.Model;
    using Telerik.Sitefinity.Versioning.Serialization.Attributes;
    using Telerik.Sitefinity.Versioning.Serialization.Extensions;
    using Telerik.Sitefinity.Versioning.Serialization.Interfaces;
    using Telerik.Sitefinity.Workflow.Model.Tracking;
  4. Make the ProductItem class inherit the Content class and also to implement the IApprovalWorkflowItem, ISecuredObject, ILocatable, ISitefinityCustomTypeSerialization and ILifecycleDataItemGeneric interfaces:
    public class ProductItem : Content, IApprovalWorkflowItem, ISecuredObject, ILocatable, ISitefinityCustomTypeSerialization, ILifecycleDataItemGeneric
    {
    }

    In the code above, inheriting the Content base class enables you to use the following features in your Products module:

    • Workflows
    • Content lifecycle
  5. Define the Price, QuantityInStock, WhatIsInTheBox, and Content properties:
    private decimal price;
    private int quantityInStock;
    [Transient]
    private Lstring whatIsInTheBox;
    [Transient]
    private Lstring content;
      
    [DataMember]
    [FieldAlias("price")]
    public decimal Price
    {
        get
        {
            return this.price;
        }
      
        set
        {
            this.price = value;
        }
    }
      
    [DataMember]
    [FieldAlias("quantityInStock")]
    public int QuantityInStock
    {
        get
        {
            return this.quantityInStock;
        }
      
        set
        {
            this.quantityInStock = value;
        }
    }
      
    [DataMember]
    [MetadataMapping(true, false)]
    public virtual Lstring WhatIsInTheBox
    {
        get
        {
            if (this.whatIsInTheBox == null)
            {
                this.whatIsInTheBox = this.GetString("WhatIsInTheBox");
            }
      
            return this.whatIsInTheBox;
        }
      
        set
        {
            this.whatIsInTheBox = value;
            this.SetString("WhatIsInTheBox", this.whatIsInTheBox);
        }
    }
      
    [DataMember]
    [MetadataMapping(true, true)]
    [UserFriendlyDataType(UserFriendlyDataType.LongText)]
    [CommonProperty]
    [ScaffoldInfo(@"<sitefinity:HtmlField runat=""server"" DisplayMode=""Read"" Value='<%# Eval(""Content"")%>' />")]
    public Lstring Content
    {
        get
        {
            if (this.content == null)
            {
                this.content = this.GetString("Content");
            }
      
            return this.ApplyContentFilters(this.content);
        }
      
        set
        {
            this.content = value;
            this.SetString("Content", this.content);
        }
    }

    In the code above, the DataMember attribute allows the properties to be serialized for usage in a WCF service. The ScaffoldInfo attribute specifies that the value of the content property that is displayed in a specific markup element.

    The Content property is of type LString. This type is used for values that you want to localize.

  6. Create a class that implements the UrlData abstract class:
    1. Expand the ProductsModule project, open the context menu of the Model folder and click Add » Class.
    2. Name the class file ProductItemUrlData.cs and click Add.
    3. Open the file ProductItemUrlData.cs and add the following using statements:
      using Telerik.OpenAccess;
      using Telerik.Sitefinity.GenericContent.Model;
      using Telerik.Sitefinity.Model;
      using Telerik.Sitefinity.Versioning.Serialization.Attributes;
    4. Make the ProductItemUrlData class inherit the UrlData abstract class:
      public class ProductItemUrlData : UrlData
      {
      }
    5. Implement the UrlData abstract class in the following way:
      public ProductItemUrlData()
          : base()
      {
          this.Id = Guid.NewGuid();
      }
       
      private ProductItem parent;
       
      [FieldAlias("parent")]
      [NonSerializableProperty]
      public override IDataItem Parent
      {
          get
          {
              if (this.parent != null)
                  ((IDataItem)this.parent).Provider = ((IDataItem)this).Provider;
              return this.parent;
          }
          set
          {
              this.parent = (ProductItem)value;
          }
      }

      In the code above, the parent property returns the parent ProductItem of the instance.

    6. Mark the ProductItemUrlData class with the Persistent attribute:
      [Persistent]
      public class ProductItemUrlData : UrlData

      In the code above, the Persistent attribute allows the class to be persisted in the database.

    The implementation of the UrlData class associates your items with a URL.

  7. In the ProductItem class, implement the ILocatable interface. To do so, create the following members:
    [Depend]
    private ProviderTrackedList<ProductItemUrlData> urls;
        
    [NonSerializableProperty]
    public bool AutoGenerateUniqueUrl
    {
        get { return false; }
    }
        
    [FieldAlias("urls")]
    [NonSerializableProperty]
    public virtual IList<ProductItemUrlData> Urls
    {
        get
        {
            if (this.urls == null)
            {
                this.urls = new ProviderTrackedList<ProductItemUrlData>(this, "Urls");
            }
        
            this.urls.SetCollectionParent(this);
        
            return this.urls;
        }
    }
        
    [NonSerializableProperty]
    IEnumerable<UrlData> ILocatable.Urls
    {
        get
        {
            return this.Urls.Cast<UrlData>();
        }
    }
       
    void ILocatable.ClearUrls(bool excludeDefault = false)
    {
                this.urls.ClearUrls(excludeDefault);
    }
       
    void ILocatable.RemoveUrls(Func<UrlData, bool> predicate)
    {
            this.urls.RemoveUrls(predicate);
    }
  8. The ILocatable interface is responsible for associating each of your items with an URL.
    NOTE: The methods required by the ILocatable interface use the ProductItemUrlData class.
  9. Implement the ISecuredObject interface in the model class.
    You do this because the Products module uses permission. Use the following code for the required methods:
    private bool canInheritPermissions;
      
    [FieldAlias("canInheritPermissions")]
    [NonSerializableProperty]
    public bool CanInheritPermissions
    {
        get
        {
            return this.canInheritPermissions;
        }
      
        set
        {
            this.canInheritPermissions = value;
        }
    }
      
    private bool inheritsPermissions;
      
    [FieldAlias("inheritsPermissions")]
    [NonSerializableProperty]
    public bool InheritsPermissions
    {
        get
        {
            return this.inheritsPermissions;
        }
      
        set
        {
            this.inheritsPermissions = value;
        }
    }
    private ProviderTrackedList<Permission> permissions;
      
    [FieldAlias("permissions")]
    [NonSerializableProperty]
    public IList<Permission> Permissions
    {
        get
        {
            if (this.permissions == null)
            {
                this.permissions = new ProviderTrackedList<Permission>(this, "Permissions");
            }
      
            this.permissions.SetCollectionParent(this);
            return this.permissions;
        }
    }
      
    private IDictionary<string, string> permissionsetObjectTitleResKeys;
      
    [NonSerializableProperty]
    public virtual IDictionary<string, string> PermissionsetObjectTitleResKeys
    {
        get
        {
            return permissionsetObjectTitleResKeys;
        }
      
        set
        {
            permissionsetObjectTitleResKeys = value;
        }
    }
      
    private string[] supportedPermissionSets;
      
    [NonSerializableProperty]
    public string[] SupportedPermissionSets
    {
        get
        {
            return supportedPermissionSets;
        }
      
        set
        {
            supportedPermissionSets = value;
        }
    }
  10. Implement the IApprovalWorkflow interface.
    You do this because the Products module uses Approval workflow. Use the following code for the members required by the interface:
    [Transient]
    private Lstring approvalWorkflowState;
     
    [DataMember]
    [Database(DBType = "VARCHAR", DBSqlType = "NVARCHAR")]
    public virtual Lstring ApprovalWorkflowState
    {
        get
        {
            if (this.approvalWorkflowState == null)
            {
                this.approvalWorkflowState = this.GetString("ApprovalWorkflowState");
            }
     
            return this.approvalWorkflowState;
        }
     
        set
        {
            this.approvalWorkflowState = value;
            this.SetString("ApprovalWorkflowState", this.approvalWorkflowState);
        }
    }
     
    private ApprovalTrackingRecordMap approvalTrackingRecordMap;
     
    [FieldAlias("approvalTrackingRecordMap")]
    [NonSerializableProperty]
    public ApprovalTrackingRecordMap ApprovalTrackingRecordMap
    {
        get
        {
            return this.approvalTrackingRecordMap;
        }
     
        set
        {
            this.approvalTrackingRecordMap = value;
        }
    }
  11. Implement the ISitefinityCustomTypeSerialization interface:
    public void Serialize(object obj, out Dictionary<string, object> serializedObject)
    {
     
        var unfilteredObjects = obj.GetSerializationPropertyValueCollection();
        serializedObject = new Dictionary<string, object>(unfilteredObjects.Count);
     
        //Removing of ContentLink objects is necessary since we cannot handle deserialziation of this type
        //ContentLinks are persisted outside the ProductItem and deserialization causes side effects
        foreach (var item in unfilteredObjects)
        {
            if (!(item.Value is ContentLink))
            {
                serializedObject.Add(item.Key, item.Value);
            }
        }
     
        if (Urls.Count > 0)
        {
            var urls = obj.GetListSerializationItemsItems("Urls");
            serializedObject.Add("URLS", urls);
        }
    }
     
    public void Deserialize(ref object obj, Dictionary<string, object> serializedObject)
    {
        VersioningUtilities.SetSerializationPropertyValueCollection(ref obj, serializedObject);
     
        ((ProductItem)obj).Urls.Clear();
        if (serializedObject.ContainsKey("URLS"))
        {
            VersioningUtilities.SetListDeserializedItems(ref obj, "Urls", "Parent", this, serializedObject["URLS"]);
        }
    }
  12. Implement the ILifecycleDataItem interface:
    private TrackedList<string> publishedTranslations;
    private TrackedList<LanguageData> languageData;
     
    [Searchable(false)]
    [NonSerializableProperty]
    public virtual IList<string> PublishedTranslations
    {
        get
        {
            if (this.publishedTranslations == null)
                this.publishedTranslations = new TrackedList<string>();
            return this.publishedTranslations;
        }
    }
     
    [Searchable(false)]
    [NonSerializableProperty]
    public IList<LanguageData> LanguageData
    {
        get
        {
            if (this.languageData == null)
                this.languageData = new TrackedList<LanguageData>();
            return this.languageData;
        }
    }
  13. Create a constructor that sets default values to the ISecuredObject members:
    public ProductItem()
    {
        // set default values
        this.inheritsPermissions = true;
        this.canInheritPermissions = true;
        this.supportedPermissionSets = new string[] { ProductsConstants.Security.PermissionSetName, SecurityConstants.Sets.Comments.SetName };
    }
     
    static ProductItem()
    {
        // set default values
        permissionsetObjectTitleResKeys = new Dictionary<string, string>()
        {
            { ProductsConstants.Security.PermissionSetName, "NewsActionPermissionsListTitle" }
        };
    }
  14. Mark the ProductItem class with the DataContract, ManagerType, and Persistent attribute:
    [DataContract(Namespace = "http://sitefinity.com/samples/productcatalogue", Name = "ProductItem")]
    [ManagerType("ProductCatalogSample.Data.ProductsManager, ProductCatalogSample")]
    [Persistent(IdentityField = "contentId")]
    public class ProductItem : Content, IApprovalWorkflowItem, ISecuredObject, ILocatable, ISitefinityCustomTypeSerialization, ILifecycleDataItemGeneric

    In the code above, the Persistent attribute allows the class to be persisted in the database. You set the IdentityField property to contentId.

    The DataContract attribute allows the class to be serialized for usage with WCF services. The ManagerType attribute specifies the manager class that will use the persistent class. Its argument must contain the type of the manager and the name of the assembly that it is located in.

Back To Top

Next: Custom Products module: Create the base data provider class