@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/mappers/notification-mapper.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationMapper = void 0;
+class NotificationMapper {
+    static mapParameters(request) {
+        const parameters = {
+            title: request.title,
+            options: request.options,
+            extra: {
+                level: request.notificationLevel,
+                link: request.link,
+            },
+        };
+        return parameters;
+    }
+}
+exports.NotificationMapper = NotificationMapper;

package/dist/mappers/option-list-mapper.d.ts

@@ -0,0 +1,18 @@
+import { Nullable, NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IOptionList } from "../contracts/base/option-lists/option-list";
+import { IFlatOptionListValue, IHierarchicalOptionListValue, IOptionListValue } from "../contracts/base/option-lists/option-list-value";
+import OptionListResource from "../models/option-lists/option-list-resource";
+import OptionListValueResource from "../models/option-lists/option-list-value-resource";
+export declare class OptionListMapper {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    mapOptionListAsync(resource: OptionListResource): NullableResultPromise<IOptionList>;
+    map(ol: IOptionList): Nullable<OptionListResource>;
+    mapFlatOptionListValues(optionListValues: Array<OptionListValueResource>): Array<IFlatOptionListValue>;
+    mapFlatOptionListValue(optionListValue: OptionListValueResource): IFlatOptionListValue;
+    mapHierarchicalOptionListValues(optionListValues: Array<OptionListValueResource>): Array<IHierarchicalOptionListValue>;
+    mapHierarchicalOptionListValue(optionListValue: OptionListValueResource): IHierarchicalOptionListValue;
+    mapValues(optionListValues: Array<IOptionListValue>): Array<OptionListValueResource>;
+    mapValue(optionListValue: IOptionListValue): OptionListValueResource;
+}

package/dist/mappers/option-list-mapper.js

@@ -0,0 +1,131 @@
+"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.OptionListMapper = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const flat_option_list_1 = __importDefault(require("../contracts/base/option-lists/flat-option-list"));
+const flat_option_list_value_1 = __importDefault(require("../contracts/base/option-lists/flat-option-list-value"));
+const hierarchical_option_list_1 = __importDefault(require("../contracts/base/option-lists/hierarchical-option-list"));
+const hierarchical_options_list_value_1 = __importDefault(require("../contracts/base/option-lists/hierarchical-options-list-value"));
+const option_list_type_1 = require("../contracts/base/option-lists/option-list-type");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const guard_1 = __importDefault(require("../guard"));
+const option_list_resource_1 = __importDefault(require("../models/option-lists/option-list-resource"));
+const option_list_value_resource_1 = __importDefault(require("../models/option-lists/option-list-value-resource"));
+class OptionListMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client, "client");
+        this._client = client;
+    }
+    mapOptionListAsync(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (resource === null) {
+                return null;
+            }
+            const createdBy = yield this._client.linkHelper.idFromEntityAsync(resource.createdBy);
+            const modifiedBy = yield this._client.linkHelper.idFromEntityAsync(resource.modifiedBy);
+            const labels = resource.labels || {};
+            let olBase;
+            if (resource.type === option_list_type_1.OptionListType.Flat) {
+                const values = this.mapFlatOptionListValues(resource.values);
+                olBase = new flat_option_list_1.default(resource.name, labels, values);
+            }
+            else if (resource.type === option_list_type_1.OptionListType.Hierarchical) {
+                const values = this.mapHierarchicalOptionListValues(resource.values);
+                olBase = new hierarchical_option_list_1.default(resource.name, labels, values);
+            }
+            else {
+                throw string_format_1.default(error_messages_1.default.UnknownOptionListType, resource.type);
+            }
+            olBase.createdBy = createdBy || undefined;
+            olBase.createdOn = resource.createdOn;
+            olBase.modifiedBy = modifiedBy || undefined;
+            olBase.modifiedOn = resource.modifiedOn;
+            olBase.isSystemOwned = resource.isSystemOwned;
+            olBase.name = resource.name;
+            return olBase;
+        });
+    }
+    map(ol) {
+        if (ol === null) {
+            return null;
+        }
+        const type = ol.type;
+        const values = this.mapValues(ol.getOptionListValues());
+        const resource = new option_list_resource_1.default();
+        resource.isSystemOwned = ol.isSystemOwned;
+        resource.name = ol.name;
+        resource.type = type;
+        resource.values = values;
+        resource.labels = JSON.parse(JSON.stringify(ol.labels));
+        return resource;
+    }
+    mapFlatOptionListValues(optionListValues) {
+        if (optionListValues === null) {
+            return [];
+        }
+        const values = optionListValues.map((optionListValue) => {
+            return this.mapFlatOptionListValue(optionListValue);
+        });
+        return values;
+    }
+    mapFlatOptionListValue(optionListValue) {
+        guard_1.default.notNullOrUndefined(optionListValue);
+        return new flat_option_list_value_1.default(optionListValue.identifier, optionListValue.labels);
+    }
+    mapHierarchicalOptionListValues(optionListValues) {
+        if (optionListValues === null) {
+            return [];
+        }
+        const values = optionListValues.map((optionListValue) => {
+            return this.mapHierarchicalOptionListValue(optionListValue);
+        });
+        return values;
+    }
+    mapHierarchicalOptionListValue(optionListValue) {
+        guard_1.default.notNullOrUndefined(optionListValue);
+        let values;
+        if (optionListValue.values && optionListValue.values.length) {
+            values = this.mapHierarchicalOptionListValues(optionListValue.values);
+        }
+        else {
+            values = [];
+        }
+        return new hierarchical_options_list_value_1.default(optionListValue.identifier, optionListValue.labels, values);
+    }
+    mapValues(optionListValues) {
+        if (optionListValues === null) {
+            return [];
+        }
+        const list = [];
+        optionListValues.forEach((optionListValue) => {
+            const olv = this.mapValue(optionListValue);
+            list.push(olv);
+        });
+        return list;
+    }
+    mapValue(optionListValue) {
+        guard_1.default.notNullOrUndefined(optionListValue);
+        const value = new option_list_value_resource_1.default();
+        value.identifier = optionListValue.identifier;
+        value.labels = optionListValue.labels;
+        if (optionListValue instanceof hierarchical_options_list_value_1.default) {
+            optionListValue;
+            const subValues = this.mapValues(optionListValue.values);
+            value.values = subValues;
+        }
+        return value;
+    }
+}
+exports.OptionListMapper = OptionListMapper;

package/dist/mappers/policy-mapper.d.ts

@@ -0,0 +1,29 @@
+import { Nullable, NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IPolicy } from "../contracts/policies/policy";
+import { IUserGroupPolicy } from "../contracts/policies/user-group-policy";
+import { IUserPolicy } from "../contracts/policies/user-policy";
+import { PolicyResource } from "../models/policies/policy-resource";
+export declare class PolicyMapper {
+    /**
+     * Map a policy resource to a user group policy instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param ruleResource - A policy resource
+     * @returns a user group policy or null.
+     */
+    static mapToUserGroupPolicyAsync(client: IExtendedContentHubClient, policyResource: Nullable<PolicyResource>): NullableResultPromise<IUserGroupPolicy>;
+    /**
+     * Map a policy resource to a user policy instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param policyResource - A policy resource
+     * @returns a user policy or null.
+     */
+    static mapToUserPolicyAsync(client: IExtendedContentHubClient, policyResource: Nullable<PolicyResource>): NullableResultPromise<IUserPolicy>;
+    /**
+     * Map a user (group) policy instance to a policy resource.
+     * @param client - An instance of an extended Content Hub client
+     * @param policy - A user policy or user group policy instance
+     * @returns A policy resource.
+     */
+    static mapToResourceAsync(client: IExtendedContentHubClient, policy: Nullable<IPolicy>): NullableResultPromise<PolicyResource>;
+}

package/dist/mappers/policy-mapper.js

@@ -0,0 +1,124 @@
+"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.PolicyMapper = void 0;
+const user_group_policy_1 = require("../contracts/policies/user-group-policy");
+const user_policy_1 = require("../contracts/policies/user-policy");
+const internal_error_1 = require("../errors/internal-error");
+const guard_1 = __importDefault(require("../guard"));
+const policy_resource_1 = require("../models/policies/policy-resource");
+const mapping_utilities_1 = require("./mapping-utilities");
+const member_security_mapper_1 = require("./member-security-mapper");
+const rules_mapper_1 = require("./rules-mapper");
+class PolicyMapper {
+    /**
+     * Map a policy resource to a user group policy instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param ruleResource - A policy resource
+     * @returns a user group policy or null.
+     */
+    static mapToUserGroupPolicyAsync(client, policyResource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (policyResource == null) {
+                return null;
+            }
+            guard_1.default.notNullOrUndefined(policyResource.userGroup);
+            const userGroupId = yield client.linkHelper.idFromEntityAsync(policyResource.userGroup);
+            guard_1.default.notNull(userGroupId);
+            guard_1.default.validId(userGroupId);
+            const createdBy = yield client.linkHelper.idFromEntityAsync(policyResource.createdBy);
+            const modifiedBy = yield client.linkHelper.idFromEntityAsync(policyResource.modifiedBy);
+            const memberSecurity = yield member_security_mapper_1.MemberSecurityMapper.mapToMemberPoliciesAsync(client, policyResource.memberSecurity);
+            const memberGroupSecurity = yield member_security_mapper_1.MemberSecurityMapper.mapToMemberPoliciesAsync(client, policyResource.memberGroupSecurity);
+            const rules = yield rules_mapper_1.RulesMapper.mapToRulesAsync(client, policyResource.rules);
+            const userGroupPolicy = new user_group_policy_1.UserGroupPolicy({
+                memberSecurity: memberSecurity,
+                memberGroupSecurity: memberGroupSecurity,
+                rules: rules,
+                userGroupId: userGroupId,
+                createdBy: createdBy,
+                createdOn: mapping_utilities_1.MappingUtilities.toNullableDate(policyResource.createdOn),
+                modifiedBy: modifiedBy,
+                modifiedOn: mapping_utilities_1.MappingUtilities.toNullableDate(policyResource.modifiedOn),
+            });
+            return userGroupPolicy;
+        });
+    }
+    /**
+     * Map a policy resource to a user policy instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param policyResource - A policy resource
+     * @returns a user policy or null.
+     */
+    static mapToUserPolicyAsync(client, policyResource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (policyResource == null) {
+                return null;
+            }
+            guard_1.default.notNullOrUndefined(policyResource.user);
+            const userId = yield client.linkHelper.idFromEntityAsync(policyResource.user);
+            guard_1.default.notNull(userId);
+            guard_1.default.validId(userId);
+            const createdBy = yield client.linkHelper.idFromEntityAsync(policyResource.createdBy);
+            const modifiedBy = yield client.linkHelper.idFromEntityAsync(policyResource.modifiedBy);
+            const memberSecurity = yield member_security_mapper_1.MemberSecurityMapper.mapToMemberPoliciesAsync(client, policyResource.memberSecurity);
+            const memberGroupSecurity = yield member_security_mapper_1.MemberSecurityMapper.mapToMemberPoliciesAsync(client, policyResource.memberGroupSecurity);
+            const rules = yield rules_mapper_1.RulesMapper.mapToRulesAsync(client, policyResource.rules);
+            const userPolicy = new user_policy_1.UserPolicy({
+                memberSecurity: memberSecurity,
+                memberGroupSecurity: memberGroupSecurity,
+                rules: rules,
+                userId: userId,
+                createdBy: createdBy,
+                createdOn: mapping_utilities_1.MappingUtilities.toNullableDate(policyResource.createdOn),
+                modifiedBy: modifiedBy,
+                modifiedOn: mapping_utilities_1.MappingUtilities.toNullableDate(policyResource.modifiedOn),
+            });
+            return userPolicy;
+        });
+    }
+    /**
+     * Map a user (group) policy instance to a policy resource.
+     * @param client - An instance of an extended Content Hub client
+     * @param policy - A user policy or user group policy instance
+     * @returns A policy resource.
+     */
+    static mapToResourceAsync(client, policy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (policy == null) {
+                return null;
+            }
+            const rules = yield rules_mapper_1.RulesMapper.mapToRuleResourcesAsync(client, policy.rules);
+            const resource = new policy_resource_1.PolicyResource();
+            resource.rules = rules;
+            if (policy instanceof user_policy_1.UserPolicy) {
+                const user = yield client.linkHelper.entityToLinkAsync(policy.userId);
+                resource.user = user;
+            }
+            else if (policy instanceof user_group_policy_1.UserGroupPolicy) {
+                const userGroup = yield client.linkHelper.entityToLinkAsync(policy.userGroupId);
+                resource.userGroup = userGroup;
+            }
+            else {
+                throw new internal_error_1.InternalError("Policy type is not supported.");
+            }
+            const memberSecurity = yield member_security_mapper_1.MemberSecurityMapper.mapToMemberPolicyResourcesAsync(client, policy.memberSecurity);
+            resource.memberSecurity = memberSecurity;
+            const groupSecurity = yield member_security_mapper_1.MemberSecurityMapper.mapToMemberPolicyResourcesAsync(client, policy.memberGroupSecurity);
+            resource.memberGroupSecurity = groupSecurity;
+            return resource;
+        });
+    }
+}
+exports.PolicyMapper = PolicyMapper;

package/dist/mappers/property-mapper.d.ts

@@ -0,0 +1,21 @@
+import { KeyValuePair, MapStringTo } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IEntity } from "../contracts/base/entity";
+import { IProperty } from "../contracts/base/property";
+import { MinimalSchema } from "../contracts/querying/minimal-schema";
+import CultureInfo from "../culture-info";
+import { EntityResource } from "../models/entity-resource";
+export declare class PropertyMapper {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    mapPropertiesAsync(resource: EntityResource, loadedCultures: Array<CultureInfo>, schema?: MinimalSchema): Promise<Array<IProperty>>;
+    private mapProperty;
+    private static mapMultilingualProperty;
+    static mapToPropertyResources(entity: IEntity): MapStringTo<any>;
+    static mapDirtyProperties(entity: IEntity): MapStringTo<unknown>;
+    static mapToPropertyData(property: IProperty): KeyValuePair<string, any>;
+    private static getType;
+    private static convertValue;
+    private static mapDataSource;
+    private static mapDataSourceValue;
+}