Implementing the module class

The module class wraps the entire functionality created for the module. To create the module class, you must perform the following:

1. From the context menu of the project ProductsModule, click Add » Class.
2. Name the class file ProductsModule.cs and click Add.
3. Open the file ProductsModule.cs.

4. Add the following using statements:

   using ProductsModule.Configuration;

   using ProductsModule.Data;

   using ProductsModule.Model;

   using ProductsModule.Web.Services;

   using ProductsModule.Web.UI;

   using ProductsModule.Web.UI.Public;

   using Telerik.Sitefinity.Abstractions;

   using Telerik.Sitefinity.Abstractions.VirtualPath;

   using Telerik.Sitefinity.Abstractions.VirtualPath.Configuration;

   using Telerik.Sitefinity.Configuration;

   using Telerik.Sitefinity.Data;

   using Telerik.Sitefinity.Data.ContentLinks;

   using Telerik.Sitefinity.Localization;

   using Telerik.Sitefinity.Modules.ControlTemplates;

   using Telerik.Sitefinity.Modules.GenericContent;

   using Telerik.Sitefinity.Modules.Pages;

   using Telerik.Sitefinity.Modules.Pages.Configuration;

   using Telerik.Sitefinity.Security;

   using Telerik.Sitefinity.Security.Configuration;

   using Telerik.Sitefinity.Security.Model;

   using Telerik.Sitefinity.Services;

   using Telerik.Sitefinity.Taxonomies.Model;

   using Telerik.Sitefinity.Utilities.TypeConverters;

   using Telerik.Sitefinity.Web.UI.ContentUI;

   using Telerik.Sitefinity.Workflow.Configuration;

5. Make the ProductsModule class inherit the ContentModuleBase class:

   public class ProductsModule : ContentModuleBase

   {

   }

6. Define the following constants, static fields and properties:

   private static readonly string WorkflowEmbeddedPath = "ProductsModule.ProductsWorkflow.xamlx";

   private static readonly Type[] managerTypes = new Type[] { typeof(ProductsManager) };

    

   public static readonly Guid ColorsTaxonomyId = new Guid("47FC0316-0F9B-4D6D-A606-6CDC1977E10D");

   public static readonly string ProductsVirtualPath = "~/SFProducts/";

    

   public static readonly string WorkflowRelativeUrl = "~/Workflows/Products.xamlx";

   public static readonly Guid ProductsPageGroupId = new Guid("F0EB1F97-6E95-455C-B349-86F4A25C75EB");

   public static readonly Guid HomePageId = new Guid("21848245-6CB3-41F0-8A87-487B459914EB");

   public static readonly Guid CommentsPageId = new Guid("BB493061-3BF7-4920-AACA-44A35DF5742C");

   public static readonly string ResourceClassId = typeof(ProductsResources).Name;

    

   public const string ModuleName = "Products";

   public const string ProductsViewConfigKey = "ProductsView";

   public const string PublicProductsViewConfigKey = "PublicProductsView";

    

   public override Type[] Managers

   {

       get { return managerTypes; }

   }

    

   public override Guid LandingPageId

   {

       get

       {

           return ProductsModule.HomePageId;

       }

   }

7. Override the Initialize method of the ContentModuleBase class.

   In it you must register the configuration class for the module and the backend service. Following is the code for the method.

   public override void Initialize(ModuleSettings settings)

   {

       base.Initialize(settings);

    

       Config.RegisterSection<ProductsConfig>();

       Res.RegisterResource<ProductsResources>();

       ObjectFactory.RegisterWebService(typeof(ProductsBackendService), "Sitefinity/Services/Content/Products.svc");

    

       //register templatable controls

       ControlTemplates.RegisterTemplatableControl(typeof(MasterListView), typeof(ProductItem));

       ControlTemplates.RegisterTemplatableControl(typeof(ProductDetailsView), typeof(ProductItem));

    

       //register the assembly with the TypeResolutionService

       TypeResolutionService.RegisterAssembly(typeof(ProductsModule).Assembly.GetName());

   }

8. Override the Install method of the ContentModuleBase class.

   The method installs the module in Sitefinity system.

   public override void Install(SiteInitializer initializer)

   {

       base.Install(initializer);

    

       IModule productsModule;

       SystemManager.ApplicationModules.TryGetValue(ProductsModule.ModuleName, out productsModule);

       string resourceAssembly = this.GetType().Assembly.FullName;

       string customTemplatesArea = "Products module SDK sample";

       string friendlyWidgetName = "Products module sample widget";

    

       initializer.RegisterControlTemplate(MasterListView.titlesOnlyLayoutTemplateName, typeof(MasterListView).FullName, ProductsDefinitions.FrontendTitlesOnlyListViewName, null, customTemplatesArea, Presentation.AspNetTemplate, friendlyControlName: friendlyWidgetName);

       initializer.RegisterControlTemplate(MasterListView.titlesDatesLayoutTemplateName, typeof(MasterListView).FullName, ProductsDefinitions.FrontendTitlesDatesListViewName, null, customTemplatesArea, Presentation.AspNetTemplate, friendlyControlName: friendlyWidgetName);

       initializer.RegisterControlTemplate(MasterListView.titlesDatesSummariesLayoutTemplateName, typeof(MasterListView).FullName, ProductsDefinitions.FrontendTitlesDatesSummariesListViewName, null, customTemplatesArea, Presentation.AspNetTemplate, friendlyControlName: friendlyWidgetName);

       initializer.RegisterControlTemplate(MasterListView.titlesDatesContentsLayoutTemplateName, typeof(MasterListView).FullName, ProductsDefinitions.FrontendTitlesDatesContentsListViewName, null, customTemplatesArea, Presentation.AspNetTemplate, friendlyControlName: friendlyWidgetName);

       initializer.RegisterControlTemplate(ProductDetailsView.layoutTemplateName, typeof(ProductDetailsView).FullName, ProductsDefinitions.FrontendFullProductItemDetailViewName, null, customTemplatesArea, Presentation.AspNetTemplate, resourceAssembly, friendlyWidgetName);

    

       this.InstallCustomPermissions(initializer);

       this.InstallCustomWorkflow(initializer);

       this.InstallCustomVirtualPaths(initializer);

       this.InstallCustomTaxonomies(initializer);

   }

    

   private void InstallCustomVirtualPaths(SiteInitializer initializer)

   {

       var virtualPathConfig = initializer.Context.GetConfig<VirtualPathSettingsConfig>();

       ConfigManager.Executed += new EventHandler<ExecutedEventArgs>(ConfigManager_Executed);

       var productsModuleVirtualPathConfig = new VirtualPathElement(virtualPathConfig.VirtualPaths)

       {

           VirtualPath = ProductsModule.ProductsVirtualPath + "*",

           ResolverName = "EmbeddedResourceResolver",

           ResourceLocation = "ProductsModule"

       };

       if (!virtualPathConfig.VirtualPaths.ContainsKey(ProductsModule.ProductsVirtualPath + "*"))

           virtualPathConfig.VirtualPaths.Add(productsModuleVirtualPathConfig);

   }

    

   private void ConfigManager_Executed(object sender, Telerik.Sitefinity.Data.ExecutedEventArgs args)

   {

       if (args.CommandName == "SaveSection")

       {

           var section = args.CommandArguments as VirtualPathSettingsConfig;

           if (section != null)

           {

               // Reset the VirtualPathManager whenever we save the VirtualPathConfig section.

               // This is needed so that our prefixes for the widget templates in the module assembly are taken into account.

               VirtualPathManager.Reset();

           }

       }

   }

    

   private void InstallCustomWorkflow(SiteInitializer initializer)

   {

       var workflowConfig = initializer.Context.GetConfig<WorkflowConfig>();

       if (!workflowConfig.Workflows.ContainsKey(typeof(ProductItem).FullName))

       {

           workflowConfig.Workflows.Add(

           new WorkflowElement(workflowConfig.Workflows)

           {

               ContentType = typeof(ProductItem).FullName,

               ServiceUrl = WorkflowRelativeUrl,

               Title = "ModuleTitle",

               ResourceClassId = typeof(ProductsResources).Name

           });

           initializer.InstallEmbeddedVirtualPath(WorkflowRelativeUrl, WorkflowEmbeddedPath, typeof(ProductsModule).Assembly);

       }

   }

    

   private void InstallCustomPermissions(SiteInitializer initializer)

   {

       SecurityConfig securityConfig = initializer.Context.GetConfig<SecurityConfig>();

       ConfigElementDictionary<string, Telerik.Sitefinity.Security.Configuration.Permission> permissionSetConfig = securityConfig.Permissions;

       ConfigElementDictionary<string, CustomPermissionsDisplaySettingsConfig> CustomPermissionsDisplaySettings = securityConfig.CustomPermissionsDisplaySettings;

    

       //Add the set

       if (!permissionSetConfig.ContainsKey(ProductsConstants.Security.PermissionSetName))

       {

           var productsPermissionSet = new Telerik.Sitefinity.Security.Configuration.Permission(permissionSetConfig)

           {

               Name = ProductsConstants.Security.PermissionSetName,

               Title = "ProductsPermissions",

               Description = "ProductsPermissionsDescription",

               ResourceClassId = typeof(ProductsResources).Name

           };

           permissionSetConfig.Add(productsPermissionSet);

    

           productsPermissionSet.Actions.Add(new SecurityAction(productsPermissionSet.Actions)

           {

               Name = ProductsConstants.Security.View,

               Type = SecurityActionTypes.View,

               Title = "ViewProducts",

               Description = "ViewProductsDescription",

               ResourceClassId = typeof(ProductsResources).Name

           });

           productsPermissionSet.Actions.Add(new SecurityAction(productsPermissionSet.Actions)

           {

               Name = ProductsConstants.Security.Create,

               Type = SecurityActionTypes.Create,

               Title = "CreateProducts",

               Description = "CreateProductsDescription",

               ResourceClassId = typeof(ProductsResources).Name

           });

           productsPermissionSet.Actions.Add(new SecurityAction(productsPermissionSet.Actions)

           {

               Name = ProductsConstants.Security.Modify,

               Type = SecurityActionTypes.Modify,

               Title = "ModifyProducts",

               Description = "ModifyProductsDescription",

               ResourceClassId = typeof(ProductsResources).Name

           });

           productsPermissionSet.Actions.Add(new SecurityAction(productsPermissionSet.Actions)

           {

               Name = ProductsConstants.Security.Delete,

               Type = SecurityActionTypes.Delete,

               Title = "DeleteProducts",

               Description = "DeleteProductsDescription",

               ResourceClassId = typeof(ProductsResources).Name

           });

           productsPermissionSet.Actions.Add(new SecurityAction(productsPermissionSet.Actions)

           {

               Name = ProductsConstants.Security.ChangeOwner,

               Type = SecurityActionTypes.ChangeOwner,

               Title = "ChangeProductsOwner",

               Description = "ChangeProductsOwnerDescription",

               ResourceClassId = typeof(ProductsResources).Name

           });

           productsPermissionSet.Actions.Add(new SecurityAction(productsPermissionSet.Actions)

           {

               Name = ProductsConstants.Security.ChangePermissions,

               Type = SecurityActionTypes.ChangePermissions,

               Title = "ChangeProductsPermissions",

               Description = "ChangeProductsPermissionsDescription",

               ResourceClassId = typeof(ProductsResources).Name

           });

       }

    

       //Custom UI views

       if (!CustomPermissionsDisplaySettings.ContainsKey(ProductsConstants.Security.PermissionSetName))

       {

           var productsCustomSet = new CustomPermissionsDisplaySettingsConfig(CustomPermissionsDisplaySettings)

           {

               SetName = ProductsConstants.Security.PermissionSetName

           };

           CustomPermissionsDisplaySettings.Add(productsCustomSet);

    

           var productsCustomActions = new SecuredObjectCustomPermissionSet(productsCustomSet.SecuredObjectCustomPermissionSets) { TypeName = typeof(ProductItem).FullName };

           productsCustomSet.SecuredObjectCustomPermissionSets.Add(productsCustomActions);

    

           var blogCreateAction = new CustomSecurityAction(productsCustomActions.CustomSecurityActions)

           {

               Name = ProductsConstants.Security.Create,

               ShowActionInList = false,

               Title = string.Empty,

               ResourceClassId = string.Empty

           };

           productsCustomActions.CustomSecurityActions.Add(blogCreateAction);

    

           var blogModifyAction = new CustomSecurityAction(productsCustomActions.CustomSecurityActions)

           {

               Name = ProductsConstants.Security.Modify,

               ShowActionInList = true,

               Title = "ModifyThisProduct",

               ResourceClassId = typeof(ProductsResources).Name

           };

           productsCustomActions.CustomSecurityActions.Add(blogModifyAction);

    

           var blogViewAction = new CustomSecurityAction(productsCustomActions.CustomSecurityActions)

           {

               Name = ProductsConstants.Security.View,

               ShowActionInList = true,

               Title = "ViewThisProduct",

               ResourceClassId = typeof(ProductsResources).Name

           };

           productsCustomActions.CustomSecurityActions.Add(blogViewAction);

    

           var blogDeleteAction = new CustomSecurityAction(productsCustomActions.CustomSecurityActions)

           {

               Name = ProductsConstants.Security.Delete,

               ShowActionInList = true,

               Title = "DeleteThisProduct",

               ResourceClassId = typeof(ProductsResources).Name

           };

           productsCustomActions.CustomSecurityActions.Add(blogDeleteAction);

    

           var blogChangeOwnerAction = new CustomSecurityAction(productsCustomActions.CustomSecurityActions)

           {

               Name = ProductsConstants.Security.ChangeOwner,

               ShowActionInList = true,

               Title = "ChangeOwnerOfThisProduct",

               ResourceClassId = typeof(ProductsResources).Name

           };

           productsCustomActions.CustomSecurityActions.Add(blogChangeOwnerAction);

    

           var blogChangePermissionsAction = new CustomSecurityAction(productsCustomActions.CustomSecurityActions)

           {

               Name = ProductsConstants.Security.ChangePermissions,

               ShowActionInList = true,

               Title = "ChangePermissionsOfThisProduct",

               ResourceClassId = typeof(ProductsResources).Name

           };

           productsCustomActions.CustomSecurityActions.Add(blogChangePermissionsAction);

       }

   }

    

   protected void InstallCustomTaxonomies(SiteInitializer initializer)

   {

       //installs the default Tags and Category taxonomies

       this.InstallTaxonomy(initializer, typeof(ProductItem));

    

       var metaMan = initializer.Context.MetadataManager;

       var taxMan = initializer.TaxonomyManager;

    

       var flatTaxonomy = this.CreateTaxonomy<FlatTaxonomy>(initializer, "Colors", ColorsTaxonomyId, "Color");

    

       var taxon1 = initializer.TaxonomyManager.CreateTaxon<FlatTaxon>();

       taxon1.Title = "Red";

       taxon1.Name = "Red";

       var taxon2 = initializer.TaxonomyManager.CreateTaxon<FlatTaxon>();

       taxon2.Title = "Blue";

       taxon2.Name = "Blue";

       flatTaxonomy.Taxa.Add(taxon1);

       flatTaxonomy.Taxa.Add(taxon2);

    

       var type = metaMan.GetMetaType(typeof(ProductItem));

       if (type == null)

       {

           type = metaMan.CreateMetaType(typeof(ProductItem));

       }

    

       if (!type.Fields.ToList().Any(fld => fld.FieldName == "Colors"))

       {

           var field = metaMan.CreateMetafield("Colors");

           field.TaxonomyProvider = taxMan.Provider.Name;

           field.TaxonomyId = ColorsTaxonomyId;

           field.IsSingleTaxon = false;

           type.Fields.Add(field);

       }

    

       if (!type.Fields.ToList().Any(fld => fld.FieldName == "ProductImage"))

       {

           type.Fields.Add(ContentLinksExtensions.CreateContentLinkField("ProductImage", "OpenAccessDataProvider", metaMan, RelationshipType.OneToOne));

       }

   }

    

   private TTaxonomy CreateTaxonomy<TTaxonomy>(SiteInitializer initializer, string taxonomyName, Guid taxonomyId, string taxonName) where TTaxonomy : class, ITaxonomy

   {

       var taxMan = initializer.TaxonomyManager;

       var taxonomy = taxMan.GetTaxonomies<TTaxonomy>().FirstOrDefault(t => t.Name == taxonomyName);

       if (taxonomy == null)

       {

           taxonomy = taxMan.CreateTaxonomy<TTaxonomy>(taxonomyId);

           taxonomy.Name = taxonomyName;

           taxonomy.Title = taxonomyName;

           taxonomy.TaxonName = taxonName;

           ((ISecuredObject)taxonomy).CanInheritPermissions = true;

           ((ISecuredObject)taxonomy).InheritsPermissions = true;

           ((ISecuredObject)taxonomy).SupportedPermissionSets = new string[] { SecurityConstants.Sets.Taxonomies.SetName };

       }

       return taxonomy;

   }

   In the Install method you register custom permissions, workflows, virtual paths and taxonomies.

   NOTE: The workflow file used here, can be found in the ProductsCatalogSample project in the SDK samples.

9. Implement the abstract members of the ContentModuleBase class in the following way:

   protected override void InstallPages(SiteInitializer initializer)

   {

       var pageManager = initializer.PageManager;

       var moduleNode = pageManager.GetPageNode(SiteInitializer.ModulesNodeId);

       var id = ProductsPageGroupId;

       var productsNode = pageManager.GetPageNodes().Where(t => t.Id == id).SingleOrDefault();

       if (productsNode == null)

       {

           productsNode = initializer.CreatePageNode(ProductsPageGroupId, moduleNode, Telerik.Sitefinity.Pages.Model.NodeType.Group);

           productsNode.Name = "Products";

           productsNode.ShowInNavigation = true;

           productsNode.Attributes["ModuleName"] = ProductsModule.ModuleName;

           Res.SetLstring(productsNode.Title, ResourceClassId, "PageGroupNodeTitle");

           Res.SetLstring(productsNode.UrlName, ResourceClassId, "PageGroupNodeTitle");

           Res.SetLstring(productsNode.Description, ResourceClassId, "PageGroupNodeDescription");

       }

    

       id = this.LandingPageId;

       var landingPage =

           pageManager

           .GetPageNodes()

           .SingleOrDefault(p => p.Id == id);

       if (landingPage == null)

       {

           var pageInfo = new PageDataElement()

           {

               PageId = this.LandingPageId,

               Name = "Products",

               MenuName = "ProductsLandingPageTitle",

               UrlName = "ProductsLandingPageUrlName",

               Description = "ProductsLandingPageDescription",

               HtmlTitle = "ProductsLandingPageHtmlTitle",

               ResourceClassId = ResourceClassId,

               IncludeScriptManager = true,

               ShowInNavigation = false,

               EnableViewState = false,

               TemplateName = SiteInitializer.BackendTemplateName

           };

           pageInfo.Parameters["ModuleName"] = ProductsModule.ModuleName;

           var controlPanel = new BackendContentView()

           {

               ModuleName = ProductsModule.ModuleName,

               ControlDefinitionName = ProductsDefinitions.BackendDefinitionName

           };

           initializer.CreatePageFromConfiguration(pageInfo, productsNode, controlPanel);

       }

    

       // Products Comments

       id = ProductsModule.CommentsPageId;

       var commentsPage = initializer.PageManager.GetPageNodes().Where(p => p.Id == id).SingleOrDefault();

       if (commentsPage == null)

       {

           var pageInfo = new PageDataElement()

           {

               PageId = CommentsPageId,

               Name = "ProductComments",

               MenuName = "ProductCommentsPageTitle",

               UrlName = "ProductCommentsPageUrlName",

               Description = "ProductCommentsPageDescription",

               HtmlTitle = "ProductCommentsPageHtmlTitle",

               ResourceClassId = ResourceClassId,

               IncludeScriptManager = true,

               ShowInNavigation = false,

               EnableViewState = false,

               TemplateName = SiteInitializer.BackendTemplateName

           };

           pageInfo.Parameters["ModuleName"] = ProductsModule.ModuleName;

           var comments = new BackendContentView() { ControlDefinitionName = ProductsDefinitions.BackendCommentsDefinitionName };

           initializer.CreatePageFromConfiguration(pageInfo, productsNode, comments);

       }

   }

    

   protected override ConfigSection GetModuleConfig()

   {

       return Config.Get<ProductsConfig>();

   }

    

   protected override void InstallConfiguration(SiteInitializer initializer)

   {

       var config = initializer.Context.GetConfig<ToolboxesConfig>();

    

       var pageControls = config.Toolboxes["PageControls"];

    

       var section = pageControls

           .Sections

           .Where<ToolboxSection>(e => e.Name == ToolboxesConfig.ContentToolboxSectionName)

           .FirstOrDefault();

       var classId = typeof(ProductsResources).Name;

       if (section == null)

       {

           section = new ToolboxSection(pageControls.Sections)

           {

               Name = ToolboxesConfig.ContentToolboxSectionName,

               Title = "ContentToolboxSectionTitle",

               Description = "ContentToolboxSectionDescription",

               ResourceClassId = typeof(PageResources).Name

           };

           pageControls.Sections.Add(section);

       }

       if (!section.Tools.Any<ToolboxItem>(e => e.Name == "ProductsView"))

       {

           var tool = new ToolboxItem(section.Tools)

           {

               Name = "ProductsView",

               Title = "ProductsViewTitle",

               Description = "ProductsViewDescription",

               ResourceClassId = classId,

               CssClass = "sfProductsViewIcn",

               ControlType = typeof(ProductsView).AssemblyQualifiedName

           };

           section.Tools.Add(tool);

       }

   }

    

   public override void Upgrade(SiteInitializer initializer, Version upgradeFrom)

   {

   }

    

   protected override void InstallTaxonomies(SiteInitializer initializer)

   {

       return;

   }