Enabling continuous integration for custom classes

The Kentico 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 Kentico 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. Expand the Type information region.

4. 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.

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

5. (Optional) Set the SerializationSettings property of the TYPEINFO object. Use a nested initializer to configure the SerializationSettings properties.
6. 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 Kentico 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 Kentico web application (as a console application by default). Module classes defined directly within the Kentico web project (in the App_Code folder on web site projects or under the CMSApp project on web application installations) 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 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 Kentico web project, use the following process to move the code to a separate assembly:

1. Create a new Class Library project (assembly) in the Kentico solution.

2. Add references to the required Kentico libraries (DLLs) for the module project:

   • Right-click the project and select Add -> Reference.

   • Select the Browse tab of the Reference manager dialog, click Browse and navigate to the Lib folder of your Kentico web project.

   • Add references to the following libraries (and any others that you use in the module’s code):

     • CMS.Base.dll
     • CMS.Core.dll
     • CMS.DataEngine.dll
     • CMS.Helpers.dll

3. Add a reference from the Kentico web project (CMSApp or CMS) to the custom module project.

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

5. Add the AssemblyDiscoverable assembly attribute:

using CMS;

[assembly:AssemblyDiscoverable]

6. Move all of the module’s code files (Info and InfoProvider classes, etc.) into the new project.
7. Save all changes.
8. Build the Kentico solution (or only the module project on web site installations).

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 Kentico 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")
    }
}