@acorex/modules 19.3.0-next.4 → 19.3.0

package/fesm2022/acorex-modules-issue-management-acorex-modules-issue-management-DhuDuKkz.mjs

@@ -0,0 +1,2486 @@
+import { createAllQueryView, AXPEntityCommandScope, AXPEntityQueryType, AXPDataGenerator, AXPRefreshEvent, AXPFileStorageService, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER } from '@acorex/platform/common';
+import * as i11 from '@acorex/platform/layout/builder';
+import { AXPWidgetsCatalog, AXPLayoutBuilderModule } from '@acorex/platform/layout/builder';
+import { AXMEntityCrudServiceImpl, AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import * as i0 from '@angular/core';
+import { Injectable, inject, Injector, ApplicationRef, ViewContainerRef, computed, ViewChild, Component, NgModule } from '@angular/core';
+import * as i1$1 from '@acorex/platform/workflow';
+import { AXPWorkflowEventService, AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
+import * as i10 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import { AXDataSource } from '@acorex/components/common';
+import * as i3$1 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i4 from '@acorex/components/form';
+import { AXFormModule, AXFormComponent } from '@acorex/components/form';
+import * as i5 from '@acorex/components/label';
+import { AXLabelModule } from '@acorex/components/label';
+import { AXMediaViewerModule } from '@acorex/components/media-viewer';
+import { AXBasePageComponent } from '@acorex/components/page';
+import * as i7 from '@acorex/components/select-box';
+import { AXSelectBoxModule } from '@acorex/components/select-box';
+import * as i8 from '@acorex/components/text-area';
+import { AXTextAreaModule } from '@acorex/components/text-area';
+import * as i6 from '@acorex/components/text-box';
+import { AXTextBoxModule } from '@acorex/components/text-box';
+import * as i3 from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import { AXMDocumentService } from '@acorex/modules/document-management';
+import { AXPSessionService } from '@acorex/platform/auth';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i2 from '@angular/forms';
+import { FormsModule } from '@angular/forms';
+import { AXPopupService } from '@acorex/components/popup';
+import { signalStore, withState, withMethods, patchState, withComputed } from '@ngrx/signals';
+import { AXToastService } from '@acorex/components/toast';
+import html2canvas from 'html2canvas';
+import { Subject, take } from 'rxjs';
+
+const config = {
+    i18n: 'issue-management',
+};
+const RootConfig = {
+    config,
+    module: {
+        route: 'issue-management',
+        name: 'IssueManagement',
+        title: `t('issueManagement', {scope:"${config.i18n}"})`,
+        icon: 'fa-light fa-file-invoice',
+    },
+    entities: {
+        issueType: {
+            name: 'IssueType',
+            title: `t("issue-type.individual-title", { scope: "${config.i18n}" })`,
+            titlePlural: `t("issue-type.plural-title", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-list',
+        },
+        reportedIssues: {
+            name: 'ReportedIssues',
+            title: `t("reported-issues.individual-title", { scope: "${config.i18n}" })`,
+            titlePlural: `t("reported-issues.plural-title", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-bug',
+        },
+        myReportedIssues: {
+            name: 'MyReportedIssues',
+            title: `t("my-reported-issues.individual-title", { scope: "${config.i18n}" })`,
+            titlePlural: `t("my-reported-issues.plural-title", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-message-exclamation',
+        },
+        reportNewIssue: {
+            name: 'ReportNewIssue',
+            title: `t("report-new-issue.individual-title", { scope: "${config.i18n}" })`,
+            titlePlural: `t("report-new-issue.plural-title", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-clipboard-list-check',
+        },
+    },
+};
+
+class AXMIssueTypeService extends AXMEntityCrudServiceImpl {
+}
+class AXMIssueTypeServiceImpl extends AXMIssueTypeService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.issueType.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMIssueTypeServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMIssueTypeServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMIssueTypeServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function issueTypeEntityFactory(injector) {
+    const dataService = injector.get(AXMIssueTypeService);
+    const i18n = RootConfig.config.i18n;
+    const entityName = 'issue-type';
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.issueType.name,
+        source: '',
+        title: RootConfig.entities.issueType.title,
+        formats: {
+            individual: RootConfig.entities.issueType.title,
+            plural: RootConfig.entities.issueType.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: '{{ description }}',
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'main',
+                title: `t("${entityName}.main-section", { scope: "${i18n}" })`,
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: 'ID',
+                groupId: 'main',
+                schema: {
+                    dataType: 'string',
+                    hidden: true,
+                    nullable: false,
+                    readonly: true,
+                    unique: {
+                        enabled: true,
+                    },
+                },
+            },
+            {
+                name: 'title',
+                title: `t("${entityName}.title", { scope: "${i18n}" })`,
+                groupId: 'main',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'description',
+                title: `t("${entityName}.description", { scope: "${i18n}" })`,
+                groupId: 'main',
+                options: {
+                    sort: {
+                        enabled: false,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.largeText,
+                        options: {
+                            rows: 3,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'description' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'main',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'main',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'main',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMReportedIssuesService extends AXMEntityCrudServiceImpl {
+}
+class AXMReportedIssuesServiceImpl extends AXMReportedIssuesService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reportedIssues.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMReportedIssuesServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMReportedIssuesServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMReportedIssuesServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function reportedIssuesEntityFactory(injector) {
+    const dataService = injector.get(AXMReportedIssuesService);
+    const i18n = RootConfig.config.i18n;
+    const entityName = 'reported-issues';
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.reportedIssues.name,
+        source: '',
+        title: `t("${entityName}.individual-title", { scope: "${i18n}" })`,
+        formats: {
+            individual: `t("${entityName}.individual-title", { scope: "${i18n}" })`,
+            plural: `t("${entityName}.plural-title", { scope: "${i18n}" })`,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'main',
+                title: `t("${entityName}.main-section", { scope: "${i18n}" })`,
+            },
+            {
+                id: 'details',
+                title: `t("${entityName}.details-section", { scope: "${i18n}" })`,
+            },
+            {
+                id: 'system',
+                title: `t("${entityName}.system-section", { scope: "${i18n}" })`,
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: 'ID',
+                schema: {
+                    dataType: 'uuid',
+                    hidden: true,
+                    nullable: false,
+                    readonly: true,
+                    unique: {
+                        enabled: true,
+                    },
+                },
+            },
+            {
+                name: 'user',
+                title: `t("${entityName}.user", { scope: "${i18n}" })`,
+                groupId: 'main',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entityName: 'users',
+                            // textField: 'fullName',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'issueType',
+                title: `t("${entityName}.issue-type", { scope: "${i18n}" })`,
+                groupId: 'main',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entityName: 'issueType',
+                            // displayField: 'title',
+                            // valueField: 'id',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'priority',
+                title: `t("${entityName}.priority", { scope: "${i18n}" })`,
+                groupId: 'main',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            items: [
+                                { title: 'Low', id: 1 },
+                                { title: 'Medium', id: 2 },
+                                { title: 'High', id: 3 },
+                                { title: 'Critical', id: 4 },
+                            ],
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'status',
+                title: `t("${entityName}.status", { scope: "${i18n}" })`,
+                groupId: 'main',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            items: [
+                                { value: 'new', title: 'New' },
+                                { value: 'in-progress', title: 'In Progress' },
+                                { value: 'pending', title: 'Pending' },
+                                { value: 'resolved', title: 'Resolved' },
+                                { value: 'closed', title: 'Closed' },
+                            ],
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: `t("${entityName}.title", { scope: "${i18n}" })`,
+                groupId: 'main',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'description',
+                title: `t("${entityName}.description", { scope: "${i18n}" })`,
+                groupId: 'details',
+                options: {
+                    sort: {
+                        enabled: false,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.largeText,
+                        options: {
+                            rows: 4,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'attachments',
+                title: `t("${entityName}.attachments", { scope: "${i18n}" })`,
+                groupId: 'details',
+                options: {
+                    sort: {
+                        enabled: false,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: false,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'array',
+                    interface: {
+                        type: AXPWidgetsCatalog.documentAttachment,
+                        options: {
+                            multiple: true,
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.reportedIssues.name}`,
+                            record: '{{context.eval("id")}}',
+                            accept: '*/*',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'systemInfo',
+                title: `t("${entityName}.system-info", { scope: "${i18n}" })`,
+                groupId: 'system',
+                options: {
+                    sort: {
+                        enabled: false,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: false,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.metaData,
+                        options: {
+                            fields: [
+                                { name: 'browser', title: 'Browser' },
+                                { name: 'os', title: 'Operating System' },
+                                { name: 'appVersion', title: 'App Version' },
+                                { name: 'deviceType', title: 'Device Type' },
+                                { name: 'screenResolution', title: 'Screen Resolution' },
+                            ],
+                        },
+                    },
+                },
+            },
+            {
+                name: 'errorLogs',
+                title: `t("${entityName}.error-logs", { scope: "${i18n}" })`,
+                groupId: 'system',
+                options: {
+                    sort: {
+                        enabled: false,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: false,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.largeText,
+                        options: {
+                            rows: 8,
+                            readonly: true,
+                        },
+                    },
+                },
+            },
+            {
+                name: 'createdAt',
+                title: `t("${entityName}.created-at", { scope: "${i18n}" })`,
+                groupId: 'system',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            readonly: true,
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'user' },
+            { name: 'issueType' },
+            { name: 'priority' },
+            { name: 'status' },
+            { name: 'title' },
+            { name: 'description' },
+            { name: 'createdAt' },
+        ],
+        // commands: {
+        //   create: {
+        //     execute: async (data: any) => {
+        //       data.createdAt = new Date();
+        //       data.status = 'new';
+        //       const res = await dataService.insertOne(data);
+        //       return { id: res };
+        //     },
+        //   },--
+        //   delete: {
+        //     execute: async (id: any) => {
+        //       return await dataService.deleteOne(id);
+        //     },
+        //   },
+        //   update: {
+        //     execute: async (data: any) => {
+        //       return await dataService.updateOne(data.id, data);
+        //     },
+        //   },
+        // },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                // create: {
+                //   sections: [
+                //     {
+                //       id: 'main',
+                //     },
+                //     {
+                //       id: 'details',
+                //     },
+                //     {
+                //       id: 'system',
+                //     },
+                //   ],
+                //   properties: [
+                //     {
+                //       name: 'user',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 1,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'issueType',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 2,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'priority',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 3,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'status',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 4,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'title',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 5,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'description',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 6,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'attachments',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 7,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'systemInfo',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 8,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'errorLogs',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 9,
+                //           },
+                //         },
+                //       },
+                //     },
+                //   ],
+                // },
+                // update: {
+                //   sections: [
+                //     {
+                //       id: 'main',
+                //     },
+                //     {
+                //       id: 'details',
+                //     },
+                //     {
+                //       id: 'system',
+                //     },
+                //   ],
+                //   properties: [
+                //     {
+                //       name: 'user',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 1,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'issueType',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 2,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'priority',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 3,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'status',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 4,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'title',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 5,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'description',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 6,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'attachments',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 7,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'systemInfo',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 8,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'errorLogs',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //             order: 9,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'createdAt',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //             order: 11,
+                //           },
+                //         },
+                //       },
+                //     },
+                //   ],
+                // },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'main',
+                        },
+                        {
+                            id: 'details',
+                        },
+                        {
+                            id: 'system',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'user',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'issueType',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'priority',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'status',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'attachments',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 7,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'systemInfo',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 8,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'errorLogs',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 9,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'createdAt',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 11,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        // {
+                        //   title: `t("create", { scope: "common" })`,
+                        //   command: 'create-entity',
+                        //   priority: 'primary',
+                        //   type: 'create',
+                        //   scope: AXPEntityCommandScope.TypeLevel,
+                        // },
+                        // {
+                        //   title: 't("deleteItems", { scope: "common" })',
+                        //   command: 'delete-entity',
+                        //   priority: 'primary',
+                        //   type: 'delete',
+                        //   scope: AXPEntityCommandScope.Selected,
+                        // },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        // {
+                        //   title: 't("delete", { scope: "common" })',
+                        //   command: 'delete-entity',
+                        //   priority: 'secondary',
+                        //   type: 'delete',
+                        //   scope: AXPEntityCommandScope.Individual,
+                        // },
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'createdAt', dir: 'desc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMMyReportedIssuesService extends AXMEntityCrudServiceImpl {
+}
+class AXMMyReportedIssuesServiceImpl extends AXMMyReportedIssuesService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.myReportedIssues.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMMyReportedIssuesServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMMyReportedIssuesServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMMyReportedIssuesServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function myReportedIssuesEntityFactory(injector) {
+    const dataService = injector.get(AXMMyReportedIssuesService);
+    const reportedIssueDataService = injector.get(AXMReportedIssuesService);
+    const i18n = RootConfig.config.i18n;
+    const entityName = 'my-reported-issues';
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.myReportedIssues.name,
+        source: '',
+        title: `t("${entityName}.individual-title", { scope: "${i18n}" })`,
+        formats: {
+            individual: `t("${entityName}.individual-title", { scope: "${i18n}" })`,
+            plural: `t("${entityName}.plural-title", { scope: "${i18n}" })`,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: `t("${entityName}.section-title", { scope: "${i18n}" })`,
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: 'ID',
+                schema: {
+                    dataType: 'uuid',
+                    hidden: true,
+                    nullable: false,
+                    readonly: true,
+                    unique: {
+                        enabled: true,
+                    },
+                },
+            },
+            {
+                name: 'issueType',
+                title: `t("${entityName}.issue-type", { scope:"${i18n}" })`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entityName: 'issueType',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'priority',
+                title: `t("${entityName}.priority", { scope: "${i18n}" })`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            items: [
+                                { value: 'high', title: 'High' },
+                                { value: 'medium', title: 'Medium' },
+                                { value: 'low', title: 'Low' },
+                            ],
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: `t("${entityName}.title", { scope: "${i18n}" })`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'description',
+                title: `t("${entityName}.description", { scope: "${i18n}" })`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: false,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.largeText,
+                        options: {
+                            rows: 4,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'attachments',
+                title: `t("${entityName}.attachments", { scope: "${i18n}" })`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: false,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: false,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'array',
+                    interface: {
+                        type: AXPWidgetsCatalog.documentAttachment,
+                        options: {
+                            multiple: true,
+                            accept: '*/*',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'createdAt',
+                title: `t("${entityName}.created-at", { scope: "${i18n}" })`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            readonly: true,
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'issueType' },
+            { name: 'priority' },
+            { name: 'title' },
+            { name: 'description' },
+            { name: 'createdAt' },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    data.createdAt = new Date();
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await reportedIssueDataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'issue-type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'priority',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'attachments',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'issue-type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'priority',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'attachments',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'created-at',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'issue-type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'priority',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'attachments',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'created-at',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'show-report-issue',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'name', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMIssueTypeService: AXMIssueTypeService,
+    AXMIssueTypeServiceImpl: AXMIssueTypeServiceImpl,
+    AXMMyReportedIssuesService: AXMMyReportedIssuesService,
+    AXMMyReportedIssuesServiceImpl: AXMMyReportedIssuesServiceImpl,
+    AXMReportedIssuesService: AXMReportedIssuesService,
+    AXMReportedIssuesServiceImpl: AXMReportedIssuesServiceImpl,
+    issueTypeEntityFactory: issueTypeEntityFactory,
+    myReportedIssuesEntityFactory: myReportedIssuesEntityFactory,
+    reportedIssuesEntityFactory: reportedIssuesEntityFactory
+});
+
+class AXMEntityProvider {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    preload() {
+        const module = RootConfig.module.name;
+        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
+            module: module,
+            entity: entity.name,
+        }));
+    }
+    async get(moduleName, entityName) {
+        if (moduleName == RootConfig.module.name) {
+            return new Promise(async (resolve) => {
+                switch (entityName) {
+                    case RootConfig.entities.issueType.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).issueTypeEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.reportedIssues.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).reportedIssuesEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.myReportedIssues.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).myReportedIssuesEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                }
+            });
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider, decorators: [{
+            type: Injectable
+        }] });
+
+const AXMCaptureScreenService = signalStore({ providedIn: 'root' }, withState(() => {
+    const state = {
+        loading: false,
+        captureMode: 'screenshot',
+        screenshotBlob: '',
+        videoBlob: '',
+        muted: false,
+        isRecording: false,
+        timer: {
+            second: 0,
+            minute: 0,
+        },
+        onFinish: undefined,
+    };
+    return state;
+}), withMethods((store) => {
+    let interval;
+    let videoStream;
+    let audioStream;
+    let mediaRecorder;
+    let recordedChunks = [];
+    let componentRef;
+    const toastService = inject(AXToastService);
+    const translationService = inject(AXTranslationService);
+    const application = inject(ApplicationRef);
+    const stopRecorderSubject = new Subject();
+    const recordStream = async () => {
+        mediaRecorder = await new MediaRecorder(videoStream, {
+            mimeType: 'video/mp4',
+        });
+        patchState(store, { isRecording: true });
+        mediaRecorder.start();
+        startTimer();
+        mediaRecorder.ondataavailable = (e) => {
+            recordedChunks.push(e.data);
+        };
+        mediaRecorder.onstop = () => {
+            stopRecorder();
+        };
+        videoStream.getVideoTracks()[0].onended = () => {
+            stopRecorder();
+        };
+    };
+    const finishRecording = async (result) => {
+        if (store.onFinish() && result) {
+            store.onFinish()?.(result);
+        }
+        resetState();
+        componentRef.destroy();
+    };
+    const stopRecorder = async () => {
+        stopRecorderSubject.pipe(take(1)).subscribe(async () => {
+            try {
+                if (mediaRecorder && videoStream?.active) {
+                    await mediaRecorder.stop();
+                    if (audioStream) {
+                        audioStream.getTracks().forEach((track) => track.stop());
+                    }
+                    videoStream.getVideoTracks().forEach((track) => track.stop());
+                    clearInterval(interval);
+                    patchState(store, { isRecording: false, timer: { second: 0, minute: 0 } });
+                    setTimeout(() => {
+                        createVideoBlob();
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Error stopping recorder:', error);
+                finishRecording(null);
+            }
+        });
+        stopRecorderSubject.next();
+    };
+    const createVideoBlob = () => {
+        try {
+            if (recordedChunks.length > 0) {
+                const blob = new Blob(recordedChunks, {
+                    type: recordedChunks[0].type,
+                });
+                finishRecording({ blob, type: 'video' });
+            }
+        }
+        catch (error) {
+            console.error('Error creating video blob:', error);
+            finishRecording(null);
+        }
+    };
+    const startTimer = () => {
+        interval = setInterval(() => {
+            if (store.timer().minute === 5) {
+                stopRecorder();
+                setTimeout(async () => {
+                    toastService.show({
+                        color: 'warning',
+                        content: await translationService.translateAsync('issue.recording-time-limit', {
+                            scope: 'issue-management',
+                        }),
+                        timeOut: 5000,
+                    });
+                }, 100);
+            }
+            else if (store.timer().second === 59) {
+                patchState(store, { timer: { minute: ++store.timer().minute, second: 0 } });
+            }
+            else {
+                patchState(store, { timer: { minute: store.timer().minute, second: ++store.timer().second } });
+            }
+        }, 1000);
+    };
+    const resetState = () => {
+        patchState(store, {
+            loading: false,
+            captureMode: 'screenshot',
+            screenshotBlob: '',
+            videoBlob: '',
+            muted: false,
+            isRecording: false,
+            timer: {
+                second: 0,
+                minute: 0,
+            },
+            onFinish: undefined,
+        });
+    };
+    return {
+        init: async (onFinish) => {
+            try {
+                const { AXMCaptureScreenComponent } = await import('./acorex-modules-issue-management-capture-screen.component-XFV3kuzQ.mjs');
+                const viewContainerRef = application.components[0].injector.get(ViewContainerRef);
+                componentRef = viewContainerRef.createComponent(AXMCaptureScreenComponent);
+                document.body.appendChild(componentRef.location.nativeElement);
+                patchState(store, { onFinish });
+            }
+            catch (error) {
+                console.error('Error initializing capture screen:', error);
+                onFinish?.({ blob: new Blob(), type: 'image' });
+            }
+        },
+        cancelClick() {
+            if (store.isRecording()) {
+                stopRecorder();
+                return;
+            }
+            this.changeCaptureMode();
+            finishRecording(null);
+        },
+        changeCaptureMode() {
+            patchState(store, {
+                captureMode: store.captureMode() === 'screenshot' ? 'video' : 'screenshot',
+            });
+        },
+        async mutedClick() {
+            const enabled = store.muted();
+            if (audioStream) {
+                audioStream.getTracks().forEach((track) => (track.enabled = enabled));
+            }
+            patchState(store, { muted: !enabled });
+        },
+        screenshotClick() {
+            patchState(store, { loading: true });
+            const captureElement = document.getElementsByTagName('body')[0];
+            html2canvas(captureElement)
+                .then(async (canvas) => {
+                try {
+                    const blob = await new Promise((resolve, reject) => {
+                        canvas.toBlob((blob) => (blob ? resolve(blob) : reject(new Error('Failed to create blob'))), 'image/png');
+                    });
+                    finishRecording({ blob, type: 'image' });
+                }
+                catch (error) {
+                    console.error('Error creating screenshot:', error);
+                    finishRecording(null);
+                }
+            })
+                .catch((error) => {
+                console.error('Error capturing screenshot:', error);
+                finishRecording(null);
+            })
+                .finally(() => {
+                patchState(store, { loading: false });
+            });
+        },
+        async recordScreenClick() {
+            if (!store.isRecording() && !videoStream?.active) {
+                try {
+                    videoStream = await navigator.mediaDevices.getDisplayMedia({
+                        video: { displaySurface: 'monitor' },
+                        audio: true,
+                    });
+                    await this.getMicrophonePermission();
+                    await recordStream();
+                }
+                catch (error) {
+                    console.error('Error starting screen recording:', error);
+                    toastService.show({
+                        color: 'warning',
+                        content: await translationService.translateAsync('issue.capture-screen-error', {
+                            scope: 'issue-management',
+                        }),
+                        timeOut: 5000,
+                    });
+                    finishRecording(null);
+                }
+            }
+            else if (mediaRecorder) {
+                stopRecorder();
+            }
+        },
+        async getMicrophonePermission() {
+            try {
+                audioStream = await navigator.mediaDevices.getUserMedia({
+                    audio: {
+                        echoCancellation: true,
+                        noiseSuppression: true,
+                        sampleRate: 44100,
+                        autoGainControl: true,
+                    },
+                });
+                if (audioStream && videoStream) {
+                    videoStream.addTrack(audioStream.getTracks()[0]);
+                    audioStream.getTracks()[0].enabled = !store.muted();
+                }
+            }
+            catch (error) {
+                console.error('Error getting microphone permission:', error);
+                toastService.show({
+                    color: 'warning',
+                    content: await translationService.translateAsync('issue.get-microphone-error', {
+                        scope: 'issue-management',
+                    }),
+                    timeOut: 5000,
+                });
+                audioStream = null;
+            }
+        },
+    };
+}));
+
+const AXMReportNewIssueViewModel = signalStore({ providedIn: 'root' }, withState(() => {
+    const state = {
+        id: AXPDataGenerator.uuid(),
+        data: {
+            title: '',
+            description: '',
+            issueType: {},
+            priority: {},
+        },
+        status: 'new',
+        media: [],
+    };
+    return state;
+}), withComputed(({ status }) => ({
+    isRecording: computed(() => status() === 'recording'),
+})), withMethods((store, popupService = inject(AXPopupService), captureScreenService = inject(AXMCaptureScreenService), eventService = inject(AXPWorkflowEventService), fileStorageService = inject(AXPFileStorageService), documentService = inject(AXMDocumentService)) => {
+    const createMediaItem = (name, mediaUrl, type, documentId, fileId) => ({
+        id: (store.media().length + 1).toString(),
+        name: name,
+        type,
+        thumbnail: mediaUrl,
+        url: mediaUrl,
+        documentId,
+        fileId,
+    });
+    return {
+        async startCapturing() {
+            patchState(store, { status: 'recording' });
+            return captureScreenService.init(async (data) => {
+                try {
+                    let documentId = '';
+                    let file;
+                    if (typeof data === 'object' && 'blob' in data) {
+                        const mediaUrl = await URL.createObjectURL(data.blob);
+                        const fileName = `${new Date().toISOString()}.${data.type === 'image' ? 'png' : 'mp4'}`;
+                        file = new File([data.blob], fileName);
+                        const fileStorage = await fileStorageService.save({
+                            category: 'issue-document',
+                            file: file,
+                            name: fileName,
+                            refId: '',
+                            refType: `${RootConfig.module.name}.${RootConfig.entities.reportedIssues.name}`,
+                        });
+                        documentId = await documentService.insertOne({
+                            refRecordId: store.id(),
+                            refEntity: `${RootConfig.module.name}.${RootConfig.entities.reportedIssues.name}`,
+                            fileId: fileStorage.fileId,
+                            name: fileStorage.name,
+                            title: fileStorage.name,
+                            size: file.size,
+                            parentId: `${RootConfig.module.name}.${RootConfig.entities.reportedIssues.name}`,
+                        });
+                        const newMedia = createMediaItem(fileStorage.name, mediaUrl, data.type, documentId, fileStorage.fileId);
+                        patchState(store, {
+                            media: [...store.media(), newMedia],
+                            status: 'recorded',
+                        });
+                    }
+                    this.showPopup(documentId);
+                    return file;
+                }
+                catch (error) {
+                    console.error('Error capturing media:', error);
+                    return undefined;
+                }
+            });
+        },
+        async showPopup(documentId) {
+            try {
+                const scope = RootConfig.config.i18n;
+                const { AXMReportNewIssueComponent } = await Promise.resolve().then(function () { return reportNewIssue_component; });
+                const config = {
+                    title: `t('report-new-issue.individual-title',{scope: "${scope}"})`,
+                };
+                const result = await popupService.open(AXMReportNewIssueComponent, config);
+                if (result.data?.insertResult) {
+                    eventService.dispatch(AXPRefreshEvent({ entity: 'reported-issues' }));
+                    patchState(store, { status: 'new' });
+                }
+            }
+            catch (error) {
+                console.error('Error showing popup:', error);
+                patchState(store, { status: 'new' });
+            }
+        },
+        deleteCapturedItem(index) {
+            patchState(store, { media: store.media().filter((_, i) => i !== index) });
+        },
+        resetState() {
+            patchState(store, {
+                id: AXPDataGenerator.uuid(),
+                data: {
+                    title: '',
+                    description: '',
+                    issueType: {},
+                    priority: {},
+                },
+                status: 'new',
+                media: [],
+            });
+        },
+    };
+}));
+
+class AXMReportNewIssueComponent extends AXBasePageComponent {
+    constructor() {
+        super();
+        this.vm = inject(AXMReportNewIssueViewModel);
+        this.sessionService = inject(AXPSessionService);
+        this.issueTypeService = inject(AXMIssueTypeService);
+        this.reportedIssuesService = inject(AXMReportedIssuesService);
+        this.fileStorageService = inject(AXPFileStorageService);
+        this.documentService = inject(AXMDocumentService);
+        this.issueTypeDataSource = new AXDataSource({
+            load: async (_) => {
+                const issueTypeList = await this.issueTypeService.query();
+                return issueTypeList;
+            },
+            pageSize: 20,
+        });
+        this.priorityList = [
+            {
+                title: 'Low',
+                id: 1,
+            },
+            {
+                title: 'Medium',
+                id: 2,
+            },
+            {
+                title: 'High',
+                id: 3,
+            },
+            {
+                title: 'Critical',
+                id: 4,
+            },
+        ];
+        this.attachNode = {
+            type: AXPWidgetsCatalog.documentAttachment,
+            name: 'attach',
+            path: 'attach',
+            // defaultValue: this.vm.media().map((el) => el.documentId),
+            options: {
+                multiple: true,
+                entity: `${RootConfig.module.name}.${RootConfig.entities.reportedIssues.name}`,
+                record: this.vm.id(),
+                actions: [
+                    {
+                        name: 'attach',
+                        icon: 'fa-light fa-video',
+                        title: `t('report-new-issue.start-capture-screen', { scope: 'issue-management' })`,
+                        callback: async () => {
+                            this.vm.startCapturing();
+                            this.close();
+                        },
+                    },
+                ],
+            },
+        };
+        this.context = {};
+    }
+    async handleSubmitClick() {
+        const formResult = await this.form.validate();
+        if (formResult.result) {
+            const params = {
+                id: this.vm.id(),
+                attachments: this.addToFileStorage(),
+                // attachments: this.vm.media(),
+                createdAt: new Date(),
+                description: this.vm.data().description,
+                errorLogs: [],
+                issueType: this.vm.data().issueType,
+                priority: this.vm.data().priority,
+                status: 'new',
+                systemInfo: navigator.userAgent,
+                title: this.vm.data().title,
+                user: this.sessionService.user,
+            };
+            debugger;
+            const reportedIssue = await this.reportedIssuesService.insertOne(params);
+            await this.vm.media().forEach(async (x) => {
+                await this.documentService.updateOne(x.documentId, {
+                    refRecordId: reportedIssue,
+                });
+            });
+            if (reportedIssue.length) {
+                this.vm.resetState();
+                this.close({ insertResult: true });
+            }
+        }
+    }
+    async convertURLToFile(url, fileName) {
+        const response = await fetch(url);
+        const blob = await response.blob();
+        const file = new File([blob], fileName);
+        return file;
+    }
+    addToFileStorage() {
+        let fileIDs = [];
+        // this.vm.media().forEach(async (el) => {
+        //   const file = await this.convertURLToFile(el.url, el.name as string);
+        //   fileIDs.push(
+        //     (await this.fileStorageService.save({ category: 'issue-document', file: file, refId: '', refType: '' })).fileId
+        //   );
+        // });
+        return fileIDs;
+    }
+    async handleStartRecordingClick() {
+        await this.vm.startCapturing();
+        this.close();
+    }
+    async onDeleteMediaClick(index) {
+        this.vm.deleteCapturedItem(index);
+    }
+    async onCancelClick() {
+        this.vm.resetState();
+        this.close();
+    }
+    handleIssueTypeChange(event) {
+        this.vm.data().issueType = event.component.selectedItems[0];
+    }
+    handlePriorityChange(event) {
+        this.vm.data().priority = event.component.selectedItems[0];
+    }
+    ngOnDestroy() {
+        if (this.vm.status() !== 'recording') {
+            this.vm.resetState();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMReportNewIssueComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMReportNewIssueComponent, isStandalone: true, selector: "axm-report-new-issue", viewQueries: [{ propertyName: "form", first: true, predicate: AXFormComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: "<div *translate=\"let t\" class=\"ax-p-6\">\n  <ax-form #form>\n    <div class=\"ax-grid ax-gap-2\">\n      <ax-form-field>\n        <ax-label>{{ t('report-new-issue.title', { scope: 'issue-management' }) | async }}</ax-label>\n        <ax-text-box [(ngModel)]=\"vm.data().title\">\n          <ax-validation-rule rule=\"required\"></ax-validation-rule>\n        </ax-text-box>\n      </ax-form-field>\n      <ax-form-field>\n        <ax-label>{{ t('report-new-issue.issue-type', { scope: 'issue-management' }) | async }}</ax-label>\n        <ax-select-box\n          valueField=\"id\"\n          textField=\"title\"\n          [dataSource]=\"issueTypeDataSource\"\n          [value]=\"vm.data().issueType\"\n          (onValueChanged)=\"handleIssueTypeChange($event)\"\n        ></ax-select-box>\n      </ax-form-field>\n      <ax-form-field>\n        <ax-label>{{ t('report-new-issue.priority', { scope: 'issue-management' }) | async }}</ax-label>\n        <ax-select-box\n          valueField=\"id\"\n          textField=\"title\"\n          [dataSource]=\"priorityList\"\n          [value]=\"vm.data().priority\"\n          (onValueChanged)=\"handlePriorityChange($event)\"\n        ></ax-select-box>\n      </ax-form-field>\n      <ax-form-field>\n        <ax-label>{{ t('report-new-issue.description', { scope: 'issue-management' }) | async }}</ax-label>\n        <ax-text-area [(ngModel)]=\"vm.data().description\">\n          <ax-validation-rule rule=\"required\"></ax-validation-rule>\n        </ax-text-area>\n      </ax-form-field>\n      <ax-form-field>\n        <axp-widgets-container class=\"ax-flex ax-flex-col ax-gap-2 ax-p-4\" [context]=\"context\">\n          <ng-container axp-widget-renderer [node]=\"attachNode\" [mode]=\"'edit'\"> </ng-container>\n        </axp-widgets-container>\n      </ax-form-field>\n    </div>\n  </ax-form>\n  <!-- @if(vm.media().length > 0){\n  <div class=\"ax-py-4\">\n    <ax-content>\n      <ax-media-viewer-container #mediaViewer [dataArray]=\"vm.media()\" class=\"ax-block\">\n        <ax-header>\n          <ax-file-info></ax-file-info>\n          <ax-suffix>\n            <ax-button class=\"ax-sm\" color=\"danger\" (onClick)=\"onDeleteMediaClick(mediaViewer.getActiveIndex())\">\n              <ax-icon class=\"ax-icon ax-icon-trash\"> </ax-icon>\n            </ax-button>\n          </ax-suffix>\n        </ax-header>\n        <ax-prefix>\n          <ax-button (click)=\"mediaViewer.next()\">\n            <ax-icon class=\"ax-icon ax-icon-chevron-right\"> </ax-icon>\n          </ax-button>\n        </ax-prefix>\n        <ax-suffix>\n          <ax-button (click)=\"mediaViewer.prev()\">\n            <ax-icon class=\"ax-icon ax-icon-chevron-left\"> </ax-icon>\n          </ax-button>\n        </ax-suffix>\n      </ax-media-viewer-container>\n    </ax-content>\n  </div>\n  } -->\n  <!-- <div>\n    <ax-label>{{ t('report-new-issue.attach', { scope: 'issue-management' }) | async }}</ax-label>\n    <div\n      class=\"ax-flex ax-flex-col ax-items-center ax-justify-center ax-border ax-border-dashed ax-border-secondary-500 ax-rounded-lg ax-p-6\"\n    >\n      <div class=\"ax-rounded-full ax-bg-surface ax-px-4 ax-py-3\">\n        <ax-icon class=\"fa-solid fa-paperclip ax-text-on-surface ax-text-xl\"></ax-icon>\n      </div>\n      <p class=\"ax-text-lg ax-text-on-surface\">\n        {{ t('report-new-issue.attach-box-description', { scope: 'issue-management' }) | async }}\n      </p>\n      <ax-button\n        class=\"ax-w-fit ax-mt-6\"\n        [text]=\"t('report-new-issue.start-capture-screen', { scope: 'issue-management' }) | async\"\n        color=\"secondary\"\n        (onClick)=\"handleStartRecordingClick()\"\n      ></ax-button>\n    </div>\n  </div> -->\n</div>\n<ax-footer>\n  <ax-suffix>\n    <ax-button\n      look=\"solid\"\n      color=\"default\"\n      [text]=\"'cancel' | translate | async\"\n      (onClick)=\"onCancelClick()\"\n    ></ax-button>\n    <ax-button\n      look=\"solid\"\n      color=\"primary\"\n      [text]=\"'save' | translate | async\"\n      (onClick)=\"handleSubmitClick()\"\n    ></ax-button>\n  </ax-suffix>\n</ax-footer>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: 
+                //
+                AXTranslationModule }, { kind: "pipe", type: i3.AXTranslatorPipe, name: "translate" }, { kind: "directive", type: i3.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXFormModule }, { kind: "component", type: i4.AXFormFieldComponent, selector: "ax-form-field", inputs: ["labelMode"] }, { kind: "component", type: i4.AXFormComponent, selector: "ax-form", inputs: ["labelMode", "look", "messageStyle", "updateOn"], outputs: ["onValidate", "updateOnChange"] }, { kind: "directive", type: i4.AXValidationRuleDirective, selector: "ax-validation-rule", inputs: ["rule", "options", "message"] }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i5.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXTextBoxModule }, { kind: "component", type: i6.AXTextBoxComponent, selector: "ax-text-box", inputs: ["disabled", "tabIndex", "readonly", "value", "state", "name", "id", "placeholder", "maxLength", "allowNull", "type", "autoComplete", "look", "mask-options", "class"], outputs: ["onBlur", "onFocus", "valueChange", "stateChange", "onValueChanged", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress"] }, { kind: "ngmodule", type: AXSelectBoxModule }, { kind: "component", type: i7.AXSelectBoxComponent, selector: "ax-select-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "minValue", "maxValue", "value", "state", "name", "id", "type", "look", "multiple", "valueField", "textField", "disabledField", "textTemplate", "selectedItems", "dataSource", "minRecordsForSearch", "caption", "itemTemplate", "selectedTemplate", "emptyTemplate", "loadingTemplate", "dropdownWidth", "searchBoxAutoFocus"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onOpened", "onClosed"] }, { kind: "ngmodule", type: AXTextAreaModule }, { kind: "component", type: i8.AXTextAreaComponent, selector: "ax-text-area", inputs: ["disabled", "tabIndex", "readonly", "value", "state", "name", "placeholder", "maxLength", "look", "rows", "allowResize", "showCounter", "class"], outputs: ["onBlur", "onFocus", "valueChange", "stateChange", "onValueChanged", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3$1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i10.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXMediaViewerModule }, { kind: "ngmodule", type: AXPLayoutBuilderModule }, { kind: "component", type: i11.AXPWidgetContainerComponent, selector: "axp-widgets-container", inputs: ["context", "functions"], outputs: ["onContextChanged"] }, { kind: "directive", type: i11.AXPWidgetRendererDirective, selector: "[axp-widget-renderer]", inputs: ["parentNode", "index", "mode", "node"], outputs: ["onOptionsChanged", "onValueChanged"], exportAs: ["widgetRenderer"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMReportNewIssueComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-report-new-issue', imports: [
+                        CommonModule,
+                        FormsModule,
+                        //
+                        AXTranslationModule,
+                        AXFormModule,
+                        AXLabelModule,
+                        AXTextBoxModule,
+                        AXSelectBoxModule,
+                        AXTextAreaModule,
+                        AXDecoratorModule,
+                        AXButtonModule,
+                        AXMediaViewerModule,
+                        AXPLayoutBuilderModule,
+                    ], template: "<div *translate=\"let t\" class=\"ax-p-6\">\n  <ax-form #form>\n    <div class=\"ax-grid ax-gap-2\">\n      <ax-form-field>\n        <ax-label>{{ t('report-new-issue.title', { scope: 'issue-management' }) | async }}</ax-label>\n        <ax-text-box [(ngModel)]=\"vm.data().title\">\n          <ax-validation-rule rule=\"required\"></ax-validation-rule>\n        </ax-text-box>\n      </ax-form-field>\n      <ax-form-field>\n        <ax-label>{{ t('report-new-issue.issue-type', { scope: 'issue-management' }) | async }}</ax-label>\n        <ax-select-box\n          valueField=\"id\"\n          textField=\"title\"\n          [dataSource]=\"issueTypeDataSource\"\n          [value]=\"vm.data().issueType\"\n          (onValueChanged)=\"handleIssueTypeChange($event)\"\n        ></ax-select-box>\n      </ax-form-field>\n      <ax-form-field>\n        <ax-label>{{ t('report-new-issue.priority', { scope: 'issue-management' }) | async }}</ax-label>\n        <ax-select-box\n          valueField=\"id\"\n          textField=\"title\"\n          [dataSource]=\"priorityList\"\n          [value]=\"vm.data().priority\"\n          (onValueChanged)=\"handlePriorityChange($event)\"\n        ></ax-select-box>\n      </ax-form-field>\n      <ax-form-field>\n        <ax-label>{{ t('report-new-issue.description', { scope: 'issue-management' }) | async }}</ax-label>\n        <ax-text-area [(ngModel)]=\"vm.data().description\">\n          <ax-validation-rule rule=\"required\"></ax-validation-rule>\n        </ax-text-area>\n      </ax-form-field>\n      <ax-form-field>\n        <axp-widgets-container class=\"ax-flex ax-flex-col ax-gap-2 ax-p-4\" [context]=\"context\">\n          <ng-container axp-widget-renderer [node]=\"attachNode\" [mode]=\"'edit'\"> </ng-container>\n        </axp-widgets-container>\n      </ax-form-field>\n    </div>\n  </ax-form>\n  <!-- @if(vm.media().length > 0){\n  <div class=\"ax-py-4\">\n    <ax-content>\n      <ax-media-viewer-container #mediaViewer [dataArray]=\"vm.media()\" class=\"ax-block\">\n        <ax-header>\n          <ax-file-info></ax-file-info>\n          <ax-suffix>\n            <ax-button class=\"ax-sm\" color=\"danger\" (onClick)=\"onDeleteMediaClick(mediaViewer.getActiveIndex())\">\n              <ax-icon class=\"ax-icon ax-icon-trash\"> </ax-icon>\n            </ax-button>\n          </ax-suffix>\n        </ax-header>\n        <ax-prefix>\n          <ax-button (click)=\"mediaViewer.next()\">\n            <ax-icon class=\"ax-icon ax-icon-chevron-right\"> </ax-icon>\n          </ax-button>\n        </ax-prefix>\n        <ax-suffix>\n          <ax-button (click)=\"mediaViewer.prev()\">\n            <ax-icon class=\"ax-icon ax-icon-chevron-left\"> </ax-icon>\n          </ax-button>\n        </ax-suffix>\n      </ax-media-viewer-container>\n    </ax-content>\n  </div>\n  } -->\n  <!-- <div>\n    <ax-label>{{ t('report-new-issue.attach', { scope: 'issue-management' }) | async }}</ax-label>\n    <div\n      class=\"ax-flex ax-flex-col ax-items-center ax-justify-center ax-border ax-border-dashed ax-border-secondary-500 ax-rounded-lg ax-p-6\"\n    >\n      <div class=\"ax-rounded-full ax-bg-surface ax-px-4 ax-py-3\">\n        <ax-icon class=\"fa-solid fa-paperclip ax-text-on-surface ax-text-xl\"></ax-icon>\n      </div>\n      <p class=\"ax-text-lg ax-text-on-surface\">\n        {{ t('report-new-issue.attach-box-description', { scope: 'issue-management' }) | async }}\n      </p>\n      <ax-button\n        class=\"ax-w-fit ax-mt-6\"\n        [text]=\"t('report-new-issue.start-capture-screen', { scope: 'issue-management' }) | async\"\n        color=\"secondary\"\n        (onClick)=\"handleStartRecordingClick()\"\n      ></ax-button>\n    </div>\n  </div> -->\n</div>\n<ax-footer>\n  <ax-suffix>\n    <ax-button\n      look=\"solid\"\n      color=\"default\"\n      [text]=\"'cancel' | translate | async\"\n      (onClick)=\"onCancelClick()\"\n    ></ax-button>\n    <ax-button\n      look=\"solid\"\n      color=\"primary\"\n      [text]=\"'save' | translate | async\"\n      (onClick)=\"handleSubmitClick()\"\n    ></ax-button>\n  </ax-suffix>\n</ax-footer>\n" }]
+        }], ctorParameters: () => [], propDecorators: { form: [{
+                type: ViewChild,
+                args: [AXFormComponent]
+            }] } });
+
+var reportNewIssue_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMReportNewIssueComponent: AXMReportNewIssueComponent
+});
+
+class AXMShowReportNewIssuePopupeAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.vm = inject(AXMReportNewIssueViewModel);
+    }
+    async execute() {
+        await this.vm.showPopup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMShowReportNewIssuePopupeAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMShowReportNewIssuePopupeAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMShowReportNewIssuePopupeAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMShowReportNewIssueWorkflow = {
+    startStepId: 'show-popup',
+    steps: {
+        'show-popup': {
+            action: 'AXMShowReportNewIssuePopupeAction',
+        },
+    },
+};
+
+class AXMMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const scope = RootConfig.config.i18n;
+        const module = RootConfig.module;
+        context.addItems([
+            {
+                name: 'app-issue',
+                priority: 9001,
+                text: `t('issue-management', {scope:"${scope}"})`,
+                icon: module.icon,
+                children: [
+                    {
+                        name: 'my-reported-issues',
+                        text: RootConfig.entities.myReportedIssues.title,
+                        icon: RootConfig.entities.myReportedIssues.icon,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.myReportedIssues.name),
+                        priority: 1000,
+                    },
+                    {
+                        name: 'app-report-issue',
+                        text: RootConfig.entities.reportNewIssue.title,
+                        icon: RootConfig.entities.reportNewIssue.icon,
+                        command: {
+                            name: 'show-report-issue',
+                        },
+                        priority: 1001,
+                    },
+                    {
+                        priority: 9008,
+                        text: RootConfig.entities.reportedIssues.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.reportedIssues.name),
+                        icon: RootConfig.entities.reportedIssues.icon,
+                    },
+                    {
+                        priority: 9009,
+                        text: RootConfig.entities.issueType.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.issueType.name),
+                        icon: RootConfig.entities.issueType.icon,
+                    },
+                ],
+            },
+        ]);
+    }
+}
+
+class AXMSettingProvider {
+    async provide(context) {
+        // context
+        //   // Add Form Template Group
+        //   .addGroup('form-template', 'Form Template', 'Settings related to form templates.', RootConfig.module.icon)
+        //   // Start Interface Section
+        //   .addSection('interface', 'UI Interface', 'Customize the user interface for forms.')
+        //   .addSetting({
+        //     key: 'history-panel',
+        //     title: 'Show History Panel',
+        //     scope: 'U',
+        //     isInherited: true,
+        //     defaultValue: false,
+        //     widget: {
+        //       type: AXPWidgetsCatalog.toggle,
+        //     },
+        //     description: 'Enable or disable the history panel for forms.',
+        //     validationRules: [
+        //       {
+        //         rule: 'required',
+        //       },
+        //     ],
+        //   })
+        //   .endSection()
+        //   .endGroup();
+    }
+}
+
+class AXMIssueManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMIssueManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMIssueManagementModule, imports: [i1$1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMIssueManagementModule, providers: [
+            {
+                provide: AXMIssueTypeService,
+                useClass: AXMIssueTypeServiceImpl,
+            },
+            {
+                provide: AXMReportedIssuesService,
+                useClass: AXMReportedIssuesServiceImpl,
+            },
+            {
+                provide: AXMMyReportedIssuesService,
+                useClass: AXMMyReportedIssuesServiceImpl,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMEntityProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMSettingProvider,
+                multi: true,
+            },
+        ], imports: [AXPWorkflowModule.forChild({
+                actions: {
+                    AXMShowReportNewIssuePopupeAction: AXMShowReportNewIssuePopupeAction,
+                },
+                workflows: {
+                    'show-report-issue': AXMShowReportNewIssueWorkflow,
+                },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMIssueManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXMShowReportNewIssuePopupeAction: AXMShowReportNewIssuePopupeAction,
+                            },
+                            workflows: {
+                                'show-report-issue': AXMShowReportNewIssueWorkflow,
+                            },
+                        }),
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMIssueTypeService,
+                            useClass: AXMIssueTypeServiceImpl,
+                        },
+                        {
+                            provide: AXMReportedIssuesService,
+                            useClass: AXMReportedIssuesServiceImpl,
+                        },
+                        {
+                            provide: AXMMyReportedIssuesService,
+                            useClass: AXMMyReportedIssuesServiceImpl,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMEntityProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMSettingProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMCaptureScreenService as A, RootConfig as R, AXMIssueTypeService as a, AXMIssueTypeServiceImpl as b, AXMMyReportedIssuesService as c, AXMMyReportedIssuesServiceImpl as d, AXMReportedIssuesService as e, AXMReportedIssuesServiceImpl as f, AXMEntityProvider as g, AXMIssueManagementModule as h, issueTypeEntityFactory as i, AXMMenuProvider as j, AXMSettingProvider as k, myReportedIssuesEntityFactory as m, reportedIssuesEntityFactory as r };
+//# sourceMappingURL=acorex-modules-issue-management-acorex-modules-issue-management-DhuDuKkz.mjs.map