@cwellt_software/cwellt-reactjs-lib 1.1.6 → 1.2.0

package/dist/src/components/custom/scheduler-temporal/CwSchedulerComp2.js

@@ -0,0 +1,267 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import lodash from "lodash";
+import moment from "moment";
+import { Component } from "react";
+import { ResourcesTitleList } from "./components/resources_title_list/ResourcesTitleList";
+import { SchedulerContentArea } from "./components/scheduler_content_area/SchedulerContentArea";
+import { SchedulerHeader } from "./components/scheduler_header/SchedulerHeader";
+import { addMinutesToDateFromPx } from "./logic/dates/addMinutesToDateFromPx";
+import { daysBetweenTwoDates } from "./logic/dates/daysBetweenTwoDates";
+import { daysBetweenTwoDatesIncludingBoth } from "./logic/dates/daysBetweenTwoDatesWithoutCeil";
+import { getUtcToday } from "./logic/dates/getUtcToday";
+import { calculateDivisions } from "./logic/divisions/calculateDivisions";
+import { calculateDivisionType } from "./logic/divisions/calculateDivisionType";
+import { filterAndProcessResources } from "./logic/filtering/filterAndProcessResources";
+import { filterResources } from "./logic/filtering/filterResources";
+import { getEventWithSize } from "./logic/pixels/getPixelsForEvent";
+import { heightScheduler } from "./logic/pixels/heightScheduler";
+import { getEventsInInnerRows, getEventsOfResource } from "./logic/ui/getEventsOfResource";
+import { getTimeHeaders } from "./logic/ui/getTimeHeaders";
+export class CwScheduler2 extends Component {
+    contentArea;
+    constructor(Props) {
+        super(Props);
+        this.init(this.props);
+    }
+    resizeObserver;
+    calculateMaxPx = () => {
+        const mainElement = document.querySelector(".cw-scheduler-main-wrapper");
+        if (!mainElement)
+            return window.innerWidth - 402; // sidebar + first column + padding
+        const mainRect = mainElement.getBoundingClientRect();
+        return Math.floor(mainRect.width - 162); // first column + padding
+    };
+    init = (props) => {
+        const maxPx = this.calculateMaxPx();
+        const timeHeaders = getTimeHeaders(props.startDate, props.endDate);
+        const dayPx = maxPx / Math.floor(daysBetweenTwoDates(props.startDate, props.endDate));
+        const hourPx = dayPx / 24;
+        const minutePx = dayPx / 1440;
+        this.state = {
+            startDate: props.startDate,
+            endDate: props.endDate,
+            maxPx: maxPx,
+            dayPx: dayPx,
+            hourPx: hourPx,
+            minutePx: minutePx,
+            timeHeaders: timeHeaders,
+            eventHeight: 30,
+            events: props.events,
+            resources: props.resources,
+            top: 0,
+            bottom: 1000,
+            lineStyle: 0,
+            nowUtc: getUtcToday(),
+            division: 0,
+            divisionType: "",
+            pinnedResources: props.pinnedResources ? props.pinnedResources : [],
+            selectedEvents: [],
+            showConsoleLogs: false, // Change to false to not show the console.log(...)
+            groupByFunction: props.groupByFunction ?? false,
+        };
+    };
+    initOutside = (events, resources, _nextProps, startDate, endDate) => {
+        // const maxPx: number = (document.getElementById("root")?.clientWidth ?? window.innerWidth) - 150;
+        const maxPx = this.calculateMaxPx();
+        const timeHeaders = getTimeHeaders(startDate, endDate);
+        const days = Math.floor(daysBetweenTwoDates(startDate, endDate));
+        const dayPx = maxPx / days;
+        const hourPx = dayPx / 24;
+        const minutePx = dayPx / 1440;
+        const eventHeight = 30;
+        resources = filterResources(this.props.module, this.props.resourceName, this.props.resources, this.props.groupByFunction, endDate, startDate);
+        resources = resources.map((resource) => {
+            return {
+                ...resource,
+                events: getEventsOfResource(resource, events, this.state, this.props.id, this.props.module, startDate, endDate),
+            };
+        });
+        const groupByFunction = this.props.groupByFunction ?? false;
+        const now = getUtcToday();
+        const isInDateRange = now >= startDate && now <= endDate && this.contentArea !== undefined;
+        const lineStyle = isInDateRange ? daysBetweenTwoDatesIncludingBoth(startDate, now) * dayPx : 0;
+        this.setState({
+            startDate: startDate,
+            endDate: endDate,
+            maxPx: maxPx,
+            dayPx: dayPx,
+            hourPx: hourPx,
+            minutePx: minutePx,
+            timeHeaders: timeHeaders,
+            eventHeight: eventHeight,
+            events: [...events],
+            resources: [...resources],
+            top: 0,
+            bottom: 1000,
+            lineStyle: lineStyle,
+            nowUtc: now,
+            division: 0,
+            divisionType: "",
+            pinnedResources: this.props.pinnedResources ?? [],
+            groupByFunction: groupByFunction,
+        });
+    };
+    componentDidMount() {
+        const eventsCopy = [...this.props.events];
+        const filteredResources = filterAndProcessResources(this.props, this.state);
+        const divisions = calculateDivisions(this.state.startDate, this.state.endDate);
+        const divisionType = calculateDivisionType(this.state.startDate, this.state.endDate);
+        this.setState({
+            events: eventsCopy,
+            resources: filteredResources,
+            division: divisions,
+            divisionType: divisionType,
+        });
+        // Añadir ResizeObserver
+        const mainElement = document.querySelector(".cw-scheduler-main-wrapper");
+        if (mainElement) {
+            this.resizeObserver = new ResizeObserver(() => {
+                this.handleResize();
+            });
+            this.resizeObserver.observe(mainElement);
+        }
+        window?.addEventListener("resize", this.handleResize);
+    }
+    componentWillUnmount() {
+        if (this.resizeObserver) {
+            this.resizeObserver.disconnect();
+        }
+        window?.removeEventListener("resize", this.handleResize);
+    }
+    recalculateEventPositions = (events, dayPx, startDate) => {
+        return events.map(event => getEventWithSize(event, startDate, dayPx));
+    };
+    updateResourcesWithEvents = (resources, events) => {
+        return resources.map(resource => ({
+            ...resource,
+            events: events.filter(event => event.resourceId === resource.id)
+        }));
+    };
+    handleResize = () => {
+        const maxPx = this.calculateMaxPx();
+        const days = Math.floor(daysBetweenTwoDates(this.state.startDate, this.state.endDate));
+        const dayPx = maxPx / days;
+        const hourPx = dayPx / 24;
+        const minutePx = dayPx / 1440;
+        const recalculatedEvents = this.recalculateEventPositions(this.state.events, dayPx, this.state.startDate);
+        const updatedResources = this.updateResourcesWithEvents(this.state.resources, recalculatedEvents);
+        this.setState({
+            maxPx,
+            dayPx,
+            hourPx,
+            minutePx,
+            events: recalculatedEvents,
+            resources: updatedResources
+        });
+    };
+    componentWillReceiveProps(_nextProps) {
+        if (this.state.showConsoleLogs) {
+            console.log("Schedule - componentWillReceiveProps, start: ", moment(new Date()).toString());
+            console.log("Schedule - componentWillReceiveProps - has changes, start: ", moment(new Date()).toString());
+        }
+        const dateChange = _nextProps.startDate.toISOString() !== this.state.startDate.toISOString() ||
+            _nextProps.endDate.toISOString() !== this.state.endDate.toISOString();
+        if (document.getElementById("root") !== null) {
+            this.handleResize();
+        }
+        if (dateChange) {
+            const events = lodash.cloneDeep(this.props.events);
+            const resources = lodash.cloneDeep(this.props.resources);
+            this.initOutside(events, resources, _nextProps, _nextProps.startDate, _nextProps.endDate);
+            if (this.state.showConsoleLogs) {
+                console.log("Schedule - componentWillReceiveProps - print on schedule, end: ", moment(new Date()).toString());
+                console.log("Schedule - componentWillReceiveProps, end: ", moment(new Date()).toString());
+            }
+            return;
+        }
+        const mappedEvents = _nextProps.events
+            .map((event) => {
+            return getEventWithSize(event, _nextProps.startDate, this.state.dayPx);
+        })
+            .filter((event) => {
+            const outOfRange = event.end <= this.props.startDate || event.start >= this.props.endDate;
+            return !outOfRange;
+        });
+        const newResources = _nextProps.resources
+            .map((resource) => {
+            return {
+                ...resource,
+                events: mappedEvents.filter((event) => event.resourceId === resource.id),
+            };
+        })
+            .map((resource) => {
+            const tops = getEventsInInnerRows(resource, this.state, _nextProps.startDate);
+            const height = tops.length === 0 ? this.state.eventHeight : tops.length * this.state.eventHeight;
+            let flatMapEvents = [];
+            for (let h = 0; h < tops.length; h++) {
+                flatMapEvents = flatMapEvents.concat(tops[h]);
+            }
+            return {
+                ...resource,
+                maxTop: height,
+                events: flatMapEvents,
+            };
+        });
+        this.setState({
+            events: mappedEvents,
+            resources: newResources,
+        });
+    }
+    handleOnClickContextMenuResourceScheduler = (_clickEvent, _resource) => {
+        let datetime = new Date();
+        const _ca = this.contentArea;
+        if (_clickEvent.domEvent.currentTarget !== undefined) {
+            const leftPos = _clickEvent.domEvent.currentTarget.parentElement.getBoundingClientRect().left -
+                (_ca?.getBoundingClientRect()?.left ?? 0) -
+                window.scrollX;
+            datetime = addMinutesToDateFromPx(this.state.startDate, leftPos, this.state.minutePx);
+        }
+        if (this.props.scheduler_handleOnClickContextMenuResource) {
+            this.props.scheduler_handleOnClickContextMenuResource(datetime, _resource, _clickEvent.key, this.props.id);
+        }
+    };
+    handleOnClickResourceContextMenu = (_e, resource) => {
+        if (this.props.scheduler_handleOnClickResourceContextMenu) {
+            this.props.scheduler_handleOnClickResourceContextMenu(_e, resource);
+        }
+    };
+    handleCrewPinning = (resource, text) => {
+        if (this.props.scheduler_handlePinned) {
+            this.props.scheduler_handlePinned.call(this.props.parent, resource.id, text, this.props.id);
+        }
+    };
+    render() {
+        const isInDateRange = this.state.nowUtc >= this.state.startDate &&
+            this.state.nowUtc <= this.state.endDate &&
+            this.contentArea !== undefined;
+        const showTimeline = isInDateRange && this.state.lineStyle < this.state.maxPx;
+        const isPinnedTable = this.props.id.toLowerCase().includes("pinned");
+        const schedulerHeight = heightScheduler(this.state.resources, this.props.height, this.props.id === "crewAssignmentsScheduler");
+        const timeHeaders = this.state.timeHeaders;
+        const referenceDate = timeHeaders[0];
+        const divisions = 24 / calculateDivisions(timeHeaders[0], timeHeaders[timeHeaders.length - 1]);
+        const hoursPixels = timeHeaders
+            .filter((_, index) => {
+            return index != 0 && index % divisions == 0;
+        })
+            .map((date) => {
+            const daysDiff = daysBetweenTwoDatesIncludingBoth(date, referenceDate);
+            const pixels = daysDiff * 24 * this.state.hourPx;
+            return pixels;
+        });
+        return (_jsx("div", { id: this.props.id, style: {
+                overflowY: "auto",
+                maxHeight: isPinnedTable ? "auto" : schedulerHeight
+            }, className: this.state.resources.length > 0 ? "cwellt_tb_con" : "cwellt_tb_con cw_tb_con_emptyValues", children: _jsxs("table", { id: "cwelltTableScheduler", children: [this.props.id !== "crewAssignmentsScheduler" && (_jsx(SchedulerHeader, { timelineProps: {
+                            maxPx: this.state.maxPx,
+                            hoursList: this.state.timeHeaders,
+                            pxPerHour: this.state.hourPx,
+                            startDate: this.state.startDate,
+                            endDate: this.state.endDate,
+                            headerName: this.props.resourceName,
+                        }, descriptionColumn: this.props.descriptionColumn })), _jsx("tbody", { style: {
+                            overflow: "visible",
+                            width: this.state.maxPx + 150
+                        }, className: isPinnedTable ? "fc-body cw-fc-body-pinned" : "fc-body", children: _jsxs("tr", { className: "fc_body_row", children: [_jsx(ResourcesTitleList, { resources: this.state.resources, canBePinned: this.props.canBePinned ?? false, includesPinned: this.props.id.toLowerCase().includes("pinned"), onCrewPinning: this.handleCrewPinning, onClickResourceContextMenu: this.handleOnClickResourceContextMenu, ResourceTitleComponent: this.props.resourceComp }), _jsx("td", { className: "dividerArea" }), _jsx(SchedulerContentArea, { now: this.state.nowUtc, showTimeline: showTimeline, timeSeparatorLeftPx: hoursPixels, timeLineLeftPx: this.state.lineStyle, resources: this.state.resources, contextMenuContents: this.props.resourceContextMenuContents, scheduler: this, onEmptyClick: this.props.scheduler_handleEmptyClick, setContentArea: (n) => (this.contentArea = n), onClickContextMenu: this.handleOnClickContextMenuResourceScheduler })] }) })] }) }));
+    }
+}

package/dist/src/components/custom/scheduler-temporal/CwSuperSchedulerComp.js

@@ -0,0 +1,269 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import _ from "lodash";
+import * as React from "react";
+import { CwButton } from "../../control/action/button/CwButton";
+import { CwScheduler2 } from "./CwSchedulerComp2";
+let topsCounter = 0;
+export default class SuperScheduler extends React.Component {
+    constructor(Props) {
+        super(Props);
+        this.state = {
+            topsCalculated: 0,
+            height: 50,
+            dataConfig: this.props.dataConfig ? this.props.dataConfig : undefined,
+            pinnedResources: [],
+        };
+    }
+    componentDidUpdate(_previousProps, _previousState) {
+        if (this.props.pinnedResources !== _previousProps.pinnedResources) {
+            let returnedTops = 0;
+            let returnedHeight = 50;
+            let data;
+            if (this.props.pinnedResources) {
+                let pinned = [...this.props.pinnedResources];
+                pinned = _.uniq(pinned);
+                for (let i = 0; i < pinned.length; i++) {
+                    data = this.returnDynamicHeight(pinned[i], returnedTops);
+                    returnedTops = data.topsCalculated;
+                    returnedHeight = data.height;
+                }
+                this.setState({
+                    topsCalculated: returnedTops,
+                    height: returnedHeight !== 50 ? 80 + returnedHeight : 50,
+                    pinnedResources: this.props.pinnedResources,
+                });
+            }
+        }
+    }
+    scheduler_handleCblEventClick = (cblEvent, schedulerId) => {
+        this.props.scheduler_handleCblEventClick(cblEvent, schedulerId);
+    };
+    scheduler_handleCblEventClickRight = (cblEvent, schedulerId) => {
+        if (this.props.scheduler_handleCblEventClickRight) {
+            this.props.scheduler_handleCblEventClickRight(cblEvent, schedulerId);
+        }
+    };
+    scheduler_handleCblEventDoubleClick = (cblEvent, schedulerId) => {
+        this.props.scheduler_handleCblEventDoubleClick(cblEvent, schedulerId);
+    };
+    scheduler_handlePinnedClickMultipleIds = (resIds, schedulerId, requestString) => {
+        this.props.scheduler_handlePinningOfResources(resIds, "", schedulerId, requestString);
+    };
+    scheduler_handlePinnedClick = (resId, text, schedulerId) => {
+        const array = new Array();
+        array.push(resId);
+        this.props.scheduler_handlePinningOfResources(array, text, schedulerId, "resources");
+    };
+    returnDynamicHeight(pinned, topsCalculated) {
+        let height = 100;
+        let maxTop = 0;
+        const eventHeight = 30;
+        const tops = new Array();
+        tops[0] = new Array();
+        const diffDates = this.props.endDate.getTime() - this.props.startDate.getTime();
+        const diffDays = diffDates / (1000 * 3600 * 24);
+        const dateToFilter = new Date(this.props.startDate.getTime());
+        dateToFilter.setDate(dateToFilter.getDate() + diffDays);
+        let events = this.props.pinnedEvents !== undefined ? this.props.pinnedEvents : new Array();
+        events = events
+            .filter((x) => pinned === x.resourceId && x.start >= this.props.startDate && x.start <= dateToFilter)
+            .sort((a, b) => {
+            return +new Date(a.start) - +new Date(b.start);
+        });
+        for (let i = 0; i < events.length; i++) {
+            const event = events[i];
+            if (i === 0 || event.isFullHeight) {
+                tops[0].push(event);
+            }
+            else {
+                let found = false;
+                for (let j = 0; j < tops.length && found === false; j++) {
+                    found = this.checkIfSlotAvailable(tops[j], event);
+                    if (found === true || event.isFullHeight) {
+                        tops[j].push(event);
+                    }
+                }
+                if (found === false) {
+                    maxTop++;
+                    tops[maxTop] = new Array();
+                    tops[maxTop].push(event);
+                }
+            }
+        }
+        for (let h = 0; h < tops.length; h++) {
+            if (tops.length === 0) {
+                height = 100;
+            }
+            else {
+                height = (topsCalculated + tops.length) * eventHeight;
+            }
+        }
+        topsCounter = topsCounter + tops.length;
+        return {
+            topsCalculated: topsCalculated + tops.length,
+            height: height,
+        };
+    }
+    checkIfSlotAvailable(array, event) {
+        let found = false;
+        if (array[array.length - 1].end <= event.start || array[array.length - 1].isFullHeight) {
+            found = true;
+        }
+        return found;
+    }
+    handleOnClickContextMenuResource = (date, resource, key, schedulerId) => {
+        let url = "";
+        switch (key) {
+            case "showReserves": {
+                // CrewControl
+                if (this.props.module === "CrewControl") {
+                    url = "/Winops/CrewControl/CrewControlReact/GetCrewIdsOfReserve";
+                }
+                // CrewScheduling
+                if (this.props.module === "CrewScheduling") {
+                    url = "/Winops/CrewPlanning/CrewPlanning/GetCrewIdsOfReserve";
+                }
+                const requestOptions = {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        from: this.dateUTCString(this.props.startDate),
+                        to: this.dateUTCString(this.props.endDate),
+                        acftCategories: [],
+                        functions: [],
+                        clickedDate: this.dateUTCString(date),
+                        airportSelected: this.props.airportSelected,
+                    }),
+                };
+                if (this.state.dataConfig) {
+                    fetch(this.state.dataConfig + url, requestOptions)
+                        .then((response) => response.json())
+                        .then((res) => {
+                        if (res.length > 0) {
+                            this.scheduler_handlePinnedClickMultipleIds(res, schedulerId, "Reserves");
+                        }
+                        else {
+                            alert("No Reserves");
+                        }
+                    });
+                }
+                break;
+            }
+            case "showStandbys": {
+                // CrewControl
+                if (this.props.module === "CrewControl") {
+                    url = "/Winops/CrewControl/CrewControlReact/GetCrewIdsOfStandby";
+                }
+                // CrewScheduling
+                if (this.props.module === "CrewScheduling") {
+                    url = "/Winops/CrewPlanning/CrewPlanning/GetCrewIdsOfStandby";
+                }
+                const requestOptions2 = {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        from: this.dateUTCString(this.props.startDate),
+                        to: this.dateUTCString(this.props.startDate),
+                        acftCategories: [],
+                        functions: [],
+                        clickedDate: this.dateUTCString(date),
+                        airportSelected: this.props.airportSelected,
+                    }),
+                };
+                if (this.state.dataConfig) {
+                    fetch(this.state.dataConfig + url, requestOptions2)
+                        .then((response) => response.json())
+                        .then((res) => {
+                        if (res.length > 0) {
+                            this.scheduler_handlePinnedClickMultipleIds(res, schedulerId, "Standbys");
+                        }
+                        else {
+                            alert("No Standbys");
+                        }
+                    });
+                }
+                break;
+            }
+            case "showAvailables": {
+                // CrewControl
+                if (this.props.module === "CrewControl") {
+                    url = "/Winops/CrewControl/CrewControlReact/GetCrewIdsOfAvailables";
+                }
+                // CrewScheduling
+                if (this.props.module === "CrewScheduling") {
+                    url = "/Winops/CrewPlanning/CrewPlanning/GetCrewIdsOfAvailables";
+                }
+                const requestOptions3 = {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        from: this.dateUTCString(this.props.startDate),
+                        to: this.dateUTCString(this.props.startDate),
+                        acftCategories: [],
+                        functions: [],
+                        clickedDate: this.dateUTCString(date),
+                        airportSelected: this.props.airportSelected,
+                    }),
+                };
+                if (this.state.dataConfig) {
+                    fetch(this.state.dataConfig + url, requestOptions3)
+                        .then((response) => response.json())
+                        .then((res) => {
+                        if (res.length > 0) {
+                            this.scheduler_handlePinnedClickMultipleIds(res, schedulerId, "Availables");
+                        }
+                        else {
+                            alert("No Availables");
+                        }
+                    });
+                }
+                break;
+            }
+            default: {
+                if (this.props.scheduler_handleOnClickContextMenuResource) {
+                    this.props.scheduler_handleOnClickContextMenuResource(date, resource, key);
+                }
+                break;
+            }
+        }
+    };
+    dateUTCString(date) {
+        if (date instanceof Date) {
+            if (date.getFullYear() > 1901)
+                return new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes())).toISOString();
+        }
+        return date;
+    }
+    render() {
+        const havePinnedResources = this.state.pinnedResources?.length > 0;
+        const firstSchedulerResources = havePinnedResources
+            ? this.props.resourcesToPin.filter((x) => this.state.pinnedResources.includes(x.id))
+            : new Array();
+        const secondSchedulerResources = this.props.resources.filter((x) => !this.state.pinnedResources.includes(x.id));
+        const pinnedEvents = this.props.pinnedEvents !== undefined
+            ? this.props.pinnedEvents.filter((x) => this.state.pinnedResources.includes(x.resourceId))
+            : new Array();
+        const notPinnedEvents = this.props.events.filter((x) => !this.props.pinnedResources?.includes(x.resourceId));
+        return (_jsxs("div", { className: "cwelltSuperScheduler_content", children: [_jsx(CwScheduler2, { id: "crewPinnedScheduler", events: pinnedEvents, resources: firstSchedulerResources, height: this.state.height, startDate: this.props.startDate, endDate: this.props.endDate, scheduler_handleCblEventClick: this.props.scheduler_handleCblEventClick, scheduler_handleCblEventClickRight: this.props.scheduler_handleCblEventClickRight, scheduler_handleCblEventDoubleClick: this.props.scheduler_handleCblEventDoubleClick, scheduler_handleOnDropCblEventsOnResource: this.props.scheduler_handleOnDropCblEventsOnResource, parent: this.props.parent, cblEventComp: this.props.cblEventComp, scheduler_handleOnClickEventContextMenu: this.props.scheduler_handleOnClickEventContextMenu, resourceComp: this.props.resourceComp, scheduler_handleOnClickContextMenuResource: this.props.scheduler_handleOnClickContextMenuResource, resourceContextMenuContents: this.props.resourceContextMenuContents, scheduler_handleDblClickOnResourceInScheduler: this.props.scheduler_handleDblClickOnResourceInScheduler, scheduler_handleEmptyClick: this.props.scheduler_handleEmptyClick, canBePinned: false, scheduler_handlePinned: this.scheduler_handlePinnedClick, resourceName: this.props.resourceName, descriptionColumn: this.props.descriptionColumn, scheduler_handleOnClickResourceContextMenu: this.props.scheduler_handleOnClickResourceContextMenu, groupByFunction: this.props.groupByFunction }), havePinnedResources && (_jsx("div", { style: { padding: "0.5rem" }, children: _jsx(CwButton, { text: "Clear", onClick: () => {
+                            this.props.scheduler_handleClearPinnedOnParent();
+                        } }) })), _jsx(CwScheduler2, { id: "crewAssignmentsScheduler", events: notPinnedEvents, resources: secondSchedulerResources, height: this.props.height, startDate: this.props.startDate, endDate: this.props.endDate, scheduler_handleCblEventClick: this.props.scheduler_handleCblEventClick, scheduler_handleCblEventClickRight: this.props.scheduler_handleCblEventClickRight, scheduler_handleCblEventDoubleClick: this.props.scheduler_handleCblEventDoubleClick, scheduler_handleOnDropCblEventsOnResource: this.props.scheduler_handleOnDropCblEventsOnResource, parent: this.props.parent, cblEventComp: this.props.cblEventComp, scheduler_handleOnClickEventContextMenu: this.props.scheduler_handleOnClickEventContextMenu, resourceComp: this.props.resourceComp, scheduler_handleOnClickContextMenuResource: this.handleOnClickContextMenuResource, resourceContextMenuContents: this.props.resourceContextMenuContents, scheduler_handleDblClickOnResourceInScheduler: this.props.scheduler_handleDblClickOnResourceInScheduler, scheduler_handleEmptyClick: this.props.scheduler_handleEmptyClick, canBePinned: true, scheduler_handlePinned: this.scheduler_handlePinnedClick, scheduler_handleCblEventResize: this.props.scheduler_handleCblEventResize, resourceName: this.props.resourceName, descriptionColumn: this.props.descriptionColumn, scheduler_handleOnClickResourceContextMenu: this.props.scheduler_handleOnClickResourceContextMenu, airportSelected: this.props.airportSelected, module: this.props.module, groupByFunction: this.props.groupByFunction })] }));
+    }
+}
+export class CblDragAndDrop {
+    fromId;
+    toId;
+    data;
+    droppedOnDate;
+    resizeFromStart;
+    resizeFromEnd;
+    isCtrlKey;
+    constructor(fromId, toId, data, droppedOnDate = null, resizeFromStart = null, resizeFromEnd = null, isCtrlKey = null) {
+        this.fromId = fromId;
+        this.toId = toId;
+        this.data = data;
+        this.droppedOnDate = droppedOnDate;
+        this.resizeFromStart = resizeFromStart;
+        this.resizeFromEnd = resizeFromEnd;
+        this.isCtrlKey = isCtrlKey;
+    }
+}