GeneratedTasksMigrationCombo.java

package com.constellio.app.modules.tasks.migrations;

import static java.util.Arrays.asList;

import com.constellio.app.entities.modules.MigrationResourcesProvider;
import com.constellio.app.entities.schemasDisplay.SchemaTypesDisplayConfig;
import com.constellio.app.entities.schemasDisplay.enums.MetadataInputType;
import com.constellio.app.modules.rm.wrappers.structures.CommentFactory;
import com.constellio.app.modules.tasks.model.calculators.DecisionsTasksCalculator;
import com.constellio.app.modules.tasks.model.calculators.TaskFollowersCalculator;
import com.constellio.app.modules.tasks.model.calculators.TaskNextReminderOnCalculator;
import com.constellio.app.modules.tasks.model.calculators.TaskTokensCalculator;
import com.constellio.app.modules.tasks.model.calculators.WorkflowTaskSortCalculator;
import com.constellio.app.modules.tasks.model.validators.TaskStatusValidator;
import com.constellio.app.modules.tasks.model.validators.TaskValidator;
import com.constellio.app.modules.tasks.model.wrappers.TaskStatusType;
import com.constellio.app.modules.tasks.model.wrappers.WorkflowInstanceStatus;
import com.constellio.app.modules.tasks.model.wrappers.structures.TaskFollowerFactory;
import com.constellio.app.modules.tasks.model.wrappers.structures.TaskReminderFactory;
import com.constellio.app.services.factories.AppLayerFactory;
import com.constellio.app.services.schemasDisplay.SchemaTypesDisplayTransactionBuilder;
import com.constellio.app.services.schemasDisplay.SchemasDisplayManager;
import com.constellio.model.entities.schemas.MetadataValueType;
import com.constellio.model.entities.structures.MapStringListStringStructureFactory;
import com.constellio.model.entities.structures.MapStringStringStructureFactory;
import com.constellio.model.services.contents.ContentFactory;
import com.constellio.model.services.schemas.builders.MetadataBuilder;
import com.constellio.model.services.schemas.builders.MetadataSchemaBuilder;
import com.constellio.model.services.schemas.builders.MetadataSchemaTypeBuilder;
import com.constellio.model.services.schemas.builders.MetadataSchemaTypesBuilder;
import com.constellio.model.services.schemas.calculators.AllAuthorizationsCalculator;
import com.constellio.model.services.schemas.calculators.InheritedAuthorizationsCalculator;
import com.constellio.model.services.schemas.calculators.ParentPathCalculator;
import com.constellio.model.services.schemas.calculators.PathCalculator;
import com.constellio.model.services.schemas.calculators.PathPartsCalculator;
import com.constellio.model.services.schemas.calculators.PrincipalPathCalculator;
import com.constellio.model.services.schemas.calculators.TokensCalculator2;
import com.constellio.model.services.schemas.validators.ManualTokenValidator;
import com.constellio.model.services.schemas.validators.PercentageValidator;
import com.constellio.model.services.security.roles.RolesManager;

public final class GeneratedTasksMigrationCombo {
	String collection;

	AppLayerFactory appLayerFactory;

	MigrationResourcesProvider resourcesProvider;

	GeneratedTasksMigrationCombo(String collection, AppLayerFactory appLayerFactory,
			MigrationResourcesProvider resourcesProvider) {
		this.collection = collection;
		this.appLayerFactory = appLayerFactory;
		this.resourcesProvider = resourcesProvider;
	}

	public void applyGeneratedSchemaAlteration(MetadataSchemaTypesBuilder typesBuilder) {
		MetadataSchemaTypeBuilder collectionSchemaType = typesBuilder.getSchemaType("collection");
		MetadataSchemaBuilder collectionSchema = collectionSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder groupSchemaType = typesBuilder.getSchemaType("group");
		MetadataSchemaBuilder groupSchema = groupSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder userSchemaType = typesBuilder.getSchemaType("user");
		MetadataSchemaBuilder userSchema = userSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder emailToSendSchemaType = typesBuilder.getSchemaType("emailToSend");
		MetadataSchemaBuilder emailToSendSchema = emailToSendSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder eventSchemaType = typesBuilder.getSchemaType("event");
		MetadataSchemaBuilder eventSchema = eventSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder facetSchemaType = typesBuilder.getSchemaType("facet");
		MetadataSchemaBuilder facet_fieldSchema = facetSchemaType.getCustomSchema("field");
		MetadataSchemaBuilder facet_querySchema = facetSchemaType.getCustomSchema("query");
		MetadataSchemaBuilder facetSchema = facetSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder reportSchemaType = typesBuilder.getSchemaType("report");
		MetadataSchemaBuilder reportSchema = reportSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder savedSearchSchemaType = typesBuilder.getSchemaType("savedSearch");
		MetadataSchemaBuilder savedSearchSchema = savedSearchSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder taskSchemaType = typesBuilder.getSchemaType("task");
		MetadataSchemaBuilder task_approvalSchema = taskSchemaType.getCustomSchema("approval");
		MetadataSchemaBuilder taskSchema = taskSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder userDocumentSchemaType = typesBuilder.getSchemaType("userDocument");
		MetadataSchemaBuilder userDocumentSchema = userDocumentSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder ddvTaskStatusSchemaType = typesBuilder.createNewSchemaType("ddvTaskStatus").setSecurity(false);
		MetadataSchemaBuilder ddvTaskStatusSchema = ddvTaskStatusSchemaType.getDefaultSchema();
		ddvTaskStatusSchema.defineValidators().add(TaskStatusValidator.class);
		MetadataSchemaTypeBuilder ddvTaskTypeSchemaType = typesBuilder.createNewSchemaType("ddvTaskType").setSecurity(false);
		MetadataSchemaBuilder ddvTaskTypeSchema = ddvTaskTypeSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder userTaskSchemaType = typesBuilder.createNewSchemaType("userTask");
		MetadataSchemaBuilder userTaskSchema = userTaskSchemaType.getDefaultSchema();
		userTaskSchema.defineValidators().add(TaskValidator.class);
		MetadataSchemaTypeBuilder workflowSchemaType = typesBuilder.createNewSchemaType("workflow").setSecurity(false);
		MetadataSchemaBuilder workflowSchema = workflowSchemaType.getDefaultSchema();
		MetadataSchemaTypeBuilder workflowInstanceSchemaType = typesBuilder.createNewSchemaType("workflowInstance")
				.setSecurity(false);
		MetadataSchemaBuilder workflowInstanceSchema = workflowInstanceSchemaType.getDefaultSchema();
		MetadataBuilder ddvTaskStatus_allauthorizations = ddvTaskStatusSchema.get("allauthorizations");
		ddvTaskStatus_allauthorizations.setMultivalue(true);
		ddvTaskStatus_allauthorizations.setSystemReserved(true);
		ddvTaskStatus_allauthorizations.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_authorizations = ddvTaskStatusSchema.get("authorizations");
		ddvTaskStatus_authorizations.setMultivalue(true);
		ddvTaskStatus_authorizations.setSystemReserved(true);
		ddvTaskStatus_authorizations.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_code = ddvTaskStatusSchema.create("code").setType(MetadataValueType.STRING);
		ddvTaskStatus_code.setDefaultRequirement(true);
		ddvTaskStatus_code.setUndeletable(true);
		ddvTaskStatus_code.setSchemaAutocomplete(true);
		ddvTaskStatus_code.setSearchable(true);
		ddvTaskStatus_code.setUniqueValue(true);
		ddvTaskStatus_code.setUnmodifiable(true);
		MetadataBuilder ddvTaskStatus_comments = ddvTaskStatusSchema.create("comments").setType(MetadataValueType.ENUM);
		ddvTaskStatus_comments.setMultivalue(true);
		ddvTaskStatus_comments.defineStructureFactory(CommentFactory.class);
		MetadataBuilder ddvTaskStatus_createdBy = ddvTaskStatusSchema.get("createdBy");
		ddvTaskStatus_createdBy.setSystemReserved(true);
		ddvTaskStatus_createdBy.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_createdOn = ddvTaskStatusSchema.get("createdOn");
		ddvTaskStatus_createdOn.setSystemReserved(true);
		ddvTaskStatus_createdOn.setUndeletable(true);
		ddvTaskStatus_createdOn.setSortable(true);
		MetadataBuilder ddvTaskStatus_deleted = ddvTaskStatusSchema.get("deleted");
		ddvTaskStatus_deleted.setSystemReserved(true);
		ddvTaskStatus_deleted.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_denyTokens = ddvTaskStatusSchema.get("denyTokens");
		ddvTaskStatus_denyTokens.setMultivalue(true);
		ddvTaskStatus_denyTokens.setSystemReserved(true);
		ddvTaskStatus_denyTokens.setUndeletable(true);
		ddvTaskStatus_denyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder ddvTaskStatus_description = ddvTaskStatusSchema.create("description").setType(MetadataValueType.TEXT);
		ddvTaskStatus_description.setUndeletable(true);
		ddvTaskStatus_description.setSearchable(true);
		MetadataBuilder ddvTaskStatus_detachedauthorizations = ddvTaskStatusSchema.get("detachedauthorizations");
		ddvTaskStatus_detachedauthorizations.setSystemReserved(true);
		ddvTaskStatus_detachedauthorizations.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_errorOnPhysicalDeletion = ddvTaskStatusSchema.get("errorOnPhysicalDeletion");
		ddvTaskStatus_errorOnPhysicalDeletion.setSystemReserved(true);
		ddvTaskStatus_errorOnPhysicalDeletion.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_followers = ddvTaskStatusSchema.get("followers");
		ddvTaskStatus_followers.setMultivalue(true);
		ddvTaskStatus_followers.setSystemReserved(true);
		ddvTaskStatus_followers.setUndeletable(true);
		ddvTaskStatus_followers.setSearchable(true);
		MetadataBuilder ddvTaskStatus_id = ddvTaskStatusSchema.get("id");
		ddvTaskStatus_id.setDefaultRequirement(true);
		ddvTaskStatus_id.setSystemReserved(true);
		ddvTaskStatus_id.setUndeletable(true);
		ddvTaskStatus_id.setSearchable(true);
		ddvTaskStatus_id.setSortable(true);
		ddvTaskStatus_id.setUniqueValue(true);
		ddvTaskStatus_id.setUnmodifiable(true);
		MetadataBuilder ddvTaskStatus_inheritedauthorizations = ddvTaskStatusSchema.get("inheritedauthorizations");
		ddvTaskStatus_inheritedauthorizations.setMultivalue(true);
		ddvTaskStatus_inheritedauthorizations.setSystemReserved(true);
		ddvTaskStatus_inheritedauthorizations.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_legacyIdentifier = ddvTaskStatusSchema.get("legacyIdentifier");
		ddvTaskStatus_legacyIdentifier.setDefaultRequirement(true);
		ddvTaskStatus_legacyIdentifier.setSystemReserved(true);
		ddvTaskStatus_legacyIdentifier.setUndeletable(true);
		ddvTaskStatus_legacyIdentifier.setSearchable(true);
		ddvTaskStatus_legacyIdentifier.setUniqueValue(true);
		ddvTaskStatus_legacyIdentifier.setUnmodifiable(true);
		MetadataBuilder ddvTaskStatus_logicallyDeletedOn = ddvTaskStatusSchema.get("logicallyDeletedOn");
		ddvTaskStatus_logicallyDeletedOn.setSystemReserved(true);
		ddvTaskStatus_logicallyDeletedOn.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_manualTokens = ddvTaskStatusSchema.get("manualTokens");
		ddvTaskStatus_manualTokens.setMultivalue(true);
		ddvTaskStatus_manualTokens.setSystemReserved(true);
		ddvTaskStatus_manualTokens.setUndeletable(true);
		ddvTaskStatus_manualTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder ddvTaskStatus_markedForPreviewConversion = ddvTaskStatusSchema.get("markedForPreviewConversion");
		ddvTaskStatus_markedForPreviewConversion.setSystemReserved(true);
		ddvTaskStatus_markedForPreviewConversion.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_modifiedBy = ddvTaskStatusSchema.get("modifiedBy");
		ddvTaskStatus_modifiedBy.setSystemReserved(true);
		ddvTaskStatus_modifiedBy.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_modifiedOn = ddvTaskStatusSchema.get("modifiedOn");
		ddvTaskStatus_modifiedOn.setSystemReserved(true);
		ddvTaskStatus_modifiedOn.setUndeletable(true);
		ddvTaskStatus_modifiedOn.setSortable(true);
		MetadataBuilder ddvTaskStatus_parentpath = ddvTaskStatusSchema.get("parentpath");
		ddvTaskStatus_parentpath.setMultivalue(true);
		ddvTaskStatus_parentpath.setSystemReserved(true);
		ddvTaskStatus_parentpath.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_path = ddvTaskStatusSchema.get("path");
		ddvTaskStatus_path.setMultivalue(true);
		ddvTaskStatus_path.setSystemReserved(true);
		ddvTaskStatus_path.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_pathParts = ddvTaskStatusSchema.get("pathParts");
		ddvTaskStatus_pathParts.setMultivalue(true);
		ddvTaskStatus_pathParts.setSystemReserved(true);
		ddvTaskStatus_pathParts.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_principalpath = ddvTaskStatusSchema.get("principalpath");
		ddvTaskStatus_principalpath.setSystemReserved(true);
		ddvTaskStatus_principalpath.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_removedauthorizations = ddvTaskStatusSchema.get("removedauthorizations");
		ddvTaskStatus_removedauthorizations.setMultivalue(true);
		ddvTaskStatus_removedauthorizations.setSystemReserved(true);
		ddvTaskStatus_removedauthorizations.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_schema = ddvTaskStatusSchema.get("schema");
		ddvTaskStatus_schema.setDefaultRequirement(true);
		ddvTaskStatus_schema.setSystemReserved(true);
		ddvTaskStatus_schema.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_searchable = ddvTaskStatusSchema.get("searchable");
		ddvTaskStatus_searchable.setSystemReserved(true);
		ddvTaskStatus_searchable.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_shareDenyTokens = ddvTaskStatusSchema.get("shareDenyTokens");
		ddvTaskStatus_shareDenyTokens.setMultivalue(true);
		ddvTaskStatus_shareDenyTokens.setSystemReserved(true);
		ddvTaskStatus_shareDenyTokens.setUndeletable(true);
		ddvTaskStatus_shareDenyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder ddvTaskStatus_shareTokens = ddvTaskStatusSchema.get("shareTokens");
		ddvTaskStatus_shareTokens.setMultivalue(true);
		ddvTaskStatus_shareTokens.setSystemReserved(true);
		ddvTaskStatus_shareTokens.setUndeletable(true);
		ddvTaskStatus_shareTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder ddvTaskStatus_statusType = ddvTaskStatusSchema.create("statusType").setType(MetadataValueType.ENUM);
		ddvTaskStatus_statusType.setDefaultRequirement(true);
		ddvTaskStatus_statusType.setUndeletable(true);
		ddvTaskStatus_statusType.defineAsEnum(TaskStatusType.class);
		MetadataBuilder ddvTaskStatus_title = ddvTaskStatusSchema.get("title");
		ddvTaskStatus_title.setDefaultRequirement(true);
		ddvTaskStatus_title.setUndeletable(true);
		ddvTaskStatus_title.setSchemaAutocomplete(true);
		ddvTaskStatus_title.setSearchable(true);
		ddvTaskStatus_title.setUniqueValue(true);
		MetadataBuilder ddvTaskStatus_tokens = ddvTaskStatusSchema.get("tokens");
		ddvTaskStatus_tokens.setMultivalue(true);
		ddvTaskStatus_tokens.setSystemReserved(true);
		ddvTaskStatus_tokens.setUndeletable(true);
		MetadataBuilder ddvTaskStatus_visibleInTrees = ddvTaskStatusSchema.get("visibleInTrees");
		ddvTaskStatus_visibleInTrees.setSystemReserved(true);
		ddvTaskStatus_visibleInTrees.setUndeletable(true);
		MetadataBuilder ddvTaskType_allauthorizations = ddvTaskTypeSchema.get("allauthorizations");
		ddvTaskType_allauthorizations.setMultivalue(true);
		ddvTaskType_allauthorizations.setSystemReserved(true);
		ddvTaskType_allauthorizations.setUndeletable(true);
		MetadataBuilder ddvTaskType_authorizations = ddvTaskTypeSchema.get("authorizations");
		ddvTaskType_authorizations.setMultivalue(true);
		ddvTaskType_authorizations.setSystemReserved(true);
		ddvTaskType_authorizations.setUndeletable(true);
		MetadataBuilder ddvTaskType_code = ddvTaskTypeSchema.create("code").setType(MetadataValueType.STRING);
		ddvTaskType_code.setDefaultRequirement(true);
		ddvTaskType_code.setUndeletable(true);
		ddvTaskType_code.setSchemaAutocomplete(true);
		ddvTaskType_code.setSearchable(true);
		ddvTaskType_code.setUniqueValue(true);
		MetadataBuilder ddvTaskType_comments = ddvTaskTypeSchema.create("comments").setType(MetadataValueType.ENUM);
		ddvTaskType_comments.setMultivalue(true);
		ddvTaskType_comments.defineStructureFactory(CommentFactory.class);
		MetadataBuilder ddvTaskType_createdBy = ddvTaskTypeSchema.get("createdBy");
		ddvTaskType_createdBy.setSystemReserved(true);
		ddvTaskType_createdBy.setUndeletable(true);
		MetadataBuilder ddvTaskType_createdOn = ddvTaskTypeSchema.get("createdOn");
		ddvTaskType_createdOn.setSystemReserved(true);
		ddvTaskType_createdOn.setUndeletable(true);
		ddvTaskType_createdOn.setSortable(true);
		MetadataBuilder ddvTaskType_deleted = ddvTaskTypeSchema.get("deleted");
		ddvTaskType_deleted.setSystemReserved(true);
		ddvTaskType_deleted.setUndeletable(true);
		MetadataBuilder ddvTaskType_denyTokens = ddvTaskTypeSchema.get("denyTokens");
		ddvTaskType_denyTokens.setMultivalue(true);
		ddvTaskType_denyTokens.setSystemReserved(true);
		ddvTaskType_denyTokens.setUndeletable(true);
		ddvTaskType_denyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder ddvTaskType_description = ddvTaskTypeSchema.create("description").setType(MetadataValueType.TEXT);
		ddvTaskType_description.setUndeletable(true);
		ddvTaskType_description.setSearchable(true);
		MetadataBuilder ddvTaskType_detachedauthorizations = ddvTaskTypeSchema.get("detachedauthorizations");
		ddvTaskType_detachedauthorizations.setSystemReserved(true);
		ddvTaskType_detachedauthorizations.setUndeletable(true);
		MetadataBuilder ddvTaskType_errorOnPhysicalDeletion = ddvTaskTypeSchema.get("errorOnPhysicalDeletion");
		ddvTaskType_errorOnPhysicalDeletion.setSystemReserved(true);
		ddvTaskType_errorOnPhysicalDeletion.setUndeletable(true);
		MetadataBuilder ddvTaskType_followers = ddvTaskTypeSchema.get("followers");
		ddvTaskType_followers.setMultivalue(true);
		ddvTaskType_followers.setSystemReserved(true);
		ddvTaskType_followers.setUndeletable(true);
		ddvTaskType_followers.setSearchable(true);
		MetadataBuilder ddvTaskType_id = ddvTaskTypeSchema.get("id");
		ddvTaskType_id.setDefaultRequirement(true);
		ddvTaskType_id.setSystemReserved(true);
		ddvTaskType_id.setUndeletable(true);
		ddvTaskType_id.setSearchable(true);
		ddvTaskType_id.setSortable(true);
		ddvTaskType_id.setUniqueValue(true);
		ddvTaskType_id.setUnmodifiable(true);
		MetadataBuilder ddvTaskType_inheritedauthorizations = ddvTaskTypeSchema.get("inheritedauthorizations");
		ddvTaskType_inheritedauthorizations.setMultivalue(true);
		ddvTaskType_inheritedauthorizations.setSystemReserved(true);
		ddvTaskType_inheritedauthorizations.setUndeletable(true);
		MetadataBuilder ddvTaskType_legacyIdentifier = ddvTaskTypeSchema.get("legacyIdentifier");
		ddvTaskType_legacyIdentifier.setDefaultRequirement(true);
		ddvTaskType_legacyIdentifier.setSystemReserved(true);
		ddvTaskType_legacyIdentifier.setUndeletable(true);
		ddvTaskType_legacyIdentifier.setSearchable(true);
		ddvTaskType_legacyIdentifier.setUniqueValue(true);
		ddvTaskType_legacyIdentifier.setUnmodifiable(true);
		MetadataBuilder ddvTaskType_linkedSchema = ddvTaskTypeSchema.create("linkedSchema").setType(MetadataValueType.STRING);
		MetadataBuilder ddvTaskType_logicallyDeletedOn = ddvTaskTypeSchema.get("logicallyDeletedOn");
		ddvTaskType_logicallyDeletedOn.setSystemReserved(true);
		ddvTaskType_logicallyDeletedOn.setUndeletable(true);
		MetadataBuilder ddvTaskType_manualTokens = ddvTaskTypeSchema.get("manualTokens");
		ddvTaskType_manualTokens.setMultivalue(true);
		ddvTaskType_manualTokens.setSystemReserved(true);
		ddvTaskType_manualTokens.setUndeletable(true);
		ddvTaskType_manualTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder ddvTaskType_markedForPreviewConversion = ddvTaskTypeSchema.get("markedForPreviewConversion");
		ddvTaskType_markedForPreviewConversion.setSystemReserved(true);
		ddvTaskType_markedForPreviewConversion.setUndeletable(true);
		MetadataBuilder ddvTaskType_modifiedBy = ddvTaskTypeSchema.get("modifiedBy");
		ddvTaskType_modifiedBy.setSystemReserved(true);
		ddvTaskType_modifiedBy.setUndeletable(true);
		MetadataBuilder ddvTaskType_modifiedOn = ddvTaskTypeSchema.get("modifiedOn");
		ddvTaskType_modifiedOn.setSystemReserved(true);
		ddvTaskType_modifiedOn.setUndeletable(true);
		ddvTaskType_modifiedOn.setSortable(true);
		MetadataBuilder ddvTaskType_parentpath = ddvTaskTypeSchema.get("parentpath");
		ddvTaskType_parentpath.setMultivalue(true);
		ddvTaskType_parentpath.setSystemReserved(true);
		ddvTaskType_parentpath.setUndeletable(true);
		MetadataBuilder ddvTaskType_path = ddvTaskTypeSchema.get("path");
		ddvTaskType_path.setMultivalue(true);
		ddvTaskType_path.setSystemReserved(true);
		ddvTaskType_path.setUndeletable(true);
		MetadataBuilder ddvTaskType_pathParts = ddvTaskTypeSchema.get("pathParts");
		ddvTaskType_pathParts.setMultivalue(true);
		ddvTaskType_pathParts.setSystemReserved(true);
		ddvTaskType_pathParts.setUndeletable(true);
		MetadataBuilder ddvTaskType_principalpath = ddvTaskTypeSchema.get("principalpath");
		ddvTaskType_principalpath.setSystemReserved(true);
		ddvTaskType_principalpath.setUndeletable(true);
		MetadataBuilder ddvTaskType_removedauthorizations = ddvTaskTypeSchema.get("removedauthorizations");
		ddvTaskType_removedauthorizations.setMultivalue(true);
		ddvTaskType_removedauthorizations.setSystemReserved(true);
		ddvTaskType_removedauthorizations.setUndeletable(true);
		MetadataBuilder ddvTaskType_schema = ddvTaskTypeSchema.get("schema");
		ddvTaskType_schema.setDefaultRequirement(true);
		ddvTaskType_schema.setSystemReserved(true);
		ddvTaskType_schema.setUndeletable(true);
		MetadataBuilder ddvTaskType_searchable = ddvTaskTypeSchema.get("searchable");
		ddvTaskType_searchable.setSystemReserved(true);
		ddvTaskType_searchable.setUndeletable(true);
		MetadataBuilder ddvTaskType_shareDenyTokens = ddvTaskTypeSchema.get("shareDenyTokens");
		ddvTaskType_shareDenyTokens.setMultivalue(true);
		ddvTaskType_shareDenyTokens.setSystemReserved(true);
		ddvTaskType_shareDenyTokens.setUndeletable(true);
		ddvTaskType_shareDenyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder ddvTaskType_shareTokens = ddvTaskTypeSchema.get("shareTokens");
		ddvTaskType_shareTokens.setMultivalue(true);
		ddvTaskType_shareTokens.setSystemReserved(true);
		ddvTaskType_shareTokens.setUndeletable(true);
		ddvTaskType_shareTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder ddvTaskType_title = ddvTaskTypeSchema.get("title");
		ddvTaskType_title.setDefaultRequirement(true);
		ddvTaskType_title.setUndeletable(true);
		ddvTaskType_title.setSchemaAutocomplete(true);
		ddvTaskType_title.setSearchable(true);
		ddvTaskType_title.setUniqueValue(true);
		MetadataBuilder ddvTaskType_tokens = ddvTaskTypeSchema.get("tokens");
		ddvTaskType_tokens.setMultivalue(true);
		ddvTaskType_tokens.setSystemReserved(true);
		ddvTaskType_tokens.setUndeletable(true);
		MetadataBuilder ddvTaskType_visibleInTrees = ddvTaskTypeSchema.get("visibleInTrees");
		ddvTaskType_visibleInTrees.setSystemReserved(true);
		ddvTaskType_visibleInTrees.setUndeletable(true);
		MetadataBuilder userTask_allauthorizations = userTaskSchema.get("allauthorizations");
		userTask_allauthorizations.setMultivalue(true);
		userTask_allauthorizations.setSystemReserved(true);
		userTask_allauthorizations.setUndeletable(true);
		MetadataBuilder userTask_assignedOn = userTaskSchema.create("assignedOn").setType(MetadataValueType.DATE);
		userTask_assignedOn.setUndeletable(true);
		MetadataBuilder userTask_assignee = userTaskSchema.create("assignee").setType(MetadataValueType.REFERENCE);
		userTask_assignee.setUndeletable(true);
		userTask_assignee.defineReferencesTo(asList(userSchema));
		MetadataBuilder userTask_assigneeGroupsCandidates = userTaskSchema.create("assigneeGroupsCandidates")
				.setType(MetadataValueType.REFERENCE);
		userTask_assigneeGroupsCandidates.setMultivalue(true);
		userTask_assigneeGroupsCandidates.setUndeletable(true);
		userTask_assigneeGroupsCandidates.defineReferencesTo(asList(groupSchema));
		MetadataBuilder userTask_assigneeUsersCandidates = userTaskSchema.create("assigneeUsersCandidates")
				.setType(MetadataValueType.REFERENCE);
		userTask_assigneeUsersCandidates.setMultivalue(true);
		userTask_assigneeUsersCandidates.setUndeletable(true);
		userTask_assigneeUsersCandidates.defineReferencesTo(asList(userSchema));
		MetadataBuilder userTask_assigner = userTaskSchema.create("assigner").setType(MetadataValueType.REFERENCE);
		userTask_assigner.setUndeletable(true);
		userTask_assigner.defineReferencesTo(asList(userSchema));
		MetadataBuilder userTask_authorizations = userTaskSchema.get("authorizations");
		userTask_authorizations.setMultivalue(true);
		userTask_authorizations.setSystemReserved(true);
		userTask_authorizations.setUndeletable(true);
		MetadataBuilder userTask_comments = userTaskSchema.create("comments").setType(MetadataValueType.STRUCTURE);
		userTask_comments.setMultivalue(true);
		userTask_comments.setUndeletable(true);
		userTask_comments.defineStructureFactory(CommentFactory.class);
		MetadataBuilder userTask_contents = userTaskSchema.create("contents").setType(MetadataValueType.CONTENT);
		userTask_contents.setMultivalue(true);
		userTask_contents.setUndeletable(true);
		userTask_contents.setSearchable(true);
		userTask_contents.defineStructureFactory(ContentFactory.class);
		MetadataBuilder userTask_createdBy = userTaskSchema.get("createdBy");
		userTask_createdBy.setSystemReserved(true);
		userTask_createdBy.setUndeletable(true);
		MetadataBuilder userTask_createdOn = userTaskSchema.get("createdOn");
		userTask_createdOn.setSystemReserved(true);
		userTask_createdOn.setUndeletable(true);
		userTask_createdOn.setSortable(true);
		MetadataBuilder userTask_decision = userTaskSchema.create("decision").setType(MetadataValueType.STRING);
		MetadataBuilder userTask_deleted = userTaskSchema.get("deleted");
		userTask_deleted.setSystemReserved(true);
		userTask_deleted.setUndeletable(true);
		MetadataBuilder userTask_denyTokens = userTaskSchema.get("denyTokens");
		userTask_denyTokens.setMultivalue(true);
		userTask_denyTokens.setSystemReserved(true);
		userTask_denyTokens.setUndeletable(true);
		userTask_denyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder userTask_description = userTaskSchema.create("description").setType(MetadataValueType.TEXT);
		userTask_description.setUndeletable(true);
		userTask_description.setSearchable(true);
		MetadataBuilder userTask_detachedauthorizations = userTaskSchema.get("detachedauthorizations");
		userTask_detachedauthorizations.setSystemReserved(true);
		userTask_detachedauthorizations.setUndeletable(true);
		MetadataBuilder userTask_dueDate = userTaskSchema.create("dueDate").setType(MetadataValueType.DATE);
		userTask_dueDate.setUndeletable(true);
		MetadataBuilder userTask_endDate = userTaskSchema.create("endDate").setType(MetadataValueType.DATE);
		userTask_endDate.setUndeletable(true);
		MetadataBuilder userTask_errorOnPhysicalDeletion = userTaskSchema.get("errorOnPhysicalDeletion");
		userTask_errorOnPhysicalDeletion.setSystemReserved(true);
		userTask_errorOnPhysicalDeletion.setUndeletable(true);
		MetadataBuilder userTask_followers = userTaskSchema.get("followers");
		userTask_followers.setMultivalue(true);
		userTask_followers.setSystemReserved(true);
		userTask_followers.setUndeletable(true);
		userTask_followers.setSearchable(true);
		MetadataBuilder userTask_id = userTaskSchema.get("id");
		userTask_id.setDefaultRequirement(true);
		userTask_id.setSystemReserved(true);
		userTask_id.setUndeletable(true);
		userTask_id.setSearchable(true);
		userTask_id.setSortable(true);
		userTask_id.setUniqueValue(true);
		userTask_id.setUnmodifiable(true);
		MetadataBuilder userTask_inheritedauthorizations = userTaskSchema.get("inheritedauthorizations");
		userTask_inheritedauthorizations.setMultivalue(true);
		userTask_inheritedauthorizations.setSystemReserved(true);
		userTask_inheritedauthorizations.setUndeletable(true);
		MetadataBuilder userTask_isModel = userTaskSchema.create("isModel").setType(MetadataValueType.BOOLEAN);
		MetadataBuilder userTask_legacyIdentifier = userTaskSchema.get("legacyIdentifier");
		userTask_legacyIdentifier.setDefaultRequirement(true);
		userTask_legacyIdentifier.setSystemReserved(true);
		userTask_legacyIdentifier.setUndeletable(true);
		userTask_legacyIdentifier.setSearchable(true);
		userTask_legacyIdentifier.setUniqueValue(true);
		userTask_legacyIdentifier.setUnmodifiable(true);
		MetadataBuilder userTask_logicallyDeletedOn = userTaskSchema.get("logicallyDeletedOn");
		userTask_logicallyDeletedOn.setSystemReserved(true);
		userTask_logicallyDeletedOn.setUndeletable(true);
		MetadataBuilder userTask_manualTokens = userTaskSchema.get("manualTokens");
		userTask_manualTokens.setMultivalue(true);
		userTask_manualTokens.setSystemReserved(true);
		userTask_manualTokens.setUndeletable(true);
		userTask_manualTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder userTask_markedForPreviewConversion = userTaskSchema.get("markedForPreviewConversion");
		userTask_markedForPreviewConversion.setSystemReserved(true);
		userTask_markedForPreviewConversion.setUndeletable(true);
		MetadataBuilder userTask_modelTask = userTaskSchema.create("modelTask").setType(MetadataValueType.REFERENCE);
		userTask_modelTask.defineReferencesTo(userTaskSchemaType);
		MetadataBuilder userTask_modifiedBy = userTaskSchema.get("modifiedBy");
		userTask_modifiedBy.setSystemReserved(true);
		userTask_modifiedBy.setUndeletable(true);
		MetadataBuilder userTask_modifiedOn = userTaskSchema.get("modifiedOn");
		userTask_modifiedOn.setSystemReserved(true);
		userTask_modifiedOn.setUndeletable(true);
		userTask_modifiedOn.setSortable(true);
		MetadataBuilder userTask_nextReminderOn = userTaskSchema.create("nextReminderOn").setType(MetadataValueType.DATE);
		userTask_nextReminderOn.setUndeletable(true);
		MetadataBuilder userTask_nextTaskCreated = userTaskSchema.create("nextTaskCreated").setType(MetadataValueType.BOOLEAN);
		MetadataBuilder userTask_nextTasks = userTaskSchema.create("nextTasks").setType(MetadataValueType.REFERENCE);
		userTask_nextTasks.setMultivalue(true);
		userTask_nextTasks.defineReferencesTo(userTaskSchemaType);
		MetadataBuilder userTask_nextTasksDecisions = userTaskSchema.create("nextTasksDecisions")
				.setType(MetadataValueType.STRUCTURE);
		userTask_nextTasksDecisions.defineStructureFactory(MapStringStringStructureFactory.class);
		MetadataBuilder userTask_parentTask = userTaskSchema.create("parentTask").setType(MetadataValueType.REFERENCE);
		userTask_parentTask.setUndeletable(true);
		userTask_parentTask.defineChildOfRelationshipToType(userTaskSchemaType);
		MetadataBuilder userTask_parentTaskDueDate = userTaskSchema.create("parentTaskDueDate").setType(MetadataValueType.DATE);
		userTask_parentTaskDueDate.setUndeletable(true);
		MetadataBuilder userTask_parentpath = userTaskSchema.get("parentpath");
		userTask_parentpath.setMultivalue(true);
		userTask_parentpath.setSystemReserved(true);
		userTask_parentpath.setUndeletable(true);
		MetadataBuilder userTask_path = userTaskSchema.get("path");
		userTask_path.setMultivalue(true);
		userTask_path.setSystemReserved(true);
		userTask_path.setUndeletable(true);
		MetadataBuilder userTask_pathParts = userTaskSchema.get("pathParts");
		userTask_pathParts.setMultivalue(true);
		userTask_pathParts.setSystemReserved(true);
		userTask_pathParts.setUndeletable(true);
		MetadataBuilder userTask_principalpath = userTaskSchema.get("principalpath");
		userTask_principalpath.setSystemReserved(true);
		userTask_principalpath.setUndeletable(true);
		MetadataBuilder userTask_progressPercentage = userTaskSchema.create("progressPercentage")
				.setType(MetadataValueType.NUMBER);
		userTask_progressPercentage.setUndeletable(true);
		userTask_progressPercentage.defineValidators().add(PercentageValidator.class);
		MetadataBuilder userTask_relativeDueDate = userTaskSchema.create("relativeDueDate").setType(MetadataValueType.NUMBER);
		MetadataBuilder userTask_reminders = userTaskSchema.create("reminders").setType(MetadataValueType.STRUCTURE);
		userTask_reminders.setMultivalue(true);
		userTask_reminders.setUndeletable(true);
		userTask_reminders.defineStructureFactory(TaskReminderFactory.class);
		MetadataBuilder userTask_removedauthorizations = userTaskSchema.get("removedauthorizations");
		userTask_removedauthorizations.setMultivalue(true);
		userTask_removedauthorizations.setSystemReserved(true);
		userTask_removedauthorizations.setUndeletable(true);
		MetadataBuilder userTask_schema = userTaskSchema.get("schema");
		userTask_schema.setDefaultRequirement(true);
		userTask_schema.setSystemReserved(true);
		userTask_schema.setUndeletable(true);
		MetadataBuilder userTask_searchable = userTaskSchema.get("searchable");
		userTask_searchable.setSystemReserved(true);
		userTask_searchable.setUndeletable(true);
		MetadataBuilder userTask_shareDenyTokens = userTaskSchema.get("shareDenyTokens");
		userTask_shareDenyTokens.setMultivalue(true);
		userTask_shareDenyTokens.setSystemReserved(true);
		userTask_shareDenyTokens.setUndeletable(true);
		userTask_shareDenyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder userTask_shareTokens = userTaskSchema.get("shareTokens");
		userTask_shareTokens.setMultivalue(true);
		userTask_shareTokens.setSystemReserved(true);
		userTask_shareTokens.setUndeletable(true);
		userTask_shareTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder userTask_startDate = userTaskSchema.create("startDate").setType(MetadataValueType.DATE);
		userTask_startDate.setUndeletable(true);
		MetadataBuilder userTask_status = userTaskSchema.create("status").setType(MetadataValueType.REFERENCE);
		userTask_status.setDefaultRequirement(true);
		userTask_status.setUndeletable(true);
		userTask_status.setDefaultValue("00000000006");
		userTask_status.defineReferencesTo(ddvTaskStatusSchemaType);
		MetadataBuilder userTask_statusType = userTaskSchema.create("statusType").setType(MetadataValueType.ENUM);
		userTask_statusType.defineAsEnum(TaskStatusType.class);
		MetadataBuilder userTask_taskFollowers = userTaskSchema.create("taskFollowers").setType(MetadataValueType.STRUCTURE);
		userTask_taskFollowers.setMultivalue(true);
		userTask_taskFollowers.setUndeletable(true);
		userTask_taskFollowers.defineStructureFactory(TaskFollowerFactory.class);
		MetadataBuilder userTask_taskFollowersIds = userTaskSchema.create("taskFollowersIds")
				.setType(MetadataValueType.REFERENCE);
		userTask_taskFollowersIds.setMultivalue(true);
		userTask_taskFollowersIds.setUndeletable(true);
		userTask_taskFollowersIds.defineReferencesTo(asList(userSchema));
		MetadataBuilder userTask_title = userTaskSchema.get("title");
		userTask_title.setDefaultRequirement(true);
		userTask_title.setUndeletable(true);
		userTask_title.setSchemaAutocomplete(true);
		userTask_title.setSearchable(true);
		MetadataBuilder userTask_tokens = userTaskSchema.get("tokens");
		userTask_tokens.setMultivalue(true);
		userTask_tokens.setSystemReserved(true);
		userTask_tokens.setUndeletable(true);
		MetadataBuilder userTask_type = userTaskSchema.create("type").setType(MetadataValueType.REFERENCE);
		userTask_type.setUndeletable(true);
		userTask_type.defineReferencesTo(asList(ddvTaskTypeSchema));
		MetadataBuilder userTask_visibleInTrees = userTaskSchema.get("visibleInTrees");
		userTask_visibleInTrees.setSystemReserved(true);
		userTask_visibleInTrees.setUndeletable(true);
		MetadataBuilder userTask_workflow = userTaskSchema.create("workflow").setType(MetadataValueType.REFERENCE);
		userTask_workflow.defineReferencesTo(workflowSchemaType);
		MetadataBuilder userTask_workflowInstance = userTaskSchema.create("workflowInstance")
				.setType(MetadataValueType.REFERENCE);
		userTask_workflowInstance.defineReferencesTo(workflowInstanceSchemaType);
		MetadataBuilder userTask_workflowTaskSort = userTaskSchema.create("workflowTaskSort").setType(MetadataValueType.NUMBER);
		MetadataBuilder workflow_allauthorizations = workflowSchema.get("allauthorizations");
		workflow_allauthorizations.setMultivalue(true);
		workflow_allauthorizations.setSystemReserved(true);
		workflow_allauthorizations.setUndeletable(true);
		MetadataBuilder workflow_authorizations = workflowSchema.get("authorizations");
		workflow_authorizations.setMultivalue(true);
		workflow_authorizations.setSystemReserved(true);
		workflow_authorizations.setUndeletable(true);
		MetadataBuilder workflow_code = workflowSchema.create("code").setType(MetadataValueType.STRING);
		workflow_code.setUniqueValue(true);
		MetadataBuilder workflow_createdBy = workflowSchema.get("createdBy");
		workflow_createdBy.setSystemReserved(true);
		workflow_createdBy.setUndeletable(true);
		MetadataBuilder workflow_createdOn = workflowSchema.get("createdOn");
		workflow_createdOn.setSystemReserved(true);
		workflow_createdOn.setUndeletable(true);
		workflow_createdOn.setSortable(true);
		MetadataBuilder workflow_deleted = workflowSchema.get("deleted");
		workflow_deleted.setSystemReserved(true);
		workflow_deleted.setUndeletable(true);
		MetadataBuilder workflow_denyTokens = workflowSchema.get("denyTokens");
		workflow_denyTokens.setMultivalue(true);
		workflow_denyTokens.setSystemReserved(true);
		workflow_denyTokens.setUndeletable(true);
		workflow_denyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder workflow_detachedauthorizations = workflowSchema.get("detachedauthorizations");
		workflow_detachedauthorizations.setSystemReserved(true);
		workflow_detachedauthorizations.setUndeletable(true);
		MetadataBuilder workflow_errorOnPhysicalDeletion = workflowSchema.get("errorOnPhysicalDeletion");
		workflow_errorOnPhysicalDeletion.setSystemReserved(true);
		workflow_errorOnPhysicalDeletion.setUndeletable(true);
		MetadataBuilder workflow_followers = workflowSchema.get("followers");
		workflow_followers.setMultivalue(true);
		workflow_followers.setSystemReserved(true);
		workflow_followers.setUndeletable(true);
		workflow_followers.setSearchable(true);
		MetadataBuilder workflow_id = workflowSchema.get("id");
		workflow_id.setDefaultRequirement(true);
		workflow_id.setSystemReserved(true);
		workflow_id.setUndeletable(true);
		workflow_id.setSearchable(true);
		workflow_id.setSortable(true);
		workflow_id.setUniqueValue(true);
		workflow_id.setUnmodifiable(true);
		MetadataBuilder workflow_inheritedauthorizations = workflowSchema.get("inheritedauthorizations");
		workflow_inheritedauthorizations.setMultivalue(true);
		workflow_inheritedauthorizations.setSystemReserved(true);
		workflow_inheritedauthorizations.setUndeletable(true);
		MetadataBuilder workflow_legacyIdentifier = workflowSchema.get("legacyIdentifier");
		workflow_legacyIdentifier.setDefaultRequirement(true);
		workflow_legacyIdentifier.setSystemReserved(true);
		workflow_legacyIdentifier.setUndeletable(true);
		workflow_legacyIdentifier.setSearchable(true);
		workflow_legacyIdentifier.setUniqueValue(true);
		workflow_legacyIdentifier.setUnmodifiable(true);
		MetadataBuilder workflow_logicallyDeletedOn = workflowSchema.get("logicallyDeletedOn");
		workflow_logicallyDeletedOn.setSystemReserved(true);
		workflow_logicallyDeletedOn.setUndeletable(true);
		MetadataBuilder workflow_manualTokens = workflowSchema.get("manualTokens");
		workflow_manualTokens.setMultivalue(true);
		workflow_manualTokens.setSystemReserved(true);
		workflow_manualTokens.setUndeletable(true);
		workflow_manualTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder workflow_markedForPreviewConversion = workflowSchema.get("markedForPreviewConversion");
		workflow_markedForPreviewConversion.setSystemReserved(true);
		workflow_markedForPreviewConversion.setUndeletable(true);
		MetadataBuilder workflow_modifiedBy = workflowSchema.get("modifiedBy");
		workflow_modifiedBy.setSystemReserved(true);
		workflow_modifiedBy.setUndeletable(true);
		MetadataBuilder workflow_modifiedOn = workflowSchema.get("modifiedOn");
		workflow_modifiedOn.setSystemReserved(true);
		workflow_modifiedOn.setUndeletable(true);
		workflow_modifiedOn.setSortable(true);
		MetadataBuilder workflow_parentpath = workflowSchema.get("parentpath");
		workflow_parentpath.setMultivalue(true);
		workflow_parentpath.setSystemReserved(true);
		workflow_parentpath.setUndeletable(true);
		MetadataBuilder workflow_path = workflowSchema.get("path");
		workflow_path.setMultivalue(true);
		workflow_path.setSystemReserved(true);
		workflow_path.setUndeletable(true);
		MetadataBuilder workflow_pathParts = workflowSchema.get("pathParts");
		workflow_pathParts.setMultivalue(true);
		workflow_pathParts.setSystemReserved(true);
		workflow_pathParts.setUndeletable(true);
		MetadataBuilder workflow_principalpath = workflowSchema.get("principalpath");
		workflow_principalpath.setSystemReserved(true);
		workflow_principalpath.setUndeletable(true);
		MetadataBuilder workflow_removedauthorizations = workflowSchema.get("removedauthorizations");
		workflow_removedauthorizations.setMultivalue(true);
		workflow_removedauthorizations.setSystemReserved(true);
		workflow_removedauthorizations.setUndeletable(true);
		MetadataBuilder workflow_schema = workflowSchema.get("schema");
		workflow_schema.setDefaultRequirement(true);
		workflow_schema.setSystemReserved(true);
		workflow_schema.setUndeletable(true);
		MetadataBuilder workflow_searchable = workflowSchema.get("searchable");
		workflow_searchable.setSystemReserved(true);
		workflow_searchable.setUndeletable(true);
		MetadataBuilder workflow_shareDenyTokens = workflowSchema.get("shareDenyTokens");
		workflow_shareDenyTokens.setMultivalue(true);
		workflow_shareDenyTokens.setSystemReserved(true);
		workflow_shareDenyTokens.setUndeletable(true);
		workflow_shareDenyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder workflow_shareTokens = workflowSchema.get("shareTokens");
		workflow_shareTokens.setMultivalue(true);
		workflow_shareTokens.setSystemReserved(true);
		workflow_shareTokens.setUndeletable(true);
		workflow_shareTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder workflow_title = workflowSchema.get("title");
		workflow_title.setUndeletable(true);
		workflow_title.setSchemaAutocomplete(true);
		workflow_title.setSearchable(true);
		MetadataBuilder workflow_tokens = workflowSchema.get("tokens");
		workflow_tokens.setMultivalue(true);
		workflow_tokens.setSystemReserved(true);
		workflow_tokens.setUndeletable(true);
		MetadataBuilder workflow_visibleInTrees = workflowSchema.get("visibleInTrees");
		workflow_visibleInTrees.setSystemReserved(true);
		workflow_visibleInTrees.setUndeletable(true);
		MetadataBuilder workflowInstance_allauthorizations = workflowInstanceSchema.get("allauthorizations");
		workflowInstance_allauthorizations.setMultivalue(true);
		workflowInstance_allauthorizations.setSystemReserved(true);
		workflowInstance_allauthorizations.setUndeletable(true);
		MetadataBuilder workflowInstance_authorizations = workflowInstanceSchema.get("authorizations");
		workflowInstance_authorizations.setMultivalue(true);
		workflowInstance_authorizations.setSystemReserved(true);
		workflowInstance_authorizations.setUndeletable(true);
		MetadataBuilder workflowInstance_createdBy = workflowInstanceSchema.get("createdBy");
		workflowInstance_createdBy.setSystemReserved(true);
		workflowInstance_createdBy.setUndeletable(true);
		MetadataBuilder workflowInstance_createdOn = workflowInstanceSchema.get("createdOn");
		workflowInstance_createdOn.setSystemReserved(true);
		workflowInstance_createdOn.setUndeletable(true);
		workflowInstance_createdOn.setSortable(true);
		MetadataBuilder workflowInstance_deleted = workflowInstanceSchema.get("deleted");
		workflowInstance_deleted.setSystemReserved(true);
		workflowInstance_deleted.setUndeletable(true);
		MetadataBuilder workflowInstance_denyTokens = workflowInstanceSchema.get("denyTokens");
		workflowInstance_denyTokens.setMultivalue(true);
		workflowInstance_denyTokens.setSystemReserved(true);
		workflowInstance_denyTokens.setUndeletable(true);
		workflowInstance_denyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder workflowInstance_detachedauthorizations = workflowInstanceSchema.get("detachedauthorizations");
		workflowInstance_detachedauthorizations.setSystemReserved(true);
		workflowInstance_detachedauthorizations.setUndeletable(true);
		MetadataBuilder workflowInstance_errorOnPhysicalDeletion = workflowInstanceSchema.get("errorOnPhysicalDeletion");
		workflowInstance_errorOnPhysicalDeletion.setSystemReserved(true);
		workflowInstance_errorOnPhysicalDeletion.setUndeletable(true);
		MetadataBuilder workflowInstance_extraFields = workflowInstanceSchema.create("extraFields")
				.setType(MetadataValueType.STRUCTURE);
		workflowInstance_extraFields.defineStructureFactory(MapStringListStringStructureFactory.class);
		MetadataBuilder workflowInstance_followers = workflowInstanceSchema.get("followers");
		workflowInstance_followers.setMultivalue(true);
		workflowInstance_followers.setSystemReserved(true);
		workflowInstance_followers.setUndeletable(true);
		workflowInstance_followers.setSearchable(true);
		MetadataBuilder workflowInstance_id = workflowInstanceSchema.get("id");
		workflowInstance_id.setDefaultRequirement(true);
		workflowInstance_id.setSystemReserved(true);
		workflowInstance_id.setUndeletable(true);
		workflowInstance_id.setSearchable(true);
		workflowInstance_id.setSortable(true);
		workflowInstance_id.setUniqueValue(true);
		workflowInstance_id.setUnmodifiable(true);
		MetadataBuilder workflowInstance_inheritedauthorizations = workflowInstanceSchema.get("inheritedauthorizations");
		workflowInstance_inheritedauthorizations.setMultivalue(true);
		workflowInstance_inheritedauthorizations.setSystemReserved(true);
		workflowInstance_inheritedauthorizations.setUndeletable(true);
		MetadataBuilder workflowInstance_legacyIdentifier = workflowInstanceSchema.get("legacyIdentifier");
		workflowInstance_legacyIdentifier.setDefaultRequirement(true);
		workflowInstance_legacyIdentifier.setSystemReserved(true);
		workflowInstance_legacyIdentifier.setUndeletable(true);
		workflowInstance_legacyIdentifier.setSearchable(true);
		workflowInstance_legacyIdentifier.setUniqueValue(true);
		workflowInstance_legacyIdentifier.setUnmodifiable(true);
		MetadataBuilder workflowInstance_logicallyDeletedOn = workflowInstanceSchema.get("logicallyDeletedOn");
		workflowInstance_logicallyDeletedOn.setSystemReserved(true);
		workflowInstance_logicallyDeletedOn.setUndeletable(true);
		MetadataBuilder workflowInstance_manualTokens = workflowInstanceSchema.get("manualTokens");
		workflowInstance_manualTokens.setMultivalue(true);
		workflowInstance_manualTokens.setSystemReserved(true);
		workflowInstance_manualTokens.setUndeletable(true);
		workflowInstance_manualTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder workflowInstance_markedForPreviewConversion = workflowInstanceSchema.get("markedForPreviewConversion");
		workflowInstance_markedForPreviewConversion.setSystemReserved(true);
		workflowInstance_markedForPreviewConversion.setUndeletable(true);
		MetadataBuilder workflowInstance_modifiedBy = workflowInstanceSchema.get("modifiedBy");
		workflowInstance_modifiedBy.setSystemReserved(true);
		workflowInstance_modifiedBy.setUndeletable(true);
		MetadataBuilder workflowInstance_modifiedOn = workflowInstanceSchema.get("modifiedOn");
		workflowInstance_modifiedOn.setSystemReserved(true);
		workflowInstance_modifiedOn.setUndeletable(true);
		workflowInstance_modifiedOn.setSortable(true);
		MetadataBuilder workflowInstance_parentpath = workflowInstanceSchema.get("parentpath");
		workflowInstance_parentpath.setMultivalue(true);
		workflowInstance_parentpath.setSystemReserved(true);
		workflowInstance_parentpath.setUndeletable(true);
		MetadataBuilder workflowInstance_path = workflowInstanceSchema.get("path");
		workflowInstance_path.setMultivalue(true);
		workflowInstance_path.setSystemReserved(true);
		workflowInstance_path.setUndeletable(true);
		MetadataBuilder workflowInstance_pathParts = workflowInstanceSchema.get("pathParts");
		workflowInstance_pathParts.setMultivalue(true);
		workflowInstance_pathParts.setSystemReserved(true);
		workflowInstance_pathParts.setUndeletable(true);
		MetadataBuilder workflowInstance_principalpath = workflowInstanceSchema.get("principalpath");
		workflowInstance_principalpath.setSystemReserved(true);
		workflowInstance_principalpath.setUndeletable(true);
		MetadataBuilder workflowInstance_removedauthorizations = workflowInstanceSchema.get("removedauthorizations");
		workflowInstance_removedauthorizations.setMultivalue(true);
		workflowInstance_removedauthorizations.setSystemReserved(true);
		workflowInstance_removedauthorizations.setUndeletable(true);
		MetadataBuilder workflowInstance_schema = workflowInstanceSchema.get("schema");
		workflowInstance_schema.setDefaultRequirement(true);
		workflowInstance_schema.setSystemReserved(true);
		workflowInstance_schema.setUndeletable(true);
		MetadataBuilder workflowInstance_searchable = workflowInstanceSchema.get("searchable");
		workflowInstance_searchable.setSystemReserved(true);
		workflowInstance_searchable.setUndeletable(true);
		MetadataBuilder workflowInstance_shareDenyTokens = workflowInstanceSchema.get("shareDenyTokens");
		workflowInstance_shareDenyTokens.setMultivalue(true);
		workflowInstance_shareDenyTokens.setSystemReserved(true);
		workflowInstance_shareDenyTokens.setUndeletable(true);
		workflowInstance_shareDenyTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder workflowInstance_shareTokens = workflowInstanceSchema.get("shareTokens");
		workflowInstance_shareTokens.setMultivalue(true);
		workflowInstance_shareTokens.setSystemReserved(true);
		workflowInstance_shareTokens.setUndeletable(true);
		workflowInstance_shareTokens.defineValidators().add(ManualTokenValidator.class);
		MetadataBuilder workflowInstance_startedBy = workflowInstanceSchema.create("startedBy")
				.setType(MetadataValueType.REFERENCE);
		workflowInstance_startedBy.defineReferencesTo(userSchemaType);
		MetadataBuilder workflowInstance_startedOn = workflowInstanceSchema.create("startedOn")
				.setType(MetadataValueType.DATE_TIME);
		MetadataBuilder workflowInstance_status = workflowInstanceSchema.create("status").setType(MetadataValueType.ENUM);
		workflowInstance_status.defineAsEnum(WorkflowInstanceStatus.class);
		MetadataBuilder workflowInstance_title = workflowInstanceSchema.get("title");
		workflowInstance_title.setUndeletable(true);
		workflowInstance_title.setSchemaAutocomplete(true);
		workflowInstance_title.setSearchable(true);
		MetadataBuilder workflowInstance_tokens = workflowInstanceSchema.get("tokens");
		workflowInstance_tokens.setMultivalue(true);
		workflowInstance_tokens.setSystemReserved(true);
		workflowInstance_tokens.setUndeletable(true);
		MetadataBuilder workflowInstance_visibleInTrees = workflowInstanceSchema.get("visibleInTrees");
		workflowInstance_visibleInTrees.setSystemReserved(true);
		workflowInstance_visibleInTrees.setUndeletable(true);
		MetadataBuilder workflowInstance_workflow = workflowInstanceSchema.create("workflow")
				.setType(MetadataValueType.REFERENCE);
		workflowInstance_workflow.defineReferencesTo(workflowSchemaType);
		ddvTaskStatus_allauthorizations.defineDataEntry().asCalculated(AllAuthorizationsCalculator.class);
		ddvTaskStatus_inheritedauthorizations.defineDataEntry().asCalculated(InheritedAuthorizationsCalculator.class);
		ddvTaskStatus_parentpath.defineDataEntry().asCalculated(ParentPathCalculator.class);
		ddvTaskStatus_path.defineDataEntry().asCalculated(PathCalculator.class);
		ddvTaskStatus_pathParts.defineDataEntry().asCalculated(PathPartsCalculator.class);
		ddvTaskStatus_principalpath.defineDataEntry().asCalculated(PrincipalPathCalculator.class);
		ddvTaskStatus_tokens.defineDataEntry().asCalculated(TokensCalculator2.class);
		ddvTaskType_allauthorizations.defineDataEntry().asCalculated(AllAuthorizationsCalculator.class);
		ddvTaskType_inheritedauthorizations.defineDataEntry().asCalculated(InheritedAuthorizationsCalculator.class);
		ddvTaskType_parentpath.defineDataEntry().asCalculated(ParentPathCalculator.class);
		ddvTaskType_path.defineDataEntry().asCalculated(PathCalculator.class);
		ddvTaskType_pathParts.defineDataEntry().asCalculated(PathPartsCalculator.class);
		ddvTaskType_principalpath.defineDataEntry().asCalculated(PrincipalPathCalculator.class);
		ddvTaskType_tokens.defineDataEntry().asCalculated(TokensCalculator2.class);
		userTask_allauthorizations.defineDataEntry().asCalculated(AllAuthorizationsCalculator.class);
		userTask_inheritedauthorizations.defineDataEntry().asCalculated(InheritedAuthorizationsCalculator.class);
		userTask_nextReminderOn.defineDataEntry().asCalculated(TaskNextReminderOnCalculator.class);
		userTask_nextTasks.defineDataEntry().asCalculated(DecisionsTasksCalculator.class);
		userTask_parentTaskDueDate.defineDataEntry().asCopied(userTask_parentTask, userTask_dueDate);
		userTask_parentpath.defineDataEntry().asCalculated(ParentPathCalculator.class);
		userTask_path.defineDataEntry().asCalculated(PathCalculator.class);
		userTask_pathParts.defineDataEntry().asCalculated(PathPartsCalculator.class);
		userTask_principalpath.defineDataEntry().asCalculated(PrincipalPathCalculator.class);
		userTask_statusType.defineDataEntry().asCopied(userTask_status, ddvTaskStatus_statusType);
		userTask_taskFollowersIds.defineDataEntry().asCalculated(TaskFollowersCalculator.class);
		userTask_tokens.defineDataEntry().asCalculated(TaskTokensCalculator.class);
		userTask_workflowTaskSort.defineDataEntry().asCalculated(WorkflowTaskSortCalculator.class);
		workflow_allauthorizations.defineDataEntry().asCalculated(AllAuthorizationsCalculator.class);
		workflow_inheritedauthorizations.defineDataEntry().asCalculated(InheritedAuthorizationsCalculator.class);
		workflow_parentpath.defineDataEntry().asCalculated(ParentPathCalculator.class);
		workflow_path.defineDataEntry().asCalculated(PathCalculator.class);
		workflow_pathParts.defineDataEntry().asCalculated(PathPartsCalculator.class);
		workflow_principalpath.defineDataEntry().asCalculated(PrincipalPathCalculator.class);
		workflow_tokens.defineDataEntry().asCalculated(TokensCalculator2.class);
		workflowInstance_allauthorizations.defineDataEntry().asCalculated(AllAuthorizationsCalculator.class);
		workflowInstance_inheritedauthorizations.defineDataEntry().asCalculated(InheritedAuthorizationsCalculator.class);
		workflowInstance_parentpath.defineDataEntry().asCalculated(ParentPathCalculator.class);
		workflowInstance_path.defineDataEntry().asCalculated(PathCalculator.class);
		workflowInstance_pathParts.defineDataEntry().asCalculated(PathPartsCalculator.class);
		workflowInstance_principalpath.defineDataEntry().asCalculated(PrincipalPathCalculator.class);
		workflowInstance_tokens.defineDataEntry().asCalculated(TokensCalculator2.class);
	}

	public void applySchemasDisplay(SchemasDisplayManager manager) {
		SchemaTypesDisplayTransactionBuilder transaction = manager.newTransactionBuilderFor(collection);
		SchemaTypesDisplayConfig typesConfig = manager.getTypes(collection);
		transaction.add(manager.getMetadata(collection, "ddvTaskStatus_default_statusType").withMetadataGroup("")
				.withInputType(MetadataInputType.DROPDOWN).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getType(collection, "userTask").withSimpleSearchStatus(true).withAdvancedSearchStatus(true)
				.withManageableStatus(false).withMetadataGroup(resourcesProvider.getLanguageMap(
						asList("default:init.userTask.definition", "init.userTask.remindersTab", "init.userTask.assignment",
								"init.userTask.details", "init.userTask.followersTab"))));
		transaction.add(manager.getSchema(collection, "userTask_default").withFormMetadataCodes(
				asList("userTask_default_title", "userTask_default_type", "userTask_default_assignee",
						"userTask_default_assigneeGroupsCandidates", "userTask_default_assigneeUsersCandidates",
						"userTask_default_assigner", "userTask_default_parentTask", "userTask_default_progressPercentage",
						"userTask_default_status", "userTask_default_assignedOn", "userTask_default_dueDate",
						"userTask_default_endDate", "userTask_default_startDate", "userTask_default_contents",
						"userTask_default_description", "userTask_default_reminders", "userTask_default_taskFollowers",
						"userTask_default_decision", "userTask_default_relativeDueDate")).withDisplayMetadataCodes(
				asList("userTask_default_title", "userTask_default_type", "userTask_default_createdOn",
						"userTask_default_modifiedOn", "userTask_default_assignedOn", "userTask_default_assignee",
						"userTask_default_assigneeGroupsCandidates", "userTask_default_assigneeUsersCandidates",
						"userTask_default_assigner", "userTask_default_dueDate", "userTask_default_endDate",
						"userTask_default_nextReminderOn", "userTask_default_parentTask", "userTask_default_parentTaskDueDate",
						"userTask_default_progressPercentage", "userTask_default_startDate", "userTask_default_status",
						"userTask_default_taskFollowersIds", "userTask_default_contents", "userTask_default_description",
						"userTask_default_comments", "userTask_default_decision", "userTask_default_workflow",
						"userTask_default_workflowInstance", "userTask_default_relativeDueDate")).withSearchResultsMetadataCodes(
				asList("userTask_default_title", "userTask_default_status", "userTask_default_dueDate",
						"userTask_default_assignee"))
				.withTableMetadataCodes(asList("userTask_default_title", "userTask_default_modifiedOn")));
		transaction.add(manager.getMetadata(collection, "userTask_default_assignedOn").withMetadataGroup("")
				.withInputType(MetadataInputType.HIDDEN).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_assignee").withMetadataGroup("init.userTask.assignment")
				.withInputType(MetadataInputType.LOOKUP).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_assigneeGroupsCandidates")
				.withMetadataGroup("init.userTask.assignment").withInputType(MetadataInputType.LOOKUP).withHighlightStatus(false)
				.withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_assigneeUsersCandidates")
				.withMetadataGroup("init.userTask.assignment").withInputType(MetadataInputType.LOOKUP).withHighlightStatus(false)
				.withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_assigner").withMetadataGroup("")
				.withInputType(MetadataInputType.HIDDEN).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_contents").withMetadataGroup("init.userTask.details")
				.withInputType(MetadataInputType.CONTENT).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_description").withMetadataGroup("")
				.withInputType(MetadataInputType.RICHTEXT).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_dueDate").withMetadataGroup("")
				.withInputType(MetadataInputType.FIELD).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_endDate").withMetadataGroup("")
				.withInputType(MetadataInputType.HIDDEN).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_parentTask").withMetadataGroup("")
				.withInputType(MetadataInputType.HIDDEN).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_parentTaskDueDate").withMetadataGroup("")
				.withInputType(MetadataInputType.FIELD).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_progressPercentage").withMetadataGroup("")
				.withInputType(MetadataInputType.FIELD).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction
				.add(manager.getMetadata(collection, "userTask_default_reminders").withMetadataGroup("init.userTask.remindersTab")
						.withInputType(MetadataInputType.FIELD).withHighlightStatus(false)
						.withVisibleInAdvancedSearchStatus(false));
		transaction.add(manager.getMetadata(collection, "userTask_default_startDate").withMetadataGroup("")
				.withInputType(MetadataInputType.HIDDEN).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_status").withMetadataGroup("")
				.withInputType(MetadataInputType.LOOKUP).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_taskFollowers")
				.withMetadataGroup("init.userTask.followersTab").withInputType(MetadataInputType.FIELD).withHighlightStatus(false)
				.withVisibleInAdvancedSearchStatus(false));
		transaction.add(manager.getMetadata(collection, "userTask_default_taskFollowersIds").withMetadataGroup("")
				.withInputType(MetadataInputType.LOOKUP).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_title").withMetadataGroup("")
				.withInputType(MetadataInputType.FIELD).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		transaction.add(manager.getMetadata(collection, "userTask_default_type").withMetadataGroup("")
				.withInputType(MetadataInputType.LOOKUP).withHighlightStatus(false).withVisibleInAdvancedSearchStatus(true));
		manager.execute(transaction.build());
	}

	public void applyGeneratedRoles() {
		RolesManager rolesManager = appLayerFactory.getModelLayerFactory().getRolesManager();
		;
		rolesManager.updateRole(rolesManager.getRole(collection, "ADM").withNewPermissions(
				asList("core.deleteContentVersion", "core.ldapConfigurationManagement", "core.manageConnectors",
						"core.manageEmailServer", "core.manageFacets", "core.manageMetadataExtractor",
						"core.manageMetadataSchemas", "core.manageSearchEngine", "core.manageSearchReports",
						"core.manageSecurity", "core.manageSystemCollections", "core.manageSystemConfiguration",
						"core.manageSystemDataImports", "core.manageSystemGroups", "core.manageSystemModules",
						"core.manageSystemServers", "core.manageSystemUpdates", "core.manageSystemUsers", "core.manageTaxonomies",
						"core.manageTrash", "core.manageValueList", "core.useExternalAPIS", "core.viewEvents",
						"tasks.manageWorkflows")));
	}
}