@colijnit/transaction 261.20.51 → 261.20.52

package/projects/transaction/src/lib/component/delivery-planning-main/component/delivery-planning-overview/delivery-planning-overview.component.ts

@@ -0,0 +1,825 @@
+import {ChangeDetectorRef, Component, EventEmitter, HostBinding, HostListener, Input, OnDestroy, OnInit, Output, QueryList, ViewChild, ViewChildren, ViewEncapsulation} from '@angular/core';
+
+import {CalendarView} from '@colijnit/sharedcomponents';
+import {DeliveryPlanningCalendarModes} from '../../../../enum/delivery-planning-calendar-modes.enum';
+import {DeliveryPlanningViewModes} from '../../../../enum/delivery-planning-view-modes.enum';
+import {DeliveryPlanningService} from '../../../delivery-planning/service/delivery-planning.service';
+import {TransactionService} from '../../../../service/transaction.service';
+import {TransactionConnectorService} from '../../../../service/transaction-connector.service';
+import {PlanningTransportWeekDay} from '@colijnit/transactionapi/build/model/planning-transport-week-day.bo';
+import {PlanOrder} from '@colijnit/transactionapi/build/model/plan-order.bo';
+import {GetTransportOrdersRequest} from '@colijnit/transactionapi/build/model/get-transport-orders-request.bo';
+import {PlanningFilterObject} from '@colijnit/transactionapi/build/model/planning-filter-object.bo';
+import {TransactionDialogService} from '../../../../service/transaction-dialog.service';
+import {OrderLinesPlannedRequest} from '@colijnit/transactionapi/build/model/order-lines-planned-request.bo';
+import {DeliveryPlanningOverviewPopupComponent} from './component/delivery-planning-overview-popup/delivery-planning-overview-popup.component';
+import {DeliveryPlanningOverviewTileComponent} from './component/delivery-planning-overview-tile/delivery-planning-overview-tile.component';
+import {IconCacheService} from '../../../../service/icon-cache.service';
+import {Icon} from '../../../../enum/icon.enum';
+import {DeliveryPlanningTileModes} from '../../../../enum/delivery-planning-tile-modes.enum';
+import {DeliveryPlanningUpdateActions} from '../../../../enum/delivery-planning-update-actions.enum';
+import {PlanOrderLine} from '@colijnit/transactionapi/build/model/plan-order-line.bo';
+import {DictionaryService} from '../../../../service/dictionary.service';
+import {TransactionLineInfo} from '@colijnit/transactionapi/build/model/transaction-line-info.bo';
+import {Subscription} from 'rxjs';
+import {InternalParam} from '@colijnit/mainapi/build/enum/internal-param.enum';
+import {TransactionEventService} from '../../../../service/transaction-event.service';
+import {PlanningTransportWeek} from '@colijnit/transactionapi/build/model/planning-transport-week.bo';
+
+@Component({
+  selector: 'co-delivery-planning-overview',
+  template: `
+      <div class="delivery-planning-wrapper">
+          @if (showNoteDialog) {
+              <co-delivery-planning-overview-popup #planningPopup (closeEvent)="showNoteDialog = false"
+                                                   (onSucceededPlanAction)="handlePopupPlanEvent($event)"></co-delivery-planning-overview-popup>
+          }
+          @if (showSettingsDialog) {
+              <co-delivery-planning-overview-tile-settings-popup [transportDay]="selectedTransportDay"
+                                                                 (onCancelAction)="handleSettingsReset()"
+                                                                 (closeEvent)="handleSettingsSaved()"></co-delivery-planning-overview-tile-settings-popup>
+          }
+          <div class="delivery-overview-wrapper" [ngClass]="columnClasses" [class.sidebar]="currentViewMode === 'DAYS_AROUND'">
+              <div class="tile-view-modes row">
+                  <co-icon (click)="currentTileMode = tileModes.Normal" [class.active]="currentTileMode === tileModes.Normal"
+                           [iconData]="iconCacheService.getIcon(icons.CalendarLinesRegular)"></co-icon>
+                  <co-icon (click)="currentTileMode = tileModes.Calendar" [class.active]="currentTileMode === tileModes.Calendar"
+                           [iconData]="iconCacheService.getIcon(icons.CalendarDayRegular)"></co-icon>
+              </div>
+              <div class="planning-component-wrapper">
+                  <co-date-planning [view]="currentViewMode" [selectedDate]="currentDate()"
+                                    (rangeChange)="handleDateRangeChange($event)"
+                                    (selectedDateChange)="handleDateRangeChange($event)"
+                                    (viewChange)="onChangeView($event)"></co-date-planning>
+              </div>
+
+              @for (transportWeekRow of planTransportWeekArr; track transportWeekRow) {
+                  <div class="row date-planning" [class.employee-view]="employeeView" #rowContainer>
+                      @for (transPortDay of filterWeekArray(transportWeekRow); track transPortDay; let i = $index) {
+                          <div class="column" [ngClass]="columnClasses" #columnElem
+                          >
+                              <co-delivery-planning-overview-tile
+                                      [class.disabled]="!transPortDay?.availableOnDate || transPortDay?.maxMinutes === 0 || checkAvailable(transPortDay)"
+                                      [disabled]="!transPortDay?.availableOnDate || transPortDay?.maxMinutes === 0"
+                                      (dragover)="allowDrop($event, transPortDay)"
+                                      (click)="selectTransportDay(transPortDay)"
+                                      (drop)="dropped($event, transportWeekRow, transPortDay, filterWeekArray(transportWeekRow))"
+                                      (dragend)="dragEnd($event)"
+                                      (transportSelected)="selectTransportDay($event)"
+                                      [transportDay]="transPortDay"
+                                      (deleteOrderEvent)="handleDeleteOrder($event, transportWeekRow)"
+                                      (timeChangeEvent)="handleTimeChangeEvent(transPortDay, transportWeekRow,$event)"
+                                      (openSettingsDialogEvent)="openSettingsDialog($event)"
+                                      (calendarPlanEvent)="handleCalendarPlanEvent($event, transPortDay, transportWeekRow)"
+                                      (deleteOrderLineEvent)="handleDeleteLine($event, transPortDay, transportWeekRow)"
+                                      (editOrderEvent)="handleEditPlannedOrder($event, transPortDay, transportWeekRow)"
+                                      (moveEvent)="handleMoveEvent($event,transPortDay, transportWeekRow, planTransportWeekArr)"
+                                      (availabilityChecked)="handleAvailabilityChecked($event)"
+                                      (moveOrderUpEvent)="handleMoveOrderUp($event, transportWeekRow, transPortDay)"
+                                      (moveOrderDownEvent)="handleMoveOrderDown($event, transportWeekRow, transPortDay)"
+                                      (planOrderOnSameTimeEvent)="handlePlanOrderOnSameTime($event, transPortDay, transportWeekRow)"
+                                      (reorderOrderEvent)="handleReorderOrder($event, transportWeekRow, transPortDay)"
+                              ></co-delivery-planning-overview-tile>
+                          </div>
+                      }
+                  </div>
+              }
+
+
+          </div>
+
+      </div>
+
+
+  `,
+  encapsulation: ViewEncapsulation.None,
+  standalone: false
+})
+export class DeliveryPlanningOverviewComponent implements OnInit, OnDestroy {
+  public readonly icons: typeof Icon = Icon;
+  public readonly planningActions: typeof DeliveryPlanningUpdateActions = DeliveryPlanningUpdateActions;
+  public readonly tileModes: typeof DeliveryPlanningTileModes = DeliveryPlanningTileModes;
+  public deliveryPlanningViewModes: typeof DeliveryPlanningViewModes = DeliveryPlanningViewModes;
+
+  public availability: { transportDay: PlanningTransportWeekDay, available: boolean }[] = [];
+
+  public planningPopupRef: DeliveryPlanningOverviewPopupComponent;
+
+  public available: boolean = false;
+  public showNoteDialog: boolean = false;
+  public showSettingsDialog: boolean = false;
+  public tilesQueryList: QueryList<DeliveryPlanningOverviewTileComponent>;
+  public selectedTransportDay: PlanningTransportWeekDay;
+
+  private _subs: Subscription[] = [];
+
+  @ViewChildren(DeliveryPlanningOverviewTileComponent)
+  public set tiles(tiles: QueryList<DeliveryPlanningOverviewTileComponent>) {
+    this.tilesQueryList = tiles;
+    if (this.deliveryPlanningService.viewMode === DeliveryPlanningViewModes.Sidebar) {
+      tiles?.forEach(tile => {
+        if (!tile.expanded) {
+          tile.expanded = true;
+        }
+      });
+    }
+  };
+
+  @ViewChild('rowContainer') rowContainer: HTMLDivElement;
+  @ViewChild('columnElem') columnElem: HTMLDivElement;
+
+  //public columnNum = 3; //initial count
+
+  @ViewChild('planningPopup')
+  public set planningPopupComponent(value: DeliveryPlanningOverviewPopupComponent) {
+    this.planningPopupRef = value;
+  };
+
+  @Input()
+  public get employeeView(): boolean {
+    return this.deliveryPlanningService.employeeView;
+  }
+
+  @Input()
+  public currentMode: DeliveryPlanningCalendarModes = DeliveryPlanningCalendarModes.Week;
+
+  @Input()
+  public currentViewMode: CalendarView = CalendarView.ThreeDaysView;
+
+  @Input()
+  public currentPlanningViewMode: DeliveryPlanningViewModes = this.deliveryPlanningViewModes.Fullscreen;
+
+  @Output()
+  public updatePlanningTransportEvent: EventEmitter<{
+    oldWeek: PlanningTransportWeekDay[],
+    oldWeekTransportId: number,
+    week: PlanningTransportWeekDay[],
+    action: DeliveryPlanningUpdateActions,
+    resolve?: () => void
+  }> = new EventEmitter<{
+    oldWeek: PlanningTransportWeekDay[],
+    oldWeekTransportId: number,
+    week: PlanningTransportWeekDay[],
+    action: DeliveryPlanningUpdateActions,
+    resolve?: () => void
+  }>();
+
+  @Output()
+  public resetPlanningTransportEvent: EventEmitter<void> = new EventEmitter<void>();
+
+  public get planTransportWeekArr() {
+    return this.deliveryPlanningService.planTransportWeekArr;
+  }
+
+  public get currentTileMode() {
+    return this.deliveryPlanningService.currentTileMode;
+  }
+
+  public set currentTileMode(tileMode: DeliveryPlanningTileModes) {
+    this.deliveryPlanningService.currentTileMode = tileMode;
+  }
+
+  public get columnNum(): number {
+    if (this.deliveryPlanningService.viewMode === DeliveryPlanningViewModes.Sidebar) {
+      return 1;
+    }
+    switch (this.currentViewMode) {
+      case CalendarView.ThreeDaysView:
+        return 3;
+      case CalendarView.WeekView:
+        return 7;
+      case CalendarView.WeekWorkView:
+        return 5;
+      default:
+        return 3;
+    }
+  }
+
+  public get columnClasses(): Record<string, boolean> {
+    return {
+      'cols-1': this.columnNum === 1,
+      'cols-3': this.columnNum === 3,
+      'cols-5': this.columnNum === 5,
+      'cols-7': this.columnNum === 7
+    };
+  }
+
+  public currentDate(): Date {
+    return this.deliveryPlanningService.currentStartDate;
+  }
+
+  constructor(
+    public deliveryPlanningService: DeliveryPlanningService,
+    private _transaction: TransactionService,
+    private _transactionCon: TransactionConnectorService,
+    private _dialog: TransactionDialogService,
+    private _changeDetector: ChangeDetectorRef,
+    private _dictionary: DictionaryService,
+    public iconCacheService: IconCacheService,
+    public transactionEventService: TransactionEventService
+  ) {
+  }
+
+  ngOnInit(): void {
+    this._subs.push(this.deliveryPlanningService.availabilityResetEvent.subscribe(event => {
+      this.availability = [];
+      this._changeDetector.markForCheck();
+      this._changeDetector.detectChanges();
+    }));
+    this._transaction.getInternalParameter(InternalParam.PlanRayon).then((result: boolean) => {
+      this.deliveryPlanningService.planRayon = result;
+    });
+  }
+
+  ngOnDestroy(): void {
+    this._subs.forEach((sub: Subscription) => {
+      sub.unsubscribe();
+    });
+  }
+
+  @HostBinding('class.co-delivery-planning-overview')
+  public showClass() {
+    return true;
+  }
+
+  //recalculating upon browser window resize
+  @HostListener('window:resize', ['$event'])
+  onResize(event: MouseEvent) {
+    //this.setColNum();
+  }
+
+  public async dropped(ev: DragEvent, week: PlanningTransportWeekDay[], transportDay: PlanningTransportWeekDay, transportDays: PlanningTransportWeekDay[]) {
+    ev.preventDefault();
+    ev.stopPropagation();
+    if (this.employeeView) {
+      await this._dialog.showError(this._dictionary.get('CAN_NOT_PLAN_IN_EMPLOYEE_VIEW'), true);
+      return;
+    }
+
+    this.deliveryPlanningService.dragging = false;
+
+    if (this.checkAvailable(transportDay)) {
+      await this._dialog.showError(this._dictionary.get('ORDER_CAN_NOT_BE_PLANNED_ON_RESOURCE'), true);
+    } else {
+      const data = ev.dataTransfer.getData('text');
+      let index = transportDays.indexOf(transportDay);
+      let tile = this.tilesQueryList.get(index);
+      if (!tile.expanded) {
+        tile.expanded = true;
+      }
+      if (data != 'lines' && !this.deliveryPlanningService.movingTransId) {
+        if (data && parseInt(data)) {
+          const planOrder = await this._transactionCon.getPlanOrder(parseInt(data));
+          if (planOrder.lines.length <= 0) {
+            await this._dialog.showError(this._dictionary.get('NO_LINES_TO_PLAN'), true);
+            return;
+          }
+          if (transportDay?.plannedOrders?.length && transportDay?.plannedOrders?.indexOf(planOrder) !== -1) {
+            await this._dialog.showError(this._dictionary.get('ORDER_HAS_ALREADY_BEEN_PLANNED'), true);
+          } else {
+            if (planOrder) {
+              this.openPlanningPopup(planOrder, transportDay, week);
+            }
+          }
+        }
+      } else if (data != 'lines' && this.deliveryPlanningService.movingTransId) {
+        ev.stopPropagation();
+        await this.handleMoveNormalEvent(data, transportDay, week, this.planTransportWeekArr);
+      } else {
+        await this.planSelectedLines(transportDay, week);
+      }
+
+    }
+
+  }
+
+  public allowDrop(ev: DragEvent, transportDay: PlanningTransportWeekDay) {
+    ev.preventDefault();
+    if (this.deliveryPlanningService.dragging && transportDay.maxMinutes > 0 && transportDay.availableOnDate) {
+      return transportDay.minutes + transportDay.minutes < transportDay.maxMinutes && transportDay.maxOrderAmount < transportDay.orderAmount && transportDay.availableOnDate && this.checkAvailable(transportDay) && !this.employeeView;
+    }
+  }
+
+  public dragEnd(ev: DragEvent) {
+    ev.preventDefault();
+    this.deliveryPlanningService.dragging = false;
+  }
+
+  public filterWeekArray(weekArray: PlanningTransportWeekDay[]) {
+    return weekArray.slice(0, this.columnNum);
+  }
+
+  public handleDateRangeChange(newDate: Date) {
+    this.deliveryPlanningService.currentStartDate = newDate;
+    this.resetPlanningTransportEvent.emit();
+  }
+
+  public onChangeView(view: CalendarView): void {
+    this.currentViewMode = view;
+    this.resetPlanningTransportEvent.emit();
+  }
+
+  public async handleDeleteOrder(deleteResult: { order: PlanOrder, transport: PlanningTransportWeekDay }, planningTransportWeek: PlanningTransportWeekDay[]) {
+    const oldWeek: PlanningTransportWeekDay[] = structuredClone(planningTransportWeek)
+    const oldWeekTransportId: number = parseInt(oldWeek[oldWeek.length -1].toString());
+    let order = deleteResult.order;
+    if (order) {
+      if (deleteResult.order.lines.length > 0 || deleteResult.order.tasks?.length > 0) {
+        this.deliveryPlanningService.deletingOrder = order;
+        deleteResult.transport.plannedOrders.splice(deleteResult.transport.plannedOrders.indexOf(order), 1);
+        this.updatePlanningTransportEvent.emit({
+          oldWeek: oldWeek,
+          oldWeekTransportId: oldWeekTransportId,
+          week: planningTransportWeek,
+          action: DeliveryPlanningUpdateActions.DeletePlannedOrder
+        });
+      } else {
+        await this._dialog.showError('NO_LINES_TO_DELETE', true);
+      }
+    }
+  }
+
+  public handleDeleteLine(deleteResult: {
+    order: PlanOrder,
+    line: PlanOrderLine
+  }, weekDay: PlanningTransportWeekDay, transportWeekRow: PlanningTransportWeekDay[]) {
+    let oldWeek: PlanningTransportWeekDay[] =  structuredClone(transportWeekRow)
+    const oldWeekTransportId: number = parseInt(oldWeek[oldWeek.length -1].toString());
+
+    let order = weekDay.plannedOrders.find(order => order.transId === deleteResult.order.transId);
+    order.lines = order.lines.filter(line => line.originalLineNr !== deleteResult.line.originalLineNr);
+    if (order.lines.length === 0) {
+      weekDay.plannedOrders.splice(weekDay.plannedOrders.indexOf(order), 1);
+    }
+    this.deliveryPlanningService.deletingOrder = order;
+    this.updatePlanningTransportEvent.emit({
+      oldWeek: oldWeek,
+      oldWeekTransportId: oldWeekTransportId,
+      week: transportWeekRow,
+      action: DeliveryPlanningUpdateActions.DeletePlannedLines
+    });
+  }
+
+  public async getOrderLinesPlanned(order: PlanOrder): Promise<void> {
+    let request: OrderLinesPlannedRequest = new OrderLinesPlannedRequest();
+    let filterObj: PlanningFilterObject = new PlanningFilterObject();
+    request.planned = true;
+    request.planningId = this.deliveryPlanningService.currentPlanning.planningId;
+    request.transId = order.transId;
+    request.plannedLineId = order.plannedLineId;
+    filterObj.onlyCurrentWeek = true;
+    filterObj.beginCurrentWeek = new Date();
+    filterObj.checkOrderLines = 1;
+    request.filterObject = filterObj;
+    if (!order.lines) {
+      order.lines = [];
+    }
+    order.lines.push(...await this._transactionCon.getOrderLinesPlanned(request));
+  }
+
+  public async getTransportOrders(transportDay: PlanningTransportWeekDay): Promise<void> {
+    let request: GetTransportOrdersRequest = new GetTransportOrdersRequest();
+    request.planningId = this.deliveryPlanningService.currentPlanning.planningId;
+    request.date = transportDay.date;
+    request.transportId = transportDay.transport.transportId;
+    transportDay.plannedOrders = await this._transactionCon.getTransportOrders(request);
+    transportDay.ordersLoaded = true;
+
+  }
+
+  public async planOrderLines(order: PlanOrder, transportDay: PlanningTransportWeekDay, week: PlanningTransportWeekDay[]): Promise<void> {
+    let oldWeek: PlanningTransportWeekDay[] =  structuredClone(week)
+    const oldWeekTransportId: number = parseInt(oldWeek[oldWeek.length -1].toString());
+    if (order.lines?.length > 0) {
+      order.linesLoaded = true;
+      order.tasks = [];
+      order.tasksLoaded = true;
+      order.lines.forEach(line => {
+        line.selected = true;
+        if (!line.amountToPlan || line.amountToPlan === 0) {
+          line.amountToPlan = (line.amountInOrder - line.amountPlanned);
+        }
+      });
+      if (!transportDay.plannedOrders) {
+        transportDay.plannedOrders = [order];
+      } else {
+        if (!transportDay.plannedOrders.find((plannedOrder: PlanOrder) => plannedOrder.transId === order.transId)) {
+          transportDay.plannedOrders.push(order);
+        } else {
+          let plannedOrder: PlanOrder = transportDay.plannedOrders.find((plannedOrder: PlanOrder) => plannedOrder.transId === order.transId);
+          if (order.startTime !== transportDay.plannedOrders.find((plannedOrder: PlanOrder) => plannedOrder.transId === order.transId).startTime) {
+
+            if (!order.partDelivery) {
+              transportDay.plannedOrders.splice(transportDay.plannedOrders.indexOf(plannedOrder), 1);
+              transportDay.plannedOrders.push(order);
+            } else {
+              transportDay.plannedOrders.push(order);
+            }
+          } else {
+            transportDay.plannedOrders.splice(transportDay.plannedOrders.indexOf(transportDay.plannedOrders.find((plannedOrder: PlanOrder) => plannedOrder.transId === order.transId)), 1);
+            transportDay.plannedOrders.push(order);
+          }
+        }
+      }
+      this.updatePlanningTransportEvent.emit({
+        oldWeek: oldWeek,
+        oldWeekTransportId: oldWeekTransportId,
+        week: week,
+        action: DeliveryPlanningUpdateActions.PlanLines
+      });
+    } else {
+      await this._dialog.showError('NO_LINES_TO_PLAN', true);
+    }
+  }
+
+  public async planSelectedLines(transportDay: PlanningTransportWeekDay, week: PlanningTransportWeekDay[]): Promise<void> {
+
+    let planOrder = await this._transactionCon.getPlanOrder(this._transaction.currentTransaction.transactionInfo.id);
+    await this.getSequenceOrderValue(planOrder);
+    await this.getOrderLinesPlanned(planOrder);
+
+    if (planOrder.partDelivery) {
+
+      let selectedLines: TransactionLineInfo[] = this._transaction.currentTransaction.transactionLines.filter((transLines: TransactionLineInfo) => transLines.selected);
+
+      //Does the order already exist?
+      if (transportDay?.plannedOrders?.find(order => order.transId === planOrder.transId)) {
+        //Yes the order exists
+
+        //If the line(s) we're trying to plan already are planned we need to validate if we need to plan anyway
+        let cantPlanSelectedLines: PlanOrderLine[] = [];
+        if (selectedLines.length > 0) {
+          transportDay.plannedOrders.find((plannedOrder: PlanOrder) => plannedOrder.transId === planOrder.transId).lines.forEach((plannedLine: PlanOrderLine) => {
+            if (selectedLines.find((selectedLine: TransactionLineInfo) => selectedLine.lineNr === plannedLine.originalLineNr)) {
+              cantPlanSelectedLines.push(plannedLine);
+            }
+          });
+
+          if (cantPlanSelectedLines.length === planOrder.lines.length) {
+            await this._dialog.showError('NO_LINES_TO_PLAN', true);
+            return;
+          }
+        } else {
+          await this._dialog.showError('NO_LINES_SELECTED', true);
+          return;
+        }
+
+        let plannedOrder: PlanOrder = transportDay.plannedOrders.find((plannedOrder: PlanOrder) => plannedOrder.transId === planOrder.transId);
+
+        //All lines that need to be planned for an order are in planOrder now
+        //Which means that we just filter the lines out that DON'T match a selected line AND are planned
+        planOrder.lines.filter(
+          (toPlanLine: PlanOrderLine) => !plannedOrder.lines.find((plannedOrderLine: PlanOrderLine) => plannedOrderLine.originalLineNr === toPlanLine.originalLineNr)
+            && !selectedLines.find((selectedLine: TransactionLineInfo) => selectedLine.lineNr === toPlanLine.originalLineNr));
+      } else {
+        //Order does not exist, lets prepare it with the selected lines
+        //Filter the lines for only the selected ones
+        planOrder.lines = planOrder.lines.filter(plannedOrderLine => selectedLines.find((selectedLine: TransactionLineInfo) => plannedOrderLine.originalLineNr === selectedLine.lineNr));
+      }
+
+    }
+
+    planOrder.lines.forEach((line: PlanOrderLine, index: number) => {
+      let matchedTransLine: TransactionLineInfo = this._transaction.currentTransaction.transactionLines.find(transLine => transLine.lineNr === line.originalLineNr);
+      if (matchedTransLine) {
+        line.amountToPlan = matchedTransLine.amountSelected;
+      }
+    });
+    //Send the prepared order to the
+    this.openPlanningPopup(planOrder, transportDay, week);
+
+  }
+
+  public async getSequenceOrderValue(order: PlanOrder): Promise<void> {
+    order.plannedLineId = await this.deliveryPlanningService.getOrderSequenceValue();
+    order.chained = false;
+  }
+
+  public async handlePopupPlanEvent(event: [PlanOrder, PlanningTransportWeekDay, PlanningTransportWeekDay[]]) {
+
+    this.showNoteDialog = false;
+    await this.getTransportOrders(event[1]);
+    await this.getSequenceOrderValue(event[0]);
+    await this.getOrderLinesPlanned(event[0]);
+    await this.planOrderLines(event[0], event[1], event[2]);
+  }
+
+  public handleSettingsReset() {
+    this.deliveryPlanningService.getPlanningTransportWeek();
+    this.showSettingsDialog = false;
+  }
+
+  public async handleSettingsSaved(): Promise<void> {
+    const week: PlanningTransportWeekDay[] | undefined = this.planTransportWeekArr.find(
+      (week: PlanningTransportWeekDay[]) => week.some(
+        (weekDay: PlanningTransportWeekDay) => weekDay === this.selectedTransportDay
+      )
+    );
+
+    const oldWeekTransportId: number = parseInt(week[week.length -1].toString());
+
+    if (week) {
+      await new Promise<void>((resolve: () => void) => {
+        this.updatePlanningTransportEvent.emit({
+          oldWeek: week,
+          oldWeekTransportId: oldWeekTransportId,
+          week: week,
+          action: DeliveryPlanningUpdateActions.DeleteOrderReplan,
+          resolve: (): void => {
+            this.showSettingsDialog = false;
+            resolve();
+          }
+        });
+      });
+    }
+  }
+
+  public openSettingsDialog(transportDay: PlanningTransportWeekDay) {
+    this.selectedTransportDay = transportDay;
+    if (this.selectedTransportDay) {
+      this.showSettingsDialog = true;
+    }
+  }
+
+  public async handleCalendarPlanEvent(data: {
+    currentHour: string,
+    data: string
+  }, transportWeekDay: PlanningTransportWeekDay, week: PlanningTransportWeekDay[]) {
+    let planOrder: PlanOrder;
+    if (data.data === 'false' && this.deliveryPlanningService.currentTransId) {
+      planOrder = await this._transactionCon.getPlanOrder(this.deliveryPlanningService?.currentTransId);
+    } else {
+      planOrder = await this._transactionCon.getPlanOrder(parseInt(data.data));
+    }
+
+    if (transportWeekDay?.plannedOrders?.find((plannedOrder: PlanOrder) => plannedOrder.transId === planOrder.transId)) {
+      await this._dialog.showError(this._dictionary.get('ORDER_HAS_ALREADY_BEEN_PLANNED'), true);
+      return;
+    }
+
+    if (planOrder && data.currentHour) {
+
+      planOrder.startTime = this.calculateStartTime(transportWeekDay, data.currentHour);
+      planOrder.endTime = this.calculateEndTime(planOrder.startTime, data.currentHour, planOrder);
+
+      await this.getTransportOrders(transportWeekDay);
+      await this.getSequenceOrderValue(planOrder);
+      await this.getOrderLinesPlanned(planOrder);
+      await this.planOrderLines(planOrder, transportWeekDay, week);
+      if (data.data === 'false' && this._transaction.currentTransaction.transactionInfo.uuid) {
+        await this._transaction.getTransactionById(this.deliveryPlanningService.currentTransId);
+        await this._transaction.saveTransaction();
+        await this._transaction.checkRefTransaction();
+      }
+    }
+  }
+
+  public calculateStartTime(transportWeekDay: PlanningTransportWeekDay, currentHour: string): Date {
+    let startDate: Date = new Date(transportWeekDay.date);
+    let startTime: number = parseInt(currentHour.split(':')[0]);
+    startDate.setHours(startTime);
+    startDate.setMinutes(parseInt(currentHour.split(':')[1]) > 0 ? parseInt(currentHour.split(':')[1]) : 0);
+    startDate.setSeconds(0);
+
+    return startDate;
+  }
+
+  public calculateEndTime(startDate: Date, currentHour: string, planOrder: PlanOrder): Date {
+    let endTime: Date = new Date(startDate);
+
+    let splitHour = currentHour.split(':');
+    const newEndMinutes = splitHour[1] === '00' ? 30 : 0;
+    const newEndHour = splitHour[1] === '30' ? (parseInt(splitHour[0]) + 1) : parseInt(splitHour[0]);
+    endTime.setHours(newEndHour);
+    endTime.setMinutes(newEndMinutes);
+    let assemblyTime = this.deliveryPlanningService.totalAssemblyTime(planOrder) * 60 * 1000;
+    endTime.setTime(endTime.getTime() + assemblyTime);
+
+    return endTime;
+  }
+
+  public openPlanningPopup(planOrder: PlanOrder, transportDay: PlanningTransportWeekDay, week: PlanningTransportWeekDay[]) {
+    this.showNoteDialog = true;
+    this._changeDetector.markForCheck();
+    this._changeDetector.detectChanges();
+    if (this.planningPopupRef) {
+      this.planningPopupRef.setPlanOrder = planOrder;
+      this.planningPopupRef.transportDay = transportDay;
+      this.planningPopupRef.week = week;
+    }
+  }
+
+  public handleAvailabilityChecked(value: { transportDay: PlanningTransportWeekDay, available: boolean }) {
+    this.availability.push(value);
+    this._changeDetector.detectChanges();
+  }
+
+  public checkAvailable(transportDay: PlanningTransportWeekDay) {
+    let transport = this.availability.find(transportObject => transportObject.transportDay === transportDay);
+    return transport && !transport.available;
+  }
+
+  public handleTimeChangeEvent(transportDay: PlanningTransportWeekDay, week: PlanningTransportWeekDay[], obj: PlanOrder) {
+    let oldWeek: PlanningTransportWeekDay[] =  structuredClone(week)
+    const oldWeekTransportId: number = parseInt(oldWeek[oldWeek.length -1].toString());
+    let order: PlanOrder = transportDay.plannedOrders.find(planOrder => planOrder.transId === obj.transId);
+    order.startTime = new Date(obj['startTime']);
+    order.endTime = new Date(obj['endTime']);
+
+    this.updatePlanningTransportEvent.emit({oldWeek: oldWeek, oldWeekTransportId: oldWeekTransportId, week: week, action: this.planningActions.PlanOrder});
+  }
+
+  public async handleMoveEvent(moveData: {
+    hour: string,
+    scheduledObject: Object
+  }, transport: PlanningTransportWeekDay, week: PlanningTransportWeekDay[], weekArr: PlanningTransportWeekDay[][]) {
+    let planOrder: PlanOrder = await this._transactionCon.getPlanOrder(moveData.scheduledObject['id']);
+
+    let oldWeekWithOrder: PlanningTransportWeekDay[] = [];
+    let weekWithOrder: PlanningTransportWeekDay[] = [];
+    const oldWeekTransportId: number = parseInt(oldWeekWithOrder[oldWeekWithOrder.length -1].toString());
+
+    //remove from old transport
+    weekArr.forEach(((row: PlanningTransportWeekDay[]) => {
+      row.forEach((weekDay: PlanningTransportWeekDay) => {
+        if (!weekDay || !Array.isArray(weekDay.plannedOrders)) {
+          return;
+        }
+        row.forEach(val => oldWeekWithOrder.push(Object.assign({}, val)));
+        const i = weekDay.plannedOrders.findIndex(o => o.transId === planOrder.transId);
+        if (i > -1) {
+          weekDay.plannedOrders.splice(i, 1);
+        }
+        weekWithOrder = row;
+      });
+    }));
+
+    this.deliveryPlanningService.deletingOrder = planOrder;
+    this.updatePlanningTransportEvent.emit({
+      oldWeek: oldWeekWithOrder,
+      oldWeekTransportId: oldWeekTransportId,
+      week: weekWithOrder,
+      action: DeliveryPlanningUpdateActions.DeletePlannedOrder
+    });
+
+    if (planOrder) {
+      //set new date for order and plan it on new transport
+      let newDate: Date = new Date(transport.date);
+      let splitTime: string[] = moveData.hour.split(':');
+      newDate.setHours(parseInt(splitTime[0]));
+      newDate.setMinutes(parseInt(splitTime[1]));
+      newDate.setSeconds(0);
+      planOrder.startTime = newDate;
+      let endDate = new Date(planOrder.startTime);
+      planOrder.endTime = this.deliveryPlanningService.addMinutes(endDate, moveData.scheduledObject['height']);
+      await this.getTransportOrders(transport);
+      await this.getSequenceOrderValue(planOrder);
+      await this.getOrderLinesPlanned(planOrder);
+      await this.planOrderLines(planOrder, transport, week);
+    }
+  }
+
+  public handleEditPlannedOrder(planOrder: PlanOrder, transportDay: PlanningTransportWeekDay, week: PlanningTransportWeekDay[]) {
+    this.openPlanningPopup(planOrder, transportDay, week);
+  }
+
+  public handleMoveOrderUp(planOrder: PlanOrder, planningTransportWeek: PlanningTransportWeekDay[], transportDay: PlanningTransportWeekDay) {
+    const oldWeek: PlanningTransportWeekDay[] = structuredClone(planningTransportWeek);
+    const oldWeekTransportId: number = parseInt(oldWeek[oldWeek.length -1].toString());
+    this.deliveryPlanningService.reorderItem(transportDay.plannedOrders, planOrder, 'up');
+    this.updatePlanningTransportEvent.emit({oldWeek: oldWeek, oldWeekTransportId: oldWeekTransportId, week: planningTransportWeek, action: DeliveryPlanningUpdateActions.PlanOrder});
+  }
+
+  public handleMoveOrderDown(planOrder: PlanOrder, planningTransportWeek: PlanningTransportWeekDay[], transportDay: PlanningTransportWeekDay) {
+    const oldWeek: PlanningTransportWeekDay[] = structuredClone(planningTransportWeek);
+    const oldWeekTransportId: number = parseInt(oldWeek[oldWeek.length -1].toString());
+    this.deliveryPlanningService.reorderItem(transportDay.plannedOrders, planOrder, 'down');
+    this.updatePlanningTransportEvent.emit({oldWeek: oldWeek, oldWeekTransportId: oldWeekTransportId, week: planningTransportWeek, action: DeliveryPlanningUpdateActions.PlanOrder});
+  }
+
+  public selectTransportDay(transportDay: PlanningTransportWeekDay) {
+
+    transportDay.selected = !transportDay.selected;
+    if (transportDay.selected) {
+      this.tilesQueryList.forEach(tile => {
+        if (tile.transportDay !== transportDay && tile.transportDay.selected) {
+          tile.expanded = false;
+          tile.transportDay.selected = false;
+        }
+      });
+      //fire event selected outwards
+      this.deliveryPlanningService.selectedPlanTransport = transportDay;
+      this.transactionEventService.selectedTransportDay.next(transportDay);
+    } else {
+      this.deliveryPlanningService.selectedPlanTransport = undefined;
+      this.transactionEventService.resetTransportDayFilteredOrders.next();
+
+    }
+  }
+
+  public async handlePlanOrderOnSameTime(order: { start: Date, end: Date, transId: number }, transportWeekDay: PlanningTransportWeekDay, week: PlanningTransportWeekDay[]) {
+    const planOrder: PlanOrder = await this._transactionCon.getPlanOrder(this.deliveryPlanningService.currentTransId);
+    planOrder.startTime = new Date(order.start);
+    planOrder.endTime = new Date(order.end);
+    await this._planCalendar(transportWeekDay, week, planOrder);
+  }
+
+  public async handleMoveNormalEvent(transId: string, transport: PlanningTransportWeekDay, week: PlanningTransportWeekDay[], weekArr: PlanningTransportWeekDay[][]) {
+    let oldPlanOrder: PlanOrder;
+    let oldTransport: PlanningTransportWeekDay;
+    let oldWeek: PlanningTransportWeekDay[];
+
+    //remove from old transport
+    const transactionId: number = parseInt(transId, 10);
+
+    for (const row of weekArr) {
+      for (const weekDay of row) {
+        const orderIndex: number = weekDay?.plannedOrders?.findIndex(order => order.transId === transactionId) ?? -1;
+        if (orderIndex !== -1) {
+          oldPlanOrder = weekDay?.plannedOrders?.find(order => order.transId === transactionId);
+          weekDay.plannedOrders.splice(orderIndex, 1);
+          oldWeek = structuredClone(row);
+          oldTransport = weekDay;
+
+          break;
+        }
+      }
+
+      if (oldTransport) {
+        break;
+      }
+    }
+
+    await this.deliveryPlanningService.syncPlanOrderTimesWithTransportDate(oldPlanOrder, transport);
+
+    if(oldWeek[oldWeek.length - 1] !== week[week.length - 1]) {
+      await this.handleDeleteOrder({order: oldPlanOrder, transport: oldTransport}, oldWeek);
+      await this.handlePopupPlanEvent([oldPlanOrder, transport, week]);
+    } else {
+      await this.handlePopupPlanEvent([oldPlanOrder, transport, week]);
+    }
+  }
+
+  public handleReorderOrder(
+    event: { transId: number, insertIndex: number },
+    planningTransportWeek: PlanningTransportWeekDay[],
+    transportDay: PlanningTransportWeekDay
+  ): void {
+    if (!event || !event.transId || !transportDay?.plannedOrders || transportDay.plannedOrders.length <= 1) {
+      return;
+    }
+
+    const oldWeek: PlanningTransportWeekDay[] = structuredClone(planningTransportWeek);
+    const oldWeekTransportId: number = parseInt(oldWeek[oldWeek.length -1].toString());
+
+    const orders: PlanOrder[] = transportDay.plannedOrders;
+    const fromIndex: number = orders.findIndex((o: PlanOrder) => o.transId === event.transId);
+    if (fromIndex === -1) {
+      return;
+    }
+
+    //Get to 'to index'
+    let toIndex: number = Math.max(0, Math.min(event.insertIndex, orders.length));
+
+    //Get to other index if not the same
+    if (fromIndex < toIndex) {
+      toIndex = toIndex - 1;
+    }
+
+    //Error handling
+    if (toIndex === fromIndex) {
+      return;
+    }
+
+    //Handle moving logic
+    const steps: number = Math.abs(toIndex - fromIndex);
+    const direction: 'up' | 'down' = toIndex > fromIndex ? 'down' : 'up';
+
+    const movingOrder: PlanOrder = orders[fromIndex];
+    for (let i: number = 0; i < steps; i++) {
+      this.deliveryPlanningService.reorderItem(orders, movingOrder, direction);
+    }
+
+    this.deliveryPlanningService.movingTransId = undefined as any; // or 0/null depending on typing
+    this.deliveryPlanningService.dragging = false;
+
+    this.updatePlanningTransportEvent.emit({
+      oldWeek: oldWeek,
+      oldWeekTransportId: oldWeekTransportId ,
+      week: planningTransportWeek,
+      action: DeliveryPlanningUpdateActions.PlanOrder
+    });
+  }
+
+  private async _planCalendar(transportWeekDay: PlanningTransportWeekDay, week: PlanningTransportWeekDay[], planOrder: PlanOrder) {
+    await this.getTransportOrders(transportWeekDay);
+    await this.getSequenceOrderValue(planOrder);
+    await this.getOrderLinesPlanned(planOrder);
+    await this.planOrderLines(planOrder, transportWeekDay, week);
+    if (this._transaction.currentTransaction.transactionInfo.uuid) {
+      await this._transaction.getTransactionById(this.deliveryPlanningService.currentTransId);
+      await this._transaction.saveTransaction();
+      await this._transaction.checkRefTransaction();
+    }
+  }
+}