Enabling continuous integration for custom classes

The Xperience continuous integration solution allows you to serialize the data of objects from the database into XML files and then use a source control system to synchronize the files between different instances. To enable continuous integration for the data of custom module classes, you need to set the appropriate type information when developing your classes. For more information about the basics of module and class development, see the example in Creating custom modules.

To configure continuous integration support for a custom module class:

1. Open the solution where you are developing the custom module (in Visual Studio).

2. Edit the Info class representing your module class.

   Important: To use continuous integration, the code of your custom class must be located in a separate assembly. See the Adding the class code into a separate assembly section for more information and instructions.

3. Set the ContinuousIntegrationSettings property in the initializer of the TYPEINFO object. Use a nested initializer to configure the properties of the ContinuousIntegrationSettings class:

   • Set the Enabled property to true.
   • (Optional) Set the other ContinuousIntegrationSettings properties according to the requirements of your class’s data.
   Copy

   
   
   
    // Enables continuous integration for the object type
    ContinuousIntegrationSettings =
    {
        Enabled = true
    },
   
   
    

4. (Optional) Set the SerializationSettings property of the TYPEINFO object. Use a nested initializer to configure the SerializationSettings properties.

5. Save the changes.

If continuous integration is enabled, the system now tracks all create, update and delete operations for objects of the given custom class, and serializes the data into XML files in the CIRepository folder.

To transfer all existing data of the class into your continuous integration repository, run complete serialization for all objects:

1. Disable running of scheduled tasks (using the Settings -> System -> Scheduled tasks enabled setting).
2. Open the Continuous integration application in the Xperience administration interface.
3. Click Serialize all objects.
4. Wait until the serialization process finishes and then re-enable scheduled tasks.

You can also use your custom object type’s name (the value of the OBJECT_TYPE constant) when filtering objects for continuous integration within the repository.config file. See Excluding objects from continuous integration to learn more.

Adding the class code into a separate assembly

When restoring data from the continuous integration repository to the database, the process runs outside of the Xperience web application (as a console application by default). Module classes defined directly within the Xperience administration project (CMSApp) cannot be detected by external utilities that are not web applications and are ignored by the continuous integration restore process.

To correctly use continuous integration with custom module classes, your class code files (Info, IInfoProvider and InfoProvider classes) must be defined within a separate assembly. The assembly must also be configured to allow the system to detect classes using the AssemblyDiscoverable assembly attribute.

If your module classes are located directly in the Xperience administration project, use the following process to move the code to a separate assembly:

1. Create a new Class Library project (assembly) in the solution (or reuse an existing custom project).

2. Add the Xperience API libraries to the module project:

   1. Right-click the solution in the Solution Explorer and select Manage NuGet Packages for Solution.
   2. Select the Kentico.Xperience.Libraries package.
   3. Install the package into the project (the version must match your live site (MVC) project’s Kentico.Xperience.AspNet.Mvc5 package and the exact hotfix version of your Xperience administration project).

3. Add a reference from the Xperience administration project (CMSApp) to the custom module project.

4. Edit the module project’s AssemblyInfo.cs file (in the Properties folder).

5. Add the AssemblyDiscoverable assembly attribute:

   Copy

   
   
   
    using CMS;
   
    [assembly:AssemblyDiscoverable]
   
   
    

6. Move all of the module’s code files (Info, IInfoProvider and InfoProvider classes, etc.) into the new project.

7. Save all changes.

8. Rebuild the solution.

Placing the class code into a discoverable custom assembly allows the continuous integration solution to work with the class when restoring data from the CIRepository folder.

Deleting classes that have continuous integration enabled

Use the following process if you ever need to delete a custom class with existing data and continuous integration enabled:

1. First delete the given class’s code files and rebuild the module project in Visual Studio (or remove the entire module project if it is no longer needed).
2. Delete the class in the Modules application in the Xperience administration interface.
3. Manually delete the folder representing the class’s data from your CIRepository folder (the system automatically removes the data from the database, but cannot clear the continuous integration data).

References

ContinuousIntegrationSettings

The ContinuousIntegrationSettings property of ObjectTypeInfo determines how classes work with the continuous integration solution.  

Assign an instance of the ContinuousIntegrationSettings class and set its properties:

ContinuousIntegrationSettings =
{
    Enabled = true,

    // Adds a field that the continuous integration solution serializes into a separate file (in addition to the BinaryColumn field)
    SeparatedFields = new List<SeparatedField>
    {
        new SeparatedField("SeparatedField")
        {
            FileName = "CustomFileName",
            FileExtension = ".txt"
        }
    }
}

SerializationSettings

The SerializationSettings property of ObjectTypeInfo determines how the system serializes class objects from the database into XML data. The serialization is used by the system’s continuous integration solution.

Assign an instance of the SerializationSettings class and set its properties:

SerializationSettings =
{
    // Adds two fields to the default collection of fields that are excluded from the serialized data
    ExcludedFieldNames = { "ClassField", "ClassSecondField" },

    // Ensures that the system processes "ClassXmlField" as nested XML in the serialized data
    StructuredFields = new IStructuredField[]
    {
        new StructuredField("ClassXmlField")
    }
}