@colijnit/sharedcomponents 1.0.69 → 254.1.1

package/esm2015/lib/components/activity-overview-component/component-activity-overview.component.js

@@ -0,0 +1,129 @@
+import { Component, HostBinding } from "@angular/core";
+import { CoreDialogService } from "@colijnit/corecomponents_v12";
+import { animate, state, style, transition, trigger } from "@angular/animations";
+import { BaseActivityOverviewComponent } from "./components/base-activity-overview.component";
+import { Icon } from "../../enum/icon.enum";
+import { IconCacheService } from "../../service/icon-cache.service";
+import { DictionaryService } from "../../service/dictionary.service";
+export class ComponentActivityOverviewComponent extends BaseActivityOverviewComponent {
+    constructor(iconCacheService, dialogService, dictionaryService) {
+        super(dialogService, dictionaryService);
+        this.iconCacheService = iconCacheService;
+        this.dialogService = dialogService;
+        this.dictionaryService = dictionaryService;
+        this.Icon = Icon;
+    }
+    showClass() {
+        return true;
+    }
+}
+ComponentActivityOverviewComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-component-activity-overview",
+                template: `
+        <div class="overview-wrapper">
+            <div class="overview-wrapper-icons">
+                <co-icon *ngIf="userIsSupervisor && (!isTask || firstTriggerToCloseWF === undefined)" icon="supervisor"
+                      class="supervisor-icon big dark"
+                      [title]="'MY_TASKS_SUPERVISOR' | localize"></co-icon>
+            </div>
+            <div class="overview-wrapper-labels">
+                <div class="activity-title" [textContent]="activityTitle"></div>
+                <div class="activity-context-title" [textContent]="activityContextTitle"></div>
+            </div>
+            <div class="overview-wrapper-date">
+                <div class="date-wrapper" [class.overdue]="overDue">
+                    <ng-container *ngIf="!sameDates">
+                        <div class="date" [textContent]="targetDate | date:'dd-MM-YYYY'"></div>
+                        <div class="date-divider" [textContent]="'-'"></div>
+                    </ng-container>
+                    <div class="date" [textContent]="deadlineDate | date:'dd-MM-YYYY'"></div>
+                </div>
+            </div>
+        </div>
+        <div class="overview-main">
+            <ng-container *ngIf="isTask && firstTriggerToCloseWF !== undefined">
+                <co-button class="trans-green custom-text button-trigger no-margin" [label]="firstTriggerToCloseWF.description"
+                               (click)="handleButtonEndClick()"></co-button>
+            </ng-container>
+            <ng-container *ngIf="openButtonLabel">
+                <co-button class="trans-green default-bg custom-text button-trigger-icon action-hover no-margin"
+                               iconClass="custom small" [iconData]="iconCacheService.getIcon(icon.DetailView)" [label]="openButtonLabel | localize"
+                               (click)="handleOpenLink($event)"></co-button>
+            </ng-container>
+            <!--TODO reinstate this when we figure out how to trigger a screen change. -->
+            <!--<ng-container *ngIf="urls && urls.length > 0">
+                <button-colijn *ngFor="let url of urls"
+                               class="trans-green custom-text button-trigger-icon action-hover no-margin"
+                               [icon]="icon.DetailView"
+                               [label]="'OPEN_LINK' | localize"
+                               iconClass="custom small"
+                               (click)="handleOpenLink($event, url)"></button-colijn>
+            </ng-container>-->
+            <ng-container *ngIf="!isTask && hasTriggers">
+                <co-button     class="trans-green custom-text action-hover button-trigger no-margin" *ngFor="let trigger of workFlow.manualGenericTriggers"
+                               [class.button-trigger-icon]="trigger.isTaskTrigger"
+                               [label]="trigger.triggerButtonName"
+                               [iconData]="trigger.isTaskTrigger ? iconCacheService.getIcon(icon.Account): null"
+                               iconClass="custom small"
+                               (click)="handleGenericTriggerClick(trigger)"
+                ></co-button>
+                <co-button     class="trans-green custom-text action-hover button-trigger no-margin" *ngFor="let trigger of workFlow.manualTriggers"
+                               [class.high-prio]="trigger.overDue"
+                               [class.button-trigger-icon]="trigger.isTaskTrigger"
+                               [label]="trigger.triggerButtonName"
+                               [iconData]="trigger.isTaskTrigger ? iconCacheService.getIcon(icon.DetailView): null"
+                               iconClass="custom small"
+                               (click)="handleTriggerClick(trigger)"
+                ></co-button >
+            </ng-container>
+        </div>
+        <!--TODO reinstate this when we figure out how to trigger a screen change. -->
+        <!-- <formbuilder-user-form *ngIf="showCreateForm"
+                                 [showPopup]="showCreateForm"
+                                 [table]="table"
+                                 [key]="key"
+                                 [form]="form"
+                                 (cancelForm)="doCancelForm()"
+                                 (saveForm)="doSaveForm($event)"
+        ></formbuilder-user-form>-->
+        <co-task-modifier
+                [userGroupId]="userGroupId"
+                [relationId]="userRelationId"
+                [tryLockTaskOperation]="lockTaskOperation"
+                [deleteActivityOperation]="deleteActivityOperation"
+                [upsertActivityOperation]="upsertActivityOperation"
+                (editingComplete)="onSaveActivity($event)"
+                (activityDeleted)="onDeleteActivity($event)"
+                (showWorkLog)="showTaskFormAndWorkLog()"
+        ></co-task-modifier>
+
+    `,
+                /*  providers: [
+                      {provide: BaseModuleScreenConfigService, useExisting: ScreenConfigurationMockService}
+                  ],*/
+                animations: [
+                    trigger("fadeInOut", [
+                        state("void", style({ opacity: 0 })),
+                        state("*", style({ opacity: 1 })),
+                        transition(":enter, :leave", animate("200ms ease-in-out")),
+                    ]),
+                    trigger("showHideExtended", [
+                        state("void", style({ "transform-origin": "top center", transform: "scaleY(0)" })),
+                        state("*", style({ "transform-origin": "top center", transform: "scaleY(1)" })),
+                        transition(":enter, :leave", [
+                            animate("200ms ease-in-out")
+                        ])
+                    ])
+                ]
+            },] }
+];
+ComponentActivityOverviewComponent.ctorParameters = () => [
+    { type: IconCacheService },
+    { type: CoreDialogService },
+    { type: DictionaryService }
+];
+ComponentActivityOverviewComponent.propDecorators = {
+    showClass: [{ type: HostBinding, args: ["class.co-component-activity-overview",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-activity-overview.component.js","sourceRoot":"","sources":["../../../../../../projects/sharedcomponents/src/lib/components/activity-overview-component/component-activity-overview.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AACrD,OAAO,EAAC,iBAAiB,EAAC,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAC,6BAA6B,EAAC,MAAM,+CAA+C,CAAC;AAC5F,OAAO,EAAC,IAAI,EAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAC,gBAAgB,EAAC,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAC,iBAAiB,EAAC,MAAM,kCAAkC,CAAC;AAsGnE,MAAM,OAAO,kCAAmC,SAAQ,6BAA6B;IAOnF,YAAmB,gBAAkC,EAClC,aAAgC,EAChC,iBAAoC;QAErD,KAAK,CAAC,aAAa,EAAE,iBAAiB,CAAa,CAAC;QAJnC,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,kBAAa,GAAb,aAAa,CAAmB;QAChC,sBAAiB,GAAjB,iBAAiB,CAAmB;QARvC,SAAI,GAAgB,IAAI,CAAC;IAWzC,CAAC;IARM,SAAS;QACd,OAAO,IAAI,CAAC;IACd,CAAC;;;YAzGF,SAAS,SAAC;gBACP,QAAQ,EAAE,gCAAgC;gBAC1C,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8ET;gBACH;;sBAEM;gBACJ,UAAU,EAAE;oBACR,OAAO,CAAC,WAAW,EAAE;wBACnB,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,EAAC,OAAO,EAAE,CAAC,EAAC,CAAC,CAAC;wBAClC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,EAAC,OAAO,EAAE,CAAC,EAAC,CAAC,CAAC;wBAC/B,UAAU,CAAC,gBAAgB,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;qBAC3D,CAAC;oBACF,OAAO,CAAC,kBAAkB,EAAE;wBACxB,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,EAAC,kBAAkB,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAC,CAAC,CAAC;wBAChF,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,EAAC,kBAAkB,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAC,CAAC,CAAC;wBAC7E,UAAU,CAAC,gBAAgB,EAAE;4BACzB,OAAO,CAAC,mBAAmB,CAAC;yBAC/B,CAAC;qBACL,CAAC;iBACL;aACJ;;;YAtGO,gBAAgB;YAJhB,iBAAiB;YAKjB,iBAAiB;;;wBAyGtB,WAAW,SAAC,sCAAsC","sourcesContent":["import {Component, HostBinding} from \"@angular/core\";\r\nimport {CoreDialogService} from \"@colijnit/corecomponents_v12\";\r\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\r\nimport {BaseActivityOverviewComponent} from \"./components/base-activity-overview.component\";\r\nimport {Icon} from \"../../enum/icon.enum\";\r\nimport {IconCacheService} from \"../../service/icon-cache.service\";\r\nimport {DictionaryService} from \"../../service/dictionary.service\";\r\n\r\n\r\n@Component({\r\n    selector: \"co-component-activity-overview\",\r\n    template: `\r\n        <div class=\"overview-wrapper\">\r\n            <div class=\"overview-wrapper-icons\">\r\n                <co-icon *ngIf=\"userIsSupervisor && (!isTask || firstTriggerToCloseWF === undefined)\" icon=\"supervisor\"\r\n                      class=\"supervisor-icon big dark\"\r\n                      [title]=\"'MY_TASKS_SUPERVISOR' | localize\"></co-icon>\r\n            </div>\r\n            <div class=\"overview-wrapper-labels\">\r\n                <div class=\"activity-title\" [textContent]=\"activityTitle\"></div>\r\n                <div class=\"activity-context-title\" [textContent]=\"activityContextTitle\"></div>\r\n            </div>\r\n            <div class=\"overview-wrapper-date\">\r\n                <div class=\"date-wrapper\" [class.overdue]=\"overDue\">\r\n                    <ng-container *ngIf=\"!sameDates\">\r\n                        <div class=\"date\" [textContent]=\"targetDate | date:'dd-MM-YYYY'\"></div>\r\n                        <div class=\"date-divider\" [textContent]=\"'-'\"></div>\r\n                    </ng-container>\r\n                    <div class=\"date\" [textContent]=\"deadlineDate | date:'dd-MM-YYYY'\"></div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        <div class=\"overview-main\">\r\n            <ng-container *ngIf=\"isTask && firstTriggerToCloseWF !== undefined\">\r\n                <co-button class=\"trans-green custom-text button-trigger no-margin\" [label]=\"firstTriggerToCloseWF.description\"\r\n                               (click)=\"handleButtonEndClick()\"></co-button>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"openButtonLabel\">\r\n                <co-button class=\"trans-green default-bg custom-text button-trigger-icon action-hover no-margin\"\r\n                               iconClass=\"custom small\" [iconData]=\"iconCacheService.getIcon(icon.DetailView)\" [label]=\"openButtonLabel | localize\"\r\n                               (click)=\"handleOpenLink($event)\"></co-button>\r\n            </ng-container>\r\n            <!--TODO reinstate this when we figure out how to trigger a screen change. -->\r\n            <!--<ng-container *ngIf=\"urls && urls.length > 0\">\r\n                <button-colijn *ngFor=\"let url of urls\"\r\n                               class=\"trans-green custom-text button-trigger-icon action-hover no-margin\"\r\n                               [icon]=\"icon.DetailView\"\r\n                               [label]=\"'OPEN_LINK' | localize\"\r\n                               iconClass=\"custom small\"\r\n                               (click)=\"handleOpenLink($event, url)\"></button-colijn>\r\n            </ng-container>-->\r\n            <ng-container *ngIf=\"!isTask && hasTriggers\">\r\n                <co-button     class=\"trans-green custom-text action-hover button-trigger no-margin\" *ngFor=\"let trigger of workFlow.manualGenericTriggers\"\r\n                               [class.button-trigger-icon]=\"trigger.isTaskTrigger\"\r\n                               [label]=\"trigger.triggerButtonName\"\r\n                               [iconData]=\"trigger.isTaskTrigger ? iconCacheService.getIcon(icon.Account): null\"\r\n                               iconClass=\"custom small\"\r\n                               (click)=\"handleGenericTriggerClick(trigger)\"\r\n                ></co-button>\r\n                <co-button     class=\"trans-green custom-text action-hover button-trigger no-margin\" *ngFor=\"let trigger of workFlow.manualTriggers\"\r\n                               [class.high-prio]=\"trigger.overDue\"\r\n                               [class.button-trigger-icon]=\"trigger.isTaskTrigger\"\r\n                               [label]=\"trigger.triggerButtonName\"\r\n                               [iconData]=\"trigger.isTaskTrigger ? iconCacheService.getIcon(icon.DetailView): null\"\r\n                               iconClass=\"custom small\"\r\n                               (click)=\"handleTriggerClick(trigger)\"\r\n                ></co-button >\r\n            </ng-container>\r\n        </div>\r\n        <!--TODO reinstate this when we figure out how to trigger a screen change. -->\r\n        <!-- <formbuilder-user-form *ngIf=\"showCreateForm\"\r\n                                 [showPopup]=\"showCreateForm\"\r\n                                 [table]=\"table\"\r\n                                 [key]=\"key\"\r\n                                 [form]=\"form\"\r\n                                 (cancelForm)=\"doCancelForm()\"\r\n                                 (saveForm)=\"doSaveForm($event)\"\r\n        ></formbuilder-user-form>-->\r\n        <co-task-modifier\r\n                [userGroupId]=\"userGroupId\"\r\n                [relationId]=\"userRelationId\"\r\n                [tryLockTaskOperation]=\"lockTaskOperation\"\r\n                [deleteActivityOperation]=\"deleteActivityOperation\"\r\n                [upsertActivityOperation]=\"upsertActivityOperation\"\r\n                (editingComplete)=\"onSaveActivity($event)\"\r\n                (activityDeleted)=\"onDeleteActivity($event)\"\r\n                (showWorkLog)=\"showTaskFormAndWorkLog()\"\r\n        ></co-task-modifier>\r\n\r\n    `,\r\n  /*  providers: [\r\n        {provide: BaseModuleScreenConfigService, useExisting: ScreenConfigurationMockService}\r\n    ],*/\r\n    animations: [\r\n        trigger(\"fadeInOut\", [\r\n          state(\"void\", style({opacity: 0})),\r\n          state(\"*\", style({opacity: 1})),\r\n          transition(\":enter, :leave\", animate(\"200ms ease-in-out\")),\r\n        ]),\r\n        trigger(\"showHideExtended\", [\r\n            state(\"void\", style({\"transform-origin\": \"top center\", transform: \"scaleY(0)\"})),\r\n            state(\"*\", style({\"transform-origin\": \"top center\", transform: \"scaleY(1)\"})),\r\n            transition(\":enter, :leave\", [\r\n                animate(\"200ms ease-in-out\")\r\n            ])\r\n        ])\r\n    ]\r\n})\r\nexport class ComponentActivityOverviewComponent extends BaseActivityOverviewComponent {\r\n  public readonly Icon: typeof Icon = Icon;\r\n\r\n  @HostBinding(\"class.co-component-activity-overview\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n  constructor(public iconCacheService: IconCacheService,\r\n              public dialogService: CoreDialogService,\r\n              public dictionaryService: DictionaryService,\r\n              /*public router: Router*/) {\r\n    super(dialogService, dictionaryService, /*router*/);\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/activity-overview-component/component-activity-overview.module.js

@@ -0,0 +1,26 @@
+import { NgModule } from "@angular/core";
+import { ComponentActivityOverviewComponent } from "./component-activity-overview.component";
+import { ButtonModule, IconModule } from "@colijnit/corecomponents_v12";
+import { CommonModule } from "@angular/common";
+import { LocalizationModule } from "../../localization/localization.module";
+import { TaskModifyerModule } from "../task-modifyer/task-modifyer.module.";
+export class ComponentActivityOverviewModule {
+}
+ComponentActivityOverviewModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    ButtonModule,
+                    CommonModule,
+                    LocalizationModule,
+                    IconModule,
+                    TaskModifyerModule
+                ],
+                declarations: [
+                    ComponentActivityOverviewComponent
+                ],
+                exports: [
+                    ComponentActivityOverviewComponent
+                ],
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LWFjdGl2aXR5LW92ZXJ2aWV3Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2FjdGl2aXR5LW92ZXJ2aWV3LWNvbXBvbmVudC9jb21wb25lbnQtYWN0aXZpdHktb3ZlcnZpZXcubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLGtDQUFrQyxFQUFDLE1BQU0seUNBQXlDLENBQUM7QUFDM0YsT0FBTyxFQUFDLFlBQVksRUFBRSxVQUFVLEVBQUMsTUFBTSw4QkFBOEIsQ0FBQztBQUN0RSxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sd0NBQXdDLENBQUM7QUFDMUUsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sd0NBQXdDLENBQUM7QUFpQjFFLE1BQU0sT0FBTywrQkFBK0I7OztZQWYzQyxRQUFRLFNBQUM7Z0JBQ1IsT0FBTyxFQUFFO29CQUNQLFlBQVk7b0JBQ1osWUFBWTtvQkFDWixrQkFBa0I7b0JBQ2xCLFVBQVU7b0JBQ1Ysa0JBQWtCO2lCQUNuQjtnQkFDRCxZQUFZLEVBQUU7b0JBQ1osa0NBQWtDO2lCQUNuQztnQkFDRCxPQUFPLEVBQUU7b0JBQ1Asa0NBQWtDO2lCQUNuQzthQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtDb21wb25lbnRBY3Rpdml0eU92ZXJ2aWV3Q29tcG9uZW50fSBmcm9tIFwiLi9jb21wb25lbnQtYWN0aXZpdHktb3ZlcnZpZXcuY29tcG9uZW50XCI7XHJcbmltcG9ydCB7QnV0dG9uTW9kdWxlLCBJY29uTW9kdWxlfSBmcm9tIFwiQGNvbGlqbml0L2NvcmVjb21wb25lbnRzX3YxMlwiO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQge0xvY2FsaXphdGlvbk1vZHVsZX0gZnJvbSBcIi4uLy4uL2xvY2FsaXphdGlvbi9sb2NhbGl6YXRpb24ubW9kdWxlXCI7XHJcbmltcG9ydCB7VGFza01vZGlmeWVyTW9kdWxlfSBmcm9tIFwiLi4vdGFzay1tb2RpZnllci90YXNrLW1vZGlmeWVyLm1vZHVsZS5cIjtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgaW1wb3J0czogW1xyXG4gICAgQnV0dG9uTW9kdWxlLFxyXG4gICAgQ29tbW9uTW9kdWxlLFxyXG4gICAgTG9jYWxpemF0aW9uTW9kdWxlLFxyXG4gICAgSWNvbk1vZHVsZSxcclxuICAgIFRhc2tNb2RpZnllck1vZHVsZVxyXG4gIF0sXHJcbiAgZGVjbGFyYXRpb25zOiBbXHJcbiAgICBDb21wb25lbnRBY3Rpdml0eU92ZXJ2aWV3Q29tcG9uZW50XHJcbiAgXSxcclxuICBleHBvcnRzOiBbXHJcbiAgICBDb21wb25lbnRBY3Rpdml0eU92ZXJ2aWV3Q29tcG9uZW50XHJcbiAgXSxcclxufSlcclxuZXhwb3J0IGNsYXNzIENvbXBvbmVudEFjdGl2aXR5T3ZlcnZpZXdNb2R1bGUge1xyXG5cclxufVxyXG4iXX0=

package/esm2015/lib/components/activity-overview-component/components/base-activity-overview.component.js

@@ -0,0 +1,284 @@
+import { __awaiter, __decorate } from "tslib";
+import { Directive, EventEmitter, Injectable, Input, Output, ViewChild } from "@angular/core";
+import { Activity } from "@colijnit/mainapi/build/model/activity.bo";
+import { ActivityType } from "@colijnit/mainapi/build/enum/activity-type";
+import { Task } from "@colijnit/mainapi/build/model/task.bo";
+import { isNill } from "@colijnit/ioneconnector/build/utils/function/is-nill.function";
+import { CoreDialogService } from "@colijnit/corecomponents_v12";
+import { Icon } from "../../../enum/icon.enum";
+import { ActivityCfgName } from "../../../enum/activity-cfg-name.enum";
+import { OperationWithAlwaysSuccessCallback } from "../../../interface/operation-callback-simple-function";
+import { OperationWithValidationCallback } from "../../../interface/operation-callback-function-with-validation";
+import { InputBoolean } from "../../../decorator/input-boolean.decorator";
+import { DictionaryService } from "../../../service/dictionary.service";
+import { DateUtils } from "../../../utils/date-utils";
+import { TaskModifierComponent } from "../../task-modifyer/task-modifier.component";
+export class BaseActivityOverviewComponent {
+    constructor(_dialogService, _dictionaryService) {
+        this._dialogService = _dialogService;
+        this._dictionaryService = _dictionaryService;
+        this.icon = Icon;
+        this.cfgNames = ActivityCfgName;
+        this.taskCfgNames = {
+            timeRegistrationMandatory: ActivityCfgName.TimeRegistrationMandatory,
+            deleteActivityTaskButton: ActivityCfgName.DeleteActivityTaskButton,
+            statusSummaryHeader: ActivityCfgName.StatusSummaryHeader,
+            creationSummaryHeader: ActivityCfgName.CreationSummaryHeader,
+            executiveSummaryHeader: ActivityCfgName.ExecutiveSummaryHeader,
+            planningSummaryHeader: ActivityCfgName.PlanningSummaryHeader,
+            attachmentsHeader: ActivityCfgName.AttachmentsHeader,
+            notificationsSummaryHeader: ActivityCfgName.NotificationsSummaryHeader,
+            tagsHeader: ActivityCfgName.TagsHeader,
+            taskInvoice: ActivityCfgName.TaskInvoice
+        };
+        this.canFireTriggerOperation = OperationWithAlwaysSuccessCallback;
+        this.prepareWorkflowOperation = OperationWithAlwaysSuccessCallback;
+        this.lockTaskOperation = OperationWithAlwaysSuccessCallback;
+        this.deleteActivityOperation = OperationWithAlwaysSuccessCallback;
+        this.upsertActivityOperation = OperationWithAlwaysSuccessCallback;
+        this.fireGenericTriggerOperation = OperationWithValidationCallback;
+        this.fireTriggerOperation = OperationWithValidationCallback;
+        this.handleOpenLinkSidebar = false;
+        this.activityChange = new EventEmitter();
+        this.activityDeleted = new EventEmitter();
+        this.triggerFired = new EventEmitter();
+        this.genericTriggerFired = new EventEmitter();
+        this.formCreated = new EventEmitter();
+        this.openLink = new EventEmitter();
+        this.linkClicked = new EventEmitter();
+        this.overDue = false;
+        this.userIsSupervisor = false;
+        this.urls = [];
+        this.isTask = false;
+        this.hasTriggers = false;
+        this.sameDates = false;
+        this._activity = new Activity();
+    }
+    set viewModel(value) {
+        this._viewModel = value;
+        this.overDue = value.overDue;
+        this.activity = value.activity;
+    }
+    set triggerToFireOnSave(value) {
+        this._triggerToFireOnSave = value;
+    }
+    get triggerToFireOnSave() {
+        return this._triggerToFireOnSave;
+    }
+    set activity(value) {
+        this._activity = value;
+        this._prepareData();
+    }
+    get activity() {
+        return this._activity;
+    }
+    handleButtonEndClick() {
+        this.handleTriggerClick(this.firstTriggerToCloseWF);
+    }
+    handleGenericTriggerClick(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.fireGenericTriggerOperation(this.workFlow.workflowProcessId, event.genericTransitionId, this.userRelationId);
+            if (result.success) {
+                this.genericTriggerFired.next(this.activity);
+            }
+            else {
+                const messages = [];
+                const len = result.messages.length;
+                for (let i = 0; i < len; i++) {
+                    messages.push(this._dictionaryService.get(result.messages[i].message.toUpperCase()));
+                }
+                this._dialogService.showError(messages.toString());
+            }
+        });
+    }
+    handleTriggerClick(eventTrigger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (eventTrigger.isTaskTrigger && eventTrigger.taskId) {
+                //prepare task on the activity object, so the task modifier can handle it
+                this.activity.task = new Task();
+                this.activity.activityType = ActivityType.Task;
+                this.activity.task.taskId = eventTrigger.taskId;
+                this.taskModifier.startModifyingTask(this.activity);
+            }
+            else if (eventTrigger.isFormTrigger) {
+                //TODO reinstate when we know what to do with the formbuilder
+                /*this.form = await this._formRepo.getForm(eventTrigger.formId);
+                this.table = this.workFlow.table;
+                this.key = this.workFlow.key;
+                this.showCreateForm = true;*/
+            }
+            else {
+                /*if (eventTrigger.toClosedState && !await this.canFireTriggerOperation({activity: this.activity, task: this.activity.task})) {
+                    await this.prepareWorkflowOperation({table: this.workFlow.table, key: this.workFlow.key});
+                    this.triggerToFireOnSave = eventTrigger;
+                    this.showTaskFormAndWorkLog();
+                    return;
+                }*/
+                const result = yield this.fireTriggerOperation(this.workFlow.workflowProcessId, this.workFlow.sequence, eventTrigger.triggerId);
+                if (result.success) {
+                    this.triggerFired.next(this.activity);
+                }
+                else {
+                    const messages = [];
+                    const len = result.messages.length;
+                    for (let i = 0; i < len; i++) {
+                        messages.push(this._dictionaryService.get(result.messages[i].message.toUpperCase()));
+                    }
+                    this._dialogService.showError(messages.toString());
+                }
+            }
+        });
+    }
+    handleOpenLink(event, url) {
+        this._stopEventPropagation(event);
+        if (url) { // breadCrumbs to url
+            this._openUrl(url);
+        }
+        else {
+            this.startModifyingTask();
+        }
+    }
+    handleOpenLinkOrUrl(event) {
+        this._stopEventPropagation(event);
+        if (this.link && this.link.module) {
+            this.linkClicked.next({ module: this.link.module, id: this.link.id });
+        }
+        else if (this.urls && this.urls.length) {
+            this._openUrl(this.urls[0]);
+        }
+        else {
+            this.startModifyingTask();
+        }
+    }
+    startModifyingTask() {
+        if (this.workFlow && this.workFlow.workFlowHasOneTaskTrigger) {
+            this.activity.task = new Task();
+            this.activity.activityType = ActivityType.Task;
+            this.activity.task.taskId = this.workFlow.taskIdFromTaskTrigger;
+        }
+        if (this.activity.task) {
+            if (this.handleOpenLinkSidebar === true) {
+                this.openLink.next(this.activity);
+            }
+            else {
+                this.taskModifier.startModifyingTask(this.activity);
+            }
+        }
+        // TODO: for now a message is shown.
+        else if (this.workFlow) {
+            this._dialogService.showInformation("Component: " + this.workFlow.component + " key: " + this.workFlow.displayKey);
+        }
+    }
+    showTaskFormAndWorkLog() {
+        if (this.activity.task) {
+            //TODO REINSTATE AFTER FIXING FORM
+            //this.taskModifier.startModifyingTaskAndWorkLog(this.activity);
+        }
+    }
+    onSaveActivity(activity) {
+        this.activity = activity;
+        this.activityChange.next(this.activity);
+    }
+    onDeleteActivity(activity) {
+        if (this.activity.getId() === activity.getId()) {
+            if (this._viewModel) {
+                this._viewModel.deleted = true;
+                this._viewModel.showing = false;
+                this._viewModel.refreshViewModel();
+            }
+            this.activityDeleted.emit(activity);
+        }
+    }
+    //TODO Reinstate once we know what to do with the formbuilder
+    /*public doCancelForm(): void {
+        this.showCreateForm = false;
+    }
+
+    public async doSaveForm(form: FormResponse): Promise<void> {
+        const result: ValidationResult = await this._formRepo.insertFormResponse(form);
+        if (result.success) {
+            this.formCreated.next();
+            this.showCreateForm = false;
+        }
+    }*/
+    _prepareData() {
+        this.workFlow = this._activity.workflow;
+        if (this.workFlow) {
+            this.workFlow.useSingleTaskTriggerAsTask = true;
+            this.urls = this.workFlow.urls;
+            this.hasTriggers = this.workFlow.hasTriggers;
+        }
+        this.activityName = this.activity.name;
+        this.link = this.activity.link;
+        this.linkDescription = this.activity.linkDescription;
+        this.targetDate = this.activity.targetDateTime;
+        this.deadlineDate = this.activity.deadlineDateTime;
+        this.openButtonLabel = this.activity.linkLabel;
+        this.activityTitle = this.activity.activityTitle;
+        this.activityContextTitle = this.activity.activityContextTitle;
+        this.isTask = this._activity.IsTask;
+        this.sameDates = DateUtils.IsSameDay(this.targetDate, this.deadlineDate);
+        this._setFirstTriggerToCloseWF();
+    }
+    _setFirstTriggerToCloseWF() {
+        if (isNill(this.workFlow) || isNill(this.workFlow.manualTriggers)) {
+            return;
+        }
+        this.firstTriggerToCloseWF = undefined;
+        const len = this.workFlow.manualTriggers.length;
+        for (let i = 0; i < len; i++) {
+            if (this.workFlow.manualTriggers[i].toClosedState) {
+                this.firstTriggerToCloseWF = this.workFlow.manualTriggers[i];
+                break;
+            }
+        }
+    }
+    _openUrl(url) {
+        const regEx = new RegExp(/(http)|(www.)/);
+        if (regEx.test(url)) {
+            window.open(url.indexOf("http") === -1 ? "http://" + url : url, "_blank");
+        }
+        else {
+            //this._router.navigateByUrl(url);
+        }
+    }
+    _stopEventPropagation(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        event.stopImmediatePropagation();
+    }
+}
+BaseActivityOverviewComponent.decorators = [
+    { type: Directive },
+    { type: Injectable }
+];
+BaseActivityOverviewComponent.ctorParameters = () => [
+    { type: CoreDialogService },
+    { type: DictionaryService }
+];
+BaseActivityOverviewComponent.propDecorators = {
+    taskModifier: [{ type: ViewChild, args: [TaskModifierComponent, { static: true },] }],
+    viewModel: [{ type: Input }],
+    triggerToFireOnSave: [{ type: Input }],
+    canFireTriggerOperation: [{ type: Input }],
+    prepareWorkflowOperation: [{ type: Input }],
+    lockTaskOperation: [{ type: Input }],
+    deleteActivityOperation: [{ type: Input }],
+    upsertActivityOperation: [{ type: Input }],
+    fireGenericTriggerOperation: [{ type: Input }],
+    fireTriggerOperation: [{ type: Input }],
+    userRelationId: [{ type: Input }],
+    userGroupId: [{ type: Input }],
+    handleOpenLinkSidebar: [{ type: Input }],
+    activityChange: [{ type: Output }],
+    activityDeleted: [{ type: Output }],
+    triggerFired: [{ type: Output }],
+    genericTriggerFired: [{ type: Output }],
+    formCreated: [{ type: Output }],
+    openLink: [{ type: Output }],
+    linkClicked: [{ type: Output }]
+};
+__decorate([
+    InputBoolean()
+], BaseActivityOverviewComponent.prototype, "handleOpenLinkSidebar", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-activity-overview.component.js","sourceRoot":"","sources":["../../../../../../../projects/sharedcomponents/src/lib/components/activity-overview-component/components/base-activity-overview.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, EventEmitter, Injectable, Input, Output, ViewChild} from \"@angular/core\";\r\nimport {Activity} from \"@colijnit/mainapi/build/model/activity.bo\";\r\nimport {Workflow} from \"@colijnit/mainapi/build/model/workflow.bo\";\r\nimport {WorkflowTrigger} from \"@colijnit/mainapi/build/model/workflow-trigger.bo\";\r\nimport {ModuleNavigationLink} from \"@colijnit/mainapi/build/enum/module-navigation-link\";\r\nimport {ActivityType} from \"@colijnit/mainapi/build/enum/activity-type\";\r\nimport {Task} from \"@colijnit/mainapi/build/model/task.bo\";\r\nimport {ValidationResult} from \"@colijnit/ioneconnector/build/model/validation-result\";\r\nimport {isNill} from \"@colijnit/ioneconnector/build/utils/function/is-nill.function\";\r\nimport {WorkflowGenericTransition} from \"@colijnit/mainapi/build/model/workflow-generic-transition.bo\";\r\nimport {ActivityViewModel} from \"@colijnit/mainapi/build/model/activity-view-model\";\r\nimport {CoreDialogService} from \"@colijnit/corecomponents_v12\";\r\nimport {Icon} from \"../../../enum/icon.enum\";\r\nimport {ActivityCfgName} from \"../../../enum/activity-cfg-name.enum\";\r\nimport {ActivitiesTaskConfigNames} from \"../../../interface/activities-task-config-names\";\r\nimport {\r\n  OperationCallbackSimpleFunction,\r\n  OperationWithAlwaysSuccessCallback\r\n} from \"../../../interface/operation-callback-simple-function\";\r\n\r\nimport {\r\n  OperationCallbackFunctionWithValidation,\r\n  OperationWithValidationCallback\r\n} from \"../../../interface/operation-callback-function-with-validation\";\r\nimport {InputBoolean} from \"../../../decorator/input-boolean.decorator\";\r\nimport {DictionaryService} from \"../../../service/dictionary.service\";\r\nimport {DateUtils} from \"../../../utils/date-utils\";\r\nimport {TaskModifierComponent} from \"../../task-modifyer/task-modifier.component\";\r\n\r\n\r\n\r\n@Directive()\r\n@Injectable()\r\nexport abstract class BaseActivityOverviewComponent {\r\n    public readonly icon: typeof Icon = Icon;\r\n\r\n    public readonly cfgNames: typeof ActivityCfgName = ActivityCfgName;\r\n\r\n    public readonly taskCfgNames: ActivitiesTaskConfigNames = {\r\n        timeRegistrationMandatory: ActivityCfgName.TimeRegistrationMandatory,\r\n        deleteActivityTaskButton: ActivityCfgName.DeleteActivityTaskButton,\r\n        statusSummaryHeader: ActivityCfgName.StatusSummaryHeader,\r\n        creationSummaryHeader: ActivityCfgName.CreationSummaryHeader,\r\n        executiveSummaryHeader: ActivityCfgName.ExecutiveSummaryHeader,\r\n        planningSummaryHeader: ActivityCfgName.PlanningSummaryHeader,\r\n        attachmentsHeader: ActivityCfgName.AttachmentsHeader,\r\n        notificationsSummaryHeader: ActivityCfgName.NotificationsSummaryHeader,\r\n        tagsHeader: ActivityCfgName.TagsHeader,\r\n        taskInvoice: ActivityCfgName.TaskInvoice\r\n    };\r\n\r\n    @ViewChild(TaskModifierComponent, {static: true})\r\n    public taskModifier: TaskModifierComponent;\r\n\r\n    @Input()\r\n    public set viewModel(value: ActivityViewModel) {\r\n        this._viewModel = value;\r\n        this.overDue = value.overDue;\r\n        this.activity = value.activity;\r\n    }\r\n\r\n    @Input()\r\n    public set triggerToFireOnSave(value: WorkflowTrigger) {\r\n      this._triggerToFireOnSave = value;\r\n    }\r\n\r\n    public get triggerToFireOnSave() {\r\n      return this._triggerToFireOnSave;\r\n    }\r\n\r\n    @Input()\r\n    public canFireTriggerOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\r\n\r\n    @Input()\r\n    public prepareWorkflowOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\r\n\r\n    @Input()\r\n    public lockTaskOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\r\n\r\n    @Input()\r\n    public deleteActivityOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\r\n\r\n    @Input()\r\n    public upsertActivityOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\r\n\r\n    @Input()\r\n    public fireGenericTriggerOperation: OperationCallbackFunctionWithValidation = OperationWithValidationCallback;\r\n\r\n    @Input()\r\n    public fireTriggerOperation: OperationCallbackFunctionWithValidation = OperationWithValidationCallback;\r\n\r\n    @Input()\r\n    public userRelationId: number;\r\n\r\n    @Input()\r\n    public userGroupId: number;\r\n\r\n    @Input()\r\n    @InputBoolean()\r\n    public handleOpenLinkSidebar: boolean = false;\r\n\r\n    @Output()\r\n    public activityChange: 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 triggerFired: EventEmitter<Activity> = new EventEmitter<Activity>();\r\n\r\n    @Output()\r\n    public genericTriggerFired: EventEmitter<Activity> = new EventEmitter<Activity>();\r\n\r\n    @Output()\r\n    public formCreated: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n    @Output()\r\n    public openLink: EventEmitter<Activity> = new EventEmitter<Activity>();\r\n\r\n    @Output()\r\n    public linkClicked: EventEmitter<{module: string, id: string}> = new EventEmitter<{module: string, id: string}>();\r\n\r\n    public set activity(value: Activity) {\r\n        this._activity = value;\r\n        this._prepareData();\r\n    }\r\n\r\n    public get activity(): Activity {\r\n        return this._activity;\r\n    }\r\n\r\n    public workFlow: Workflow;\r\n    public targetDate: Date;\r\n    public deadlineDate: Date;\r\n    public activityName: string;\r\n    public activityDescription: string;\r\n    public activityTitle: string;\r\n    public activityContextTitle: string;\r\n\r\n    public openButtonLabel: string;\r\n    public overDue: boolean = false;\r\n    public userIsSupervisor: boolean = false;\r\n    //TODO Reinstate once we know what to do with the formbuilder\r\n    //public showCreateForm: boolean = false;\r\n    //public form: FormFullObject = NULL_FORM_FULL_OBJECT;\r\n    public table: string;\r\n    public key: string;\r\n    public urls: string[] = [];\r\n    public firstTriggerToCloseWF: WorkflowTrigger;\r\n    public isTask: boolean = false;\r\n    public hasTriggers: boolean = false;\r\n\r\n    public link: ModuleNavigationLink;\r\n    public linkDescription: string;\r\n    public sameDates: boolean = false;\r\n\r\n    private _activity: Activity = new Activity();\r\n    private _viewModel: ActivityViewModel;\r\n    private _triggerToFireOnSave: WorkflowTrigger;\r\n\r\n\r\n  constructor(private _dialogService: CoreDialogService,\r\n              private _dictionaryService: DictionaryService,\r\n              //TODO reinstate when formbuilder is transferred\r\n              //private _formRepo: FormDalRepository,\r\n              /*private _router: Router*/\r\n    ) {\r\n    }\r\n\r\n    public handleButtonEndClick(): void {\r\n        this.handleTriggerClick(this.firstTriggerToCloseWF);\r\n    }\r\n\r\n    public async handleGenericTriggerClick(event: WorkflowGenericTransition): Promise<void> {\r\n        const result: ValidationResult = await this.fireGenericTriggerOperation(\r\n            this.workFlow.workflowProcessId, event.genericTransitionId, this.userRelationId );\r\n        if (result.success) {\r\n            this.genericTriggerFired.next(this.activity);\r\n        } else {\r\n            const messages: string[] = [];\r\n            const len: number = result.messages.length;\r\n            for (let i: number = 0; i < len; i++) {\r\n                messages.push(this._dictionaryService.get(result.messages[i].message.toUpperCase()));\r\n            }\r\n            this._dialogService.showError(messages.toString());\r\n        }\r\n    }\r\n\r\n    public async handleTriggerClick(eventTrigger: WorkflowTrigger): Promise<void> {\r\n        if (eventTrigger.isTaskTrigger && eventTrigger.taskId) {\r\n            //prepare task on the activity object, so the task modifier can handle it\r\n            this.activity.task = new Task();\r\n            this.activity.activityType = ActivityType.Task;\r\n            this.activity.task.taskId = eventTrigger.taskId;\r\n            this.taskModifier.startModifyingTask(this.activity);\r\n        } else if (eventTrigger.isFormTrigger) {\r\n            //TODO reinstate when we know what to do with the formbuilder\r\n            /*this.form = await this._formRepo.getForm(eventTrigger.formId);\r\n            this.table = this.workFlow.table;\r\n            this.key = this.workFlow.key;\r\n            this.showCreateForm = true;*/\r\n        } else {\r\n            /*if (eventTrigger.toClosedState && !await this.canFireTriggerOperation({activity: this.activity, task: this.activity.task})) {\r\n                await this.prepareWorkflowOperation({table: this.workFlow.table, key: this.workFlow.key});\r\n                this.triggerToFireOnSave = eventTrigger;\r\n                this.showTaskFormAndWorkLog();\r\n                return;\r\n            }*/\r\n            const result: ValidationResult = await this.fireTriggerOperation(\r\n              this.workFlow.workflowProcessId, this.workFlow.sequence, eventTrigger.triggerId);\r\n            if (result.success) {\r\n              this.triggerFired.next(this.activity);\r\n            } else {\r\n              const messages: string[] = [];\r\n              const len: number = result.messages.length;\r\n              for (let i: number = 0; i < len; i++) {\r\n                messages.push(this._dictionaryService.get(result.messages[i].message.toUpperCase()));\r\n              }\r\n              this._dialogService.showError(messages.toString());\r\n            }\r\n\r\n        }\r\n    }\r\n\r\n    public handleOpenLink(event: MouseEvent, url?: string): void {\r\n        this._stopEventPropagation(event);\r\n        if (url) { // breadCrumbs to url\r\n            this._openUrl(url);\r\n        } else {\r\n            this.startModifyingTask();\r\n        }\r\n    }\r\n\r\n    public handleOpenLinkOrUrl(event: MouseEvent): void {\r\n        this._stopEventPropagation(event);\r\n        if (this.link && this.link.module) {\r\n            this.linkClicked.next({module: this.link.module, id: this.link.id});\r\n        } else if (this.urls && this.urls.length) {\r\n            this._openUrl(this.urls[0]);\r\n        } else {\r\n            this.startModifyingTask();\r\n        }\r\n    }\r\n\r\n    public startModifyingTask(): void {\r\n        if (this.workFlow && this.workFlow.workFlowHasOneTaskTrigger) {\r\n            this.activity.task = new Task();\r\n            this.activity.activityType = ActivityType.Task;\r\n            this.activity.task.taskId = this.workFlow.taskIdFromTaskTrigger;\r\n        }\r\n        if (this.activity.task) {\r\n            if (this.handleOpenLinkSidebar === true) {\r\n                this.openLink.next(this.activity);\r\n            } else {\r\n              this.taskModifier.startModifyingTask(this.activity);\r\n            }\r\n        }\r\n        // TODO: for now a message is shown.\r\n        else if (this.workFlow) {\r\n            this._dialogService.showInformation(\"Component: \" + this.workFlow.component + \" key: \" + this.workFlow.displayKey);\r\n        }\r\n    }\r\n\r\n    public showTaskFormAndWorkLog(): void {\r\n        if (this.activity.task) {\r\n          //TODO REINSTATE AFTER FIXING FORM\r\n          //this.taskModifier.startModifyingTaskAndWorkLog(this.activity);\r\n        }\r\n    }\r\n\r\n    public onSaveActivity(activity: Activity): void {\r\n        this.activity = activity;\r\n        this.activityChange.next(this.activity);\r\n    }\r\n\r\n    public onDeleteActivity(activity: Activity): void {\r\n        if (this.activity.getId() === activity.getId()) {\r\n            if (this._viewModel) {\r\n                this._viewModel.deleted = true;\r\n                this._viewModel.showing = false;\r\n                this._viewModel.refreshViewModel();\r\n            }\r\n            this.activityDeleted.emit(activity);\r\n        }\r\n    }\r\n\r\n\r\n    //TODO Reinstate once we know what to do with the formbuilder\r\n    /*public doCancelForm(): void {\r\n        this.showCreateForm = false;\r\n    }\r\n\r\n    public async doSaveForm(form: FormResponse): Promise<void> {\r\n        const result: ValidationResult = await this._formRepo.insertFormResponse(form);\r\n        if (result.success) {\r\n            this.formCreated.next();\r\n            this.showCreateForm = false;\r\n        }\r\n    }*/\r\n\r\n    private _prepareData(): void {\r\n        this.workFlow = this._activity.workflow;\r\n        if (this.workFlow) {\r\n            this.workFlow.useSingleTaskTriggerAsTask = true;\r\n            this.urls = this.workFlow.urls;\r\n            this.hasTriggers = this.workFlow.hasTriggers;\r\n        }\r\n        this.activityName = this.activity.name;\r\n        this.link = this.activity.link;\r\n        this.linkDescription = this.activity.linkDescription;\r\n        this.targetDate = this.activity.targetDateTime;\r\n        this.deadlineDate = this.activity.deadlineDateTime;\r\n        this.openButtonLabel = this.activity.linkLabel;\r\n        this.activityTitle = this.activity.activityTitle;\r\n        this.activityContextTitle = this.activity.activityContextTitle;\r\n        this.isTask = this._activity.IsTask;\r\n        this.sameDates = DateUtils.IsSameDay(this.targetDate, this.deadlineDate);\r\n        this._setFirstTriggerToCloseWF();\r\n    }\r\n\r\n    private _setFirstTriggerToCloseWF(): void {\r\n        if (isNill(this.workFlow) || isNill(this.workFlow.manualTriggers)) {\r\n            return;\r\n        }\r\n\r\n        this.firstTriggerToCloseWF = undefined;\r\n        const len: number = this.workFlow.manualTriggers.length;\r\n        for (let i: number = 0; i < len; i++) {\r\n            if (this.workFlow.manualTriggers[i].toClosedState) {\r\n                this.firstTriggerToCloseWF = this.workFlow.manualTriggers[i];\r\n                break;\r\n            }\r\n        }\r\n    }\r\n\r\n    private _openUrl(url: string) {\r\n        const regEx: RegExp = new RegExp(/(http)|(www.)/);\r\n        if (regEx.test(url)) {\r\n            window.open(url.indexOf(\"http\") === -1 ? \"http://\" + url : url, \"_blank\");\r\n        } else {\r\n            //this._router.navigateByUrl(url);\r\n        }\r\n    }\r\n\r\n    private _stopEventPropagation(event: MouseEvent): void {\r\n        event.preventDefault();\r\n        event.stopPropagation();\r\n        event.stopImmediatePropagation();\r\n    }\r\n}\r\n"]}

package/esm2015/lib/components/modify-task-form/components/activity-summary-block/activity-summary-block.component.js

@@ -0,0 +1,100 @@
+import { __decorate } from "tslib";
+import { Component, ElementRef, EventEmitter, HostBinding, Input, Output, ViewChild } from "@angular/core";
+import { FormComponent, FormMasterService } from "@colijnit/corecomponents_v12";
+import { Icon } from "../../../../enum/icon.enum";
+import { InputBoolean } from "../../../../decorator/input-boolean.decorator";
+export class ActivitySummaryBlockComponent {
+    constructor(_formMaster, elementRef) {
+        this._formMaster = _formMaster;
+        this.elementRef = elementRef;
+        this.Icon = Icon;
+        this.noBorder = false;
+        this.readonly = false;
+        this.showButtons = false;
+        this.hideCancel = false;
+        this.actionIcon = false;
+        this.expandable = false;
+        this.saveClick = new EventEmitter();
+        this.cancelClick = new EventEmitter();
+    }
+    showClass() {
+        return true;
+    }
+    get summaryElement() {
+        return this.elementRef;
+    }
+    ngOnDestroy() {
+        this.elementRef = undefined;
+    }
+    handleOkClick(event) {
+        if (this.mainForm) {
+            this.mainForm.submit();
+        }
+    }
+    handleCancelClick(event) {
+        this.cancelClick.next(event);
+    }
+    onValid() {
+        this.saveClick.next(null);
+    }
+}
+ActivitySummaryBlockComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-activity-summary-block",
+                template: `
+        <div class="block-wrapper border">
+            <div class="activity-summary-block-edit-template" [id]="cssId">
+                <co-form (validSubmit)="onValid()">
+                    <div class="template-wrapper">
+                        <ng-template [templateWrapper]="editTemplate" *ngIf="editTemplate"></ng-template>
+                    </div>
+                </co-form>
+                <div class="ok-cancel-buttons" *ngIf="showButtons">
+                  <co-button [disabled]="readonly" [textContent]="'OK' | localize" (click)="handleOkClick($event)"></co-button>
+                  <co-button *ngIf="hideCancel" [textContent]="'STICKER' | localize" (click)="handleCancelClick($event)"></co-button>
+                  <ng-template [templateWrapper]="extraButtonsTemplate" *ngIf="extraButtonsTemplate"></ng-template>
+                </div>
+            </div>
+        </div>
+    `,
+                providers: [
+                    FormMasterService
+                ]
+            },] }
+];
+ActivitySummaryBlockComponent.ctorParameters = () => [
+    { type: FormMasterService },
+    { type: ElementRef }
+];
+ActivitySummaryBlockComponent.propDecorators = {
+    mainForm: [{ type: ViewChild, args: [FormComponent,] }],
+    cssId: [{ type: Input }],
+    noBorder: [{ type: HostBinding, args: ["class.no-border",] }, { type: Input }],
+    icon: [{ type: Input }],
+    editIcon: [{ type: Input }],
+    image: [{ type: Input }],
+    editTitle: [{ type: Input }],
+    editTemplate: [{ type: Input }],
+    extraButtonsTemplate: [{ type: Input }],
+    readonly: [{ type: Input }],
+    showButtons: [{ type: Input }],
+    hideCancel: [{ type: Input }],
+    actionIcon: [{ type: HostBinding, args: ["class.icon-action",] }, { type: Input }],
+    expandable: [{ type: Input }],
+    saveClick: [{ type: Output }],
+    cancelClick: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-activity-summary-block",] }]
+};
+__decorate([
+    InputBoolean()
+], ActivitySummaryBlockComponent.prototype, "noBorder", void 0);
+__decorate([
+    InputBoolean()
+], ActivitySummaryBlockComponent.prototype, "hideCancel", void 0);
+__decorate([
+    InputBoolean()
+], ActivitySummaryBlockComponent.prototype, "actionIcon", void 0);
+__decorate([
+    InputBoolean()
+], ActivitySummaryBlockComponent.prototype, "expandable", void 0);
+//# sourceMappingURL=data:application/json;base64,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