@hitsoft/e-donusum 1.0.5

package/src/lib/hit-proxy/hit-note-rules/hit-note-rule.service.ts

@@ -0,0 +1,83 @@
+import { RestService } from "@abp/ng.core";
+import { Injectable } from "@angular/core";
+import { EnumDto, HitNoteRuleCreateDto, HitNoteRuleUpdateDto, PreviewQueryRequestDto } from "./models";
+import { DevexpressRestService } from "../devexpress-query-builder/devexpress-query-builder";
+import { NoteRuleCreateDto, NoteRuleDto } from "../../proxy/note-rules";
+
+@Injectable({
+    providedIn: 'root',
+})
+export class HitNoteRulesService {
+    apiName = 'eDonusum';
+
+    LoadNoteRules = this.devexService.createStore({
+        key: "id",
+        loadUrl: 'api/e-donusum/note-rules/load-note-rules'
+    })
+
+    getRuleTypes = () =>
+        this.restService.request<any, EnumDto[]>({
+            method: 'GET',
+            url: '/api/e-donusum/note-rules/get-rule-types',
+        },
+            { apiName: this.apiName });
+
+    getDescTypes = () =>
+        this.restService.request<any, EnumDto[]>({
+            method: 'GET',
+            url: '/api/e-donusum/note-rules/get-desc-types',
+        },
+            { apiName: this.apiName });
+
+    getTableNames = () =>
+        this.restService.request<any, EnumDto[]>({
+            method: 'GET',
+            url: '/api/e-donusum/note-rules/get-table-names',
+        },
+            { apiName: this.apiName });
+
+
+    getParamNames = () =>
+        this.restService.request<any, EnumDto[]>({
+            method: 'GET',
+            url: '/api/e-donusum/note-rules/get-param-names',
+        },
+            { apiName: this.apiName });
+
+    create = (input: HitNoteRuleCreateDto) =>
+        this.restService.request<any, NoteRuleDto>({
+            method: 'POST',
+            url: '/api/e-donusum/note-rules/hit-note-rule-create',
+            body: input,
+        },
+            { apiName: this.apiName });
+
+    update = (id: string, input: HitNoteRuleUpdateDto) =>
+        this.restService.request<any, NoteRuleDto>({
+            method: 'POST',
+            url: `/api/e-donusum/note-rules/hit-note-rule-update/${id}`,
+            body: input,
+        },
+            { apiName: this.apiName });
+
+    LoadDocTypes = this.devexService.createStore({
+        key: "id",
+        loadUrl: 'api/e-donusum/note-rules/load-doc-types'
+    })
+
+    LoadScenarios = this.devexService.createStore({
+        key: "id",
+        loadUrl: 'api/e-donusum/note-rules/load-scenarios'
+    })
+
+    previewQueryResult = (requestDto: PreviewQueryRequestDto) =>
+        this.restService.request<any, any>({
+            method: 'POST',
+            url: '/api/e-donusum/note-rules/preview-query-result',
+            body: requestDto
+        },
+            { apiName: this.apiName });
+
+    constructor(private restService: RestService, private devexService: DevexpressRestService) { }
+
+}

package/src/lib/hit-proxy/hit-note-rules/models.ts

@@ -0,0 +1,42 @@
+import { NoteRuleDocTypeCreateDto, NoteRuleDocTypeUpdateDto } from "../../proxy/note-rule-doc-types";
+import { NoteRuleScenarioCreateDto, NoteRuleScenarioUpdateDto } from "../../proxy/note-rule-scenarios";
+import { NoteRuleCreateDto, NoteRuleUpdateDto } from "../../proxy/note-rules";
+
+export interface EnumDto {
+    id: number;
+    displayName: string;
+}
+
+export interface NoteRuleCreateOrUpdateDto extends NoteRuleUpdateDto {
+    id: string;
+}
+
+export interface HitNoteRuleCreateDto {
+    noteRules: NoteRuleCreateOrUpdateDto,
+    noteRuleScenarios: NoteRuleScenarioCreateDto[],
+    noteRuleDocTypes: NoteRuleDocTypeCreateDto[]
+}
+
+export interface HitNoteRuleUpdateDto {
+    noteRules: NoteRuleCreateOrUpdateDto;
+    noteRuleScenarios: HitNoteRuleScenarioUpdateDto[];
+    noteRuleDocTypes: HitNoteRuleDocTypeUpdateDto[];
+}
+
+export interface HitNoteRuleScenarioUpdateDto extends NoteRuleScenarioUpdateDto {
+    id: string;
+}
+
+export interface HitNoteRuleDocTypeUpdateDto extends NoteRuleDocTypeUpdateDto {
+    id: string;
+}
+
+export interface PreviewQueryRequestDto {
+    noteRule: NoteRuleCreateDto;
+    parameters: Parameters[];
+}
+
+export interface Parameters {
+    paramName: string;
+    paramValue: string;
+}

package/src/lib/hit-proxy/hit-params-companies/hit-params-company.service.ts

@@ -0,0 +1,37 @@
+import { RestService } from '@abp/ng.core';
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HitParamsCompaniesService {
+  apiName = 'eDonusum';
+
+  getParamsCompany = () =>
+    this.restService.request<any, any>(
+      {
+        method: 'GET',
+        url: '/api/e-donusum/params-companies/get-params-company',
+      },
+      { apiName: this.apiName }
+    );
+
+  updateParamsCompanySetupStatus = (id: string, setupIndex: number, completed: boolean) =>
+    this.restService.request<any, any>(
+      {
+        method: 'GET',
+        url: `/api/e-donusum/params-companies/update-params-company-setup-status/${id},${setupIndex},${completed}`,
+      },
+      { apiName: this.apiName }
+    );
+
+  setDefaultXslts = () => this.restService.request<any, any>(
+    {
+      method: 'GET',
+      url: '/api/e-donusum/params-companies/set-default-xslts',
+    },
+    { apiName: this.apiName }
+  );
+
+  constructor(private restService: RestService) { }
+}

package/src/lib/hit-proxy/hit-params-dispatches/hit-params-dispatch.service.ts

@@ -0,0 +1,20 @@
+import { RestService } from '@abp/ng.core';
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HitParamsDispatchesService {
+  apiName = 'eDonusum';
+
+  getParamsDispatch = () =>
+    this.restService.request<any, any>(
+      {
+        method: 'GET',
+        url: '/api/e-donusum/paramse-dispatches/get-params-dispatch',
+      },
+      { apiName: this.apiName }
+    );
+
+  constructor(private restService: RestService) {}
+}

package/src/lib/hit-proxy/hit-params-generals/hit-params-general.service.ts

@@ -0,0 +1,20 @@
+import { RestService } from '@abp/ng.core';
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HitParamsGeneralsService {
+  apiName = 'eDonusum';
+
+  getParamsGeneral = () =>
+    this.restService.request<any, any>(
+      {
+        method: 'GET',
+        url: '/api/e-donusum/params-generals/get-params-general',
+      },
+      { apiName: this.apiName }
+    );
+
+  constructor(private restService: RestService) {}
+}

package/src/lib/hit-proxy/hit-params-integrators/hit-params-integrator.service.ts

@@ -0,0 +1,20 @@
+import { RestService } from '@abp/ng.core';
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HitParamsIntegratorsService {
+  apiName = 'eDonusum';
+
+  getParamsIntegrator = (branchId?:string) =>
+    this.restService.request<any, any>(
+      {
+        method: 'GET',
+        url: `/api/e-donusum/params-integrators/get-params-integrator/${branchId}`,
+      },
+      { apiName: this.apiName }
+    );
+
+  constructor(private restService: RestService) {}
+}

package/src/lib/hit-proxy/hit-params-invoices/hit-params-invoice.service.ts

@@ -0,0 +1,20 @@
+import { RestService } from '@abp/ng.core';
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HitParamsInvoicesService {
+  apiName = 'eDonusum';
+
+  getParamsInvoice = () =>
+    this.restService.request<any, any>(
+      {
+        method: 'GET',
+        url: '/api/e-donusum/paramse-invoices/get-params-invoice',
+      },
+      { apiName: this.apiName }
+    );
+
+  constructor(private restService: RestService) {}
+}

package/src/lib/hit-proxy/hit-scenario-types/hit-scenario-type.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { DevexpressRestService } from '../devexpress-query-builder/devexpress-query-builder';
+import { RestService } from '@abp/ng.core';
+import { EnumDto } from '../hit-note-rules/models';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HitScenarioTypesService {
+  apiName = 'eDonusum';
+
+  LoadScenarioTypes = this.devexService.createStore({
+    key: 'id',
+    loadUrl: 'api/e-donusum/scenario-types/load-scenario-types',
+  });
+
+  getScenarioTypesLookup = () =>
+    this.restService.request<any, EnumDto[]>(
+      {
+        method: 'GET',
+        url: '/api/e-donusum/scenario-types/get-scenario-type-lookup',
+      },
+      { apiName: this.apiName }
+    );
+
+  constructor(private restService: RestService,private devexService: DevexpressRestService) {}
+}

package/src/lib/hit-proxy/hit-xslt-formats/hit-xslt-format.service.ts

@@ -0,0 +1,57 @@
+import { RestService } from "@abp/ng.core";
+import { Injectable } from "@angular/core";
+import { DevexpressRestService } from "../devexpress-query-builder/devexpress-query-builder";
+import { NoteRuleCreateDto, NoteRuleDto } from "../../proxy/note-rules";
+import { EnumDto, HitXsltFormatCreateDto } from "./models";
+import { XsltFormatCreateDto, XsltFormatDto, XsltFormatUpdateDto } from "../../proxy/xslt-formats";
+
+@Injectable({
+    providedIn: 'root',
+})
+export class HitXsltFormatService {
+    apiName = 'eDonusum';
+
+    LoadXsltFormats = this.devexService.createStore({
+        key: "id",
+        loadUrl: 'api/e-donusum/xslt-formats/load-xslt-formats'
+    })
+
+    LoadXsltFormatsWithParam = (docType: number) => this.devexService.createStore({
+        key: "id",
+        loadUrl: `api/e-donusum/xslt-formats/load-xslt-formats-with-param/${docType}`
+    })
+
+    getTypes = () =>
+        this.restService.request<any, EnumDto[]>({
+            method: 'GET',
+            url: '/api/e-donusum/xslt-formats/get-types',
+        },
+            { apiName: this.apiName });
+
+    create = (input: HitXsltFormatCreateDto) =>
+        this.restService.request<any, XsltFormatDto>({
+            method: 'POST',
+            url: '/api/e-donusum/xslt-formats/hit-xslt-format-create',
+            body: input,
+        },
+            { apiName: this.apiName });
+
+    update = (id: string, input: XsltFormatUpdateDto) =>
+        this.restService.request<any, XsltFormatDto>({
+            method: 'POST',
+            url: `/api/e-donusum/xslt-formats/hit-xslt-format-update/${id}`,
+            body: input,
+        },
+            { apiName: this.apiName });
+
+    downloadXsltFile = (id: string) =>
+        this.restService.request<any, any>(
+            {
+                method: 'GET',
+                url: `/api/e-donusum/xslt-formats/hit-download-xslt-file/${id}`,
+            },
+            { apiName: this.apiName });
+
+    constructor(private restService: RestService, private devexService: DevexpressRestService) { }
+
+}

package/src/lib/hit-proxy/hit-xslt-formats/models.ts

@@ -0,0 +1,12 @@
+import { XsltFormatCreateDto } from "../../proxy/xslt-formats";
+import { ContentMasterInputDto } from "../hit-content-master/models";
+
+export interface EnumDto {
+    id: number;
+    displayName: string;
+}
+
+export interface HitXsltFormatCreateDto{
+    xsltFormat: XsltFormatCreateDto;
+    selectedFile: ContentMasterInputDto;
+}

package/src/lib/hit-proxy/hit-xslt-rule-doc-types/hit-xslt-rule-doc-type.service.ts

@@ -0,0 +1,20 @@
+import { RestService } from "@abp/ng.core";
+import { Injectable } from "@angular/core";
+import { XsltRuleDocTypeDto } from "../../proxy/xslt-rule-doc-types";
+
+@Injectable({
+    providedIn: 'root',
+})
+export class HitXsltRuleDocTypesService {
+    apiName = 'eDonusum';
+
+    getSelectedDocTypes = (xsltRuleId: string) =>
+        this.restService.request<any, XsltRuleDocTypeDto[]>({
+            method: 'GET',
+            url: '/api/e-donusum/xslt-rule-doc-types/get-selected-doc-types',
+            params: {xsltRuleId: xsltRuleId}
+        },
+            { apiName: this.apiName });
+
+    constructor(private restService: RestService) { }
+}

package/src/lib/hit-proxy/hit-xslt-rule-scenarios/hit-xslt-rule-scenario.service.ts

@@ -0,0 +1,20 @@
+import { RestService } from "@abp/ng.core";
+import { Injectable } from "@angular/core";
+import { XsltRuleScenarioDto } from "../../proxy/xslt-rule-scenarios";
+
+@Injectable({
+    providedIn: 'root',
+})
+export class HitXsltRuleScenariosService {
+    apiName = 'eDonusum';
+
+    getSelectedScenarios = (xsltRuleId: string) =>
+        this.restService.request<any, XsltRuleScenarioDto[]>({
+            method: 'GET',
+            url: '/api/e-donusum/xslt-rule-scenarios/get-selected-scenarios',
+            params: {xsltRuleId: xsltRuleId}
+        },
+            { apiName: this.apiName });
+
+    constructor(private restService: RestService) { }
+}

package/src/lib/hit-proxy/hit-xslt-rules/hit-xslt-rule.service.ts

@@ -0,0 +1,71 @@
+import { RestService } from "@abp/ng.core";
+import { Injectable } from "@angular/core";
+import { DevexpressRestService } from "../devexpress-query-builder/devexpress-query-builder";
+import { NoteRuleCreateDto, NoteRuleDto } from "../../proxy/note-rules";
+import { HitXsltRuleCreateDto, HitXsltRuleUpdateDto, PreviewRuleRequestDto } from "./models";
+import { XsltRuleDto } from "../../proxy/xslt-rules";
+import { EnumDto } from "../hit-xslt-formats/models";
+
+@Injectable({
+    providedIn: 'root',
+})
+export class HitXsltRulesService {
+    apiName = 'eDonusum';
+
+    LoadXsltRules = this.devexService.createStore({
+        key: "xsltRule.id",
+        loadUrl: 'api/e-donusum/xslt-rules/load-xslt-rules'
+    })
+
+    create = (input: HitXsltRuleCreateDto) =>
+        this.restService.request<any, XsltRuleDto>({
+            method: 'POST',
+            url: '/api/e-donusum/xslt-rules/hit-create-xslt-rule',
+            body: input,
+        },
+            { apiName: this.apiName });
+
+    update = (id: string, input: HitXsltRuleUpdateDto) =>
+        this.restService.request<any, XsltRuleDto>({
+            method: 'POST',
+            url: `/api/e-donusum/xslt-rules/hit-update-xslt-rule/${id}`,
+            body: input,
+        },
+            { apiName: this.apiName });
+
+    delete = (id: string) =>
+        this.restService.request<any, void>({
+            method: 'DELETE',
+            url: `/api/e-donusum/xslt-rules/${id}`,
+        },
+            { apiName: this.apiName });
+
+    LoadDocTypes = this.devexService.createStore({
+        key: "id",
+        loadUrl: 'api/e-donusum/xslt-rules/load-doc-types'
+    })
+
+    LoadScenarios = this.devexService.createStore({
+        key: "id",
+        loadUrl: 'api/e-donusum/xslt-rules/load-scenarios'
+    })
+
+    getParamNames = () =>
+        this.restService.request<any, EnumDto[]>({
+            method: 'GET',
+            url: '/api/e-donusum/xslt-rules/get-param-names',
+        },
+            { apiName: this.apiName });
+
+
+    previewRuleResult = (requestDto: PreviewRuleRequestDto) =>
+        this.restService.request<any, any>({
+            method: 'POST',
+            url: '/api/e-donusum/xslt-rules/preview-rule-result',
+            body: requestDto
+        },
+            { apiName: this.apiName });
+
+    constructor(private restService: RestService, private devexService: DevexpressRestService) { }
+
+}

package/src/lib/hit-proxy/hit-xslt-rules/models.ts

@@ -0,0 +1,42 @@
+import { XsltRuleDocTypeCreateDto, XsltRuleDocTypeUpdateDto } from "../../proxy/xslt-rule-doc-types";
+import { XsltRuleScenarioCreateDto, XsltRuleScenarioUpdateDto } from "../../proxy/xslt-rule-scenarios";
+import { XsltRuleCreateDto, XsltRuleUpdateDto } from "../../proxy/xslt-rules";
+
+export interface XsltRuleCreateOrUpdateDto extends XsltRuleUpdateDto {
+    id: string;
+}
+
+export interface HitXsltRuleCreateDto {
+    xsltRule: XsltRuleCreateOrUpdateDto,
+    xsltRuleScenarios: XsltRuleScenarioCreateDto[],
+    xsltRuleDocTypes: XsltRuleDocTypeCreateDto[]
+}
+
+export interface HitXsltRuleUpdateDto{
+    xsltRule: XsltRuleCreateOrUpdateDto,
+    xsltRuleScenarios: HitXsltRuleScenarioUpdateDto[];
+    xsltRuleDocTypes: HitXsltRuleDocTypeUpdateDto[];
+}
+
+export interface HitXsltRuleDocTypeUpdateDto extends XsltRuleDocTypeUpdateDto{
+    id: string;
+}
+
+export interface HitXsltRuleScenarioUpdateDto extends XsltRuleScenarioUpdateDto{
+    id: string;
+}
+
+export interface EnumDto {
+    id: number;
+    displayName: string;
+}
+
+export interface PreviewRuleRequestDto {
+    xsltRule: XsltRuleCreateDto;
+    ruleParameters: RuleParameters[];
+}
+
+export interface RuleParameters {
+    paramName: string;
+    paramValue: string;
+}