@idea-ionic/agenda 5.29.3 → 6.0.2

package/esm2020/src/calendars.service.mjs

@@ -0,0 +1,255 @@
+import { Injectable } from '@angular/core';
+import { Plugins } from '@capacitor/core';
+import { Calendar, ExternalCalendarSources, Suggestion } from 'idea-toolbox';
+import { IDEASuggestionsComponent } from '@idea-ionic/common';
+import { environment as env } from '@env';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@idea-ionic/common";
+const { Browser } = Plugins;
+/**
+ * Note: to test locally, you need to temporarily change the redirect URI:
+ *  - in the lambda `idea_calendars`, e.g. `SCARLETT_URL`;
+ *  - in the client config file: `APP_URL`.
+ * In both cases, the value should be set to `http://localhost:8100` (or according to the local URL).
+ */
+export class IDEACalendarsService {
+    constructor(modalCtrl, alertCtrl, message, loading, API, t) {
+        this.modalCtrl = modalCtrl;
+        this.alertCtrl = alertCtrl;
+        this.message = message;
+        this.loading = loading;
+        this.API = API;
+        this.t = t;
+    }
+    /**
+     * Get the ion-icon of an external service from its name.
+     */
+    getServiceIcon(service) {
+        switch (service) {
+            case ExternalCalendarSources.GOOGLE:
+                return 'logo-google';
+            case ExternalCalendarSources.MICROSOFT:
+                return 'logo-windows';
+            default:
+                return 'help';
+        }
+    }
+    /**
+     * Get the base URL for API request (shared/private calendar).
+     */
+    getRequestURL(calendar) {
+        return (calendar.teamId ? `teams/${calendar.teamId}/` : '').concat('calendars');
+    }
+    /**
+     * Create a new calendar.
+     */
+    postCalendar(cal) {
+        return new Promise((resolve, reject) => {
+            this.API.postResource(this.getRequestURL(cal), { idea: true, body: cal })
+                .then((res) => resolve(new Calendar(res)))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+     * Update an existing calendar.
+     */
+    putCalendar(cal) {
+        return new Promise((resolve, reject) => {
+            this.API.putResource(this.getRequestURL(cal), { idea: true, resourceId: cal.calendarId, body: cal })
+                .then((res) => resolve(new Calendar(res)))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+     * Delete a calendar.
+     */
+    deleteCalendar(cal) {
+        return new Promise((resolve, reject) => {
+            this.API.deleteResource(this.getRequestURL(cal), { idea: true, resourceId: cal.calendarId })
+                .then(() => resolve())
+                .catch(err => reject(err));
+        });
+    }
+    /**
+     * Associate an external calendar with the given calendar.
+     */
+    setExternalCalendar(cal, externalId) {
+        return new Promise((resolve, reject) => {
+            this.API.patchResource(this.getRequestURL(cal), {
+                idea: true,
+                resourceId: cal.calendarId,
+                body: { action: 'SET_EXTERNAL_CALENDAR', externalId }
+            })
+                .then(res => resolve(new Calendar(res)))
+                .catch(err => reject(err));
+        });
+    }
+    /**
+     * Link the calendar with the chosen external service (auth flow).
+     */
+    linkExtService(cal) {
+        return new Promise((resolve, reject) => {
+            if (!cal.external)
+                return reject(new Error('NOT_EXTERNAL'));
+            let url;
+            switch (cal.external.service) {
+                case ExternalCalendarSources.GOOGLE:
+                    url =
+                        'https://accounts.google.com/o/oauth2/v2/auth?' +
+                            `client_id=${encodeURIComponent(env.google.apiClientId)}` +
+                            '&response_type=code' +
+                            `&redirect_uri=${encodeURIComponent(env.idea.app.url.concat('/echo/google-calendars-integration'))}` +
+                            '&include_granted_scopes=true' +
+                            '&access_type=offline&prompt=consent' +
+                            `&scope=${encodeURIComponent(env.google.apiScope)}` +
+                            `&state=${encodeURIComponent(cal.calendarId)}`;
+                    break;
+                case ExternalCalendarSources.MICROSOFT:
+                    url =
+                        'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?' +
+                            `client_id=${encodeURIComponent(env.microsoft.apiClientId)}` +
+                            '&response_type=code' +
+                            `&redirect_uri=${encodeURIComponent(env.idea.app.url.concat('/echo/microsoft-calendars-integration'))}` +
+                            '&response_mode=query' +
+                            `&scope=${encodeURIComponent(env.microsoft.apiScope)}` +
+                            `&state=${encodeURIComponent(cal.calendarId)}`;
+                    break;
+            }
+            if (!url)
+                return reject(new Error('INVALID_SERVICE'));
+            // start the auth flow in the browser
+            Browser.open({ url }).then(() => {
+                // since we don't know when/if the auth flow will finish, we wait
+                this.alertCtrl
+                    .create({
+                    header: this.t._('IDEA_AGENDA.CALENDARS.LINKING_CALENDAR'),
+                    message: this.t._('IDEA_AGENDA.CALENDARS.LINKING_CALENDAR_CONFIRM_ONCE_DONE'),
+                    backdropDismiss: false,
+                    buttons: [{ text: this.t._('COMMON.DONE'), handler: () => resolve() }]
+                })
+                    .then(alert => alert.present());
+            });
+        });
+    }
+    /**
+     * Get the external calendars list of the external service.
+     */
+    getExternalCalendars(cal) {
+        return new Promise((resolve, reject) => {
+            if (!cal.external)
+                return reject(new Error('NOT_EXTERNAL'));
+            // get the access token to make requests; in case it fails, proceed to link the external service
+            this.API.patchResource(this.getRequestURL(cal), {
+                idea: true,
+                resourceId: cal.calendarId,
+                body: { action: 'GET_ACCESS_TOKEN' }
+            })
+                .then((result) => {
+                // prepare the headers (authorization) for the request to the external service
+                const headers = { Authorization: 'Bearer '.concat(result.token) };
+                // acquire and return the calendars
+                switch (cal.external.service) {
+                    case ExternalCalendarSources.GOOGLE:
+                        this.API.rawRequest()
+                            .get('https://www.googleapis.com/calendar/v3/users/me/calendarList', { headers })
+                            .toPromise()
+                            .then((res) => resolve(res.items.map((c) => ({ name: c.summary, id: c.id }))))
+                            .catch(err => reject(err));
+                        break;
+                    case ExternalCalendarSources.MICROSOFT:
+                        this.API.rawRequest()
+                            .get('https://graph.microsoft.com/v1.0/me/calendars', { headers })
+                            .toPromise()
+                            .then((res) => resolve(res.value.map((c) => ({ name: c.name, id: c.id }))))
+                            .catch(err => reject(err));
+                        break;
+                }
+            })
+                .catch(err => reject(err));
+        });
+    }
+    /**
+     * If the external service is linked, choose an external calendar and set it for the chosen calendar.
+     * @return the updated calendar.
+     */
+    chooseAndSetExternalCalendar(cal) {
+        return new Promise((resolve, reject) => {
+            this.openModalAndPickExternalCalendar(cal)
+                .then(extCalId => {
+                // the external calendar will be set later on
+                if (!extCalId)
+                    return resolve(null);
+                // an external calendar was chosen: set it right away
+                this.setExternalCalendar(cal, extCalId)
+                    .then(res => resolve(res))
+                    .catch(err => reject(err));
+            })
+                .catch(err => reject(err));
+        });
+    }
+    /**
+     * Open the modal to pick a calendar from the external service.
+     * @return the id of the external calendar.
+     */
+    async openModalAndPickExternalCalendar(cal) {
+        await this.loading.show();
+        return new Promise((resolve, reject) => {
+            this.getExternalCalendars(cal)
+                .then((extCals) => {
+                if (!extCals.length)
+                    return reject(new Error('NO_EXTERNAL_CALENDARS'));
+                // let the user to choose the external calendar to associate
+                this.modalCtrl
+                    .create({
+                    component: IDEASuggestionsComponent,
+                    componentProps: {
+                        data: extCals.map(c => new Suggestion({ value: c.id, name: c.name })),
+                        searchPlaceholder: this.t._('IDEA_AGENDA.CALENDARS.CHOOSE_AN_EXTERNAL_CALENDAR_TO_LINK'),
+                        sortData: true,
+                        hideIdFromUI: true,
+                        hideClearButton: true,
+                        mustChoose: true
+                    },
+                    backdropDismiss: false
+                })
+                    .then(modal => {
+                    modal.onDidDismiss().then(res => resolve(res.data ? res.data.value : null));
+                    modal.present();
+                });
+            })
+                .catch(err => reject(err))
+                .finally(() => this.loading.hide());
+        });
+    }
+    /**
+     * First sync of the extenal calendar.
+     */
+    syncCalendar(cal) {
+        return new Promise((resolve, reject) => this.syncCalendarHelper(cal, err => (err ? reject(err) : resolve())));
+    }
+    /**
+     * Helper to recursively sync an the extenal calendar.
+     */
+    syncCalendarHelper(cal, done) {
+        // this is a recursive operation: the API returns if the sync has to continue or it finished
+        this.API.patchResource(this.getRequestURL(cal), {
+            idea: true,
+            resourceId: cal.calendarId,
+            body: { action: 'SYNC_EXTERNAL_CALENDAR', firstSync: true }
+        })
+            .then((res) => {
+            if (res.moreData)
+                this.syncCalendarHelper(cal, done);
+            else
+                done();
+        })
+            .catch(err => done(err));
+    }
+}
+IDEACalendarsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEACalendarsService, deps: [{ token: i1.ModalController }, { token: i1.AlertController }, { token: i2.IDEAMessageService }, { token: i2.IDEALoadingService }, { token: i2.IDEAAWSAPIService }, { token: i2.IDEATranslationsService }], target: i0.ɵɵFactoryTarget.Injectable });
+IDEACalendarsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEACalendarsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEACalendarsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ModalController }, { type: i1.AlertController }, { type: i2.IDEAMessageService }, { type: i2.IDEALoadingService }, { type: i2.IDEAAWSAPIService }, { type: i2.IDEATranslationsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendars.service.js","sourceRoot":"","sources":["../../../../modules/agenda/src/calendars.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { AlertController, ModalController } from '@ionic/angular';\nimport { Plugins } from '@capacitor/core';\nconst { Browser } = Plugins;\nimport { Calendar, ExternalCalendarSources, Suggestion } from 'idea-toolbox';\nimport {\n  IDEALoadingService,\n  IDEAAWSAPIService,\n  IDEAMessageService,\n  IDEATranslationsService,\n  IDEASuggestionsComponent\n} from '@idea-ionic/common';\nimport { environment as env } from '@env';\n\n/**\n * Note: to test locally, you need to temporarily change the redirect URI:\n *  - in the lambda `idea_calendars`, e.g. `SCARLETT_URL`;\n *  - in the client config file: `APP_URL`.\n * In both cases, the value should be set to `http://localhost:8100` (or according to the local URL).\n */\n@Injectable()\nexport class IDEACalendarsService {\n  constructor(\n    public modalCtrl: ModalController,\n    public alertCtrl: AlertController,\n    public message: IDEAMessageService,\n    public loading: IDEALoadingService,\n    public API: IDEAAWSAPIService,\n    public t: IDEATranslationsService\n  ) {}\n\n  /**\n   * Get the ion-icon of an external service from its name.\n   */\n  public getServiceIcon(service: ExternalCalendarSources): string {\n    switch (service) {\n      case ExternalCalendarSources.GOOGLE:\n        return 'logo-google';\n      case ExternalCalendarSources.MICROSOFT:\n        return 'logo-windows';\n      default:\n        return 'help';\n    }\n  }\n  /**\n   * Get the base URL for API request (shared/private calendar).\n   */\n  public getRequestURL(calendar: Calendar): string {\n    return (calendar.teamId ? `teams/${calendar.teamId}/` : '').concat('calendars');\n  }\n\n  /**\n   * Create a new calendar.\n   */\n  public postCalendar(cal: Calendar): Promise<Calendar> {\n    return new Promise((resolve, reject) => {\n      this.API.postResource(this.getRequestURL(cal), { idea: true, body: cal })\n        .then((res: Calendar) => resolve(new Calendar(res)))\n        .catch(err => reject(err));\n    });\n  }\n  /**\n   * Update an existing calendar.\n   */\n  public putCalendar(cal: Calendar): Promise<Calendar> {\n    return new Promise((resolve, reject) => {\n      this.API.putResource(this.getRequestURL(cal), { idea: true, resourceId: cal.calendarId, body: cal })\n        .then((res: Calendar) => resolve(new Calendar(res)))\n        .catch(err => reject(err));\n    });\n  }\n  /**\n   * Delete a calendar.\n   */\n  public deleteCalendar(cal: Calendar): Promise<void> {\n    return new Promise((resolve, reject) => {\n      this.API.deleteResource(this.getRequestURL(cal), { idea: true, resourceId: cal.calendarId })\n        .then(() => resolve())\n        .catch(err => reject(err));\n    });\n  }\n  /**\n   * Associate an external calendar with the given calendar.\n   */\n  public setExternalCalendar(cal: Calendar, externalId: string): Promise<Calendar> {\n    return new Promise((resolve, reject) => {\n      this.API.patchResource(this.getRequestURL(cal), {\n        idea: true,\n        resourceId: cal.calendarId,\n        body: { action: 'SET_EXTERNAL_CALENDAR', externalId }\n      })\n        .then(res => resolve(new Calendar(res)))\n        .catch(err => reject(err));\n    });\n  }\n\n  /**\n   * Link the calendar with the chosen external service (auth flow).\n   */\n  public linkExtService(cal: Calendar): Promise<void> {\n    return new Promise((resolve, reject) => {\n      if (!cal.external) return reject(new Error('NOT_EXTERNAL'));\n      let url: string;\n      switch (cal.external.service) {\n        case ExternalCalendarSources.GOOGLE:\n          url =\n            'https://accounts.google.com/o/oauth2/v2/auth?' +\n            `client_id=${encodeURIComponent(env.google.apiClientId)}` +\n            '&response_type=code' +\n            `&redirect_uri=${encodeURIComponent(env.idea.app.url.concat('/echo/google-calendars-integration'))}` +\n            '&include_granted_scopes=true' +\n            '&access_type=offline&prompt=consent' +\n            `&scope=${encodeURIComponent(env.google.apiScope)}` +\n            `&state=${encodeURIComponent(cal.calendarId)}`;\n          break;\n        case ExternalCalendarSources.MICROSOFT:\n          url =\n            'https://login.microsoftonline.com/common/oauth2/v2.0/authorize?' +\n            `client_id=${encodeURIComponent(env.microsoft.apiClientId)}` +\n            '&response_type=code' +\n            `&redirect_uri=${encodeURIComponent(env.idea.app.url.concat('/echo/microsoft-calendars-integration'))}` +\n            '&response_mode=query' +\n            `&scope=${encodeURIComponent(env.microsoft.apiScope)}` +\n            `&state=${encodeURIComponent(cal.calendarId)}`;\n          break;\n      }\n      if (!url) return reject(new Error('INVALID_SERVICE'));\n      // start the auth flow in the browser\n      Browser.open({ url }).then(() => {\n        // since we don't know when/if the auth flow will finish, we wait\n        this.alertCtrl\n          .create({\n            header: this.t._('IDEA_AGENDA.CALENDARS.LINKING_CALENDAR'),\n            message: this.t._('IDEA_AGENDA.CALENDARS.LINKING_CALENDAR_CONFIRM_ONCE_DONE'),\n            backdropDismiss: false,\n            buttons: [{ text: this.t._('COMMON.DONE'), handler: () => resolve() }]\n          })\n          .then(alert => alert.present());\n      });\n    });\n  }\n\n  /**\n   * Get the external calendars list of the external service.\n   */\n  public getExternalCalendars(cal: Calendar): Promise<ExtCalendar[]> {\n    return new Promise((resolve, reject) => {\n      if (!cal.external) return reject(new Error('NOT_EXTERNAL'));\n      // get the access token to make requests; in case it fails, proceed to link the external service\n      this.API.patchResource(this.getRequestURL(cal), {\n        idea: true,\n        resourceId: cal.calendarId,\n        body: { action: 'GET_ACCESS_TOKEN' }\n      })\n        .then((result: any) => {\n          // prepare the headers (authorization) for the request to the external service\n          const headers = { Authorization: 'Bearer '.concat(result.token) };\n          // acquire and return the calendars\n          switch (cal.external.service) {\n            case ExternalCalendarSources.GOOGLE:\n              this.API.rawRequest()\n                .get('https://www.googleapis.com/calendar/v3/users/me/calendarList', { headers })\n                .toPromise()\n                .then((res: any) => resolve(res.items.map((c: any) => ({ name: c.summary, id: c.id } as ExtCalendar))))\n                .catch(err => reject(err));\n              break;\n            case ExternalCalendarSources.MICROSOFT:\n              this.API.rawRequest()\n                .get('https://graph.microsoft.com/v1.0/me/calendars', { headers })\n                .toPromise()\n                .then((res: any) => resolve(res.value.map((c: any) => ({ name: c.name, id: c.id } as ExtCalendar))))\n                .catch(err => reject(err));\n              break;\n          }\n        })\n        .catch(err => reject(err));\n    });\n  }\n\n  /**\n   * If the external service is linked, choose an external calendar and set it for the chosen calendar.\n   * @return the updated calendar.\n   */\n  public chooseAndSetExternalCalendar(cal: Calendar): Promise<Calendar> {\n    return new Promise((resolve, reject) => {\n      this.openModalAndPickExternalCalendar(cal)\n        .then(extCalId => {\n          // the external calendar will be set later on\n          if (!extCalId) return resolve(null);\n          // an external calendar was chosen: set it right away\n          this.setExternalCalendar(cal, extCalId)\n            .then(res => resolve(res))\n            .catch(err => reject(err));\n        })\n        .catch(err => reject(err));\n    });\n  }\n  /**\n   * Open the modal to pick a calendar from the external service.\n   * @return the id of the external calendar.\n   */\n  private async openModalAndPickExternalCalendar(cal: Calendar): Promise<string> {\n    await this.loading.show();\n    return new Promise((resolve, reject) => {\n      this.getExternalCalendars(cal)\n        .then((extCals: ExtCalendar[]) => {\n          if (!extCals.length) return reject(new Error('NO_EXTERNAL_CALENDARS'));\n          // let the user to choose the external calendar to associate\n          this.modalCtrl\n            .create({\n              component: IDEASuggestionsComponent,\n              componentProps: {\n                data: extCals.map(c => new Suggestion({ value: c.id, name: c.name })),\n                searchPlaceholder: this.t._('IDEA_AGENDA.CALENDARS.CHOOSE_AN_EXTERNAL_CALENDAR_TO_LINK'),\n                sortData: true,\n                hideIdFromUI: true,\n                hideClearButton: true,\n                mustChoose: true\n              },\n              backdropDismiss: false\n            })\n            .then(modal => {\n              modal.onDidDismiss().then(res => resolve(res.data ? res.data.value : null));\n              modal.present();\n            });\n        })\n        .catch(err => reject(err))\n        .finally(() => this.loading.hide());\n    });\n  }\n\n  /**\n   * First sync of the extenal calendar.\n   */\n  public syncCalendar(cal: Calendar): Promise<void> {\n    return new Promise((resolve, reject) => this.syncCalendarHelper(cal, err => (err ? reject(err) : resolve())));\n  }\n  /**\n   * Helper to recursively sync an the extenal calendar.\n   */\n  private syncCalendarHelper(cal: Calendar, done: (err?: Error) => void) {\n    // this is a recursive operation: the API returns if the sync has to continue or it finished\n    this.API.patchResource(this.getRequestURL(cal), {\n      idea: true,\n      resourceId: cal.calendarId,\n      body: { action: 'SYNC_EXTERNAL_CALENDAR', firstSync: true }\n    })\n      .then((res: any) => {\n        if (res.moreData) this.syncCalendarHelper(cal, done);\n        else done();\n      })\n      .catch(err => done(err));\n  }\n}\n\n/**\n * Helper structure to define external services' calendars (basic info).\n */\ninterface ExtCalendar {\n  id: string;\n  name: string;\n}\n"]}

package/esm2020/src/dateFormatter.provider.mjs

@@ -0,0 +1,38 @@
+import { formatDate } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { CalendarDateFormatter } from 'angular-calendar';
+import * as i0 from "@angular/core";
+export class CustomDateFormatter extends CalendarDateFormatter {
+    // MONTH VIEW
+    monthViewColumnHeader({ date, locale }) {
+        return formatDate(date, 'EEE', locale);
+    }
+    monthViewTitle({ date, locale }) {
+        return formatDate(date, 'MMMM y', locale);
+    }
+    // WEEK VIEW
+    weekViewHour({ date, locale }) {
+        return locale === 'it' ? formatDate(date, 'HH:mm', locale) : formatDate(date, 'h aa', locale);
+    }
+    weekViewColumnHeader({ date, locale }) {
+        return formatDate(date, 'EEE', locale);
+    }
+    weekViewTitle({ date, locale }) {
+        return formatDate(date, 'MMMM yyyy', locale);
+    }
+    // DAY VIEW
+    dayViewHour({ date, locale }) {
+        return locale === 'it' ? formatDate(date, 'HH:mm', locale) : formatDate(date, 'h aa', locale);
+    }
+    dayViewTitle({ date, locale }) {
+        return locale === 'it'
+            ? formatDate(date, 'EEEE, dd MMM yyyy', locale)
+            : formatDate(date, 'EEEE, MMM dd, yyyy', locale);
+    }
+}
+CustomDateFormatter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CustomDateFormatter, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+CustomDateFormatter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CustomDateFormatter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CustomDateFormatter, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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