applications/calendar/src/app/helpers/event.ts

   1 import { ICAL_ATTENDEE_STATUS, ICAL_EVENT_STATUS } from '@proton/shared/lib/calendar/constants';
   2 import { getIsAddressActive } from '@proton/shared/lib/helpers/address';
   3 import type { Address } from '@proton/shared/lib/interfaces';
   4 import type { EventModelReadView } from '@proton/shared/lib/interfaces/calendar';
   5
   6 import { getParticipantsError } from '../components/eventModal/helpers';
   7
   8 export const generateEventUniqueId = (calendarID: string, eventID: string) => `${calendarID}.${eventID}`;
   9 export const getCalendarIDFromUniqueId = (itemID: string) => itemID.split('.')[0];
  10 export const getEventIDFromUniqueId = (itemID: string) => itemID.split('.')[1];
  11
  12 export const getEventStatusTraits = (model: EventModelReadView) => {
  13     const { status: eventStatus, selfAttendeeIndex } = model;
  14
  15     const noOneIsAttending =
  16         model.attendees.length > 0 &&
  17         model.attendees.every((attendee) => attendee.partstat === ICAL_ATTENDEE_STATUS.DECLINED);
  18
  19     if (model.isAttendee && eventStatus === ICAL_EVENT_STATUS.CONFIRMED) {
  20         const selfAttendee = selfAttendeeIndex !== undefined ? model.attendees[selfAttendeeIndex] : undefined;
  21         if (selfAttendee) {
  22             const { partstat } = selfAttendee;
  23             return {
  24                 isUnanswered: partstat === ICAL_ATTENDEE_STATUS.NEEDS_ACTION,
  25                 isTentative: partstat === ICAL_ATTENDEE_STATUS.TENTATIVE,
  26                 isCancelled: partstat === ICAL_ATTENDEE_STATUS.DECLINED || noOneIsAttending,
  27             };
  28         }
  29     }
  30     return {
  31         isTentative: eventStatus === ICAL_EVENT_STATUS.TENTATIVE,
  32         isCancelled: eventStatus === ICAL_EVENT_STATUS.CANCELLED || noOneIsAttending,
  33     };
  34 };
  35
  36 export const getCanEditEvent = ({
  37     isUnknownCalendar,
  38     isCalendarDisabled,
  39 }: {
  40     isUnknownCalendar: boolean;
  41     isCalendarDisabled: boolean;
  42 }) => {
  43     if (isUnknownCalendar) {
  44         return false;
  45     }
  46     if (isCalendarDisabled) {
  47         return false;
  48     }
  49     return true;
  50 };
  51
  52 export const getCanDeleteEvent = ({
  53     isOwnedCalendar,
  54     isCalendarWritable,
  55     isInvitation,
  56 }: {
  57     isOwnedCalendar: boolean;
  58     isCalendarWritable: boolean;
  59     isInvitation: boolean;
  60 }) => {
  61     if (!isCalendarWritable) {
  62         return false;
  63     }
  64     if (!isOwnedCalendar) {
  65         return !isInvitation;
  66     }
  67     return true;
  68 };
  69
  70 export const getCanDuplicateEvent = ({
  71     isUnknownCalendar,
  72     isSubscribedCalendar,
  73     isOwnedCalendar,
  74     isOrganizer,
  75     isInvitation,
  76 }: {
  77     isUnknownCalendar: boolean;
  78     isSubscribedCalendar: boolean;
  79     isOwnedCalendar: boolean;
  80     isOrganizer: boolean;
  81     isInvitation: boolean;
  82 }) => {
  83     if (isUnknownCalendar) {
  84         return false;
  85     }
  86     if (isSubscribedCalendar) {
  87         return false;
  88     }
  89     if (isOwnedCalendar) {
  90         return isInvitation ? isOrganizer : true;
  91     }
  92     return !isInvitation;
  93 };
  94
  95 export const getCanChangeCalendarOfEvent = ({
  96     isCreateEvent,
  97     isOwnedCalendar,
  98     isCalendarWritable,
  99     isSingleEdit,
 100     isInvitation,
 101     isAttendee,
 102     isOrganizer,
 103 }: {
 104     isCreateEvent: boolean;
 105     isOwnedCalendar: boolean;
 106     isCalendarWritable: boolean;
 107     isSingleEdit: boolean;
 108     isInvitation: boolean;
 109     isAttendee: boolean;
 110     isOrganizer: boolean;
 111 }) => {
 112     if (isCreateEvent) {
 113         return true;
 114     }
 115     if (!isCalendarWritable) {
 116         return false;
 117     }
 118     if (isInvitation) {
 119         if (!isOwnedCalendar) {
 120             return false;
 121         }
 122         if (isAttendee) {
 123             return !isSingleEdit;
 124         }
 125         if (isOrganizer) {
 126             return false;
 127         }
 128         // we should never fall here, but just in case
 129         return false;
 130     }
 131     return true;
 132 };
 133
 134 export const getCannotSaveEvent = ({
 135     isOwnedCalendar,
 136     isOrganizer,
 137     numberOfAttendees,
 138     canEditSharedEventData = true,
 139     maxAttendees,
 140 }: {
 141     isOwnedCalendar: boolean;
 142     isOrganizer: boolean;
 143     numberOfAttendees: number;
 144     canEditSharedEventData?: boolean;
 145     maxAttendees?: number;
 146 }) => {
 147     if (!canEditSharedEventData) {
 148         // user is editing only notifications
 149         return false;
 150     }
 151     if (isOrganizer) {
 152         return !!getParticipantsError({ isOwnedCalendar, numberOfAttendees, maxAttendees });
 153     }
 154     return false;
 155 };
 156
 157 export const getCanEditSharedEventData = ({
 158     isOwnedCalendar,
 159     isCalendarWritable,
 160     isOrganizer,
 161     isAttendee,
 162     isInvitation,
 163     selfAddress,
 164 }: {
 165     isOwnedCalendar: boolean;
 166     isCalendarWritable: boolean;
 167     isOrganizer: boolean;
 168     isAttendee: boolean;
 169     isInvitation: boolean;
 170     selfAddress?: Address;
 171 }) => {
 172     if (!isCalendarWritable) {
 173         return false;
 174     }
 175     if (isInvitation) {
 176         if (isOwnedCalendar) {
 177             if (isAttendee) {
 178                 return false;
 179             }
 180             if (isOrganizer) {
 181                 return selfAddress ? getIsAddressActive(selfAddress) : false;
 182             }
 183             return false;
 184         }
 185         return false;
 186     }
 187     return true;
 188 };
 189
 190 export const getCanReplyToEvent = ({
 191     isOwnedCalendar,
 192     isCalendarWritable,
 193     isAttendee,
 194     isCancelled,
 195 }: {
 196     isOwnedCalendar: boolean;
 197     isCalendarWritable: boolean;
 198     isAttendee: boolean;
 199     isCancelled: boolean;
 200 }) => {
 201     return isOwnedCalendar && isCalendarWritable && isAttendee && !isCancelled;
 202 };
 203
 204 export const getIsAvailableCalendar = ({
 205     isOwnedCalendar,
 206     isCalendarWritable,
 207     isInvitation,
 208 }: {
 209     isOwnedCalendar: boolean;
 210     isCalendarWritable: boolean;
 211     isInvitation: boolean;
 212 }) => {
 213     if (!isCalendarWritable) {
 214         return false;
 215     }
 216     if (isInvitation) {
 217         return isOwnedCalendar;
 218     }
 219     return true;
 220 };