@tager/admin-import 0.1.1 → 1.0.0

package/dist/constants/paths.d.ts

@@ -1,4 +1,4 @@
-export declare const IMPORT_ROUTE_PATHS: {
-    readonly IMPORT_LIST: "/import";
-    readonly IMPORT_FORM: "/import/:importId";
-};
+export declare const IMPORT_ROUTE_PATHS: {
+    readonly IMPORT_LIST: "/import";
+    readonly IMPORT_FORM: "/import/:importId";
+};

package/dist/constants/routes.d.ts

@@ -1,3 +1,3 @@
-import { CustomRouteConfig } from '@tager/admin-layout';
-export declare const IMPORT_LIST_ROUTE: CustomRouteConfig;
-export declare const IMPORT_FORM_ROUTE: CustomRouteConfig;
+import type { RouteRecordRaw } from 'vue-router';
+export declare const IMPORT_LIST_ROUTE: RouteRecordRaw;
+export declare const IMPORT_FORM_ROUTE: RouteRecordRaw;

package/dist/dev/App.vue.d.ts

@@ -0,0 +1,5 @@
+import { MenuItemType } from "@tager/admin-layout";
+declare const _default: import("vue").DefineComponent<{}, {
+    sidebarMenuList: MenuItemType[];
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/dist/dev/config.d.ts

@@ -0,0 +1,2 @@
+import type { AppConfigType } from '@tager/admin-services';
+export declare const OZITAG_CONFIG: AppConfigType;

package/dist/dev/env.d.ts

@@ -0,0 +1 @@
+export declare function populateEnvironment(): void;

package/dist/dev/main.d.ts

@@ -0,0 +1,3 @@
+import '@tager/admin-ui/css';
+import '@tager/admin-layout/css';
+import '@tager/admin-dynamic-field/css';

package/dist/index.mjs

@@ -0,0 +1,439 @@
+import { i18n, request, useI18n, useToast, useResource, navigateBack, convertRequestErrorToMap } from "@tager/admin-services";
+import { defineComponent, openBlock, createElementBlock, Fragment, renderList, createElementVNode, toDisplayString, createTextVNode, createCommentVNode, onMounted, resolveComponent, createBlock, withCtx, createVNode, computed, ref, watch, withModifiers } from "vue";
+import { DataTable, useDataTable, FormFieldFileInput, FormFooter, FormFieldSelect } from "@tager/admin-ui";
+import { Page } from "@tager/admin-layout";
+import { universalFieldUtils, DynamicField } from "@tager/admin-dynamic-field";
+import { compile } from "path-to-regexp";
+import { useRouter } from "vue-router";
+const EN = {
+  home: "Home",
+  import: "Import",
+  importList: "Import List",
+  importForm: "Import Form",
+  type: "Type",
+  importType: "Import type",
+  status: "status",
+  message: "Message",
+  log: "Log",
+  params: "Params",
+  file: "file",
+  newImport: "New import",
+  importCreation: "Import creation",
+  success: "Success",
+  error: "Error",
+  createdSuccessMessage: "Import has been successfully created",
+  createdErrorMessage: "Import creation has been failed"
+};
+const RU = {
+  home: "\u0413\u043B\u0430\u0432\u043D\u0430\u044F",
+  import: "\u0418\u043C\u043F\u043E\u0440\u0442",
+  importList: "\u0421\u043F\u0438\u0441\u043E\u043A \u0438\u043C\u043F\u043E\u0440\u0442\u043E\u0432",
+  importForm: "\u0424\u043E\u0440\u043C\u0430 \u0438\u043C\u043F\u043E\u0440\u0442\u0430",
+  type: "\u0422\u0438\u043F",
+  importType: "\u0422\u0438\u043F \u0438\u043C\u043F\u043E\u0440\u0442\u0430",
+  status: "\u0421\u0442\u0430\u0442\u0443\u0441",
+  message: "\u0421\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435",
+  log: "\u041B\u043E\u0433",
+  params: "\u041F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u044B",
+  file: "\u0424\u0430\u0439\u043B",
+  newImport: "\u041D\u043E\u0432\u044B\u0439 \u0438\u043C\u043F\u043E\u0440\u0442",
+  importCreation: "\u0421\u043E\u0437\u0434\u0430\u043D\u0438\u0435 \u0438\u043C\u043F\u043E\u0440\u0442\u0430",
+  success: "\u0423\u0441\u043F\u0435\u0445",
+  error: "\u041E\u0448\u0438\u0431\u043A\u0430",
+  createdSuccessMessage: "\u0418\u043C\u043F\u043E\u0440\u0442 \u0431\u044B\u043B\u0430 \u0443\u0441\u043F\u0435\u0448\u043D\u043E \u0441\u043E\u0437\u0434\u0430\u043D",
+  createdErrorMessage: "\u0421\u043E\u0437\u0434\u0430\u043D\u0438\u0435 \u0438\u043C\u043F\u043E\u0440\u0442\u0430 \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C"
+};
+function applyTranslations() {
+  i18n.addTranslations("en", "import", EN);
+  i18n.addTranslations("ru", "import", RU);
+}
+function getImportList(params) {
+  return request.get({ path: "/admin/tager/import", params });
+}
+function getModuleInfo() {
+  return request.get({ path: "/admin/tager/import/info" });
+}
+function createImport(payload) {
+  return request.post({ path: "/admin/tager/import", body: payload });
+}
+const IMPORT_ROUTE_PATHS = {
+  IMPORT_LIST: "/import",
+  IMPORT_FORM: "/import/:importId"
+};
+function getImportListUrl() {
+  return IMPORT_ROUTE_PATHS.IMPORT_LIST;
+}
+function getImportFormUrl(params) {
+  return compile(IMPORT_ROUTE_PATHS.IMPORT_FORM)(params);
+}
+function dateTimeFormat(value) {
+  const date = new Date(value);
+  return new Intl.DateTimeFormat("ru-RU", {
+    "year": "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  }).format(date);
+}
+var CellHistory_vue_vue_type_style_index_0_scoped_true_lang = "";
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _sfc_main$2 = defineComponent({
+  name: "CellHistory",
+  props: {
+    history: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup() {
+    return {
+      dateTimeFormat
+    };
+  }
+});
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = { class: "name" };
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  return _ctx.history.length > 0 ? (openBlock(), createElementBlock("ul", _hoisted_1, [
+    (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.history, (history, index) => {
+      return openBlock(), createElementBlock("li", { key: index }, [
+        createElementVNode("span", _hoisted_2, toDisplayString(history.status), 1),
+        createTextVNode(" " + toDisplayString(_ctx.dateTimeFormat(history.datetime)), 1)
+      ]);
+    }), 128))
+  ])) : createCommentVNode("", true);
+}
+var CellHistory = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__scopeId", "data-v-70566d6e"]]);
+const _sfc_main$1 = defineComponent({
+  name: "ImportList",
+  components: { CellHistory, DataTable, Page },
+  setup() {
+    const { t } = useI18n();
+    const {
+      fetchEntityList: fetchImportList,
+      isLoading: isImportListLoading,
+      rowData: importList,
+      errorMessage,
+      searchQuery,
+      handleChange,
+      pageSize,
+      pageCount,
+      pageNumber
+    } = useDataTable({
+      fetchEntityList: (params) => getImportList({
+        pageNumber: params.pageNumber,
+        pageSize: params.pageSize
+      }),
+      initialValue: [],
+      resourceName: "Import list",
+      pageSize: 100
+    });
+    onMounted(() => {
+      fetchImportList();
+    });
+    const columnDefs = [
+      {
+        id: 1,
+        name: "ID",
+        field: "id",
+        style: { width: "50px", textAlign: "center" },
+        headStyle: { width: "50px", textAlign: "center" }
+      },
+      {
+        id: 2,
+        name: t("import:type"),
+        field: "strategy",
+        style: { width: "150px" },
+        headStyle: { width: "150px" }
+      },
+      {
+        id: 3,
+        name: t("import:params"),
+        field: "params",
+        type: "key-value",
+        format: ({ row }) => row.params ? row.params.map((param) => {
+          return {
+            key: param.label,
+            value: param.value
+          };
+        }) : null
+      },
+      {
+        id: 4,
+        name: t("import:status"),
+        field: "status",
+        style: { width: "120px" },
+        headStyle: { width: "120px" }
+      },
+      {
+        id: 5,
+        name: t("import:message"),
+        field: "message"
+      },
+      {
+        id: 6,
+        name: t("import:log"),
+        field: "history",
+        style: { width: "270px", whiteSpace: "nowrap" },
+        headStyle: { width: "270px" }
+      },
+      {
+        id: 7,
+        name: t("import:file"),
+        field: "file",
+        type: "file",
+        style: { width: "150px", textAlign: "center" },
+        headStyle: { width: "150px", textAlign: "center" }
+      }
+    ];
+    return {
+      columnDefs,
+      getImportFormUrl,
+      rowData: importList,
+      isRowDataLoading: isImportListLoading,
+      errorMessage,
+      searchQuery,
+      handleChange,
+      pageSize,
+      pageCount,
+      pageNumber
+    };
+  }
+});
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_CellHistory = resolveComponent("CellHistory");
+  const _component_DataTable = resolveComponent("DataTable");
+  const _component_Page = resolveComponent("Page");
+  return openBlock(), createBlock(_component_Page, {
+    title: _ctx.$i18n.t("import:import"),
+    "header-buttons": [
+      {
+        text: _ctx.$i18n.t("import:newImport"),
+        href: _ctx.getImportFormUrl({ importId: "create" })
+      }
+    ]
+  }, {
+    default: withCtx(() => [
+      createVNode(_component_DataTable, {
+        "column-defs": _ctx.columnDefs,
+        "row-data": _ctx.rowData,
+        loading: _ctx.isRowDataLoading,
+        "error-message": _ctx.errorMessage,
+        pagination: {
+          pageSize: _ctx.pageSize,
+          pageCount: _ctx.pageCount,
+          pageNumber: _ctx.pageNumber,
+          disabled: _ctx.isRowDataLoading
+        },
+        "use-search": false,
+        onChange: _ctx.handleChange
+      }, {
+        "cell(history)": withCtx(({ row }) => [
+          createVNode(_component_CellHistory, {
+            history: row.history
+          }, null, 8, ["history"])
+        ]),
+        _: 1
+      }, 8, ["column-defs", "row-data", "loading", "error-message", "pagination", "onChange"])
+    ]),
+    _: 1
+  }, 8, ["title", "header-buttons"]);
+}
+var ImportList = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1]]);
+function convertImportFormValuesToCreationPayload(values, templateValues) {
+  var _a, _b, _c, _d;
+  return {
+    strategy: (_b = (_a = values.strategy) == null ? void 0 : _a.value) != null ? _b : "",
+    file: (_d = (_c = values.file) == null ? void 0 : _c.file.id) != null ? _d : "",
+    params: templateValues.map((field) => ({
+      name: field.config.name,
+      value: universalFieldUtils.getOutgoingValue(field)
+    }))
+  };
+}
+function convertStrategiesToStrategyOptionList(strategies) {
+  return strategies.map((strategy) => ({
+    value: strategy.id,
+    label: strategy.name
+  }));
+}
+const _sfc_main = defineComponent({
+  name: "ImportForm",
+  components: { Page, FormFieldFileInput, DynamicField, FormFooter, FormFieldSelect },
+  setup() {
+    const { t } = useI18n();
+    const toast = useToast();
+    const router = useRouter();
+    const [
+      fetchModuleInfo,
+      { data: moduleInfo, loading: isModuleInfoLoading }
+    ] = useResource({
+      fetchResource: getModuleInfo,
+      initialValue: {
+        fileScenario: "",
+        strategies: []
+      },
+      resourceName: "Module info"
+    });
+    const strategyFileScenario = computed(
+      () => moduleInfo.value.fileScenario
+    );
+    const strategyOptionList = computed(
+      () => convertStrategiesToStrategyOptionList(moduleInfo.value.strategies)
+    );
+    onMounted(() => {
+      fetchModuleInfo();
+    });
+    const errors = ref({});
+    const values = ref({ strategy: null, file: null });
+    const isSubmitting = ref(false);
+    const templateValues = ref([]);
+    function updateTemplateValues() {
+      var _a;
+      const selectedStrategy = moduleInfo.value.strategies.find(
+        (strategy) => {
+          var _a2;
+          return strategy.id === ((_a2 = values.value.strategy) == null ? void 0 : _a2.value);
+        }
+      );
+      const fieldTemplateList = (_a = selectedStrategy == null ? void 0 : selectedStrategy.fields) != null ? _a : [];
+      templateValues.value = fieldTemplateList.map(
+        (fieldConfig) => universalFieldUtils.createFormField(fieldConfig, null)
+      );
+    }
+    watch(
+      () => values.value.strategy,
+      () => {
+        updateTemplateValues();
+      }
+    );
+    onMounted(() => {
+      updateTemplateValues();
+    });
+    function submitForm(event) {
+      isSubmitting.value = true;
+      const creationPayload = convertImportFormValuesToCreationPayload(
+        values.value,
+        templateValues.value
+      );
+      createImport(creationPayload).then(() => {
+        errors.value = {};
+        if (event.type === "create" || event.type === "save" || event.type === "create_exit" || event.type === "save_exit") {
+          navigateBack(router, getImportListUrl());
+        }
+        toast.show({
+          variant: "success",
+          title: t("import:success"),
+          body: t("import:createdSuccessMessage")
+        });
+      }).catch((error) => {
+        console.error(error);
+        errors.value = convertRequestErrorToMap(error);
+        toast.show({
+          variant: "danger",
+          title: t("import:error"),
+          body: t("import:createdErrorMessage")
+        });
+      }).finally(() => {
+        isSubmitting.value = false;
+      });
+    }
+    const isContentLoading = computed(() => isModuleInfoLoading.value);
+    return {
+      values,
+      errors,
+      isSubmitting,
+      submitForm,
+      getImportListUrl,
+      strategyOptionList,
+      strategyFileScenario,
+      isContentLoading,
+      templateValues
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_FormFieldSelect = resolveComponent("FormFieldSelect");
+  const _component_FormFieldFileInput = resolveComponent("FormFieldFileInput");
+  const _component_DynamicField = resolveComponent("DynamicField");
+  const _component_FormFooter = resolveComponent("FormFooter");
+  const _component_Page = resolveComponent("Page");
+  return openBlock(), createBlock(_component_Page, {
+    title: _ctx.$i18n.t("import:importCreation"),
+    "is-content-loading": _ctx.isContentLoading
+  }, {
+    footer: withCtx(() => [
+      createVNode(_component_FormFooter, {
+        "back-href": _ctx.getImportListUrl(),
+        onSubmit: _ctx.submitForm,
+        "is-submitting": _ctx.isSubmitting,
+        "is-creation": true
+      }, null, 8, ["back-href", "onSubmit", "is-submitting"])
+    ]),
+    default: withCtx(() => [
+      createElementVNode("form", {
+        novalidate: "",
+        onSubmit: _cache[2] || (_cache[2] = withModifiers(() => {
+        }, ["prevent"]))
+      }, [
+        createVNode(_component_FormFieldSelect, {
+          value: _ctx.values.strategy,
+          "onUpdate:value": _cache[0] || (_cache[0] = ($event) => _ctx.values.strategy = $event),
+          options: _ctx.strategyOptionList,
+          error: _ctx.errors.strategy,
+          name: "importType",
+          label: _ctx.$i18n.t("import:importType")
+        }, null, 8, ["value", "options", "error", "label"]),
+        createVNode(_component_FormFieldFileInput, {
+          value: _ctx.values.file,
+          "onUpdate:value": _cache[1] || (_cache[1] = ($event) => _ctx.values.file = $event),
+          error: _ctx.errors.file,
+          label: _ctx.$i18n.t("import:file"),
+          name: "file",
+          scenario: _ctx.strategyFileScenario
+        }, null, 8, ["value", "error", "label", "scenario"]),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.templateValues, (field) => {
+          return openBlock(), createBlock(_component_DynamicField, {
+            key: field.config.name,
+            field
+          }, null, 8, ["field"]);
+        }), 128))
+      ], 32)
+    ]),
+    _: 1
+  }, 8, ["title", "is-content-loading"]);
+}
+var ImportForm = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+const IMPORT_LIST_ROUTE = {
+  path: IMPORT_ROUTE_PATHS.IMPORT_LIST,
+  component: ImportList,
+  name: "Import List",
+  meta: {
+    getBreadcrumbs: (route, i18n2) => [
+      { url: "/", text: i18n2.t("import:home") },
+      { url: route.path, text: i18n2.t("import:importList") }
+    ]
+  }
+};
+const IMPORT_FORM_ROUTE = {
+  path: IMPORT_ROUTE_PATHS.IMPORT_FORM,
+  component: ImportForm,
+  name: "Import Form",
+  meta: {
+    getBreadcrumbs: (route, i18n2) => [
+      { url: "/", text: i18n2.t("import:home") },
+      { url: IMPORT_LIST_ROUTE.path, text: i18n2.t("import:importList") },
+      { url: route.path, text: i18n2.t("import:importForm") }
+    ]
+  }
+};
+applyTranslations();
+export { IMPORT_FORM_ROUTE, IMPORT_LIST_ROUTE, createImport, getImportFormUrl, getImportList, getImportListUrl, getModuleInfo };

package/dist/locales/apply.d.ts

@@ -0,0 +1 @@
+export declare function applyTranslations(): void;

package/dist/locales/en.d.ts

@@ -1,20 +1,19 @@
-declare const EN: {
-    home: string;
-    exportAndImport: string;
-    import: string;
-    importList: string;
-    importForm: string;
-    type: string;
-    importType: string;
-    status: string;
-    message: string;
-    log: string;
-    file: string;
-    newImport: string;
-    importCreation: string;
-    success: string;
-    error: string;
-    createdSuccessMessage: string;
-    createdErrorMessage: string;
-};
-export default EN;
+export declare const EN: {
+    home: string;
+    import: string;
+    importList: string;
+    importForm: string;
+    type: string;
+    importType: string;
+    status: string;
+    message: string;
+    log: string;
+    params: string;
+    file: string;
+    newImport: string;
+    importCreation: string;
+    success: string;
+    error: string;
+    createdSuccessMessage: string;
+    createdErrorMessage: string;
+};

package/dist/locales/ru.d.ts

@@ -1,3 +1,2 @@
-import EN from './en';
-declare const RU: typeof EN;
-export default RU;
+import { EN } from './en';
+export declare const RU: typeof EN;

package/dist/main.d.ts

@@ -1,3 +1,3 @@
-export * from './constants/routes';
-export * from './utils/paths';
-export * from './services/requests';
+export * from './constants/routes';
+export * from './utils/paths';
+export * from './services/requests';

package/dist/services/requests.d.ts

@@ -1,8 +1,8 @@
-import { ResponseBody } from '@tager/admin-services';
-import { ModuleInfoType, ImportCreatePayload, ImportType } from '../typings/model';
-export declare function getImportList(params?: {
-    pageNumber?: number;
-    pageSize?: number;
-}): Promise<ResponseBody<Array<ImportType>>>;
-export declare function getModuleInfo(): Promise<ResponseBody<ModuleInfoType>>;
-export declare function createImport(payload: ImportCreatePayload): Promise<ResponseBody<ImportType>>;
+import { ResponseBody } from '@tager/admin-services';
+import { ModuleInfoType, ImportCreatePayload, ImportType } from '../typings/model';
+export declare function getImportList(params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}): Promise<ResponseBody<Array<ImportType>>>;
+export declare function getModuleInfo(): Promise<ResponseBody<ModuleInfoType>>;
+export declare function createImport(payload: ImportCreatePayload): Promise<ResponseBody<ImportType>>;

package/dist/style.css

@@ -0,0 +1 @@
+.name[data-v-70566d6e]{display:inline-block;width:100px}

package/dist/typings/model.d.ts

@@ -1,26 +1,33 @@
-import { FileType } from '@tager/admin-services';
-interface HistoryType {
-    readonly datetime: string;
-    readonly status: string;
-}
-export interface ImportType {
-    readonly id: number;
-    readonly strategy: string;
-    readonly status: string;
-    readonly message: string | null;
-    readonly history: Array<HistoryType>;
-    readonly file: FileType | null;
-}
-export interface StrategyType {
-    readonly id: string;
-    readonly name: string;
-}
-export interface ModuleInfoType {
-    readonly fileScenario: string;
-    readonly strategies: Array<StrategyType>;
-}
-export interface ImportCreatePayload {
-    strategy: string;
-    file: string;
-}
-export {};
+import { FileType } from '@tager/admin-services';
+import { FieldConfigUnion, FieldShortType, OutgoingValueUnion } from '@tager/admin-dynamic-field';
+export interface HistoryType {
+    readonly datetime: string;
+    readonly status: string;
+}
+export interface ParamType {
+    readonly label: string;
+    readonly value: string;
+}
+export interface ImportType {
+    readonly id: number;
+    readonly strategy: string;
+    readonly status: string;
+    readonly message: string | null;
+    readonly history: Array<HistoryType>;
+    readonly params: Array<ParamType> | null;
+    readonly file: FileType | null;
+}
+export interface StrategyType {
+    readonly id: string;
+    readonly name: string;
+    readonly fields: Array<FieldConfigUnion>;
+}
+export interface ModuleInfoType {
+    readonly fileScenario: string;
+    readonly strategies: Array<StrategyType>;
+}
+export interface ImportCreatePayload {
+    strategy: string;
+    file: string;
+    params: Array<FieldShortType<OutgoingValueUnion>>;
+}

package/dist/utils/paths.d.ts

@@ -1,4 +1,4 @@
-export declare function getImportListUrl(): string;
-export declare function getImportFormUrl(params: {
-    importId: string | number;
-}): string;
+export declare function getImportListUrl(): string;
+export declare function getImportFormUrl(params: {
+    importId: string | number;
+}): string;

package/dist/views/ImportForm/ImportForm.helpers.d.ts

@@ -1,7 +1,9 @@
-import { OptionType, SingleFileInputValueType } from '@tager/admin-ui';
-import { ImportCreatePayload } from '../../typings/model';
-export declare type FormValues = {
-    strategy: OptionType | null;
-    file: SingleFileInputValueType | null;
-};
-export declare function convertImportFormValuesToCreationPayload(values: FormValues): ImportCreatePayload;
+import { OptionType, SingleFileInputValueType } from '@tager/admin-ui';
+import { FieldUnion } from '@tager/admin-dynamic-field';
+import { ImportCreatePayload, StrategyType } from '../../typings/model';
+export declare type FormValues = {
+    strategy: OptionType | null;
+    file: SingleFileInputValueType | null;
+};
+export declare function convertImportFormValuesToCreationPayload(values: FormValues, templateValues: Array<FieldUnion>): ImportCreatePayload;
+export declare function convertStrategiesToStrategyOptionList(strategies: Array<StrategyType>): Array<OptionType>;