@colijnit/sharedcomponents 1.0.68 → 1.0.70

package/esm2015/lib/components/task-modifyer/task-modifier.component.js

@@ -0,0 +1,270 @@
+import { __awaiter, __decorate } from "tslib";
+import { Component, EventEmitter, forwardRef, HostBinding, Input, Output, ViewChild } from "@angular/core";
+import { CoreDialogService, FormComponent } from "@colijnit/corecomponents_v12";
+import { Activity } from "@colijnit/mainapi/build/model/activity.bo";
+import { InputBoolean } from "../../decorator/input-boolean.decorator";
+import { Icon } from "../../enum/icon.enum";
+import { DictionaryService } from "../../service/dictionary.service";
+import { BusinessObjectFactory } from "@colijnit/ioneconnector/build/service/business-object-factory";
+import { IconCacheService } from "../../service/icon-cache.service";
+import { AppPopupButtonType } from "../../enum/app-button-type.enum";
+import { ModifyTaskFormComponent } from "../modify-task-form/modify-task-form.component";
+export class TaskModifierComponent {
+    constructor(_dialogService, _boFactory, _dictionary, iconService) {
+        this._dialogService = _dialogService;
+        this._boFactory = _boFactory;
+        this._dictionary = _dictionary;
+        this.iconService = iconService;
+        this.icons = Icon;
+        this.editingComplete = new EventEmitter();
+        this.activitySaved = new EventEmitter();
+        this.activityDeleted = new EventEmitter();
+        this.closedWithoutComplete = new EventEmitter();
+        this.showWorkLog = new EventEmitter();
+        this.taskCreated = new EventEmitter();
+        this.taskModified = new EventEmitter();
+        this.showAfterInsert = false;
+        this.showNewForm = false;
+        this.showModificationForm = false;
+        this.taskEditting = false;
+        this.Icon = Icon;
+    }
+    get readonly() {
+        //return this.moduleService.readonly &&
+        return false;
+    }
+    showClass() {
+        return true;
+    }
+    get showForm() {
+        return this.showNewForm || this.showModificationForm;
+    }
+    get header() {
+        return (this.showModificationForm) ? "TASK" : "ADD_TASK2";
+    }
+    get subHeader() {
+        return this.currentActivity ? this.currentActivity.task.taskId + "" : "";
+    }
+    get subSubHeader() {
+        var _a, _b, _c, _d, _e, _f;
+        if (((_b = (_a = this.currentActivity) === null || _a === void 0 ? void 0 : _a.task) === null || _b === void 0 ? void 0 : _b.lastModifiedBy) && ((_d = (_c = this.currentActivity) === null || _c === void 0 ? void 0 : _c.task) === null || _d === void 0 ? void 0 : _d.lastModifiedDate)) {
+            const label = this._dictionary.get('LAST_CHANGE');
+            const lastModifiedBy = (_e = this.currentActivity.task) === null || _e === void 0 ? void 0 : _e.lastModifiedDisplayName;
+            const lastModifiedDate = (_f = this.currentActivity.task) === null || _f === void 0 ? void 0 : _f.lastModifiedDate.toLocaleString();
+            return label + ': ' + lastModifiedBy + ' | ' + lastModifiedDate;
+        }
+        return "";
+    }
+    get subHeaderLink() {
+        if (this.showModificationForm && this.currentActivity && this.currentActivity.task) {
+            if (this.currentActivity.task.workflowCategory && this.currentActivity.task.reference) {
+                let activityName;
+                activityName = this._dictionary.get("WORKFLOW_CATEGORY_" + this.currentActivity.task.workflowCategory) + " " + this.currentActivity.task.reference + ")";
+                return activityName;
+            }
+        }
+        return "";
+    }
+    get userIsTaskReporter() {
+        return this.editActivity &&
+            ((this.editActivity.task.reporterUserGroupId && this.editActivity.task.reporterUserGroupId === this.userGroupId) ||
+                (this.editActivity.task.reporter && this.editActivity.task.reporter.relationId === this.relationId));
+    }
+    ngOnDestroy() {
+    }
+    handleSaveForm() {
+        this.mainForm.submit();
+    }
+    onValid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.editActivity) {
+                const newActivity = this.editActivity.isNew;
+                const result = yield this.upsertActivityOperation(this.editActivity);
+                if (result) {
+                    this.activitySaved.next(this.editActivity);
+                    this.editingComplete.next(this.editActivity);
+                    if (newActivity) {
+                        this.taskCreated.next(this.editActivity.task);
+                    }
+                    else {
+                        this.taskModified.next(this.editActivity.task);
+                    }
+                    if (this.showAfterInsert) {
+                        this.startModifyingTask(this.editActivity);
+                    }
+                }
+                this.hide();
+            }
+        });
+    }
+    handleCancelForm() {
+        this._createClone();
+        //TODO: is this needed?
+        //this.moduleService.cancelEdit();
+        this.closedWithoutComplete.next(true);
+        this.hide();
+    }
+    onPopupClose() {
+        this.forceReadonly = false;
+        this.hide();
+        this.closedWithoutComplete.next(true);
+    }
+    //TODO figure out routing from external component
+    /*public openReferenceInModule(): void {
+        if (this.currentActivity && this.currentActivity.task) {
+            if (this.currentActivity.task.workflowCategory === WorkflowCategoryType.AbsenceFile || this.currentActivity.task.workflowCategory === WorkflowCategoryType.PreventiveAbsenceFile) {
+                this._appNavigator.navigateToIOneModule(IOneModuleName.AbsenceFile, this.currentActivity.task.referenceId);
+            }
+        }
+
+    }*/
+    hide() {
+        this.showNewForm = false;
+        this.showModificationForm = false;
+    }
+    deleteTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const doDelete = yield this._dialogService.showYesNo("DELETE_TASK", "DELETE_TASK", false);
+            if (doDelete.button === AppPopupButtonType.Yes) {
+                yield this.deleteActivityOperation(this.editActivity);
+                this.activityDeleted.next(this.editActivity);
+                this.hide();
+            }
+        });
+    }
+    createNewTask(standalone = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.showForm) {
+                return;
+            }
+            this.showAfterInsert = false;
+            this.currentActivity = yield this.createTaskOperation({ standalone: standalone, workflowCategory: this.workflowCategory, reference: this.reference, referenceId: this.referenceId });
+            this._createClone();
+            this.showNewForm = true;
+        });
+    }
+    startModifyingTask(activity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.showForm || !activity.IsTask) {
+                return;
+            }
+            this.showAfterInsert = false;
+            yield this.tryLockTaskOperation(activity.task.taskId);
+            activity.task = activity.task;
+            this.currentActivity = activity;
+            this._createClone();
+            this.showModificationForm = true;
+        });
+    }
+    startModifyingTaskAndWorkLog(activity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.startModifyingTask(activity);
+            setTimeout(() => {
+                /*if (this.modifyTaskForm) {
+                    this.modifyTaskForm.handleRegisterWork();
+                }*/
+            });
+        });
+    }
+    _createClone() {
+        this.editActivity = this._boFactory.makeWithRawBackendData(Activity, this.currentActivity);
+    }
+    doHandleStatusChange(editting) {
+        this.taskEditting = editting;
+    }
+    updateEditActivity(activity) {
+        this.editActivity = this._boFactory.makeWithRawBackendData(Activity, activity);
+    }
+}
+TaskModifierComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-task-modifier",
+                template: `
+        <co-dialog  *ngIf="showForm"
+                    (closeClick)="onPopupClose()"
+                    class="task-popup"
+                    cssId="task_modifier_popup"
+                    noClickOutside contentSize>
+<!--
+          [header]="header"
+          [subHeader]="subHeader"
+          [subHeaderLink]="subHeaderLink"
+          [subSubHeader]="subSubHeader"
+          [headerIcon]="icons.Task"
+          (openLink)="openReferenceInModule()"-->
+      <!--      <ng-template>-->
+                <div class="popup-wrapper"
+                     [ngClass]="(showNewForm) ? 'new-task-popup' : ''">
+                    <div class="form-wrapper mini-scrollbar">
+                        <co-form #mainForm (validSubmit)="onValid()">
+<!--
+                            <new-task-form *ngIf="showNewForm" [activity]="editActivity" [myCfgNames]="taskCfgNames" [taskKey]="referenceId" [taskWorkflowCategory]="workflowCategory"></new-task-form>
+-->
+                            <co-modify-task-form #modifyTaskForm *ngIf="showModificationForm"
+                                              [activity]="editActivity"
+                                              [readonly]="readonly"
+                                              [popupContext]="true"
+                                              (statusChange)="doHandleStatusChange($event)"
+                                              (showWorkLog)="showWorkLog.emit()"
+                                              (activityChange)="updateEditActivity($event)"
+                            ></co-modify-task-form>
+                        </co-form>
+                    </div>
+                </div>
+                <div class="popup-buttons" fxLayout="column">
+                    <div *ngIf="showNewForm" fxLayout="row" class="popup-thumb">
+                        <span [textContent]="'SHOW_AFTER_INSERT' | localize"></span>
+               <!--         <thumb [(active)]=showAfterInsert"></thumb>-->
+                    </div>
+                    <div class="ok-cancel-buttons">
+                      <div class="button-left">
+                        <co-button [disabled]="readonly || taskEditting" [textContent]="'SAVE' | localize" (click)="handleSaveForm()"></co-button>
+                      </div>
+                      <div class="button-middle">
+                        <co-button *ngIf="showNewForm" [textContent]="'CANCEL' | localize" (click)="handleCancelForm()"></co-button>
+                      </div>
+                      <div class="button-right">
+                      <co-button *ngIf="showModificationForm && !readonly"
+                                     [iconData]="iconService.getIcon(icons.Trashbin)" class="delete light"
+                                     [disabled]="readonly || taskEditting"
+                                     (click)="deleteTask()"></co-button>
+                      </div>
+                    </div>
+                </div>
+           <!-- </ng-template>-->
+        </co-dialog>
+    `
+            },] }
+];
+TaskModifierComponent.ctorParameters = () => [
+    { type: CoreDialogService },
+    { type: BusinessObjectFactory },
+    { type: DictionaryService },
+    { type: IconCacheService }
+];
+TaskModifierComponent.propDecorators = {
+    mainForm: [{ type: ViewChild, args: [FormComponent,] }],
+    modifyTaskForm: [{ type: ViewChild, args: [forwardRef(() => ModifyTaskFormComponent),] }],
+    workflowCategory: [{ type: Input }],
+    reference: [{ type: Input }],
+    referenceId: [{ type: Input }],
+    userGroupId: [{ type: Input }],
+    relationId: [{ type: Input }],
+    upsertActivityOperation: [{ type: Input }],
+    deleteActivityOperation: [{ type: Input }],
+    tryLockTaskOperation: [{ type: Input }],
+    createTaskOperation: [{ type: Input }],
+    forceReadonly: [{ type: Input }],
+    editingComplete: [{ type: Output }],
+    activitySaved: [{ type: Output }],
+    activityDeleted: [{ type: Output }],
+    closedWithoutComplete: [{ type: Output }],
+    showWorkLog: [{ type: Output }],
+    taskCreated: [{ type: Output }],
+    taskModified: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-task-modifier",] }]
+};
+__decorate([
+    InputBoolean()
+], TaskModifierComponent.prototype, "forceReadonly", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-modifier.component.js","sourceRoot":"","sources":["../../../../../../projects/sharedcomponents/src/lib/components/task-modifyer/task-modifier.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, forwardRef, HostBinding, Input, OnDestroy, Output, ViewChild} from \"@angular/core\";\r\nimport {\r\n  CoreDialogService,\r\n  DialogResponseInterface,\r\n  FormComponent\r\n} from \"@colijnit/corecomponents_v12\";\r\nimport {Activity} from \"@colijnit/mainapi/build/model/activity.bo\";\r\nimport {InputBoolean} from \"../../decorator/input-boolean.decorator\";\r\nimport {WorkflowCategoryType} from \"@colijnit/mainapi/build/enum/workflow-category.enum\";\r\nimport {Icon} from \"../../enum/icon.enum\";\r\nimport {DictionaryService} from \"../../service/dictionary.service\";\r\nimport {BusinessObjectFactory} from \"@colijnit/ioneconnector/build/service/business-object-factory\";\r\nimport {OperationCallbackSimpleFunction} from \"../../interface/operation-callback-simple-function\";\r\nimport {Task} from \"@colijnit/mainapi/build/model/task.bo\";\r\nimport {OperationCallbackActivity} from \"../../interface/operation-callback-activity\";\r\nimport {IconCacheService} from \"../../service/icon-cache.service\";\r\nimport {AppPopupButtonType} from \"../../enum/app-button-type.enum\";\r\nimport {ModifyTaskFormComponent} from \"../modify-task-form/modify-task-form.component\";\r\n\r\n\r\n@Component({\r\n    selector: \"co-task-modifier\",\r\n    template: `\r\n        <co-dialog  *ngIf=\"showForm\"\r\n                    (closeClick)=\"onPopupClose()\"\r\n                    class=\"task-popup\"\r\n                    cssId=\"task_modifier_popup\"\r\n                    noClickOutside contentSize>\r\n<!--\r\n          [header]=\"header\"\r\n          [subHeader]=\"subHeader\"\r\n          [subHeaderLink]=\"subHeaderLink\"\r\n          [subSubHeader]=\"subSubHeader\"\r\n          [headerIcon]=\"icons.Task\"\r\n          (openLink)=\"openReferenceInModule()\"-->\r\n      <!--      <ng-template>-->\r\n                <div class=\"popup-wrapper\"\r\n                     [ngClass]=\"(showNewForm) ? 'new-task-popup' : ''\">\r\n                    <div class=\"form-wrapper mini-scrollbar\">\r\n                        <co-form #mainForm (validSubmit)=\"onValid()\">\r\n<!--\r\n                            <new-task-form *ngIf=\"showNewForm\" [activity]=\"editActivity\" [myCfgNames]=\"taskCfgNames\" [taskKey]=\"referenceId\" [taskWorkflowCategory]=\"workflowCategory\"></new-task-form>\r\n-->\r\n                            <co-modify-task-form #modifyTaskForm *ngIf=\"showModificationForm\"\r\n                                              [activity]=\"editActivity\"\r\n                                              [readonly]=\"readonly\"\r\n                                              [popupContext]=\"true\"\r\n                                              (statusChange)=\"doHandleStatusChange($event)\"\r\n                                              (showWorkLog)=\"showWorkLog.emit()\"\r\n                                              (activityChange)=\"updateEditActivity($event)\"\r\n                            ></co-modify-task-form>\r\n                        </co-form>\r\n                    </div>\r\n                </div>\r\n                <div class=\"popup-buttons\" fxLayout=\"column\">\r\n                    <div *ngIf=\"showNewForm\" fxLayout=\"row\" class=\"popup-thumb\">\r\n                        <span [textContent]=\"'SHOW_AFTER_INSERT' | localize\"></span>\r\n               <!--         <thumb [(active)]=showAfterInsert\"></thumb>-->\r\n                    </div>\r\n                    <div class=\"ok-cancel-buttons\">\r\n                      <div class=\"button-left\">\r\n                        <co-button [disabled]=\"readonly || taskEditting\" [textContent]=\"'SAVE' | localize\" (click)=\"handleSaveForm()\"></co-button>\r\n                      </div>\r\n                      <div class=\"button-middle\">\r\n                        <co-button *ngIf=\"showNewForm\" [textContent]=\"'CANCEL' | localize\" (click)=\"handleCancelForm()\"></co-button>\r\n                      </div>\r\n                      <div class=\"button-right\">\r\n                      <co-button *ngIf=\"showModificationForm && !readonly\"\r\n                                     [iconData]=\"iconService.getIcon(icons.Trashbin)\" class=\"delete light\"\r\n                                     [disabled]=\"readonly || taskEditting\"\r\n                                     (click)=\"deleteTask()\"></co-button>\r\n                      </div>\r\n                    </div>\r\n                </div>\r\n           <!-- </ng-template>-->\r\n        </co-dialog>\r\n    `,\r\n})\r\nexport class TaskModifierComponent implements OnDestroy {\r\n    public readonly icons: typeof Icon = Icon;\r\n\r\n    @ViewChild(FormComponent)\r\n    public mainForm: FormComponent;\r\n\r\n    @ViewChild(forwardRef(() => ModifyTaskFormComponent))\r\n    public modifyTaskForm: ModifyTaskFormComponent;\r\n\r\n    public get readonly(): boolean {\r\n        //return this.moduleService.readonly &&\r\n      return false;\r\n    }\r\n\r\n/*    @Input()\r\n    public taskCfgNames: ActivitiesTaskConfigNames;*/\r\n\r\n    @Input()\r\n    public workflowCategory: WorkflowCategoryType;\r\n\r\n    @Input()\r\n    public reference: string;\r\n\r\n    @Input()\r\n    public referenceId: string;\r\n\r\n    @Input()\r\n    public userGroupId: number;\r\n\r\n    @Input()\r\n    public relationId: number;\r\n\r\n    @Input()\r\n    public upsertActivityOperation: OperationCallbackSimpleFunction;\r\n\r\n    @Input()\r\n    public deleteActivityOperation: OperationCallbackSimpleFunction;\r\n\r\n    @Input()\r\n    public tryLockTaskOperation: OperationCallbackSimpleFunction;\r\n\r\n    @Input()\r\n    public createTaskOperation: OperationCallbackActivity;\r\n\r\n    @Input()\r\n    @InputBoolean()\r\n    public forceReadonly: boolean;\r\n\r\n    @Output()\r\n    public readonly editingComplete: EventEmitter<Activity> = new EventEmitter<Activity>();\r\n\r\n    @Output()\r\n    public readonly activitySaved: EventEmitter<Activity> = new EventEmitter<Activity>();\r\n\r\n    @Output()\r\n    public readonly activityDeleted: EventEmitter<Activity> = new EventEmitter<Activity>();\r\n\r\n    @Output()\r\n    public readonly closedWithoutComplete: EventEmitter<boolean> = new EventEmitter<boolean>();\r\n\r\n    @Output()\r\n    public readonly showWorkLog: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n    @Output()\r\n    public readonly taskCreated: EventEmitter<Task> = new EventEmitter<Task>();\r\n\r\n    @Output()\r\n    public readonly taskModified: EventEmitter<Task> = new EventEmitter<Task>();\r\n\r\n  @HostBinding(\"class.co-task-modifier\")\r\n    public showClass() {\r\n      return true;\r\n    }\r\n\r\n    public get showForm(): boolean {\r\n        return this.showNewForm || this.showModificationForm;\r\n    }\r\n\r\n    public get header(): string {\r\n        return (this.showModificationForm) ? \"TASK\" : \"ADD_TASK2\";\r\n    }\r\n\r\n    public get subHeader(): string {\r\n        return this.currentActivity ? this.currentActivity.task.taskId + \"\" : \"\";\r\n    }\r\n\r\n    public get subSubHeader(): string {\r\n        if (this.currentActivity?.task?.lastModifiedBy && this.currentActivity?.task?.lastModifiedDate) {\r\n            const label = this._dictionary.get('LAST_CHANGE');\r\n            const lastModifiedBy: string = this.currentActivity.task?.lastModifiedDisplayName;\r\n            const lastModifiedDate: string = this.currentActivity.task?.lastModifiedDate.toLocaleString();\r\n\r\n            return label + ': ' + lastModifiedBy + ' | ' + lastModifiedDate;\r\n        }\r\n        return \"\";\r\n    }\r\n\r\n    public get subHeaderLink(): string {\r\n        if (this.showModificationForm && this.currentActivity && this.currentActivity.task) {\r\n            if (this.currentActivity.task.workflowCategory && this.currentActivity.task.reference) {\r\n                let activityName: string;\r\n                activityName = this._dictionary.get(\"WORKFLOW_CATEGORY_\" + this.currentActivity.task.workflowCategory) + \" \" + this.currentActivity.task.reference + \")\";\r\n                return activityName;\r\n            }\r\n        }\r\n        return \"\";\r\n    }\r\n\r\n    public get userIsTaskReporter(): boolean {\r\n        return this.editActivity &&\r\n            ((this.editActivity.task.reporterUserGroupId && this.editActivity.task.reporterUserGroupId === this.userGroupId) ||\r\n                (this.editActivity.task.reporter && this.editActivity.task.reporter.relationId === this.relationId));\r\n    }\r\n\r\n    public showAfterInsert: boolean = false;\r\n    public showNewForm: boolean = false;\r\n    public showModificationForm: boolean = false;\r\n    public currentActivity: Activity;\r\n    public editActivity: Activity;\r\n\r\n    public taskEditting: boolean = false;\r\n\r\n    constructor(\r\n        private _dialogService: CoreDialogService,\r\n        private _boFactory: BusinessObjectFactory,\r\n        private readonly _dictionary: DictionaryService,\r\n        public iconService: IconCacheService,\r\n    ) {\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n    }\r\n\r\n    public handleSaveForm(): void {\r\n        this.mainForm.submit();\r\n    }\r\n\r\n    public async onValid(): Promise<void> {\r\n        if (this.editActivity) {\r\n            const newActivity: boolean = this.editActivity.isNew;\r\n            const result = await this.upsertActivityOperation(this.editActivity);\r\n            if (result)\r\n            {\r\n                this.activitySaved.next(this.editActivity);\r\n                this.editingComplete.next(this.editActivity);\r\n                if (newActivity) {\r\n                    this.taskCreated.next(this.editActivity.task)\r\n                } else {\r\n                    this.taskModified.next(this.editActivity.task);\r\n                }\r\n                if (this.showAfterInsert) {\r\n                    this.startModifyingTask(this.editActivity);\r\n                }\r\n\r\n            }\r\n            this.hide();\r\n        }\r\n    }\r\n\r\n    public handleCancelForm(): void {\r\n        this._createClone();\r\n        //TODO: is this needed?\r\n        //this.moduleService.cancelEdit();\r\n        this.closedWithoutComplete.next(true);\r\n        this.hide();\r\n    }\r\n\r\n    public onPopupClose(): void {\r\n        this.forceReadonly = false;\r\n        this.hide();\r\n        this.closedWithoutComplete.next(true);\r\n    }\r\n\r\n    //TODO figure out routing from external component\r\n    /*public openReferenceInModule(): void {\r\n        if (this.currentActivity && this.currentActivity.task) {\r\n            if (this.currentActivity.task.workflowCategory === WorkflowCategoryType.AbsenceFile || this.currentActivity.task.workflowCategory === WorkflowCategoryType.PreventiveAbsenceFile) {\r\n                this._appNavigator.navigateToIOneModule(IOneModuleName.AbsenceFile, this.currentActivity.task.referenceId);\r\n            }\r\n        }\r\n\r\n    }*/\r\n\r\n    public hide(): void {\r\n        this.showNewForm = false;\r\n        this.showModificationForm = false;\r\n    }\r\n\r\n    public async deleteTask(): Promise<void> {\r\n        const doDelete: DialogResponseInterface = await this._dialogService.showYesNo(\"DELETE_TASK\",\"DELETE_TASK\",false);\r\n        if (doDelete.button === AppPopupButtonType.Yes) {\r\n            await this.deleteActivityOperation(this.editActivity);\r\n            this.activityDeleted.next(this.editActivity);\r\n            this.hide();\r\n        }\r\n    }\r\n\r\n    public async createNewTask(standalone: boolean = true): Promise<void> {\r\n        if (this.showForm) {\r\n            return;\r\n        }\r\n\r\n        this.showAfterInsert = false;\r\n        this.currentActivity = await this.createTaskOperation({standalone: standalone, workflowCategory: this.workflowCategory, reference: this.reference, referenceId: this.referenceId});\r\n        this._createClone();\r\n        this.showNewForm = true;\r\n    }\r\n\r\n    public async startModifyingTask(activity: Activity): Promise<void> {\r\n        if (this.showForm || !activity.IsTask) {\r\n            return;\r\n        }\r\n\r\n        this.showAfterInsert = false;\r\n        await this.tryLockTaskOperation(activity.task.taskId);\r\n        activity.task = activity.task;\r\n        this.currentActivity = activity;\r\n        this._createClone();\r\n        this.showModificationForm = true;\r\n    }\r\n\r\n    public async startModifyingTaskAndWorkLog(activity: Activity): Promise<void> {\r\n        await this.startModifyingTask(activity);\r\n        setTimeout(() => {\r\n            /*if (this.modifyTaskForm) {\r\n                this.modifyTaskForm.handleRegisterWork();\r\n            }*/\r\n        });\r\n    }\r\n\r\n    public _createClone(): void {\r\n        this.editActivity = this._boFactory.makeWithRawBackendData(Activity, this.currentActivity)as Activity;\r\n    }\r\n\r\n    public doHandleStatusChange(editting: boolean): void {\r\n        this.taskEditting = editting;\r\n    }\r\n\r\n    public updateEditActivity(activity: Activity): void {\r\n        this.editActivity = this._boFactory.makeWithRawBackendData(Activity, activity) as Activity;\r\n    }\r\n\r\n  protected readonly Icon = Icon;\r\n}\r\n"]}

package/esm2015/lib/components/task-modifyer/task-modifyer.module..js

@@ -0,0 +1,31 @@
+import { NgModule } from "@angular/core";
+import { TaskModifierComponent } from "./task-modifier.component";
+import { ButtonModule, CoDialogModule, FormModule } from "@colijnit/corecomponents_v12";
+import { LocalizationModule } from "../../localization/localization.module";
+import { CommonModule } from "@angular/common";
+import { ModifyTaskFormModule } from "../modify-task-form/modify-task-form.module";
+import { BusinessObjectFactory } from "@colijnit/ioneconnector/build/service/business-object-factory";
+export class TaskModifyerModule {
+}
+TaskModifyerModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    FormModule,
+                    CoDialogModule,
+                    LocalizationModule,
+                    CommonModule,
+                    ButtonModule,
+                    ModifyTaskFormModule
+                ],
+                declarations: [
+                    TaskModifierComponent
+                ],
+                exports: [
+                    TaskModifierComponent
+                ],
+                providers: [
+                    BusinessObjectFactory
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/workflow-notification-toggle/workflow-notification-toggle-popup.js

@@ -0,0 +1,53 @@
+import { Component, ElementRef, EventEmitter, Input, Output } from "@angular/core";
+import { IconCacheService } from "../../service/icon-cache.service";
+import { Icon } from "../../enum/icon.enum";
+export class WorkflowNotificationTogglePopupComponent {
+    constructor(element, iconService) {
+        this.element = element;
+        this.iconService = iconService;
+        this.icons = Icon;
+        this.workflowProcesses = [];
+        this.closePopupClicked = new EventEmitter();
+        this.workflowProcessClicked = new EventEmitter();
+    }
+    ngOnDestroy() {
+        this.element = undefined;
+    }
+}
+WorkflowNotificationTogglePopupComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-workflow-notification-toggle-popup",
+                template: `
+    <div class="workflow-list-wrapper" [overlay]="parentForOverlay"
+         [alignWith]="element"
+         [alignTopOffsetPx]="35"
+         [class.showing]="true"
+         [enableAlign]="true"
+         [clickOutside]="true"
+         (clickOutside)="closePopupClicked.emit()"
+         keepInView noWidthAlign alignRight>
+      <div class="workflow-row" *ngFor="let workflow of workflowProcesses"
+           (click)="workflowProcessClicked.emit(workflow)">
+        <div class="icon-wrapper">
+          <co-icon class="workflow-icon"
+                   [iconData]="iconService.getIcon(workflow.hasPausedNotifications ? icons.BellSlashRegular : icons.BellRegular)"
+                   [class.small-icon]="!workflow.hasPausedNotifications"></co-icon>
+        </div>
+        <div class="workflow-text">
+          <span class="workflow-title" [textContent]="workflow.workflowName"></span>
+        </div>
+      </div>
+    </div>`
+            },] }
+];
+WorkflowNotificationTogglePopupComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: IconCacheService }
+];
+WorkflowNotificationTogglePopupComponent.propDecorators = {
+    workflowProcesses: [{ type: Input }],
+    parentForOverlay: [{ type: Input }],
+    closePopupClicked: [{ type: Output }],
+    workflowProcessClicked: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/workflow-notification-toggle/workflow-notification-toggle.component.js

@@ -0,0 +1,81 @@
+import { __awaiter } from "tslib";
+import { Component, ElementRef, HostBinding, Input } from "@angular/core";
+import { Icon } from "../../enum/icon.enum";
+import { IconCacheService } from "../../service/icon-cache.service";
+import { SharedService } from "../../service/shared.service";
+import { TableName } from "@colijnit/mainapi/build/enum/table-name.enum";
+import { OverlayService } from "@colijnit/corecomponents_v12";
+import { WorkflowNotificationTogglePopupComponent } from "./workflow-notification-toggle-popup";
+export class WorkflowNotificationToggleComponent {
+    constructor(element, iconService, sharedService, _overlayService) {
+        this.element = element;
+        this.iconService = iconService;
+        this.sharedService = sharedService;
+        this._overlayService = _overlayService;
+        this.icons = Icon;
+        this.workflowProcesses = [];
+        this.showPopup = false;
+    }
+    showClass() {
+        return true;
+    }
+    ngOnInit() {
+        this._loadWorkflowProcesses();
+    }
+    _loadWorkflowProcesses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.workflowProcesses = yield this.sharedService.getActiveProcessesByTableAndKey(TableName[this.table], this.key);
+        });
+    }
+    buttonClicked() {
+        if (!this.showPopup) {
+            this.openPopup();
+        }
+        else {
+            this.closePopup();
+        }
+    }
+    openPopup() {
+        this.showPopup = true;
+        this._workflowPopupRef = this._overlayService.createComponent(WorkflowNotificationTogglePopupComponent, { parentForOverlay: this.element, workflowProcesses: this.workflowProcesses }, {
+            closePopupClicked: () => this.closePopup(),
+            workflowProcessClicked: (WorkflowProcess) => this.handleWorkflowToggle(WorkflowProcess)
+        });
+    }
+    closePopup() {
+        this.showPopup = false;
+        this._overlayService.removeComponent(this._workflowPopupRef);
+    }
+    handleWorkflowToggle(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const valResult = yield this.setHasPausedNotificationsForWorkflowProcessOperation(workflow.workflowProcessId, !workflow.hasPausedNotifications, null);
+            if (valResult && valResult.success) {
+                workflow.hasPausedNotifications = !workflow.hasPausedNotifications;
+            }
+        });
+    }
+}
+WorkflowNotificationToggleComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-workflow-notification-toggle",
+                template: `
+    <co-button isToggleButton class="transparent-rectangular-action user-button" [isToggled]="showPopup"
+               (click)="buttonClicked()"
+               [iconData]="iconService.getIcon(icons.BellRegular)"
+               [title]="'SHOW_WORKFLOW_NOTIFICATION_SETTINGS' | localize"></co-button>
+  `
+            },] }
+];
+WorkflowNotificationToggleComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: IconCacheService },
+    { type: SharedService },
+    { type: OverlayService }
+];
+WorkflowNotificationToggleComponent.propDecorators = {
+    table: [{ type: Input }],
+    key: [{ type: Input }],
+    setHasPausedNotificationsForWorkflowProcessOperation: [{ type: Input }],
+    showClass: [{ type: HostBinding, args: ["class.co-workflow-notification-toggle",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/workflow-notification-toggle/workflow-notification-toggle.module.js

@@ -0,0 +1,34 @@
+import { NgModule } from "@angular/core";
+import { WorkflowNotificationToggleComponent } from "./workflow-notification-toggle.component";
+import { ButtonModule, ClickoutsideModule, IconModule, OverlayModule, OverlayService } from "@colijnit/corecomponents_v12";
+import { LocalizationModule } from "../../localization/localization.module";
+import { DirectivesModule } from "../../directives/directives.module";
+import { CommonModule } from "@angular/common";
+import { WorkflowNotificationTogglePopupComponent } from "./workflow-notification-toggle-popup";
+export class WorkflowNotificationToggleModule {
+}
+WorkflowNotificationToggleModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    ButtonModule,
+                    ClickoutsideModule,
+                    LocalizationModule,
+                    IconModule,
+                    DirectivesModule,
+                    CommonModule,
+                    OverlayModule
+                ],
+                declarations: [
+                    WorkflowNotificationToggleComponent,
+                    WorkflowNotificationTogglePopupComponent
+                ],
+                exports: [
+                    WorkflowNotificationToggleComponent,
+                    WorkflowNotificationTogglePopupComponent
+                ],
+                providers: [
+                    OverlayService
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/absolute-overlay-template.directive.js

@@ -0,0 +1,29 @@
+import { Directive, Input } from "@angular/core";
+import { AppAbsoluteOverlayOutletService } from "../service/app-absolute-overlay-outlet.service";
+// Directive applicable to <ng-template>'s of components. Places template content in the app's absolute overlay outlet.
+export class AbsoluteOverlayTemplateDirective {
+    constructor(_outletService) {
+        this._outletService = _outletService;
+    }
+    // spawn host template in absolute overlay outlet
+    ngOnInit() {
+        this._outletService.placeTemplateIntoOverlay(this.absoluteOverlayTemplate);
+    }
+    // de-spawn host template from absolute overlay outlet
+    ngOnDestroy() {
+        this._outletService.removeTemplateFromOverlay(this.absoluteOverlayTemplate);
+        this.absoluteOverlayTemplate = undefined;
+    }
+}
+AbsoluteOverlayTemplateDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[absoluteOverlayTemplate]"
+            },] }
+];
+AbsoluteOverlayTemplateDirective.ctorParameters = () => [
+    { type: AppAbsoluteOverlayOutletService }
+];
+AbsoluteOverlayTemplateDirective.propDecorators = {
+    absoluteOverlayTemplate: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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