@sitecore/sc-contenthub-webclient-sdk/esm/mappers/member-condition-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 { BooleanMemberCondition, NoAncestorMemberCondition, RelationMemberCondition, StringMemberCondition, } from "../contracts/base/member-condition";
import ErrorMessages from "../error-messages";
import Guard from "../guard";
import { BooleanMemberConditionResource, NoAncestorMemberConditionResource, RelationMemberConditionResource, StringMemberConditionResource, } from "../models/member-condition-resource";
export class MemberConditionMapper {
    constructor(client) {
        Guard.notNullOrUndefined(client, "client");
        this._client = client;
    }
    //#region To SDK
    mapMemberConditionsAsync(conditionResources) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!conditionResources || conditionResources.length === 0)
                return [];
            const list = [];
            for (const conditionResource of conditionResources) {
                const condition = yield this.mapMemberConditionAsync(conditionResource);
                if (condition != null) {
                    list.push(condition);
                }
            }
            return list;
        });
    }
    mapMemberConditionAsync(conditionResource) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!conditionResource)
                return null;
            if (conditionResource instanceof NoAncestorMemberConditionResource) {
                const definitionId = yield this._client.linkHelper.idFromEntityAsync(conditionResource.definition);
                return new NoAncestorMemberCondition(conditionResource.memberName, definitionId);
            }
            else if (conditionResource instanceof RelationMemberConditionResource) {
                const valueId = yield this._client.linkHelper.idFromEntityAsync(conditionResource.value);
                return new RelationMemberCondition(conditionResource.memberName, valueId);
            }
            else if (conditionResource instanceof StringMemberConditionResource) {
                return new StringMemberCondition(conditionResource.memberName, conditionResource.value);
            }
            else if (conditionResource instanceof BooleanMemberConditionResource) {
                return new BooleanMemberCondition(conditionResource.memberName, conditionResource.value);
            }
            else {
                throw Error(format(ErrorMessages.UnknownMemberCondition, conditionResource.constructor.name));
            }
        });
    }
    //#endregion
    //#region To API resource
    mapMemberConditionResourcesAsync(conditions) {
        return __awaiter(this, void 0, void 0, function* () {
            if (conditions == null || conditions.length === 0)
                return [];
            const list = [];
            for (const condition of conditions) {
                const resource = yield this.mapMemberConditionResourceAsync(condition);
                if (resource) {
                    list.push(resource);
                }
            }
            return list;
        });
    }
    mapMemberConditionResourceAsync(condition) {
        return __awaiter(this, void 0, void 0, function* () {
            if (condition == null)
                return null;
            let resource;
            if (condition instanceof NoAncestorMemberCondition) {
                const definitionName = yield this._client.entityDefinitions.getNameCachedAsync(condition.definitionId);
                const definitionLink = yield this._client.linkHelper.definitionToLinkAsync(definitionName);
                resource = new NoAncestorMemberConditionResource({
                    memberName: condition.memberName,
                    definition: definitionLink,
                });
            }
            else if (condition instanceof StringMemberCondition) {
                resource = new StringMemberConditionResource({
                    memberName: condition.memberName,
                    value: condition.value,
                });
            }
            else if (condition instanceof BooleanMemberCondition) {
                resource = new BooleanMemberConditionResource({
                    memberName: condition.memberName,
                    value: condition.value,
                });
            }
            else if (condition instanceof RelationMemberCondition) {
                const definitionLink = yield this._client.linkHelper.entityToLinkAsync(condition.entityId);
                resource = new RelationMemberConditionResource({
                    memberName: condition.memberName,
                    value: definitionLink,
                });
            }
            else {
                throw Error(format(ErrorMessages.UnknownMemberCondition, condition.constructor.name));
            }
            return resource;
        });
    }
}
//# sourceMappingURL=member-condition-mapper.js.map