@sitecore/sc-contenthub-webclient-sdk/esm/mappers/member-definition-mapper.js

Sitecore Content Hub WebClient SDK.

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import format from "string-format";
import { BooleanPropertyDefinition, DateTimeOffsetPropertyDefinition, DateTimePropertyDefinition, DecimalPropertyDefinition, IntegerPropertyDefinition, JsonPropertyDefinition, LongPropertyDefinition, PropertyDefinition, RelationDefinition, StringPropertyDefinition, } from "../contracts/base";
import DataType from "../contracts/base/data-type";
import ErrorMessages from "../error-messages";
import Guard from "../guard";
import { BooleanPropertyDefinitionResource, DateTimeOffsetPropertyDefinitionResource, DateTimePropertyDefinitionResource, DecimalPropertyDefinitionResource, IntegerPropertyDefinitionResource, JsonPropertyDefinitionResource, LongPropertyDefinitionResource, PropertyDefinitionResource, StringPropertyDefinitionResource, } from "../models/property-definition-resource";
import { RelationDefinitionResource } from "../models/relation-definition-resource";
import { MemberConditionMapper } from "./member-condition-mapper";
import { RelationCardinalityMapper } from "./relation-cardinality-mapper";
import { RelationRoleMapper } from "./relation-role-mapper";
export class MemberDefinitionMapper {
    constructor(client) {
        Guard.notNullOrUndefined(client, "client");
        this._client = client;
        this._memberConditionMapper = new MemberConditionMapper(client);
    }
    //#region To SDK
    mapMemberDefinitionsAsync(memberDefinitionResources) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!memberDefinitionResources || memberDefinitionResources.length === 0)
                return [];
            const list = [];
            for (const memberDefinitionResource of memberDefinitionResources) {
                const memberDefinition = yield this.mapMemberDefinitionAsync(memberDefinitionResource);
                if (memberDefinition != null) {
                    list.push(memberDefinition);
                }
            }
            return list;
        });
    }
    mapMemberDefinitionAsync(resource) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!resource)
                return null;
            let definition;
            if (resource instanceof PropertyDefinitionResource) {
                definition = yield this.mapPropertyDefinitionAsync(resource);
            }
            else if (resource instanceof RelationDefinitionResource) {
                definition = yield this.mapRelationDefinitionAsync(resource);
            }
            else {
                throw Error("Unknown property definition type.");
            }
            definition.conditions = yield this._memberConditionMapper.mapMemberConditionsAsync(resource.conditions);
            definition.isSecured = resource.isConditional != null ? resource.isSecured : false;
            definition.isSystemOwned = resource.isSystemOwned;
            definition.allowUpdates = resource.allowUpdates != null ? resource.allowUpdates : false;
            definition.labels = JSON.parse(JSON.stringify(resource.labels));
            definition.helpText = JSON.parse(JSON.stringify(resource.helpText));
            definition.canTriggerConditionalMembers = resource.canTriggerConditionalMembers;
            definition.canWrite = resource.canWrite;
            return definition;
        });
    }
    mapPropertyDefinitionAsync(resource) {
        return __awaiter(this, void 0, void 0, function* () {
            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
            Guard.notNullOrUndefined(resource);
            const initObj = {
                boost: (_a = resource.boost) !== null && _a !== void 0 ? _a : false,
                includeInCompletion: (_b = resource.includeInCompletion) !== null && _b !== void 0 ? _b : false,
                includeInContent: (_c = resource.includeInContent) !== null && _c !== void 0 ? _c : false,
                indexed: (_d = resource.indexed) !== null && _d !== void 0 ? _d : false,
                isMultiLanguage: (_e = resource.isMultiLanguage) !== null && _e !== void 0 ? _e : false,
                isMandatory: (_f = resource.isMandatory) !== null && _f !== void 0 ? _f : false,
                isMultiValue: (_g = resource.isMultiValue) !== null && _g !== void 0 ? _g : false,
                isUnique: (_h = resource.isUnique) !== null && _h !== void 0 ? _h : false,
                canTriggerConditionalMembers: (_j = resource.canTriggerConditionalMembers) !== null && _j !== void 0 ? _j : false,
                canWrite: (_k = resource.canWrite) !== null && _k !== void 0 ? _k : false,
                ignoreOnExport: (_l = resource.ignoreOnExport) !== null && _l !== void 0 ? _l : false,
                storedInGraph: (_m = resource.storedInGraph) !== null && _m !== void 0 ? _m : false,
                conditionalValidation: resource.conditionalValidation,
            };
            switch (resource.type) {
                case DataType.Boolean:
                    return new BooleanPropertyDefinition(resource.name, Object.assign({}, initObj));
                case DataType.DateTime:
                    return new DateTimePropertyDefinition(resource.name, Object.assign({}, initObj));
                case DataType.DateTimeOffset:
                    return new DateTimeOffsetPropertyDefinition(resource.name, Object.assign({}, initObj));
                case DataType.Decimal:
                    return new DecimalPropertyDefinition(resource.name, Object.assign({}, initObj));
                case DataType.Integer:
                    return new IntegerPropertyDefinition(resource.name, Object.assign({}, initObj));
                case DataType.Json: {
                    const jsonPropResource = resource;
                    return new JsonPropertyDefinition(resource.name, Object.assign(Object.assign({}, initObj), { contentType: jsonPropResource.contentType }));
                }
                case DataType.Long:
                    return new LongPropertyDefinition(resource.name, Object.assign({}, initObj));
                case DataType.String: {
                    const stringPropResource = resource;
                    const dataSourceName = stringPropResource.dataSource &&
                        (yield this._client.linkHelper.nameFromDataSourceAsync(stringPropResource.dataSource));
                    return new StringPropertyDefinition(resource.name, Object.assign(Object.assign({}, initObj), { contentType: stringPropResource.contentType, validationExpression: stringPropResource.validationExpression, dataSourceName: dataSourceName }));
                }
                default:
                    throw format(ErrorMessages.UnsupportedMemberDefinition, resource.name, DataType[resource.type]);
            }
        });
    }
    mapRelationDefinitionAsync(resource) {
        return __awaiter(this, void 0, void 0, function* () {
            Guard.notNullOrUndefined(resource);
            Guard.notNullOrUndefined(resource.role, "role");
            Guard.notNullOrUndefined(resource.cardinality, "cardinality");
            const associatedEntityDefinitionName = yield this._client.linkHelper.nameFromDefinitionAsync(resource.associatedEntityDefinition);
            const relationDefinition = new RelationDefinition(resource.name, {
                allowNavigation: resource.allowNavigation,
                associatedEntityDefinitionName: associatedEntityDefinitionName != null ? associatedEntityDefinitionName : undefined,
                pathHierarchyScore: resource.pathHierarchyScore,
                childIsMandatory: resource.childIsMandatory != null ? resource.childIsMandatory : false,
                parentIsMandatory: resource.parentIsMandatory != null ? resource.parentIsMandatory : false,
                completionIsCopied: resource.completionIsCopied,
                contentIsCopied: resource.contentIsCopied,
                inheritsSecurity: resource.inheritsSecurity,
                isNested: resource.isNested,
                isPathHierarchyRelation: resource.isPathHierarchyRelation,
                isPathRelation: resource.isPathRelation,
                isRenditionRelation: resource.isRenditionRelation,
                isTaxonomyHierarchyRelation: resource.isTaxonomyHierarchyRelation,
                isTaxonomyRelation: resource.isTaxonomyRelation,
                associatedLabels: JSON.parse(JSON.stringify(resource.associatedLabels)),
                nestedPermissions: resource.nestedPermissions,
                cardinality: RelationCardinalityMapper.mapToEnumValue(resource.cardinality),
                role: RelationRoleMapper.mapToEnumValue(resource.role),
                childConditionalValidation: resource.childConditionalValidation,
                parentConditionalValidation: resource.parentConditionalValidation,
            });
            if (resource.nestedProperties != null) {
                relationDefinition.nestedProperties.push(...resource.nestedProperties);
            }
            return relationDefinition;
        });
    }
    //#endregion
    //#region To API resource
    mapMemberDefinitionResourcesAsync(memberDefinitions) {
        return __awaiter(this, void 0, void 0, function* () {
            if (memberDefinitions == null || memberDefinitions.length === 0)
                return [];
            const list = [];
            for (const memberDefinition of memberDefinitions) {
                const resource = yield this.mapMemberDefinitionResourceAsync(memberDefinition);
                if (resource) {
                    list.push(resource);
                }
            }
            return list;
        });
    }
    mapMemberDefinitionResourceAsync(memberDefinition) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!memberDefinition)
                return null;
            let resource;
            if (memberDefinition instanceof PropertyDefinition) {
                resource = yield this.mapPropertyDefinitionResourceAsync(memberDefinition);
            }
            else if (memberDefinition instanceof RelationDefinition) {
                resource = yield this.mapRelationDefinitionResourceAsync(memberDefinition);
            }
            else {
                throw format(ErrorMessages.UnsupportedMemberDefinition, memberDefinition.name, DataType[memberDefinition.type]);
            }
            if (!resource)
                return null;
            resource.helpText = JSON.parse(JSON.stringify(memberDefinition.helpText));
            resource.labels = JSON.parse(JSON.stringify(memberDefinition.labels));
            resource.conditions = yield this._memberConditionMapper.mapMemberConditionResourcesAsync(memberDefinition.conditions);
            resource.isConditional = memberDefinition.isConditional;
            resource.isSecured = memberDefinition.isSecured;
            resource.isSystemOwned = memberDefinition.isSystemOwned;
            resource.name = memberDefinition.name;
            resource.allowUpdates = memberDefinition.allowUpdates;
            resource.canTriggerConditionalMembers = memberDefinition.canTriggerConditionalMembers;
            resource.canWrite = memberDefinition.canWrite;
            return resource;
        });
    }
    mapPropertyDefinitionResourceAsync(definition) {
        return __awaiter(this, void 0, void 0, function* () {
            var _a, _b, _c, _d;
            if (!definition)
                return null;
            let resource;
            const initObj = {
                type: definition.type,
                name: definition.name,
                boost: definition.boost != null ? definition.boost : false,
                includeInCompletion: definition.includeInCompletion,
                includeInContent: definition.includeInContent,
                indexed: definition.indexed,
                isMandatory: definition.isMandatory,
                isUnique: definition.isUnique,
                isMultiLanguage: definition.isMultiLanguage,
                isMultiValue: definition.isMultiValue,
                canTriggerConditionalMembers: (_a = definition.canTriggerConditionalMembers) !== null && _a !== void 0 ? _a : false,
                canWrite: (_b = definition.canWrite) !== null && _b !== void 0 ? _b : false,
                ignoreOnExport: (_c = definition.ignoreOnExport) !== null && _c !== void 0 ? _c : false,
                storedInGraph: (_d = definition.storedInGraph) !== null && _d !== void 0 ? _d : false,
                conditionalValidation: definition.conditionalValidation,
            };
            switch (definition.type) {
                case DataType.Boolean:
                    resource = new BooleanPropertyDefinitionResource(Object.assign({}, initObj));
                    break;
                case DataType.DateTime:
                    resource = new DateTimePropertyDefinitionResource(Object.assign({}, initObj));
                    break;
                case DataType.DateTimeOffset:
                    resource = new DateTimeOffsetPropertyDefinitionResource(Object.assign({}, initObj));
                    break;
                case DataType.Decimal:
                    resource = new DecimalPropertyDefinitionResource(Object.assign({}, initObj));
                    break;
                case DataType.Integer:
                    resource = new IntegerPropertyDefinitionResource(Object.assign({}, initObj));
                    break;
                case DataType.Json: {
                    const jsonPropDefinition = definition;
                    resource = new JsonPropertyDefinitionResource(Object.assign(Object.assign({}, initObj), { contentType: jsonPropDefinition.contentType }));
                    break;
                }
                case DataType.Long:
                    resource = new LongPropertyDefinitionResource(Object.assign({}, initObj));
                    break;
                case DataType.String: {
                    const stringPropDefinition = definition;
                    const dataSourceLink = stringPropDefinition.dataSourceName &&
                        (yield this._client.linkHelper.dataSourceToLinkAsync(stringPropDefinition.dataSourceName));
                    resource = new StringPropertyDefinitionResource(Object.assign(Object.assign({}, initObj), { contentType: stringPropDefinition.contentType, validationExpression: stringPropDefinition.validationExpression, dataSource: dataSourceLink || null }));
                    break;
                }
                default:
                    throw format(ErrorMessages.UnsupportedMemberDefinition, definition.name, DataType[definition.type]);
            }
            return resource;
        });
    }
    mapRelationDefinitionResourceAsync(definition) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!definition)
                return null;
            const associatedEntityDefinitionLink = yield this._client.linkHelper.definitionToLinkAsync(definition.associatedEntityDefinitionName);
            return new RelationDefinitionResource({
                associatedEntityDefinition: associatedEntityDefinitionLink,
                allowNavigation: definition.allowNavigation,
                associatedLabels: JSON.parse(JSON.stringify(definition.associatedLabels)),
                pathHierarchyScore: definition.pathHierarchyScore,
                childIsMandatory: definition.childIsMandatory,
                completionIsCopied: definition.completionIsCopied,
                contentIsCopied: definition.contentIsCopied,
                inheritsSecurity: definition.inheritsSecurity,
                isNested: definition.isNested,
                isPathHierarchyRelation: definition.isPathHierarchyRelation,
                isPathRelation: definition.isPathRelation,
                isRenditionRelation: definition.isRenditionRelation,
                isTaxonomyHierarchyRelation: definition.isTaxonomyHierarchyRelation,
                isTaxonomyRelation: definition.isTaxonomyRelation,
                nestedPermissions: definition.nestedPermissions,
                nestedProperties: JSON.parse(JSON.stringify(definition.nestedProperties)),
                parentIsMandatory: definition.parentIsMandatory,
                cardinality: RelationCardinalityMapper.mapToType(definition.cardinality),
                role: RelationRoleMapper.mapToType(definition.role),
                childConditionalValidation: definition.childConditionalValidation,
                parentConditionalValidation: definition.parentConditionalValidation,
            });
        });
    }
}
//# sourceMappingURL=member-definition-mapper.js.map