@sitecore/sc-contenthub-webclient-sdk/dist/link-helper.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.LinkHelper = void 0;
const URITemplate_1 = __importDefault(require("urijs/src/URITemplate"));
const constants_1 = require("./constants");
const api_1 = require("./constants/api");
const argument_error_1 = require("./errors/argument-error");
const guard_1 = __importDefault(require("./guard"));
const link_1 = __importDefault(require("./link"));
const type_guards_1 = require("./type-guards");
class LinkHelper {
    constructor(client) {
        guard_1.default.notNullOrUndefined(client);
        this._client = client;
    }
    //#region DataSources
    nameFromDataSourceAsync(link) {
        return __awaiter(this, void 0, void 0, function* () {
            if (link == null)
                return null;
            const variable = yield this.getVariableValueAsync(link, api_1.DATA_SOURCE_BY_NAME.templateName, api_1.DATA_SOURCE_BY_NAME.name);
            return variable || null;
        });
    }
    dataSourceToLinkAsync(name) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.stringNotNullOrEmpty(name);
            return yield this.bindAsync(api_1.DATA_SOURCE_BY_NAME.templateName, { [api_1.DATA_SOURCE_BY_NAME.name]: name });
        });
    }
    dataSourcesLinkAsync() {
        return __awaiter(this, void 0, void 0, function* () {
            const routes = yield this._client.api.getApiRoutesAsync();
            return routes[api_1.DATA_SOURCES.templateName];
        });
    }
    //#endregion
    //#region Definitions
    nameFromDefinitionAsync(link) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!link)
                return null;
            const variable = yield this.getVariableValueAsync(link, api_1.ENTITY_DEFINITION_BY_NAME.templateName, api_1.ENTITY_DEFINITION_BY_NAME.name);
            return variable || null;
        });
    }
    namesFromDefinitionsAsync(links) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!links)
                return [];
            const result = [];
            yield Promise.all(links.map((link) => __awaiter(this, void 0, void 0, function* () {
                result.push(yield this.nameFromDefinitionAsync(link));
            })));
            return result;
        });
    }
    definitionToLinkAsync(param, includeConditionalMembers, loadPermissions) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.notNullOrUndefined(param);
            if (typeof param === "string") {
                guard_1.default.stringNotNullOrEmpty(param);
                const variables = {
                    [api_1.ENTITY_DEFINITION_BY_NAME.name]: param,
                };
                if (includeConditionalMembers != null) {
                    variables[api_1.ENTITY_DEFINITION_BY_NAME.includeConditionalMembers] = includeConditionalMembers.toString();
                }
                if (loadPermissions != null) {
                    variables[api_1.ENTITY_DEFINITION_BY_NAME.loadPermissions] = loadPermissions.toString();
                }
                return yield this.bindAsync(api_1.ENTITY_DEFINITION_BY_NAME.templateName, variables);
            }
            else {
                guard_1.default.validId(param);
                const variables = {
                    [api_1.ENTITY_DEFINITION_BY_ID.id]: param.toString(),
                };
                if (includeConditionalMembers != null) {
                    variables[api_1.ENTITY_DEFINITION_BY_ID.includeConditionalMembers] = includeConditionalMembers.toString();
                }
                if (loadPermissions != null) {
                    variables[api_1.ENTITY_DEFINITION_BY_ID.loadPermissions] = loadPermissions.toString();
                }
                return yield this.bindAsync(api_1.ENTITY_DEFINITION_BY_ID.templateName, variables);
            }
        });
    }
    definitionToLinkV2Async(name, includeConditionalMembers, loadPermissions) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.stringNotNullOrEmpty(name);
            const variables = {
                [api_1.ENTITY_DEFINITION_BY_NAME_V2.name]: name,
            };
            if (includeConditionalMembers != null) {
                variables[api_1.ENTITY_DEFINITION_BY_NAME_V2.includeConditionalMembers] = includeConditionalMembers.toString();
            }
            if (loadPermissions != null) {
                variables[api_1.ENTITY_DEFINITION_BY_NAME_V2.loadPermissions] = loadPermissions.toString();
            }
            return yield this.bindAsync(api_1.ENTITY_DEFINITION_BY_NAME_V2.templateName, variables);
        });
    }
    definitionsToLinkAsync(values, skip, take, includeConditionalMembers, viewMode, loadPermissions, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions) {
        var arguments_1 = arguments;
        return __awaiter(this, void 0, void 0, function* () {
            const variables = LinkHelper.applyEntityDefinitionVariables({
                skip,
                take,
                includeConditionalMembers,
                viewMode,
                loadPermissions,
                excludeTaxonomyDefinitions,
                excludeSystemOwnedDefinitions,
            });
            if (values == null && arguments_1.length === 1) {
                throw new argument_error_1.ArgumentError("Missing function arguments.");
            }
            if (values) {
                guard_1.default.arrayNotEmpty(values);
                if (type_guards_1.TypeGuards.isStringArray(values)) {
                    variables[api_1.ENTITY_DEFINITIONS.definitionsToLoadByName] = values.join();
                }
                else {
                    variables[api_1.ENTITY_DEFINITIONS.definitionsToLoadById] = values.join();
                }
            }
            return yield this.bindAsync(api_1.ENTITY_DEFINITIONS.templateName, variables);
        });
    }
    definitionsLinkAsync(skip, take, includeConditionalMembers, viewMode, loadPermissions, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById, excludeLightDefinitions) {
        return __awaiter(this, void 0, void 0, function* () {
            const variables = LinkHelper.applyEntityDefinitionVariables({
                skip,
                take,
                includeConditionalMembers,
                viewMode,
                loadPermissions,
                excludeTaxonomyDefinitions,
                excludeSystemOwnedDefinitions,
                filter,
                definitionsToLoadByName,
                definitionsToLoadById,
                excludeLightDefinitions,
            });
            return yield this.bindAsync(api_1.ENTITY_DEFINITIONS.templateName, variables);
        });
    }
    //#endregion
    //#region Entities
    idFromEntityAsync(link) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!link)
                return null;
            const variable = yield this.getVariableValueAsync(link, api_1.ENTITY_BY_ID.templateName, api_1.ENTITY_BY_ID.id);
            if (!variable)
                return null;
            guard_1.default.parsableInteger(variable);
            return parseInt(variable);
        });
    }
    idsFromEntitiesAsync(links) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!links || links.length === 0)
                return [];
            const list = [];
            for (const link of links) {
                const id = yield this.idFromEntityAsync(link);
                if (id != null && id !== 0) {
                    list.push(id);
                }
            }
            return list;
        });
    }
    entityToLinkAsync(param, culture) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.notNullOrUndefined(param);
            if (typeof param === "string") {
                guard_1.default.stringNotNullOrEmpty(param);
                return yield this.bindAsync(api_1.ENTITY_BY_IDENTIFIER.templateName, {
                    [api_1.ENTITY_BY_IDENTIFIER.identifier]: param,
                });
            }
            else {
                const variables = {
                    [api_1.ENTITY_BY_ID.id]: param.toString(),
                };
                if (culture != null) {
                    variables[api_1.ENTITY_BY_ID.culture] = culture;
                }
                return yield this.bindAsync(api_1.ENTITY_BY_ID.templateName, variables);
            }
        });
    }
    relationToLinkAsync(id, name) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.notNullOrUndefined(id);
            const variables = {
                [api_1.ENTITY_RELATION_BY_NAME.id]: id.toString(),
            };
            if (name != null) {
                variables[api_1.ENTITY_RELATION_BY_NAME.name] = name;
            }
            return yield this.bindAsync(api_1.ENTITY_RELATION_BY_NAME.templateName, variables);
        });
    }
    entitiesToLinksAsync(ids) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!ids || ids.length === 0)
                return [];
            guard_1.default.validIds(ids);
            const list = [];
            for (const id of ids) {
                const link = yield this.entityToLinkAsync(id);
                if (link) {
                    list.push(link);
                }
            }
            return list;
        });
    }
    identifierFromEntityAsync(link) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!link)
                return null;
            return yield this.getVariableValueAsync(link, api_1.ENTITY_BY_IDENTIFIER.templateName, api_1.ENTITY_BY_IDENTIFIER.identifier);
        });
    }
    entitiesLinkAsync() {
        return __awaiter(this, void 0, void 0, function* () {
            const routes = yield this._client.api.getApiRoutesAsync();
            return routes[api_1.ENTITIES.templateName];
        });
    }
    permissionsForEntityToLinkAsync(id) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.validId(id);
            return yield this.bindAsync(api_1.PERMISSIONS_FOR_ENTITY.templateName, api_1.PERMISSIONS_FOR_ENTITY.id, id.toString());
        });
    }
    explainUserPermissionsForEntityToLinkAsync(id, userId) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.validId(id);
            guard_1.default.validId(userId);
            const variables = {
                [api_1.EXPLAIN_USER_PERMISSIONS_FOR_ENTITY.id]: id.toString(),
                [api_1.EXPLAIN_USER_PERMISSIONS_FOR_ENTITY.userId]: userId.toString(),
            };
            return yield this.bindAsync(api_1.EXPLAIN_USER_PERMISSIONS_FOR_ENTITY.templateName, variables);
        });
    }
    copyEntityToLinkAsync(id) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.validId(id);
            return yield this.bindAsync(api_1.COPY_ENTITY.templateName, api_1.COPY_ENTITY.id, id.toString());
        });
    }
    //#endregion
    //#region Passwords
    setUserPasswordToLinkAsync(userId) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.validId(userId);
            return yield this.bindAsync(api_1.SET_USER_PASSWORD.templateName, api_1.SET_USER_PASSWORD.userId, userId.toString());
        });
    }
    resetPasswordToLinkAsync(userId) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.validId(userId);
            return yield this.bindAsync(api_1.RESET_PASSWORD.templateName, api_1.RESET_PASSWORD.userId, userId.toString());
        });
    }
    //#endregion
    //#region Policy
    policyToLinkAsync(id) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.validId(id);
            return yield this.bindAsync(constants_1.API.POLICY_BY_ID.templateName, constants_1.API.POLICY_BY_ID.id, id.toString());
        });
    }
    idFromPolicyAsync(link) {
        return __awaiter(this, void 0, void 0, function* () {
            if (link == null) {
                return null;
            }
            const variable = yield this.getVariableValueAsync(link, constants_1.API.POLICY_BY_ID.templateName, constants_1.API.POLICY_BY_ID.id);
            guard_1.default.parsableInteger(variable);
            return parseInt(variable);
        });
    }
    //#endregion
    //#region Commands
    commandToLinkAsync(namespace, command) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.stringNotNullOrEmpty(namespace);
            guard_1.default.stringNotNullOrEmpty(command);
            const variables = {
                [constants_1.API.COMMANDS.folder]: namespace,
                [constants_1.API.COMMANDS.command]: command,
            };
            const res = yield this.bindAsync(constants_1.API.COMMANDS.templateName, variables);
            return res;
        });
    }
    //#endregion
    //#region Mails
    sendConfirmationMailToLinkAsync(userId) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.validId(userId);
            return yield this.bindAsync(api_1.SEND_CONFIRMATION_MAIL.templateName, api_1.SEND_CONFIRMATION_MAIL.userId, userId.toString());
        });
    }
    sendNotificationToLinkAsync(notificationType) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.stringNotNullOrEmpty(notificationType);
            const task = yield this.bindAsync(api_1.SEND_NOTIFICATION.templateName, api_1.SEND_NOTIFICATION.type, notificationType);
            return task;
        });
    }
    //#endregion
    //#region Aggregates
    aggregateToLinkAsync(aggregateName_1, entityId_1, culture_1) {
        return __awaiter(this, arguments, void 0, function* (aggregateName, entityId, culture, { loadPermissions, loadOptionLists = true, loadSettings = true, loadEntities = true, loadDefinitions = true, } = {}) {
            guard_1.default.stringNotNullOrEmpty(aggregateName);
            guard_1.default.validId(entityId);
            const variables = {
                [constants_1.API.AGGREGATES.name]: aggregateName,
                [constants_1.API.AGGREGATES.id]: entityId.toString(),
                [constants_1.API.AGGREGATES.loadOptionLists]: loadOptionLists.toString(),
                [constants_1.API.AGGREGATES.loadSettings]: loadSettings.toString(),
                [constants_1.API.AGGREGATES.loadDefinitions]: loadDefinitions.toString(),
                [constants_1.API.AGGREGATES.loadEntities]: loadEntities.toString(),
            };
            if (culture) {
                variables[constants_1.API.AGGREGATES.culture] = culture;
            }
            if (loadPermissions != undefined) {
                variables[constants_1.API.AGGREGATES.loadPermissions] = loadPermissions.toString();
            }
            const aggregateLink = yield this.bindAsync(api_1.AGGREGATES.templateName, variables);
            return aggregateLink;
        });
    }
    //#endregion
    //#region PageResource
    pageResourceToLinkAsync(page, culture, entityId) {
        return __awaiter(this, void 0, void 0, function* () {
            guard_1.default.stringNotNullOrEmpty(culture);
            guard_1.default.notNullOrUndefined(page);
            const variables = {
                [constants_1.API.PAGE_BY_IDENTIFIER.culture]: culture,
            };
            if (entityId) {
                variables[constants_1.API.PAGE_BY_IDENTIFIER.entityId] = entityId.toString();
            }
            let templateName = "";
            if (typeof page === "string") {
                guard_1.default.stringNotNullOrEmpty(page);
                variables[constants_1.API.PAGE_BY_IDENTIFIER.identifier] = page;
                templateName = constants_1.API.PAGE_BY_IDENTIFIER.templateName;
            }
            else {
                guard_1.default.validId(page);
                variables[constants_1.API.PAGE_BY_ID.id] = page.toString();
                templateName = constants_1.API.PAGE_BY_ID.templateName;
            }
            const pageLink = yield this.bindAsync(templateName, variables);
            return pageLink;
        });
    }
    //#endregion
    //#region Search
    searchLinkAsync() {
        return __awaiter(this, void 0, void 0, function* () {
            const routes = yield this._client.api.getApiRoutesAsync();
            return routes[api_1.SEARCH.templateName];
        });
    }
    allFacetsAsync() {
        return __awaiter(this, void 0, void 0, function* () {
            const routes = yield this._client.api.getApiRoutesAsync();
            return routes[api_1.ALL_FACETS.templateName];
        });
    }
    //#endregion
    // #region Search
    settingByNameLink(categoryName, settingName) {
        return __awaiter(this, void 0, void 0, function* () {
            return yield this.bindAsync(api_1.SETTING.templateName, {
                [api_1.SETTING.category]: categoryName,
                [api_1.SETTING.name]: settingName,
            });
        });
    }
    //#endregion
    //#region Upload
    createUploadToLinkAsync() {
        return __awaiter(this, void 0, void 0, function* () {
            const routes = yield this._client.api.getApiRoutesAsync();
            return routes[api_1.UPLOAD.templateName];
        });
    }
    finalizeUploadToLinkAsync() {
        return __awaiter(this, void 0, void 0, function* () {
            const routes = yield this._client.api.getApiRoutesAsync();
            return routes[api_1.UPLOAD_FINALIZE.templateName];
        });
    }
    //#endregion
    getVariableValueAsync(link, templateName, variable) {
        return __awaiter(this, void 0, void 0, function* () {
            const routes = yield this._client.api.getApiRoutesAsync();
            const value = link.getVariableValue(routes[templateName], variable);
            return value;
        });
    }
    bindAsync(templateName, value, argument) {
        return __awaiter(this, void 0, void 0, function* () {
            let values = {};
            if (typeof value === "string") {
                guard_1.default.stringNotNullOrEmpty(value);
                guard_1.default.notNullOrUndefined(argument);
                values[value] = argument;
            }
            else {
                values = value;
            }
            const routes = yield this._client.api.getApiRoutesAsync();
            const link = routes[templateName];
            if (!link.templated) {
                return new link_1.default(link.href);
            }
            else {
                const template = new URITemplate_1.default(link.href);
                return new link_1.default(template.expand(values));
            }
        });
    }
    static applyEntityDefinitionVariables({ skip, take, filter, definitionsToLoad, definitionsToLoadByName, definitionsToLoadById, viewMode, loadPermissions, includeConditionalMembers, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, excludeLightDefinitions, }) {
        const variables = {};
        if (skip != null && skip !== 0) {
            variables[api_1.ENTITY_DEFINITIONS.skip] = skip.toString();
        }
        if (take != null) {
            variables[api_1.ENTITY_DEFINITIONS.take] = take.toString();
        }
        if (includeConditionalMembers != null) {
            variables[api_1.ENTITY_DEFINITIONS.includeConditionalMembers] = includeConditionalMembers.toString();
        }
        if (viewMode != null) {
            variables[api_1.ENTITY_DEFINITIONS.viewMode] = viewMode;
        }
        if (loadPermissions != null) {
            variables[api_1.ENTITY_DEFINITIONS.loadPermissions] = loadPermissions.toString();
        }
        if (filter != null) {
            variables[api_1.ENTITY_DEFINITIONS.filter] = filter;
        }
        if (definitionsToLoad != null) {
            variables[api_1.ENTITY_DEFINITIONS.definitionsToLoad] = definitionsToLoad.toString();
        }
        if (definitionsToLoadByName != null) {
            variables[api_1.ENTITY_DEFINITIONS.definitionsToLoadByName] = definitionsToLoadByName.toString();
        }
        if (definitionsToLoadById != null) {
            variables[api_1.ENTITY_DEFINITIONS.definitionsToLoadById] = definitionsToLoadById.toString();
        }
        if (excludeTaxonomyDefinitions != null) {
            variables[api_1.ENTITY_DEFINITIONS.excludeTaxonomyDefinitions] = excludeTaxonomyDefinitions.toString();
        }
        if (excludeSystemOwnedDefinitions != null) {
            variables[api_1.ENTITY_DEFINITIONS.excludeSystemOwnedDefinitions] = excludeSystemOwnedDefinitions.toString();
        }
        if (excludeLightDefinitions != null) {
            variables[api_1.ENTITY_DEFINITIONS.excludeLightDefinitions] = excludeLightDefinitions.toString();
        }
        return variables;
    }
}
exports.LinkHelper = LinkHelper;
//# sourceMappingURL=link-helper.js.map