@hitsoft/e-donusum 1.0.5

package/src/lib/components/hit-note-rules/hit-note-rule.component.ts

@@ -0,0 +1,388 @@
+import { ABP, isNullOrEmpty, isNullOrUndefined, ListService, PagedResultDto } from '@abp/ng.core';
+import { Confirmation, ConfirmationService, ToasterService } from '@abp/ng.theme.shared';
+import { DateAdapter } from '@abp/ng.theme.shared/extensions';
+import { ChangeDetectionStrategy, Component, HostListener, OnInit, ViewChild } from '@angular/core';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { NgbDateAdapter } from '@ng-bootstrap/ng-bootstrap';
+import { NoteRuleCreateDto, NoteRuleDto, NoteRuleService } from '../../proxy/note-rules';
+import { DxDataGridComponent, DxHtmlEditorComponent } from 'devextreme-angular';
+import { finalize, tap, filter, switchMap } from 'rxjs';
+import { HitNoteRulesService } from '../../hit-proxy/hit-note-rules/hit-note-rule.service';
+import dxHtmlEditor from 'devextreme/ui/html_editor';
+import { HitNoteRuleCreateDto, NoteRuleCreateOrUpdateDto, PreviewQueryRequestDto } from '../../hit-proxy/hit-note-rules/models';
+import { NoteRuleDocTypeCreateDto } from '../../proxy/note-rule-doc-types';
+import { NoteRuleScenarioCreateDto } from '../../proxy/note-rule-scenarios';
+import { HitNoteRuleDocTypesService } from '../../hit-proxy/hit-note-rule-doc-types/hit-note-rule-doc-type.service';
+import { HitNoteRuleScenariosService } from '../../hit-proxy/hit-note-rule-scenarios/hit-note-rule-scenario.service';
+
+@Component({
+    selector: 'lib-note-rule',
+    changeDetection: ChangeDetectionStrategy.Default,
+    providers: [ListService, { provide: NgbDateAdapter, useClass: DateAdapter }],
+    templateUrl: './hit-note-rule.component.html',
+    styles: [],
+})
+export class HitNoteRuleComponent implements OnInit {
+    @ViewChild('dxNoteRuleInstance', { static: false }) dxNoteRuleInstance: DxDataGridComponent
+    @ViewChild('dxDocTypeInstance', { static: false }) dxDocTypeInstance: DxDataGridComponent
+    @ViewChild('dxScenarioInstance', { static: false }) dxScenarioInstance: DxDataGridComponent
+    @ViewChild('dxParamInstance', { static: false }) dxParamInstance: DxDataGridComponent
+    @ViewChild('dxHtmlEditor', { static: false }) dxHtmlEditor: dxHtmlEditor;
+
+    noteRuleDataSource: any
+    isQueryable = true;
+
+    enterPressed = false;
+
+    scenarioDataSource: any
+    selectedScenarios = [];
+
+    docTypeDataSource: any
+    selectedDocTypes = [];
+
+    ruleTypesDataSource: any;
+    descTypesDataSource: any;
+    tablesDataSource = [];
+    paramNamesDataSource = [];
+    htmlMentionDataSource = [];
+
+    previewDataSource: [] = [];
+    paramsDataSource = [];
+    isParameterless = false;
+    isModalBusyPreview = false;
+    isModalOpenPreview = false;
+
+    form: FormGroup;
+    isModalBusy = false;
+    isModalOpen = false;
+    isUpdate = false;
+    selected?: NoteRuleDto;
+
+    constructor(
+        public readonly list: ListService,
+        public readonly service: NoteRuleService,
+        private readonly hitNoteRuleService: HitNoteRulesService,
+        private readonly hitNoteRuleDocTypeService: HitNoteRuleDocTypesService,
+        private readonly hitNoteRuleScenarioService: HitNoteRuleScenariosService,
+        private readonly toasterService: ToasterService,
+        private confirmation: ConfirmationService,
+        private fb: FormBuilder
+    ) { }
+
+    ngOnInit() {
+        this.noteRuleDataSource = this.hitNoteRuleService.LoadNoteRules;
+        this.scenarioDataSource = this.hitNoteRuleService.LoadScenarios;
+        this.docTypeDataSource = this.hitNoteRuleService.LoadDocTypes;
+
+        this.hitNoteRuleService.getRuleTypes().subscribe(list => {
+            this.ruleTypesDataSource = list;
+            console.log(this.ruleTypesDataSource);
+        })
+
+        this.hitNoteRuleService.getDescTypes().subscribe(list => {
+            this.descTypesDataSource = list;
+        })
+
+        this.hitNoteRuleService.getTableNames().subscribe(list => {
+            list.forEach(element => {
+                this.tablesDataSource.push({
+                    text: element.displayName,
+                    id: element.id,
+                    icon: "/assets/images/table-icon.png"
+                })
+                this.htmlMentionDataSource.push({
+                    text: element.displayName,
+                    id: element.id,
+                    icon: "/assets/images/table-icon.png"
+                })
+            });
+        })
+        this.hitNoteRuleService.getParamNames().subscribe(list => {
+            list.forEach(element => {
+                this.htmlMentionDataSource.push({
+                    text: element.displayName,
+                    id: element.id,
+                    icon: "/assets/images/key-icon.png"
+                })
+            })
+        })
+    }
+
+    buildForm() {
+        const {
+            ruleName,
+            ruleType,
+            descType,
+            orderNo,
+            firstDesc,
+            lastDesc,
+            noteQuery,
+            noteQueryHTML,
+            fixDesc,
+            isBold,
+            isPassive,
+            desc,
+            document
+        } = this.selected || {};
+        debugger;
+        this.form = this.fb.group({
+            ruleName: [ruleName ?? null, [Validators.required, Validators.maxLength(256)]],
+            ruleType: [ruleType ?? this.ruleTypesDataSource[0].id, []],
+            descType: [descType ?? this.descTypesDataSource[0].id, []],
+            document: [document ?? this.tablesDataSource[0].id, []],
+            orderNo: [orderNo ?? 0, [Validators.min(0)]],
+            firstDesc: [firstDesc ?? null, []],
+            lastDesc: [lastDesc ?? null, []],
+            noteQuery: [noteQuery ?? null, []],
+            noteQueryHTML: [noteQueryHTML ?? null, []],
+            fixDesc: [fixDesc ?? null, []],
+            isBold: [isBold ?? false, []],
+            isPassive: [isPassive ?? false, []],
+            desc: [desc ?? null, [Validators.maxLength(512)]],
+        });
+        debugger;
+        if (this.form.controls.ruleType.value == 0) {
+            this.isQueryable = true;
+        }
+        else {
+            this.isQueryable = false;
+        }
+
+    }
+
+    hideForm() {
+        this.isModalOpen = false;
+        this.form.reset();
+    }
+
+    showForm() {
+        this.buildForm();
+        this.isModalOpen = true;
+    }
+
+    previewQuery() {
+        
+        if (this.isQueryable && !isNullOrEmpty(this.form.controls.ruleName.value)) {
+            let noteRuleReq = this.form.value as NoteRuleCreateDto
+            this.previewDataSource = [];
+            this.paramsDataSource = [];
+
+            let noteQuery = this.stripHTML(noteRuleReq.noteQueryHTML);
+
+            if (this.form.controls.descType.value === 1) {
+                if (!this.checkLineQuery(noteQuery)) {
+                    this.toasterService.error("Seçili açıklama türü için sorgu içerisinde BelgeDetayKey bulunmak zorundadır.");
+                    return;
+                }
+            }
+
+            const tableName = this.checkTableAfterFrom(noteQuery);
+
+            if (!tableName) {
+                this.toasterService.error("Seçili tablo ile sorguda başlanılan tablo aynı olmalı.");
+                return;
+            }
+
+            let params = noteQuery.match(/(BelgeKey|BelgeDetayKey)/g);
+
+            if (!isNullOrUndefined(params)) {
+                this.paramsDataSource = [];
+                params.forEach(element => {
+                    this.paramsDataSource.push({
+                        paramName: element.replace(":", ""),
+                        paramValue: ""
+                    })
+                })
+            }
+
+            if (isNullOrEmpty(this.paramsDataSource) || this.paramsDataSource.length == 0) {
+                this.toasterService.info('eDonusum::QueryPreviewIsPreparing')
+                this.isParameterless = true;
+                this.runQuery();
+            }
+            else {
+                this.isParameterless = false;
+            }
+
+            this.isModalOpenPreview = true;
+        }
+        else {
+            this.toasterService.info('eDonusum::QueryPreviewOnlyUsingByQueryDesc')
+        }
+
+    }
+
+    ruleTypeChanged() {
+        if (this.form.controls.ruleType.value == 0) {
+            this.isQueryable = true;
+        }
+        else {
+            this.isQueryable = false;
+        }
+        this.form.controls.noteQueryHTML.setValue("");
+        this.form.controls.noteQuery.setValue("");
+        this.form.controls.fixDesc.setValue("");
+    }
+
+    documentChanged() {
+        this.form.controls.noteQueryHTML.setValue("");
+        this.form.controls.noteQuery.setValue("");
+        this.form.controls.fixDesc.setValue("");
+    }
+
+    runQuery() {
+        
+        let paramValues = [];
+
+        if (!this.isParameterless) {
+            this.toasterService.info('eDonusum::QueryPreviewIsPreparing')
+
+            this.dxParamInstance.instance.getVisibleRows().forEach(element => {
+                paramValues.push({
+                    paramName: element.data.paramName,
+                    paramValue: element.data.paramValue
+                });
+            })
+        }
+
+        let noteRuleReq = this.form.value as NoteRuleCreateDto
+
+        let requestDto: PreviewQueryRequestDto = {
+            noteRule: noteRuleReq,
+            parameters: paramValues
+        }
+
+        this.hitNoteRuleService.previewQueryResult(requestDto).subscribe(result => {
+            this.previewDataSource = result.value
+
+            if (this.previewDataSource.length > 0)
+                this.toasterService.success('eDonusum::QueryPreviewIsReady')
+            else
+                this.toasterService.warn('eDonusum::QueryPreviewNoResult')
+        })
+    }
+
+    @HostListener('document:keydown', ['$event'])
+    handleKeyDown(event: KeyboardEvent) {
+        if (event.key === 'Enter') {
+            this.enterPressed = true;
+        }
+    }
+
+    submitForm() {
+        
+        if(this.enterPressed){
+            this.enterPressed = false;
+            return;
+        } 
+
+        if (this.form.invalid) return;
+
+        let noteRuleReq = this.form.value as NoteRuleCreateOrUpdateDto
+        let noteRuleScenariosReq = [];
+        let noteRuleDocTypesReq = [];
+
+        this.dxScenarioInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {
+            noteRuleScenariosReq.push({
+                noteRuleId: this.selected?.id,
+                scenario: element.data.id
+            })
+        })
+
+        this.dxDocTypeInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {
+            noteRuleDocTypesReq.push({
+                noteRuleId: this.selected?.id,
+                docType: element.data.id
+            })
+        })
+
+        noteRuleReq.concurrencyStamp = this.selected?.concurrencyStamp;
+        noteRuleReq.id = this.selected?.id
+
+        const request = this.selected
+            ? this.hitNoteRuleService.update(this.selected.id, {
+                noteRules: noteRuleReq,
+                noteRuleScenarios: noteRuleScenariosReq,
+                noteRuleDocTypes: noteRuleDocTypesReq
+            })
+            : this.hitNoteRuleService.create(
+                {
+                    noteRules: noteRuleReq,
+                    noteRuleScenarios: noteRuleScenariosReq,
+                    noteRuleDocTypes: noteRuleDocTypesReq
+                });
+
+        this.isModalBusy = true;
+
+        request
+            .pipe(
+                finalize(() => (this.isModalBusy = false)),
+                tap(() => this.hideForm())
+            )
+            .subscribe(() => this.dxNoteRuleInstance.instance.refresh());
+    }
+
+    create() {
+        this.isUpdate = false;
+        this.selected = undefined;
+        this.previewDataSource = [];
+        this.selectedScenarios = [];
+        this.selectedDocTypes = [];
+        this.showForm();
+    }
+
+    update(record: NoteRuleDto) {
+        this.isUpdate = true;
+        this.selected = record;
+        this.previewDataSource = [];
+        this.hitNoteRuleScenarioService.getSelectedScenarios(this.selected.id).subscribe(list => {
+            this.selectedScenarios = list.map(i => i.scenario);
+        })
+
+        this.hitNoteRuleDocTypeService.getSelectedDocTypes(this.selected.id).subscribe(list => {
+            this.selectedDocTypes = list.map(i => i.docType);
+        })
+
+        this.showForm();
+    }
+
+    delete(record: NoteRuleDto) {
+        this.confirmation
+            .warn('eDonusum::DeleteConfirmationMessage', 'eDonusum::AreYouSure', {
+                messageLocalizationParams: [],
+            })
+            .pipe(
+                filter(status => status === Confirmation.Status.confirm),
+                switchMap(() => this.service.delete(record.id))
+            )
+            .subscribe(() => this.dxNoteRuleInstance.instance.refresh());
+    }
+
+    stripHTML(input: string): string {
+        const strippedHtml = input.replace("</p><p>", " ");
+        return strippedHtml.replace(/@/g, '').replace(/<.*?>/g, '');
+    }
+
+    checkTableAfterFrom(query: string): boolean {
+        const regex = /FROM\s+([@\w]+)/i;
+        const selectedTableName = this.tablesDataSource.filter(i => i.id == this.form.controls.document.value)[0].text
+        const match = query.match(regex);
+
+        if (match && match[1]) {
+            const tableName = match[1];
+            if (tableName === ("@" + selectedTableName) || tableName === selectedTableName) {
+                return true
+            }
+        }
+
+        return false;
+    }
+
+    checkLineQuery(query: string): boolean {
+
+        if (query.includes("BelgeDetayKey"))
+            return true;
+        else
+            return false;
+    }
+}

package/src/lib/components/hit-note-rules/hit-note-rule.module.ts

@@ -0,0 +1,40 @@
+import { CoreModule } from '@abp/ng.core';
+import { ThemeSharedModule } from '@abp/ng.theme.shared';
+import { NgModule } from '@angular/core';
+import {
+  NgbCollapseModule,
+  NgbDatepickerModule,
+  NgbDropdownModule,
+} from '@ng-bootstrap/ng-bootstrap';
+import { NgxValidateCoreModule } from '@ngx-validate/core';
+import { CommercialUiModule } from '@volo/abp.commercial.ng.ui';
+import { PageModule } from '@abp/ng.components/page';
+import { HitNoteRuleComponent } from './hit-note-rule.component';
+import { DxDataGridModule, DxHtmlEditorModule, DxLookupModule, DxSelectBoxModule, DxTabPanelModule, DxTextAreaModule, DxTextBoxModule } from 'devextreme-angular';
+import dxTextBox from 'devextreme/ui/text_box';
+
+@NgModule({
+  declarations: [HitNoteRuleComponent],
+  imports: [
+    CoreModule,
+    ThemeSharedModule,
+    CommercialUiModule,
+    NgxValidateCoreModule,
+    NgbCollapseModule,
+    NgbDatepickerModule,
+    NgbDropdownModule,
+    DxDataGridModule,
+    DxTextAreaModule,
+    DxTextBoxModule,
+    DxHtmlEditorModule,
+    DxSelectBoxModule,
+    DxLookupModule,
+    DxTabPanelModule,
+    PageModule,
+  ],
+})
+export class HitNoteRuleModule {}
+
+export function loadHitNoteRuleModuleAsChild() {
+  return Promise.resolve(HitNoteRuleModule);
+}

package/src/lib/components/hit-paramas-invoices/hit-params-invoice.component.html

@@ -0,0 +1,90 @@
+<div class="card">
+    <div class="card-body">
+        <form [formGroup]="formParamsInvoice" id="params-invoice" (ngSubmit)="submitForm()" validateOnSubmit>
+            <div class="row">
+                <div class="col-sm-2">
+                    <div class="mb-3">
+                        <label class="form-label" for="params-invoice-default-inv-serial">
+                            {{ 'eDonusum::DefaultInvSerial' | abpLocalization }} *
+                        </label>
+
+                        <input id="params-invoice-default-inv-serial" formControlName="defaultInvSerial"
+                            class="form-control" maxlength="8" autofocus />
+                    </div>
+                </div>
+            </div>
+            <div class="row">
+                <div class="col-sm-6">
+                    <div class="form-check mb-3">
+                        <input type="checkbox" id="params-invoice-use-default-scenario" formControlName="useDefScenario"
+                            class="form-check-input" />
+
+                        <label for="params-invoice-use-default-scenario" class="form-check-label">
+                            {{ 'eDonusum::UseDefScenario' | abpLocalization }}
+                        </label>
+                    </div>
+                </div>
+            </div>
+            <div class="row" *ngIf="formParamsInvoice.controls.useDefScenario.value">
+                <div class="col-sm-6">
+                    <div class="mb-3">
+                        <label for="params-invoice-default-scenario" class="form-check-label">
+                            {{ 'eDonusum::DefaultScenario' | abpLocalization }}
+                        </label>
+
+                        <dx-select-box id="params-invoice-default-scenario" formControlName="defaultScenario"
+                            class="form-control" displayExpr="displayName" valueExpr="id"
+                            [dataSource]="scenarioTypeDataSource">
+                        </dx-select-box>
+                    </div>
+                </div>
+            </div>
+            <div class="row">
+                <div class="col-sm-6">
+                    <div class="form-check mb-3">
+                        <input type="checkbox" id="params-invoice-use-def-inv-type" formControlName="useDefInvType"
+                            class="form-check-input" />
+
+                        <label for="params-invoice-use-def-inv-type" class="form-check-label">
+                            {{ 'eDonusum::UseDefInvType' | abpLocalization }}
+                        </label>
+                    </div>
+                </div>
+            </div>
+            <div class="row" *ngIf="formParamsInvoice.controls.useDefInvType.value">
+                <div class="col-sm-6">
+                    <div class="mb-3">
+                        <label for="params-invoice-default-inv-type" class="form-check-label">
+                            {{ 'eDonusum::DefaultInvType' | abpLocalization }}
+                        </label>
+                        
+                        <dx-select-box id="params-invoice-default-inv-type" formControlName="defaultInvType"
+                            class="form-control" displayExpr="displayName" valueExpr="id"
+                            [dataSource]="documentTypeDataSource">
+                        </dx-select-box>
+                    </div>
+                </div>
+            </div>
+            <div class="row">
+                <div class="col-sm-6">
+                    <div class="form-check mb-3">
+                        <input type="checkbox" id="params-invoice-is-shipping-address"
+                            formControlName="isShippingAddress" class="form-check-input" />
+
+                        <label for="params-invoice-is-shipping-address" class="form-check-label">
+                            {{ 'eDonusum::IsShippingAddress' | abpLocalization }}
+                        </label>
+                    </div>
+                </div>
+            </div>
+        </form>
+        <div class="row">
+            <div class="col-sm-12 text-lg-end">
+                <abp-button iconClass="fa fa-check" buttonType="submit" formName="params-invoice"
+                    [disabled]="submitButtonDisabled" [hidden]="IsSubmitButtonHidden">
+                    {{ 'AbpUi::Save' | abpLocalization }}
+                </abp-button>
+            </div>
+        </div>
+    </div>
+</div>

package/src/lib/components/hit-paramas-invoices/hit-params-invoice.component.ts

@@ -0,0 +1,147 @@
+import { ABP, downloadBlob, ListService, PagedResultDto, TrackByService } from '@abp/ng.core';
+import { ConfirmationService, ToasterService } from '@abp/ng.theme.shared';
+import { DateAdapter } from '@abp/ng.theme.shared/extensions';
+import {
+  ChangeDetectionStrategy,
+  Component,
+  EventEmitter,
+  Injectable,
+  Input,
+  OnInit,
+  Output,
+} from '@angular/core';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { NgbDateAdapter } from '@ng-bootstrap/ng-bootstrap';
+import { finalize, tap } from 'rxjs';
+import { HitParamsInvoicesService } from '../../hit-proxy/hit-params-invoices/hit-params-invoice.service';
+import { HitScenarioTypesService } from '../../hit-proxy/hit-scenario-types/hit-scenario-type.service';
+import { HitDocumentTypesService } from '../../hit-proxy/hit-document-types/hit-document-type.service';
+import { ParamseInvoiceDto, ParamseInvoiceService } from '../../proxy/paramse-invoices';
+@Component({
+  selector: 'hit-params-invoice',
+  changeDetection: ChangeDetectionStrategy.Default,
+  providers: [ListService, { provide: NgbDateAdapter, useClass: DateAdapter }],
+  templateUrl: './hit-params-invoice.component.html',
+  styles: [],
+})
+export class HitParamsInvoiceComponent implements OnInit {
+  formParamsInvoice: FormGroup;
+
+  paramsInvoiceDto?: ParamseInvoiceDto;
+
+  submitButtonDisabled = false;
+
+  scenarioTypeDataSource: any;
+  documentTypeDataSource: any;
+
+  @Input() IsSubmitButtonHidden = false;
+
+  @Output() valid = new EventEmitter<boolean>();
+
+  constructor(
+    public readonly list: ListService,
+    public readonly track: TrackByService,
+    public readonly service: ParamseInvoiceService,
+    private confirmation: ConfirmationService,
+    private fb: FormBuilder,
+    private readonly hitParamsInvoicesService: HitParamsInvoicesService,
+    private readonly toasterService: ToasterService,
+    private readonly hitScenarioTypesService: HitScenarioTypesService,
+    private readonly hitDocumentTypesService: HitDocumentTypesService
+  ) {}
+
+  async ngOnInit() {
+    this.buildForm();
+
+    this.hitScenarioTypesService.getScenarioTypesLookup().subscribe(data => {
+      this.scenarioTypeDataSource = data;
+    });
+
+    this.hitDocumentTypesService.getDocumentTypesLookup().subscribe(data => {
+      this.documentTypeDataSource = data;
+    });
+
+    await this.getParamsInvoice(true);
+  }
+
+  buildForm() {
+    const {
+      defaultScenario,
+      defaultInvType,
+      defaultInvSerial,
+      isShippingAddress,
+      useDefScenario,
+      useDefInvType,
+    } = this.paramsInvoiceDto || {};
+
+    this.formParamsInvoice = this.fb.group({
+      defaultScenario: [defaultScenario ?? false, []],
+      defaultInvType: [defaultInvType ?? false, []],
+      defaultInvSerial: [defaultInvSerial ?? null, [Validators.required, Validators.maxLength(3)]],
+      isShippingAddress: [isShippingAddress ?? false, []],
+      useDefScenario: [useDefScenario ?? false, []],
+      useDefInvType: [useDefInvType ?? false, []],
+    });
+  }
+
+  submitForm() {
+    if (this.formParamsInvoice.controls.defaultInvSerial.value.length > 3) {
+      this.toasterService.error('eDonusum::EnterMax3Character');
+    }
+
+    if (this.formParamsInvoice.invalid) {
+      window.scroll({
+        top: 0,
+        left: 0,
+        behavior: 'smooth',
+      });
+      return;
+    }
+
+    this.submitButtonDisabled = true;
+
+    // this.toasterService.info('eDonusum::TransactionStarted');
+    
+    if (!this.formParamsInvoice.controls.defaultScenario.value)
+      this.formParamsInvoice.controls.defaultScenario.setValue(0);
+    
+    if (!this.formParamsInvoice.controls.defaultInvType.value)
+      this.formParamsInvoice.controls.defaultInvType.setValue(0);
+
+    const request = this.paramsInvoiceDto
+      ? this.service.update(this.paramsInvoiceDto.id, {
+          ...this.formParamsInvoice.value,
+        })
+      : this.service.create(this.formParamsInvoice.value);
+
+    request
+      .pipe(
+        finalize(() => {
+          this.submitButtonDisabled = false;
+        }),
+        tap(() => {})
+      )
+      .subscribe(
+        async () => {
+          // this.toasterService.success('eDonusum::TransactionSuccessful');
+
+          await this.getParamsInvoice();
+
+          this.valid.emit(true);
+        },
+        err => {
+          this.toasterService.error('eDonusum::TransactionUnsuccessful');
+
+          this.valid.emit(true);
+        }
+      );
+  }
+
+  async getParamsInvoice(buildForm: boolean = false) {
+    this.hitParamsInvoicesService.getParamsInvoice().subscribe(data => {
+      this.paramsInvoiceDto = data;
+
+      if (buildForm) this.buildForm();
+    });
+  }
+}

package/src/lib/components/hit-paramas-invoices/hit-params-invoice.module.ts

@@ -0,0 +1,20 @@
+import { CoreModule } from '@abp/ng.core';
+import { ThemeSharedModule } from '@abp/ng.theme.shared';
+import { NgModule } from '@angular/core';
+import { NgxValidateCoreModule } from '@ngx-validate/core';
+import { CommercialUiModule } from '@volo/abp.commercial.ng.ui';
+import { HitParamsInvoiceComponent } from './hit-params-invoice.component';
+import { DxSelectBoxModule } from 'devextreme-angular';
+
+@NgModule({
+  declarations: [HitParamsInvoiceComponent],
+  imports: [
+    CoreModule,
+    ThemeSharedModule,
+    CommercialUiModule,
+    NgxValidateCoreModule,
+    DxSelectBoxModule
+  ],
+  exports:[HitParamsInvoiceComponent],
+})
+export class HitParamsInvoiceModule {}