@sitecore/sc-contenthub-webclient-sdk/dist/mappers/member-condition-mapper.js

Sitecore Content Hub WebClient SDK.

"use strict";
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());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MemberConditionMapper = void 0;
const string_format_1 = __importDefault(require("string-format"));
const member_condition_1 = require("../contracts/base/member-condition");
const error_messages_1 = __importDefault(require("../error-messages"));
const guard_1 = __importDefault(require("../guard"));
const member_condition_resource_1 = require("../models/member-condition-resource");
class MemberConditionMapper {
    constructor(client) {
        guard_1.default.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 member_condition_resource_1.NoAncestorMemberConditionResource) {
                const definitionId = yield this._client.linkHelper.idFromEntityAsync(conditionResource.definition);
                return new member_condition_1.NoAncestorMemberCondition(conditionResource.memberName, definitionId);
            }
            else if (conditionResource instanceof member_condition_resource_1.RelationMemberConditionResource) {
                const valueId = yield this._client.linkHelper.idFromEntityAsync(conditionResource.value);
                return new member_condition_1.RelationMemberCondition(conditionResource.memberName, valueId);
            }
            else if (conditionResource instanceof member_condition_resource_1.StringMemberConditionResource) {
                return new member_condition_1.StringMemberCondition(conditionResource.memberName, conditionResource.value);
            }
            else if (conditionResource instanceof member_condition_resource_1.BooleanMemberConditionResource) {
                return new member_condition_1.BooleanMemberCondition(conditionResource.memberName, conditionResource.value);
            }
            else {
                throw Error((0, string_format_1.default)(error_messages_1.default.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 member_condition_1.NoAncestorMemberCondition) {
                const definitionName = yield this._client.entityDefinitions.getNameCachedAsync(condition.definitionId);
                const definitionLink = yield this._client.linkHelper.definitionToLinkAsync(definitionName);
                resource = new member_condition_resource_1.NoAncestorMemberConditionResource({
                    memberName: condition.memberName,
                    definition: definitionLink,
                });
            }
            else if (condition instanceof member_condition_1.StringMemberCondition) {
                resource = new member_condition_resource_1.StringMemberConditionResource({
                    memberName: condition.memberName,
                    value: condition.value,
                });
            }
            else if (condition instanceof member_condition_1.BooleanMemberCondition) {
                resource = new member_condition_resource_1.BooleanMemberConditionResource({
                    memberName: condition.memberName,
                    value: condition.value,
                });
            }
            else if (condition instanceof member_condition_1.RelationMemberCondition) {
                const definitionLink = yield this._client.linkHelper.entityToLinkAsync(condition.entityId);
                resource = new member_condition_resource_1.RelationMemberConditionResource({
                    memberName: condition.memberName,
                    value: definitionLink,
                });
            }
            else {
                throw Error((0, string_format_1.default)(error_messages_1.default.UnknownMemberCondition, condition.constructor.name));
            }
            return resource;
        });
    }
}
exports.MemberConditionMapper = MemberConditionMapper;
//# sourceMappingURL=member-condition-mapper.js.map