575 lines
33 KiB
JavaScript
575 lines
33 KiB
JavaScript
/* tslint:disable:no-null-keyword max-line-length typedef no-any no-string-literal variable-name */
|
|
/**
|
|
* This code is a copy from the library @pnp/sp-dev-fx-controls-react
|
|
*/
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator = (this && this.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (_) try {
|
|
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [0, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
import { SPHttpClient } from '@microsoft/sp-http';
|
|
import { findIndex } from '@microsoft/sp-lodash-subset';
|
|
var EmptyGuid = '00000000-0000-0000-0000-000000000000';
|
|
/**
|
|
* Service implementation to manage term stores in SharePoint
|
|
*/
|
|
var SPTermStorePickerService = (function () {
|
|
/**
|
|
* Service constructor
|
|
*/
|
|
function SPTermStorePickerService(props, context) {
|
|
this.props = props;
|
|
this.context = context;
|
|
this.clientServiceUrl = this.context.pageContext.web.absoluteUrl + '/_vti_bin/client.svc/ProcessQuery';
|
|
this.suggestionServiceUrl = this.context.pageContext.web.absoluteUrl + '/_vti_bin/TaxonomyInternalService.json/GetSuggestions';
|
|
}
|
|
SPTermStorePickerService.prototype.getTermLabels = function (termId) {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var result, data, reqHeaders, httpPostOptions, callResult, jsonResult, node, error_1;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
result = null;
|
|
_a.label = 1;
|
|
case 1:
|
|
_a.trys.push([1, 4, , 5]);
|
|
data = "<Request AddExpandoFieldTypeSuffix=\"true\" SchemaVersion=\"15.0.0.0\" LibraryVersion=\"16.0.0.0\" ApplicationName=\".NET Library\" xmlns=\"http://schemas.microsoft.com/sharepoint/clientquery/2009\"><Actions><ObjectPath Id=\"8\" ObjectPathId=\"7\" /><ObjectIdentityQuery Id=\"9\" ObjectPathId=\"7\" /><ObjectPath Id=\"11\" ObjectPathId=\"10\" /><ObjectIdentityQuery Id=\"12\" ObjectPathId=\"10\" /><ObjectPath Id=\"14\" ObjectPathId=\"13\" /><ObjectIdentityQuery Id=\"15\" ObjectPathId=\"13\" /><Query Id=\"16\" ObjectPathId=\"13\"><Query SelectAllProperties=\"false\"><Properties><Property Name=\"Labels\" SelectAll=\"true\"><Query SelectAllProperties=\"false\"><Properties /></Query></Property></Properties></Query></Query></Actions><ObjectPaths><StaticMethod Id=\"7\" Name=\"GetTaxonomySession\" TypeId=\"{981cbc68-9edc-4f8d-872f-71146fcbb84f}\" /><Method Id=\"10\" ParentId=\"7\" Name=\"GetDefaultKeywordsTermStore\" /><Method Id=\"13\" ParentId=\"10\" Name=\"GetTerm\"><Parameters><Parameter Type=\"Guid\">" + termId + "</Parameter></Parameters></Method></ObjectPaths></Request>";
|
|
reqHeaders = new Headers();
|
|
reqHeaders.append('accept', 'application/json');
|
|
reqHeaders.append('content-type', 'application/xml');
|
|
httpPostOptions = {
|
|
headers: reqHeaders,
|
|
body: data
|
|
};
|
|
return [4 /*yield*/, this.context.spHttpClient.post(this.clientServiceUrl, SPHttpClient.configurations.v1, httpPostOptions)];
|
|
case 2:
|
|
callResult = _a.sent();
|
|
return [4 /*yield*/, callResult.json()];
|
|
case 3:
|
|
jsonResult = _a.sent();
|
|
node = jsonResult.find(function (x) { return x._ObjectType_ === 'SP.Taxonomy.Term'; });
|
|
if (node && node.Labels && node.Labels._Child_Items_) {
|
|
result = node.Labels._Child_Items_.map(function (termLabel) { return termLabel.Value; });
|
|
}
|
|
return [3 /*break*/, 5];
|
|
case 4:
|
|
error_1 = _a.sent();
|
|
result = null;
|
|
console.log(error_1.message);
|
|
return [3 /*break*/, 5];
|
|
case 5: return [2 /*return*/, result];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Gets the collection of term stores in the current SharePoint env
|
|
*/
|
|
SPTermStorePickerService.prototype.getTermStores = function () {
|
|
var _this = this;
|
|
// Retrieve the term store name, groups, and term sets
|
|
var data = '<Request AddExpandoFieldTypeSuffix="true" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName=".NET Library" xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009"><Actions><ObjectPath Id="2" ObjectPathId="1" /><ObjectIdentityQuery Id="3" ObjectPathId="1" /><ObjectPath Id="5" ObjectPathId="4" /><ObjectIdentityQuery Id="6" ObjectPathId="4" /><Query Id="7" ObjectPathId="4"><Query SelectAllProperties="false"><Properties><Property Name="Id" ScalarProperty="true" /><Property Name="Name" ScalarProperty="true" /><Property Name="Groups"><Query SelectAllProperties="false"><Properties /></Query><ChildItemQuery SelectAllProperties="false"><Properties><Property Name="Name" ScalarProperty="true" /><Property Name="Id" ScalarProperty="true" /><Property Name="IsSystemGroup" ScalarProperty="true" /><Property Name="TermSets"><Query SelectAllProperties="false"><Properties /></Query><ChildItemQuery SelectAllProperties="false"><Properties><Property Name="Name" ScalarProperty="true" /><Property Name="Id" ScalarProperty="true" /><Property Name="Description" ScalarProperty="true" /><Property Name="Names" ScalarProperty="true" /></Properties></ChildItemQuery></Property></Properties></ChildItemQuery></Property></Properties></Query></Query></Actions><ObjectPaths><StaticMethod Id="1" Name="GetTaxonomySession" TypeId="{981cbc68-9edc-4f8d-872f-71146fcbb84f}" /><Method Id="4" ParentId="1" Name="GetDefaultSiteCollectionTermStore" /></ObjectPaths></Request>';
|
|
var reqHeaders = new Headers();
|
|
reqHeaders.append('accept', 'application/json');
|
|
reqHeaders.append('content-type', 'application/xml');
|
|
var httpPostOptions = {
|
|
headers: reqHeaders,
|
|
body: data
|
|
};
|
|
return this.context.spHttpClient.post(this.clientServiceUrl, SPHttpClient.configurations.v1, httpPostOptions).then(function (serviceResponse) {
|
|
return serviceResponse.json().then(function (serviceJSONResponse) {
|
|
// Construct results
|
|
var termStoreResult = serviceJSONResponse.filter(function (r) { return r['_ObjectType_'] === 'SP.Taxonomy.TermStore'; });
|
|
// Check if term store was retrieved
|
|
if (termStoreResult.length > 0) {
|
|
// Check if the termstore needs to be filtered or limited
|
|
if (_this.props.termsetNameOrID) {
|
|
return termStoreResult.map(function (termstore) {
|
|
var termGroups = termstore.Groups._Child_Items_;
|
|
// Check if the groups have to be limited to a specific term set
|
|
if (_this.props.termsetNameOrID) {
|
|
var termsetNameOrId_1 = _this.props.termsetNameOrID;
|
|
termGroups = termGroups.map(function (group) {
|
|
group.TermSets._Child_Items_ = group.TermSets._Child_Items_.filter(function (termSet) { return termSet.Name === termsetNameOrId_1 || _this.cleanGuid(termSet.Id).toLowerCase() === _this.cleanGuid(termsetNameOrId_1).toLowerCase(); });
|
|
return group;
|
|
});
|
|
}
|
|
// Filter out all systen groups
|
|
termGroups = termGroups.filter(function (group) { return !group.IsSystemGroup; });
|
|
// Filter out empty groups
|
|
termGroups = termGroups.filter(function (group) { return group.TermSets._Child_Items_.length > 0; });
|
|
// Map the new groups
|
|
termstore.Groups._Child_Items_ = termGroups;
|
|
return termstore;
|
|
});
|
|
}
|
|
// Return the term store results
|
|
return termStoreResult;
|
|
}
|
|
return [];
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Gets the current term set
|
|
*/
|
|
SPTermStorePickerService.prototype.getTermSet = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var termStore;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0: return [4 /*yield*/, this.getTermStores()];
|
|
case 1:
|
|
termStore = _a.sent();
|
|
return [2 /*return*/, this.getTermSetId(termStore, this.props.termsetNameOrID)];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Retrieve all terms for the given term set
|
|
* @param termset
|
|
*/
|
|
SPTermStorePickerService.prototype.getAllTerms = function (termset, hideDeprecatedTags, hideTagsNotAvailableForTagging, useSessionStorage) {
|
|
if (useSessionStorage === void 0) { useSessionStorage = true; }
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var _this = this;
|
|
var termsetId, termStore, crntTermSet, childTerms, data, reqHeaders, httpPostOptions;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
termsetId = termset;
|
|
if (!!this.isGuid(termset)) return [3 /*break*/, 2];
|
|
return [4 /*yield*/, this.getTermStores()];
|
|
case 1:
|
|
termStore = _a.sent();
|
|
crntTermSet = this.getTermSetId(termStore, termset);
|
|
if (crntTermSet) {
|
|
termsetId = this.cleanGuid(crntTermSet.Id);
|
|
}
|
|
else {
|
|
return [2 /*return*/, null];
|
|
}
|
|
_a.label = 2;
|
|
case 2:
|
|
childTerms = this.getTermsById(termsetId, useSessionStorage);
|
|
if (childTerms) {
|
|
return [2 /*return*/, childTerms];
|
|
}
|
|
data = "<Request xmlns=\"http://schemas.microsoft.com/sharepoint/clientquery/2009\" SchemaVersion=\"15.0.0.0\" LibraryVersion=\"16.0.0.0\" ApplicationName=\"Javascript Library\"><Actions><ObjectPath Id=\"1\" ObjectPathId=\"0\" /><ObjectIdentityQuery Id=\"2\" ObjectPathId=\"0\" /><ObjectPath Id=\"4\" ObjectPathId=\"3\" /><ObjectIdentityQuery Id=\"5\" ObjectPathId=\"3\" /><ObjectPath Id=\"7\" ObjectPathId=\"6\" /><ObjectIdentityQuery Id=\"8\" ObjectPathId=\"6\" /><ObjectPath Id=\"10\" ObjectPathId=\"9\" /><Query Id=\"11\" ObjectPathId=\"6\"><Query SelectAllProperties=\"true\"><Properties /></Query></Query><Query Id=\"12\" ObjectPathId=\"9\"><Query SelectAllProperties=\"false\"><Properties /></Query><ChildItemQuery SelectAllProperties=\"false\"><Properties><Property Name=\"IsRoot\" SelectAll=\"true\" /><Property Name=\"Labels\" SelectAll=\"true\" /><Property Name=\"TermsCount\" SelectAll=\"true\" /><Property Name=\"CustomSortOrder\" SelectAll=\"true\" /><Property Name=\"Id\" SelectAll=\"true\" /><Property Name=\"Name\" SelectAll=\"true\" /><Property Name=\"PathOfTerm\" SelectAll=\"true\" /><Property Name=\"Parent\" SelectAll=\"true\" /><Property Name=\"LocalCustomProperties\" SelectAll=\"true\" /><Property Name=\"IsDeprecated\" ScalarProperty=\"true\" /><Property Name=\"IsAvailableForTagging\" ScalarProperty=\"true\" /></Properties></ChildItemQuery></Query></Actions><ObjectPaths><StaticMethod Id=\"0\" Name=\"GetTaxonomySession\" TypeId=\"{981cbc68-9edc-4f8d-872f-71146fcbb84f}\" /><Method Id=\"3\" ParentId=\"0\" Name=\"GetDefaultKeywordsTermStore\" /><Method Id=\"6\" ParentId=\"3\" Name=\"GetTermSet\"><Parameters><Parameter Type=\"Guid\">" + termsetId + "</Parameter></Parameters></Method><Method Id=\"9\" ParentId=\"6\" Name=\"GetAllTerms\" /></ObjectPaths></Request>";
|
|
reqHeaders = new Headers();
|
|
reqHeaders.append('accept', 'application/json');
|
|
reqHeaders.append('content-type', 'application/xml');
|
|
httpPostOptions = {
|
|
headers: reqHeaders,
|
|
body: data
|
|
};
|
|
return [2 /*return*/, this.context.spHttpClient.post(this.clientServiceUrl, SPHttpClient.configurations.v1, httpPostOptions).then(function (serviceResponse) {
|
|
return serviceResponse.json().then(function (serviceJSONResponse) {
|
|
var termStoreResultTermSets = serviceJSONResponse.filter(function (r) { return r['_ObjectType_'] === 'SP.Taxonomy.TermSet'; });
|
|
if (termStoreResultTermSets.length > 0) {
|
|
var termStoreResultTermSet_1 = termStoreResultTermSets[0];
|
|
termStoreResultTermSet_1.Terms = [];
|
|
// Retrieve the term collection results
|
|
var termStoreResultTerms = serviceJSONResponse.filter(function (r) { return r['_ObjectType_'] === 'SP.Taxonomy.TermCollection'; });
|
|
if (termStoreResultTerms.length > 0) {
|
|
// Retrieve all terms
|
|
var terms = termStoreResultTerms[0]._Child_Items_;
|
|
if (hideDeprecatedTags === true) {
|
|
terms = terms.filter(function (d) { return d.IsDeprecated === false; });
|
|
}
|
|
if (hideTagsNotAvailableForTagging === true) {
|
|
terms = terms.filter(function (d) { return d.IsAvailableForTagging === true; });
|
|
}
|
|
// Clean the term ID and specify the path depth
|
|
terms = terms.map(function (term) {
|
|
if (term.IsRoot) {
|
|
term.CustomSortOrderIndex = (termStoreResultTermSet_1.CustomSortOrder) ? termStoreResultTermSet_1.CustomSortOrder.split(':').indexOf(_this.cleanGuid(term.Id)) : -1;
|
|
}
|
|
else {
|
|
term.CustomSortOrderIndex = (term['Parent'].CustomSortOrder) ? term['Parent'].CustomSortOrder.split(':').indexOf(_this.cleanGuid(term.Id)) : -1;
|
|
}
|
|
term.Id = _this.cleanGuid(term.Id);
|
|
term['PathDepth'] = term.PathOfTerm.split(';').length;
|
|
term.TermSet = { Id: _this.cleanGuid(termStoreResultTermSet_1.Id), Name: termStoreResultTermSet_1.Name };
|
|
if (term['Parent']) {
|
|
term.ParentId = _this.cleanGuid(term['Parent'].Id);
|
|
}
|
|
return term;
|
|
});
|
|
// Check if the term set was not empty
|
|
if (terms.length > 0) {
|
|
// Sort the terms by PathOfTerm and their depth
|
|
terms = _this.sortTerms(terms);
|
|
termStoreResultTermSet_1.Terms = terms;
|
|
}
|
|
}
|
|
try {
|
|
if (useSessionStorage && window.sessionStorage) {
|
|
window.sessionStorage.setItem(termsetId, JSON.stringify(termStoreResultTermSet_1));
|
|
}
|
|
}
|
|
catch (error) {
|
|
// Do nothing, sometimes "storage quota exceeded" error if too many items
|
|
}
|
|
return termStoreResultTermSet_1;
|
|
}
|
|
return null;
|
|
});
|
|
})];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Retrieve all terms that starts with the searchText
|
|
* @param searchText
|
|
*/
|
|
SPTermStorePickerService.prototype.searchTermsByName = function (searchText) {
|
|
return this.searchTermsByTermSet(searchText);
|
|
};
|
|
SPTermStorePickerService.prototype.searchTermsByTermId = function (searchText, termId) {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var useSessionStorage, childTerms, _a, termsetNameOrID, hideDeprecatedTags, hideTagsNotAvailableForTagging, terms;
|
|
return __generator(this, function (_b) {
|
|
switch (_b.label) {
|
|
case 0:
|
|
useSessionStorage = this.props.useSessionStorage;
|
|
childTerms = this.getTermsById(termId, useSessionStorage);
|
|
if (!childTerms) return [3 /*break*/, 1];
|
|
return [2 /*return*/, this.searchTermsBySearchText(childTerms, searchText)];
|
|
case 1:
|
|
_a = this.props, termsetNameOrID = _a.termsetNameOrID, hideDeprecatedTags = _a.hideDeprecatedTags, hideTagsNotAvailableForTagging = _a.hideTagsNotAvailableForTagging;
|
|
return [4 /*yield*/, this.getAllTermsByAnchorId(termsetNameOrID, termId, hideDeprecatedTags, hideTagsNotAvailableForTagging, useSessionStorage)];
|
|
case 2:
|
|
terms = _b.sent();
|
|
if (terms) {
|
|
return [2 /*return*/, this.searchTermsBySearchText(terms, searchText)];
|
|
}
|
|
_b.label = 3;
|
|
case 3: return [2 /*return*/, null];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Retrieve all terms for the given term set and anchorId
|
|
*/
|
|
SPTermStorePickerService.prototype.getAllTermsByAnchorId = function (termsetNameOrID, anchorId, hideDeprecatedTags, hideTagsNotAvailableForTagging, useSessionStorage) {
|
|
if (useSessionStorage === void 0) { useSessionStorage = true; }
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var _this = this;
|
|
var returnTerms, childTerms, termSet, terms, anchorTerm_1, anchorTermPath_1, anchorTerms;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
returnTerms = [];
|
|
childTerms = this.getTermsById(anchorId, useSessionStorage);
|
|
if (childTerms) {
|
|
return [2 /*return*/, childTerms];
|
|
}
|
|
return [4 /*yield*/, this.getAllTerms(termsetNameOrID, hideDeprecatedTags, hideTagsNotAvailableForTagging)];
|
|
case 1:
|
|
termSet = _a.sent();
|
|
terms = termSet.Terms;
|
|
if (anchorId) {
|
|
anchorTerm_1 = terms.filter(function (t) { return t.Id.toLowerCase() === anchorId.toLowerCase(); }).shift();
|
|
if (anchorTerm_1) {
|
|
anchorTermPath_1 = anchorTerm_1.PathOfTerm + ";";
|
|
anchorTerms = terms.filter(function (t) { return t.PathOfTerm.substring(0, anchorTermPath_1.length) === anchorTermPath_1 && t.Id !== anchorTerm_1.Id; });
|
|
anchorTerms.forEach(function (term) {
|
|
returnTerms.push(_this.convertTermToPickerTerm(term));
|
|
});
|
|
try {
|
|
if (useSessionStorage && window.sessionStorage) {
|
|
window.sessionStorage.setItem(anchorId, JSON.stringify(returnTerms));
|
|
}
|
|
}
|
|
catch (error) {
|
|
// Do nothing
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
terms.forEach(function (term) {
|
|
returnTerms.push(_this.convertTermToPickerTerm(term));
|
|
});
|
|
}
|
|
return [2 /*return*/, returnTerms];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Clean the Guid from the Web Service response
|
|
* @param guid
|
|
*/
|
|
SPTermStorePickerService.prototype.cleanGuid = function (guid) {
|
|
if (guid !== undefined) {
|
|
return guid.replace('/Guid(', '').replace('/', '').replace(')', '');
|
|
}
|
|
else {
|
|
return '';
|
|
}
|
|
};
|
|
/**
|
|
* Get the term set ID by its name
|
|
* @param termstore
|
|
* @param termset
|
|
*/
|
|
SPTermStorePickerService.prototype.getTermSetId = function (termstore, termsetName) {
|
|
if (termstore && termstore.length > 0 && termsetName) {
|
|
// Get the first term store
|
|
var ts = termstore[0];
|
|
// Check if the term store contains groups
|
|
if (ts.Groups && ts.Groups._Child_Items_) {
|
|
for (var _i = 0, _a = ts.Groups._Child_Items_; _i < _a.length; _i++) {
|
|
var group = _a[_i];
|
|
// Check if the group contains term sets
|
|
if (group.TermSets && group.TermSets._Child_Items_) {
|
|
for (var _b = 0, _c = group.TermSets._Child_Items_; _b < _c.length; _b++) {
|
|
var termSet = _c[_b];
|
|
// Check if the term set is found
|
|
if (termSet.Name === termsetName) {
|
|
return termSet;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
SPTermStorePickerService.prototype.getTermsById = function (termId, useSessionStorage) {
|
|
if (useSessionStorage === void 0) { useSessionStorage = true; }
|
|
try {
|
|
if (useSessionStorage && window.sessionStorage) {
|
|
var terms = window.sessionStorage.getItem(termId);
|
|
if (terms) {
|
|
return JSON.parse(terms);
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
catch (error) {
|
|
return null;
|
|
}
|
|
};
|
|
SPTermStorePickerService.prototype.searchTermsBySearchText = function (terms, searchText) {
|
|
if (terms) {
|
|
return terms.filter(function (t) { return t.name.toLowerCase().indexOf(searchText.toLowerCase()) > -1; });
|
|
}
|
|
else {
|
|
return [];
|
|
}
|
|
};
|
|
/**
|
|
* Searches terms for the given term set
|
|
* @param searchText
|
|
* @param termsetId
|
|
*/
|
|
SPTermStorePickerService.prototype.searchTermsByTermSet = function (searchText) {
|
|
var _this = this;
|
|
return new Promise(function (resolve) {
|
|
_this.getTermStores().then(function (termStore) {
|
|
var termSetId = _this.props.termsetNameOrID;
|
|
if (!_this.isGuid(termSetId)) {
|
|
// Get the ID of the provided term set name
|
|
var crntTermSet = _this.getTermSetId(termStore, termSetId);
|
|
if (crntTermSet) {
|
|
termSetId = _this.cleanGuid(crntTermSet.Id);
|
|
}
|
|
else {
|
|
resolve(null);
|
|
return;
|
|
}
|
|
}
|
|
if (termStore === undefined || termStore.length === 0) {
|
|
resolve(null);
|
|
return;
|
|
}
|
|
var loc = _this.context.pageContext.cultureInfo.currentUICultureName === 'de-de' ? 1031 : 1033;
|
|
var data = {
|
|
start: searchText,
|
|
lcid: loc !== 0 ? loc : _this.context.pageContext.web.language,
|
|
sspList: _this.cleanGuid(termStore[0].Id),
|
|
termSetList: termSetId,
|
|
anchorId: _this.props.anchorId ? _this.props.anchorId : EmptyGuid,
|
|
isSpanTermStores: false,
|
|
isSpanTermSets: false,
|
|
isIncludeUnavailable: _this.props.hideTagsNotAvailableForTagging === true,
|
|
isIncludeDeprecated: _this.props.hideDeprecatedTags === true,
|
|
isAddTerms: false,
|
|
isIncludePathData: false,
|
|
excludeKeyword: false,
|
|
excludedTermset: EmptyGuid
|
|
};
|
|
var reqHeaders = new Headers();
|
|
reqHeaders.append('accept', 'application/json');
|
|
reqHeaders.append('content-type', 'application/json');
|
|
var httpPostOptions = {
|
|
headers: reqHeaders,
|
|
body: JSON.stringify(data)
|
|
};
|
|
return _this.context.spHttpClient.post(_this.suggestionServiceUrl, SPHttpClient.configurations.v1, httpPostOptions).then(function (serviceResponse) {
|
|
return serviceResponse.json().then(function (serviceJSONResponse) {
|
|
var groups = serviceJSONResponse.d.Groups;
|
|
if (groups && groups.length > 0) {
|
|
// Retrieve the term collection results
|
|
var terms = groups[0].Suggestions;
|
|
if (terms.length > 0) {
|
|
// Retrieve all terms
|
|
var returnTerms = terms.map(function (term) { return _this.convertSuggestTermToPickerTerm(term); });
|
|
resolve(returnTerms);
|
|
return;
|
|
}
|
|
}
|
|
resolve([]);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
};
|
|
SPTermStorePickerService.prototype.isGuid = function (strGuid) {
|
|
return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(strGuid);
|
|
};
|
|
/**
|
|
* Sorting terms based on their path and depth
|
|
*
|
|
* @param terms
|
|
*/
|
|
SPTermStorePickerService.prototype.sortTerms = function (terms) {
|
|
// Start sorting by depth
|
|
var newTermsOrder = [];
|
|
var itemsToSort = true;
|
|
var pathLevel = 1;
|
|
while (itemsToSort) {
|
|
// Get terms for the current level
|
|
var crntTerms = terms.filter(function (term) { return term.PathDepth === pathLevel; });
|
|
if (crntTerms && crntTerms.length > 0) {
|
|
crntTerms = crntTerms.sort(this.sortTermByPath);
|
|
if (pathLevel !== 1) {
|
|
crntTerms = crntTerms.reverse();
|
|
var _loop_1 = function (crntTerm) {
|
|
var pathElms = crntTerm.PathOfTerm.split(';');
|
|
// Last item is not needed for parent path
|
|
pathElms.pop();
|
|
// Find the parent item and add the new item
|
|
var idx = findIndex(newTermsOrder, function (term) { return term.PathOfTerm === pathElms.join(';'); });
|
|
if (idx !== -1) {
|
|
newTermsOrder.splice(idx + 1, 0, crntTerm);
|
|
}
|
|
else {
|
|
// Push the item at the end if the parent couldn't be found
|
|
newTermsOrder.push(crntTerm);
|
|
}
|
|
};
|
|
for (var _i = 0, crntTerms_1 = crntTerms; _i < crntTerms_1.length; _i++) {
|
|
var crntTerm = crntTerms_1[_i];
|
|
_loop_1(crntTerm);
|
|
}
|
|
}
|
|
else {
|
|
newTermsOrder = crntTerms;
|
|
}
|
|
++pathLevel;
|
|
}
|
|
else {
|
|
itemsToSort = false;
|
|
}
|
|
}
|
|
return newTermsOrder;
|
|
};
|
|
/**
|
|
* Sort the terms by their path
|
|
*
|
|
* @param a term 2
|
|
* @param b term 2
|
|
*/
|
|
SPTermStorePickerService.prototype.sortTermByPath = function (a, b) {
|
|
if (a.CustomSortOrderIndex === -1) {
|
|
if (a.PathOfTerm.toLowerCase() < b.PathOfTerm.toLowerCase()) {
|
|
return -1;
|
|
}
|
|
if (a.PathOfTerm.toLowerCase() > b.PathOfTerm.toLowerCase()) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
else {
|
|
if (a.CustomSortOrderIndex < b.CustomSortOrderIndex) {
|
|
return -1;
|
|
}
|
|
if (a.CustomSortOrderIndex > b.CustomSortOrderIndex) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
};
|
|
SPTermStorePickerService.prototype.convertTermToPickerTerm = function (term) {
|
|
return {
|
|
key: this.cleanGuid(term.Id),
|
|
name: term.Name,
|
|
path: term.PathOfTerm,
|
|
termSet: this.cleanGuid(term.TermSet.Id),
|
|
termSetName: term.TermSet.Name
|
|
};
|
|
};
|
|
SPTermStorePickerService.prototype.convertSuggestTermToPickerTerm = function (term) {
|
|
var path = '';
|
|
var termSetName = '';
|
|
if (term.Paths && term.Paths.length > 0) {
|
|
var fullPath = term.Paths[0].replace(/^\[/, '').replace(/\]$/, '');
|
|
var fullPathParts = fullPath.split(':');
|
|
path = fullPathParts.join(';') + ';' + term.DefaultLabel;
|
|
termSetName = fullPathParts[0];
|
|
}
|
|
return {
|
|
key: this.cleanGuid(term.Id),
|
|
name: term.DefaultLabel,
|
|
path: path,
|
|
termSet: EmptyGuid,
|
|
termSetName: termSetName
|
|
};
|
|
};
|
|
return SPTermStorePickerService;
|
|
}());
|
|
export default SPTermStorePickerService;
|
|
|
|
//# sourceMappingURL=SPTermStorePickerService.js.map
|