@sitecore/sc-contenthub-webclient-sdk
Version:
Sitecore Content Hub WebClient SDK.
486 lines • 21.1 kB
JavaScript
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 URITemplate from "urijs/src/URITemplate";
import { API } from "./constants";
import { AGGREGATES, ALL_FACETS, COPY_ENTITY, DATA_SOURCE_BY_NAME, DATA_SOURCES, ENTITIES, ENTITY_BY_ID, ENTITY_BY_IDENTIFIER, ENTITY_DEFINITION_BY_ID, ENTITY_DEFINITION_BY_NAME, ENTITY_DEFINITION_BY_NAME_V2, ENTITY_DEFINITIONS, ENTITY_RELATION_BY_NAME, EXPLAIN_USER_PERMISSIONS_FOR_ENTITY, PERMISSIONS_FOR_ENTITY, RESET_PASSWORD, SEARCH, SEND_CONFIRMATION_MAIL, SEND_NOTIFICATION, SET_USER_PASSWORD, SETTING, UPLOAD, UPLOAD_FINALIZE, } from "./constants/api";
import { ArgumentError } from "./errors/argument-error";
import Guard from "./guard";
import Link from "./link";
import { TypeGuards } from "./type-guards";
export class LinkHelper {
constructor(client) {
Guard.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, DATA_SOURCE_BY_NAME.templateName, DATA_SOURCE_BY_NAME.name);
return variable || null;
});
}
dataSourceToLinkAsync(name) {
return __awaiter(this, void 0, void 0, function* () {
Guard.stringNotNullOrEmpty(name);
return yield this.bindAsync(DATA_SOURCE_BY_NAME.templateName, { [DATA_SOURCE_BY_NAME.name]: name });
});
}
dataSourcesLinkAsync() {
return __awaiter(this, void 0, void 0, function* () {
const routes = yield this._client.api.getApiRoutesAsync();
return routes[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, ENTITY_DEFINITION_BY_NAME.templateName, 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.notNullOrUndefined(param);
if (typeof param === "string") {
Guard.stringNotNullOrEmpty(param);
const variables = {
[ENTITY_DEFINITION_BY_NAME.name]: param,
};
if (includeConditionalMembers != null) {
variables[ENTITY_DEFINITION_BY_NAME.includeConditionalMembers] = includeConditionalMembers.toString();
}
if (loadPermissions != null) {
variables[ENTITY_DEFINITION_BY_NAME.loadPermissions] = loadPermissions.toString();
}
return yield this.bindAsync(ENTITY_DEFINITION_BY_NAME.templateName, variables);
}
else {
Guard.validId(param);
const variables = {
[ENTITY_DEFINITION_BY_ID.id]: param.toString(),
};
if (includeConditionalMembers != null) {
variables[ENTITY_DEFINITION_BY_ID.includeConditionalMembers] = includeConditionalMembers.toString();
}
if (loadPermissions != null) {
variables[ENTITY_DEFINITION_BY_ID.loadPermissions] = loadPermissions.toString();
}
return yield this.bindAsync(ENTITY_DEFINITION_BY_ID.templateName, variables);
}
});
}
definitionToLinkV2Async(name, includeConditionalMembers, loadPermissions) {
return __awaiter(this, void 0, void 0, function* () {
Guard.stringNotNullOrEmpty(name);
const variables = {
[ENTITY_DEFINITION_BY_NAME_V2.name]: name,
};
if (includeConditionalMembers != null) {
variables[ENTITY_DEFINITION_BY_NAME_V2.includeConditionalMembers] = includeConditionalMembers.toString();
}
if (loadPermissions != null) {
variables[ENTITY_DEFINITION_BY_NAME_V2.loadPermissions] = loadPermissions.toString();
}
return yield this.bindAsync(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 ArgumentError("Missing function arguments.");
}
if (values) {
Guard.arrayNotEmpty(values);
if (TypeGuards.isStringArray(values)) {
variables[ENTITY_DEFINITIONS.definitionsToLoadByName] = values.join();
}
else {
variables[ENTITY_DEFINITIONS.definitionsToLoadById] = values.join();
}
}
return yield this.bindAsync(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(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, ENTITY_BY_ID.templateName, ENTITY_BY_ID.id);
if (!variable)
return null;
Guard.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.notNullOrUndefined(param);
if (typeof param === "string") {
Guard.stringNotNullOrEmpty(param);
return yield this.bindAsync(ENTITY_BY_IDENTIFIER.templateName, {
[ENTITY_BY_IDENTIFIER.identifier]: param,
});
}
else {
const variables = {
[ENTITY_BY_ID.id]: param.toString(),
};
if (culture != null) {
variables[ENTITY_BY_ID.culture] = culture;
}
return yield this.bindAsync(ENTITY_BY_ID.templateName, variables);
}
});
}
relationToLinkAsync(id, name) {
return __awaiter(this, void 0, void 0, function* () {
Guard.notNullOrUndefined(id);
const variables = {
[ENTITY_RELATION_BY_NAME.id]: id.toString(),
};
if (name != null) {
variables[ENTITY_RELATION_BY_NAME.name] = name;
}
return yield this.bindAsync(ENTITY_RELATION_BY_NAME.templateName, variables);
});
}
entitiesToLinksAsync(ids) {
return __awaiter(this, void 0, void 0, function* () {
if (!ids || ids.length === 0)
return [];
Guard.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, ENTITY_BY_IDENTIFIER.templateName, ENTITY_BY_IDENTIFIER.identifier);
});
}
entitiesLinkAsync() {
return __awaiter(this, void 0, void 0, function* () {
const routes = yield this._client.api.getApiRoutesAsync();
return routes[ENTITIES.templateName];
});
}
permissionsForEntityToLinkAsync(id) {
return __awaiter(this, void 0, void 0, function* () {
Guard.validId(id);
return yield this.bindAsync(PERMISSIONS_FOR_ENTITY.templateName, PERMISSIONS_FOR_ENTITY.id, id.toString());
});
}
explainUserPermissionsForEntityToLinkAsync(id, userId) {
return __awaiter(this, void 0, void 0, function* () {
Guard.validId(id);
Guard.validId(userId);
const variables = {
[EXPLAIN_USER_PERMISSIONS_FOR_ENTITY.id]: id.toString(),
[EXPLAIN_USER_PERMISSIONS_FOR_ENTITY.userId]: userId.toString(),
};
return yield this.bindAsync(EXPLAIN_USER_PERMISSIONS_FOR_ENTITY.templateName, variables);
});
}
copyEntityToLinkAsync(id) {
return __awaiter(this, void 0, void 0, function* () {
Guard.validId(id);
return yield this.bindAsync(COPY_ENTITY.templateName, COPY_ENTITY.id, id.toString());
});
}
//#endregion
//#region Passwords
setUserPasswordToLinkAsync(userId) {
return __awaiter(this, void 0, void 0, function* () {
Guard.validId(userId);
return yield this.bindAsync(SET_USER_PASSWORD.templateName, SET_USER_PASSWORD.userId, userId.toString());
});
}
resetPasswordToLinkAsync(userId) {
return __awaiter(this, void 0, void 0, function* () {
Guard.validId(userId);
return yield this.bindAsync(RESET_PASSWORD.templateName, RESET_PASSWORD.userId, userId.toString());
});
}
//#endregion
//#region Policy
policyToLinkAsync(id) {
return __awaiter(this, void 0, void 0, function* () {
Guard.validId(id);
return yield this.bindAsync(API.POLICY_BY_ID.templateName, 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, API.POLICY_BY_ID.templateName, API.POLICY_BY_ID.id);
Guard.parsableInteger(variable);
return parseInt(variable);
});
}
//#endregion
//#region Commands
commandToLinkAsync(namespace, command) {
return __awaiter(this, void 0, void 0, function* () {
Guard.stringNotNullOrEmpty(namespace);
Guard.stringNotNullOrEmpty(command);
const variables = {
[API.COMMANDS.folder]: namespace,
[API.COMMANDS.command]: command,
};
const res = yield this.bindAsync(API.COMMANDS.templateName, variables);
return res;
});
}
//#endregion
//#region Mails
sendConfirmationMailToLinkAsync(userId) {
return __awaiter(this, void 0, void 0, function* () {
Guard.validId(userId);
return yield this.bindAsync(SEND_CONFIRMATION_MAIL.templateName, SEND_CONFIRMATION_MAIL.userId, userId.toString());
});
}
sendNotificationToLinkAsync(notificationType) {
return __awaiter(this, void 0, void 0, function* () {
Guard.stringNotNullOrEmpty(notificationType);
const task = yield this.bindAsync(SEND_NOTIFICATION.templateName, 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.stringNotNullOrEmpty(aggregateName);
Guard.validId(entityId);
const variables = {
[API.AGGREGATES.name]: aggregateName,
[API.AGGREGATES.id]: entityId.toString(),
[API.AGGREGATES.loadOptionLists]: loadOptionLists.toString(),
[API.AGGREGATES.loadSettings]: loadSettings.toString(),
[API.AGGREGATES.loadDefinitions]: loadDefinitions.toString(),
[API.AGGREGATES.loadEntities]: loadEntities.toString(),
};
if (culture) {
variables[API.AGGREGATES.culture] = culture;
}
if (loadPermissions != undefined) {
variables[API.AGGREGATES.loadPermissions] = loadPermissions.toString();
}
const aggregateLink = yield this.bindAsync(AGGREGATES.templateName, variables);
return aggregateLink;
});
}
//#endregion
//#region PageResource
pageResourceToLinkAsync(page, culture, entityId) {
return __awaiter(this, void 0, void 0, function* () {
Guard.stringNotNullOrEmpty(culture);
Guard.notNullOrUndefined(page);
const variables = {
[API.PAGE_BY_IDENTIFIER.culture]: culture,
};
if (entityId) {
variables[API.PAGE_BY_IDENTIFIER.entityId] = entityId.toString();
}
let templateName = "";
if (typeof page === "string") {
Guard.stringNotNullOrEmpty(page);
variables[API.PAGE_BY_IDENTIFIER.identifier] = page;
templateName = API.PAGE_BY_IDENTIFIER.templateName;
}
else {
Guard.validId(page);
variables[API.PAGE_BY_ID.id] = page.toString();
templateName = 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[SEARCH.templateName];
});
}
allFacetsAsync() {
return __awaiter(this, void 0, void 0, function* () {
const routes = yield this._client.api.getApiRoutesAsync();
return routes[ALL_FACETS.templateName];
});
}
//#endregion
// #region Search
settingByNameLink(categoryName, settingName) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.bindAsync(SETTING.templateName, {
[SETTING.category]: categoryName,
[SETTING.name]: settingName,
});
});
}
//#endregion
//#region Upload
createUploadToLinkAsync() {
return __awaiter(this, void 0, void 0, function* () {
const routes = yield this._client.api.getApiRoutesAsync();
return routes[UPLOAD.templateName];
});
}
finalizeUploadToLinkAsync() {
return __awaiter(this, void 0, void 0, function* () {
const routes = yield this._client.api.getApiRoutesAsync();
return routes[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.stringNotNullOrEmpty(value);
Guard.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(link.href);
}
else {
const template = new URITemplate(link.href);
return new Link(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[ENTITY_DEFINITIONS.skip] = skip.toString();
}
if (take != null) {
variables[ENTITY_DEFINITIONS.take] = take.toString();
}
if (includeConditionalMembers != null) {
variables[ENTITY_DEFINITIONS.includeConditionalMembers] = includeConditionalMembers.toString();
}
if (viewMode != null) {
variables[ENTITY_DEFINITIONS.viewMode] = viewMode;
}
if (loadPermissions != null) {
variables[ENTITY_DEFINITIONS.loadPermissions] = loadPermissions.toString();
}
if (filter != null) {
variables[ENTITY_DEFINITIONS.filter] = filter;
}
if (definitionsToLoad != null) {
variables[ENTITY_DEFINITIONS.definitionsToLoad] = definitionsToLoad.toString();
}
if (definitionsToLoadByName != null) {
variables[ENTITY_DEFINITIONS.definitionsToLoadByName] = definitionsToLoadByName.toString();
}
if (definitionsToLoadById != null) {
variables[ENTITY_DEFINITIONS.definitionsToLoadById] = definitionsToLoadById.toString();
}
if (excludeTaxonomyDefinitions != null) {
variables[ENTITY_DEFINITIONS.excludeTaxonomyDefinitions] = excludeTaxonomyDefinitions.toString();
}
if (excludeSystemOwnedDefinitions != null) {
variables[ENTITY_DEFINITIONS.excludeSystemOwnedDefinitions] = excludeSystemOwnedDefinitions.toString();
}
if (excludeLightDefinitions != null) {
variables[ENTITY_DEFINITIONS.excludeLightDefinitions] = excludeLightDefinitions.toString();
}
return variables;
}
}
//# sourceMappingURL=link-helper.js.map