@topconsultnpm/sdkui-react 6.19.0-dev1.9 → 6.19.0-dev2.2

package/lib/components/features/tasks/TMTasksUtils.js

@@ -0,0 +1,634 @@
+import { Task_States, PdGs, Priorities, ValidationItem, SDK_Localizator, ResultTypes, SDK_Globals } from '@topconsultnpm/sdk-ts';
+import { TMColors } from '../../../utils/theme';
+import { SDKUI_Localizator } from '../../../helper';
+import { FormModes } from '../../../ts';
+export const TEXT_SELECTED_COLOR = "#ff5e1a";
+export const BG_COLOR_INACTIVE_WIDGET = "#fff";
+export const BG_COLOR_ACTIVE_WIDGET = "#fff0b7";
+export const TEXT_NOT_SELECTED_COLOR = "#2559A5";
+export const TODAY_ROW_HIGHLIGHT_BG_COLOR = "#ffb74d";
+export const NOT_TODAY_ROW_HIGHLIGHT_COLOR = "#ff0000";
+export const NOT_TODAY_ROW_HIGHLIGHT_BG_COLOR = "#81d7fe";
+export const START_DATE_MUST_BE_BEFORE_END_DATE = "StartDateMustBeBeforeEndDate";
+export const REMINDER_TIME_MUST_BE_BEFORE_END_TIME = "ReminderTimeMustBeBeforeEndTime";
+export var AssignedTab;
+(function (AssignedTab) {
+    AssignedTab[AssignedTab["AssignedToMe"] = 0] = "AssignedToMe";
+    AssignedTab[AssignedTab["AssignedByMe"] = 1] = "AssignedByMe";
+    AssignedTab[AssignedTab["All"] = 2] = "All";
+    AssignedTab[AssignedTab["TaskNotPersonalAssignedToMe"] = 3] = "TaskNotPersonalAssignedToMe";
+    AssignedTab[AssignedTab["TaskPersonalAssignedToMe"] = 4] = "TaskPersonalAssignedToMe";
+})(AssignedTab || (AssignedTab = {}));
+const sortByEndTimeAndName = (tasks) => {
+    return tasks.sort((a, b) => {
+        // If both tasks have `endTime`
+        if (a.endTime && b.endTime) {
+            // Compare `endTime` in descending order (newest first)
+            const endTimeComparison = new Date(b.endTime).getTime() - new Date(a.endTime).getTime();
+            // If `endTime` is the same, compare `name` in ascending alphabetical order
+            return endTimeComparison !== 0
+                ? endTimeComparison
+                : (a.name ?? '').localeCompare(b.name ?? '');
+        }
+        // If only `a` has `endTime`, it should come before `b`
+        if (a.endTime)
+            return -1;
+        // If only `b` has `endTime`, it should come before `a`
+        if (b.endTime)
+            return 1;
+        // If neither has `endTime`, compare by `name` in ascending alphabetical order
+        return (a.name ?? '').localeCompare(b.name ?? '');
+    });
+};
+export const sortTasks = (tasks) => {
+    const newTasks = tasks.filter(task => checkIfNew(task.fromID, task.isNew));
+    const oldTasks = tasks.filter(task => !checkIfNew(task.fromID, task.isNew));
+    const sortedNewTasks = sortByEndTimeAndName(newTasks);
+    const sortedOldTasks = sortByEndTimeAndName(oldTasks);
+    return [...sortedNewTasks, ...sortedOldTasks];
+};
+export const taskIsToday = (startTime, endTime) => {
+    const currentDate = new Date(); // Get the current date
+    const todayDay = currentDate.getDate();
+    const todayMonth = currentDate.getMonth(); // Months are 0-indexed
+    const todayYear = currentDate.getFullYear();
+    // Convert startTime and endTime to Date objects
+    const startDate = new Date(startTime);
+    const endDate = new Date(endTime);
+    // Extract day, month, and year for startDate and endDate
+    const startDay = startDate.getDate();
+    const startMonth = startDate.getMonth();
+    const startYear = startDate.getFullYear();
+    const endDay = endDate.getDate();
+    const endMonth = endDate.getMonth();
+    const endYear = endDate.getFullYear();
+    // Check if both startDate and endDate match today's day, month, and year
+    if ((startYear < todayYear || (startYear === todayYear && startMonth < todayMonth) || (startYear === todayYear && startMonth === todayMonth && startDay <= todayDay)) &&
+        (endYear > todayYear || (endYear === todayYear && endMonth > todayMonth) || (endYear === todayYear && endMonth === todayMonth && endDay >= todayDay))) {
+        return true;
+    }
+    return false;
+};
+export const taskIsExpiringSoon = (endTime, remTime) => {
+    const now = new Date();
+    const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    // Set endTime to midnight for date-only comparison
+    const endDate = new Date(endTime.getFullYear(), endTime.getMonth(), endTime.getDate());
+    // Condition 1: Check if today is exactly one day before endTime
+    const oneDayBeforeEnd = new Date(endDate);
+    oneDayBeforeEnd.setDate(endDate.getDate() - 1);
+    const isOneDayBeforeEndTime = startOfToday.getTime() === oneDayBeforeEnd.getTime();
+    // Condition 2: Check if endTime is today
+    const isEndTimeToday = startOfToday.getTime() === endDate.getTime();
+    // Set remTime to midnight for date-only comparison if defined
+    const remDate = remTime ? new Date(remTime.getFullYear(), remTime.getMonth(), remTime.getDate()) : null;
+    // Condition 3: Check if remTime is defined and today is between remTime and endTime (inclusive)
+    const isBetweenRemAndEnd = remDate
+        ? startOfToday >= remDate && startOfToday <= endDate
+        : false;
+    // Return true if any condition is met
+    return isOneDayBeforeEndTime || isEndTimeToday || isBetweenRemAndEnd;
+};
+export const appointmentBackgroundColorFn = (startTime, endTime) => {
+    return taskIsToday(startTime, endTime) ? TODAY_ROW_HIGHLIGHT_BG_COLOR : NOT_TODAY_ROW_HIGHLIGHT_BG_COLOR;
+};
+export const getPriorityLocalizatorValues = () => {
+    // Filtered enum for Low and High values
+    const filteredPriorities = { Low: Priorities.Low, High: Priorities.High };
+    return Object.values(filteredPriorities).map(priority => {
+        switch (priority) {
+            case Priorities.High:
+                return ({ value: priority, display: SDKUI_Localizator.High });
+            default:
+                return ({ value: priority, display: SDKUI_Localizator.Low });
+        }
+    });
+};
+export const getPriorityId = (priority) => {
+    switch (priority) {
+        case Priorities.High:
+            return 2;
+        default:
+            return 1;
+    }
+};
+export const getPriorityColor = (priority) => {
+    switch (priority) {
+        case Priorities.High:
+            return LIGTH_RED_ORGANGE;
+        default:
+            return LIGTH_CYAN;
+    }
+};
+export const LIGTH_CYAN = '#80DEEA';
+export const LIGTH_RED_ORGANGE = '#FFAB91';
+export const prioritiesResourceData = [
+    { text: SDKUI_Localizator.Low, id: getPriorityId(Priorities.Low), color: LIGTH_CYAN }, // Light Cyan
+    { text: SDKUI_Localizator.High, id: getPriorityId(Priorities.High), color: LIGTH_RED_ORGANGE } // Light Red-Orange
+];
+export const getStatusLocalizatorValues = () => {
+    return Object.values(Task_States)
+        .filter(status => status !== Task_States.None) // Remove the "None" status
+        .map(status => {
+        switch (status) {
+            case Task_States.Completed:
+                return ({ value: status, display: SDKUI_Localizator.Completed });
+            case Task_States.Deferred:
+                return ({ value: status, display: SDKUI_Localizator.Postponed });
+            case Task_States.InProgress:
+                return ({ value: status, display: SDKUI_Localizator.InProgress });
+            case Task_States.NotStarted:
+                return ({ value: status, display: SDKUI_Localizator.NewFemale });
+            case Task_States.Waiting:
+                return ({ value: status, display: SDKUI_Localizator.Pending });
+            default:
+                return ({ value: status, display: "" }); // Just in case, though it won't be hit
+        }
+    });
+};
+export const getStatusLocalizatorValue = (status) => {
+    switch (status) {
+        case Task_States.Completed:
+            return SDKUI_Localizator.Completed;
+        case Task_States.Deferred:
+            return SDKUI_Localizator.Postponed;
+        case Task_States.InProgress:
+            return SDKUI_Localizator.InProgress;
+        case Task_States.Waiting:
+            return SDKUI_Localizator.Pending;
+        default:
+            return SDKUI_Localizator.NewFemale;
+    }
+};
+export const getPriorityLocalizatorValue = (priority) => {
+    switch (priority) {
+        case Priorities.High:
+            return SDKUI_Localizator.High;
+        default:
+            return SDKUI_Localizator.Low;
+    }
+};
+export const getTaskAssignedToMe = (tasks) => {
+    const userID = SDK_Globals.tmSession?.SessionDescr?.userID;
+    return tasks.filter((task) => task.fromID !== undefined && task.toID === userID);
+};
+export const getTaskNotPersonalAssignedToMe = (tasks) => {
+    const userID = SDK_Globals.tmSession?.SessionDescr?.userID;
+    return tasks
+        .filter((task) => task.fromID !== undefined &&
+        task.fromID !== userID &&
+        task.toID === userID &&
+        task.state !== Task_States.Completed)
+        .sort((a, b) => {
+        if (!a.endTime && !b.endTime)
+            return 0;
+        if (!a.endTime)
+            return 1;
+        if (!b.endTime)
+            return -1;
+        return a.endTime.getTime() - b.endTime.getTime();
+    });
+};
+export const getTaskPersonalAssignedToMe = (tasks) => {
+    const userID = SDK_Globals.tmSession?.SessionDescr?.userID;
+    return tasks
+        .filter((task) => task.fromID !== undefined &&
+        task.fromID === userID &&
+        task.toID === userID &&
+        task.state !== Task_States.Completed)
+        .sort((a, b) => {
+        if (!a.endTime && !b.endTime)
+            return 0;
+        if (!a.endTime)
+            return 1;
+        if (!b.endTime)
+            return -1;
+        return a.endTime.getTime() - b.endTime.getTime();
+    });
+};
+export const getTaskAssignedByMe = (tasks) => {
+    const userID = SDK_Globals.tmSession?.SessionDescr?.userID;
+    return tasks.filter((task) => task.toID !== undefined && task.toID !== userID);
+};
+export const getHeaderStatusFilterConfig = () => ({
+    enabled: true,
+    dataSource: getStatusLocalizatorValues().map(item => ({
+        text: item.display,
+        value: item.value,
+    })),
+});
+export const getHeaderPriorityFilterConfig = () => ({
+    enabled: true,
+    dataSource: getPriorityLocalizatorValues().map(item => ({
+        text: item.display,
+        value: item.value,
+    })),
+});
+export const TaskView = {
+    LIST_TASK: 'LIST_TASK',
+    AGENDA_TASK: 'AGENDA_TASK',
+    CALENDAR_TASK: 'CALENDAR_TASK'
+};
+export var Extended_Task_States;
+(function (Extended_Task_States) {
+    Extended_Task_States["Init"] = "Init";
+    Extended_Task_States["Expiring"] = "Expiring";
+    Extended_Task_States["AssignedToMe"] = "AssignedToMe";
+    Extended_Task_States["AssignedByMe"] = "AssignedByMe";
+    Extended_Task_States["NewAssignedActivities"] = "NewAssignedActivities";
+})(Extended_Task_States || (Extended_Task_States = {}));
+export const getTaskColor = (taskState) => {
+    let color;
+    switch (taskState) {
+        case Task_States.Completed:
+            color = TMColors.success;
+            break;
+        case Task_States.Deferred:
+            color = TMColors.error;
+            break;
+        case Task_States.InProgress:
+            color = TMColors.secondary;
+            break;
+        case Task_States.NotStarted:
+            color = TMColors.primary;
+            break;
+        case Task_States.Waiting:
+            color = TMColors.tertiary;
+            break;
+        default:
+            color = TMColors.secondary;
+            break;
+    }
+    return { color };
+};
+export const mergeUniqueTasks = (existing, // Array of existing tasks
+newTasks // Array of new tasks to merge
+) => {
+    const taskMap = new Map(); // Create a map to hold tasks by ID
+    // Add existing tasks to the map, checking that the ID is defined
+    existing.forEach(task => {
+        if (task.id !== undefined) {
+            taskMap.set(task.id, task);
+        } // Store the existing task in the map
+    });
+    // Add new tasks to the map, overriding existing tasks with the same ID
+    newTasks.forEach(task => {
+        if (task.id !== undefined) {
+            taskMap.set(task.id, task);
+        } // Store the new task, replacing existing ones with the same ID
+    });
+    // Return the values of the map as an array, which contains unique tasks
+    return Array.from(taskMap.values());
+};
+export const getOriginLabel = (pdg, ID1Name) => {
+    return pdg ? (ID1Name ?? '') : SDKUI_Localizator.NoSource;
+};
+export const taskValidatorAsync = async (taskDescriptor) => {
+    let vil = [];
+    // Validate task name
+    if (!taskDescriptor.name || taskDescriptor.name === "")
+        vil.push(new ValidationItem(ResultTypes.ERROR, SDKUI_Localizator.Name, `${SDK_Localizator.RequiredField}`));
+    // Validate name length (max 100)
+    if (taskDescriptor.name && taskDescriptor.name.length > 100) {
+        vil.push(new ValidationItem(ResultTypes.ERROR, SDKUI_Localizator.Name, `${SDKUI_Localizator.NameTooLong.replaceParams(100)}`));
+    }
+    // Validate description length (max 200)
+    if (taskDescriptor.description && taskDescriptor.description.length > 200) {
+        vil.push(new ValidationItem(ResultTypes.ERROR, SDKUI_Localizator.Description, `${SDKUI_Localizator.DescriptionTooLongMessage.replaceParams(200)}`));
+    }
+    // Validate toID
+    if (!taskDescriptor.toID || taskDescriptor.toID <= 0)
+        vil.push(new ValidationItem(ResultTypes.ERROR, SDKUI_Localizator.AssignedTo, `${SDK_Localizator.RequiredField}`));
+    // Validate that startTime is less than or equal to endTime
+    if (taskDescriptor.startTime && taskDescriptor.endTime) {
+        if (taskDescriptor.startTime > taskDescriptor.endTime) {
+            vil.push(new ValidationItem(ResultTypes.ERROR, SDKUI_Localizator.ErrorStartEndDate, `${SDKUI_Localizator.StartDateMustBeBeforeEndDate}`));
+        }
+    }
+    // Validate that reminderTime is less than endTime
+    if (taskDescriptor.remTime && taskDescriptor.endTime) {
+        if (taskDescriptor.remTime >= taskDescriptor.endTime) {
+            vil.push(new ValidationItem(ResultTypes.ERROR, SDKUI_Localizator.ErrorEndRemDate, `${SDKUI_Localizator.ReminderDateMustBeBeforeEndDate}`));
+        }
+    }
+    return vil;
+};
+const getPDGExtended = (pdg) => {
+    switch (pdg) {
+        case PdGs.WG:
+            return SDKUI_Localizator.WorkGroup;
+        case PdGs.CF:
+            return SDKUI_Localizator.Practice;
+        case PdGs.DT:
+            return SDKUI_Localizator.Document;
+        case PdGs.WF:
+            return SDKUI_Localizator.Workflow;
+        default:
+            return pdg;
+    }
+};
+export const gotoPDGExtendedLabel = (gotoVisible, pdg, iD1Name) => {
+    return (gotoVisible ? (SDKUI_Localizator.GoTo + ' ') : '') + getPDGExtended(pdg) + ': ' + (iD1Name ?? '-');
+};
+const subtractMinutes = (date, minutes) => {
+    const result = new Date(date);
+    result.setMinutes(result.getMinutes() - minutes);
+    return result;
+};
+export const convertToSchedulerAppointments = (tasks) => {
+    const adjustEndTime = (endTime) => {
+        if (!endTime)
+            return undefined;
+        const date = new Date(endTime);
+        // Check if time is exactly 00:00
+        if (date.getHours() === 0 && date.getMinutes() === 0) {
+            date.setDate(date.getDate() - 1); // Move to the previous day
+            date.setHours(23, 59, 0, 0); // Set time to 23:59:00
+        }
+        return date;
+    };
+    if (tasks.length === 0)
+        return [];
+    const appointments = [];
+    tasks.forEach((task, index) => {
+        if (task.startTime !== undefined || task.endTime !== undefined) {
+            appointments.push({
+                key: `${task.id}-${index}`,
+                id: task.id,
+                text: task.name,
+                startDate: task.startTime ? task.startTime : (task.endTime ? subtractMinutes(task.endTime, 30) : undefined),
+                endDate: adjustEndTime(task.endTime),
+                priority: getPriorityId(task.priority ?? Priorities.Low)
+            });
+        }
+    });
+    return appointments;
+};
+export const formatDate = (date) => {
+    // Get the month, day, hours, and minutes from the date
+    const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are 0-indexed
+    const day = String(date.getDate()).padStart(2, '0');
+    const year = date.getFullYear();
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    // Return the formatted date string
+    return `${day}/${month}/${year} ${hours}:${minutes}:${seconds}`;
+};
+export const areDifferentIDs = (fromID, userID) => {
+    if (fromID && userID) {
+        return fromID !== userID;
+    }
+    return false;
+};
+export const createTasksMenuItems = (taskDescriptor, showId, setShowId, showSearch, setShowSearch, openTaskForm, openEditTaskForm, openDuplicateTaskForm, onDeleteCallback, markAsStatus, getAllTasks, fromWG, showContextualWG, setShowContextualWG, fromDossier, showContextualDossier, setShowContextualDossier, fromDocument, showContextualDocument, setShowContextualDocument, showGoToToday, handleGoToToday, fromDatagrid = true) => {
+    const isTaskDescriptorDefined = taskDescriptor !== undefined;
+    const isTaskFromAnotherUser = isTaskDescriptorDefined && areDifferentIDs(taskDescriptor.fromID, SDK_Globals.tmSession?.SessionDescr?.userID);
+    const menuItems = [
+        {
+            id: 'createContextualTask',
+            text: SDKUI_Localizator.CreateContextualTask,
+            icon: 'plus',
+            onClick: () => { openTaskForm(FormModes.Create, undefined, true); },
+            disabled: false
+        },
+        {
+            text: SDKUI_Localizator.Create,
+            icon: 'plus',
+            onClick: () => { openTaskForm(FormModes.Create, undefined, false); },
+            disabled: false
+        },
+        {
+            text: SDKUI_Localizator.Update,
+            icon: 'edit',
+            onClick: openEditTaskForm,
+            operationType: 'singleRow',
+            disabled: fromDatagrid ? false : !isTaskDescriptorDefined
+        },
+        {
+            text: SDKUI_Localizator.Duplicate,
+            icon: 'copy',
+            onClick: openDuplicateTaskForm,
+            operationType: 'singleRow',
+            disabled: fromDatagrid ? isTaskFromAnotherUser : !isTaskDescriptorDefined || isTaskFromAnotherUser
+        },
+        {
+            text: SDKUI_Localizator.Delete,
+            icon: 'trash',
+            onClick: onDeleteCallback,
+            operationType: 'multiRow',
+            disabled: fromDatagrid ? isTaskFromAnotherUser : !isTaskDescriptorDefined || isTaskFromAnotherUser
+        },
+        {
+            icon: 'optionsgear',
+            text: SDKUI_Localizator.MarkAs,
+            id: "markAs",
+            operationType: 'multiRow',
+            disabled: fromDatagrid ? false : !isTaskDescriptorDefined,
+            items: [
+                { icon: 'isblank', text: SDKUI_Localizator.NewFemale, operationType: 'multiRow', onClick: (rowIds) => markAsStatus(rowIds, Task_States.NotStarted) },
+                { icon: 'refresh', text: SDKUI_Localizator.InProgress, operationType: 'multiRow', onClick: (rowIds) => markAsStatus(rowIds, Task_States.InProgress) },
+                { icon: 'check', text: SDKUI_Localizator.Completed, operationType: 'multiRow', onClick: (rowIds) => markAsStatus(rowIds, Task_States.Completed) },
+                { icon: 'taskstop', text: SDKUI_Localizator.Pending, operationType: 'multiRow', onClick: (rowIds) => markAsStatus(rowIds, Task_States.Waiting) },
+                { icon: 'clock', text: SDKUI_Localizator.Postponed, operationType: 'multiRow', onClick: (rowIds) => markAsStatus(rowIds, Task_States.Deferred) }
+            ]
+        },
+        {
+            id: 'wgContextFilter',
+            text: showContextualWG ? SDKUI_Localizator.RemoveContextualFilter : SDKUI_Localizator.ApplyContextualFilter,
+            icon: 'filter',
+            onClick: () => { setShowContextualWG(prev => !prev); },
+            disabled: false,
+            beginGroup: true,
+            visible: fromWG
+        },
+        {
+            id: 'dossierContextFilter',
+            text: showContextualDossier ? SDKUI_Localizator.RemoveContextualFilter : SDKUI_Localizator.ApplyContextualFilter,
+            icon: 'filter',
+            onClick: () => { setShowContextualDossier(prev => !prev); },
+            disabled: false,
+            beginGroup: !fromWG && !fromDocument,
+            visible: fromDossier
+        },
+        {
+            id: 'documentContextFilter',
+            text: showContextualDocument ? SDKUI_Localizator.RemoveContextualFilter : SDKUI_Localizator.ApplyContextualFilter,
+            icon: 'filter',
+            onClick: () => { setShowContextualDocument(prev => !prev); },
+            disabled: false,
+            beginGroup: !fromDossier && !fromWG,
+            visible: fromDocument
+        },
+        {
+            icon: "event",
+            onClick: () => { if (handleGoToToday) {
+                handleGoToToday();
+            } },
+            text: SDKUI_Localizator.GoToToday,
+            disabled: false,
+            beginGroup: true,
+        },
+        {
+            beginGroup: true,
+            icon: showSearch ? "eyeclose" : "eyeopen",
+            onClick: () => setShowSearch(prevShowSearch => !prevShowSearch),
+            text: showSearch ? SDKUI_Localizator.HideSearch : SDKUI_Localizator.ShowSearch,
+            disabled: false
+        },
+        {
+            icon: showId ? "eyeclose" : "eyeopen",
+            onClick: () => setShowId(prevShowId => !prevShowId),
+            text: showId ? SDKUI_Localizator.ID_Hide : SDKUI_Localizator.ID_Show,
+            disabled: false
+        },
+        {
+            text: SDKUI_Localizator.Refresh,
+            icon: 'refresh',
+            onClick: () => getAllTasks(),
+            disabled: false,
+        },
+    ];
+    // Apply filters
+    let filteredMenuItems = [...menuItems];
+    // Show "CreateContextualTask" only if we are in a WG or Dossier context
+    if (fromWG === false && fromDossier === false && fromDocument === false) {
+        filteredMenuItems = filteredMenuItems.filter(item => item.id !== 'createContextualTask');
+    }
+    // Remove WG contextual filter menu if not in WG context
+    if (fromWG === false) {
+        filteredMenuItems = filteredMenuItems.filter(item => item.id !== 'wgContextFilter' ||
+            item.visible !== true ||
+            item.visible === undefined);
+    }
+    // Remove Dossier contextual filter menu if not in Dossier context
+    if (fromDossier === false) {
+        filteredMenuItems = filteredMenuItems.filter(item => item.id !== 'dossierContextFilter' ||
+            item.visible !== true ||
+            item.visible === undefined);
+    }
+    // Remove Document contextual filter menu if not in Document context
+    if (fromDocument === false) {
+        filteredMenuItems = filteredMenuItems.filter(item => item.id !== 'documentContextFilter' ||
+            item.visible !== true ||
+            item.visible === undefined);
+    }
+    if (showGoToToday === false) {
+        filteredMenuItems = filteredMenuItems.filter(item => item.text !== SDKUI_Localizator.GoToToday);
+    }
+    return filteredMenuItems;
+};
+export const checkIfNew = (fromId, isNew) => {
+    return fromId && fromId !== SDK_Globals.tmSession?.SessionDescr?.userID && isNew ? isNew === 1 : false;
+};
+export const getNewTaskCount = (tasks) => {
+    return tasks.filter(task => checkIfNew(task.fromID, task.isNew)).length;
+};
+export const isTaskAssignedToAnotherUser = (task) => {
+    const userID = SDK_Globals.tmSession?.SessionDescr?.userID;
+    return task.toID !== userID;
+};
+export const getMondayOfCurrentWeek = (date) => {
+    const dayOfWeek = date.getDay(); // Sunday = 0, Monday = 1, ..., Saturday = 6
+    const differenceToMonday = (dayOfWeek === 0 ? 6 : dayOfWeek - 1); // Calculate difference to previous Monday
+    date.setDate(date.getDate() - differenceToMonday); // Adjust the date to Monday
+    date.setHours(0, 0, 0, 0); // Reset the time part of the date
+    return date;
+};
+export const getSundayOfCurrentWeek = (date) => {
+    const result = new Date(date);
+    const dayOfWeek = result.getDay(); // Sunday = 0, Monday = 1, ..., Saturday = 6
+    const differenceToSunday = 7 - dayOfWeek; // Calculate days to next Sunday
+    result.setDate(result.getDate() + differenceToSunday); // Adjust the date to Sunday
+    result.setHours(0, 0, 0, 0); // Reset the time part of the date
+    return result;
+};
+export const getFirstDayOfMonth = (date) => {
+    const result = new Date(date);
+    result.setMonth(result.getMonth() - 2); // Move to the previous month
+    result.setDate(1); // Set the date to the first day of the previous month
+    result.setHours(0, 0, 0, 0); // Reset the time part to midnight
+    return result;
+};
+export const getLastDayOfMonth = (date) => {
+    const result = new Date(date);
+    result.setMonth(result.getMonth() + 2); // Move to the next month
+    result.setDate(0); // Set the date to the last day of the current month
+    result.setHours(0, 0, 0, 0); // Reset the time part to midnight
+    return result;
+};
+export const findTasksBySearch = (visualizedTasks, searchText) => {
+    const searchTextLower = searchText.toLowerCase();
+    return visualizedTasks
+        .filter(task => {
+        const stateLabel = getStatusLocalizatorValue(task.state ?? Task_States.None);
+        const priorityLabel = getPriorityLocalizatorValue(task.priority ?? Priorities.None);
+        return ((task.id && task.id.toString().toLowerCase().includes(searchTextLower)) ||
+            (task.name && task.name.toLowerCase().includes(searchTextLower)) ||
+            (task.description && task.description.toLowerCase().includes(searchTextLower)) ||
+            (stateLabel && stateLabel.toLowerCase().includes(searchTextLower)) ||
+            (task.fromName && task.fromName.toLowerCase().includes(searchTextLower)) ||
+            (task.toName && task.toName.toLowerCase().includes(searchTextLower)) ||
+            (task.priority && priorityLabel.toLowerCase().includes(searchTextLower)));
+    });
+};
+export var FilterCategoryId;
+(function (FilterCategoryId) {
+    FilterCategoryId[FilterCategoryId["AllStates"] = 1] = "AllStates";
+    FilterCategoryId[FilterCategoryId["AllPriorities"] = 2] = "AllPriorities";
+    FilterCategoryId[FilterCategoryId["NewAssignedActivities"] = 1.05] = "NewAssignedActivities";
+    FilterCategoryId[FilterCategoryId["Expiring"] = 1.1] = "Expiring";
+    FilterCategoryId[FilterCategoryId["New"] = 1.2] = "New";
+    FilterCategoryId[FilterCategoryId["InProgress"] = 1.3] = "InProgress";
+    FilterCategoryId[FilterCategoryId["Completed"] = 1.4] = "Completed";
+    FilterCategoryId[FilterCategoryId["Pending"] = 1.5] = "Pending";
+    FilterCategoryId[FilterCategoryId["Postponed"] = 1.6] = "Postponed";
+    FilterCategoryId[FilterCategoryId["Low"] = 2.1] = "Low";
+    FilterCategoryId[FilterCategoryId["Normal"] = 2.2] = "Normal";
+    FilterCategoryId[FilterCategoryId["High"] = 2.3] = "High";
+})(FilterCategoryId || (FilterCategoryId = {}));
+export const filterTreeTask = (tasks, filtersApplied) => {
+    const filters = {
+        [FilterCategoryId.AllStates]: (task) => !task.state || (Object.values(Task_States).includes(task.state)),
+        [FilterCategoryId.AllPriorities]: (task) => !task.priority || (Object.values(Priorities).includes(task.priority)),
+        [FilterCategoryId.NewAssignedActivities]: (task) => checkIfNew(task.fromID, task.isNew),
+        [FilterCategoryId.Expiring]: (task) => task.state !== Task_States.Completed && task.endTime && taskIsExpiringSoon(task.endTime, task.remTime),
+        [FilterCategoryId.New]: (task) => task.state === undefined || task.state === Task_States.NotStarted,
+        [FilterCategoryId.InProgress]: (task) => task.state === Task_States.InProgress,
+        [FilterCategoryId.Completed]: (task) => task.state === Task_States.Completed,
+        [FilterCategoryId.Pending]: (task) => task.state === Task_States.Waiting,
+        [FilterCategoryId.Postponed]: (task) => task.state === Task_States.Deferred,
+        // Low = Low + Normal: Merged 'Low' and 'Normal' filters for backwards compatibility
+        [FilterCategoryId.Low]: (task) => task.priority === undefined || task.priority === Priorities.None || task.priority === Priorities.Low || task.priority === Priorities.Normal,
+        [FilterCategoryId.Normal]: (task) => task.priority === undefined || task.priority === Priorities.None || task.priority === Priorities.Low || task.priority === Priorities.Normal,
+        [FilterCategoryId.High]: (task) => task.priority === Priorities.High,
+    };
+    // Separate filters into levels
+    const stateFilters = filtersApplied.filter(filter => filter < 2); // Level 1: AllStates and task state-related filters
+    const priorityFilters = filtersApplied.filter(filter => filter >= 2); // Level 2: AllPriorities and task priority-related filters
+    const filteredTasks = tasks.filter((task) => {
+        // OR logic within the state filter level
+        const matchesStateFilters = stateFilters.length === 0 || stateFilters.some((filterApplied) => filters[filterApplied] && filters[filterApplied](task));
+        // OR logic within the priority filter level
+        const matchesPriorityFilters = priorityFilters.length === 0 || priorityFilters.some((filterApplied) => filters[filterApplied] && filters[filterApplied](task));
+        // AND logic between state and priority filter levels
+        return matchesStateFilters && matchesPriorityFilters;
+    });
+    return filteredTasks;
+};
+export const applyContextFilters = (allTasks, showContextualWG, showContextualDossier, showContextualDocument, taskContext) => {
+    if (taskContext === undefined)
+        return allTasks;
+    let filtered = allTasks;
+    if (showContextualWG && taskContext.workingGroup?.id) {
+        filtered = filtered.filter(t => t.iD1?.toString() === taskContext.workingGroup?.id.toString());
+    }
+    if (showContextualDossier && taskContext.dossier?.id) {
+        filtered = filtered.filter(t => t.iD1?.toString() === taskContext.dossier?.id.toString());
+    }
+    if (showContextualDocument && taskContext.document?.tid && taskContext?.document?.did) {
+        filtered = filtered.filter(t => t.iD1?.toString() === taskContext.document?.tid.toString() &&
+            t.iD2?.toString() === taskContext.document?.did.toString());
+    }
+    return filtered;
+};

package/lib/components/features/tasks/TMTasksUtilsView.d.ts

@@ -0,0 +1,39 @@
+import { ReactNode } from "react";
+import { PdGs, Task_States, TaskDescriptor } from '@topconsultnpm/sdk-ts';
+import { FormModes } from "../../../ts";
+export declare const taskStateIconMap: (fontSize?: number) => Map<Task_States, JSX.Element>;
+export declare const calculateNumberOfDays: (startTime: Date | undefined, endTime: Date | undefined) => number;
+export declare const renderTaskIcons: (taskData: {
+    stateLabel: Task_States;
+    stateTooltipLabel: string;
+    pdg: PdGs | undefined;
+    ID1Name: string;
+    endTime: Date | undefined;
+    remTime: Date | undefined;
+    isNew: boolean;
+    numberOfDays: number;
+}) => import("react/jsx-runtime").JSX.Element;
+interface TMActionCalendarProps {
+    currentTask: TaskDescriptor;
+    openTaskForm: (formMode: FormModes, task?: TaskDescriptor) => void;
+    onDeleteCallback: (rowIds: Array<number>) => void;
+}
+export declare const TMActionCalendar: (props: TMActionCalendarProps) => import("react/jsx-runtime").JSX.Element;
+export declare const priorityLegend: () => import("react/jsx-runtime").JSX.Element;
+export declare const highlightTaskText: (text: string, search: string, taskId: number) => string | (string | import("react/jsx-runtime").JSX.Element)[];
+export declare const treeFilterDataSource: (allTasks: Array<TaskDescriptor>) => Array<{
+    id: number;
+    label: string;
+    value: string;
+    categoryId?: number;
+    expanded?: boolean;
+    tooltipContent?: ReactNode;
+}>;
+type RenderContextBlockParams = {
+    condition: boolean;
+    pdg: PdGs;
+    label: string | undefined;
+    isMobile: boolean;
+};
+export declare const renderContextBlock: ({ condition, pdg, label, isMobile }: RenderContextBlockParams) => JSX.Element | null;
+export {};