@cwellt_software/cwellt-reactjs-lib 1.2.13 → 1.2.14

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

@@ -0,0 +1,178 @@
+import lodash from "lodash";
+import moment from "moment";
+import { hasSameProperties } from "../filtering/hasSameProperties";
+import { getEventsOfResource } from "../ui/getEventsOfResource";
+export const handlePropChanges = (_nextProps, currentProps, state, setState) => {
+    let eventsPropDic = Object.assign({}, ..._nextProps.events.map(x => ({ [x.id]: x })));
+    let resourcesPropDic = Object.assign({}, ..._nextProps.resources.map(x => ({
+        [x.data.fullName !== undefined ? x.data.fullName : x.name]: x
+    })));
+    let eventsStateDic = Object.assign({}, ...state.events.map(x => ({ [x.id]: x })));
+    let resourcesStateDic = Object.assign({}, ...state.resources.map(x => ({ [x.id]: x })));
+    let state_resources_copy = [...state.resources];
+    let propEvents = [];
+    let stateEvents = [];
+    if (state.events.length !== _nextProps.events.length) {
+        if (currentProps.id === "crewPinnedScheduler" || currentProps.id === "crewAssignmentsScheduler") {
+            // WHEN IS AN INSERT:
+            // Get the inserted events
+            propEvents = lodash.differenceWith(_nextProps.events, state.events, function (o1, o2) {
+                return o1.data.Crew_Id === o2.data.Crew_Id;
+            });
+            eventsPropDic = Object.assign({}, ...propEvents.map(x => ({ [x.id]: x })));
+            // WHEN IS A DELETE:
+            // Get the deleted events
+            stateEvents = lodash.differenceWith(state.events, _nextProps.events, function (o1, o2) {
+                return o1.data.Crew_Id === o2.data.Crew_Id;
+            });
+            eventsStateDic = Object.assign({}, ...stateEvents.map(x => ({ [x.id]: x })));
+        }
+        if (currentProps.id === "vacationsScheduler") {
+            // WHEN IS AN INSERT:
+            // Get the inserted events
+            propEvents = lodash.differenceWith(_nextProps.events, state.events, function (o1, o2) {
+                return o1.data.ID === o2.data.ID;
+            });
+            eventsPropDic = Object.assign({}, ...propEvents.map(x => ({ [x.id]: x })));
+            // WHEN IS A DELETE:
+            // Get the deleted events
+            stateEvents = lodash.differenceWith(state.events, _nextProps.events, function (o1, o2) {
+                return o1.data.ID === o2.data.ID;
+            });
+            eventsStateDic = Object.assign({}, ...stateEvents.map(x => ({ [x.id]: x })));
+        }
+    }
+    if (propEvents.length === 0) {
+        eventsPropDic = Object.assign({}, ..._nextProps.events.map(x => ({ [x.id]: x })));
+        eventsStateDic = Object.assign({}, ...state.events.map(x => ({ [x.id]: x })));
+    }
+    let propResources = [];
+    let stateResources = [];
+    if (state.resources.length !== _nextProps.resources.length &&
+        state.resources.length > 0 &&
+        _nextProps.resources.length > 0) {
+        if (currentProps.id === "crewPinnedScheduler" || currentProps.id === "crewAssignmentsScheduler") {
+            // WHEN IS AN INSERT:
+            // Get the inserted events
+            propResources = lodash.differenceWith(_nextProps.resources, state.resources, function (o1, o2) {
+                return o1.data.Crewmember_Id === o2.data.Crewmember_Id;
+            });
+            resourcesPropDic = Object.assign({}, ...propResources.map(x => ({ [x.id]: x })));
+            // WHEN IS A DELETE:
+            // Get the deleted events
+            stateResources = lodash.differenceWith(state.resources, _nextProps.resources, function (o1, o2) {
+                return o1.data.Crewmember_Id === o2.data.Crewmember_Id;
+            });
+            resourcesStateDic = Object.assign({}, ...stateResources.map(x => ({ [x.id]: x })));
+        }
+        if (currentProps.id === "vacationsScheduler") {
+            // WHEN IS AN INSERT:
+            // Get the inserted events
+            propResources = lodash.differenceWith(_nextProps.resources, state.resources, function (o1, o2) {
+                return o1.data.CrewmemberID === o2.data.CrewmemberID;
+            });
+            resourcesPropDic = Object.assign({}, ...propResources.map(x => ({ [x.id]: x })));
+            // WHEN IS A DELETE:
+            // Get the deleted events
+            stateResources = lodash.differenceWith(state.resources, _nextProps.resources, function (o1, o2) {
+                return o1.data.CrewmemberID === o2.data.CrewmemberID;
+            });
+            resourcesStateDic = Object.assign({}, ...stateResources.map(x => ({ [x.id]: x })));
+        }
+    }
+    if (propResources.length === 0) {
+        resourcesPropDic = Object.assign({}, ..._nextProps.resources.map(x => ({ [x.id]: x })));
+        resourcesStateDic = Object.assign({}, ...state.resources.map(x => ({ [x.id]: x })));
+    }
+    const eventsKeys = Array.from(new Set([...Object.keys(eventsPropDic), ...Object.keys(eventsStateDic)]));
+    let resourcesToRecalculate = [];
+    const state_events_copy = [...state.events];
+    eventsKeys.forEach(eventKey => {
+        const eventInPropsDic = eventsPropDic[eventKey];
+        const eventInStateDic = eventsStateDic[eventKey];
+        const createNewEvent = (eventProps, eventInDictionary) => Object.assign(new eventProps.constructor(), eventInDictionary);
+        if (eventInPropsDic && !eventInStateDic) {
+            const newEvent = createNewEvent(eventsPropDic[eventKey], eventInPropsDic);
+            state_events_copy.push(newEvent);
+            resourcesToRecalculate.push(eventInPropsDic.resourceId);
+        }
+        else if (!eventInPropsDic && eventInStateDic) {
+            const index = state_events_copy.indexOf(eventInStateDic);
+            state_events_copy.splice(index, 1);
+            resourcesToRecalculate.push(eventInStateDic.resourceId);
+        }
+        else if (eventInPropsDic && eventInStateDic) {
+            const hasSameProps = hasSameProperties(eventsPropDic[eventKey], eventsStateDic[eventKey]);
+            if (!hasSameProps) {
+                const newEvent = createNewEvent(eventsPropDic[eventKey], eventInPropsDic);
+                const eventInStateCopyIndex = state_events_copy.findIndex(sec => sec.id === newEvent.id);
+                state_events_copy[eventInStateCopyIndex] = newEvent;
+                resourcesToRecalculate.push(eventInPropsDic.resourceId);
+                resourcesToRecalculate.push(eventInStateDic.resourceId);
+            }
+        }
+    });
+    const resourceKeys = Array.from(new Set([...Object.keys(resourcesPropDic), ...Object.keys(resourcesStateDic)]));
+    resourceKeys.forEach(resourceKey => {
+        const resourceInPropsDic1 = resourcesPropDic[resourceKey];
+        const resourceInStateDic1 = resourcesStateDic[resourceKey];
+        if (resourceInPropsDic1 &&
+            resourceInStateDic1 &&
+            (resourceInPropsDic1.isLoading !== resourceInStateDic1.isLoading ||
+                resourceInPropsDic1.data.hasFunctionChangeInPeriod !== resourceInStateDic1.data.hasFunctionChangeInPeriod ||
+                resourceInPropsDic1.data.hasTyperatingChangeInPeriod !== resourceInStateDic1.data.hasTyperatingChangeInPeriod)) {
+            resourcesToRecalculate.push(resourceInPropsDic1.id);
+        }
+    });
+    resourcesToRecalculate = Array.from(new Set(resourcesToRecalculate)).map(m => Number(m));
+    resourceKeys.forEach(resourceKey => {
+        const resourceInPropsDic = resourcesPropDic[resourceKey];
+        const resourceInStateDic = resourcesStateDic[resourceKey];
+        if (resourceInPropsDic && !resourceInStateDic) {
+            const newResource = Object.assign(new resourcesPropDic[resourceKey].constructor(), resourceInPropsDic);
+            newResource.events = getEventsOfResource(newResource, state_events_copy, state, currentProps.id, currentProps.module, _nextProps.startDate, _nextProps.endDate);
+            state_resources_copy.push(newResource);
+        }
+        else if (!resourceInPropsDic && resourceInStateDic) {
+            const index = state_resources_copy.indexOf(resourceInStateDic);
+            state_resources_copy.splice(index, 1);
+        }
+        else if (resourceInPropsDic && resourceInStateDic && resourcesToRecalculate.includes(resourceInPropsDic.id)) {
+            const newResource2 = Object.assign(new resourcesPropDic[resourceKey].constructor(), resourceInPropsDic);
+            newResource2.events = getEventsOfResource(newResource2, state_events_copy, state, currentProps.id, currentProps.module, _nextProps.startDate, _nextProps.endDate);
+            const resourceInStateCopyIndex = state_resources_copy.findIndex(src => src.id === newResource2.id);
+            state_resources_copy[resourceInStateCopyIndex] = newResource2;
+        }
+    });
+    if (currentProps.id === "crewPinnedScheduler" || currentProps.id === "crewAssignmentsScheduler") {
+        state_resources_copy = state_resources_copy.sort((a, b) => {
+            if (a.data.C3_LC > b.data.C3_LC) {
+                return 1;
+            }
+            if (a.data.C3_LC < b.data.C3_LC) {
+                return -1;
+            }
+            return 0;
+        });
+    }
+    if (currentProps.id === "vacationsScheduler") {
+        state_resources_copy = state_resources_copy.sort((a, b) => {
+            if (a.data.C3LC > b.data.C3LC) {
+                return 1;
+            }
+            if (a.data.C3LC < b.data.C3LC) {
+                return -1;
+            }
+            return 0;
+        });
+    }
+    if (resourcesToRecalculate.length > 0 ||
+        _nextProps.resources.length !== state.resources.length ||
+        _nextProps.events.length !== state.events.length) {
+        setState(state_events_copy, state_resources_copy);
+    }
+    if (state.showConsoleLogs) {
+        console.log("Schedule - componentWillReceiveProps - print on schedule, end: ", moment(new Date()).toString());
+        console.log("Schedule - componentWillReceiveProps, end: ", moment(new Date()).toString());
+    }
+};

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

@@ -0,0 +1,11 @@
+import moment from "moment";
+import { getResourcesWithPixels } from "../pixels/getPixelsForEvent";
+export const handleResourceChange = (nextProps, showLogs, dayPx, setState) => {
+    const props_events_copy = [...nextProps.events];
+    const props_resources_copy = [...nextProps.resources];
+    setState(props_events_copy, getResourcesWithPixels(props_resources_copy, nextProps, dayPx));
+    if (showLogs) {
+        console.log("Schedule - componentWillReceiveProps - print on schedule, end: ", moment(new Date()).toString());
+        console.log("Schedule - componentWillReceiveProps, end: ", moment(new Date()).toString());
+    }
+};

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

@@ -0,0 +1,9 @@
+export const onDragOver = (e) => {
+    if (e.ctrlKey === true) {
+        e.dataTransfer.dropEffect = "copy";
+    }
+    else {
+        e.dataTransfer.dropEffect = "link";
+    }
+    e.preventDefault();
+};

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

@@ -0,0 +1,3 @@
+export const onDropEventToResource = (props, cblDragNDrop, resource) => {
+    props.scheduler_handleOnDropCblEventsOnResource.call(props.parent, cblDragNDrop, resource);
+};

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

@@ -0,0 +1,3 @@
+export const handleOnResize = (props, cblDragNDrop) => {
+    props.scheduler_handleCblEventResize?.call(props.parent, cblDragNDrop);
+};

package/dist/src/components/custom/scheduler-temporal/logic/strings/compareStrings.js

@@ -0,0 +1,7 @@
+export const compareStrings = (str1, str2) => {
+    if (str1 > str2)
+        return 1;
+    if (str1 < str2)
+        return -1;
+    return 0;
+};

package/dist/src/components/custom/scheduler-temporal/logic/strings/getGUID.js

@@ -0,0 +1,7 @@
+export const getGUID = () => {
+    return generateSegment(false) + generateSegment(true) + generateSegment(true) + generateSegment(false);
+};
+const generateSegment = (includeHyphens) => {
+    const p = (Math.random().toString(16) + "000000000").substring(2, 10);
+    return includeHyphens ? "-" + p.substring(0, 4) + "-" + p.substring(4, 8) : p;
+};

package/dist/src/components/custom/scheduler-temporal/logic/ui/checkIfSlotAvailable.js

@@ -0,0 +1,9 @@
+export const checkIfSlotAvailable = (events, event) => {
+    const lastElement = events.length - 1;
+    if (events.length == 0)
+        return true;
+    const collide = events.some(existent => {
+        return !(existent.end <= event.start || event.end <= existent.start);
+    });
+    return !collide || events[lastElement].isFullHeight;
+};

package/dist/src/components/custom/scheduler-temporal/logic/ui/getEventsOfResource.js

@@ -0,0 +1,92 @@
+import { filterEvents } from "../filtering/filterEvents";
+import { getEventWithSize } from "../pixels/getPixelsForEvent";
+import { checkIfSlotAvailable } from "./checkIfSlotAvailable";
+export const getEventsOfResource = (res, events, state, id, module, start, end) => {
+    let maxTop = 0;
+    const tops = [];
+    tops[0] = new Array();
+    const eventsOrdered = filterEvents(events, start ?? state.startDate, end ?? state.endDate, id, res.id, module);
+    eventsOrdered.forEach((event, i) => {
+        if (i === 0 || event.isFullHeight) {
+            event.top = 0;
+            tops[0].push(event);
+        }
+        else {
+            let found = false;
+            for (let j = 0; j < tops.length && found === false; j++) {
+                found = checkIfSlotAvailable(tops[j], event);
+                if (found === true || event.isFullHeight) {
+                    event.top = j * state.eventHeight;
+                    tops[j].push(event);
+                }
+            }
+            if (found === false && !event.isFullHeight) {
+                maxTop++;
+                tops[maxTop] = new Array();
+                event.top = maxTop * state.eventHeight;
+                tops[maxTop].push(event);
+            }
+            else {
+                // This is for flightwatch
+                if (found === true && event.data.order === 2 && maxTop < 1) {
+                    maxTop++;
+                    tops[maxTop] = new Array();
+                    event.top = maxTop * state.eventHeight;
+                    tops[maxTop].push(event);
+                    maxTop--;
+                }
+            }
+        }
+        event = getEventWithSize(event, start, state.dayPx);
+    });
+    let OrderedArray = new Array();
+    for (let h = 0; h < tops.length; h++) {
+        if (tops.length === 0) {
+            res.maxTop = state.eventHeight;
+        }
+        else {
+            res.maxTop = tops.length * state.eventHeight;
+        }
+        OrderedArray = OrderedArray.concat(tops[h]);
+    }
+    return OrderedArray;
+};
+export const getEventsInInnerRows = (res, state, start) => {
+    let maxTop = 0;
+    const tops = [];
+    tops[0] = new Array();
+    res.events.forEach((event, i) => {
+        if (i === 0 || event.isFullHeight) {
+            event.top = 0;
+            tops[0].push(event);
+        }
+        else {
+            let found = false;
+            for (let j = 0; j < tops.length && found === false; j++) {
+                found = checkIfSlotAvailable(tops[j], event);
+                if (found === true || event.isFullHeight) {
+                    event.top = j * state.eventHeight;
+                    tops[j].push(event);
+                }
+            }
+            if (found === false && !event.isFullHeight) {
+                maxTop++;
+                tops[maxTop] = new Array();
+                event.top = maxTop * state.eventHeight;
+                tops[maxTop].push(event);
+            }
+            else {
+                // This is for flightwatch
+                if (found === true && event.data.order === 2 && maxTop < 1) {
+                    maxTop++;
+                    tops[maxTop] = new Array();
+                    event.top = maxTop * state.eventHeight;
+                    tops[maxTop].push(event);
+                    maxTop--;
+                }
+            }
+        }
+        event = getEventWithSize(event, start, state.dayPx);
+    });
+    return tops;
+};

package/dist/src/components/custom/scheduler-temporal/logic/ui/getHasPropsChanged.js

@@ -0,0 +1,242 @@
+import moment from "moment";
+export const getHasPropsChanges = (props, state, _nextProps) => {
+    let propHasChanges = false;
+    if (state.startDate.getTime() !== _nextProps.startDate.getTime()) {
+        propHasChanges = true;
+    }
+    if (state.endDate.getTime() !== _nextProps.endDate.getTime()) {
+        propHasChanges = true;
+    }
+    if (state.groupByFunction !== _nextProps.groupByFunction && _nextProps.groupByFunction !== undefined) {
+        propHasChanges = true;
+    }
+    if (props.events && _nextProps.events && props.events.length !== _nextProps.events.length) {
+        propHasChanges = true;
+    }
+    if (state.events && _nextProps.events && state.events.length !== _nextProps.events.length) {
+        propHasChanges = true;
+    }
+    if (state.events && _nextProps.events && state.events.length > 0 && _nextProps.events.length > 0) {
+        // When an event has been updated.
+        if (state.events.length === _nextProps.events.length) {
+            for (let i = 0; i < props.events.length; i++) {
+                if (state.events[i].selected !== _nextProps.events[i].selected) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.state !== undefined &&
+                    props.events[i].data.state !== _nextProps.events[i].data.state) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.start !== undefined &&
+                    props.events[i].data.start !== _nextProps.events[i].data.start) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.end !== undefined && props.events[i].data.end !== _nextProps.events[i].data.end) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.remark !== undefined &&
+                    props.events[i].data.remark !== _nextProps.events[i].data.remark) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.highPrio !== undefined &&
+                    props.events[i].data.highPrio !== _nextProps.events[i].data.highPrio) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.VacID !== undefined &&
+                    props.events[i].data.VacID !== _nextProps.events[i].data.VacID) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.Crew_Id !== undefined &&
+                    props.events[i].data.Crew_Id !== _nextProps.events[i].data.Crew_Id) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.CrewComp !== undefined &&
+                    props.events[i].data.CrewComp !== _nextProps.events[i].data.CrewComp) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.crewCompString !== undefined &&
+                    props.events[i].data.crewCompString !== _nextProps.events[i].data.crewCompString) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.SplitDuty !== undefined &&
+                    props.events[i].data.SplitDuty !== _nextProps.events[i].data.SplitDuty) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.firstNumber !== undefined &&
+                    props.events[i].data.firstNumber !== _nextProps.events[i].data.firstNumber) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.CompRectList !== undefined &&
+                    props.events[i].data.CompRectList !== _nextProps.events[i].data.CompRectList) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.Jumpseats !== undefined &&
+                    props.events[i].data.Jumpseats !== _nextProps.events[i].data.Jumpseats) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.openJumpSeatsString !== undefined &&
+                    props.events[i].data.openJumpSeatsString !== _nextProps.events[i].data.openJumpSeatsString) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.IsCrewchange !== undefined &&
+                    props.events[i].data.IsCrewchange !== _nextProps.events[i].data.IsCrewchange) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.SStartApt !== undefined &&
+                    props.events[i].data.SStartApt !== _nextProps.events[i].data.SStartApt) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.SEndApt !== undefined &&
+                    props.events[i].data.SEndApt !== _nextProps.events[i].data.SEndApt) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.Instructor !== undefined &&
+                    props.events[i].data.Instructor !== _nextProps.events[i].data.Instructor) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.Trainee !== undefined &&
+                    props.events[i].data.Trainee !== _nextProps.events[i].data.Trainee) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.LineCheck !== undefined &&
+                    props.events[i].data.LineCheck !== _nextProps.events[i].data.LineCheck) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.IsObserver !== undefined &&
+                    props.events[i].data.IsObserver !== _nextProps.events[i].data.IsObserver) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.IsSplitDuty !== undefined &&
+                    props.events[i].data.IsSplitDuty !== _nextProps.events[i].data.IsSplitDuty) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.Comment !== undefined &&
+                    props.events[i].data.Comment !== _nextProps.events[i].data.Comment) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.InternalRemark !== undefined &&
+                    props.events[i].data.InternalRemark !== _nextProps.events[i].data.InternalRemark) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.ExternalRemark !== undefined &&
+                    props.events[i].data.ExternalRemark !== _nextProps.events[i].data.ExternalRemark) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.inserted !== undefined &&
+                    props.events[i].data.inserted !== _nextProps.events[i].data.inserted) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.edited !== undefined &&
+                    props.events[i].data.edited !== _nextProps.events[i].data.edited) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.deleted !== undefined &&
+                    props.events[i].data.deleted !== _nextProps.events[i].data.deleted) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.MissingFunc !== undefined &&
+                    props.events[i].data.MissingFunc !== _nextProps.events[i].data.MissingFunc) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.crewComposition_CompositionName !== undefined &&
+                    props.events[i].data.crewComposition_CompositionName !==
+                        _nextProps.events[i].data.crewComposition_CompositionName) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.subject !== undefined &&
+                    props.events[i].data.subject !== _nextProps.events[i].data.subject) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.ACFTID !== undefined &&
+                    props.events[i].data.ACFTID !== _nextProps.events[i].data.ACFTID) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.allAcftId !== undefined &&
+                    props.events[i].data.allAcftId !== _nextProps.events[i].data.allAcftId) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.SCDcrew !== undefined &&
+                    props.events[i].data.SCDcrew !== _nextProps.events[i].data.SCDcrew) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.C3_LC !== undefined &&
+                    props.events[i].data.C3_LC !== _nextProps.events[i].data.C3_LC) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.C3LC !== undefined && props.events[i].data.C3LC !== _nextProps.events[i].data.C3LC) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.Remark !== undefined &&
+                    props.events[i].data.Remark !== _nextProps.events[i].data.Remark) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.HighPriority !== undefined &&
+                    props.events[i].data.HighPriority !== _nextProps.events[i].data.HighPriority) {
+                    propHasChanges = true;
+                }
+                if (props.events[i].data.FirstNumber !== undefined &&
+                    props.events[i].data.FirstNumber !== _nextProps.events[i].data.FirstNumber) {
+                    propHasChanges = true;
+                }
+            }
+        }
+    }
+    if (state.showConsoleLogs) {
+        console.log("Schedule - componentWillReceiveProps - has changes, end: ", moment(new Date()).toString());
+        console.log("Schedule - componentWillReceiveProps - print on schedule, start: ", moment(new Date()).toString());
+    }
+    if (props.height !== _nextProps.height) {
+        propHasChanges = true;
+    }
+    if (props.pinnedResources !== _nextProps.pinnedResources) {
+        propHasChanges = true;
+    }
+    if (props.resources && _nextProps.resources && props.resources.length !== _nextProps.resources.length) {
+        propHasChanges = true;
+    }
+    if (props.resources && _nextProps.resources && props.resources.length > 0 && _nextProps.resources.length > 0) {
+        if (props.resources.length === _nextProps.resources.length) {
+            for (let i = 0; i < props.resources.length; i++) {
+                if (props.resources[i].isLoading !== _nextProps.resources[i].isLoading) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].isInViewport !== _nextProps.resources[i].isInViewport) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].data.isGroupedByFunction !== _nextProps.resources[i].data.isGroupedByFunction) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].data.hasFunctionChangeInPeriod !== _nextProps.resources[i].data.hasFunctionChangeInPeriod) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].data.hasTyperatingChangeInPeriod !==
+                    _nextProps.resources[i].data.hasTyperatingChangeInPeriod) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].data.HasFunctionChangeInPeriod !== _nextProps.resources[i].data.HasFunctionChangeInPeriod) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].data.HasTyperatingChangeInPeriod !==
+                    _nextProps.resources[i].data.HasTyperatingChangeInPeriod) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].data.TraineeStatus !== _nextProps.resources[i].data.TraineeStatus) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].data.FunctionTyperatingStringTooltip !==
+                    _nextProps.resources[i].data.FunctionTyperatingStringTooltip) {
+                    propHasChanges = true;
+                }
+                if (props.resources[i].data.CrewPlanningVac !== _nextProps.resources[i].data.CrewPlanningVac) {
+                    propHasChanges = true;
+                }
+            }
+            if (props.module === "CrewScheduling" && props.resourceName === "Employees") {
+                if (props.groupByFunction !== _nextProps.groupByFunction) {
+                    propHasChanges = true;
+                }
+            }
+        }
+    }
+    return propHasChanges && _nextProps.resources.length > 0 && _nextProps.events.length > 0;
+};

package/dist/src/components/custom/scheduler-temporal/logic/ui/getTimeHeaders.js

@@ -0,0 +1,35 @@
+export const getTimeHeaders = (startDate, endDate) => {
+    const dateArray = new Array();
+    const currentDate = new Date(startDate);
+    const startOffset = Math.abs(startDate.getTimezoneOffset());
+    const endOffset = Math.abs(endDate.getTimezoneOffset());
+    // Summer: +1 -> +2, true
+    // Winter: +2 -> -1, false
+    const offsetSummerWinter = startOffset < endOffset;
+    if (offsetSummerWinter === true) {
+        while (currentDate < endDate) {
+            if (dateArray.length > 0) {
+                const lastPosition = dateArray[dateArray.length - 1];
+                const differenceHours = currentDate.getHours() - lastPosition.getHours();
+                if (differenceHours === 1 || differenceHours < 0) {
+                    dateArray.push(new Date(currentDate));
+                }
+                else if (differenceHours > 1) {
+                    dateArray.push(new Date(currentDate.getHours() - 1));
+                    dateArray.push(new Date(currentDate));
+                }
+            }
+            else {
+                dateArray.push(new Date(currentDate));
+            }
+            currentDate.setHours(currentDate.getHours() + 1);
+        }
+    }
+    else {
+        while (currentDate < endDate) {
+            dateArray.push(new Date(currentDate));
+            currentDate.setHours(currentDate.getHours() + 1);
+        }
+    }
+    return dateArray;
+};

package/dist/src/components/custom/scheduler-temporal/logic/ui/isAllowedToMove.js

@@ -0,0 +1,19 @@
+export const isAllowedToMove = (data, resData, cblDragNDrop) => {
+    if (data?.eventType !== 1) {
+        return true;
+    }
+    const allowedMoves = [
+        { from: "acftsScheduler", to: "flightsPairingsScheduler" },
+        { from: "flightsScheduler", to: "crewAssignmentsScheduler" },
+        { from: "opstoolScheduler", to: "opstoolScheduler" },
+        { from: "opstoolScheduler", to: "opstoolSchedulerVirtual" },
+        { from: "opstoolSchedulerVirtual", to: "opstoolScheduler" },
+        { from: "opstoolSchedulerVirtual", to: "opstoolSchedulerVirtual" },
+        { from: "vacationsScheduler", to: "vacationsScheduler" }
+    ];
+    const crewControllAllowedMove = allowedMoves.some(move => move.from === cblDragNDrop.fromId && move.to === cblDragNDrop.toId);
+    if (crewControllAllowedMove) {
+        return true;
+    }
+    return data.Crew !== resData.Crewmember_Id;
+};