@cwellt_software/cwellt-reactjs-lib 1.1.5 → 1.1.7

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);
+    }
+};

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;
+};