import { OldGeneratedCatalogBaseCardDataAppConnection } from './old-generated-catalog-base.card.app.connection.js';
|
import { CardFetchMethod, FilterSelectionStrategy, CardContainerUpdate } from './card-container-definitions.js';
|
import { CardContainerBackToStartEvent, CardContainerTriggerCardClickEvent } from './card-container-events.js';
|
import { CardDataUpdateEvent } from './card-data-service-update-events.js';
|
import { CardDataService } from './card.data.service.js';
|
import { U as UtilService } from './modal.component-7c440789.js';
|
import './base.card.app.connection.js';
|
import './catalog.service.js';
|
import './manu-prog.service.js';
|
import './query-assigned-elements-fea1f631.js';
|
import './custom-element-30fc6381.js';
|
import './base.component-813fc7cf.js';
|
import '@dh-software/furnview-icons';
|
import './class-map-a0fb5d87.js';
|
import './event.handler.model.js';
|
import './loading.component.js';
|
import './dimmer.component.js';
|
import './query-1c86d710.js';
|
import './dot-flashing-loader.component.js';
|
import './rotating-dots-loader.component.js';
|
import './key-frame-effect.service.js';
|
import './toolbar.component.js';
|
import './toggle-toolbar.component.js';
|
import './style.helper.js';
|
import './image.service.js';
|
import './svg-icon.component.js';
|
import './popup.component.js';
|
import './popup-closer.component.js';
|
import './hr-item.component.js';
|
import './hr-list.component.js';
|
import './query-all-828de4b2.js';
|
import './hr-theme.model.js';
|
import './configurator.form.component.js';
|
import './configurator.form.base.element.component.js';
|
import './scene-helper.service.js';
|
import './async.base.component.js';
|
import './card-container-settings.js';
|
import './card-container-states.js';
|
import './card-container-additional-data.js';
|
import './card-containers-shared-data.js';
|
import './input.mask.component.js';
|
import './mask.component.js';
|
import './information.mask.component.js';
|
import './open-cloud-id.mask.component.js';
|
import './share-link-per-mail.component.js';
|
import './request-appointment.component.js';
|
import './prog-property.model.js';
|
import './interface.js';
|
import './reset.mask.component.js';
|
import './configuration.service.js';
|
import './step-based.mask.component.js';
|
import './container-mask.component.js';
|
import './messageNoCalc.mask.component.js';
|
import './button.component.js';
|
import './iwoFurn.mask.component.js';
|
import './input.component.js';
|
import './base-input.js';
|
import './save-dialog.mask.component.js';
|
import './cloud-id.service.js';
|
import './send-offer-request-mask.component.js';
|
import './file-upload-mask.component.js';
|
import './label.component.js';
|
import './sass.default-1ca9b57f.js';
|
import './accordion.component.js';
|
import './accordion-item.component.js';
|
import './accordion-layer.component.js';
|
import './slider.component.js';
|
import './equipment-list.component.js';
|
import './state-7ee0cf4f.js';
|
import './confirming-button.component.js';
|
import './fitting-item.component.js';
|
import './proptrans-item.component.js';
|
import './shoppingcart-item.component.js';
|
import './prog-context.model.js';
|
import './step-child.component.js';
|
import './clock.controller.js';
|
|
var __async = (__this, __arguments, generator) => {
|
return new Promise((resolve, reject) => {
|
var fulfilled = (value) => {
|
try {
|
step(generator.next(value));
|
} catch (e) {
|
reject(e);
|
}
|
};
|
var rejected = (value) => {
|
try {
|
step(generator.throw(value));
|
} catch (e) {
|
reject(e);
|
}
|
};
|
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
|
step((generator = generator.apply(__this, __arguments)).next());
|
});
|
};
|
class KataPageSelectionCardAppConnection extends OldGeneratedCatalogBaseCardDataAppConnection {
|
constructor() {
|
super();
|
this.previousLastSelectedElement = void 0;
|
this.lastSelectionChangeTime = void 0;
|
this.selectionChangePromise = void 0;
|
this.CheckPageForCategoryCombnation = (articles, categories) => {
|
for (const article of articles) {
|
let includes = true;
|
for (const category of categories) {
|
if (article.CatString.includes(category) == false) {
|
includes = false;
|
break;
|
}
|
}
|
if (includes) {
|
return true;
|
}
|
}
|
return false;
|
};
|
this.AppendLevel = (levels, level, key, name) => {
|
if (level.length > 0) {
|
const existingLevel = levels.get(key);
|
if (existingLevel) {
|
for (const card of level) {
|
if (existingLevel.data.includes(card) == false) {
|
existingLevel.data.push(card);
|
}
|
}
|
return;
|
}
|
levels.set(key, {
|
data: level,
|
name
|
});
|
}
|
};
|
this.Method = CardFetchMethod.KataPageSelection;
|
}
|
CheckUpdate(event, eventParameters, context) {
|
return __async(this, null, function* () {
|
switch (event) {
|
case CardDataUpdateEvent.SelectionChanged:
|
return CardContainerUpdate.FILTER;
|
case CardDataUpdateEvent.LastPOLoaded:
|
return CardContainerUpdate.FILTER;
|
default:
|
return CardContainerUpdate.NONE;
|
}
|
});
|
}
|
_InteractionOnSelectionChangeCheckLevel(level, plannedArticleNumber) {
|
if (level.additional && level.additional["articles-by-level-key"]) {
|
const keys = Object.keys(level.additional["articles-by-level-key"]);
|
for (const key of keys) {
|
const aricles = level.additional["articles-by-level-key"][key];
|
let articleInList = false;
|
for (const article of aricles) {
|
if (article.ArtNr == plannedArticleNumber) {
|
articleInList = true;
|
break;
|
}
|
}
|
if (articleInList) {
|
return key;
|
}
|
}
|
}
|
return "";
|
}
|
_InteractionOnSelectionChangePromisified(context, eventParameters) {
|
return __async(this, null, function* () {
|
const triggerTime = Date.now();
|
const lastSelectedElement = eventParameters.objectInfo[eventParameters.objectInfo.length - 1];
|
if (lastSelectedElement == void 0)
|
return;
|
if (this.previousLastSelectedElement != void 0) {
|
if (this.lastSelectionChangeTime != void 0 && triggerTime - this.lastSelectionChangeTime < 1e3) {
|
if (this.previousLastSelectedElement == lastSelectedElement.instanceIdent)
|
return;
|
}
|
}
|
this.previousLastSelectedElement = lastSelectedElement.instanceIdent;
|
this.lastSelectionChangeTime = triggerTime;
|
if (this.selectionChangePromise != void 0) {
|
yield this.selectionChangePromise;
|
}
|
this.selectionChangePromise = new Promise((resolve) => {
|
CommunicationMessageService.getPlannedArticles([lastSelectedElement.instanceIdent]).then((articles) => __async(this, null, function* () {
|
if (context.cards == void 0)
|
return;
|
let katapageToOpen = "";
|
const root = context.cards.get(context.settings.Fetch["root-level"]);
|
if (root && root.additional) {
|
katapageToOpen = this._InteractionOnSelectionChangeCheckLevel(root, articles[0].catalogArticleNumber);
|
}
|
if (katapageToOpen === "") {
|
for (const card of context.cards) {
|
if (card[0] == context.settings.Fetch["root-level"])
|
continue;
|
katapageToOpen = this._InteractionOnSelectionChangeCheckLevel(card[1], articles[0].catalogArticleNumber);
|
}
|
}
|
if (katapageToOpen) {
|
context.dispatchEvent(new CardContainerBackToStartEvent(() => __async(this, null, function* () {
|
context.dispatchEvent(new CardContainerTriggerCardClickEvent([katapageToOpen]));
|
yield CardDataService.WaitForAllCardContainerFetchPromises();
|
resolve();
|
this.selectionChangePromise = void 0;
|
})));
|
}
|
}));
|
});
|
});
|
}
|
InteractionOnSelectionChange(context, eventParameters) {
|
this._InteractionOnSelectionChangePromisified(context, eventParameters);
|
}
|
Fetch(context) {
|
var __superGet = (key) => super[key];
|
return __async(this, null, function* () {
|
const result = yield __superGet("Fetch").call(this, context);
|
if (result["kata-tree"] == void 0)
|
return result;
|
if (result["kata-tree"].kataPages == void 0) {
|
console.error("kata page selection> katatree does not have the kataPages node!", result["kata-tree"]);
|
return result;
|
}
|
if (result["kata-pages"].size < 1)
|
return result;
|
const levels = new Map();
|
for (const kataPageCategory of result["kata-tree"].kataPages) {
|
if (kataPageCategory.id.includes("dhcat_") == false)
|
continue;
|
if (context.settings.Fetch.parameters && context.settings.Fetch.parameters["categories-to-hide"]) {
|
let categoriesToHide = [];
|
if (Array.isArray(context.settings.Fetch.parameters["categories-to-hide"]))
|
categoriesToHide = context.settings.Fetch.parameters["categories-to-hide"];
|
else {
|
Object.keys(context.settings.Fetch.parameters["categories-to-hide"]).forEach((key2) => {
|
categoriesToHide.push(...context.settings.Fetch.parameters["categories-to-hide"][key2]);
|
});
|
}
|
if (categoriesToHide.includes(kataPageCategory.id))
|
continue;
|
}
|
const page = result["kata-pages"].get(kataPageCategory.id);
|
if (page == void 0)
|
continue;
|
const articles = page.Modules[0].Articles[0];
|
if (articles == void 0)
|
continue;
|
if (kataPageCategory.children) {
|
const prioUnsortedLevelsData = new Map();
|
kataPageCategory.children.forEach((child) => {
|
const existing2 = prioUnsortedLevelsData.get(child.priority);
|
if (existing2) {
|
if (existing2.includes(child) == false) {
|
existing2.push(child);
|
}
|
} else {
|
prioUnsortedLevelsData.set(child.priority, [child]);
|
}
|
});
|
const prioSortedLevelsData = new Map([...prioUnsortedLevelsData].sort());
|
const prioSortedLevelsDataKeys = new Array();
|
prioSortedLevelsData.forEach((levelData, key2) => {
|
prioSortedLevelsDataKeys.push(key2);
|
});
|
for (let levelsDataKeyIndex = 0; levelsDataKeyIndex < prioSortedLevelsDataKeys.length; ++levelsDataKeyIndex) {
|
const levelData = prioSortedLevelsData.get(prioSortedLevelsDataKeys[levelsDataKeyIndex]);
|
if (levelData == void 0)
|
continue;
|
const nextLevelData = levelsDataKeyIndex < prioSortedLevelsDataKeys.length - 1 ? prioSortedLevelsData.get(prioSortedLevelsDataKeys[levelsDataKeyIndex + 1]) : void 0;
|
const previousLevelData = levelsDataKeyIndex > 0 ? prioSortedLevelsData.get(prioSortedLevelsDataKeys[levelsDataKeyIndex - 1]) : void 0;
|
const nextLevelKeys = new Array();
|
if (nextLevelData) {
|
nextLevelData.forEach((cardData) => {
|
nextLevelKeys.push(cardData.id);
|
});
|
}
|
const previousLevels = new Array();
|
if (previousLevelData) {
|
previousLevelData.forEach((cardData) => {
|
previousLevels.push({ id: cardData.id, name: cardData.name });
|
});
|
}
|
if (previousLevels.length > 0) {
|
for (const previousLevel of previousLevels) {
|
const level = new Array();
|
levelData.forEach((cardData) => {
|
const categories = [cardData.id, kataPageCategory.id, previousLevel.id];
|
const validNextLevelCategories = new Array();
|
for (const nextLevelKey of nextLevelKeys) {
|
const checkCategories = new Array(...categories);
|
checkCategories.push(nextLevelKey);
|
if (this.CheckPageForCategoryCombnation(articles, checkCategories)) {
|
validNextLevelCategories.push(nextLevelKey);
|
}
|
}
|
if (this.CheckPageForCategoryCombnation(articles, categories)) {
|
const card = cardData;
|
card["next-level"] = validNextLevelCategories.length > 0 ? cardData.id : "";
|
level.push(card);
|
}
|
});
|
if (level.length > 0) {
|
this.AppendLevel(levels, level, previousLevel.id, previousLevel.name);
|
}
|
}
|
} else {
|
const level = new Array();
|
levelData.forEach((cardData) => {
|
const categories = [cardData.id, kataPageCategory.id];
|
const validNextLevelCategories = new Array();
|
for (const nextLevelKey of nextLevelKeys) {
|
const checkCategories = new Array(...categories);
|
checkCategories.push(nextLevelKey);
|
if (this.CheckPageForCategoryCombnation(articles, checkCategories)) {
|
validNextLevelCategories.push(nextLevelKey);
|
}
|
}
|
if (this.CheckPageForCategoryCombnation(articles, categories)) {
|
const card = cardData;
|
card["next-level"] = validNextLevelCategories.length > 0 ? cardData.id : "";
|
level.push(card);
|
}
|
});
|
if (level.length > 0) {
|
this.AppendLevel(levels, level, kataPageCategory.id, kataPageCategory.name);
|
}
|
}
|
}
|
}
|
const categoryDataInternal = kataPageCategory;
|
categoryDataInternal["next-level"] = kataPageCategory.id;
|
const existing = levels.get(context.settings.Fetch["root-level"]);
|
if (existing) {
|
if (existing.data.includes(categoryDataInternal) == false) {
|
existing.data.push(categoryDataInternal);
|
}
|
} else {
|
levels.set(context.settings.Fetch["root-level"], { data: [categoryDataInternal], name: context.settings.Fetch["root-level"] });
|
}
|
}
|
result["levels-data"] = levels;
|
return result;
|
});
|
}
|
Filter(unfiltered, context, active) {
|
const filtered = {
|
"kata-tree": unfiltered["kata-tree"] || [],
|
"kata-pages": unfiltered["kata-pages"] || [],
|
"levels-data": unfiltered["levels-data"] || [],
|
"active-keys": new Array(),
|
"articles": unfiltered["articles"]
|
};
|
filtered["active-keys"] = active;
|
const sorted = new Map([...filtered["levels-data"]].sort());
|
filtered["levels-data"] = new Map();
|
if (context.settings.Fetch.filter["level-key-filter"] == void 0 || context.settings.Fetch.filter["level-key-filter"].length < 1) {
|
filtered["levels-data"] = sorted;
|
return filtered;
|
}
|
for (const level of sorted) {
|
if (context.settings.Fetch.filter["level-key-filter"].includes(level[0])) {
|
filtered["levels-data"].set(level[0], level[1]);
|
}
|
}
|
return filtered;
|
}
|
GetRelevantArticles(articles, katapageLevelKey) {
|
const relevantArticles = new Array();
|
const levelKeyString = typeof katapageLevelKey == "number" ? katapageLevelKey.toFixed(0) : katapageLevelKey;
|
for (const article of articles) {
|
if (article.CatString.includes(levelKeyString)) {
|
relevantArticles.push(article);
|
}
|
}
|
return relevantArticles;
|
}
|
CreateCards(filtered, context) {
|
const result = new Map();
|
if (filtered["levels-data"] == void 0)
|
return result;
|
for (const kataPage of filtered["levels-data"]) {
|
const level = { title: kataPage[1].name, cards: new Array() };
|
level.additional = { "articles-by-level-key": {} };
|
for (const cardData of kataPage[1].data) {
|
if (kataPage[0] == cardData["next-level"])
|
continue;
|
if (level.additional["articles-by-level-key"]) {
|
level.additional["articles-by-level-key"][cardData.id] = this.GetRelevantArticles(filtered["articles"], cardData.id);
|
}
|
const cardDataParameters = context.settings.Fetch.parameters[cardData.id];
|
const imagePrefix = cardDataParameters && cardDataParameters.prefix ? cardDataParameters.prefix : "";
|
const imageFile = cardDataParameters && cardDataParameters.file ? cardDataParameters.file : "";
|
level.cards.push({
|
txt: { title: UtilService.ncrToUTF8(cardData.name) },
|
click: {
|
"previous-level-key": kataPage[0],
|
"level-key": cardData.id,
|
strategy: FilterSelectionStrategy.AND,
|
priority: cardData.priority,
|
"next-level-key": cardData["next-level"]
|
},
|
image: {
|
prefix: imagePrefix,
|
file: imageFile
|
},
|
active: context.settings.Fetch.parameters["selection-result-filter-is-last-clicked"] ? filtered["active-keys"].includes(cardData.id) : void 0
|
});
|
}
|
result.set(kataPage[0], level);
|
}
|
return result;
|
}
|
Click(card, context) {
|
return __async(this, null, function* () {
|
if (context.settings.Fetch.parameters["selection-result-filter-is-last-clicked"] == void 0)
|
return;
|
if (context.filter == void 0)
|
return;
|
if (card.click == void 0)
|
return;
|
if (context.filter.Contains(card.click["level-key"])) {
|
context.filter.Remove(card.click["level-key"]);
|
} else {
|
context.filter.Reset(false, context);
|
context.filter.Add(card.click["level-key"]);
|
}
|
return;
|
});
|
}
|
}
|
CardDataService.RegisterAppConnection(new KataPageSelectionCardAppConnection());
|
