Refactor imports (#470)

src/features/Calendars/CalendarApi.ts

@@ -1,4 +1,4 @@
-import { api } from "../../utils/apiUtils";
+import { api } from "@/utils/apiUtils";
 
 export async function getCalendars(
   userId: string,

src/features/Calendars/CalendarSlice.ts

@@ -1,40 +1,27 @@
-import { createAsyncThunk, createSlice, PayloadAction } from "@reduxjs/toolkit";
-import { Calendar } from "./CalendarTypes";
+import { extractEventBaseUuid } from "@/utils/extractEventBaseUuid";
+import { browserDefaultTimeZone } from "@/utils/timezone";
+import { createSlice, PayloadAction } from "@reduxjs/toolkit";
 import { CalendarEvent } from "../Events/EventsTypes";
+import { Calendar } from "./CalendarTypes";
 import {
-  addSharedCalendar,
-  getCalendar,
-  getCalendars,
-  postCalendar,
-  proppatchCalendar,
-  removeCalendar,
-  updateAclCalendar,
-} from "./CalendarApi";
-import { getUserDetails } from "../User/userAPI";
-import { parseCalendarEvent } from "../Events/eventUtils";
-import {
-  deleteEvent,
-  deleteEventInstance,
-  getEvent,
-  importEventFromFile,
-  moveEvent,
-  putEvent,
-  putEventWithOverrides,
-  updateSeries,
-} from "../Events/EventApi";
-import {
-  computeWeekRange,
-  formatDateToYYYYMMDDTHHMMSS,
-} from "../../utils/dateUtils";
-import { User } from "../../components/Attendees/PeopleSearch";
-import { getCalendarVisibility } from "../../components/Calendar/utils/calendarUtils";
-import { importFile } from "../../utils/apiUtils";
-import { formatReduxError } from "../../utils/errorUtils";
-import { browserDefaultTimeZone } from "../../utils/timezone";
-import { getCalendarDetailAsync } from "./services/getCalendarDetailAsync";
-import { refreshCalendarWithSyncToken } from "./services/refreshCalendar";
-import { getCalendarsListAsync } from "./services/getCalendarsListAsync";
-import { extractEventBaseUuid } from "../../utils/extractEventBaseUuid";
+  addSharedCalendarAsync,
+  createCalendarAsync,
+  deleteEventAsync,
+  deleteEventInstanceAsync,
+  getCalendarDetailAsync,
+  getCalendarsListAsync,
+  getEventAsync,
+  getTempCalendarsListAsync,
+  importEventFromFileAsync,
+  moveEventAsync,
+  patchACLCalendarAsync,
+  patchCalendarAsync,
+  putEventAsync,
+  refreshCalendarWithSyncToken,
+  removeCalendarAsync,
+  updateEventInstanceAsync,
+  updateSeriesAsync,
+} from "./services";
 
 // Define error type for rejected actions
 export interface RejectedError {
@@ -42,459 +29,6 @@ export interface RejectedError {
   status?: number;
 }
 
-export const getTempCalendarsListAsync = createAsyncThunk<
-  Record<string, Calendar>,
-  User,
-  { rejectValue: RejectedError }
->("calendars/getTempCalendars", async (tempUser, { rejectWithValue }) => {
-  try {
-    const importedCalendars: Record<string, Calendar> = {};
-
-    const calendars = (await getCalendars(
-      tempUser.openpaasId ?? "",
-      "sharedPublic=true&"
-    )) as Record<string, any>;
-
-    const rawCalendars = calendars._embedded?.["dav:calendar"];
-    if (!rawCalendars || rawCalendars.length === 0) {
-      const userName = tempUser.displayName || tempUser.email || "User";
-      // Format: TRANSLATION:key|param1=value1
-      const encodedName = encodeURIComponent(userName);
-      throw new Error(
-        `TRANSLATION:calendar.userDoesNotHavePublicCalendars|name=${encodedName}`
-      );
-    }
-
-    for (const cal of rawCalendars) {
-      const name = cal["dav:name"];
-      const description = cal["caldav:description"];
-      const delegated = cal["calendarserver:delegatedsource"] ? true : false;
-      const source = cal["calendarserver:source"]
-        ? cal["calendarserver:source"]._links.self.href
-        : cal._links.self.href;
-      const link = cal._links.self.href;
-
-      const id = source.replace("/calendars/", "").replace(".json", "");
-      const visibility = getCalendarVisibility(cal["acl"]);
-      const ownerData: any = await getUserDetails(id.split("/")[0]);
-
-      importedCalendars[id] = {
-        id,
-        name,
-        link,
-        owner: `${ownerData.firstname ? `${ownerData.firstname} ` : ""}${ownerData.lastname}`,
-        ownerEmails: ownerData.emails,
-        description,
-        delegated,
-        color: {
-          light: tempUser.color?.light ?? "#a8a8a8ff",
-          dark: tempUser.color?.dark ?? "#a8a8a8ff",
-        },
-        visibility,
-        events: {},
-      };
-    }
-
-    return importedCalendars;
-  } catch (err: any) {
-    return rejectWithValue({
-      message: formatReduxError(err),
-      status: err.response?.status,
-    });
-  }
-});
-
-export const putEventAsync = createAsyncThunk<
-  { calId: string; events: CalendarEvent[]; calType?: "temp" },
-  { cal: Calendar; newEvent: CalendarEvent; calType?: "temp" },
-  { rejectValue: RejectedError }
->(
-  "calendars/putEvent",
-  async ({ cal, newEvent, calType }, { rejectWithValue }) => {
-    try {
-      await putEvent(
-        newEvent,
-        cal.ownerEmails ? cal.ownerEmails[0] : undefined
-      );
-      const eventDate = new Date(newEvent.start);
-
-      const { start: weekStart, end: weekEnd } = computeWeekRange(eventDate);
-
-      const calEvents = (await getCalendar(cal.id, {
-        start: formatDateToYYYYMMDDTHHMMSS(weekStart),
-        end: formatDateToYYYYMMDDTHHMMSS(weekEnd),
-      })) as Record<string, any>;
-      const events: CalendarEvent[] = calEvents._embedded["dav:item"].flatMap(
-        (eventdata: any) => {
-          const vevents = eventdata.data[2] as any[][];
-          const eventURL = eventdata._links.self.href;
-          const valarm = eventdata.data[2][0][2][0];
-          return vevents.map((vevent: any[]) => {
-            return parseCalendarEvent(
-              vevent[1],
-              cal.color ?? {},
-              cal.id,
-              eventURL,
-              valarm
-            );
-          });
-        }
-      );
-
-      return {
-        calId: cal.id,
-        events,
-        calType,
-      };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const getEventAsync = createAsyncThunk<
-  { calId: string; event: CalendarEvent },
-  CalendarEvent,
-  { rejectValue: RejectedError }
->("calendars/getEvent", async (event, { rejectWithValue }) => {
-  try {
-    const response: CalendarEvent = await getEvent(event);
-    return {
-      calId: event.calId,
-      event: response,
-    };
-  } catch (err: any) {
-    return rejectWithValue({
-      message: formatReduxError(err),
-      status: err.response?.status,
-    });
-  }
-});
-
-export const patchCalendarAsync = createAsyncThunk<
-  {
-    calId: string;
-    calLink: string;
-    patch: { name: string; desc: string; color: Record<string, string> };
-  },
-  {
-    calId: string;
-    calLink: string;
-    patch: { name: string; desc: string; color: Record<string, string> };
-  },
-  { rejectValue: RejectedError }
->(
-  "calendars/patchCalendar",
-  async ({ calId, calLink, patch }, { rejectWithValue }) => {
-    try {
-      await proppatchCalendar(calLink, patch);
-      return {
-        calId,
-        calLink,
-        patch,
-      };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const removeCalendarAsync = createAsyncThunk<
-  {
-    calId: string;
-  },
-  {
-    calId: string;
-    calLink: string;
-  },
-  { rejectValue: RejectedError }
->(
-  "calendars/removeCalendar",
-  async ({ calId, calLink }, { rejectWithValue }) => {
-    try {
-      await removeCalendar(calLink);
-      return {
-        calId,
-        calLink,
-      };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const moveEventAsync = createAsyncThunk<
-  { calId: string; events: CalendarEvent[] },
-  { cal: Calendar; newEvent: CalendarEvent; newURL: string },
-  { rejectValue: RejectedError }
->(
-  "calendars/moveEvent",
-  async ({ cal, newEvent, newURL }, { rejectWithValue }) => {
-    try {
-      await moveEvent(newEvent, newURL);
-
-      const eventDate = new Date(newEvent.start);
-      const { start: weekStart, end: weekEnd } = computeWeekRange(eventDate);
-
-      const calEvents = (await getCalendar(cal.id, {
-        start: formatDateToYYYYMMDDTHHMMSS(weekStart),
-        end: formatDateToYYYYMMDDTHHMMSS(weekEnd),
-      })) as Record<string, any>;
-      const events: CalendarEvent[] = calEvents._embedded["dav:item"].flatMap(
-        (eventdata: any) => {
-          const vevents = eventdata.data[2] as any[][];
-          const eventURL = eventdata._links.self.href;
-          return vevents.map((vevent: any[]) => {
-            return parseCalendarEvent(
-              vevent[1],
-              cal.color ?? {},
-              cal.id,
-              eventURL
-            );
-          });
-        }
-      );
-
-      return {
-        calId: cal.id,
-        events,
-      };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const patchACLCalendarAsync = createAsyncThunk<
-  {
-    calId: string;
-    calLink: string;
-    request: string;
-  },
-  {
-    calId: string;
-    calLink: string;
-    request: string;
-  },
-  { rejectValue: RejectedError }
->(
-  "calendars/requestACLCalendar",
-  async ({ calId, calLink, request }, { rejectWithValue }) => {
-    try {
-      const response = await updateAclCalendar(calLink, request);
-      return {
-        calId,
-        calLink,
-        request,
-      };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const deleteEventAsync = createAsyncThunk<
-  { calId: string; eventId: string },
-  { calId: string; eventId: string; eventURL: string },
-  { rejectValue: RejectedError }
->(
-  "calendars/delEvent",
-  async ({ calId, eventId, eventURL }, { rejectWithValue }) => {
-    try {
-      await deleteEvent(eventURL);
-      return { calId, eventId };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const deleteEventInstanceAsync = createAsyncThunk<
-  { calId: string; eventId: string },
-  { cal: Calendar; event: CalendarEvent },
-  { rejectValue: RejectedError }
->("calendars/delEventInstance", async ({ cal, event }, { rejectWithValue }) => {
-  try {
-    await deleteEventInstance(event, cal.ownerEmails?.[0]);
-    return { calId: cal.id, eventId: event.uid };
-  } catch (err: any) {
-    return rejectWithValue({
-      message: formatReduxError(err),
-      status: err.response?.status,
-    });
-  }
-});
-
-export const updateEventInstanceAsync = createAsyncThunk<
-  { calId: string; event: CalendarEvent },
-  { cal: Calendar; event: CalendarEvent },
-  { rejectValue: RejectedError }
->(
-  "calendars/updateEventInstance",
-  async ({ cal, event }, { rejectWithValue }) => {
-    try {
-      await putEventWithOverrides(event, cal.ownerEmails?.[0]);
-      return { calId: cal.id, event };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const updateSeriesAsync = createAsyncThunk<
-  void,
-  { cal: Calendar; event: CalendarEvent; removeOverrides?: boolean },
-  { rejectValue: RejectedError }
->(
-  "calendars/updateSeries",
-  async ({ cal, event, removeOverrides = true }, { rejectWithValue }) => {
-    try {
-      await updateSeries(event, cal.ownerEmails?.[0], removeOverrides);
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const createCalendarAsync = createAsyncThunk<
-  {
-    userId: string;
-    calId: string;
-    color: Record<string, string>;
-    name: string;
-    desc: string;
-    owner: string;
-    ownerEmails: string[];
-  },
-  {
-    userId: string;
-    calId: string;
-    color: Record<string, string>;
-    name: string;
-    desc: string;
-  },
-  { rejectValue: RejectedError }
->(
-  "calendars/createCalendar",
-  async ({ userId, calId, color, name, desc }, { rejectWithValue }) => {
-    try {
-      await postCalendar(userId, calId, color, name, desc);
-      const ownerData: any = await getUserDetails(userId.split("/")[0]);
-
-      return {
-        userId,
-        calId,
-        color,
-        name,
-        desc,
-        owner: `${ownerData.firstname ? `${ownerData.firstname} ` : ""}${
-          ownerData.lastname
-        }`,
-        ownerEmails: ownerData.emails,
-      };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const addSharedCalendarAsync = createAsyncThunk<
-  {
-    calId: string;
-    color: Record<string, string>;
-    link: string;
-    name: string;
-    desc: string;
-    owner: string;
-    ownerEmails: string[];
-  },
-  { userId: string; calId: string; cal: Record<string, any> },
-  { rejectValue: RejectedError }
->(
-  "calendars/addSharedCalendar",
-  async ({ userId, calId, cal }, { rejectWithValue }) => {
-    try {
-      await addSharedCalendar(userId, calId, cal);
-      const ownerData: any = await getUserDetails(
-        cal.cal._links.self.href
-          .replace("/calendars/", "")
-          .replace(".json", "")
-          .split("/")[0]
-      );
-
-      return {
-        calId: cal.cal._links.self.href
-          .replace("/calendars/", "")
-          .replace(".json", ""),
-        color: cal.color,
-        link: `/calendars/${userId}/${calId}.json`,
-        desc: cal.cal["caldav:description"],
-        name:
-          ownerData.id !== userId && cal.cal["dav:name"] === "#default"
-            ? `${ownerData.firstname ? `${ownerData.firstname} ` : ""}${
-                ownerData.lastname
-              }` + "'s calendar"
-            : cal.cal["dav:name"],
-        owner: `${ownerData.firstname ? `${ownerData.firstname} ` : ""}${
-          ownerData.lastname
-        }`,
-        ownerEmails: ownerData.emails,
-      };
-    } catch (err: any) {
-      return rejectWithValue({
-        message: formatReduxError(err),
-        status: err.response?.status,
-      });
-    }
-  }
-);
-
-export const importEventFromFileAsync = createAsyncThunk<
-  void,
-  {
-    calLink: string;
-    file: File;
-  },
-  { rejectValue: RejectedError }
->("calendars/importEvent", async ({ calLink, file }, { rejectWithValue }) => {
-  try {
-    const id = ((await importFile(file)) as Record<string, string>)._id;
-    const response = await importEventFromFile(id, calLink);
-  } catch (err: any) {
-    return rejectWithValue({
-      message: formatReduxError(err),
-      status: err.response?.status,
-    });
-  }
-});
-
 const CalendarSlice = createSlice({
   name: "calendars",
   initialState: {

src/features/Calendars/api/fetchSyncTokenChanges.ts

@@ -1,4 +1,4 @@
-import { api } from "../../../utils/apiUtils";
+import { api } from "@/utils/apiUtils";
 import { Calendar } from "../CalendarTypes";
 import { DavSyncResponse } from "./types";
 

src/features/Calendars/services/addSharedCalendarAsync.ts

@@ -0,0 +1,56 @@
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { getUserDetails } from "@/features/User/userAPI";
+import { addSharedCalendar } from "../CalendarApi";
+import { RejectedError } from "../CalendarSlice";
+
+export const addSharedCalendarAsync = createAsyncThunk<
+  {
+    calId: string;
+    color: Record<string, string>;
+    link: string;
+    name: string;
+    desc: string;
+    owner: string;
+    ownerEmails: string[];
+  },
+  { userId: string; calId: string; cal: Record<string, any> },
+  { rejectValue: RejectedError }
+>(
+  "calendars/addSharedCalendar",
+  async ({ userId, calId, cal }, { rejectWithValue }) => {
+    try {
+      await addSharedCalendar(userId, calId, cal);
+      const ownerData: any = await getUserDetails(
+        cal.cal._links.self.href
+          .replace("/calendars/", "")
+          .replace(".json", "")
+          .split("/")[0]
+      );
+
+      return {
+        calId: cal.cal._links.self.href
+          .replace("/calendars/", "")
+          .replace(".json", ""),
+        color: cal.color,
+        link: `/calendars/${userId}/${calId}.json`,
+        desc: cal.cal["caldav:description"],
+        name:
+          ownerData.id !== userId && cal.cal["dav:name"] === "#default"
+            ? `${ownerData.firstname ? `${ownerData.firstname} ` : ""}${
+                ownerData.lastname
+              }` + "'s calendar"
+            : cal.cal["dav:name"],
+        owner: `${ownerData.firstname ? `${ownerData.firstname} ` : ""}${
+          ownerData.lastname
+        }`,
+        ownerEmails: ownerData.emails,
+      };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/createCalendarAsync.ts

@@ -0,0 +1,50 @@
+import { getUserDetails } from "@/features/User/userAPI";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { postCalendar } from "../CalendarApi";
+import { RejectedError } from "../CalendarSlice";
+
+export const createCalendarAsync = createAsyncThunk<
+  {
+    userId: string;
+    calId: string;
+    color: Record<string, string>;
+    name: string;
+    desc: string;
+    owner: string;
+    ownerEmails: string[];
+  },
+  {
+    userId: string;
+    calId: string;
+    color: Record<string, string>;
+    name: string;
+    desc: string;
+  },
+  { rejectValue: RejectedError }
+>(
+  "calendars/createCalendar",
+  async ({ userId, calId, color, name, desc }, { rejectWithValue }) => {
+    try {
+      await postCalendar(userId, calId, color, name, desc);
+      const ownerData: any = await getUserDetails(userId.split("/")[0]);
+
+      return {
+        userId,
+        calId,
+        color,
+        name,
+        desc,
+        owner: [ownerData.firstname, ownerData.lastname]
+          .filter(Boolean)
+          .join(" "),
+        ownerEmails: ownerData.emails ?? [],
+      };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/deleteEventAsync.ts

@@ -0,0 +1,23 @@
+import { deleteEvent } from "@/features/Events/EventApi";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { RejectedError } from "../CalendarSlice";
+
+export const deleteEventAsync = createAsyncThunk<
+  { calId: string; eventId: string },
+  { calId: string; eventId: string; eventURL: string },
+  { rejectValue: RejectedError }
+>(
+  "calendars/delEvent",
+  async ({ calId, eventId, eventURL }, { rejectWithValue }) => {
+    try {
+      await deleteEvent(eventURL);
+      return { calId, eventId };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/deleteEventInstanceAsync.ts

@@ -0,0 +1,22 @@
+import { deleteEventInstance } from "@/features/Events/EventApi";
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { RejectedError } from "../CalendarSlice";
+import { Calendar } from "../CalendarTypes";
+
+export const deleteEventInstanceAsync = createAsyncThunk<
+  { calId: string; eventId: string },
+  { cal: Calendar; event: CalendarEvent },
+  { rejectValue: RejectedError }
+>("calendars/delEventInstance", async ({ cal, event }, { rejectWithValue }) => {
+  try {
+    await deleteEventInstance(event, cal.ownerEmails?.[0]);
+    return { calId: cal.id, eventId: event.uid };
+  } catch (err: any) {
+    return rejectWithValue({
+      message: formatReduxError(err),
+      status: err.response?.status,
+    });
+  }
+});

src/features/Calendars/services/getCalendarDetailAsync.ts

@@ -1,6 +1,6 @@
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { formatReduxError } from "@/utils/errorUtils";
 import { createAsyncThunk } from "@reduxjs/toolkit";
-import { formatReduxError } from "../../../utils/errorUtils";
-import { CalendarEvent } from "../../Events/EventsTypes";
 import { getCalendar } from "../CalendarApi";
 import { RejectedError } from "../CalendarSlice";
 import { extractCalendarEvents } from "../utils/extractCalendarEvents";

src/features/Calendars/services/getCalendarsListAsync.ts

@@ -1,6 +1,6 @@
+import { getOpenPaasUser, getUserDetails } from "@/features/User/userAPI";
+import { formatReduxError } from "@/utils/errorUtils";
 import { createAsyncThunk } from "@reduxjs/toolkit";
-import { formatReduxError } from "../../../utils/errorUtils";
-import { getOpenPaasUser, getUserDetails } from "../../User/userAPI";
 import { getCalendars } from "../CalendarApi";
 import { RejectedError } from "../CalendarSlice";
 import { Calendar } from "../CalendarTypes";

src/features/Calendars/services/getEventAsync.ts

@@ -0,0 +1,24 @@
+import { getEvent } from "@/features/Events/EventApi";
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { RejectedError } from "../CalendarSlice";
+
+export const getEventAsync = createAsyncThunk<
+  { calId: string; event: CalendarEvent },
+  CalendarEvent,
+  { rejectValue: RejectedError }
+>("calendars/getEvent", async (event, { rejectWithValue }) => {
+  try {
+    const response: CalendarEvent = await getEvent(event);
+    return {
+      calId: event.calId,
+      event: response,
+    };
+  } catch (err: any) {
+    return rejectWithValue({
+      message: formatReduxError(err),
+      status: err.response?.status,
+    });
+  }
+});

src/features/Calendars/services/getTempCalendarsListAsync.ts

@@ -0,0 +1,70 @@
+import { User } from "@/components/Attendees/PeopleSearch";
+import { getCalendarVisibility } from "@/components/Calendar/utils/calendarUtils";
+import { getUserDetails } from "@/features/User/userAPI";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { getCalendars } from "../CalendarApi";
+import { RejectedError } from "../CalendarSlice";
+import { Calendar } from "../CalendarTypes";
+
+export const getTempCalendarsListAsync = createAsyncThunk<
+  Record<string, Calendar>,
+  User,
+  { rejectValue: RejectedError }
+>("calendars/getTempCalendars", async (tempUser, { rejectWithValue }) => {
+  try {
+    const importedCalendars: Record<string, Calendar> = {};
+
+    const calendars = (await getCalendars(
+      tempUser.openpaasId ?? "",
+      "sharedPublic=true&"
+    )) as Record<string, any>;
+
+    const rawCalendars = calendars._embedded?.["dav:calendar"];
+    if (!rawCalendars || rawCalendars.length === 0) {
+      const userName = tempUser.displayName || tempUser.email || "User";
+      // Format: TRANSLATION:key|param1=value1
+      const encodedName = encodeURIComponent(userName);
+      throw new Error(
+        `TRANSLATION:calendar.userDoesNotHavePublicCalendars|name=${encodedName}`
+      );
+    }
+
+    for (const cal of rawCalendars) {
+      const name = cal["dav:name"];
+      const description = cal["caldav:description"];
+      const delegated = cal["calendarserver:delegatedsource"] ? true : false;
+      const source = cal["calendarserver:source"]
+        ? cal["calendarserver:source"]._links.self.href
+        : cal._links.self.href;
+      const link = cal._links.self.href;
+
+      const id = source.replace("/calendars/", "").replace(".json", "");
+      const visibility = getCalendarVisibility(cal["acl"]);
+      const ownerData: any = await getUserDetails(id.split("/")[0]);
+
+      importedCalendars[id] = {
+        id,
+        name,
+        link,
+        owner: `${ownerData.firstname ? `${ownerData.firstname} ` : ""}${ownerData.lastname}`,
+        ownerEmails: ownerData.emails,
+        description,
+        delegated,
+        color: {
+          light: tempUser.color?.light ?? "#a8a8a8ff",
+          dark: tempUser.color?.dark ?? "#a8a8a8ff",
+        },
+        visibility,
+        events: {},
+      };
+    }
+
+    return importedCalendars;
+  } catch (err: any) {
+    return rejectWithValue({
+      message: formatReduxError(err),
+      status: err.response?.status,
+    });
+  }
+});

src/features/Calendars/services/importEventFromFileAsync.ts

@@ -0,0 +1,31 @@
+import { importEventFromFile } from "@/features/Events/EventApi";
+import { importFile } from "@/utils/apiUtils";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { RejectedError } from "../CalendarSlice";
+
+export const importEventFromFileAsync = createAsyncThunk<
+  void,
+  {
+    calLink: string;
+    file: File;
+  },
+  { rejectValue: RejectedError }
+>("calendars/importEvent", async ({ calLink, file }, { rejectWithValue }) => {
+  try {
+    const response = await importFile(file);
+    const id = response?._id;
+    if (!id) {
+      return rejectWithValue({
+        message: "Failed to upload file: missing file ID",
+        status: undefined,
+      });
+    }
+    await importEventFromFile(id, calLink);
+  } catch (err: any) {
+    return rejectWithValue({
+      message: formatReduxError(err),
+      status: err.response?.status,
+    });
+  }
+});

src/features/Calendars/services/index.ts

@@ -0,0 +1,17 @@
+export { addSharedCalendarAsync } from "./addSharedCalendarAsync";
+export { createCalendarAsync } from "./createCalendarAsync";
+export { deleteEventAsync } from "./deleteEventAsync";
+export { deleteEventInstanceAsync } from "./deleteEventInstanceAsync";
+export { getCalendarDetailAsync } from "./getCalendarDetailAsync";
+export { getCalendarsListAsync } from "./getCalendarsListAsync";
+export { getEventAsync } from "./getEventAsync";
+export { getTempCalendarsListAsync } from "./getTempCalendarsListAsync";
+export { importEventFromFileAsync } from "./importEventFromFileAsync";
+export { moveEventAsync } from "./moveEventAsync";
+export { patchACLCalendarAsync } from "./patchACLCalendarAsync";
+export { patchCalendarAsync } from "./patchCalendarAsync";
+export { putEventAsync } from "./putEventAsync";
+export { refreshCalendarWithSyncToken } from "./refreshCalendar";
+export { removeCalendarAsync } from "./removeCalendarAsync";
+export { updateEventInstanceAsync } from "./updateEventInstanceAsync";
+export { updateSeriesAsync } from "./updateSeriesAsync";

src/features/Calendars/services/moveEventAsync.ts

@@ -0,0 +1,57 @@
+import { moveEvent } from "@/features/Events/EventApi";
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { parseCalendarEvent } from "@/features/Events/eventUtils";
+import {
+  computeWeekRange,
+  formatDateToYYYYMMDDTHHMMSS,
+} from "@/utils/dateUtils";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { getCalendar } from "../CalendarApi";
+import { RejectedError } from "../CalendarSlice";
+import { Calendar } from "../CalendarTypes";
+
+export const moveEventAsync = createAsyncThunk<
+  { calId: string; events: CalendarEvent[] },
+  { cal: Calendar; newEvent: CalendarEvent; newURL: string },
+  { rejectValue: RejectedError }
+>(
+  "calendars/moveEvent",
+  async ({ cal, newEvent, newURL }, { rejectWithValue }) => {
+    try {
+      await moveEvent(newEvent, newURL);
+
+      const eventDate = new Date(newEvent.start);
+      const { start: weekStart, end: weekEnd } = computeWeekRange(eventDate);
+
+      const calEvents = (await getCalendar(cal.id, {
+        start: formatDateToYYYYMMDDTHHMMSS(weekStart),
+        end: formatDateToYYYYMMDDTHHMMSS(weekEnd),
+      })) as Record<string, any>;
+      const events: CalendarEvent[] = calEvents._embedded["dav:item"].flatMap(
+        (eventdata: any) => {
+          const vevents = eventdata.data[2] as any[][];
+          const eventURL = eventdata._links.self.href;
+          return vevents.map((vevent: any[]) => {
+            return parseCalendarEvent(
+              vevent[1],
+              cal.color ?? {},
+              cal.id,
+              eventURL
+            );
+          });
+        }
+      );
+
+      return {
+        calId: cal.id,
+        events,
+      };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/patchACLCalendarAsync.ts

@@ -0,0 +1,35 @@
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { updateAclCalendar } from "../CalendarApi";
+import { RejectedError } from "../CalendarSlice";
+
+export const patchACLCalendarAsync = createAsyncThunk<
+  {
+    calId: string;
+    calLink: string;
+    request: string;
+  },
+  {
+    calId: string;
+    calLink: string;
+    request: string;
+  },
+  { rejectValue: RejectedError }
+>(
+  "calendars/requestACLCalendar",
+  async ({ calId, calLink, request }, { rejectWithValue }) => {
+    try {
+      await updateAclCalendar(calLink, request);
+      return {
+        calId,
+        calLink,
+        request,
+      };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/patchCalendarAsync.ts

@@ -0,0 +1,35 @@
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { proppatchCalendar } from "../CalendarApi";
+import { RejectedError } from "../CalendarSlice";
+
+export const patchCalendarAsync = createAsyncThunk<
+  {
+    calId: string;
+    calLink: string;
+    patch: { name: string; desc: string; color: Record<string, string> };
+  },
+  {
+    calId: string;
+    calLink: string;
+    patch: { name: string; desc: string; color: Record<string, string> };
+  },
+  { rejectValue: RejectedError }
+>(
+  "calendars/patchCalendar",
+  async ({ calId, calLink, patch }, { rejectWithValue }) => {
+    try {
+      await proppatchCalendar(calLink, patch);
+      return {
+        calId,
+        calLink,
+        patch,
+      };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/putEventAsync.ts

@@ -0,0 +1,63 @@
+import { putEvent } from "@/features/Events/EventApi";
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { parseCalendarEvent } from "@/features/Events/eventUtils";
+import {
+  computeWeekRange,
+  formatDateToYYYYMMDDTHHMMSS,
+} from "@/utils/dateUtils";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { getCalendar } from "../CalendarApi";
+import { RejectedError } from "../CalendarSlice";
+import { Calendar } from "../CalendarTypes";
+
+export const putEventAsync = createAsyncThunk<
+  { calId: string; events: CalendarEvent[]; calType?: "temp" },
+  { cal: Calendar; newEvent: CalendarEvent; calType?: "temp" },
+  { rejectValue: RejectedError }
+>(
+  "calendars/putEvent",
+  async ({ cal, newEvent, calType }, { rejectWithValue }) => {
+    try {
+      await putEvent(
+        newEvent,
+        cal.ownerEmails ? cal.ownerEmails[0] : undefined
+      );
+      const eventDate = new Date(newEvent.start);
+
+      const { start: weekStart, end: weekEnd } = computeWeekRange(eventDate);
+
+      const calEvents = (await getCalendar(cal.id, {
+        start: formatDateToYYYYMMDDTHHMMSS(weekStart),
+        end: formatDateToYYYYMMDDTHHMMSS(weekEnd),
+      })) as Record<string, any>;
+      const events: CalendarEvent[] = calEvents._embedded["dav:item"].flatMap(
+        (eventdata: any) => {
+          const vevents = eventdata.data[2] as any[][];
+          const eventURL = eventdata._links.self.href;
+          const valarm = eventdata.data[2][0][2][0];
+          return vevents.map((vevent: any[]) => {
+            return parseCalendarEvent(
+              vevent[1],
+              cal.color ?? {},
+              cal.id,
+              eventURL,
+              valarm
+            );
+          });
+        }
+      );
+
+      return {
+        calId: cal.id,
+        events,
+        calType,
+      };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/refreshCalendar.ts

@@ -1,7 +1,7 @@
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { formatReduxError } from "@/utils/errorUtils";
 import { createAsyncThunk } from "@reduxjs/toolkit";
 import pMap from "p-map";
-import { formatReduxError } from "../../../utils/errorUtils";
-import { CalendarEvent } from "../../Events/EventsTypes";
 import { fetchSyncTokenChanges } from "../api/fetchSyncTokenChanges";
 import { RejectedError } from "../CalendarSlice";
 import { Calendar } from "../CalendarTypes";

src/features/Calendars/services/removeCalendarAsync.ts

@@ -0,0 +1,30 @@
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { removeCalendar } from "../CalendarApi";
+import { RejectedError } from "../CalendarSlice";
+
+export const removeCalendarAsync = createAsyncThunk<
+  {
+    calId: string;
+  },
+  {
+    calId: string;
+    calLink: string;
+  },
+  { rejectValue: RejectedError }
+>(
+  "calendars/removeCalendar",
+  async ({ calId, calLink }, { rejectWithValue }) => {
+    try {
+      await removeCalendar(calLink);
+      return {
+        calId,
+      };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/updateEventInstanceAsync.ts

@@ -0,0 +1,25 @@
+import { putEventWithOverrides } from "@/features/Events/EventApi";
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { RejectedError } from "../CalendarSlice";
+import { Calendar } from "../CalendarTypes";
+
+export const updateEventInstanceAsync = createAsyncThunk<
+  { calId: string; event: CalendarEvent },
+  { cal: Calendar; event: CalendarEvent },
+  { rejectValue: RejectedError }
+>(
+  "calendars/updateEventInstance",
+  async ({ cal, event }, { rejectWithValue }) => {
+    try {
+      await putEventWithOverrides(event, cal.ownerEmails?.[0]);
+      return { calId: cal.id, event };
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/services/updateSeriesAsync.ts

@@ -0,0 +1,24 @@
+import { updateSeries } from "@/features/Events/EventApi";
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { formatReduxError } from "@/utils/errorUtils";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { RejectedError } from "../CalendarSlice";
+import { Calendar } from "../CalendarTypes";
+
+export const updateSeriesAsync = createAsyncThunk<
+  void,
+  { cal: Calendar; event: CalendarEvent; removeOverrides?: boolean },
+  { rejectValue: RejectedError }
+>(
+  "calendars/updateSeries",
+  async ({ cal, event, removeOverrides = true }, { rejectWithValue }) => {
+    try {
+      await updateSeries(event, cal.ownerEmails?.[0] ?? "", removeOverrides);
+    } catch (err: any) {
+      return rejectWithValue({
+        message: formatReduxError(err),
+        status: err.response?.status,
+      });
+    }
+  }
+);

src/features/Calendars/utils/expandEventFunction.ts

@@ -1,6 +1,6 @@
-import { formatDateToYYYYMMDDTHHMMSS } from "../../../utils/dateUtils";
-import { reportEvent } from "../../Events/EventApi";
-import { CalendarEvent } from "../../Events/EventsTypes";
+import { reportEvent } from "@/features/Events/EventApi";
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { formatDateToYYYYMMDDTHHMMSS } from "@/utils/dateUtils";
 import { Calendar } from "../CalendarTypes";
 import { extractCalendarEvents } from "./extractCalendarEvents";
 

src/features/Calendars/utils/extractCalendarEvents.ts

@@ -1,6 +1,6 @@
-import { defaultColors } from "../../../components/Calendar/utils/calendarColorsUtils";
-import { CalendarEvent } from "../../Events/EventsTypes";
-import { parseCalendarEvent } from "../../Events/eventUtils";
+import { defaultColors } from "@/components/Calendar/utils/calendarColorsUtils";
+import { CalendarEvent } from "@/features/Events/EventsTypes";
+import { parseCalendarEvent } from "@/features/Events/eventUtils";
 import { CalDavItem } from "../api/types";
 
 export function extractCalendarEvents(

src/features/Calendars/utils/normalizeCalendar.ts

@@ -1,4 +1,4 @@
-import { getCalendarVisibility } from "../../../components/Calendar/utils/calendarUtils";
+import { getCalendarVisibility } from "@/components/Calendar/utils/calendarUtils";
 
 export function normalizeCalendar(rawCalendar: Record<string, any>) {
   const description = rawCalendar["caldav:description"];

src/features/Events/AttendanceValidation/AttendanceValidation.tsx

@@ -1,8 +1,8 @@
+import { Calendar } from "@/features/Calendars/CalendarTypes";
+import { userData } from "@/features/User/userDataTypes";
 import { Box, Typography } from "@linagora/twake-mui";
 import { Dispatch, SetStateAction } from "react";
 import { useI18n } from "twake-i18n";
-import { Calendar } from "../../Calendars/CalendarTypes";
-import { userData } from "../../User/userDataTypes";
 import { ContextualizedEvent } from "../EventsTypes";
 import { RSVPButton } from "./RSVPButton";
 

src/features/Events/AttendanceValidation/RSVPButton.tsx

@@ -1,10 +1,10 @@
+import { useAppDispatch } from "@/app/hooks";
+import { Calendar } from "@/features/Calendars/CalendarTypes";
+import { PartStat } from "@/features/User/models/attendee";
+import { userData } from "@/features/User/userDataTypes";
 import { Button } from "@linagora/twake-mui";
 import { Dispatch, SetStateAction } from "react";
 import { useI18n } from "twake-i18n";
-import { useAppDispatch } from "../../../app/hooks";
-import { Calendar } from "../../Calendars/CalendarTypes";
-import { PartStat } from "../../User/models/attendee";
-import { userData } from "../../User/userDataTypes";
 import { ContextualizedEvent } from "../EventsTypes";
 import { handleRSVPClick } from "./handleRSVPClick";
 

src/features/Events/AttendanceValidation/handleRSVPClick.tsx

@@ -1,9 +1,9 @@
+import { AppDispatch } from "@/app/store";
+import { handleRSVP } from "@/components/Event/eventHandlers/eventHandlers";
+import { Calendar } from "@/features/Calendars/CalendarTypes";
+import { PartStat } from "@/features/User/models/attendee";
+import { userData } from "@/features/User/userDataTypes";
 import { Dispatch, SetStateAction } from "react";
-import { AppDispatch } from "../../../app/store";
-import { handleRSVP } from "../../../components/Event/eventHandlers/eventHandlers";
-import { Calendar } from "../../Calendars/CalendarTypes";
-import { PartStat } from "../../User/models/attendee";
-import { userData } from "../../User/userDataTypes";
 import { ContextualizedEvent } from "../EventsTypes";
 
 export async function handleRSVPClick(

src/features/Events/EventApi.ts

@@ -1,5 +1,10 @@
-import { api } from "../../utils/apiUtils";
-import { TIMEZONES } from "../../utils/timezone-data";
+import { detectDateTimeFormat } from "@/components/Event/utils/dateTimeHelpers";
+import { api } from "@/utils/apiUtils";
+import { extractEventBaseUuid } from "@/utils/extractEventBaseUuid";
+import { TIMEZONES } from "@/utils/timezone-data";
+import ICAL from "ical.js";
+import moment from "moment-timezone";
+import { CalDavItem } from "../Calendars/api/types";
 import { CalendarEvent } from "./EventsTypes";
 import {
   calendarEventToJCal,
@@ -7,11 +12,6 @@ import {
   makeVevent,
   parseCalendarEvent,
 } from "./eventUtils";
-import ICAL from "ical.js";
-import moment from "moment-timezone";
-import { detectDateTimeFormat } from "../../components/Event/utils/dateTimeHelpers";
-import { CalDavItem } from "../Calendars/api/types";
-import { extractEventBaseUuid } from "../../utils/extractEventBaseUuid";
 
 function resolveTimezoneId(tzid?: string): string | undefined {
   if (!tzid) return undefined;

src/features/Events/EventDisplayPreview.tsx

@@ -1,4 +1,30 @@
+import { useAppDispatch, useAppSelector } from "@/app/hooks";
+import { CalendarName } from "@/components/Calendar/CalendarName";
+import { getTimezoneOffset } from "@/components/Calendar/TimezoneSelector";
+import {
+  formatEventChipTitle,
+  updateTempCalendar,
+} from "@/components/Calendar/utils/calendarUtils";
+import ResponsiveDialog from "@/components/Dialog/ResponsiveDialog";
+import { EditModeDialog } from "@/components/Event/EditModeDialog";
+import EventDuplication from "@/components/Event/EventDuplicate";
+import { handleDelete } from "@/components/Event/eventHandlers/eventHandlers";
+import { InfoRow } from "@/components/Event/InfoRow";
+import { renderAttendeeBadge } from "@/components/Event/utils/eventUtils";
+import { getCalendarRange } from "@/utils/dateUtils";
+import { browserDefaultTimeZone } from "@/utils/timezone";
 import { DateSelectArg } from "@fullcalendar/core";
+import {
+  AvatarGroup,
+  Box,
+  Button,
+  Chip,
+  IconButton,
+  Menu,
+  MenuItem,
+  Tooltip,
+  Typography,
+} from "@linagora/twake-mui";
 import CalendarTodayIcon from "@mui/icons-material/CalendarToday";
 import CircleIcon from "@mui/icons-material/Circle";
 import CloseIcon from "@mui/icons-material/Close";
@@ -13,42 +39,16 @@ import PeopleAltOutlinedIcon from "@mui/icons-material/PeopleAltOutlined";
 import RepeatIcon from "@mui/icons-material/Repeat";
 import SubjectIcon from "@mui/icons-material/Subject";
 import VideocamOutlinedIcon from "@mui/icons-material/VideocamOutlined";
-import { Box, Typography } from "@linagora/twake-mui";
-import EventPopover from "./EventModal";
-import {
-  Button,
-  Chip,
-  IconButton,
-  Menu,
-  MenuItem,
-  Tooltip,
-} from "@linagora/twake-mui";
-import { AvatarGroup } from "@linagora/twake-mui";
-import { useEffect, useState, useRef } from "react";
-import { useAppDispatch, useAppSelector } from "../../app/hooks";
-import { CalendarName } from "../../components/Calendar/CalendarName";
-import { getTimezoneOffset } from "../../components/Calendar/TimezoneSelector";
-import {
-  formatEventChipTitle,
-  updateTempCalendar,
-} from "../../components/Calendar/utils/calendarUtils";
-import ResponsiveDialog from "../../components/Dialog/ResponsiveDialog";
-import { EditModeDialog } from "../../components/Event/EditModeDialog";
-import EventDuplication from "../../components/Event/EventDuplicate";
-import { handleDelete } from "../../components/Event/eventHandlers/eventHandlers";
-import { InfoRow } from "../../components/Event/InfoRow";
-import { renderAttendeeBadge } from "../../components/Event/utils/eventUtils";
-import { getCalendarRange } from "../../utils/dateUtils";
-import { deleteEventAsync } from "../Calendars/CalendarSlice";
+import { useEffect, useRef, useState } from "react";
+import { useI18n } from "twake-i18n";
+import { deleteEventAsync } from "../Calendars/services";
+import { userAttendee } from "../User/models/attendee";
+import { AttendanceValidation } from "./AttendanceValidation/AttendanceValidation";
+import { createEventContext } from "./createEventContext";
 import { dlEvent } from "./EventApi";
+import EventPopover from "./EventModal";
 import { CalendarEvent } from "./EventsTypes";
 import EventUpdateModal from "./EventUpdateModal";
-import { useI18n } from "twake-i18n";
-import { userAttendee } from "../User/models/attendee";
-import { browserDefaultTimeZone } from "../../utils/timezone";
-import { AttendanceValidation } from "./AttendanceValidation/AttendanceValidation";
-import { Calendar } from "../Calendars/CalendarTypes";
-import { createEventContext } from "./createEventContext";
 
 export default function EventPreviewModal({
   eventId,

src/features/Events/EventModal.tsx

@@ -1,47 +1,47 @@
-import { CalendarApi, DateSelectArg } from "@fullcalendar/core";
-import { Box, Button } from "@linagora/twake-mui";
-import AddIcon from "@mui/icons-material/Add";
-import React, {
-  useEffect,
-  useState,
-  useMemo,
-  useCallback,
-  useRef,
-  startTransition,
-} from "react";
-import { useAppDispatch, useAppSelector } from "../../app/hooks";
-import { ResponsiveDialog } from "../../components/Dialog";
-import { putEventAsync } from "../Calendars/CalendarSlice";
-import { Calendar } from "../Calendars/CalendarTypes";
-import { userAttendee } from "../User/models/attendee";
-import { CalendarEvent, RepetitionObject } from "./EventsTypes";
-import { createSelector } from "@reduxjs/toolkit";
-import { TIMEZONES } from "../../utils/timezone-data";
-import { addVideoConferenceToDescription } from "../../utils/videoConferenceUtils";
+import { useAppDispatch, useAppSelector } from "@/app/hooks";
 import {
   getTimezoneOffset,
   resolveTimezone,
-} from "../../components/Calendar/TimezoneSelector";
-import { getCalendarRange } from "../../utils/dateUtils";
-import { updateTempCalendar } from "../../components/Calendar/utils/calendarUtils";
-import EventFormFields from "../../components/Event/EventFormFields";
+} from "@/components/Calendar/TimezoneSelector";
+import { updateTempCalendar } from "@/components/Calendar/utils/calendarUtils";
+import { ResponsiveDialog } from "@/components/Dialog";
+import EventFormFields from "@/components/Event/EventFormFields";
+import { addDays } from "@/components/Event/utils/dateRules";
 import {
-  formatLocalDateTime,
   formatDateTimeInTimezone,
-} from "../../components/Event/utils/dateTimeFormatters";
-import { convertFormDateTimeToISO } from "../../components/Event/utils/dateTimeHelpers";
-import { addDays } from "../../components/Event/utils/dateRules";
-import { useI18n } from "twake-i18n";
+  formatLocalDateTime,
+} from "@/components/Event/utils/dateTimeFormatters";
+import { convertFormDateTimeToISO } from "@/components/Event/utils/dateTimeHelpers";
+import { getCalendarRange } from "@/utils/dateUtils";
 import {
-  saveEventFormDataToTemp,
-  restoreEventFormDataFromTemp as restoreEventFormDataFromStorage,
-  clearEventFormTempData,
-  showErrorNotification,
   buildEventFormTempData,
-  restoreFormDataFromTemp,
+  clearEventFormTempData,
   EventFormState,
-} from "../../utils/eventFormTempStorage";
-import { browserDefaultTimeZone } from "../../utils/timezone";
+  restoreEventFormDataFromTemp as restoreEventFormDataFromStorage,
+  restoreFormDataFromTemp,
+  saveEventFormDataToTemp,
+  showErrorNotification,
+} from "@/utils/eventFormTempStorage";
+import { browserDefaultTimeZone } from "@/utils/timezone";
+import { TIMEZONES } from "@/utils/timezone-data";
+import { addVideoConferenceToDescription } from "@/utils/videoConferenceUtils";
+import { CalendarApi, DateSelectArg } from "@fullcalendar/core";
+import { Box, Button } from "@linagora/twake-mui";
+import AddIcon from "@mui/icons-material/Add";
+import { createSelector } from "@reduxjs/toolkit";
+import React, {
+  startTransition,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import { useI18n } from "twake-i18n";
+import { Calendar } from "../Calendars/CalendarTypes";
+import { putEventAsync } from "../Calendars/services";
+import { userAttendee } from "../User/models/attendee";
+import { CalendarEvent, RepetitionObject } from "./EventsTypes";
 
 function EventPopover({
   open,

src/features/Events/EventUpdateModal.tsx

@@ -1,48 +1,50 @@
-import { Box, Button } from "@linagora/twake-mui";
-import AddIcon from "@mui/icons-material/Add";
-import { useEffect, useState, useMemo, useCallback, useRef } from "react";
-import { useAppDispatch, useAppSelector } from "../../app/hooks";
-import { ResponsiveDialog } from "../../components/Dialog";
+import { useAppDispatch, useAppSelector } from "@/app/hooks";
+import { updateAttendeesAfterTimeChange } from "@/components/Calendar/handlers/eventHandlers";
+import { updateTempCalendar } from "@/components/Calendar/utils/calendarUtils";
+import { ResponsiveDialog } from "@/components/Dialog";
+import EventFormFields from "@/components/Event/EventFormFields";
+import { addDays } from "@/components/Event/utils/dateRules";
+import { formatDateTimeInTimezone } from "@/components/Event/utils/dateTimeFormatters";
+import { convertFormDateTimeToISO } from "@/components/Event/utils/dateTimeHelpers";
+import { refreshCalendars } from "@/components/Event/utils/eventUtils";
 import {
-  putEventAsync,
-  removeEvent,
   moveEventAsync,
+  putEventAsync,
   updateEventInstanceAsync,
   updateSeriesAsync,
-  updateEventLocal,
+} from "@/features/Calendars/services";
+import { getCalendarRange } from "@/utils/dateUtils";
+import {
+  buildEventFormTempData,
+  clearEventFormTempData,
+  EventFormContext,
+  EventFormState,
+  restoreEventFormDataFromTemp as restoreEventFormDataFromStorage,
+  restoreFormDataFromTemp,
+  saveEventFormDataToTemp,
+  showErrorNotification,
+} from "@/utils/eventFormTempStorage";
+import { extractEventBaseUuid } from "@/utils/extractEventBaseUuid";
+import { browserDefaultTimeZone } from "@/utils/timezone";
+import { TIMEZONES } from "@/utils/timezone-data";
+import { addVideoConferenceToDescription } from "@/utils/videoConferenceUtils";
+import { Box, Button } from "@linagora/twake-mui";
+import AddIcon from "@mui/icons-material/Add";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useI18n } from "twake-i18n";
+import {
   clearFetchCache,
+  removeEvent,
+  updateEventLocal,
 } from "../Calendars/CalendarSlice";
 import { Calendar } from "../Calendars/CalendarTypes";
 import { userAttendee } from "../User/models/attendee";
+import { deleteEvent, getEvent, putEvent } from "./EventApi";
 import { CalendarEvent, RepetitionObject } from "./EventsTypes";
-import { TIMEZONES } from "../../utils/timezone-data";
-import { addVideoConferenceToDescription } from "../../utils/videoConferenceUtils";
-import EventFormFields from "../../components/Event/EventFormFields";
-import { formatDateTimeInTimezone } from "../../components/Event/utils/dateTimeFormatters";
-import { addDays } from "../../components/Event/utils/dateRules";
-import { getEvent, deleteEvent, putEvent } from "./EventApi";
-import { refreshCalendars } from "../../components/Event/utils/eventUtils";
-import { getCalendarRange } from "../../utils/dateUtils";
 import {
   combineMasterDateWithFormTime,
   detectRecurringEventChanges,
 } from "./eventUtils";
-import { updateTempCalendar } from "../../components/Calendar/utils/calendarUtils";
-import { useI18n } from "twake-i18n";
-import { updateAttendeesAfterTimeChange } from "../../components/Calendar/handlers/eventHandlers";
-import { convertFormDateTimeToISO } from "../../components/Event/utils/dateTimeHelpers";
-import {
-  saveEventFormDataToTemp,
-  restoreEventFormDataFromTemp as restoreEventFormDataFromStorage,
-  clearEventFormTempData,
-  showErrorNotification,
-  buildEventFormTempData,
-  restoreFormDataFromTemp,
-  EventFormState,
-  EventFormContext,
-} from "../../utils/eventFormTempStorage";
-import { browserDefaultTimeZone } from "../../utils/timezone";
-import { extractEventBaseUuid } from "../../utils/extractEventBaseUuid";
 
 function EventUpdateModal({
   eventId,

src/features/Events/EventsTypes.ts

@@ -18,7 +18,7 @@ export interface CalendarEvent {
   organizer?: userOrganiser;
   attendee: userAttendee[];
   stamp?: string;
-  sequence?: Number;
+  sequence?: number;
   color?: Record<string, string>;
   allday?: boolean;
   error?: string;

src/features/Events/ImportAlert.tsx

@@ -1,6 +1,6 @@
-import { useState, useMemo, useEffect } from "react";
-import { useAppSelector } from "../../app/hooks";
-import { EventErrorSnackbar } from "../../components/Error/ErrorSnackbar";
+import { useAppSelector } from "@/app/hooks";
+import { EventErrorSnackbar } from "@/components/Error/ErrorSnackbar";
+import { useMemo, useState } from "react";
 
 export default function ImportAlert() {
   const calendars = useAppSelector((state) => state.calendars.list);

src/features/Events/eventUtils.ts

@@ -1,14 +1,14 @@
-import { userAttendee } from "../User/models/attendee";
-import { AlarmObject, CalendarEvent, RepetitionObject } from "./EventsTypes";
-import ICAL from "ical.js";
-import { TIMEZONES } from "../../utils/timezone-data";
-import moment from "moment-timezone";
 import {
   convertFormDateTimeToISO,
   detectDateTimeFormat,
-} from "../../components/Event/utils/dateTimeHelpers";
+} from "@/components/Event/utils/dateTimeHelpers";
+import { extractEventBaseUuid } from "@/utils/extractEventBaseUuid";
+import { TIMEZONES } from "@/utils/timezone-data";
+import ICAL from "ical.js";
+import moment from "moment-timezone";
+import { userAttendee } from "../User/models/attendee";
 import { createAttendee } from "../User/models/attendee.mapper";
-import { extractEventBaseUuid } from "../../utils/extractEventBaseUuid";
+import { AlarmObject, CalendarEvent, RepetitionObject } from "./EventsTypes";
 type RawEntry = [string, Record<string, string>, string, any];
 
 function resolveTimezoneId(tzid?: string): string | undefined {

src/features/Events/formHelpers.ts

@@ -1,11 +1,11 @@
-import { TIMEZONES } from "../../utils/timezone-data";
-import { resolveTimezone } from "../../components/Calendar/TimezoneSelector";
-import { CalendarEvent, RepetitionObject } from "./EventsTypes";
+import { resolveTimezone } from "@/components/Calendar/TimezoneSelector";
+import { formatDateTimeInTimezone } from "@/components/Event/utils/dateTimeFormatters";
+import { extractEventBaseUuid } from "@/utils/extractEventBaseUuid";
+import { browserDefaultTimeZone } from "@/utils/timezone";
+import { TIMEZONES } from "@/utils/timezone-data";
+import { addVideoConferenceToDescription } from "@/utils/videoConferenceUtils";
 import { userAttendee } from "../User/models/attendee";
-import { formatDateTimeInTimezone } from "../../components/Event/utils/dateTimeFormatters";
-import { addVideoConferenceToDescription } from "../../utils/videoConferenceUtils";
-import { browserDefaultTimeZone } from "../../utils/timezone";
-import { extractEventBaseUuid } from "../../utils/extractEventBaseUuid";
+import { CalendarEvent, RepetitionObject } from "./EventsTypes";
 
 export interface TimezoneListResult {
   zones: string[];

src/features/Search/SearchResultsPage.tsx

@@ -1,25 +1,24 @@
+import { useAppDispatch, useAppSelector } from "@/app/hooks";
+import { AppDispatch } from "@/app/store";
+import { browserDefaultTimeZone } from "@/utils/timezone";
+import {
+  Box,
+  Button,
+  CircularProgress,
+  IconButton,
+  Stack,
+  Typography,
+} from "@linagora/twake-mui";
 import ArrowBackIcon from "@mui/icons-material/ArrowBack";
 import RepeatIcon from "@mui/icons-material/Repeat";
 import SquareRoundedIcon from "@mui/icons-material/SquareRounded";
 import VideocamIcon from "@mui/icons-material/Videocam";
-import {
-  Box,
-  Button,
-  IconButton,
-  Stack,
-  Typography,
-  CircularProgress,
-} from "@linagora/twake-mui";
-import { useI18n } from "twake-i18n";
 import { useState } from "react";
-import { useAppDispatch, useAppSelector } from "../../app/hooks";
-import { AppDispatch } from "../../app/store";
+import { useI18n } from "twake-i18n";
 import logo from "../../static/noResult-logo.svg";
-import { browserDefaultTimeZone } from "../../utils/timezone";
-import { getEventAsync } from "../Calendars/CalendarSlice";
+import { getEventAsync } from "../Calendars/services";
 import EventPreviewModal from "../Events/EventDisplayPreview";
 import { CalendarEvent } from "../Events/EventsTypes";
-
 import { setView } from "../Settings/SettingsSlice";
 import "./searchResult.styl";
 

src/features/Search/SearchSlice.ts

@@ -1,5 +1,5 @@
+import { formatReduxError } from "@/utils/errorUtils";
 import { createAsyncThunk, createSlice, PayloadAction } from "@reduxjs/toolkit";
-import { formatReduxError } from "../../utils/errorUtils";
 import { searchEvent } from "../Events/EventApi";
 
 export interface SearchResultsState {

src/features/Settings/SettingsPage.tsx

@@ -1,48 +1,47 @@
-import React, { useState } from "react";
+import { useAppDispatch, useAppSelector } from "@/app/hooks";
+import {
+  getTimezoneOffset,
+  useTimeZoneList,
+} from "@/components/Calendar/TimezoneSelector";
+import { TimezoneAutocomplete } from "@/components/Timezone/TimezoneAutocomplete";
+import { browserDefaultTimeZone } from "@/utils/timezone";
 import {
   Box,
+  FormControl,
+  FormControlLabel,
+  IconButton,
   List,
   ListItem,
   ListItemIcon,
   ListItemText,
-  Tabs,
-  Tab,
-  IconButton,
-  FormControl,
-  Select,
   MenuItem,
-  Typography,
+  Select,
   Snackbar,
   Switch,
-  FormControlLabel,
+  Tab,
+  Tabs,
+  Typography,
 } from "@linagora/twake-mui";
 import ArrowBackIcon from "@mui/icons-material/ArrowBack";
 import SettingsIcon from "@mui/icons-material/Settings";
-// import SyncIcon from "@mui/icons-material/Sync";
-import { useAppDispatch, useAppSelector } from "../../app/hooks";
+import React, { useState } from "react";
+import { useI18n } from "twake-i18n";
 import {
-  setView,
-  setLanguage as setSettingsLanguage,
-  setTimeZone as setSettingsTimeZone,
-  setIsBrowserDefaultTimeZone,
-  setHideDeclinedEvents,
-  setDisplayWeekNumbers,
-} from "./SettingsSlice";
-import {
-  updateUserConfigurationsAsync,
+  setAlarmEmails,
   setLanguage as setUserLanguage,
   setTimezone as setUserTimeZone,
-  setAlarmEmails,
+  updateUserConfigurationsAsync,
 } from "../User/userSlice";
 import { AVAILABLE_LANGUAGES } from "./constants";
-import { useI18n } from "twake-i18n";
 import "./SettingsPage.styl";
 import {
-  useTimeZoneList,
-  getTimezoneOffset,
-} from "../../components/Calendar/TimezoneSelector";
-import { TimezoneAutocomplete } from "../../components/Timezone/TimezoneAutocomplete";
-import { browserDefaultTimeZone } from "../../utils/timezone";
+  setDisplayWeekNumbers,
+  setHideDeclinedEvents,
+  setIsBrowserDefaultTimeZone,
+  setLanguage as setSettingsLanguage,
+  setTimeZone as setSettingsTimeZone,
+  setView,
+} from "./SettingsSlice";
 
 type SidebarNavItem = "settings" | "sync";
 type SettingsSubTab = "settings" | "notifications";

src/features/Settings/SettingsSlice.ts

@@ -1,5 +1,5 @@
+import { browserDefaultTimeZone } from "@/utils/timezone";
 import { createSlice, PayloadAction } from "@reduxjs/toolkit";
-import { browserDefaultTimeZone } from "../../utils/timezone";
 import { getOpenPaasUserDataAsync } from "../User/userSlice";
 
 export interface SettingsState {

src/features/User/HandleLogin.tsx

@@ -1,11 +1,11 @@
+import { useAppDispatch, useAppSelector } from "@/app/hooks";
+import { Loading } from "@/components/Loading/Loading";
+import { redirectTo } from "@/utils/apiUtils";
 import { useEffect, useRef } from "react";
-import { useAppDispatch, useAppSelector } from "../../app/hooks";
-import { Auth } from "./oidcAuth";
-import { Loading } from "../../components/Loading/Loading";
 import { push } from "redux-first-history";
-import { redirectTo } from "../../utils/apiUtils";
+import { getCalendarsListAsync } from "../Calendars/services";
+import { Auth } from "./oidcAuth";
 import { getOpenPaasUserDataAsync, setTokens, setUserData } from "./userSlice";
-import { getCalendarsListAsync } from "../Calendars/services/getCalendarsListAsync";
 
 export function HandleLogin() {
   const userData = useAppSelector((state) => state.user);

src/features/User/LoginCallback.tsx

@@ -1,15 +1,15 @@
+import { useAppDispatch } from "@/app/hooks";
+import { Loading } from "@/components/Loading/Loading";
 import { useEffect, useRef } from "react";
-import { Callback } from "./oidcAuth";
-import { useAppDispatch } from "../../app/hooks";
 import { push } from "redux-first-history";
+import { getCalendarsListAsync } from "../Calendars/services";
+import { Callback } from "./oidcAuth";
 import {
   getOpenPaasUserDataAsync,
   setTokens,
   setUserData,
   setUserError,
 } from "./userSlice";
-import { Loading } from "../../components/Loading/Loading";
-import { getCalendarsListAsync } from "../Calendars/services/getCalendarsListAsync";
 
 export function CallbackResume() {
   const dispatch = useAppDispatch();

src/features/User/oidcAuth.ts

@@ -1,5 +1,5 @@
 import * as client from "openid-client";
-import { getLocation } from "../../utils/apiUtils";
+import { getLocation } from "@/utils/apiUtils";
 
 export const clientConfig = {
   url: (window as any).SSO_BASE_URL ?? "",

src/features/User/userAPI.ts

@@ -1,5 +1,5 @@
-import { User } from "../../components/Attendees/PeopleSearch";
-import { api } from "../../utils/apiUtils";
+import { User } from "@/components/Attendees/PeopleSearch";
+import { api } from "@/utils/apiUtils";
 
 export async function getOpenPaasUser() {
   const user = await api.get(`api/user`);

src/features/User/userSlice.ts

@@ -1,11 +1,11 @@
+import { formatReduxError } from "@/utils/errorUtils";
 import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
-import { userData, userOrganiser } from "./userDataTypes";
 import {
   getOpenPaasUser,
   updateUserConfigurations,
   UserConfigurationUpdates,
 } from "./userAPI";
-import { formatReduxError } from "../../utils/errorUtils";
+import { userData, userOrganiser } from "./userDataTypes";
 
 export const getOpenPaasUserDataAsync = createAsyncThunk<
   Record<string, any>,