@colijnit/sharedcomponents 261.1.0 → 261.1.2

package/projects/sharedcomponents/src/lib/components/task-creator/task-creator.component.ts

@@ -0,0 +1,497 @@
+import {Component, EventEmitter, forwardRef, HostBinding, Input, OnInit, Output, ViewChild} from '@angular/core';
+import {Icon} from '../../enum/icon.enum';
+import {IconCacheService} from '../../service/icon-cache.service';
+import {Activity} from '@colijnit/mainapi/build/model/activity.bo';
+import {ActivityType} from '@colijnit/mainapi/build/enum/activity-type';
+import {Remark} from '@colijnit/mainapi/build/model/remark.bo';
+import {RelationSmallObject} from '@colijnit/mainapi/build/model/relation-small-object.bo';
+import {TableName} from '@colijnit/mainapi/build/enum/table-name.enum';
+import {Work} from '@colijnit/mainapi/build/model/work.bo';
+import {Task} from '@colijnit/mainapi/build/model/task.bo';
+import {WorkflowCategoryType} from '@colijnit/mainapi/build/enum/workflow-category.enum';
+import {CoDocument} from '@colijnit/mainapi/build/model/co-document.bo';
+import {ArrayUtils} from '../../utils/array-utils';
+import {activityEmailRequestData} from '@colijnit/mainapi/build/model/activity-email-request-data';
+import {SharedService} from '../../service/shared.service';
+import {ReportType} from '@colijnit/mainapi/build/enum/report-type.enum';
+import {Report} from '@colijnit/mainapi/build/model/report.bo';
+import {
+  CoreDialogService,
+  FormComponent,
+  FormMasterService,
+  SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME,
+  ScreenConfigAdapterComponent
+} from '@colijnit/corecomponents_v12';
+import {IconListItem} from '@colijnit/corecomponents_v12/lib/model/icon-list-item';
+import {ActivityEmailHistory} from '@colijnit/mainapi/build/model/activity-email-history.bo';
+import {SharedComponentsDictionaryService} from '../../translation/shared-components-dictionary.service';
+import {EmailActivityRequest} from "@colijnit/mainapi/build/model/email-activity-request";
+
+
+@Component({
+  selector: "co-task-creator",
+  template: `
+    <div class="task-creator-wrapper">
+      <div class="top-rows">
+        <co-email-selector [(emailAddresses)]="emailAddresses" [(bccEmailAddresses)]="bccEmailAddresses" *ngIf="allowEmailing"
+                           [key]="remarkAndWorkKey" [workflowCategoryType]="workflowCategoryType"></co-email-selector>
+        <co-form #createForm class="creator-remarks input-fields">
+          <co-list-of-icons [collection]="optionCollection" (itemSelected)="itemSelected($event)"></co-list-of-icons>
+          <co-input-textarea *ngIf="chosenActivityType === remarkListItem"
+                             [required]="chosenActivityType === remarkListItem"
+                             [placeholder]="'REMARK' | sharedLocalize" [(model)]="remarkText"
+                             class="large-remark"></co-input-textarea>
+          <co-input-textarea *ngIf="chosenActivityType === workListItem"
+                             [required]="chosenActivityType === workListItem"
+                             [placeholder]="'DESCRIPTION' | sharedLocalize" [(model)]="workDescription"
+                             class="large-remark"></co-input-textarea>
+          <div class="task-input-fields" *ngIf="chosenActivityType === taskListItem">
+            <co-input-text [(model)]="taskName" [placeholder]="'NAME' | sharedLocalize"
+                           [required]="chosenActivityType === taskListItem"></co-input-text>
+            <co-input-textarea [(model)]="taskDescription" [placeholder]="'DESCRIPTION' | sharedLocalize"
+                               class="large-remark"
+                               [required]="chosenActivityType === taskListItem"></co-input-textarea>
+          </div>
+        </co-form>
+      </div>
+      <div class="extras-buttons">
+        <co-button [iconData]="iconService.getIcon(icons.PaperclipRegular)" (click)="openAttachmentDialog()"
+                   [label]="documents.length === 0 ? '' : documents.length.toString()"></co-button>
+        <co-button *ngIf="chosenActivityType === remarkListItem"
+                   [iconData]="iconService.getIcon(icons.PaperPlaneTopSolid)"
+                   (click)="createRemarkClicked()"></co-button>
+        <co-button *ngIf="chosenActivityType === workListItem"
+                   [iconData]="iconService.getIcon(icons.PaperPlaneTopSolid)"
+                   (click)="createWorkClicked()"></co-button>
+        <div class="task-buttons" *ngIf="chosenActivityType === taskListItem">
+          <co-button
+                     [iconData]="iconService.getIcon(icons.PaperPlaneTopSolid)"
+                     (click)="createTaskClicked()"></co-button>
+          <co-button
+                     [iconData]="iconService.getIcon(icons.DetailView)"
+                     (click)="createTaskNoEmailClicked()"></co-button>
+        </div>
+      </div>
+    </div>
+    <co-dialog *ngIf="showFilesDialog" (closeClick)="attachmentDialogCancelled()"
+               [headerTemplate]="attachmentHeaderTemplate"
+               [footerTemplate]="attachmentFooterTemplate">
+
+      <ng-template #attachmentHeaderTemplate>
+        <div class="co-dialog-wrapper-popup-title">
+          <co-icon [iconData]="iconService.getIcon(icons.PaperclipRegular)"></co-icon>
+          <div class="co-dialog-header-title" [textContent]="'ATTACHMENTS' | sharedLocalize"></div>
+        </div>
+      </ng-template>
+      <co-files-upload (documentsAdded)="addedDocument($event)" (documentDeleted)="deletedDocument"
+                       [documents]="documents" [useWithoutSettingProps]="true"></co-files-upload>
+    </co-dialog>
+
+
+    <ng-template #attachmentFooterTemplate>
+      <div class="co-dialog-footer-button-wrapper">
+        <co-button class="save-button"
+                   [iconData]="iconService.getIcon(icons.CheckDuotone)"
+                   (click)="attachmentDialogClosed()"></co-button>
+        <co-button class="close-button"
+                   [iconData]="iconService.getIcon(icons.CrossSkinny)"
+                   (click)="attachmentDialogCancelled()"></co-button>
+      </div>
+    </ng-template>
+  `,
+  providers: [
+    FormMasterService,
+    {
+      provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME,
+      useExisting: forwardRef(() => TaskCreatorComponent)
+    }
+  ],
+})
+export class TaskCreatorComponent implements OnInit, ScreenConfigAdapterComponent {
+  public readonly icons: typeof Icon = Icon;
+
+  @ViewChild(FormComponent)
+  public createForm: FormComponent;
+
+  @Input()
+  public author: RelationSmallObject;
+
+  @Input()
+  public branchNo: string;
+
+  @Input()
+  public table: TableName = TableName.Transactions;
+
+  @Input()
+  public remarkAndWorkKey: string;
+
+  @Input()
+  public taskKey: string;
+
+  @Input()
+  public workflowCategoryType: WorkflowCategoryType;
+
+  @Input()
+  public set allowRemarkCreation(allow: boolean) {
+    this._allowRemarkCreation = allow;
+    this.setupOptionCollection();
+  }
+
+  @Input()
+  public set allowWorkCreation(allow: boolean) {
+    this._allowWorkCreation = allow;
+    this.setupOptionCollection();
+  }
+
+  @Input()
+  public set allowTaskCreation(allow: boolean) {
+    this._allowTaskCreation = allow;
+    this.setupOptionCollection();
+  }
+
+  @Input()
+  public allowEmailing: boolean = true;
+
+  @Output()
+  public activityCreated: EventEmitter<void> = new EventEmitter<void>();
+
+  @Output()
+  public taskCreated: EventEmitter<number> = new EventEmitter<number>();
+
+  @HostBinding("class.co-task-creator")
+  public showClass() {
+    return true;
+  }
+
+  public objectConfigName: string;
+  @HostBinding('class.co-shared-hidden')
+  public hidden: boolean;
+  public required: boolean;
+  public forceReadonly: boolean;
+  public readonly: boolean;
+  public maxLength: number;
+  public decimals: number;
+  public redErrorBackground: boolean;
+
+  public optionCollection: IconListItem[] = [];
+  public remarkListItem: IconListItem = {icon: this.iconService.getIcon(this.icons.CommentRegular), label: this.dictionaryService.get('REMARK', true)};
+  public workListItem: IconListItem = {icon: this.iconService.getIcon(this.icons.PersonDiggingRegular), label: this.dictionaryService.get('WORK', true)};
+  public taskListItem: IconListItem = {icon: this.iconService.getIcon(this.icons.ListUlRegular), label: this.dictionaryService.get('TASK', true)};
+
+  public showFilesDialog: boolean = false;
+  public documents: CoDocument[] = [];
+  public oldDocuments: CoDocument[] = [];
+
+
+  public showEmailDialog: boolean = false;
+  public senderAddress: string = '';
+  public emailAddresses: string[] = [];
+  public bccEmailAddresses: string[] = [];
+
+  public emailRequest: activityEmailRequestData = null;
+
+  public createdTask: Task;
+  public createdRemark: Remark;
+  public createdWork: Work;
+  public chosenActivityType: IconListItem;
+
+  public remarkText: string = "";
+  public workDescription: string = "";
+  public taskName: string = "";
+  public taskDescription: string = "";
+
+
+  private _allowRemarkCreation: boolean = true;
+  private _allowWorkCreation: boolean = true;
+  private _allowTaskCreation: boolean = true;
+
+  constructor(public iconService: IconCacheService,
+              public dictionaryService: SharedComponentsDictionaryService,
+              public sharedService: SharedService,
+              private _dialogService: CoreDialogService,
+              private _formMasterService: FormMasterService,
+  ) {
+  }
+
+  async ngOnInit() {
+    this.setupOptionCollection();
+    this.senderAddress = await this.sharedService.getEmailSenderByWorkflowCategoryAndKey('SERVICE_ORDER', this.remarkAndWorkKey);
+  }
+
+  public setupOptionCollection(): void {
+    this.optionCollection = [];
+    if (this._allowRemarkCreation) {
+      this.optionCollection.push(this.remarkListItem);
+    }
+    if (this._allowWorkCreation) {
+      this.optionCollection.push(this.workListItem);
+    }
+    if (this._allowTaskCreation) {
+      this.optionCollection.push(this.taskListItem);
+    }
+
+    if (this.optionCollection.length > 0) {
+      this.chosenActivityType = this.optionCollection[0];
+    }
+  }
+
+  public itemSelected(item: IconListItem): void {
+    this.chosenActivityType = item;
+  }
+
+  public openAttachmentDialog(): void {
+    this.oldDocuments = this.documents.slice();
+    this.showFilesDialog = true
+  }
+
+  public attachmentDialogClosed(): void {
+    this.showFilesDialog = false
+  }
+
+  public attachmentDialogCancelled(): void {
+    this.documents = this.oldDocuments.slice();
+    this.showFilesDialog = false
+  }
+
+  public async addedDocument(docs: CoDocument[]): Promise<void> {
+    this.documents = this.documents.concat(docs);
+  }
+
+  public async deletedDocument(doc: CoDocument): Promise<void> {
+    ArrayUtils.RemoveElement(doc, this.documents);
+  }
+
+  public async createRemarkClicked(): Promise<void> {
+    this._formMasterService.submitSlaves();
+    if (this.createForm.isValid()) {
+      let remark: Remark = this.createRemark();
+
+      let activity: Activity = new Activity();
+      activity.activityType = ActivityType.Remark;
+      activity.remark = remark;
+
+      this.createdRemark = await this.sharedService.insertRemark(activity);
+      if (this.createdRemark) {
+        await this.handleAfterCreation(this.createdRemark.remarkId, 'OPMERKINGEN');
+      }
+    }
+  }
+
+  public async createWorkClicked(): Promise<void> {
+    this._formMasterService.submitSlaves();
+    if (this.createForm.isValid()) {
+      let work: Work = this.createWork();
+
+      let activity: Activity = new Activity();
+      activity.activityType = ActivityType.Work;
+      activity.work = work;
+
+      this.createdWork = await this.sharedService.insertWork(activity);
+      if (this.createdWork) {
+        await this.handleAfterCreation(this.createdWork.workId, 'WERKZAAMHEDEN');
+      }
+    }
+  }
+
+  public async createTaskClicked(): Promise<void> {
+    this._formMasterService.submitSlaves();
+    if (this.createForm.isValid()) {
+      const task = this.createTask();
+
+      let activity: Activity = new Activity();
+      activity.activityType = ActivityType.Task;
+      activity.task = task;
+
+      this.createdTask = await this.sharedService.insertTask(activity);
+      if (this.createdTask) {
+        await this.handleAfterTaskCreation(this.createdTask.taskId, /*sendEmail*/ true);
+      }
+    }
+  }
+
+  public async createTaskNoEmailClicked(): Promise<void> {
+    this._formMasterService.submitSlaves();
+    if (this.createForm.isValid()) {
+      const task: Task = this.createTask();
+      const activity: Activity = new Activity();
+      activity.activityType = ActivityType.Task;
+      activity.task = task;
+      this.createdTask = await this.sharedService.insertTask(activity);
+      if (this.createdTask) {
+        const createdTaskId: number = this.createdTask.taskId;
+        await this.handleAfterTaskCreation(createdTaskId, false);
+        this.taskCreated.emit(createdTaskId);
+      }
+    }
+  }
+
+  private async handleAfterTaskCreation(taskId: number, sendEmail: boolean): Promise<void> {
+    this.activityCreated.emit();
+    if (sendEmail) {
+      await this.sendEmailIfNeccesary(taskId, 'TAKEN');
+    }
+    this._clearFields();
+  }
+
+  private createRemark(): Remark {
+    let remark: Remark = new Remark();
+    remark.author = this.author;
+    remark.author.image = undefined;
+    remark.documents = this.documents;
+    remark.remark = this.remarkText;
+    remark.dateTime = new Date();
+    remark.table = this.table;
+    remark.key = this.remarkAndWorkKey;
+    remark.read = false;
+    remark.current = true;
+
+    return remark;
+  }
+
+  private createWork(): Work {
+    let work: Work = new Work();
+    work.executive = this.author;
+    work.executive.image = undefined;
+    work.documents = this.documents;
+    work.workedTime = 0;
+    work.workDescription = this.workDescription
+    work.dateTime = new Date();
+    work.table = this.table;
+    work.key = this.remarkAndWorkKey;
+
+    return work;
+  }
+
+  private createTask(): Task {
+    let task: Task = new Task();
+    task.executive = this.author;
+    task.executive.image = undefined;
+    task.reporter = this.author;
+    task.reporter.image = undefined;
+    task.documents = this.documents;
+    task.name = this.taskName;
+    task.description = this.taskDescription;
+    task.creationDateTime = new Date();
+    task.dateDefinate = false;
+    task.needsPlanning = true;
+    task.priority = 0;
+    task.workflowCategory = this.workflowCategoryType;
+    task.reference = this.taskKey;
+    task.emailAddresses = this.emailAddresses;
+
+    return task;
+  }
+
+  private async handleAfterCreation(activityId: number, activityTable: string): Promise<void> {
+    this.activityCreated.emit();
+    await this.sendEmailIfNeccesary(activityId, activityTable);
+    this._clearFields();
+  }
+
+  private async sendEmailIfNeccesary(activityId: number, activityTable: string): Promise<void> {
+    if (this.emailAddresses.length > 0) {
+      let templates: Report[] = await this.sharedService.getDefaultEmailReportTemplatesForBranch(this.branchNo, this.findReportType());
+      if (templates.length != 0) {
+        let template: Report = this.findDefault(templates);
+        if (template) {
+          await this.startEmailing(template, activityId, activityTable);
+        } else {
+          this._dialogService.showError('NO_DEFAULT_EMAIL_TEMPLATE_FOR_REPORT');
+        }
+      }
+    }
+  }
+
+
+  private findReportType(): ReportType {
+    if (this.chosenActivityType === this.remarkListItem) {
+      return ReportType.RemarkMessage;
+    } else if (this.chosenActivityType === this.workListItem) {
+      return ReportType.WorkMessage;
+    } else {
+      return ReportType.TaskMessage;
+    }
+  }
+
+  private findDefault(reportList: Report[]): Report {
+    let defaultTemplate: Report = null;
+    reportList.forEach(r => {
+      if (r.isDefault) {
+        defaultTemplate = r;
+      }
+    });
+    return defaultTemplate;
+  }
+
+  private async startEmailing(template: Report, activityId: number, activityTable: string): Promise<void> {
+    let request: EmailActivityRequest = this._createEmailParams(template, activityId, activityTable)
+    const emailsSent: CoDocument | boolean = await this.sharedService.emailActivity(request);
+
+    if (emailsSent) {
+      let history: ActivityEmailHistory = new ActivityEmailHistory();
+      history.remarkId = this.createdRemark ? this.createdRemark.remarkId : undefined;
+      history.workId = this.createdWork ? this.createdWork.workId : undefined;
+      history.taskId = this.createdTask ? this.createdTask.taskId : undefined;
+      history.emailAddresses = this._createEmailAddressString(this.emailAddresses);
+      history.emailDateTime = new Date();
+      history.message = 'Email Content created via Report';
+      if (this.chosenActivityType === this.remarkListItem) {
+        await this.sharedService.insertEmailHistoryForRemark(history);
+      } else if (this.chosenActivityType === this.workListItem) {
+        await this.sharedService.insertEmailHistoryForWork(history);
+      } else {
+        await this.sharedService.insertEmailHistoryForTask(history);
+      }
+    }
+  }
+
+  private _createEmailParams(template: Report, activityId: number, activityTable: string): EmailActivityRequest{
+    let request: EmailActivityRequest = new EmailActivityRequest();
+    request.emailSubject = this._createEmailSubject();
+    request.toAddresses = this._createEmailAddressString(this.emailAddresses);
+    request.bccAddresses = this._createEmailAddressString(this.bccEmailAddresses);
+    request.activityId = activityId;
+    request.activityTableName = activityTable;
+    request.reportId = template.reportId;
+    return request;
+  }
+
+  private _createEmailAddressString(addresses: string[]): string {
+    if (addresses.length === 0) {
+      return '';
+    } else {
+      return addresses.join(';');
+    }
+  }
+
+  private _createEmailSubject(): string {
+    let subject: string = "";
+    if (this.createdRemark) {
+      subject += this.dictionaryService.get("REMARK") + " " + this.createdRemark.remarkId;
+    } else if (this.createdWork) {
+      subject += this.dictionaryService.get("WORK") + " " + this.createdWork.workId;
+    } else if (this.createdTask) {
+      subject += (this.createdTask.workflowCategory ? this.createdTask.workflowCategory : this.dictionaryService.get("TASK")) + " " +
+        (this.createdTask.workflowCategory ? this.createdTask.reference : this.createdTask.taskId);
+    }
+    return subject;
+  }
+
+  private _clearFields(): void {
+    this.remarkText = "";
+    this.workDescription = "";
+    this.taskName = "";
+    this.taskDescription = "";
+
+    this.senderAddress = "";
+    this.emailAddresses = [];
+    this.bccEmailAddresses = [];
+    this.emailRequest = null;
+
+    this.documents = [];
+
+    this.createdWork = undefined;
+    this.createdRemark = undefined;
+    this.createdTask = undefined;
+  }
+}

package/projects/sharedcomponents/src/lib/components/task-creator/task-creator.module.ts

@@ -0,0 +1,49 @@
+import {NgModule} from '@angular/core';
+import {BusinessObjectFactory} from '@colijnit/ioneconnector/build/service/business-object-factory';
+import {
+  ButtonModule,
+  CoDialogModule,
+  FormModule,
+  IconModule,
+  InputTextareaModule,
+  InputTextModule,
+  ListOfIconsModule,
+  ListOfValuesModule
+} from '@colijnit/corecomponents_v12';
+import {CommonModule} from '@angular/common';
+import {FilesUploadModule} from '../files-upload/files-upload.module';
+import {RoleEmailSelectorModule} from '../role-email-selector/role-email-selector.module';
+import {EmailSelectorModule} from '../email-selector/email-selector.module';
+import {SharedComponentsTranslationModule} from '../../translation/shared-components-translation.module';
+import {TaskCreatorComponent} from "./task-creator.component";
+
+
+@NgModule({
+  imports: [
+    ListOfValuesModule,
+    InputTextModule,
+    ButtonModule,
+    CommonModule,
+    CoDialogModule,
+    FilesUploadModule,
+    SharedComponentsTranslationModule,
+    ListOfIconsModule,
+    FormModule,
+    IconModule,
+    RoleEmailSelectorModule,
+    EmailSelectorModule,
+    InputTextareaModule
+  ],
+  declarations: [
+    TaskCreatorComponent
+  ],
+  exports: [
+    TaskCreatorComponent
+  ],
+  providers: [
+    BusinessObjectFactory
+  ]
+})
+export class TaskCreatorModule {
+
+}