@firestitch/system 12.0.0 → 12.1.2

package/esm2015/app/components/crons/crons.component.js

@@ -1,191 +1,188 @@
-import { Component, ViewChild, Input } from '@angular/core';
-import { MatDialog } from '@angular/material/dialog';
-import { FsMessage } from '@firestitch/message';
-import { ItemType } from '@firestitch/filter';
-import { FsListComponent } from '@firestitch/list';
-import { map, tap } from 'rxjs/operators';
-import { SystemService } from './../../services';
-import { indexNameValue } from '../../helpers/index-name-value';
-import { CronComponent } from '../cron/cron.component';
-import { CronStates } from '../../consts';
-import { CronState } from '../../enums';
-import { SelectionActionType } from '@firestitch/selection';
-import * as i0 from "@angular/core";
-import * as i1 from "@firestitch/message";
-import * as i2 from "./../../services";
-import * as i3 from "@angular/material/dialog";
-import * as i4 from "@firestitch/list";
-import * as i5 from "@firestitch/date";
-import * as i6 from "@angular/common";
-export class CronsComponent {
-    constructor(_message, _systemService, _dialog) {
-        this._message = _message;
-        this._systemService = _systemService;
-        this._dialog = _dialog;
-        this.config = null;
-        this.cronStates = indexNameValue(CronStates);
-    }
-    ngOnInit() {
-        this._configList();
-    }
-    _configList() {
-        this.config = {
-            paging: false,
-            filters: [
-                {
-                    type: ItemType.Keyword,
-                    name: 'keyword',
-                    label: 'Search'
-                }
-            ],
-            rowActions: this.getCronActions()
-                .map((rowAction) => {
-                return Object.assign(Object.assign({}, rowAction), { click: (cron) => {
-                        rowAction.action(cron)
-                            .subscribe();
-                    } });
-            }),
-            fetch: query => {
-                query.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-                return this.loadCrons(query)
-                    .pipe(map((response) => ({ data: this._systemService.input(response) })));
-            },
-        };
-        if (this.bulk) {
-            this.config.selection = {
-                selectAll: false,
-                actions: [
-                    {
-                        type: SelectionActionType.Action,
-                        name: 'disable',
-                        label: 'Disable'
-                    },
-                    {
-                        type: SelectionActionType.Action,
-                        name: 'enable',
-                        label: 'Enable'
-                    },
-                ],
-                actionSelected: (action) => {
-                    return this.bulk(action.action.name, action.selected)
-                        .pipe(tap(() => {
-                        this.list.reload();
-                        this._message.success('Applied Changes');
-                    }));
-                },
-            };
-        }
-    }
-    open(cron) {
-        this._dialog.open(CronComponent, {
-            data: {
-                cron,
-                loadCronLogs: this.loadCronLogs,
-                loadCron: this.loadCron,
-                cronActions: this.getCronActions(),
-            },
-            width: '85%'
-        });
-    }
-    getCronActions() {
-        return [
-            {
-                action: (data) => {
-                    return this.queue(this._systemService.output(data))
-                        .pipe(tap(() => {
-                        this._message.success('Queued cron');
-                        this.list.reload();
-                    }));
-                },
-                label: 'Queue',
-                show: (cron) => {
-                    return cron.state === CronState.Idle || cron.state === CronState.Failed;
-                },
-            },
-            {
-                action: (data) => {
-                    return this.run(this._systemService.output(data))
-                        .pipe(tap(() => {
-                        this._message.success('Cron ran');
-                        this.list.reload();
-                    }));
-                },
-                label: 'Run',
-                show: (cron) => {
-                    return cron.state === CronState.Idle || cron.state === CronState.Failed;
-                },
-            },
-            {
-                action: (data) => {
-                    return this.enable(this._systemService.output(data))
-                        .pipe(tap(() => {
-                        this._message.success('Enabled cron');
-                        this.list.reload();
-                    }));
-                },
-                label: 'Enable',
-                show: (cron) => {
-                    return cron.state === CronState.Disabled;
-                },
-            },
-            {
-                action: (data) => {
-                    return this.disable(this._systemService.output(data))
-                        .pipe(tap(() => {
-                        this._message.success('Disabled cron');
-                        this.list.reload();
-                    }));
-                },
-                label: 'Disable',
-                show: (cron) => {
-                    return cron.state === CronState.Idle || cron.state === CronState.Failed;
-                },
-            },
-            {
-                action: (data) => {
-                    return this.kill(this._systemService.output(data))
-                        .pipe(tap(() => {
-                        this._message.success('Killed cron');
-                        this.list.reload();
-                    }));
-                },
-                label: 'Kill',
-                show: (cron) => {
-                    return cron.state === CronState.Running;
-                },
-            },
-        ];
-    }
-}
-CronsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CronsComponent, deps: [{ token: i1.FsMessage }, { token: i2.SystemService }, { token: i3.MatDialog }], target: i0.ɵɵFactoryTarget.Component });
-CronsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: CronsComponent, selector: "fs-system-crons", inputs: { enable: "enable", disable: "disable", kill: "kill", queue: "queue", run: "run", loadCrons: "loadCrons", loadCron: "loadCron", loadCronLogs: "loadCronLogs", bulk: "bulk" }, viewQueries: [{ propertyName: "list", first: true, predicate: FsListComponent, descendants: true, static: true }], ngImport: i0, template: "<fs-list [config]=\"config\">\n  <fs-list-column>\n    <ng-template fs-list-header>Name</ng-template>\n    <ng-template fs-list-cell let-row=\"row\">\n      <a (click)=\"open(row)\">{{row.name}}</a>\n      <div *ngIf=\"row.cronSetting\">\n        <small>{{row.cronSetting.summary}}</small>\n      </div>\n    </ng-template>\n  </fs-list-column>\n  <fs-list-column>\n    <ng-template fs-list-header>Status</ng-template>\n    <ng-template fs-list-cell let-row=\"row\">\n      {{cronStates[row.state]}}\n    </ng-template>\n  </fs-list-column>\n  <fs-list-column>\n    <ng-template fs-list-header>Last Ran</ng-template>\n    <ng-template fs-list-cell let-row=\"row\">\n      <ng-container *ngIf=\"row.duration===null; else lastRan\">\n        Never\n      </ng-container>\n      <ng-template #lastRan>\n        <fs-date-ago [date]=\"row.createDate\"></fs-date-ago>\n        <div><small *ngIf=\"row.duration\">Duration: {{ row.duration | fsDateDuration }}</small></div>\n      </ng-template>\n    </ng-template>\n  </fs-list-column>\n</fs-list>\n", styles: [""], components: [{ type: i4.FsListComponent, selector: "fs-list", inputs: ["config", "loaderLines"], outputs: ["filtersReady"] }, { type: i5.FsDateAgoComponent, selector: "fs-date-ago", inputs: ["date", "showTime", "format", "showTooltip", "tooltipDateFormat"] }], directives: [{ type: i4.FsListColumnDirective, selector: "fs-list-column", inputs: ["title", "name", "show", "customize", "sortable", "sortableDefault", "direction", "align", "width", "class"] }, { type: i4.FsListHeaderDirective, selector: "[fs-list-header]", inputs: ["colspan", "align", "class"] }, { type: i4.FsListCellDirective, selector: "[fs-list-cell]", inputs: ["colspan", "align", "class"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "fsDateDuration": i5.FsDateDurationPipe } });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CronsComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'fs-system-crons',
-                    templateUrl: './crons.component.html',
-                    styleUrls: ['./crons.component.scss'],
-                }]
-        }], ctorParameters: function () { return [{ type: i1.FsMessage }, { type: i2.SystemService }, { type: i3.MatDialog }]; }, propDecorators: { list: [{
-                type: ViewChild,
-                args: [FsListComponent, { static: true }]
-            }], enable: [{
-                type: Input
-            }], disable: [{
-                type: Input
-            }], kill: [{
-                type: Input
-            }], queue: [{
-                type: Input
-            }], run: [{
-                type: Input
-            }], loadCrons: [{
-                type: Input
-            }], loadCron: [{
-                type: Input
-            }], loadCronLogs: [{
-                type: Input
-            }], bulk: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crons.component.js","sourceRoot":"","sources":["../../../../../src/app/components/crons/crons.component.ts","../../../../../src/app/components/crons/crons.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, ViewChild, Input } from '@angular/core';\r\nimport { MatDialog } from '@angular/material/dialog';\r\n\r\nimport { FsMessage } from '@firestitch/message';\r\nimport { ItemType } from '@firestitch/filter';\r\nimport { FsListConfig, FsListComponent, FsListActionSelected } from '@firestitch/list';\r\n\r\nimport { map, tap } from 'rxjs/operators';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { SystemService } from './../../services';\r\nimport { indexNameValue } from '../../helpers/index-name-value';\r\nimport { CronComponent } from '../cron/cron.component';\r\nimport { CronStates } from '../../consts';\r\nimport { CronState } from '../../enums';\r\nimport { SelectionActionType } from '@firestitch/selection';\r\n\r\n\r\n@Component({\r\n  selector: 'fs-system-crons',\r\n  templateUrl: './crons.component.html',\r\n  styleUrls: ['./crons.component.scss'],\r\n})\r\nexport class CronsComponent implements OnInit {\r\n\r\n  @ViewChild(FsListComponent, { static: true }) list: FsListComponent;\r\n\r\n  @Input() public enable: (data: any) => Observable<any>;\r\n  @Input() public disable: (data: any) => Observable<any>;\r\n  @Input() public kill: (data: any) => Observable<any>;\r\n  @Input() public queue: (data: any) => Observable<any>;\r\n  @Input() public run: (data: any) => Observable<any>;\r\n  @Input() public loadCrons: (data: any) => Observable<any[]>;\r\n  @Input() public loadCron: (data: any) => Observable<any>;\r\n  @Input() public loadCronLogs: (data: any) => Observable<{ data: any[], paging: any }>;\r\n  @Input() public bulk: (actionName: string, data: any[]) => Observable<any>;\r\n\r\n  public config: FsListConfig = null;\r\n  public cronStates = indexNameValue(CronStates);\r\n\r\n  constructor(\r\n    private _message: FsMessage,\r\n    private _systemService: SystemService,\r\n    private _dialog: MatDialog,\r\n  ) { }\r\n\r\n  public ngOnInit(): void {\r\n    this._configList();\r\n  }\r\n\r\n  private _configList(): void {\r\n    this.config = {\r\n      paging: false,\r\n      filters: [\r\n        {\r\n          type: ItemType.Keyword,\r\n          name: 'keyword',\r\n          label: 'Search'\r\n        }\r\n      ],\r\n      rowActions: this.getCronActions()\r\n      .map((rowAction) => {\r\n        return {\r\n          ...rowAction,\r\n          click: (cron) => {\r\n            rowAction.action(cron)\r\n            .subscribe();\r\n          },\r\n        }\r\n      }),\r\n      fetch: query => {\r\n        query.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;\r\n        return this.loadCrons(query)\r\n          .pipe(\r\n            map((response) => ({ data: this._systemService.input(response) }))\r\n          );\r\n      },    \r\n    };\r\n\r\n    if(this.bulk) {\r\n      this.config.selection = {\r\n        selectAll: false,\r\n        actions: [\r\n          {\r\n            type: SelectionActionType.Action,\r\n            name: 'disable',\r\n            label: 'Disable'\r\n          },\r\n          {\r\n            type: SelectionActionType.Action,\r\n            name: 'enable',\r\n            label: 'Enable'\r\n          },\r\n        ],\r\n        actionSelected: (action: FsListActionSelected) => {\r\n          return this.bulk(action.action.name, action.selected)\r\n          .pipe(\r\n            tap(() => {\r\n              this.list.reload();\r\n              this._message.success('Applied Changes');\r\n            }),\r\n          );\r\n        },\r\n      };\r\n    }\r\n  }\r\n\r\n  public open(cron) {\r\n    this._dialog.open(CronComponent, {\r\n      data: { \r\n        cron,\r\n        loadCronLogs: this.loadCronLogs,\r\n        loadCron: this.loadCron,\r\n        cronActions: this.getCronActions(),\r\n      },\r\n      width: '85%'\r\n    });\r\n  }  \r\n\r\n  public getCronActions() {\r\n    return [\r\n      {\r\n        action: (data) => {\r\n          return this.queue(this._systemService.output(data))\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Queued cron');\r\n              this.list.reload();\r\n            }),\r\n          );\r\n        },\r\n        label: 'Queue',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Idle || cron.state === CronState.Failed;\r\n        },\r\n      },\r\n      {\r\n        action: (data) => {\r\n          return this.run(this._systemService.output(data))\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Cron ran');\r\n              this.list.reload();\r\n            })\r\n          );\r\n        },\r\n        label: 'Run',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Idle || cron.state === CronState.Failed;\r\n        },\r\n      },\r\n      {\r\n        action: (data) => {\r\n          return this.enable(this._systemService.output(data))\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Enabled cron');\r\n              this.list.reload();\r\n            }),\r\n          );\r\n        },\r\n        label: 'Enable',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Disabled;\r\n        },\r\n      },\r\n      {\r\n        action: (data) => {\r\n          return this.disable(this._systemService.output(data))\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Disabled cron');\r\n              this.list.reload();\r\n            }),\r\n          );\r\n        },\r\n        label: 'Disable',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Idle || cron.state === CronState.Failed;\r\n        },\r\n      },\r\n      {\r\n        action: (data) => {\r\n          return this.kill(this._systemService.output(data))\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Killed cron');\r\n              this.list.reload();\r\n            }),\r\n          );\r\n        },\r\n        label: 'Kill',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Running;\r\n        },\r\n      },\r\n    ];    \r\n  }\r\n}\r\n","<fs-list [config]=\"config\">\n  <fs-list-column>\n    <ng-template fs-list-header>Name</ng-template>\n    <ng-template fs-list-cell let-row=\"row\">\n      <a (click)=\"open(row)\">{{row.name}}</a>\n      <div *ngIf=\"row.cronSetting\">\n        <small>{{row.cronSetting.summary}}</small>\n      </div>\n    </ng-template>\n  </fs-list-column>\n  <fs-list-column>\n    <ng-template fs-list-header>Status</ng-template>\n    <ng-template fs-list-cell let-row=\"row\">\n      {{cronStates[row.state]}}\n    </ng-template>\n  </fs-list-column>\n  <fs-list-column>\n    <ng-template fs-list-header>Last Ran</ng-template>\n    <ng-template fs-list-cell let-row=\"row\">\n      <ng-container *ngIf=\"row.duration===null; else lastRan\">\n        Never\n      </ng-container>\n      <ng-template #lastRan>\n        <fs-date-ago [date]=\"row.createDate\"></fs-date-ago>\n        <div><small *ngIf=\"row.duration\">Duration: {{ row.duration | fsDateDuration }}</small></div>\n      </ng-template>\n    </ng-template>\n  </fs-list-column>\n</fs-list>\n"]}
+import { Component, ViewChild, Input } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { FsMessage } from '@firestitch/message';
+import { ItemType } from '@firestitch/filter';
+import { FsListComponent } from '@firestitch/list';
+import { map, tap } from 'rxjs/operators';
+import { indexNameValue } from '../../helpers/index-name-value';
+import { CronComponent } from '../cron/cron.component';
+import { CronStates } from '../../consts';
+import { CronState } from '../../enums';
+import { SelectionActionType } from '@firestitch/selection';
+import * as i0 from "@angular/core";
+import * as i1 from "@firestitch/message";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "@firestitch/list";
+import * as i4 from "@firestitch/date";
+import * as i5 from "@angular/common";
+export class CronsComponent {
+    constructor(_message, _dialog) {
+        this._message = _message;
+        this._dialog = _dialog;
+        this.config = null;
+        this.cronStates = indexNameValue(CronStates);
+    }
+    ngOnInit() {
+        this._configList();
+    }
+    _configList() {
+        this.config = {
+            paging: false,
+            filters: [
+                {
+                    type: ItemType.Keyword,
+                    name: 'keyword',
+                    label: 'Search'
+                }
+            ],
+            rowActions: this.getCronActions()
+                .map((rowAction) => {
+                return Object.assign(Object.assign({}, rowAction), { click: (cron) => {
+                        rowAction.action(cron)
+                            .subscribe();
+                    } });
+            }),
+            fetch: query => {
+                query.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+                return this.loadCrons(query)
+                    .pipe(map((response) => ({ data: response })));
+            },
+        };
+        if (this.bulk) {
+            this.config.selection = {
+                selectAll: false,
+                actions: [
+                    {
+                        type: SelectionActionType.Action,
+                        name: 'disable',
+                        label: 'Disable'
+                    },
+                    {
+                        type: SelectionActionType.Action,
+                        name: 'enable',
+                        label: 'Enable'
+                    },
+                ],
+                actionSelected: (action) => {
+                    return this.bulk(action.action.name, action.selected)
+                        .pipe(tap(() => {
+                        this.list.reload();
+                        this._message.success('Applied Changes');
+                    }));
+                },
+            };
+        }
+    }
+    open(cron) {
+        this._dialog.open(CronComponent, {
+            data: {
+                cron,
+                loadCronLogs: this.loadCronLogs,
+                loadCron: this.loadCron,
+                cronActions: this.getCronActions(),
+            },
+            width: '85%'
+        });
+    }
+    getCronActions() {
+        return [
+            {
+                action: (data) => {
+                    return this.queue(data)
+                        .pipe(tap(() => {
+                        this._message.success('Queued cron');
+                        this.list.reload();
+                    }));
+                },
+                label: 'Queue',
+                show: (cron) => {
+                    return cron.state === CronState.Idle || cron.state === CronState.Failed;
+                },
+            },
+            {
+                action: (data) => {
+                    return this.run(data)
+                        .pipe(tap(() => {
+                        this._message.success('Cron ran');
+                        this.list.reload();
+                    }));
+                },
+                label: 'Run',
+                show: (cron) => {
+                    return cron.state === CronState.Idle || cron.state === CronState.Failed;
+                },
+            },
+            {
+                action: (data) => {
+                    return this.enable(data)
+                        .pipe(tap(() => {
+                        this._message.success('Enabled cron');
+                        this.list.reload();
+                    }));
+                },
+                label: 'Enable',
+                show: (cron) => {
+                    return cron.state === CronState.Disabled;
+                },
+            },
+            {
+                action: (data) => {
+                    return this.disable(data)
+                        .pipe(tap(() => {
+                        this._message.success('Disabled cron');
+                        this.list.reload();
+                    }));
+                },
+                label: 'Disable',
+                show: (cron) => {
+                    return cron.state === CronState.Idle || cron.state === CronState.Failed;
+                },
+            },
+            {
+                action: (data) => {
+                    return this.kill(data)
+                        .pipe(tap(() => {
+                        this._message.success('Killed cron');
+                        this.list.reload();
+                    }));
+                },
+                label: 'Kill',
+                show: (cron) => {
+                    return cron.state === CronState.Running;
+                },
+            },
+        ];
+    }
+}
+CronsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CronsComponent, deps: [{ token: i1.FsMessage }, { token: i2.MatDialog }], target: i0.ɵɵFactoryTarget.Component });
+CronsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: CronsComponent, selector: "fs-system-crons", inputs: { enable: "enable", disable: "disable", kill: "kill", queue: "queue", run: "run", loadCrons: "loadCrons", loadCron: "loadCron", loadCronLogs: "loadCronLogs", bulk: "bulk" }, viewQueries: [{ propertyName: "list", first: true, predicate: FsListComponent, descendants: true, static: true }], ngImport: i0, template: "<fs-list [config]=\"config\">\r\n  <fs-list-column>\r\n    <ng-template fs-list-header>Name</ng-template>\r\n    <ng-template fs-list-cell let-row=\"row\">\r\n      <a (click)=\"open(row)\">{{row.name}}</a>\r\n      <div *ngIf=\"row.cronSetting\">\r\n        <small>{{row.cronSetting.summary}}</small>\r\n      </div>\r\n    </ng-template>\r\n  </fs-list-column>\r\n  <fs-list-column>\r\n    <ng-template fs-list-header>Status</ng-template>\r\n    <ng-template fs-list-cell let-row=\"row\">\r\n      {{cronStates[row.state]}}\r\n    </ng-template>\r\n  </fs-list-column>\r\n  <fs-list-column>\r\n    <ng-template fs-list-header>Last Ran</ng-template>\r\n    <ng-template fs-list-cell let-row=\"row\">\r\n      <ng-container *ngIf=\"row.duration===null; else lastRan\">\r\n        Never\r\n      </ng-container>\r\n      <ng-template #lastRan>\r\n        <fs-date-ago [date]=\"row.createDate\"></fs-date-ago>\r\n        <div><small *ngIf=\"row.duration\">Duration: {{ row.duration | fsDateDuration }}</small></div>\r\n      </ng-template>\r\n    </ng-template>\r\n  </fs-list-column>\r\n</fs-list>\r\n", styles: [""], components: [{ type: i3.FsListComponent, selector: "fs-list", inputs: ["config", "loaderLines"], outputs: ["filtersReady"] }, { type: i4.FsDateAgoComponent, selector: "fs-date-ago", inputs: ["date", "showTime", "format", "showTooltip", "tooltipDateFormat"] }], directives: [{ type: i3.FsListColumnDirective, selector: "fs-list-column", inputs: ["title", "name", "show", "customize", "sortable", "sortableDefault", "direction", "align", "width", "class"] }, { type: i3.FsListHeaderDirective, selector: "[fs-list-header]", inputs: ["colspan", "align", "class"] }, { type: i3.FsListCellDirective, selector: "[fs-list-cell]", inputs: ["colspan", "align", "class"] }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "fsDateDuration": i4.FsDateDurationPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CronsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'fs-system-crons',
+                    templateUrl: './crons.component.html',
+                    styleUrls: ['./crons.component.scss'],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FsMessage }, { type: i2.MatDialog }]; }, propDecorators: { list: [{
+                type: ViewChild,
+                args: [FsListComponent, { static: true }]
+            }], enable: [{
+                type: Input
+            }], disable: [{
+                type: Input
+            }], kill: [{
+                type: Input
+            }], queue: [{
+                type: Input
+            }], run: [{
+                type: Input
+            }], loadCrons: [{
+                type: Input
+            }], loadCron: [{
+                type: Input
+            }], loadCronLogs: [{
+                type: Input
+            }], bulk: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crons.component.js","sourceRoot":"","sources":["../../../../../src/app/components/crons/crons.component.ts","../../../../../src/app/components/crons/crons.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, ViewChild, Input } from '@angular/core';\r\nimport { MatDialog } from '@angular/material/dialog';\r\n\r\nimport { FsMessage } from '@firestitch/message';\r\nimport { ItemType } from '@firestitch/filter';\r\nimport { FsListConfig, FsListComponent, FsListActionSelected } from '@firestitch/list';\r\n\r\nimport { map, tap } from 'rxjs/operators';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { indexNameValue } from '../../helpers/index-name-value';\r\nimport { CronComponent } from '../cron/cron.component';\r\nimport { CronStates } from '../../consts';\r\nimport { CronState } from '../../enums';\r\nimport { SelectionActionType } from '@firestitch/selection';\r\n\r\n\r\n@Component({\r\n  selector: 'fs-system-crons',\r\n  templateUrl: './crons.component.html',\r\n  styleUrls: ['./crons.component.scss'],\r\n})\r\nexport class CronsComponent implements OnInit {\r\n\r\n  @ViewChild(FsListComponent, { static: true }) list: FsListComponent;\r\n\r\n  @Input() public enable: (data: any) => Observable<any>;\r\n  @Input() public disable: (data: any) => Observable<any>;\r\n  @Input() public kill: (data: any) => Observable<any>;\r\n  @Input() public queue: (data: any) => Observable<any>;\r\n  @Input() public run: (data: any) => Observable<any>;\r\n  @Input() public loadCrons: (data: any) => Observable<any[]>;\r\n  @Input() public loadCron: (data: any) => Observable<any>;\r\n  @Input() public loadCronLogs: (data: any) => Observable<{ data: any[], paging: any }>;\r\n  @Input() public bulk: (actionName: string, data: any[]) => Observable<any>;\r\n\r\n  public config: FsListConfig = null;\r\n  public cronStates = indexNameValue(CronStates);\r\n\r\n  constructor(\r\n    private _message: FsMessage,\r\n    private _dialog: MatDialog,\r\n  ) { }\r\n\r\n  public ngOnInit(): void {\r\n    this._configList();\r\n  }\r\n\r\n  private _configList(): void {\r\n    this.config = {\r\n      paging: false,\r\n      filters: [\r\n        {\r\n          type: ItemType.Keyword,\r\n          name: 'keyword',\r\n          label: 'Search'\r\n        }\r\n      ],\r\n      rowActions: this.getCronActions()\r\n      .map((rowAction) => {\r\n        return {\r\n          ...rowAction,\r\n          click: (cron) => {\r\n            rowAction.action(cron)\r\n            .subscribe();\r\n          },\r\n        }\r\n      }),\r\n      fetch: query => {\r\n        query.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;\r\n        return this.loadCrons(query)\r\n          .pipe(\r\n            map((response) => ({ data: response }))\r\n          );\r\n      },    \r\n    };\r\n\r\n    if(this.bulk) {\r\n      this.config.selection = {\r\n        selectAll: false,\r\n        actions: [\r\n          {\r\n            type: SelectionActionType.Action,\r\n            name: 'disable',\r\n            label: 'Disable'\r\n          },\r\n          {\r\n            type: SelectionActionType.Action,\r\n            name: 'enable',\r\n            label: 'Enable'\r\n          },\r\n        ],\r\n        actionSelected: (action: FsListActionSelected) => {\r\n          return this.bulk(action.action.name, action.selected)\r\n          .pipe(\r\n            tap(() => {\r\n              this.list.reload();\r\n              this._message.success('Applied Changes');\r\n            }),\r\n          );\r\n        },\r\n      };\r\n    }\r\n  }\r\n\r\n  public open(cron) {\r\n    this._dialog.open(CronComponent, {\r\n      data: { \r\n        cron,\r\n        loadCronLogs: this.loadCronLogs,\r\n        loadCron: this.loadCron,\r\n        cronActions: this.getCronActions(),\r\n      },\r\n      width: '85%'\r\n    });\r\n  }  \r\n\r\n  public getCronActions() {\r\n    return [\r\n      {\r\n        action: (data) => {\r\n          return this.queue(data)\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Queued cron');\r\n              this.list.reload();\r\n            }),\r\n          );\r\n        },\r\n        label: 'Queue',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Idle || cron.state === CronState.Failed;\r\n        },\r\n      },\r\n      {\r\n        action: (data) => {\r\n          return this.run(data)\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Cron ran');\r\n              this.list.reload();\r\n            })\r\n          );\r\n        },\r\n        label: 'Run',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Idle || cron.state === CronState.Failed;\r\n        },\r\n      },\r\n      {\r\n        action: (data) => {\r\n          return this.enable(data)\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Enabled cron');\r\n              this.list.reload();\r\n            }),\r\n          );\r\n        },\r\n        label: 'Enable',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Disabled;\r\n        },\r\n      },\r\n      {\r\n        action: (data) => {\r\n          return this.disable(data)\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Disabled cron');\r\n              this.list.reload();\r\n            }),\r\n          );\r\n        },\r\n        label: 'Disable',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Idle || cron.state === CronState.Failed;\r\n        },\r\n      },\r\n      {\r\n        action: (data) => {\r\n          return this.kill(data)\r\n          .pipe(\r\n            tap(() => {\r\n              this._message.success('Killed cron');\r\n              this.list.reload();\r\n            }),\r\n          );\r\n        },\r\n        label: 'Kill',\r\n        show: (cron) => {\r\n          return cron.state === CronState.Running;\r\n        },\r\n      },\r\n    ];    \r\n  }\r\n}\r\n","<fs-list [config]=\"config\">\r\n  <fs-list-column>\r\n    <ng-template fs-list-header>Name</ng-template>\r\n    <ng-template fs-list-cell let-row=\"row\">\r\n      <a (click)=\"open(row)\">{{row.name}}</a>\r\n      <div *ngIf=\"row.cronSetting\">\r\n        <small>{{row.cronSetting.summary}}</small>\r\n      </div>\r\n    </ng-template>\r\n  </fs-list-column>\r\n  <fs-list-column>\r\n    <ng-template fs-list-header>Status</ng-template>\r\n    <ng-template fs-list-cell let-row=\"row\">\r\n      {{cronStates[row.state]}}\r\n    </ng-template>\r\n  </fs-list-column>\r\n  <fs-list-column>\r\n    <ng-template fs-list-header>Last Ran</ng-template>\r\n    <ng-template fs-list-cell let-row=\"row\">\r\n      <ng-container *ngIf=\"row.duration===null; else lastRan\">\r\n        Never\r\n      </ng-container>\r\n      <ng-template #lastRan>\r\n        <fs-date-ago [date]=\"row.createDate\"></fs-date-ago>\r\n        <div><small *ngIf=\"row.duration\">Duration: {{ row.duration | fsDateDuration }}</small></div>\r\n      </ng-template>\r\n    </ng-template>\r\n  </fs-list-column>\r\n</fs-list>\r\n"]}

package/esm2015/app/components/crons/index.js

@@ -1,2 +1,2 @@
-export * from './crons.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2NvbXBvbmVudHMvY3JvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY3JvbnMuY29tcG9uZW50JztcbiJdfQ==
+export * from './crons.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2NvbXBvbmVudHMvY3JvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY3JvbnMuY29tcG9uZW50JztcclxuIl19