d2aura 26.0.13 → 26.0.15

package/coreui/components/edaManagerComponent/utils/export.js

@@ -0,0 +1,570 @@
+import { create } from "xmlbuilder";
+import { EdaSamplingType, EdaVectorType } from "../constants/edaTypes";
+import dayjs from "d2core/dayjs";
+import i18n from "d2core/i18n/i18n";
+export async function exportVector(api, vector, config, dateTimeMask, setLoadingState, message) {
+    const resultData = [];
+    const root = create('vektor', { version: '1.0', encoding: 'UTF-8' });
+    let pairVector;
+    setLoadingState((s) => ({ ...s, loadingItem: vector.data.ZOBRAZ_MENO }));
+    if (vector.data.TYP === EdaVectorType.Pair) {
+        try {
+            const pairVectors = (await api.loadPairVectorData(vector.data.ID_VEKTOR)).data;
+            pairVector = pairVectors.length > 0 ? pairVectors[0] : undefined;
+        }
+        catch (e) {
+            message.error(String(e));
+        }
+    }
+    root.att("meno", vector.data.MENO);
+    root.att("id_vektor", vector.data.ID_VEKTOR);
+    root.att("typ", vector.data.TYP);
+    root.att("autor", vector.data.AUTOR);
+    root.att("private", vector.data.PRIVATE);
+    root.att("integral", vector.data.INTEGRAL);
+    root.att("zobraz_meno", vector.data.ZOBRAZ_MENO);
+    root.att("view_round", vector.data.VIEW_ROUND);
+    root.att("exec_round", vector.data.EXEC_ROUND);
+    root.att("view_dec_pl", vector.data.VIEW_DEC_PL);
+    root.att("exec_dec_pl", vector.data.EXEC_DEC_PL);
+    if (vector.data.POPIS !== undefined) {
+        root.att("popis", vector.data.POPIS);
+    }
+    if (vector.data.TYP !== EdaVectorType.Pair && vector.data.TECH_JEDNOTKY !== undefined) {
+        root.att("tech_jednotky", vector.data.TECH_JEDNOTKY);
+    }
+    if (vector.data.TYP === EdaVectorType.Pair && pairVector?.TECH_JEDNOTKY !== undefined) {
+        root.att("tech_jednotky", pairVector?.TECH_JEDNOTKY);
+    }
+    if (vector.data.TYP === EdaVectorType.Pair && pairVector?.TECH_JEDNOTKY_Y !== undefined) {
+        root.att("tech_jednotky", pairVector?.TECH_JEDNOTKY_Y);
+    }
+    if (vector.data.TYP_HODNOTY !== undefined) {
+        root.att("typ_hodnoty", vector.data.TYP_HODNOTY);
+    }
+    if (vector.data.PRIST_PRAVA_R !== undefined) {
+        root.att("prist_prava_r", vector.data.PRIST_PRAVA_R);
+    }
+    if (vector.data.PRIST_PRAVA_W !== undefined) {
+        root.att("prist_prava_w", vector.data.PRIST_PRAVA_W);
+    }
+    if (vector.data.MENOEX !== ".") {
+        root.att("menoex", vector.data.MENOEX);
+    }
+    if (vector.data.TIME_ZONE !== undefined) {
+        root.att("time_zone_offset", vector.data.TIME_ZONE);
+    }
+    if (vector.data.USER_CH !== undefined) {
+        root.att("user_ch", vector.data.USER_CH);
+    }
+    if (vector.data.DATA_OFFSET !== undefined) {
+        root.att("data_offset", vector.data.DATA_OFFSET);
+    }
+    if (vector.data.ID_TABLESPACE !== undefined) {
+        root.att("id_tablespace", vector.data.ID_TABLESPACE);
+    }
+    if (vector.data.VERSIONED_SINCE !== undefined) {
+        root.att("versioned_since", vector.data.VERSIONED_SINCE);
+    }
+    if (vector.data.ARCHIVE_NAME !== undefined) {
+        root.att("archive_name", vector.data.ARCHIVE_NAME);
+    }
+    if (vector.data.ARCHIVE_ROW !== undefined) {
+        root.att("archive_row", vector.data.ARCHIVE_ROW);
+    }
+    if (vector.data.ARCHIVE_COL !== undefined) {
+        root.att("archive_col", vector.data.ARCHIVE_COL);
+    }
+    if (vector.data.STATUS_TEXT !== undefined) {
+        root.att("status_text", vector.data.STATUS_TEXT);
+    }
+    if (vector.data.LOG_ACCESS !== undefined) {
+        root.att("log_access", vector.data.LOG_ACCESS);
+    }
+    if (vector.data.INTERVAL_STABLE !== undefined) {
+        root.att("interval_stable", vector.data.INTERVAL_STABLE);
+    }
+    if (vector.data.PERIOD_BEGIN_TIME !== undefined) {
+        root.att("period_begin_time", dayjs(vector.data.PERIOD_BEGIN_TIME).format(dateTimeMask));
+    }
+    if (vector.data.PERIOD_STEP_BASE !== undefined) {
+        root.att("period_step_base", vector.data.PERIOD_STEP_BASE);
+    }
+    if (vector.data.PERIOD_STEP_COUNT !== undefined) {
+        root.att("period_step_count", vector.data.PERIOD_STEP_COUNT);
+    }
+    if (vector.data.ID_VALIDATOR !== undefined) {
+        root.att("id_validator", vector.data.ID_VALIDATOR);
+    }
+    if (vector.data.ID_MASTER_ENTITY !== undefined) {
+        root.att("id_master_entity", vector.data.ID_MASTER_ENTITY);
+    }
+    if (vector.data.TYP === EdaVectorType.Pair && pairVector?.HODNOTA_X !== undefined) {
+        root.att("hodnota_x", pairVector?.HODNOTA_X);
+    }
+    if (vector.data.TYP === EdaVectorType.Pair && pairVector?.HODNOTA_Y !== undefined) {
+        root.att("hodnota_y", pairVector?.HODNOTA_Y);
+    }
+    if (config.exportValues && [EdaVectorType.FifteenMinutes, EdaVectorType.Hour, EdaVectorType.Day, EdaVectorType.Change].includes(vector.data.TYP)) {
+        resultData.push(...await exportSpecifiedVector(api, vector, config, dateTimeMask, setLoadingState, message));
+    }
+    if (config.exportValues && [EdaVectorType.Descriptive, EdaVectorType.Interval].includes(vector.data.TYP)) {
+        await exportDescriptiveVector(root, api, vector, dateTimeMask, message);
+    }
+    if ([EdaVectorType.FifteenMinutesCalc, EdaVectorType.HourCalc, EdaVectorType.DayCalc, EdaVectorType.ChangeCalc].includes(vector.data.TYP)) {
+        await exportCalcVector(root, api, vector, message);
+    }
+    if (vector.data.TYP === EdaVectorType.Pair) {
+        await exportPairVector(root, api, vector, config, dateTimeMask, message);
+    }
+    root.dtd({ pubID: '' });
+    resultData.push([`vekt_${vector.data.MENO}`, root.end({ pretty: true })]);
+    return resultData;
+}
+export async function exportGroup(api, group, config, dateTimeMask, setLoadingState, message) {
+    const resultData = [];
+    const root = create('skupina', { version: '1.0', encoding: 'UTF-8' });
+    root.att("meno", group.data.MENO);
+    root.att("id_skvektor", group.data.ID_SKVEKTOR);
+    root.att("autor", group.data.AUTOR);
+    root.att("zobraz_meno", group.data.ZOBRAZ_MENO);
+    root.att("private", group.data.PRIVATE);
+    if (group.data.POPIS !== undefined) {
+        root.att("popis", group.data.POPIS);
+    }
+    if (group.data.PRIST_PRAVA_R !== undefined) {
+        root.att("prist_prava_r", group.data.PRIST_PRAVA_R);
+    }
+    if (group.data.PRIST_PRAVA_W !== undefined) {
+        root.att("prist_prava_w", group.data.PRIST_PRAVA_W);
+    }
+    if (group.data.USERINPUTFLAG !== undefined) {
+        root.att("userinputflag", group.data.USERINPUTFLAG);
+    }
+    if (config.exportSubgroups) {
+        setLoadingState((s) => ({ ...s, loadingPercentage: 0, loadingItem: i18n("Loading subgroups") }));
+        let offset = 0;
+        let totalItems = 0;
+        let firstPage;
+        try {
+            firstPage = await api.getGroupChildren(group.data.ID_SKVEKTOR);
+        }
+        catch (e) {
+            message.error(String(e));
+            return [];
+        }
+        for (let item of firstPage.items) {
+            resultData.push(...await exportSubGroup(api, item, root, config, dateTimeMask, setLoadingState, message));
+        }
+        if (firstPage.leftCount > 0) {
+            totalItems = firstPage.items.length + firstPage.leftCount;
+            offset += firstPage.items.length;
+            while (offset < totalItems) {
+                let page;
+                setLoadingState((s) => ({ ...s, loadingPercentage: (offset / totalItems) * 100 }));
+                try {
+                    page = await api.getGroupChildren(group.data.ID_SKVEKTOR, offset);
+                }
+                catch (e) {
+                    message.error(String(e));
+                    break;
+                }
+                for (let item of page.items) {
+                    resultData.push(...await exportSubGroup(api, item, root, config, dateTimeMask, setLoadingState, message));
+                }
+                offset += page.items.length;
+            }
+        }
+    }
+    {
+        setLoadingState((s) => ({ ...s, loadingPercentage: 0, loadingItem: i18n("Loading vectors") }));
+        let offset = 0;
+        let totalItems = 0;
+        let firstPage;
+        try {
+            firstPage = await api.getGroupVectors(group.data.ID_SKVEKTOR);
+        }
+        catch (e) {
+            message.error(String(e));
+            return [];
+        }
+        for (let item of firstPage.items) {
+            resultData.push(...await exportSubVector(api, item, root, config, dateTimeMask, setLoadingState, message));
+        }
+        if (firstPage.leftCount > 0) {
+            totalItems = firstPage.items.length + firstPage.leftCount;
+            offset += firstPage.items.length;
+            while (offset < totalItems) {
+                let page;
+                setLoadingState((s) => ({ ...s, loadingPercentage: (offset / totalItems) * 100 }));
+                try {
+                    page = await api.getGroupVectors(group.data.ID_SKVEKTOR, offset);
+                }
+                catch (e) {
+                    message.error(String(e));
+                    break;
+                }
+                for (let item of page.items) {
+                    resultData.push(...await exportSubVector(api, item, root, config, dateTimeMask, setLoadingState, message));
+                }
+                offset += page.items.length;
+            }
+        }
+    }
+    root.dtd({ pubID: '' });
+    resultData.push([`skup_${group.data.MENO}`, root.end({ pretty: true })]);
+    return resultData;
+}
+export async function exportScenario(api, scenario, config, dateTimeMask, setLoadingState, message) {
+    const resultData = [];
+    const root = create('scenar', { version: '1.0', encoding: 'UTF-8' });
+    root.att("meno", scenario.data.MENO);
+    root.att("autor", scenario.data.AUTOR);
+    root.att("zobraz_meno", scenario.data.ZOBRAZ_MENO);
+    root.att("private", scenario.data.PRIVATE);
+    root.att("ano_diagram", scenario.data.ANO_DIAGRAM);
+    if (scenario.data.POPIS !== undefined) {
+        root.att("popis", scenario.data.POPIS);
+    }
+    if (scenario.data.CAS_DLZKA !== undefined) {
+        root.att("cas_dlzka", scenario.data.CAS_DLZKA);
+    }
+    if (scenario.data.CAS_POSUN !== undefined) {
+        root.att("cas_posun", scenario.data.CAS_POSUN);
+    }
+    if (scenario.data.CAS_JEMNOST !== undefined) {
+        root.att("cas_posun", scenario.data.CAS_JEMNOST);
+    }
+    if (scenario.data.PRIST_PRAVA_R !== undefined) {
+        root.att("prist_prava_r", scenario.data.PRIST_PRAVA_R);
+    }
+    if (scenario.data.PRIST_PRAVA_W !== undefined) {
+        root.att("prist_prava_w", scenario.data.PRIST_PRAVA_W);
+    }
+    if (scenario.data.FILTER !== undefined) {
+        root.att("filter", scenario.data.FILTER);
+    }
+    if (scenario.data.FILTER_USER !== undefined) {
+        root.att("filter_user", scenario.data.FILTER_USER);
+    }
+    if (scenario.data.FILTER_TYP !== undefined) {
+        root.att("filter_typ", scenario.data.FILTER_TYP);
+    }
+    if (scenario.data.DIAGRAM !== undefined) {
+        root.att("diagram", scenario.data.DIAGRAM);
+    }
+    if (scenario.data.ANO_ZMENA !== undefined) {
+        root.att("ano_zmena", scenario.data.ANO_ZMENA);
+    }
+    if (scenario.data.ANO_GRAFXY !== undefined) {
+        root.att("ano_grafxy", scenario.data.ANO_GRAFXY);
+    }
+    if (scenario.data.ANO_MATICA !== undefined) {
+        root.att("ano_matica", scenario.data.ANO_MATICA);
+    }
+    if (scenario.data.ANO_PAIR !== undefined) {
+        root.att("ano_matica", scenario.data.ANO_PAIR);
+    }
+    if (config.exportSubgroups) {
+        setLoadingState((s) => ({ ...s, loadingPercentage: 0, loadingItem: i18n("Loading subscenarios") }));
+        let offset = 0;
+        let totalItems = 0;
+        let firstPage;
+        try {
+            firstPage = await api.getScenarioChildren(scenario.data.ID_SCENAR);
+        }
+        catch (e) {
+            message.error(String(e));
+            return [];
+        }
+        for (let item of firstPage.items) {
+            resultData.push(...await exportSubScenarios(api, item, root, config, dateTimeMask, setLoadingState, message));
+        }
+        if (firstPage.leftCount > 0) {
+            totalItems = firstPage.items.length + firstPage.leftCount;
+            offset += firstPage.items.length;
+            while (offset < totalItems) {
+                let page;
+                setLoadingState((s) => ({ ...s, loadingPercentage: (offset / totalItems) * 100 }));
+                try {
+                    page = await api.getScenarioChildren(scenario.data.ID_SCENAR, offset);
+                }
+                catch (e) {
+                    message.error(String(e));
+                    break;
+                }
+                for (let item of page.items) {
+                    resultData.push(...await exportSubScenarios(api, item, root, config, dateTimeMask, setLoadingState, message));
+                }
+                offset += page.items.length;
+            }
+        }
+    }
+    {
+        setLoadingState((s) => ({ ...s, loadingPercentage: 0, loadingItem: i18n("Loading vectors") }));
+        let offset = 0;
+        let totalItems = 0;
+        let firstPage;
+        try {
+            firstPage = await api.getScenarioVectors(scenario.data.ID_SCENAR, undefined, undefined, true);
+        }
+        catch (e) {
+            message.error(String(e));
+            return [];
+        }
+        for (let item of firstPage.items) {
+            resultData.push(...await exportSubVector(api, item, root, config, dateTimeMask, setLoadingState, message));
+        }
+        if (firstPage.leftCount > 0) {
+            totalItems = firstPage.items.length + firstPage.leftCount;
+            offset += firstPage.items.length;
+            while (offset < totalItems) {
+                let page;
+                setLoadingState((s) => ({ ...s, loadingPercentage: (offset / totalItems) * 100 }));
+                try {
+                    page = await api.getScenarioVectors(scenario.data.ID_SCENAR, offset, undefined, true);
+                }
+                catch (e) {
+                    message.error(String(e));
+                    break;
+                }
+                for (let item of page.items) {
+                    resultData.push(...await exportSubVector(api, item, root, config, dateTimeMask, setLoadingState, message));
+                }
+                offset += page.items.length;
+            }
+        }
+    }
+    root.dtd({ pubID: '' });
+    resultData.push([`scenar_${scenario.data.MENO}`, root.end({ pretty: true })]);
+    return resultData;
+}
+async function exportCalcVector(root, api, vector, message) {
+    let data;
+    try {
+        data = await api.loadCalcVectorData(vector.data.ID_VEKTOR);
+    }
+    catch (e) {
+        message.error(String(e));
+        return;
+    }
+    if (data.data.length > 0) {
+        const prescription = data.data[0];
+        const element = root.ele("predpis");
+        if (prescription.POPIS !== undefined) {
+            element.att("popis", prescription.POPIS);
+        }
+        element.cdata(data.prescription);
+    }
+}
+async function exportDescriptiveVector(root, api, vector, dateTimeMask, message) {
+    let data;
+    try {
+        data = await api.loadDescriptiveVectorData(vector.data.ID_VEKTOR);
+    }
+    catch (e) {
+        message.error(String(e));
+        return;
+    }
+    const element = root.ele("popis");
+    for (let desc of data) {
+        element.att("idx", desc.idx);
+        element.att("typ_periody", desc.periodType);
+        element.att("typ_hodnoty", desc.valueType);
+        element.att("hodnota", desc.value);
+        element.att("valid", desc.valid);
+        if (desc.timeFrom !== undefined) {
+            element.att("od", dayjs(desc.timeFrom).format(dateTimeMask));
+        }
+        if (desc.timeTo !== undefined) {
+            element.att("do", dayjs(desc.timeTo).format(dateTimeMask));
+        }
+        if (desc.value2 !== undefined) {
+            element.att("hodnota2", desc.value2);
+        }
+        if (desc.status !== undefined) {
+            element.att("stav", desc.status);
+        }
+        if (desc.supplement !== undefined) {
+            element.att("dodatok_id", desc.supplement);
+        }
+    }
+}
+async function exportSpecifiedVector(api, vector, config, dateTimeMask, setLoadingState, message) {
+    const exportInterval = getExportInterval(config.from, config.to, vector.data.DATA_OD !== undefined ? dayjs(vector.data.DATA_OD) : undefined, vector.data.DATA_DO !== undefined ? dayjs(vector.data.DATA_DO) : undefined);
+    if (exportInterval === undefined) {
+        return [];
+    }
+    const result = [];
+    const [from, to] = exportInterval;
+    const years = [];
+    let current = from;
+    while (current.isSameOrBefore(to, "year")) {
+        const yearEnd = current.endOf("year");
+        years.push({ start: current, end: yearEnd });
+        current = current.add(1, 'year').startOf('year');
+    }
+    for (const range of years.values()) {
+        let values;
+        setLoadingState((s) => ({ ...s, loadingItem: vector.data.ZOBRAZ_MENO + " - " + range.start.year() }));
+        try {
+            values = await api.readVectorValues(vector.data.ID_VEKTOR, range.start, range.end, EdaSamplingType.Default);
+        }
+        catch (e) {
+            message.error(String(e));
+            continue;
+        }
+        const root = create('vektor', { version: '1.0', encoding: 'UTF-8' });
+        if (!values.data) {
+            message.error(i18n("No vector data found"));
+            continue;
+        }
+        for (let value of values.data) {
+            const valueElement = root.ele("value");
+            valueElement.att("time", dayjs(value.val.valueTime).format(dateTimeMask));
+            if (value.val.value !== undefined && value.val.value !== null) {
+                valueElement.att("value", value.val.value);
+            }
+            if (value.val.flags?.includes("A")) {
+                valueElement.att("flagA", 1);
+            }
+            if (value.val.flags?.includes("B")) {
+                valueElement.att("flagB", 1);
+            }
+            if (value.val.flags?.includes("C")) {
+                valueElement.att("flagC", 1);
+            }
+            if (value.val.flags?.includes("D")) {
+                valueElement.att("flagD", 1);
+            }
+        }
+        root.dtd({ pubID: '' });
+        result.push([`vekt_${vector.data.MENO}_DATA_${range.start.year()}`, root.end({ pretty: true })]);
+    }
+    return result;
+}
+async function exportPairVector(root, api, vector, config, dateTimeMask, message) {
+    const exportInterval = getExportInterval(config.from, config.to, vector.data.DATA_OD !== undefined ? dayjs(vector.data.DATA_OD) : undefined, vector.data.DATA_DO !== undefined ? dayjs(vector.data.DATA_DO) : undefined);
+    if (exportInterval === undefined || !config.exportValues) {
+        return;
+    }
+    let pairData;
+    try {
+        pairData = await api.readPairVectorValues(vector.data.ID_VEKTOR, exportInterval[0], exportInterval[1], EdaSamplingType.Default);
+    }
+    catch (e) {
+        message.error(String(e));
+        return;
+    }
+    for (let data of pairData) {
+        const valueElement = root.ele("value");
+        valueElement.att("time", dayjs(data.valX.valueTime).format(dateTimeMask));
+        if (data.valX.valueTime !== undefined) {
+            valueElement.att("value_x", data.valX.value);
+            if (data.valX.flags?.includes("A")) {
+                valueElement.att("flagA_x", 1);
+            }
+            if (data.valX.flags?.includes("B")) {
+                valueElement.att("flagB_x", 1);
+            }
+            if (data.valX.flags?.includes("C")) {
+                valueElement.att("flagC_x", 1);
+            }
+            if (data.valX.flags?.includes("D")) {
+                valueElement.att("flagD_x", 1);
+            }
+        }
+        if (data.valY.valueTime !== undefined) {
+            valueElement.att("value_y", data.valY.value);
+            if (data.valY.flags?.includes("A")) {
+                valueElement.att("flagA_y", 1);
+            }
+            if (data.valY.flags?.includes("B")) {
+                valueElement.att("flagB_y", 1);
+            }
+            if (data.valY.flags?.includes("C")) {
+                valueElement.att("flagC_y", 1);
+            }
+            if (data.valY.flags?.includes("D")) {
+                valueElement.att("flagD_y", 1);
+            }
+        }
+        if (data.idx.value !== undefined) {
+            valueElement.att("idx", data.idx.value);
+        }
+    }
+}
+async function exportSubGroup(api, item, root, config, dateTimeMask, setLoadingState, message) {
+    let subgroup;
+    root.ele("podskupina", { meno: item.Name });
+    try {
+        subgroup = await api.loadGroupData(item.ID);
+    }
+    catch (e) {
+        message.error(String(e));
+        console.error(e);
+        return [];
+    }
+    if (subgroup) {
+        return await exportGroup(api, subgroup, config, dateTimeMask, setLoadingState, message);
+    }
+    return [];
+}
+async function exportSubVector(api, item, root, config, dateTimeMask, setLoadingState, message) {
+    let subVector;
+    if (!config.vectorTypes[item.Type]) {
+        return [];
+    }
+    root.ele("vektor", { meno: item.Name });
+    try {
+        subVector = await api.loadVectorData(item.ID);
+    }
+    catch (e) {
+        message.error(String(e));
+        console.error(e);
+        return [];
+    }
+    if (subVector) {
+        return await exportVector(api, subVector, config, dateTimeMask, setLoadingState, message);
+    }
+    return [];
+}
+async function exportSubScenarios(api, item, root, config, dateTimeMask, setLoadingState, message) {
+    let subScenario;
+    root.ele("podscenar", { meno: item.Name });
+    try {
+        subScenario = await api.loadScenarioData(item.ID);
+    }
+    catch (e) {
+        message.error(String(e));
+        console.error(e);
+        return [];
+    }
+    if (subScenario) {
+        return await exportScenario(api, subScenario, config, dateTimeMask, setLoadingState, message);
+    }
+    return [];
+}
+function getExportInterval(bt, et, vectorBt, vectorEt) {
+    if (vectorBt === undefined || vectorEt === undefined) {
+        return undefined;
+    }
+    if (bt !== undefined && et !== undefined) {
+        let start = undefined;
+        let end = undefined;
+        if (bt.isBefore(vectorBt)) {
+            start = bt;
+        }
+        if (et.isAfter(vectorEt)) {
+            end = bt;
+        }
+        if (start !== undefined && end !== undefined && start.isBefore(end)) {
+            return [start, end];
+        }
+    }
+    else {
+        return [vectorBt, vectorEt];
+    }
+    return undefined;
+}
+//# sourceMappingURL=export.js.map