Files
cal.diy/packages/lib/schedules/transformers/for-atom.ts
T
Lauris Skraucis c25c835b76 refactor: api v2 schedules (#14870)
* api: createSchedule refactor - still need to handle overrides

* createSchedule: handle overrides

* createSchedule: default schedule e2e test fix and pad hours:minutes

* get default schedule, by id and all schedules

* update schedule

* refactor: update handler delete only if overrides or availabilities given

* remove comment

* refactor: move schedules inputs, outputs to platform-types + e2e tests refactor

* refactor e2e

* fix: overrides and test

* fix managed user create

* my brain is fried but refactor good

* WIP: transform api schedule for atom

* WIP: transform api schedule for atom

* WIP: transform api schedule for atom

* fix: re-export atom transformer from lib

* fix: format schedule for api from atom

* fix ts ignore

* refactor: move schedule hooks into hooks/schedules

* feat: useSchedules hook to get count of user schedules

* tests: setup atom tests & test transformScheduleForAtom

* rename transformers

* test transformAtomScheduleForApi

* reset scheduel update handler for trpc

* fix: import path

* refactor: transformers

* swagger docs fix

* get rid of unused availabilities module

* get rid of eslint-disable-next-line in schedules repository

* refactor: remove crypto from atoms vite rollupOptions

* refactor: comment schedules repository update logic
2024-05-16 15:20:13 +03:00

95 lines
3.1 KiB
TypeScript

import type { Availability } from "@prisma/client";
import dayjs from "@calcom/dayjs";
import { getWorkingHours } from "@calcom/lib/availability";
import { yyyymmdd } from "@calcom/lib/date-fns";
import type { Schedule, TimeRange } from "@calcom/types/schedule";
type ScheduleAvailability = Pick<Availability, "days" | "startTime" | "endTime">[];
type ScheduleOverride = Pick<Availability, "date" | "startTime" | "endTime">[];
export function transformWorkingHoursForAtom(schedule: {
timeZone: string | null;
availability: ScheduleAvailability;
}) {
return getWorkingHours(
{ timeZone: schedule.timeZone || undefined, utcOffset: 0 },
schedule.availability || []
);
}
export function transformAvailabilityForAtom(schedule: { availability: ScheduleAvailability }) {
return transformScheduleToAvailabilityForAtom(schedule).map((a) =>
a.map((startAndEnd) => ({
...startAndEnd,
end: new Date(startAndEnd.end.toISOString().replace("23:59:00.000Z", "23:59:59.999Z")),
}))
);
}
export function transformDateOverridesForAtom(
schedule: { availability: ScheduleOverride },
timeZone: string
) {
return schedule.availability.reduce((acc, override) => {
// only iff future date override
if (!override.date || dayjs.tz(override.date, timeZone).isBefore(dayjs(), "day")) {
return acc;
}
const newValue = {
start: dayjs
.utc(override.date)
.hour(override.startTime.getUTCHours())
.minute(override.startTime.getUTCMinutes())
.toDate(),
end: dayjs
.utc(override.date)
.hour(override.endTime.getUTCHours())
.minute(override.endTime.getUTCMinutes())
.toDate(),
};
const dayRangeIndex = acc.findIndex(
// early return prevents override.date from ever being empty.
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
(item) => yyyymmdd(item.ranges[0].start) === yyyymmdd(override.date!)
);
if (dayRangeIndex === -1) {
acc.push({ ranges: [newValue] });
return acc;
}
acc[dayRangeIndex].ranges.push(newValue);
return acc;
}, [] as { ranges: TimeRange[] }[]);
}
export const transformScheduleToAvailabilityForAtom = (schedule: { availability: ScheduleAvailability }) => {
return schedule.availability.reduce(
(schedule: Schedule, availability) => {
availability.days.forEach((day) => {
schedule[day].push({
start: new Date(
Date.UTC(
new Date().getUTCFullYear(),
new Date().getUTCMonth(),
new Date().getUTCDate(),
availability.startTime.getUTCHours(),
availability.startTime.getUTCMinutes()
)
),
end: new Date(
Date.UTC(
new Date().getUTCFullYear(),
new Date().getUTCMonth(),
new Date().getUTCDate(),
availability.endTime.getUTCHours(),
availability.endTime.getUTCMinutes()
)
),
});
});
return schedule;
},
Array.from([...Array(7)]).map(() => [])
);
};