@cwellt_software/cwellt-reactjs-lib 1.2.13 → 1.2.14

package/dist/src/components/custom/scheduler-temporal/components/time_headers/TimeHeader.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getFormattedTimeForHeader } from "../../logic/dates/getFormatedTimeForHeader";
+import { calculateDivisions } from "../../logic/divisions/calculateDivisions";
+import { calculateDivisionType } from "../../logic/divisions/calculateDivisionType";
+export const TimeHeader = ({ isWeekend, index, text, width, header }) => {
+    if (text === "") {
+        return;
+    }
+    const commonStyles = {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "left",
+        fontSize: "10px",
+        width: width,
+        maxWidth: width,
+        height: "2rem",
+        borderLeft: "1px solid white",
+        background: isWeekend ? "#cbc9c9" : "",
+        color: "#000000d9",
+        fontWeight: 700,
+    };
+    return (_jsx("td", { style: commonStyles, id: `${header}Time${index}`, children: _jsx("span", { style: { paddingLeft: "8px" }, children: text }) }, `t${index}`));
+};
+export const _preview = () => {
+    const startDate = new Date();
+    const endDate = new Date();
+    const calculatedDivision = calculateDivisions(startDate, endDate);
+    const calculatedDivType = calculateDivisionType(startDate, endDate);
+    const data = getFormattedTimeForHeader(calculatedDivType, calculatedDivision, startDate);
+    return _jsx(TimeHeader, { isWeekend: false, index: 1, text: data.text, width: 30, header: "test" });
+};

package/dist/src/components/custom/scheduler-temporal/components/time_headers/TimeHeaderRow.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getFormattedTimeForHeader } from "../../logic/dates/getFormatedTimeForHeader";
+import { calculateDivisions } from "../../logic/divisions/calculateDivisions";
+import { calculateDivisionType } from "../../logic/divisions/calculateDivisionType";
+import { TimeHeader } from "./TimeHeader";
+export const TimeHeaderRow = ({ timeHeaders, startDate, endDate, maxWidth, header }) => {
+    const calculatedDivision = calculateDivisions(startDate, endDate);
+    const calculatedDivType = calculateDivisionType(startDate, endDate);
+    const formattedHeaders = timeHeaders.map((th) => {
+        return getFormattedTimeForHeader(calculatedDivType, calculatedDivision, th);
+    });
+    const filteredHeaders = formattedHeaders.filter((element) => element.text !== "");
+    return (_jsx("tr", { className: "cwelltSchRowTime", style: { height: "30px" }, children: filteredHeaders.map(({ text, isWeekend }, index) => {
+            return (_jsx(TimeHeader, { isWeekend: isWeekend, index: index, text: text, width: maxWidth / filteredHeaders.length, header: header }, index));
+        }) }));
+};

package/dist/src/components/custom/scheduler-temporal/components/time_line/TimeLine.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Tooltip } from "antd";
+export const TimeLine = ({ id, toolTipTitle, marginLeft, color = "rgba(255,0,0,.6)", pixels = 2, height = "100%", zIndex = 1, }) => {
+    return (_jsx(Tooltip, { title: toolTipTitle, children: _jsx("div", { id: id, style: {
+                borderLeft: `${pixels}px solid ${color}`,
+                marginLeft: marginLeft,
+                width: "0px",
+                height: height,
+                position: "absolute",
+                zIndex: zIndex,
+            } }) }));
+};

package/dist/src/components/custom/scheduler-temporal/logic/dates/addMinutesToDateFromPx.js

@@ -0,0 +1,5 @@
+export const addMinutesToDateFromPx = (originalDate, leftPx, minutesPerPx) => {
+    const minutes = leftPx / minutesPerPx;
+    const datePlusMinutes = new Date(originalDate.getTime() + minutes * 60000);
+    return datePlusMinutes;
+};

package/dist/src/components/custom/scheduler-temporal/logic/dates/daysBetweenTwoDates.js

@@ -0,0 +1,15 @@
+export const daysBetweenTwoDates = (date1, date2) => {
+    const diff = Math.abs(date1.getTime() - date2.getTime());
+    let diffDays = 0;
+    const startOffset = Math.abs(date1.getTimezoneOffset());
+    const endOffset = Math.abs(date2.getTimezoneOffset());
+    // Summer: +1 -> +2, true
+    // Winter: +2 -> -1, false
+    if (startOffset > endOffset) {
+        diffDays = Math.floor(diff / (1000 * 3600 * 24));
+    }
+    else {
+        diffDays = Math.ceil(diff / (1000 * 3600 * 24));
+    }
+    return diffDays;
+};

package/dist/src/components/custom/scheduler-temporal/logic/dates/daysBetweenTwoDatesWithoutCeil.js

@@ -0,0 +1,5 @@
+export const daysBetweenTwoDatesIncludingBoth = (date1, date2) => {
+    const diff = Math.abs(date1.getTime() - date2.getTime());
+    const diffDays = diff / (1000 * 3600 * 24);
+    return diffDays;
+};

package/dist/src/components/custom/scheduler-temporal/logic/dates/getFormatedTimeForHeader.js

@@ -0,0 +1,43 @@
+import moment from "moment";
+export const getFormattedTimeForHeader = (calculatedDivType, calculatedDivision, timeHeader) => {
+    let showDate = "";
+    switch (calculatedDivType) {
+        case "d":
+            switch (calculatedDivision) {
+                case 8:
+                    showDate =
+                        timeHeader.getHours() === 0 ||
+                            timeHeader.getHours() === 3 ||
+                            timeHeader.getHours() === 6 ||
+                            timeHeader.getHours() === 9 ||
+                            timeHeader.getHours() === 12 ||
+                            timeHeader.getHours() === 15 ||
+                            timeHeader.getHours() === 18 ||
+                            timeHeader.getHours() === 21
+                            ? moment(timeHeader).format("HH:mm")
+                            : "";
+                    break;
+                case 3:
+                    showDate =
+                        timeHeader.getHours() === 0 || timeHeader.getHours() === 8 || timeHeader.getHours() === 16
+                            ? moment(timeHeader).format("HH:mm")
+                            : "";
+                    break;
+                case 2:
+                    showDate =
+                        timeHeader.getHours() === 0 || timeHeader.getHours() === 12 ? moment(timeHeader).format("HH:mm") : "";
+                    break;
+            }
+            break;
+        case "m":
+            showDate = timeHeader.getHours() === 0 ? timeHeader.getDate().toString() : "";
+            break;
+        case "w":
+            showDate = timeHeader.getHours() === 0 ? timeHeader.getDate().toString() : "";
+            break;
+    }
+    return {
+        text: showDate,
+        isWeekend: timeHeader.getDay() === 6 || timeHeader.getDay() === 0,
+    };
+};

package/dist/src/components/custom/scheduler-temporal/logic/dates/getMonthHeaderData.js

@@ -0,0 +1,35 @@
+export const getMonthHeaderData = (dates, maxWidth) => {
+    if (dates.length === 0)
+        return [];
+    const dayWidth = maxWidth / dates.length;
+    const ranges = getMonthRanges(dates);
+    return ranges.map((range) => {
+        return {
+            monthFormatted: range.start.getMonth() + 1 + "." + range.start.getFullYear(),
+            width: dayWidth * range.daysLong,
+        };
+    });
+};
+const getMonthRanges = (dates) => {
+    const firstDay = dates[0];
+    const lastDay = dates[dates.length - 1];
+    let currentDate = new Date(firstDay);
+    const ranges = [];
+    while (currentDate <= lastDay) {
+        const rangeStart = new Date(currentDate);
+        let rangeEnd = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0);
+        if (rangeEnd >= lastDay) {
+            rangeEnd = lastDay;
+        }
+        ranges.push({
+            start: rangeStart,
+            daysLong: getDaysBetweenDates(rangeStart, rangeEnd),
+        });
+        currentDate = new Date(rangeEnd.getFullYear(), rangeEnd.getMonth() + 1, 1);
+    }
+    return ranges;
+};
+const getDaysBetweenDates = (startDate, endDate) => {
+    const timeDifference = endDate.getTime() - startDate.getTime();
+    return Math.floor(timeDifference / (1000 * 60 * 60 * 24)) + 1;
+};

package/dist/src/components/custom/scheduler-temporal/logic/dates/getUtcToday.js

@@ -0,0 +1,6 @@
+export const getUtcToday = () => {
+    const now = new Date();
+    const userTimezoneOffset = now.getTimezoneOffset() * 60000;
+    const nowUtc = new Date(now.getTime() + userTimezoneOffset);
+    return nowUtc;
+};

package/dist/src/components/custom/scheduler-temporal/logic/dates/getWeekHeaderDataFromWeekRange.js

@@ -0,0 +1,20 @@
+export const getWeekHeaderDataFromWeekRange = (weekRange, maxWidth, dateFormatter) => weekRange.map(week => {
+    const numberOfDaysInScheduler = weekRange
+        .flatMap(element => {
+        return element.days;
+    })
+        .reduce((el1, el2) => {
+        return el1 + el2;
+    });
+    return {
+        formattedString: getStringForWeekRange(week, dateFormatter),
+        width: getWidthForWeekRange(maxWidth, week.days, numberOfDaysInScheduler)
+    };
+});
+const getStringForWeekRange = (weekRange, dateFormatter) => weekRange.days == 1
+    ? dateFormatter(weekRange.start)
+    : `${dateFormatter(weekRange.start)} - ${dateFormatter(weekRange.end)}`;
+const getWidthForWeekRange = (maxWidth, weekDays, monthDays) => {
+    const dayWidth = maxWidth / monthDays;
+    return dayWidth * weekDays;
+};

package/dist/src/components/custom/scheduler-temporal/logic/dates/listOfDatesToWeeks.js

@@ -0,0 +1,55 @@
+// stringRange: `${formatter(date)} - ${formatter(end)}`,
+export const listOfDatesToWeekRangeList = (dates) => {
+    if (dates.length === 0) {
+        return [];
+    }
+    const datesToReturn = [];
+    dates.forEach((date, index) => {
+        const dayOfWeek = date.getDay();
+        const isFirstDay = index === 0;
+        const isLastDay = index === dates.length - 1;
+        const isSunday = dayOfWeek === 0;
+        const isMonday = dayOfWeek === 1;
+        if (isFirstDay && !isSunday) {
+            datesToReturn.push(createWeekRange(date, 8 - dayOfWeek));
+            return;
+        }
+        if (isLastDay && !isSunday) {
+            if (!isMonday) {
+                datesToReturn.pop();
+            }
+            const firstOfWeek = getFirstDayOfWeek(date);
+            datesToReturn.push(createWeekRange(firstOfWeek, dayOfWeek));
+            return;
+        }
+        if (isMonday) {
+            datesToReturn.push(createWeekRange(date, 7));
+            return;
+        }
+        // this is because sunday is 0
+        if (isFirstDay && isSunday) {
+            datesToReturn.push(createWeekRange(date, 1));
+            return;
+        }
+    });
+    return datesToReturn;
+};
+const createWeekRange = (start, days) => {
+    const end = new Date(start);
+    end.setDate(end.getDate() + days - 1);
+    return {
+        days,
+        start,
+        end,
+        isShortWeek: days < 7
+    };
+};
+const getFirstDayOfWeek = (date) => {
+    const currentDate = new Date(date);
+    const dayOfWeek = currentDate.getDay();
+    // dayOfWeek 0 == (Sunday)
+    const diffToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+    // Set the date to the first day of the week
+    currentDate.setDate(currentDate.getDate() - diffToMonday);
+    return currentDate;
+};

package/dist/src/components/custom/scheduler-temporal/logic/divisions/calculateDivisionType.js

@@ -0,0 +1,13 @@
+import { daysBetweenTwoDates } from "../dates/daysBetweenTwoDates";
+export const calculateDivisionType = (start, end) => {
+    const diffDays = daysBetweenTwoDates(start, end);
+    if (diffDays <= 15) {
+        return "d";
+    }
+    else if (diffDays <= 30) {
+        return "w";
+    }
+    else {
+        return "m";
+    }
+};

package/dist/src/components/custom/scheduler-temporal/logic/divisions/calculateDivisions.js

@@ -0,0 +1,16 @@
+import { daysBetweenTwoDates } from "../dates/daysBetweenTwoDates";
+export const calculateDivisions = (start, end) => {
+    const diffDays = daysBetweenTwoDates(start, end);
+    if (diffDays <= 3) {
+        return 8;
+    }
+    else if (diffDays < 8) {
+        return 3;
+    }
+    else if (diffDays <= 15) {
+        return 2;
+    }
+    else {
+        return 1;
+    }
+};

package/dist/src/components/custom/scheduler-temporal/logic/filtering/filterAndProcessResources.js

@@ -0,0 +1,10 @@
+import { getEventsOfResource } from "../ui/getEventsOfResource";
+import { filterResources } from "./filterResources";
+export const filterAndProcessResources = (props, state) => {
+    const events = [...props.events];
+    const filteredResources = filterResources(props.module, props.resourceName, [...props.resources], props.groupByFunction, props.endDate, props.startDate);
+    return filteredResources.map(r => ({
+        ...r,
+        events: getEventsOfResource(r, events, state, props.id, props.module, props.startDate, props.endDate)
+    }));
+};

package/dist/src/components/custom/scheduler-temporal/logic/filtering/filterEvents.js

@@ -0,0 +1,34 @@
+export const filterEvents = (events, start, end, id, resId, module = undefined) => {
+    const hasSameResourceId = (event) => event.resourceId === resId;
+    const datesCollide = (event) => event.start <= end && event.end >= start;
+    let eventsFiltered = events.filter(event => hasSameResourceId(event) && datesCollide(event));
+    if (id !== "flightWatchScheduler") {
+        eventsFiltered = sortByDate(eventsFiltered);
+    }
+    if (id !== "crewAssignmentsScheduler" && id !== "vacationsScheduler") {
+        return eventsFiltered;
+    }
+    eventsFiltered = setNotFullHeightEventsFirst(eventsFiltered);
+    if (module === "CrewControl") {
+        eventsFiltered = removeDuplicated(eventsFiltered, "Crew_Id");
+    }
+    if (module === "CrewScheduling") {
+        eventsFiltered = removeDuplicated(eventsFiltered, "AssignmentID");
+    }
+    if (module === "CrewSchedulingVacations") {
+        eventsFiltered = removeDuplicated(eventsFiltered, "ID");
+    }
+    return eventsFiltered;
+};
+const sortByDate = (events) => events.sort((a, b) => +new Date(a.start) - +new Date(b.start));
+const removeDuplicated = (events, key) => {
+    return events.filter((obj, index, self) => index === self.findIndex(o => o.data[key] === obj.data[key] && o.data.subject === obj.data.subject));
+};
+const setNotFullHeightEventsFirst = (events) => {
+    const notFullHeight = [];
+    const isFullHeight = [];
+    events.forEach(element => {
+        element.isFullHeight ? notFullHeight.push(element) : isFullHeight.push(element);
+    });
+    return notFullHeight.concat(isFullHeight);
+};

package/dist/src/components/custom/scheduler-temporal/logic/filtering/filterResources.js

@@ -0,0 +1,14 @@
+import moment from "moment";
+import { compareStrings } from "../strings/compareStrings";
+export const filterResources = (module, resourceName, resources, groupByFunction, endDate, startDate) => {
+    if ((module === "CrewControl" || module === "CrewScheduling" || module === "CrewSchedulingVacations") &&
+        resourceName === "Employees") {
+        resources = resources.filter(c => (c.data.Eintritt === null || (c.data.Eintritt !== null && moment(c.data.Eintritt).toDate() <= endDate)) &&
+            (c.data.Austritt === null || (c.data.Austritt !== null && moment(c.data.Austritt).toDate() >= startDate)));
+    }
+    if (module === "CrewScheduling" && resourceName === "Employees") {
+        const sortKey = groupByFunction ? "mainFunction" : "C3_LC";
+        resources = resources.sort((a, b) => compareStrings(a.data[sortKey], b.data[sortKey]));
+    }
+    return resources;
+};

package/dist/src/components/custom/scheduler-temporal/logic/filtering/hasSameProperties.js

@@ -0,0 +1,10 @@
+export const hasSameProperties = (event1, other) => {
+    const areDifferent = event1.resourceId !== other.resourceId ||
+        event1.start !== other.start ||
+        event1.end !== other.end ||
+        event1.selected !== other.selected ||
+        event1.data !== other.data;
+    // TODO: event1.data !== other.data is making a bad compare, we should use
+    // JSON.stringify(this.data) === JSON.stringify(other.data)
+    return !areDifferent;
+};

package/dist/src/components/custom/scheduler-temporal/logic/onDrop/OnDrop.js

@@ -0,0 +1,36 @@
+import { addMinutesToDateFromPx } from "../dates/addMinutesToDateFromPx";
+import { onDropEventToResource } from "../state_handle/onDropEventToResource";
+import { handleOnResize } from "../state_handle/onResizeEvent";
+import { isAllowedToMove } from "../ui/isAllowedToMove";
+export const OnDrop = ({ e, resource, id, contentArea, state, schedulerProps }) => {
+    e.dataTransfer.dropEffect = "move";
+    const cblDragNDrop = JSON.parse(e.dataTransfer.getData("data"));
+    if (!cblDragNDrop.data || !cblDragNDrop.data[0]) {
+        return;
+    }
+    cblDragNDrop.toId = id;
+    const obj = cblDragNDrop.data[0];
+    cblDragNDrop.isCtrlKey = e.ctrlKey;
+    const isResizeEvent = cblDragNDrop.resizeFromStart === true || cblDragNDrop.resizeFromEnd === true;
+    if (isResizeEvent) {
+        // Resize
+        if (obj.data === undefined || obj.data.eventType === 1) {
+            return;
+        }
+        const _eventX = e.clientX;
+        const _caLeft = contentArea?.getBoundingClientRect()?.left ?? 0;
+        const leftPos = _eventX - _caLeft;
+        const datetime = addMinutesToDateFromPx(state.startDate, leftPos, state.minutePx);
+        cblDragNDrop.droppedOnDate = datetime;
+        handleOnResize(schedulerProps, cblDragNDrop);
+        return;
+    }
+    // Drag & Drop
+    if (!isAllowedToMove(obj.data, resource.data, cblDragNDrop)) {
+        return;
+    }
+    const d = e.clientX - (contentArea?.getBoundingClientRect()?.left ?? 0);
+    const date = new Date(state.startDate.getTime() + (d / state.minutePx) * 60000);
+    cblDragNDrop.droppedOnDate = date;
+    onDropEventToResource(schedulerProps, cblDragNDrop, resource);
+};

package/dist/src/components/custom/scheduler-temporal/logic/pixels/getHeightLineScheduler.js

@@ -0,0 +1,14 @@
+export const getHeightLineScheduler = (length, clientHeight, height) => {
+    const noResources = length <= 0;
+    const minResources = length <= 5;
+    if (noResources) {
+        return "100px";
+    }
+    if (minResources) {
+        return clientHeight?.toString();
+    }
+    if (!minResources && clientHeight && clientHeight < height) {
+        return clientHeight?.toString();
+    }
+    return height.toString();
+};

package/dist/src/components/custom/scheduler-temporal/logic/pixels/getPixelsForEvent.js

@@ -0,0 +1,32 @@
+import { daysBetweenTwoDatesIncludingBoth } from "../dates/daysBetweenTwoDatesWithoutCeil";
+export const getLeftPixels = (eventStart, scheduleStart, dayPx) => {
+    if (scheduleStart >= eventStart)
+        return 0;
+    return daysBetweenTwoDatesIncludingBoth(scheduleStart, eventStart) * dayPx;
+};
+export const getResourcesWithPixels = (resources, _nextProps, dayPx) => {
+    return resources.map((resource) => {
+        const events = resource.events;
+        const mappedEvents = events.map((event) => {
+            return getEventWithSize(event, _nextProps.startDate, dayPx);
+        });
+        return {
+            ...resource,
+            events: mappedEvents,
+        };
+    });
+};
+export const getEventWithSize = (event, schedulerStart, dayPx) => {
+    const eventStartBeforeScheduleStart = event.start.getTime() < schedulerStart.getTime();
+    const lengthOfEvent = daysBetweenTwoDatesIncludingBoth(event.start, event.end);
+    const daysUntilSchedulerStart = daysBetweenTwoDatesIncludingBoth(event.start, schedulerStart);
+    const daysLong = eventStartBeforeScheduleStart ? lengthOfEvent - daysUntilSchedulerStart : lengthOfEvent;
+    // we want minimum of 8 px
+    const eventMinSize = 8;
+    const newEvent = {
+        ...event,
+        leftPx: getLeftPixels(event.start, schedulerStart, dayPx),
+        width: Math.max(daysLong * dayPx, eventMinSize),
+    };
+    return newEvent;
+};

package/dist/src/components/custom/scheduler-temporal/logic/pixels/heightScheduler.js

@@ -0,0 +1,14 @@
+export const heightScheduler = (resources, visibleRows, isPinnerScheduler) => {
+    if (resources.length <= 0) {
+        return 100;
+    }
+    const realVisibleRows = visibleRows > resources.length ? resources.length : visibleRows;
+    const rowsHeight = resources.slice(0, realVisibleRows).map((row) => {
+        return row.maxTop;
+    });
+    const height = rowsHeight.reduce((sum, row) => {
+        return sum + row;
+    }, 0);
+    const headerHeight = isPinnerScheduler ? 0 : 60;
+    return height + headerHeight;
+};

package/dist/src/components/custom/scheduler-temporal/logic/pixels/heightSchedulerPinned.js

@@ -0,0 +1,9 @@
+export const heightSchedulerPinned = (resourcesLength, id, rowReference) => {
+    const noResources = resourcesLength <= 0;
+    const pinnedScheduler = id.toLowerCase().includes("pinned");
+    const rowResourcesHeight_sch = rowReference.current?.clientHeight;
+    if (pinnedScheduler && !noResources && rowResourcesHeight_sch) {
+        return rowResourcesHeight_sch + 83;
+    }
+    return rowResourcesHeight_sch;
+};

package/dist/src/components/custom/scheduler-temporal/logic/state_handle/doubleClickOnResource.js

@@ -0,0 +1,5 @@
+export const doubleClickOnResource = (props, resource) => {
+    if (props.scheduler_handleDblClickOnResourceInScheduler) {
+        props.scheduler_handleDblClickOnResourceInScheduler(resource);
+    }
+};