97d2b6b5d2
- Deleted obsolete localization file for English (en-us). - Updated version number from 1.0.4 to 1.1.0 in manifests.js and manifests.json. - Added localization support for German (de-de) in a new localization file. - Removed unnecessary dependencies from manifests. - Added .gitignore to exclude build artifacts and temporary files.
614 lines
29 KiB
TypeScript
614 lines
29 KiB
TypeScript
/* 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
|
|
*/
|
|
|
|
import { SPHttpClient, SPHttpClientResponse, ISPHttpClientOptions } from '@microsoft/sp-http';
|
|
import { ITermStore, ITerms, ITerm, IGroup, ITermSet, ISuggestTerm } from './ISPTermStorePickerService';
|
|
import { findIndex } from '@microsoft/sp-lodash-subset';
|
|
import { ISPTermStorePickerServiceProps } from './ISPTermStorePickerServiceProps';
|
|
import { IPickerTerm } from './IPickerTerm';
|
|
import { ApplicationCustomizerContext } from '@microsoft/sp-application-base';
|
|
import { debugError } from './MegaMenuDebug';
|
|
|
|
const EmptyGuid: string = '00000000-0000-0000-0000-000000000000';
|
|
const TermCachePrefix: string = 'MegaMenu:TermSet:';
|
|
const PickerCachePrefix: string = 'MegaMenu:PickerTerms:';
|
|
|
|
interface ITermCacheEntry {
|
|
expiresAt: number;
|
|
value: ITermSet;
|
|
}
|
|
|
|
interface IPickerTermCacheEntry {
|
|
expiresAt: number;
|
|
value: IPickerTerm[];
|
|
}
|
|
|
|
/**
|
|
* Service implementation to manage term stores in SharePoint
|
|
*/
|
|
export default class SPTermStorePickerService {
|
|
private clientServiceUrl: string;
|
|
private suggestionServiceUrl: string;
|
|
|
|
/**
|
|
* Service constructor
|
|
*/
|
|
constructor(private props: ISPTermStorePickerServiceProps, private context: ApplicationCustomizerContext, private debug: boolean = false) {
|
|
this.clientServiceUrl = this.context.pageContext.web.absoluteUrl + '/_vti_bin/client.svc/ProcessQuery';
|
|
this.suggestionServiceUrl = this.context.pageContext.web.absoluteUrl + '/_vti_bin/TaxonomyInternalService.json/GetSuggestions';
|
|
}
|
|
|
|
public async getTermLabels(termId: string): Promise<string[]> {
|
|
let result: string[] = null;
|
|
try {
|
|
const 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="GetDefaultSiteCollectionTermStore" /><Method Id="13" ParentId="10" Name="GetTerm"><Parameters><Parameter Type="Guid">${termId}</Parameter></Parameters></Method></ObjectPaths></Request>`;
|
|
|
|
const reqHeaders = new Headers();
|
|
reqHeaders.append('accept', 'application/json');
|
|
reqHeaders.append('content-type', 'application/xml');
|
|
|
|
const httpPostOptions: ISPHttpClientOptions = {
|
|
headers: reqHeaders,
|
|
body: data
|
|
};
|
|
|
|
const callResult = await this.context.spHttpClient.post(this.clientServiceUrl, SPHttpClient.configurations.v1, httpPostOptions);
|
|
this.ensureSuccessfulResponse(callResult, 'Term labels');
|
|
const jsonResult = await callResult.json();
|
|
|
|
const node = jsonResult.find(x => x._ObjectType_ === 'SP.Taxonomy.Term');
|
|
if (node && node.Labels && node.Labels._Child_Items_) {
|
|
result = node.Labels._Child_Items_.map(termLabel => termLabel.Value);
|
|
}
|
|
} catch (error) {
|
|
result = null;
|
|
debugError(this.debug, 'SPTermStorePickerService', 'Error reading term labels.', error);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Gets the collection of term stores in the current SharePoint env
|
|
*/
|
|
public getTermStores(): Promise<ITermStore[]> {
|
|
// Retrieve the term store name, groups, and term sets
|
|
const 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>';
|
|
|
|
const reqHeaders = new Headers();
|
|
reqHeaders.append('accept', 'application/json');
|
|
reqHeaders.append('content-type', 'application/xml');
|
|
|
|
const httpPostOptions: ISPHttpClientOptions = {
|
|
headers: reqHeaders,
|
|
body: data
|
|
};
|
|
|
|
return this.context.spHttpClient.post(this.clientServiceUrl, SPHttpClient.configurations.v1, httpPostOptions).then((serviceResponse: SPHttpClientResponse) => {
|
|
this.ensureSuccessfulResponse(serviceResponse, 'Term stores');
|
|
return serviceResponse.json().then((serviceJSONResponse: any) => {
|
|
// Construct results
|
|
const termStoreResult: ITermStore[] = serviceJSONResponse.filter((r: { [x: string]: string; }) => 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(termstore => {
|
|
let termGroups = termstore.Groups._Child_Items_;
|
|
|
|
// Check if the groups have to be limited to a specific term set
|
|
if (this.props.termsetNameOrID) {
|
|
const termsetNameOrId = this.props.termsetNameOrID;
|
|
termGroups = termGroups.map((group: IGroup) => {
|
|
group.TermSets._Child_Items_ = group.TermSets._Child_Items_.filter((termSet: ITermSet) => termSet.Name === termsetNameOrId || this.cleanGuid(termSet.Id).toLowerCase() === this.cleanGuid(termsetNameOrId).toLowerCase());
|
|
return group;
|
|
});
|
|
}
|
|
|
|
// Filter out all systen groups
|
|
termGroups = termGroups.filter(group => !group.IsSystemGroup);
|
|
|
|
// Filter out empty groups
|
|
termGroups = termGroups.filter((group: IGroup) => 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
|
|
*/
|
|
public async getTermSet(): Promise<ITermSet> {
|
|
const termStore = await this.getTermStores();
|
|
return this.getTermSetId(termStore, this.props.termsetNameOrID);
|
|
}
|
|
|
|
/**
|
|
* Retrieve all terms for the given term set
|
|
* @param termset
|
|
*/
|
|
public async getAllTerms(
|
|
termset: string,
|
|
hideDeprecatedTags?: boolean,
|
|
hideTagsNotAvailableForTagging?: boolean,
|
|
useSessionStorage: boolean = true,
|
|
cacheMinutes: number = 15
|
|
): Promise<ITermSet> {
|
|
let termsetId: string = termset;
|
|
// Check if the provided term set property is a GUID or string
|
|
if (!this.isGuid(termset)) {
|
|
// Fetch the term store information
|
|
const termStore = await this.getTermStores();
|
|
// Get the ID of the provided term set name
|
|
const crntTermSet = this.getTermSetId(termStore, termset);
|
|
if (crntTermSet) {
|
|
termsetId = this.cleanGuid(crntTermSet.Id);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
const childTerms = this.getCachedTermSet(termsetId, useSessionStorage);
|
|
|
|
if (childTerms) {
|
|
return childTerms;
|
|
}
|
|
|
|
// Request body to retrieve all terms for the given term set
|
|
const 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="GetDefaultSiteCollectionTermStore" /><Method Id="6" ParentId="3" Name="GetTermSet"><Parameters><Parameter Type="Guid">${termsetId}</Parameter></Parameters></Method><Method Id="9" ParentId="6" Name="GetAllTerms" /></ObjectPaths></Request>`;
|
|
|
|
const reqHeaders = new Headers();
|
|
reqHeaders.append('accept', 'application/json');
|
|
reqHeaders.append('content-type', 'application/xml');
|
|
|
|
const httpPostOptions: ISPHttpClientOptions = {
|
|
headers: reqHeaders,
|
|
body: data
|
|
};
|
|
|
|
return this.context.spHttpClient.post(this.clientServiceUrl, SPHttpClient.configurations.v1, httpPostOptions).then((serviceResponse: SPHttpClientResponse) => {
|
|
this.ensureSuccessfulResponse(serviceResponse, 'Terms');
|
|
return serviceResponse.json().then((serviceJSONResponse: any) => {
|
|
if (!Array.isArray(serviceJSONResponse)) {
|
|
throw new Error('The taxonomy service returned an unexpected response.');
|
|
}
|
|
const termStoreResultTermSets: ITermSet[] = serviceJSONResponse.filter((r: { [x: string]: string; }) => r['_ObjectType_'] === 'SP.Taxonomy.TermSet');
|
|
|
|
if (termStoreResultTermSets.length > 0) {
|
|
const termStoreResultTermSet = termStoreResultTermSets[0];
|
|
termStoreResultTermSet.Terms = [];
|
|
// Retrieve the term collection results
|
|
const termStoreResultTerms: ITerms[] = serviceJSONResponse.filter((r: { [x: string]: string; }) => r['_ObjectType_'] === 'SP.Taxonomy.TermCollection');
|
|
if (termStoreResultTerms.length > 0) {
|
|
// Retrieve all terms
|
|
let terms = termStoreResultTerms[0]._Child_Items_;
|
|
|
|
if (hideDeprecatedTags === true) {
|
|
terms = terms.filter(d => d.IsDeprecated === false);
|
|
}
|
|
|
|
if (hideTagsNotAvailableForTagging === true) {
|
|
terms = terms.filter(d => d.IsAvailableForTagging === true);
|
|
}
|
|
|
|
// Clean the term ID and specify the path depth
|
|
terms = terms.map(term => {
|
|
if (term.IsRoot) {
|
|
term.CustomSortOrderIndex = (termStoreResultTermSet.CustomSortOrder) ? termStoreResultTermSet.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.Id), Name: termStoreResultTermSet.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.Terms = terms;
|
|
}
|
|
}
|
|
|
|
try {
|
|
if (useSessionStorage && window.sessionStorage) {
|
|
const ttlMinutes: number = this.normalizeCacheMinutes(cacheMinutes);
|
|
const cacheEntry: ITermCacheEntry = {
|
|
expiresAt: Date.now() + ttlMinutes * 60 * 1000,
|
|
value: termStoreResultTermSet
|
|
};
|
|
window.sessionStorage.setItem(TermCachePrefix + termsetId, JSON.stringify(cacheEntry));
|
|
}
|
|
} catch (error) {
|
|
// Do nothing, sometimes "storage quota exceeded" error if too many items
|
|
}
|
|
return termStoreResultTermSet;
|
|
}
|
|
return null;
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Retrieve all terms that starts with the searchText
|
|
* @param searchText
|
|
*/
|
|
public searchTermsByName(searchText: string): Promise<IPickerTerm[]> {
|
|
return this.searchTermsByTermSet(searchText);
|
|
}
|
|
|
|
public async searchTermsByTermId(searchText: string, termId: string): Promise<IPickerTerm[]> {
|
|
const { useSessionStorage } = this.props;
|
|
const childTerms = this.getCachedPickerTerms(termId, useSessionStorage);
|
|
if (childTerms) {
|
|
return this.searchTermsBySearchText(childTerms, searchText);
|
|
} else {
|
|
const {
|
|
termsetNameOrID,
|
|
hideDeprecatedTags,
|
|
hideTagsNotAvailableForTagging
|
|
} = this.props;
|
|
|
|
const terms = await this.getAllTermsByAnchorId(
|
|
termsetNameOrID,
|
|
termId,
|
|
hideDeprecatedTags,
|
|
hideTagsNotAvailableForTagging,
|
|
useSessionStorage);
|
|
|
|
if (terms) {
|
|
return this.searchTermsBySearchText(terms, searchText);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Retrieve all terms for the given term set and anchorId
|
|
*/
|
|
public async getAllTermsByAnchorId(termsetNameOrID: string, anchorId: string, hideDeprecatedTags?: boolean, hideTagsNotAvailableForTagging?: boolean, useSessionStorage: boolean = true): Promise<IPickerTerm[]> {
|
|
|
|
const returnTerms: IPickerTerm[] = [];
|
|
|
|
const childTerms = this.getCachedPickerTerms(anchorId, useSessionStorage);
|
|
if (childTerms) {
|
|
return childTerms;
|
|
}
|
|
|
|
const termSet = await this.getAllTerms(
|
|
termsetNameOrID,
|
|
hideDeprecatedTags,
|
|
hideTagsNotAvailableForTagging,
|
|
useSessionStorage,
|
|
this.props.cacheMinutes
|
|
);
|
|
const terms = termSet.Terms;
|
|
if (anchorId) {
|
|
const anchorTerm = terms.filter(t => t.Id.toLowerCase() === anchorId.toLowerCase()).shift();
|
|
if (anchorTerm) {
|
|
// Append ';' separator, as a suffix to anchor term path.
|
|
const anchorTermPath = `${anchorTerm.PathOfTerm};`;
|
|
const anchorTerms: ITerm[] = terms.filter(t => t.PathOfTerm.substring(0, anchorTermPath.length) === anchorTermPath && t.Id !== anchorTerm.Id);
|
|
|
|
anchorTerms.forEach(term => {
|
|
returnTerms.push(this.convertTermToPickerTerm(term));
|
|
});
|
|
|
|
try {
|
|
if (useSessionStorage && window.sessionStorage) {
|
|
const cacheEntry: IPickerTermCacheEntry = {
|
|
expiresAt: Date.now() + this.normalizeCacheMinutes(this.props.cacheMinutes) * 60 * 1000,
|
|
value: returnTerms
|
|
};
|
|
window.sessionStorage.setItem(PickerCachePrefix + anchorId, JSON.stringify(cacheEntry));
|
|
}
|
|
} catch (error) {
|
|
// Do nothing
|
|
}
|
|
}
|
|
} else {
|
|
terms.forEach(term => {
|
|
returnTerms.push(this.convertTermToPickerTerm(term));
|
|
});
|
|
}
|
|
|
|
return returnTerms;
|
|
}
|
|
|
|
/**
|
|
* Clean the Guid from the Web Service response
|
|
* @param guid
|
|
*/
|
|
public cleanGuid(guid: string): string {
|
|
if (guid !== undefined) {
|
|
return guid.replace('/Guid(', '').replace('/', '').replace(')', '');
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the term set ID by its name
|
|
* @param termstore
|
|
* @param termset
|
|
*/
|
|
private getTermSetId(termstore: ITermStore[], termsetName: string): ITermSet {
|
|
if (termstore && termstore.length > 0 && termsetName) {
|
|
// Get the first term store
|
|
const ts = termstore[0];
|
|
// Check if the term store contains groups
|
|
if (ts.Groups && ts.Groups._Child_Items_) {
|
|
for (const group of ts.Groups._Child_Items_) {
|
|
// Check if the group contains term sets
|
|
if (group.TermSets && group.TermSets._Child_Items_) {
|
|
for (const termSet of group.TermSets._Child_Items_) {
|
|
// Check if the term set is found
|
|
if (termSet.Name === termsetName) {
|
|
return termSet;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private getCachedTermSet(termId: string, useSessionStorage: boolean = true): ITermSet {
|
|
try {
|
|
if (useSessionStorage && window.sessionStorage) {
|
|
const key: string = TermCachePrefix + termId;
|
|
const terms: string = window.sessionStorage.getItem(key);
|
|
if (!terms) {
|
|
return null;
|
|
}
|
|
|
|
const cacheEntry: ITermCacheEntry = JSON.parse(terms) as ITermCacheEntry;
|
|
if (!cacheEntry || !cacheEntry.value || !cacheEntry.expiresAt || cacheEntry.expiresAt <= Date.now()) {
|
|
window.sessionStorage.removeItem(key);
|
|
return null;
|
|
}
|
|
return cacheEntry.value;
|
|
} else {
|
|
return null;
|
|
}
|
|
} catch (error) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private getCachedPickerTerms(termId: string, useSessionStorage: boolean = true): IPickerTerm[] {
|
|
try {
|
|
if (!useSessionStorage || !window.sessionStorage) {
|
|
return null;
|
|
}
|
|
|
|
const key: string = PickerCachePrefix + termId;
|
|
const serialized: string = window.sessionStorage.getItem(key);
|
|
if (!serialized) {
|
|
return null;
|
|
}
|
|
|
|
const cacheEntry: IPickerTermCacheEntry = JSON.parse(serialized) as IPickerTermCacheEntry;
|
|
if (!cacheEntry || !cacheEntry.value || !cacheEntry.expiresAt || cacheEntry.expiresAt <= Date.now()) {
|
|
window.sessionStorage.removeItem(key);
|
|
return null;
|
|
}
|
|
return cacheEntry.value;
|
|
} catch (error) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private normalizeCacheMinutes(value: number): number {
|
|
if (typeof value !== 'number' || !isFinite(value)) {
|
|
return 15;
|
|
}
|
|
return Math.min(Math.max(Math.floor(value), 1), 1440);
|
|
}
|
|
|
|
private ensureSuccessfulResponse(response: SPHttpClientResponse, operation: string): void {
|
|
if (!response.ok) {
|
|
throw new Error(operation + ' request failed (' + response.status + ' ' + response.statusText + ').');
|
|
}
|
|
}
|
|
|
|
private searchTermsBySearchText(terms, searchText) {
|
|
if (terms) {
|
|
return terms.filter((t) => { return t.name.toLowerCase().indexOf(searchText.toLowerCase()) > -1; });
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Searches terms for the given term set
|
|
* @param searchText
|
|
* @param termsetId
|
|
*/
|
|
private searchTermsByTermSet(searchText: string): Promise<IPickerTerm[]> {
|
|
return new Promise<IPickerTerm[]>(resolve => {
|
|
this.getTermStores().then(termStore => {
|
|
let termSetId = this.props.termsetNameOrID;
|
|
if (!this.isGuid(termSetId)) {
|
|
// Get the ID of the provided term set name
|
|
const 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;
|
|
}
|
|
const loc: number = this.context.pageContext.cultureInfo.currentUICultureName === 'de-de' ? 1031 : 1033;
|
|
const data: any = {
|
|
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
|
|
};
|
|
|
|
const reqHeaders: Headers = new Headers();
|
|
reqHeaders.append('accept', 'application/json');
|
|
reqHeaders.append('content-type', 'application/json');
|
|
|
|
const httpPostOptions: ISPHttpClientOptions = {
|
|
headers: reqHeaders,
|
|
body: JSON.stringify(data)
|
|
};
|
|
|
|
return this.context.spHttpClient.post(this.suggestionServiceUrl, SPHttpClient.configurations.v1, httpPostOptions).then((serviceResponse: SPHttpClientResponse) => {
|
|
return serviceResponse.json().then((serviceJSONResponse: any) => {
|
|
const groups = serviceJSONResponse.d.Groups;
|
|
if (groups && groups.length > 0) {
|
|
// Retrieve the term collection results
|
|
const terms: ISuggestTerm[] = groups[0].Suggestions;
|
|
if (terms.length > 0) {
|
|
// Retrieve all terms
|
|
|
|
const returnTerms: IPickerTerm[] = terms.map((term: ISuggestTerm) => this.convertSuggestTermToPickerTerm(term));
|
|
resolve(returnTerms);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
resolve([]);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
private isGuid(strGuid: string): boolean {
|
|
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
|
|
*/
|
|
private sortTerms(terms: ITerm[]) {
|
|
// Start sorting by depth
|
|
let newTermsOrder: ITerm[] = [];
|
|
let itemsToSort: boolean = true;
|
|
let pathLevel: number = 1;
|
|
while (itemsToSort) {
|
|
// Get terms for the current level
|
|
let crntTerms = terms.filter(term => term.PathDepth === pathLevel);
|
|
if (crntTerms && crntTerms.length > 0) {
|
|
crntTerms = crntTerms.sort(this.sortTermByPath);
|
|
|
|
if (pathLevel !== 1) {
|
|
crntTerms = crntTerms.reverse();
|
|
for (const crntTerm of crntTerms) {
|
|
const pathElms: string[] = crntTerm.PathOfTerm.split(';');
|
|
// Last item is not needed for parent path
|
|
pathElms.pop();
|
|
// Find the parent item and add the new item
|
|
const idx: number = findIndex(newTermsOrder, term => 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);
|
|
}
|
|
}
|
|
} else {
|
|
newTermsOrder = crntTerms;
|
|
}
|
|
|
|
++pathLevel;
|
|
} else {
|
|
itemsToSort = false;
|
|
}
|
|
}
|
|
return newTermsOrder;
|
|
}
|
|
|
|
/**
|
|
* Sort the terms by their path
|
|
*
|
|
* @param a term 2
|
|
* @param b term 2
|
|
*/
|
|
private sortTermByPath(a: ITerm, b: ITerm) {
|
|
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;
|
|
}
|
|
}
|
|
|
|
private convertTermToPickerTerm(term: ITerm): IPickerTerm {
|
|
return {
|
|
key: this.cleanGuid(term.Id),
|
|
name: term.Name,
|
|
path: term.PathOfTerm,
|
|
termSet: this.cleanGuid(term.TermSet.Id),
|
|
termSetName: term.TermSet.Name
|
|
};
|
|
}
|
|
|
|
private convertSuggestTermToPickerTerm(term: ISuggestTerm): IPickerTerm {
|
|
let path: string = '';
|
|
let termSetName: string = '';
|
|
if (term.Paths && term.Paths.length > 0) {
|
|
const fullPath: string = term.Paths[0].replace(/^\[/, '').replace(/\]$/, '');
|
|
const fullPathParts: string[] = fullPath.split(':');
|
|
path = fullPathParts.join(';') + ';' + term.DefaultLabel;
|
|
termSetName = fullPathParts[0];
|
|
}
|
|
return {
|
|
key: this.cleanGuid(term.Id),
|
|
name: term.DefaultLabel,
|
|
path: path,
|
|
termSet: EmptyGuid, // TermSet Guid is not given with suggestion
|
|
termSetName: termSetName
|
|
};
|
|
}
|
|
}
|