packages/shared/lib/calendar/import/import.ts

   1 import { c } from 'ttag';
   2
   3 import { CryptoProxy, serverTime } from '@proton/crypto';
   4 import { arrayToHexString, binaryStringToArray } from '@proton/crypto/lib/utils';
   5 import type { TelemetryReport } from '@proton/shared/lib/api/telemetry';
   6 import { TelemetryIcsSurgeryEvents, TelemetryMeasurementGroups } from '@proton/shared/lib/api/telemetry';
   7 import { sendMultipleTelemetryReports, sendTelemetryReport } from '@proton/shared/lib/helpers/metrics';
   8 import { captureMessage } from '@proton/shared/lib/helpers/sentry';
   9 import isTruthy from '@proton/utils/isTruthy';
  10 import truncate from '@proton/utils/truncate';
  11 import unique from '@proton/utils/unique';
  12
  13 import { getEventByUID } from '../../api/calendars';
  14 import type { Options as FormatOptions } from '../../date-fns-utc/format';
  15 import formatUTC from '../../date-fns-utc/format';
  16 import { getSupportedTimezone, toUTCDate } from '../../date/timezone';
  17 import { readFileAsString } from '../../helpers/file';
  18 import { dateLocale } from '../../i18n';
  19 import type { Api, SimpleMap } from '../../interfaces';
  20 import type {
  21     CalendarEvent,
  22     ImportCalendarModel,
  23     ImportedEvent,
  24     VcalCalendarComponentWithMaybeErrors,
  25     VcalErrorComponent,
  26     VcalVcalendarWithMaybeErrors,
  27     VcalVeventComponent,
  28     VcalVtimezoneComponent,
  29 } from '../../interfaces/calendar';
  30 import { ICAL_METHOD, IMPORT_ERROR_TYPE, MAX_CALENDARS_PAID, MAX_IMPORT_EVENTS } from '../constants';
  31 import getComponentFromCalendarEvent from '../getComponentFromCalendarEvent';
  32 import { generateVeventHashUID, getNaiveDomainFromUID, getOriginalUID } from '../helper';
  33 import { IMPORT_EVENT_ERROR_TYPE, ImportEventError } from '../icsSurgery/ImportEventError';
  34 import { getSupportedCalscale } from '../icsSurgery/vcal';
  35 import { getLinkedDateTimeProperty, getSupportedEvent, withSupportedDtstamp } from '../icsSurgery/vevent';
  36 import { getVeventWithoutErrors, parseVcalendarWithRecoveryAndMaybeErrors, serialize } from '../vcal';
  37 import {
  38     getHasDtStart,
  39     getHasRecurrenceId,
  40     getIcalMethod,
  41     getIsEventComponent,
  42     getIsFreebusyComponent,
  43     getIsJournalComponent,
  44     getIsPropertyAllDay,
  45     getIsTimezoneComponent,
  46     getIsTodoComponent,
  47     getIsVcalErrorComponent,
  48     getPropertyTzid,
  49 } from '../vcalHelper';
  50 import { ImportFileError } from './ImportFileError';
  51
  52 const icsHashesForImportTelemetry = new Set<string>();
  53 const icsFilesForIcsParsingTelemetry = new Set<string>();
  54
  55 /**
  56  * Send telemetry event if we got some fails during import process, so that we know how common errors are, and which error users are facing
  57  */
  58 export const sendImportErrorTelemetryReport = async ({
  59     errors,
  60     api,
  61     hash,
  62 }: {
  63     errors: ImportEventError[];
  64     api: Api;
  65     hash: string;
  66 }) => {
  67     if (errors.length === 0 || icsHashesForImportTelemetry.has(hash)) {
  68         return;
  69     }
  70
  71     const reports: TelemetryReport[] = errors.map(({ type, componentIdentifiers: { component, prodId, domain } }) => {
  72         const dimensions: SimpleMap<string> = {
  73             reason: IMPORT_EVENT_ERROR_TYPE[type],
  74             component,
  75             prodid: prodId,
  76             domain,
  77         };
  78
  79         const report: TelemetryReport = {
  80             measurementGroup: TelemetryMeasurementGroups.calendarIcsSurgery,
  81             event: TelemetryIcsSurgeryEvents.import,
  82             dimensions,
  83         };
  84
  85         return report;
  86     });
  87
  88     await sendMultipleTelemetryReports({
  89         api: api,
  90         reports,
  91     });
  92
  93     icsHashesForImportTelemetry.add(hash);
  94 };
  95
  96 export const sendTelemetryEventParsingError = (api: Api, error: IMPORT_ERROR_TYPE, filename: string | undefined) => {
  97     if (!filename || icsFilesForIcsParsingTelemetry.has(filename)) {
  98         return;
  99     }
 100
 101     void sendTelemetryReport({
 102         api,
 103         measurementGroup: TelemetryMeasurementGroups.calendarIcsSurgery,
 104         event: TelemetryIcsSurgeryEvents.ics_parsing,
 105         dimensions: {
 106             parsing_error: error,
 107         },
 108     });
 109     icsFilesForIcsParsingTelemetry.add(filename);
 110 };
 111
 112 export const parseIcs = async (ics: File) => {
 113     const filename = ics.name;
 114     try {
 115         const icsAsString = await readFileAsString(ics);
 116         const hashPromise = CryptoProxy.computeHash({ algorithm: 'unsafeSHA1', data: binaryStringToArray(icsAsString) })
 117             .then((result) => arrayToHexString(result))
 118             .catch((error: any) => {
 119                 captureMessage('Failed to hash ics', {
 120                     level: 'info',
 121                     extra: { error },
 122                 });
 123                 return 'failed_to_hash';
 124             });
 125         if (!icsAsString) {
 126             throw new ImportFileError(IMPORT_ERROR_TYPE.FILE_EMPTY, filename);
 127         }
 128         const parsedVcalendar = parseVcalendarWithRecoveryAndMaybeErrors(icsAsString) as VcalVcalendarWithMaybeErrors;
 129         if (parsedVcalendar.component?.toLowerCase() !== 'vcalendar') {
 130             throw new ImportFileError(IMPORT_ERROR_TYPE.INVALID_CALENDAR, filename);
 131         }
 132         const { method, prodid, calscale, components, 'x-wr-timezone': xWrTimezone } = parsedVcalendar;
 133         const supportedCalscale = getSupportedCalscale(calscale);
 134         const supportedMethod = getIcalMethod(method);
 135
 136         if (!supportedMethod) {
 137             throw new ImportFileError(IMPORT_ERROR_TYPE.INVALID_METHOD, filename);
 138         }
 139         if (!components?.length) {
 140             throw new ImportFileError(IMPORT_ERROR_TYPE.NO_EVENTS, filename);
 141         }
 142         if (components.length > MAX_IMPORT_EVENTS) {
 143             throw new ImportFileError(IMPORT_ERROR_TYPE.TOO_MANY_EVENTS, filename);
 144         }
 145
 146         return {
 147             components,
 148             calscale: supportedCalscale,
 149             xWrTimezone: xWrTimezone?.value,
 150             method: supportedMethod,
 151             prodId: prodid.value,
 152             hashedIcs: await hashPromise,
 153         };
 154     } catch (e: any) {
 155         if (e instanceof ImportFileError) {
 156             throw e;
 157         }
 158         throw new ImportFileError(IMPORT_ERROR_TYPE.FILE_CORRUPTED, filename);
 159     }
 160 };
 161
 162 /**
 163  * Get a string that can identify an imported component
 164  */
 165 export const getComponentIdentifier = (
 166     vcalComponent: VcalCalendarComponentWithMaybeErrors | VcalErrorComponent,
 167     options: FormatOptions = { locale: dateLocale }
 168 ) => {
 169     if (getIsVcalErrorComponent(vcalComponent)) {
 170         return '';
 171     }
 172     if (getIsTimezoneComponent(vcalComponent)) {
 173         return vcalComponent.tzid.value || '';
 174     }
 175     const uid = 'uid' in vcalComponent ? vcalComponent.uid?.value : undefined;
 176     const originalUid = getOriginalUID(uid);
 177     if (originalUid) {
 178         return originalUid;
 179     }
 180     if (getIsEventComponent(vcalComponent)) {
 181         const { summary, dtstart } = vcalComponent;
 182         const shortTitle = truncate(summary?.value || '');
 183         if (shortTitle) {
 184             return shortTitle;
 185         }
 186         if (dtstart?.value) {
 187             const format = getIsPropertyAllDay(dtstart) ? 'PP' : 'PPpp';
 188             return formatUTC(toUTCDate(dtstart.value), format, options);
 189         }
 190         return c('Error importing event').t`No UID, title or start time`;
 191     }
 192     return '';
 193 };
 194
 195 const extractGuessTzid = (components: (VcalCalendarComponentWithMaybeErrors | VcalErrorComponent)[]) => {
 196     const vtimezones = components.filter((componentOrError): componentOrError is VcalVtimezoneComponent => {
 197         if (getIsVcalErrorComponent(componentOrError)) {
 198             return false;
 199         }
 200         return getIsTimezoneComponent(componentOrError);
 201     });
 202     if (vtimezones.length === 1) {
 203         // we do not have guarantee that the VcalVtimezoneComponent's in vtimezones are propper, so better use optional chaining
 204         const guessTzid = vtimezones[0]?.tzid?.value;
 205         return guessTzid ? getSupportedTimezone(guessTzid) : undefined;
 206     }
 207 };
 208
 209 interface ExtractSupportedEventArgs {
 210     method: ICAL_METHOD;
 211     prodId: string;
 212     vcalComponent: VcalCalendarComponentWithMaybeErrors | VcalErrorComponent;
 213     hasXWrTimezone: boolean;
 214     formatOptions?: FormatOptions;
 215     calendarTzid?: string;
 216     guessTzid: string;
 217     canImportEventColor?: boolean;
 218 }
 219 export const extractSupportedEvent = async ({
 220     method,
 221     prodId,
 222     vcalComponent: vcalComponentWithMaybeErrors,
 223     hasXWrTimezone,
 224     formatOptions,
 225     calendarTzid,
 226     guessTzid,
 227     canImportEventColor,
 228 }: ExtractSupportedEventArgs) => {
 229     const componentId = getComponentIdentifier(vcalComponentWithMaybeErrors, formatOptions);
 230     const isInvitation = method !== ICAL_METHOD.PUBLISH;
 231     if (getIsVcalErrorComponent(vcalComponentWithMaybeErrors)) {
 232         throw new ImportEventError({
 233             errorType: IMPORT_EVENT_ERROR_TYPE.EXTERNAL_ERROR,
 234             componentIdentifiers: { component: 'error', componentId, prodId, domain: '' },
 235             externalError: vcalComponentWithMaybeErrors.error,
 236         });
 237     }
 238     if (getIsTodoComponent(vcalComponentWithMaybeErrors)) {
 239         throw new ImportEventError({
 240             errorType: IMPORT_EVENT_ERROR_TYPE.TODO_FORMAT,
 241             componentIdentifiers: { component: 'vtodo', componentId, prodId, domain: '' },
 242         });
 243     }
 244     if (getIsJournalComponent(vcalComponentWithMaybeErrors)) {
 245         throw new ImportEventError({
 246             errorType: IMPORT_EVENT_ERROR_TYPE.JOURNAL_FORMAT,
 247             componentIdentifiers: { component: 'vjournal', componentId, prodId, domain: '' },
 248         });
 249     }
 250     if (getIsFreebusyComponent(vcalComponentWithMaybeErrors)) {
 251         throw new ImportEventError({
 252             errorType: IMPORT_EVENT_ERROR_TYPE.FREEBUSY_FORMAT,
 253             componentIdentifiers: { component: 'vfreebusy', componentId, prodId, domain: '' },
 254         });
 255     }
 256     if (getIsTimezoneComponent(vcalComponentWithMaybeErrors)) {
 257         if (!getSupportedTimezone(vcalComponentWithMaybeErrors.tzid.value)) {
 258             throw new ImportEventError({
 259                 errorType: IMPORT_EVENT_ERROR_TYPE.TIMEZONE_FORMAT,
 260                 componentIdentifiers: { component: 'vtimezone', componentId, prodId, domain: '' },
 261             });
 262         }
 263         throw new ImportEventError({
 264             errorType: IMPORT_EVENT_ERROR_TYPE.TIMEZONE_IGNORE,
 265             componentIdentifiers: { component: 'vtimezone', componentId, prodId, domain: '' },
 266         });
 267     }
 268     if (!getIsEventComponent(vcalComponentWithMaybeErrors)) {
 269         throw new ImportEventError({
 270             errorType: IMPORT_EVENT_ERROR_TYPE.WRONG_FORMAT,
 271             componentIdentifiers: { component: 'unknown', componentId, prodId, domain: '' },
 272         });
 273     }
 274     const vcalComponent = getVeventWithoutErrors(vcalComponentWithMaybeErrors);
 275     if (!getHasDtStart(vcalComponent)) {
 276         throw new ImportEventError({
 277             errorType: IMPORT_EVENT_ERROR_TYPE.DTSTART_MISSING,
 278             componentIdentifiers: { component: 'vevent', componentId, prodId, domain: '' },
 279         });
 280     }
 281     const validVevent = withSupportedDtstamp(vcalComponent, +serverTime());
 282     const generateHashUid = !validVevent.uid?.value || isInvitation;
 283
 284     if (generateHashUid) {
 285         validVevent.uid = {
 286             value: await generateVeventHashUID(serialize(vcalComponent), vcalComponent?.uid?.value),
 287         };
 288     }
 289
 290     const componentIdentifiers = {
 291         component: 'vevent',
 292         componentId,
 293         prodId,
 294         domain: getNaiveDomainFromUID(validVevent.uid.value),
 295     };
 296
 297     return getSupportedEvent({
 298         vcalVeventComponent: validVevent,
 299         hasXWrTimezone,
 300         calendarTzid,
 301         guessTzid,
 302         method,
 303         isEventInvitation: false,
 304         generatedHashUid: generateHashUid,
 305         componentIdentifiers,
 306         canImportEventColor,
 307     });
 308 };
 309
 310 export const getSupportedEventsOrErrors = async ({
 311     components,
 312     method,
 313     prodId = '',
 314     formatOptions,
 315     calscale,
 316     xWrTimezone,
 317     primaryTimezone,
 318     canImportEventColor,
 319 }: {
 320     components: (VcalCalendarComponentWithMaybeErrors | VcalErrorComponent)[];
 321     method: ICAL_METHOD;
 322     prodId?: string;
 323     formatOptions?: FormatOptions;
 324     calscale?: string;
 325     xWrTimezone?: string;
 326     primaryTimezone: string;
 327     canImportEventColor?: boolean;
 328 }) => {
 329     if (calscale?.toLowerCase() !== 'gregorian') {
 330         return [
 331             new ImportEventError({
 332                 errorType: IMPORT_EVENT_ERROR_TYPE.NON_GREGORIAN,
 333                 componentIdentifiers: { component: 'vcalendar', componentId: '', prodId, domain: '' },
 334             }),
 335         ];
 336     }
 337     const hasXWrTimezone = !!xWrTimezone;
 338     const calendarTzid = xWrTimezone ? getSupportedTimezone(xWrTimezone) : undefined;
 339     const guessTzid = extractGuessTzid(components) || primaryTimezone;
 340     const supportedEvents = await Promise.all(
 341         components.map(async (vcalComponent) => {
 342             try {
 343                 const supportedEvent = await extractSupportedEvent({
 344                     method,
 345                     prodId,
 346                     vcalComponent,
 347                     calendarTzid,
 348                     hasXWrTimezone,
 349                     formatOptions,
 350                     guessTzid,
 351                     canImportEventColor,
 352                 });
 353                 return supportedEvent;
 354             } catch (e: any) {
 355                 return e;
 356             }
 357         })
 358     );
 359
 360     return supportedEvents.filter(isTruthy);
 361 };
 362
 363 /**
 364  * Split an array of events into those which have a recurrence id and those which don't
 365  */
 366 export const splitByRecurrenceId = (events: VcalVeventComponent[]) => {
 367     return events.reduce<{
 368         withoutRecurrenceId: VcalVeventComponent[];
 369         withRecurrenceId: (VcalVeventComponent & Required<Pick<VcalVeventComponent, 'recurrence-id'>>)[];
 370     }>(
 371         (acc, event) => {
 372             if (!getHasRecurrenceId(event)) {
 373                 acc.withoutRecurrenceId.push(event);
 374             } else {
 375                 acc.withRecurrenceId.push(event);
 376             }
 377             return acc;
 378         },
 379         { withoutRecurrenceId: [], withRecurrenceId: [] }
 380     );
 381 };
 382
 383 export const splitErrors = <T>(events: (T | ImportEventError)[]) => {
 384     return events.reduce<{ errors: ImportEventError[]; rest: T[] }>(
 385         (acc, event) => {
 386             if (event instanceof ImportEventError) {
 387                 acc.errors.push(event);
 388             } else {
 389                 acc.rest.push(event);
 390             }
 391             return acc;
 392         },
 393         { errors: [], rest: [] }
 394     );
 395 };
 396
 397 // Separate errors that we want to hide
 398 export const splitHiddenErrors = (errors: ImportEventError[]) => {
 399     return errors.reduce<{ hidden: ImportEventError[]; visible: ImportEventError[] }>(
 400         (acc, error) => {
 401             if (error.type === IMPORT_EVENT_ERROR_TYPE.NO_OCCURRENCES) {
 402                 // Importing an event without occurrences is the same as not importing it
 403                 acc.hidden.push(error);
 404             } else {
 405                 acc.visible.push(error);
 406             }
 407             return acc;
 408         },
 409         { hidden: [], visible: [] }
 410     );
 411 };
 412
 413 const getParentEventFromApi = async (uid: string, api: Api, calendarId: string) => {
 414     try {
 415         const { Events } = await api<{ Events: CalendarEvent[] }>({
 416             ...getEventByUID({
 417                 UID: uid,
 418                 Page: 0,
 419                 PageSize: MAX_CALENDARS_PAID,
 420             }),
 421             silence: true,
 422         });
 423         const [parentEvent] = Events.filter(({ CalendarID }) => CalendarID === calendarId);
 424         if (!parentEvent) {
 425             return;
 426         }
 427         const parentComponent = getComponentFromCalendarEvent(parentEvent);
 428         if (getHasRecurrenceId(parentComponent)) {
 429             // it wouldn't be a parent then
 430             return;
 431         }
 432         return {
 433             vcalComponent: parentComponent,
 434             calendarEvent: parentEvent,
 435         };
 436     } catch {
 437         return undefined;
 438     }
 439 };
 440
 441 interface GetSupportedEventsWithRecurrenceIdArgs {
 442     eventsWithRecurrenceId: (VcalVeventComponent & Required<Pick<VcalVeventComponent, 'recurrence-id'>>)[];
 443     parentEvents: ImportedEvent[];
 444     calendarId: string;
 445     api: Api;
 446     prodId?: string;
 447 }
 448 export const getSupportedEventsWithRecurrenceId = async ({
 449     eventsWithRecurrenceId,
 450     parentEvents,
 451     calendarId,
 452     api,
 453     prodId = '',
 454 }: GetSupportedEventsWithRecurrenceIdArgs) => {
 455     // map uid -> parent event
 456     const mapParentEvents = parentEvents.reduce<
 457         SimpleMap<{
 458             vcalComponent: VcalVeventComponent;
 459             calendarEvent: CalendarEvent;
 460         }>
 461     >((acc, event) => {
 462         acc[event.component.uid.value] = {
 463             vcalComponent: event.component,
 464             calendarEvent: event.response.Response.Event,
 465         };
 466
 467         return acc;
 468     }, {});
 469     // complete the map with parent events in the DB
 470     const uidsToFetch = unique(
 471         eventsWithRecurrenceId.filter(({ uid }) => !mapParentEvents[uid.value]).map(({ uid }) => uid.value)
 472     );
 473     const result = await Promise.all(uidsToFetch.map((uid) => getParentEventFromApi(uid, api, calendarId)));
 474     result.forEach((parentEvent, i) => {
 475         mapParentEvents[uidsToFetch[i]] = parentEvent;
 476     });
 477
 478     return eventsWithRecurrenceId.map((event) => {
 479         const uid = event.uid.value;
 480         const componentIdentifiers = {
 481             component: 'vevent',
 482             componentId: getComponentIdentifier(event),
 483             prodId,
 484             domain: getNaiveDomainFromUID(event.uid.value),
 485         };
 486         const parentEvent = mapParentEvents[uid];
 487         if (!parentEvent) {
 488             return new ImportEventError({
 489                 errorType: IMPORT_EVENT_ERROR_TYPE.PARENT_EVENT_MISSING,
 490                 componentIdentifiers,
 491             });
 492         }
 493         const parentComponent = parentEvent.vcalComponent;
 494         if (!parentComponent.rrule) {
 495             return new ImportEventError({
 496                 errorType: IMPORT_EVENT_ERROR_TYPE.SINGLE_EDIT_UNSUPPORTED,
 497                 componentIdentifiers,
 498             });
 499         }
 500         const recurrenceId = event['recurrence-id'];
 501         try {
 502             const parentDtstart = parentComponent.dtstart;
 503             const supportedRecurrenceId = getLinkedDateTimeProperty({
 504                 property: recurrenceId,
 505                 componentIdentifiers,
 506                 linkedIsAllDay: getIsPropertyAllDay(parentDtstart),
 507                 linkedTzid: getPropertyTzid(parentDtstart),
 508             });
 509             return { ...event, 'recurrence-id': supportedRecurrenceId };
 510         } catch (e: any) {
 511             if (e instanceof ImportEventError) {
 512                 return e;
 513             }
 514             return new ImportEventError({
 515                 errorType: IMPORT_EVENT_ERROR_TYPE.VALIDATION_ERROR,
 516                 componentIdentifiers,
 517             });
 518         }
 519     });
 520 };
 521
 522 export const extractTotals = (model: ImportCalendarModel) => {
 523     const { eventsParsed, totalEncrypted, totalImported, visibleErrors, hiddenErrors } = model;
 524     const totalToImport = eventsParsed.length + hiddenErrors.length;
 525     const totalToProcess = 2 * totalToImport; // count encryption and submission equivalently for the progress
 526     const totalEncryptedFake = totalEncrypted + hiddenErrors.length;
 527     const totalImportedFake = totalImported + hiddenErrors.length;
 528     const totalVisibleErrors = visibleErrors.length;
 529     const totalProcessed = totalEncryptedFake + totalImportedFake + totalVisibleErrors;
 530     return {
 531         totalToImport,
 532         totalToProcess,
 533         totalImported: totalImportedFake,
 534         totalProcessed,
 535     };
 536 };