@colijnit/sharedcomponents 261.1.0 → 261.1.2

package/projects/sharedcomponents/src/lib/components/workflow-info-tiles/workflow-info-tiles.component.ts

@@ -0,0 +1,63 @@
+import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from "@angular/core";
+import {WorkflowCategoryType} from "@colijnit/mainapi/build/enum/workflow-category.enum";
+import {Icon} from "../../enum/icon.enum";
+import {IconCacheService} from "../../service/icon-cache.service";
+import {WorkflowProcessInfoPerStatus} from "@colijnit/mainapi/build/model/workflow-process-info-per-status";
+import {SharedService} from "../../service/shared.service";
+
+@Component({
+    selector: "co-workflow-info-tiles",
+    template: `
+        <div class="tile-row">
+            <co-workflow-info-tile *ngFor="let workflowProcessInfoPerStatus of WorkflowProcessInfoPerStatusCollection"
+                                   [workflowProcessInfoPerStatus]="workflowProcessInfoPerStatus"
+                                   [isActive]="activeStatus === workflowProcessInfoPerStatus.statusName"
+                                   (click)="workflowProcessInfoPerStatusClickedHandler(workflowProcessInfoPerStatus)">
+            </co-workflow-info-tile>
+        </div>
+    `,
+    encapsulation: ViewEncapsulation.None,
+})
+
+export class WorkflowInfoTilesComponent implements OnInit {
+    protected readonly Icon = Icon;
+    public readonly icons: typeof Icon = Icon;
+    @Input()
+    public set workflowCategory(value: WorkflowCategoryType) {
+      this._workflowCategory = value;
+      this.getWorkflowProcessInfoPerStatusCollection();
+    }
+
+    @Output()
+    public workflowProcessInfoPerStatusClicked: EventEmitter<string> = new EventEmitter<string>();
+
+    public WorkflowProcessInfoPerStatusCollection: WorkflowProcessInfoPerStatus[];
+    public activeStatus: string | null = null;
+    private _workflowCategory: WorkflowCategoryType;
+
+  @HostBinding("class.co-workflow-info-tiles")
+    public showClass(): boolean {
+      return true;
+    }
+
+    constructor(public iconCacheService: IconCacheService,
+                public sharedService: SharedService) {
+    }
+
+    ngOnInit(): void {
+      this.getWorkflowProcessInfoPerStatusCollection();
+    }
+
+    public workflowProcessInfoPerStatusClickedHandler(status: WorkflowProcessInfoPerStatus){
+      this.activeStatus = status.statusName;
+      this.workflowProcessInfoPerStatusClicked.emit(status.statusName);
+    }
+
+    private getWorkflowProcessInfoPerStatusCollection(): void {
+      if(this._workflowCategory) {
+        this.sharedService.getWorkflowProcessInfoPerStatus(this._workflowCategory).then((result: WorkflowProcessInfoPerStatus[]) => {
+          this.WorkflowProcessInfoPerStatusCollection = result;
+        });
+      }
+    }
+}

package/projects/sharedcomponents/src/lib/components/workflow-info-tiles/workflow-info-tiles.module.ts

@@ -0,0 +1,22 @@
+import {NgModule} from "@angular/core";
+import {WorkflowInfoTilesComponent} from "./workflow-info-tiles.component";
+import {WorkflowInfoTileModule} from "./components/workflow-info-tile.module";
+import {CommonModule} from "@angular/common";
+
+@NgModule({
+  imports: [
+    WorkflowInfoTileModule,
+    CommonModule
+  ],
+  declarations: [
+    WorkflowInfoTilesComponent
+  ],
+  exports: [
+    WorkflowInfoTilesComponent
+  ],
+  providers: [
+  ]
+})
+export class WorkflowInfoTilesModule {
+
+}

package/projects/sharedcomponents/src/lib/components/workflow-notification-toggle/workflow-notification-toggle-popup.ts

@@ -0,0 +1,55 @@
+import {Component, ElementRef, EventEmitter, Input, OnDestroy, Output} from "@angular/core";
+import {WorkflowProcess} from "@colijnit/mainapi/build/model/workflow-process";
+import {IconCacheService} from "../../service/icon-cache.service";
+import {Icon} from "../../enum/icon.enum";
+
+@Component({
+  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>`
+})
+
+export class WorkflowNotificationTogglePopupComponent implements OnDestroy {
+  public readonly icons: typeof Icon = Icon;
+
+  @Input()
+  public workflowProcesses: WorkflowProcess[] = [];
+  @Input()
+  public parentForOverlay: ElementRef;
+
+
+  @Output()
+  public closePopupClicked: EventEmitter<any> = new EventEmitter<any>();
+  @Output()
+  public workflowProcessClicked: EventEmitter<WorkflowProcess> = new EventEmitter<WorkflowProcess>();
+
+  constructor(
+    public element: ElementRef,
+    public iconService: IconCacheService,
+  ) {
+  }
+
+  ngOnDestroy(): void {
+    this.element = undefined;
+  }
+
+}

package/projects/sharedcomponents/src/lib/components/workflow-notification-toggle/workflow-notification-toggle.component.ts

@@ -0,0 +1,88 @@
+import {Component, ComponentRef, ElementRef, HostBinding, Input, OnInit} from "@angular/core";
+import {Icon} from "../../enum/icon.enum";
+import {IconCacheService} from "../../service/icon-cache.service";
+import {OperationCallbackFunctionWithValidation} from "../../interface/operation-callback-function-with-validation";
+import {ValidationResult} from "@colijnit/ioneconnector/build/model/validation-result";
+import {WorkflowProcess} from "@colijnit/mainapi/build/model/workflow-process";
+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";
+
+@Component({
+  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' | sharedLocalize"></co-button>
+  `
+})
+export class WorkflowNotificationToggleComponent implements OnInit {
+  public readonly icons: typeof Icon = Icon;
+
+  @Input()
+  public table: string;
+
+  @Input()
+  public key: string;
+
+  @Input()
+  public setHasPausedNotificationsForWorkflowProcessOperation: OperationCallbackFunctionWithValidation;
+
+  @HostBinding("class.co-workflow-notification-toggle")
+  public showClass() {
+    return true;
+  }
+
+  public workflowProcesses: WorkflowProcess[] = [];
+
+  public showPopup: boolean = false;
+
+  private _workflowPopupRef: ComponentRef<any>;
+
+  constructor(
+    public element: ElementRef,
+    public iconService: IconCacheService,
+    public sharedService: SharedService,
+    private _overlayService: OverlayService
+  ) {
+  }
+
+  public ngOnInit(): void {
+    this._loadWorkflowProcesses();
+  }
+
+  private async _loadWorkflowProcesses(): Promise<void> {
+    this.workflowProcesses = await this.sharedService.getActiveProcessesByTableAndKey(TableName[this.table], this.key);
+  }
+
+  public buttonClicked(): void {
+    if (!this.showPopup) {
+      this.openPopup();
+    } else {
+      this.closePopup();
+    }
+  }
+
+  public openPopup(): void {
+    this.showPopup = true;
+    this._workflowPopupRef = this._overlayService.createComponent(WorkflowNotificationTogglePopupComponent,
+      {parentForOverlay: this.element, workflowProcesses: this.workflowProcesses}, {
+        closePopupClicked: () => this.closePopup(),
+        workflowProcessClicked: (WorkflowProcess) => this.handleWorkflowToggle(WorkflowProcess)
+      });
+  }
+
+  public closePopup(): void {
+    this.showPopup = false;
+    this._overlayService.removeComponent(this._workflowPopupRef);
+  }
+
+  public async handleWorkflowToggle(workflow: WorkflowProcess): Promise<void> {
+    const valResult: ValidationResult = await this.setHasPausedNotificationsForWorkflowProcessOperation(workflow.workflowProcessId, !workflow.hasPausedNotifications, null)
+    if (valResult && valResult.success) {
+      workflow.hasPausedNotifications = !workflow.hasPausedNotifications;
+    }
+  }
+}

package/projects/sharedcomponents/src/lib/components/workflow-notification-toggle/workflow-notification-toggle.module.ts

@@ -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 {DirectivesModule} from '../../directives/directives.module';
+import {CommonModule} from '@angular/common';
+import {WorkflowNotificationTogglePopupComponent} from './workflow-notification-toggle-popup';
+import {SharedComponentsTranslationModule} from '../../translation/shared-components-translation.module';
+
+
+@NgModule({
+  imports: [
+    ButtonModule,
+    ClickoutsideModule,
+    SharedComponentsTranslationModule,
+    IconModule,
+    DirectivesModule,
+    CommonModule,
+    OverlayModule
+  ],
+  declarations: [
+    WorkflowNotificationToggleComponent,
+    WorkflowNotificationTogglePopupComponent
+  ],
+  exports: [
+    WorkflowNotificationToggleComponent,
+    WorkflowNotificationTogglePopupComponent
+  ],
+  providers: [
+    OverlayService
+  ]
+})
+export class WorkflowNotificationToggleModule {
+
+}

package/projects/sharedcomponents/src/lib/decorator/input-boolean.decorator.ts

@@ -0,0 +1,35 @@
+import {Input} from "@angular/core";
+import {StringUtils} from "../utils/string-utils";
+
+/**
+ * Property decorator which enables template syntax like "someBoolInput" instead of "[someBoolInput]='true'". Makes use of the fact that
+ * Angular assigns an empty string to the input property in the naked "someBoolInput" template case.
+ */
+export function InputBoolean(bindingPropertyName?: string): PropertyDecorator {
+    const inputDecorator: PropertyDecorator = Input(bindingPropertyName);
+    return (target: Object, key: string) => {
+        inputDecorator(target, key);
+        const descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(target, key) || {};
+        Object.defineProperty(target, key, {
+            get: descriptor.get || function (): boolean {
+                return this["__" + key];
+            },
+            set: function(newValue: any): void {
+                const val: boolean = InputBooleanDecorator.InputValueToBoolean(newValue);
+                descriptor.set ? descriptor.set(val) : this["__" + key] = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+    };
+}
+
+// Utility function holder of the InputBooleanDecorator decorator.
+export class InputBooleanDecorator {
+    public static InputValueToBoolean(value: any): boolean {
+        if (StringUtils.IsString(value) && !StringUtils.IsStringWithLength(value)) {
+            return true;
+        }
+        return !!value;
+    }
+}

package/projects/sharedcomponents/src/lib/directives/absolute-overlay-template.directive.ts

@@ -0,0 +1,26 @@
+import {Directive, Input, OnDestroy, OnInit, TemplateRef} from "@angular/core";
+import {AppAbsoluteOverlayOutletService} from "../service/app-absolute-overlay-outlet.service";
+
+@Directive({
+    selector: "[absoluteOverlayTemplate]"
+})
+// Directive applicable to <ng-template>'s of components. Places template content in the app's absolute overlay outlet.
+export class AbsoluteOverlayTemplateDirective implements OnInit, OnDestroy {
+    // The host <ng-template> tag to which this directive is applied.
+    @Input()
+    public absoluteOverlayTemplate: TemplateRef<any>;
+
+    constructor(private _outletService: AppAbsoluteOverlayOutletService) {
+    }
+
+    // spawn host template in absolute overlay outlet
+    ngOnInit(): void {
+        this._outletService.placeTemplateIntoOverlay(this.absoluteOverlayTemplate);
+    }
+
+    // de-spawn host template from absolute overlay outlet
+    ngOnDestroy(): void {
+        this._outletService.removeTemplateFromOverlay(this.absoluteOverlayTemplate);
+        this.absoluteOverlayTemplate = undefined;
+    }
+}

package/projects/sharedcomponents/src/lib/directives/align-with.directive.ts

@@ -0,0 +1,191 @@
+import {
+    AfterContentChecked,
+    AfterViewInit,
+    Directive,
+    ElementRef,
+    HostBinding,
+    Input,
+    NgZone,
+    OnChanges,
+    OnDestroy,
+    OnInit
+} from "@angular/core";
+import {InputBoolean} from "../decorator/input-boolean.decorator";
+import {ElementPosition} from "@colijnit/corecomponents_v12/lib/core/model/element-position";
+import {EventUtils} from "../utils/event-utils";
+import {BrowserUtils} from "../utils/browser-utils";
+
+@Directive({
+    selector: "[alignWith]"
+})
+export class AlignWithDirective implements OnInit, AfterViewInit, OnChanges, OnDestroy, AfterContentChecked {
+    // a native OR custom element
+    @Input()
+    public set alignWith(alignWith: any | ElementRef) {
+        if (alignWith) {
+            // enables simple #templateVars passing to [alignWith] for native elements like <div>; Angular passes these as HTMLElement's
+            if (alignWith instanceof HTMLElement) {
+                this._hostNativeEl = alignWith;
+            } else {
+                this._hostNativeEl = alignWith.nativeElement;
+            }
+        }
+    }
+
+    @Input() @InputBoolean()
+    public enableAlign: boolean;
+
+    @Input() @InputBoolean()
+    public keepInView: boolean = true;
+
+    @Input() @InputBoolean()
+    public keepInViewHorizontal: boolean = true;
+
+    @Input() @InputBoolean()
+    public keepInViewVertical: boolean = true;
+
+    @Input() @InputBoolean()
+    public alignRight: boolean;
+
+    @Input() @InputBoolean()
+    public noWidthAlign: boolean;
+
+    @Input() @InputBoolean()
+    public ajustableHeight: boolean = false;
+
+    @Input()
+    public alignTopOffsetPx: number = 0;
+
+    @Input()
+    public alignLeftOffsetPx: number = 0;
+
+    @Input()
+    public viewElement: ElementRef;
+
+    @HostBinding("style.position")
+    public fixed: string = "fixed";
+
+    @HostBinding("style.left.px")
+    public left: number;
+
+    @HostBinding("style.top.px")
+    public top: number;
+
+    @HostBinding("style.max-height.px")
+    public height: number;
+
+    @HostBinding("style.width.px")
+    public width: number;
+
+    private _hostNativeEl: any;
+
+    private get _shouldDoAlign(): boolean {
+        return this._hostNativeEl && this.enableAlign;
+    }
+
+    constructor(private _ngZone: NgZone, private _elementRef: ElementRef) {
+    }
+
+    ngAfterViewInit(): void {
+        this.align();
+        // align again after hosts 'animation finished'
+        setTimeout(() => {
+            this.align();
+        }, 200);
+    }
+
+    ngOnChanges(): void {
+        this.align();
+    }
+
+    ngAfterContentChecked(): void {
+        this.align();
+    }
+
+    ngOnDestroy(): void {
+        window.removeEventListener("scroll", this.scroll, EventUtils.passiveCapture);
+        window.removeEventListener("resize", this.resize, EventUtils.passiveCapture);
+        window.removeEventListener("keyup", this.handleKeyUp, EventUtils.passiveCapture);
+        this._elementRef = undefined;
+        this._hostNativeEl = undefined;
+        this.viewElement = undefined;
+    }
+
+    ngOnInit(): void {
+        this._ngZone.runOutsideAngular(() => {
+            window.addEventListener("scroll", this.scroll, EventUtils.passiveCapture);
+            window.addEventListener("resize", this.resize, EventUtils.passiveCapture);
+            window.addEventListener("keyup", this.handleKeyUp, EventUtils.passiveCapture);
+        });
+    }
+
+    private _getDimensions(): ElementPosition {
+        return {
+            top: this.top,
+            right: this.left + this._elementRef.nativeElement.clientWidth,
+            bottom: this.top + this._elementRef.nativeElement.clientHeight,
+            left: this.left
+        };
+    }
+
+    public align(): void {
+        if (this._shouldDoAlign) {
+            const rect: ClientRect = this._hostNativeEl.getBoundingClientRect();
+            this.left = Math.max(0, rect.left + this.alignLeftOffsetPx);
+            this.top = rect.top + this.alignTopOffsetPx;
+            if (this.alignRight) {
+                this.left = rect.right - this._elementRef.nativeElement.clientWidth;
+            }
+            if (!this.noWidthAlign) {
+                this.width = rect.width;
+            }
+            let dimensions = this._getDimensions();
+            if (this.keepInView && !BrowserUtils.AreDimensionsInView(dimensions, this.viewElement)) {
+                const viewElemDimensions: ElementPosition = BrowserUtils.GetDimensions(this.viewElement);
+                if (!BrowserUtils.HorizontalFitInView(dimensions, this.viewElement) && this.keepInViewHorizontal) {
+                    this.left = Math.max(0, viewElemDimensions.right - this._elementRef.nativeElement.clientWidth);
+                    dimensions = this._getDimensions();
+                }
+                if (!BrowserUtils.VerticalFitInView(dimensions, this.viewElement) && this.keepInViewVertical) {
+                    // Prevent this from going negative (which can happen with tall popups on small screens) and starting offscreen.
+                    this.top = Math.max(0, rect.top - this._elementRef.nativeElement.clientHeight);
+                    dimensions = this._getDimensions();
+                }
+                // Prevent running off the _bottom_ of the screen
+                const overrun = dimensions.bottom - window.innerHeight;
+                if (overrun > 0) {
+                    this.top = Math.max(0, this.top - overrun);
+                    dimensions = this._getDimensions();
+                }
+
+                if (this.ajustableHeight) {
+                    if (dimensions.bottom >= viewElemDimensions.bottom) {
+                        this.height = viewElemDimensions.bottom - this.top;
+                    } else {
+                        this.height = undefined;
+                    }
+                }
+            }
+        }
+    }
+
+    public scroll = (): void => {
+        this._alignWithZone();
+    }
+
+    public resize = (): void => {
+        this._alignWithZone();
+    }
+
+    public handleKeyUp = (): void => {
+        this._alignWithZone();
+    }
+
+    private _alignWithZone(): void {
+        if (this._shouldDoAlign) {
+            this._ngZone.run(() => {
+                this.align();
+            });
+        }
+    }
+}

package/projects/sharedcomponents/src/lib/directives/click-outside.directive.ts

@@ -0,0 +1,25 @@
+import {
+  Directive,
+  EventEmitter,
+  HostListener,
+  Output,
+  ElementRef,
+} from '@angular/core';
+
+@Directive({
+  selector: '[outsideClick]',
+})
+export class ClickOutsideDirective {
+
+  @Output()
+  outsideClick: EventEmitter<MouseEvent> = new EventEmitter();
+
+  @HostListener('document:mousedown', ['$event'])
+  onClick(event: MouseEvent): void {
+    if (!this.elementRef.nativeElement.contains(event.target)) {
+      this.outsideClick.emit(event);
+    }
+  }
+
+  constructor(private elementRef: ElementRef) {}
+}

package/projects/sharedcomponents/src/lib/directives/directives.module.ts

@@ -0,0 +1,22 @@
+import {NgModule} from "@angular/core";
+import {AbsoluteOverlayTemplateDirective} from "./absolute-overlay-template.directive";
+import {AlignWithDirective} from "./align-with.directive";
+import {ClickOutsideDirective} from "./click-outside.directive";
+
+@NgModule({
+  imports: [
+  ],
+  declarations: [
+    AbsoluteOverlayTemplateDirective,
+    AlignWithDirective,
+    ClickOutsideDirective
+  ],
+  exports: [
+    AbsoluteOverlayTemplateDirective,
+    AlignWithDirective,
+    ClickOutsideDirective
+  ]
+})
+export class DirectivesModule {
+
+}

package/projects/sharedcomponents/src/lib/enum/activity-cfg-name.enum.ts

@@ -0,0 +1,28 @@
+export enum ActivityCfgName {
+    TaskForms = "TaskForms",
+    NewTaskFormHeader = "NewTaskFormHeader",
+    NewTaskTitle = "NewTaskTitle",
+    ActivitiesHeader = "activitiesHeader",
+    NewTaskGlobalButton = "newTaskGlobalButton",
+    AddActivityTaskButton = "addActivityTaskButton",
+    DeleteActivityTaskButton = "deleteActivityTaskButton",
+    AddActivityRemarkButton = "addActivityRemarkButton",
+    AddActivityWorkButton = "addActivityWorkButton",
+    TimeRegistrationMandatory = "timeRegistrationMandatory",
+    StatusSummaryHeader = "statusSummaryHeader",
+    CreationSummaryHeader = "creationSummaryHeader",
+    ExecutiveSummaryHeader = "executiveSummaryHeader",
+    PlanningSummaryHeader = "planningSummaryHeader",
+    AttachmentsHeader = "attachmentsHeader",
+    NotificationsSummaryHeader = "notificationsSummaryHeader",
+    TagsHeader = "tagsHeader",
+    WorkHeader = "workHeader",
+    WorkExecutive = "workExecutive",
+    WorkCalculationKey = "calculationKey",
+    WorkDescription = "workDescription",
+    WorkFile = "workFile",
+    EstimationStandardTime = "estimate",
+    TaskInvoice = "taskInvoice",
+
+    WorkedTime = "workedTime"
+}

package/projects/sharedcomponents/src/lib/enum/app-button-type.enum.ts

@@ -0,0 +1,9 @@
+export enum AppPopupButtonType {
+    Ok = 0,
+    Open = 1,
+    Save = 2,
+    Cancel = 3,
+    Yes = 4,
+    No = 5,
+    NoButton = 6
+}

package/projects/sharedcomponents/src/lib/enum/calendar-view.enum.ts

@@ -0,0 +1,10 @@
+export enum CalendarView {
+    DayView = "DAY",
+    DaysAround = "DAYS_AROUND",
+    ThreeDaysView = "THREE_DAYS_AROUND",
+    WeekView = "WEEK",
+    WeekSelectView = "WEEK_SELECT",
+    WeekWorkView = "WORK_WEEK",
+    WeekPlanningView = "WEEK_PLANNING",
+    MonthView = "MONTH",
+}

package/projects/sharedcomponents/src/lib/enum/co-document-type.ts

@@ -0,0 +1,11 @@
+// for refcode CV_DOCUMENTATIE.DOC_TYPE
+export enum CoDocumentType {
+    // BN: Document opslaan als bestand, locatie niet van toepassing
+    SaveAsDocument = "BN",
+    // LS: Document opslaan als link op willekeurige locatie
+    SaveAsLinkOnRandomLocation = "LS",
+    // LW: Document opslaan als link op standaardloactie
+    SaveAsLinkOnDefaultLocation = "LW",
+    // CD: Document saved on cdn server
+    SaveAsLinkOnCdnServerLocation = "CD",
+}

package/projects/sharedcomponents/src/lib/enum/document-allowed-type.enum.ts

@@ -0,0 +1,10 @@
+export enum DocumentAllowedType {
+    Image = "Image",
+    Document = "Document",
+    Text = "Text",
+    ThreeD = "3D",
+    JasperReport = "Jasper report",
+    Video = "Video",
+    Audio = "Audio",
+    Archive = "Archive"
+}

package/projects/sharedcomponents/src/lib/enum/document-email-report.enum.ts

@@ -0,0 +1,16 @@
+// <b>Enum</b> Encapsulation of the doc numbers to store it in DOCUMENTATIE table, java enum ReportDocKind
+export enum DocumentEmailReport {
+    Orderbevestiging = 1,
+    Afleverbon = 2,
+    Factuur = 4,
+    Bestelbon = 8,
+    Atelierbon = 16,
+    Werkbon = 32,
+    Vrachtbrief = 64,
+    Leverindicatie = 128,
+    Uitlopende_levering = 256,
+    Goederen_binnen = 512,
+    Afspraakbevestiging = 1024,
+    Herinneringsbestelbon = 2048,
+    Aanmaninglevertijd = 4096
+}

package/projects/sharedcomponents/src/lib/enum/domain-multiple-name.enum.ts

@@ -0,0 +1,11 @@
+// Enum of all domain names (refcodes) from db table CG_REF_CODES2 (2!!) that iOneJS currently uses.
+export enum DomainMultipleName {
+    ArticlePublication = "ART_PUBLICATIE",
+    ArticlePublicationSales = "ART_PUBLICATIE_VERK",
+    ArticleSyncField = "DOM_SYNC_VELDEN",
+    DocumentPublication = "DOC_PUBLICATIE",
+    TextType = "TEKST_PUBLICATIE",
+    TextPublication = "TEKSTSOORT",
+    RotationOption = "ART_ROTATION_ALLOWED",
+    WeekDays = "WEEKDAGEN",
+}