@thescaffold/ngx-apps-capital 0.0.10

package/README.md

@@ -0,0 +1,25 @@
+# Ngx Apps
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.0.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project capital` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project capital`.
+
+> Note: Don't forget to add `--project capital` or else it will be added to the default project in your `angular.json` file.
+
+## Build
+
+Run `ng build capital` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build capital`, go to the dist folder `cd dist/capital` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test capital` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

package/esm2022/lib/app.config.mjs

@@ -0,0 +1,81 @@
+import { getClientId, getEnv, translate } from '@thescaffold/ngx-core';
+export const config = () => ({
+    // keep this root level ones for backward compatibility
+    name: getEnv('APP_NAME'),
+    desc: getEnv('APP_DESC'),
+    url: getEnv('APP_URL'),
+    logo: getEnv('APP_LOGO'),
+    business: {
+        name: getEnv('BUSINESS_NAME'),
+        desc: getEnv('BUSINESS_DESC'),
+        url: getEnv('BUSINESS_URL'),
+    },
+    group: {
+        name: getEnv('GROUP_NAME'),
+        desc: getEnv('GROUP_DESC'),
+        url: getEnv('GROUP_URL'),
+    },
+    app: {
+        name: getEnv('APP_NAME'),
+        desc: getEnv('APP_DESC'),
+        url: getEnv('APP_URL'),
+        logo: getEnv('APP_LOGO'),
+    },
+    links: {
+        projects: [], // make it empty to prevent the projects menu
+        primary: [
+            {
+                title: translate('apps.capital.config.menu.primary.dashboard.title'),
+                url: '/payments/dashboard',
+                icon: 'fa-solid fa-gauge',
+            },
+            {
+                title: translate('apps.capital.config.menu.primary.card.title'),
+                url: '/payments/card',
+                icon: 'fa-solid fa-credit-card',
+            },
+            {
+                title: translate('apps.capital.config.menu.primary.payment.title'),
+                url: '/payments/payment',
+                icon: 'fa-solid fa-comments-dollar',
+            },
+            {
+                title: translate('apps.capital.config.menu.primary.voucher.title'),
+                url: '/payments/voucher',
+                icon: 'fa-solid fa-ticket',
+            },
+        ],
+        secondary: [
+            {
+                title: translate('apps.capital.config.menu.secondary.add-card.title'),
+                url: '/payments/card/new',
+            },
+        ],
+    },
+    guardBaseUrl: getEnv('GUARD_BASE_URL'),
+    identityBaseUrl: getEnv('IDENTITY_BASE_URL'),
+    paymentBaseUrl: getEnv('PAYMENT_BASE_URL'),
+    clientId: getClientId(),
+});
+export const paths = () => [
+    'translations/en/ngx/packages/code-editor.yaml',
+    'translations/en/ngx/packages/common.yaml',
+    'translations/en/ngx/packages/core.yaml',
+    'translations/en/ngx/packages/payments.yaml',
+    'translations/en/ngx/packages/polylog.yaml',
+    'translations/en/ngx/packages/ui.yaml',
+    'translations/en/ngx/apps/capital.yaml',
+    `translations/en/ngx/${getEnv('GROUP_NAME')}/${getEnv('APP_NAME')}.yaml`,
+];
+export var SourceTypeType;
+(function (SourceTypeType) {
+    SourceTypeType["Repository"] = "repository";
+    SourceTypeType["Registry"] = "registry";
+    SourceTypeType["Datacenter"] = "datacenter";
+})(SourceTypeType || (SourceTypeType = {}));
+export const sourceTypesId = {
+    [SourceTypeType.Repository]: 'e47daadc-0907-4b1f-8bcf-a007366a8271',
+    [SourceTypeType.Registry]: '3ad50df3-90c6-4a70-a74d-d08c13abc67d',
+    [SourceTypeType.Datacenter]: '8605643d-df3b-45fa-a0f6-6d51e6f19a84',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/app.module.mjs

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { AppModuleDirective } from '@thescaffold/ngx-common';
+import { PagesModule } from './pages/pages.module';
+import * as i0 from "@angular/core";
+export class AppModule extends AppModuleDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: AppModule, deps: null, target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.5", ngImport: i0, type: AppModule, imports: [PagesModule], exports: [PagesModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: AppModule, imports: [PagesModule, PagesModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: AppModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [PagesModule],
+                    exports: [PagesModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2NhcGl0YWwvc3JjL2xpYi9hcHAubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDN0QsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDOztBQU1uRCxNQUFNLE9BQU8sU0FBVSxTQUFRLGtCQUFrQjs4R0FBcEMsU0FBUzsrR0FBVCxTQUFTLFlBSFYsV0FBVyxhQUNYLFdBQVc7K0dBRVYsU0FBUyxZQUhWLFdBQVcsRUFDWCxXQUFXOzsyRkFFVixTQUFTO2tCQUpyQixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFdBQVcsQ0FBQztvQkFDdEIsT0FBTyxFQUFFLENBQUMsV0FBVyxDQUFDO2lCQUN2QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBcHBNb2R1bGVEaXJlY3RpdmUgfSBmcm9tICdAdGhlc2NhZmZvbGQvbmd4LWNvbW1vbic7XG5pbXBvcnQgeyBQYWdlc01vZHVsZSB9IGZyb20gJy4vcGFnZXMvcGFnZXMubW9kdWxlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1BhZ2VzTW9kdWxlXSxcbiAgZXhwb3J0czogW1BhZ2VzTW9kdWxlXSxcbn0pXG5leHBvcnQgY2xhc3MgQXBwTW9kdWxlIGV4dGVuZHMgQXBwTW9kdWxlRGlyZWN0aXZlIHt9XG4iXX0=

package/esm2022/lib/index.mjs

@@ -0,0 +1,11 @@
+export { AppModule as CapitalAppModule } from './app.module';
+export { PagesModule } from './pages/pages.module';
+export const routes = {
+    root: ['/', 'payments'],
+    start: ['/', 'payments', 'start'],
+    error: ['/', 'payments', 'error'],
+    dashboard: {
+        root: ['/', 'payments', 'dashboard'],
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jYXBpdGFsL3NyYy9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsSUFBSSxnQkFBZ0IsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUM3RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFbkQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHO0lBQ3BCLElBQUksRUFBRSxDQUFDLEdBQUcsRUFBRSxVQUFVLENBQUM7SUFDdkIsS0FBSyxFQUFFLENBQUMsR0FBRyxFQUFFLFVBQVUsRUFBRSxPQUFPLENBQUM7SUFDakMsS0FBSyxFQUFFLENBQUMsR0FBRyxFQUFFLFVBQVUsRUFBRSxPQUFPLENBQUM7SUFDakMsU0FBUyxFQUFFO1FBQ1QsSUFBSSxFQUFFLENBQUMsR0FBRyxFQUFFLFVBQVUsRUFBRSxXQUFXLENBQUM7S0FDckM7Q0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQXBwTW9kdWxlIGFzIENhcGl0YWxBcHBNb2R1bGUgfSBmcm9tICcuL2FwcC5tb2R1bGUnO1xuZXhwb3J0IHsgUGFnZXNNb2R1bGUgfSBmcm9tICcuL3BhZ2VzL3BhZ2VzLm1vZHVsZSc7XG5cbmV4cG9ydCBjb25zdCByb3V0ZXMgPSB7XG4gIHJvb3Q6IFsnLycsICdwYXltZW50cyddLFxuICBzdGFydDogWycvJywgJ3BheW1lbnRzJywgJ3N0YXJ0J10sXG4gIGVycm9yOiBbJy8nLCAncGF5bWVudHMnLCAnZXJyb3InXSxcbiAgZGFzaGJvYXJkOiB7XG4gICAgcm9vdDogWycvJywgJ3BheW1lbnRzJywgJ2Rhc2hib2FyZCddLFxuICB9LFxufTtcbiJdfQ==

package/esm2022/lib/pages/card/card.component.mjs

@@ -0,0 +1,161 @@
+import { Component, TemplateRef, ViewChild, inject } from '@angular/core';
+import { BaseDirective, getEnv, navigateExternal, notify, using, } from '@thescaffold/ngx-core';
+import { FlyoutService } from '@thescaffold/ngx-ui';
+import { of, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@thescaffold/ngx-common";
+import * as i3 from "@thescaffold/ngx-ui";
+import * as i4 from "@thescaffold/ngx-core";
+export class CardComponent extends BaseDirective {
+    constructor() {
+        super(...arguments);
+        this.flyoutService = inject(FlyoutService);
+        this.paymentMeta$ = () => of({
+            type: 'apps.capital.card.link',
+        });
+        this.paymentData = {
+            mode: 'pay',
+            appName: getEnv('APP_NAME'),
+            hooks: {
+                meta: () => this.paymentMeta$(),
+            },
+            amount: 50.0,
+            options: ['card'],
+            redirect: (provider, amount, reference, currency) => {
+                navigateExternal(`${getEnv('BASE_URL')}${this.router.url}?type=${provider}&reference=${reference}`);
+            },
+        };
+        this.verifyPaymentData = {
+            mode: 'verify',
+            appName: getEnv('APP_NAME'),
+            amount: 0.0,
+            hooks: {},
+            options: [],
+        };
+    }
+    update(item) {
+        this.apiService
+            .on('apps/capital/provider')
+            .update(item.id, {
+            primary: true,
+        })
+            .pipe(takeUntil(this.$))
+            .subscribe(using(({ message, data }) => {
+            notify(message);
+            this.flyoutService.dismiss();
+            this.reload();
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: CardComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.5", type: CardComponent, selector: "app-card", viewQueries: [{ propertyName: "beforeListTemplate", first: true, predicate: ["beforeListTemplate"], descendants: true, read: TemplateRef, static: true }, { propertyName: "beforeCreateTemplate", first: true, predicate: ["beforeCreateTemplate"], descendants: true, read: TemplateRef, static: true }, { propertyName: "afterShowTemplate", first: true, predicate: ["afterShowTemplate"], descendants: true, read: TemplateRef, static: true }], usesInheritance: true, ngImport: i0, template: `
+    <!-- verify payment -->
+    <ng-template #beforeListTemplate>
+      <x-common-payment [data]="verifyPaymentData"></x-common-payment>
+    </ng-template>
+
+    <!-- add card -->
+    <ng-template #beforeCreateTemplate>
+      <x-common-payment [data]="paymentData"></x-common-payment>
+    </ng-template>
+
+    <!-- show card buttons -->
+    <ng-template #afterShowTemplate let-item="item">
+      <div
+        *ngIf="item"
+        class="d-flex justify-content-center align-items-center"
+      >
+        <div class="btn-toolbar">
+          <div class="btn-group">
+            <button
+              type="button"
+              class="btn btn-primary"
+              (click)="update(item)"
+              [attr.disabled]="item.primary ? true : null"
+            >
+              {{
+                'apps.capital.card.collection.links.secondary.make-primary.title'
+                  | xTranslate
+              }}
+            </button>
+          </div>
+        </div>
+      </div>
+    </ng-template>
+
+    <!-- misc -->
+    <ng-template #loader>
+      <x-element-loader></x-element-loader>
+    </ng-template>
+
+    <ng-template #empty>
+      <x-element-blank></x-element-blank>
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.PaymentComponent, selector: "x-common-payment", inputs: ["data"] }, { kind: "component", type: i3.BlankComponent, selector: "x-element-blank", inputs: ["image", "icon", "type"] }, { kind: "component", type: i3.LoaderComponent, selector: "x-element-loader", inputs: ["data"] }, { kind: "pipe", type: i4.TranslatePipe, name: "xTranslate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: CardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-card', template: `
+    <!-- verify payment -->
+    <ng-template #beforeListTemplate>
+      <x-common-payment [data]="verifyPaymentData"></x-common-payment>
+    </ng-template>
+
+    <!-- add card -->
+    <ng-template #beforeCreateTemplate>
+      <x-common-payment [data]="paymentData"></x-common-payment>
+    </ng-template>
+
+    <!-- show card buttons -->
+    <ng-template #afterShowTemplate let-item="item">
+      <div
+        *ngIf="item"
+        class="d-flex justify-content-center align-items-center"
+      >
+        <div class="btn-toolbar">
+          <div class="btn-group">
+            <button
+              type="button"
+              class="btn btn-primary"
+              (click)="update(item)"
+              [attr.disabled]="item.primary ? true : null"
+            >
+              {{
+                'apps.capital.card.collection.links.secondary.make-primary.title'
+                  | xTranslate
+              }}
+            </button>
+          </div>
+        </div>
+      </div>
+    </ng-template>
+
+    <!-- misc -->
+    <ng-template #loader>
+      <x-element-loader></x-element-loader>
+    </ng-template>
+
+    <ng-template #empty>
+      <x-element-blank></x-element-blank>
+    </ng-template>
+  ` }]
+        }], propDecorators: { beforeListTemplate: [{
+                type: ViewChild,
+                args: ['beforeListTemplate', {
+                        read: TemplateRef,
+                        static: true,
+                    }]
+            }], beforeCreateTemplate: [{
+                type: ViewChild,
+                args: ['beforeCreateTemplate', {
+                        read: TemplateRef,
+                        static: true,
+                    }]
+            }], afterShowTemplate: [{
+                type: ViewChild,
+                args: ['afterShowTemplate', {
+                        read: TemplateRef,
+                        static: true,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/pages/card/card.module.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { PaymentModule } from '@thescaffold/ngx-common';
+import { PipesModule, SharedModule } from '@thescaffold/ngx-core';
+import { CRUD_PROVIDER, CrudModule, ElementsModule } from '@thescaffold/ngx-ui';
+import { CardComponent } from './card.component';
+import { CardProvider } from './card.provider';
+import * as i0 from "@angular/core";
+export class CardModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: CardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.5", ngImport: i0, type: CardModule, declarations: [CardComponent], imports: [SharedModule, PaymentModule, ElementsModule, PipesModule], exports: [CrudModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: CardModule, providers: [
+            {
+                provide: CRUD_PROVIDER,
+                useClass: CardProvider,
+            },
+        ], imports: [SharedModule, PaymentModule, ElementsModule, PipesModule, CrudModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: CardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [CardComponent],
+                    exports: [CrudModule],
+                    providers: [
+                        {
+                            provide: CRUD_PROVIDER,
+                            useClass: CardProvider,
+                        },
+                    ],
+                    imports: [SharedModule, PaymentModule, ElementsModule, PipesModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/pages/card/card.provider.mjs

@@ -0,0 +1,249 @@
+import { Injectable } from '@angular/core';
+import { CrudActionType, CrudProvider } from '@thescaffold/ngx-ui';
+import { CardComponent } from './card.component';
+import * as i0 from "@angular/core";
+export class CardProvider extends CrudProvider {
+    constructor() {
+        super(...arguments);
+        this.main = true;
+        this.name = this.translate('apps.capital.card.name');
+        this.pluralName = this.translate('apps.capital.card.plural');
+        this.dataSource = this.apiService.on('apps/capital/provider');
+        this.path = ['/', 'payments', 'card'];
+        this.columns = [
+            {
+                key: 'meta.last4',
+                value: this.translate('apps.capital.card.columns.last4.title'),
+                type: 'link',
+                links: (column, item) => [
+                    {
+                        title: `${item.meta.first6}...${item.meta.last4}`,
+                        fn: (link) => {
+                            this.show(item);
+                        },
+                    },
+                ],
+            },
+            {
+                key: 'meta.country',
+                value: this.translate('apps.capital.card.columns.country.title'),
+            },
+            {
+                key: 'currency',
+                value: this.translate('apps.capital.card.columns.currency.title'),
+            },
+            {
+                key: 'meta.expiry',
+                value: this.translate('apps.capital.card.columns.expiry.title'),
+            },
+            {
+                key: 'priority',
+                value: '',
+                type: 'class',
+                class: 'badge border text-primary',
+            },
+            {
+                key: 'createdAt',
+                value: '',
+                type: 'date',
+            },
+        ];
+        this.fields = [];
+        this.templateSource = CardComponent;
+        this.routes = {
+        // [CrudActionType.CloseCreate]: ['/', 'payments', 'card'],
+        // [CrudActionType.AfterSave]: ['/', 'payments', 'card'],
+        // [CrudActionType.CloseEdit]: ['/', 'payments', 'card'],
+        // [CrudActionType.AfterUpdate]: ['/', 'payments', 'card'],
+        // [CrudActionType.CloseShow]: ['/', 'payments', 'card'],
+        // [CrudActionType.CloseDelete]: ['/', 'payments', 'card'],
+        // [CrudActionType.AfterRemove]: ['/', 'payments', 'card'],
+        };
+        this.morphs = {
+            [CrudActionType.BeforeSave]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.AfterSave]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.BeforeEdit]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.AfterEdit]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.BeforeUpdate]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.AfterUpdate]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.BeforeShow]: (payload) => {
+                return {
+                    list: [
+                        {
+                            title: this.translate('apps.capital.card.show.list.name.title'),
+                            value: payload.name,
+                        },
+                        {
+                            title: this.translate('apps.capital.card.show.list.country.title'),
+                            value: payload.meta.country,
+                        },
+                        {
+                            title: this.translate('apps.capital.card.show.list.first6.title'),
+                            value: payload.meta.first6,
+                        },
+                        {
+                            title: this.translate('apps.capital.card.show.list.last4.title'),
+                            value: payload.meta.last4,
+                        },
+                        {
+                            title: this.translate('apps.capital.card.show.list.currency.title'),
+                            value: payload.currency,
+                        },
+                        {
+                            title: this.translate('apps.capital.card.show.list.expiry.title'),
+                            value: payload.meta.expiry,
+                        },
+                        {
+                            title: this.translate('apps.capital.card.show.list.priority.title'),
+                            value: payload.primary ? 'primary' : '',
+                        },
+                    ],
+                    ...payload,
+                };
+            },
+            [CrudActionType.AfterShow]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.BeforeList]: (payload) => {
+                return {
+                    ...payload,
+                    type: 'card',
+                };
+            },
+            [CrudActionType.AfterList]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.BeforeDelete]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.AfterDelete]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.BeforeRemove]: (payload) => {
+                return payload;
+            },
+            [CrudActionType.AfterRemove]: (payload) => {
+                return payload;
+            },
+        };
+        this.hooks = {
+            [CrudActionType.BeforeCreate]: () => { },
+            [CrudActionType.AfterCreate]: () => { },
+            [CrudActionType.BeforeSave]: (payload) => { },
+            [CrudActionType.AfterSave]: (payload, data) => { },
+            [CrudActionType.BeforeEdit]: (payload) => { },
+            [CrudActionType.AfterEdit]: (payload) => { },
+            [CrudActionType.BeforeUpdate]: (payload) => { },
+            [CrudActionType.AfterUpdate]: (payload, data) => { },
+            [CrudActionType.BeforeShow]: (payload) => { },
+            [CrudActionType.AfterShow]: (payload) => { },
+            [CrudActionType.BeforeList]: (payload) => { },
+            [CrudActionType.AfterList]: (payload, data) => { },
+            [CrudActionType.BeforeDelete]: (payload) => { },
+            [CrudActionType.AfterDelete]: (payload) => { },
+            [CrudActionType.BeforeRemove]: (payload) => { },
+            [CrudActionType.AfterRemove]: (payload, data) => { },
+        };
+        this.toCollection = (response) => {
+            return {
+                title: this.pluralName,
+                columns: this.columns,
+                rows: response?.data
+                    ?.sort((a, b) => {
+                    if (a.primary && !b.primary) {
+                        return -1;
+                    }
+                    if (!a.primary && b.primary) {
+                        return 1;
+                    }
+                    return 0; //a.primary == b.primary & others
+                })
+                    ?.map((r) => ({ ...r, priority: r.primary ? 'primary' : '' })),
+                links: {
+                    primary: [
+                        {
+                            title: this.translate('apps.capital.card.collection.links.primary.add-card.title'),
+                            fn: (link) => {
+                                this.create();
+                            },
+                        },
+                    ],
+                    secondary: [
+                        {
+                            title: this.translate('apps.capital.card.collection.links.secondary.view.title'),
+                            fn: (link, item) => {
+                                this.show(item);
+                            },
+                        },
+                        {
+                            title: this.translate('apps.capital.card.collection.links.secondary.make-primary.title'),
+                            fn: (link, item) => {
+                                this.update({ id: item.id, primary: true });
+                            },
+                            enabled: (link, item) => {
+                                return !item.primary;
+                            },
+                        },
+                        {
+                            title: this.translate('apps.capital.card.collection.links.secondary.remove-card.title'),
+                            fn: (link, item) => {
+                                this.delete(item);
+                            },
+                            enabled: (link, item) => {
+                                return !item.primary;
+                            },
+                        },
+                    ],
+                    tertiary: [],
+                    empty: [
+                        {
+                            title: this.translate('apps.capital.card.collection.links.empty.new.title'),
+                            fn: (link) => {
+                                this.create();
+                            },
+                        },
+                        // {
+                        //   title: this.translate(
+                        //     'apps.capital.card.collection.links.empty.learn-more.title',
+                        //   ),
+                        //   fn: (link: any) => {
+                        //     navigateExternal(
+                        //       `${getEnv('DOCS_BASE_URL')}/cards`,
+                        //       true,
+                        //     );
+                        //   },
+                        // },
+                    ],
+                },
+                hasTextFilter: true,
+                hasDateFilter: false,
+                selectable: false,
+                hasHeaders: true,
+                page: response?.meta?.current_page,
+                perPage: response?.meta?.per_page,
+                total: response?.meta?.total,
+            };
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: CardProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: CardProvider, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: CardProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"card.provider.js","sourceRoot":"","sources":["../../../../../../projects/capital/src/lib/pages/card/card.provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { CrudActionType, CrudProvider } from '@thescaffold/ngx-ui';\nimport { CardComponent } from './card.component';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CardProvider extends CrudProvider {\n  override main = true;\n  override name = this.translate('apps.capital.card.name');\n  override pluralName = this.translate('apps.capital.card.plural');\n  override dataSource = this.apiService.on('apps/capital/provider');\n  override path = ['/', 'payments', 'card'];\n  override columns = [\n    {\n      key: 'meta.last4',\n      value: this.translate('apps.capital.card.columns.last4.title'),\n      type: 'link',\n      links: (column: any, item: any) => [\n        {\n          title: `${item.meta.first6}...${item.meta.last4}`,\n          fn: (link: any) => {\n            this.show(item);\n          },\n        },\n      ],\n    },\n    {\n      key: 'meta.country',\n      value: this.translate('apps.capital.card.columns.country.title'),\n    },\n    {\n      key: 'currency',\n      value: this.translate('apps.capital.card.columns.currency.title'),\n    },\n    {\n      key: 'meta.expiry',\n      value: this.translate('apps.capital.card.columns.expiry.title'),\n    },\n    {\n      key: 'priority',\n      value: '',\n      type: 'class',\n      class: 'badge border text-primary',\n    },\n    {\n      key: 'createdAt',\n      value: '',\n      type: 'date',\n    },\n  ];\n  override fields = [];\n\n  override templateSource = CardComponent;\n\n  override routes = {\n    // [CrudActionType.CloseCreate]: ['/', 'payments', 'card'],\n    // [CrudActionType.AfterSave]: ['/', 'payments', 'card'],\n    // [CrudActionType.CloseEdit]: ['/', 'payments', 'card'],\n    // [CrudActionType.AfterUpdate]: ['/', 'payments', 'card'],\n    // [CrudActionType.CloseShow]: ['/', 'payments', 'card'],\n    // [CrudActionType.CloseDelete]: ['/', 'payments', 'card'],\n    // [CrudActionType.AfterRemove]: ['/', 'payments', 'card'],\n  };\n\n  override morphs = {\n    [CrudActionType.BeforeSave]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.AfterSave]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.BeforeEdit]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.AfterEdit]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.BeforeUpdate]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.AfterUpdate]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.BeforeShow]: (payload: any) => {\n      return {\n        list: [\n          {\n            title: this.translate('apps.capital.card.show.list.name.title'),\n            value: payload.name,\n          },\n          {\n            title: this.translate('apps.capital.card.show.list.country.title'),\n            value: payload.meta.country,\n          },\n          {\n            title: this.translate('apps.capital.card.show.list.first6.title'),\n            value: payload.meta.first6,\n          },\n          {\n            title: this.translate('apps.capital.card.show.list.last4.title'),\n            value: payload.meta.last4,\n          },\n          {\n            title: this.translate('apps.capital.card.show.list.currency.title'),\n            value: payload.currency,\n          },\n          {\n            title: this.translate('apps.capital.card.show.list.expiry.title'),\n            value: payload.meta.expiry,\n          },\n          {\n            title: this.translate('apps.capital.card.show.list.priority.title'),\n            value: payload.primary ? 'primary' : '',\n          },\n        ],\n        ...payload,\n      };\n    },\n    [CrudActionType.AfterShow]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.BeforeList]: (payload: any) => {\n      return {\n        ...payload,\n        type: 'card',\n      };\n    },\n    [CrudActionType.AfterList]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.BeforeDelete]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.AfterDelete]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.BeforeRemove]: (payload: any) => {\n      return payload;\n    },\n    [CrudActionType.AfterRemove]: (payload: any) => {\n      return payload;\n    },\n  };\n\n  override hooks = {\n    [CrudActionType.BeforeCreate]: () => {},\n    [CrudActionType.AfterCreate]: () => {},\n    [CrudActionType.BeforeSave]: (payload: any) => {},\n    [CrudActionType.AfterSave]: (payload: any, data: any) => {},\n    [CrudActionType.BeforeEdit]: (payload: any) => {},\n    [CrudActionType.AfterEdit]: (payload: any) => {},\n    [CrudActionType.BeforeUpdate]: (payload: any) => {},\n    [CrudActionType.AfterUpdate]: (payload: any, data: any) => {},\n    [CrudActionType.BeforeShow]: (payload: any) => {},\n    [CrudActionType.AfterShow]: (payload: any) => {},\n    [CrudActionType.BeforeList]: (payload: any) => {},\n    [CrudActionType.AfterList]: (payload: any, data: any) => {},\n    [CrudActionType.BeforeDelete]: (payload: any) => {},\n    [CrudActionType.AfterDelete]: (payload: any) => {},\n    [CrudActionType.BeforeRemove]: (payload: any) => {},\n    [CrudActionType.AfterRemove]: (payload: any, data: any) => {},\n  };\n\n  override toCollection = (response: any) => {\n    return {\n      title: this.pluralName,\n      columns: this.columns,\n      rows: response?.data\n        ?.sort((a: any, b: any) => {\n          if (a.primary && !b.primary) {\n            return -1;\n          }\n\n          if (!a.primary && b.primary) {\n            return 1;\n          }\n\n          return 0; //a.primary == b.primary & others\n        })\n        ?.map((r: any) => ({ ...r, priority: r.primary ? 'primary' : '' })),\n      links: {\n        primary: [\n          {\n            title: this.translate(\n              'apps.capital.card.collection.links.primary.add-card.title',\n            ),\n            fn: (link: any) => {\n              this.create();\n            },\n          },\n        ],\n        secondary: [\n          {\n            title: this.translate(\n              'apps.capital.card.collection.links.secondary.view.title',\n            ),\n            fn: (link: any, item: any) => {\n              this.show(item);\n            },\n          },\n          {\n            title: this.translate(\n              'apps.capital.card.collection.links.secondary.make-primary.title',\n            ),\n            fn: (link: any, item: any) => {\n              this.update({ id: item.id, primary: true });\n            },\n            enabled: (link: any, item: any) => {\n              return !item.primary;\n            },\n          },\n          {\n            title: this.translate(\n              'apps.capital.card.collection.links.secondary.remove-card.title',\n            ),\n            fn: (link: any, item: any) => {\n              this.delete(item);\n            },\n            enabled: (link: any, item: any) => {\n              return !item.primary;\n            },\n          },\n        ],\n        tertiary: [],\n        empty: [\n          {\n            title: this.translate(\n              'apps.capital.card.collection.links.empty.new.title',\n            ),\n            fn: (link: any) => {\n              this.create();\n            },\n          },\n          // {\n          //   title: this.translate(\n          //     'apps.capital.card.collection.links.empty.learn-more.title',\n          //   ),\n          //   fn: (link: any) => {\n          //     navigateExternal(\n          //       `${getEnv('DOCS_BASE_URL')}/cards`,\n          //       true,\n          //     );\n          //   },\n          // },\n        ],\n      },\n      hasTextFilter: true,\n      hasDateFilter: false,\n      selectable: false,\n      hasHeaders: true,\n      page: response?.meta?.current_page,\n      perPage: response?.meta?.per_page,\n      total: response?.meta?.total,\n    };\n  };\n}\n"]}