@dv4resi/dvss-backend-module-calendar-im 0.0.7 → 0.0.9

package/dist/index.js

@@ -977,6 +977,7 @@ var GET_PAYMENTS_SORTING_ENUM = /* @__PURE__ */ (function(GET_PAYMENTS_SORTING_E
   GET_PAYMENTS_SORTING_ENUM2["NOTES"] = "NOTES";
   GET_PAYMENTS_SORTING_ENUM2["PAYMENT_MODE"] = "PAYMENT_MODE";
   GET_PAYMENTS_SORTING_ENUM2["CREATED_TIME"] = "CREATED_TIME";
+  GET_PAYMENTS_SORTING_ENUM2["DUE_AMOUNT"] = "DUE_AMOUNT";
   return GET_PAYMENTS_SORTING_ENUM2;
 })({});
 var EVENT_INSTANCE_KIND = /* @__PURE__ */ (function(EVENT_INSTANCE_KIND2) {
@@ -3524,9 +3525,17 @@ var MICROSOFT_GRAPH_PATHS = {
   userCalendarEvents: /* @__PURE__ */ __name((mailboxEmail) => `/users/${encodeURIComponent(mailboxEmail)}/calendar/events`, "userCalendarEvents"),
   userCalendarEvent: /* @__PURE__ */ __name((mailboxEmail, eventId) => `/users/${encodeURIComponent(mailboxEmail)}/calendar/events/${encodeURIComponent(eventId)}`, "userCalendarEvent"),
   userCalendarView: /* @__PURE__ */ __name((mailboxEmail, startDateTime, endDateTime) => `/users/${encodeURIComponent(mailboxEmail)}/calendarView?startDateTime=${encodeURIComponent(startDateTime)}&endDateTime=${encodeURIComponent(endDateTime)}`, "userCalendarView"),
+  userCalendarViewDelta: /* @__PURE__ */ __name((mailboxEmail, startDateTime, endDateTime) => `/users/${encodeURIComponent(mailboxEmail)}/calendarView/delta?startDateTime=${encodeURIComponent(startDateTime)}&endDateTime=${encodeURIComponent(endDateTime)}`, "userCalendarViewDelta"),
+  userCalendarEventAccept: /* @__PURE__ */ __name((mailboxEmail, eventId) => `/users/${encodeURIComponent(mailboxEmail)}/events/${encodeURIComponent(eventId)}/accept`, "userCalendarEventAccept"),
+  userCalendarEventDecline: /* @__PURE__ */ __name((mailboxEmail, eventId) => `/users/${encodeURIComponent(mailboxEmail)}/events/${encodeURIComponent(eventId)}/decline`, "userCalendarEventDecline"),
+  /** Real Graph instance ids of a recurring series in a date window - backs "this and following" edits. */
+  userCalendarEventInstances: /* @__PURE__ */ __name((mailboxEmail, seriesMasterEventId, startDateTime, endDateTime) => `/users/${encodeURIComponent(mailboxEmail)}/calendar/events/${encodeURIComponent(seriesMasterEventId)}/instances?startDateTime=${encodeURIComponent(startDateTime)}&endDateTime=${encodeURIComponent(endDateTime)}`, "userCalendarEventInstances"),
   subscriptions: "/subscriptions",
-  subscription: /* @__PURE__ */ __name((subscriptionId) => `/subscriptions/${encodeURIComponent(subscriptionId)}`, "subscription")
+  subscription: /* @__PURE__ */ __name((subscriptionId) => `/subscriptions/${encodeURIComponent(subscriptionId)}`, "subscription"),
+  /** Graph JSON batching endpoint - up to 20 sub-requests per call. */
+  batch: "/$batch"
 };
+var MICROSOFT_CALENDAR_DELTA_DEFAULT_WINDOW_YEARS = 10;
 var MICROSOFT_DEFAULT_GRAPH_BASE_URL = "https://graph.microsoft.com/v1.0";
 var MICROSOFT_DEFAULT_AUTH_URL = "https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token";
 
@@ -4032,7 +4041,10 @@ function graphEventsToInstances(response) {
   return (response.value ?? []).filter((graph) => Boolean(graph.id && graph.start?.dateTime)).map((graph) => omitUndefined({
     id: graph.id,
     startDateLabel: graph.start.dateTime.slice(0, 10),
-    seriesId: graph.seriesMasterId
+    seriesId: graph.seriesMasterId,
+    iCalUId: graph.iCalUId,
+    transactionId: graph.transactionId,
+    subject: graph.subject
   }));
 }
 __name(graphEventsToInstances, "graphEventsToInstances");
@@ -4064,6 +4076,7 @@ function _ts_metadata23(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata23, "_ts_metadata");
+var GRAPH_BATCH_MAX_SIZE = 20;
 exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService extends BaseCalendarBookingManagement {
   static {
     __name(this, "MicrosoftCalendarBookingService");
@@ -4169,6 +4182,81 @@ exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService
       throw error;
     }
   }
+  async getEvent(request, integration, loggedInUserId) {
+    try {
+      const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceId);
+      this.assertMailbox(mailboxEmail);
+      this.assertEventId(request.eventId);
+      let url = MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, request.eventId);
+      const queryParams = [];
+      const selectFields = [
+        "id",
+        "seriesMasterId",
+        "type",
+        "subject",
+        "body",
+        "start",
+        "end",
+        "isAllDay",
+        "location",
+        "recurrence",
+        "attendees",
+        "organizer",
+        "isOrganizer",
+        "transactionId",
+        "iCalUId"
+      ];
+      if (request.expandSeriesExceptions) {
+        selectFields.push("cancelledOccurrences");
+        queryParams.push("$expand=exceptionOccurrences");
+      }
+      queryParams.push(`$select=${selectFields.join(",")}`);
+      if (queryParams.length > 0) {
+        url += `?${queryParams.join("&")}`;
+      }
+      this.logger.info(loggedInUserId, this.getEvent.name, this.fileName, "Get Microsoft Graph calendar event", {
+        mailboxEmail,
+        eventId: request.eventId,
+        url
+      });
+      const response = await this.microsoftApiClient.apiCall({
+        apiMethod: HTTP_METHOD.GET,
+        url
+      }, integration, loggedInUserId);
+      return graphEventToRef(response, {
+        resourceId: request.resourceId,
+        organizerUserEmail: this.organizerUserMailbox(request.organizerUserEmail)
+      });
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.getEvent.name, this.fileName, "Error getting Microsoft Graph calendar event", error);
+      throw error;
+    }
+  }
+  async acceptEvent(request, integration, loggedInUserId) {
+    try {
+      const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceEmail);
+      this.assertMailbox(mailboxEmail);
+      this.assertEventId(request.eventId);
+      this.logger.info(loggedInUserId, this.acceptEvent.name, this.fileName, "Accept Microsoft Graph calendar event", {
+        mailboxEmail,
+        eventId: request.eventId
+      });
+      const shouldSendResponse = request.sendResponse ?? false;
+      await this.microsoftApiClient.apiCall({
+        apiMethod: HTTP_METHOD.POST,
+        url: `${MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, request.eventId)}/accept`,
+        body: {
+          sendResponse: shouldSendResponse,
+          ...shouldSendResponse && request.comment ? {
+            comment: request.comment
+          } : {}
+        }
+      }, integration, loggedInUserId);
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.acceptEvent.name, this.fileName, "Error accepting Microsoft Graph calendar event", error);
+      throw error;
+    }
+  }
   async getEvents(request, integration, loggedInUserId) {
     try {
       const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceEmail);
@@ -4197,6 +4285,117 @@ exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService
       throw error;
     }
   }
+  /**
+   * Resolves the real Graph instance ids of a recurring series over a date window — the
+   * per-occurrence exception model needs these to PATCH an occurrence directly rather than the
+   * series master, so an edit never touches the master's own `start`/`recurrence.range`.
+   */
+  async getEventInstances(request, integration, loggedInUserId) {
+    try {
+      const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceEmail);
+      this.assertMailbox(mailboxEmail);
+      this.assertEventId(request.seriesEventId);
+      const url = MICROSOFT_GRAPH_PATHS.userCalendarEventInstances(mailboxEmail, request.seriesEventId, `${request.startDateLabel}T00:00:00`, `${request.endDateLabel}T23:59:59`);
+      this.logger.info(loggedInUserId, this.getEventInstances.name, this.fileName, "List Microsoft Graph series instances", {
+        mailboxEmail,
+        seriesEventId: request.seriesEventId,
+        path: url
+      });
+      const response = await this.microsoftApiClient.apiCall({
+        apiMethod: HTTP_METHOD.GET,
+        url
+      }, integration, loggedInUserId);
+      const events = graphEventsToInstances(response);
+      this.logger.info(loggedInUserId, this.getEventInstances.name, this.fileName, "Listed Microsoft Graph series instances", {
+        mailboxEmail,
+        seriesEventId: request.seriesEventId,
+        count: events.length
+      });
+      return {
+        events
+      };
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.getEventInstances.name, this.fileName, "Error listing Microsoft Graph series instances", error);
+      throw error;
+    }
+  }
+  /**
+   * PATCHes a set of a series' own instances as provider-native exceptions, batched via Graph
+   * `$batch` (≤20 sub-requests per call). Never throws on a partial failure — each instance's
+   * outcome is reported individually so the caller can persist what succeeded and retry the rest.
+   */
+  async updateEventInstances(request, integration, loggedInUserId) {
+    try {
+      const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceEmail);
+      this.assertMailbox(mailboxEmail);
+      this.logger.info(loggedInUserId, this.updateEventInstances.name, this.fileName, "Batch-update Microsoft Graph series instances", {
+        mailboxEmail,
+        instanceCount: request.updates.length
+      });
+      const results = [];
+      for (const chunk of this.chunkInstanceUpdates(request.updates)) {
+        const batchRequests = chunk.map((update, index) => ({
+          id: String(index),
+          method: "PATCH",
+          url: MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, update.instanceId),
+          body: toGraphEvent(update.event, {
+            targetMailbox: mailboxEmail
+          })
+        }));
+        const batchResponse = await this.microsoftApiClient.apiCall({
+          apiMethod: HTTP_METHOD.POST,
+          url: MICROSOFT_GRAPH_PATHS.batch,
+          body: {
+            requests: batchRequests
+          }
+        }, integration, loggedInUserId);
+        const responseById = new Map(batchResponse.responses.map((entry) => [
+          entry.id,
+          entry
+        ]));
+        chunk.forEach((update, index) => {
+          const entry = responseById.get(String(index));
+          if (!entry || entry.status >= 300) {
+            this.logger.warn(loggedInUserId, this.updateEventInstances.name, this.fileName, "Failed to update a series instance", {
+              mailboxEmail,
+              instanceId: update.instanceId,
+              status: entry?.status
+            });
+            results.push({
+              instanceId: update.instanceId,
+              error: entry ? `Graph responded ${entry.status}` : "No batch response entry"
+            });
+            return;
+          }
+          results.push({
+            instanceId: update.instanceId,
+            ref: graphEventToRef(entry.body ?? {}, {
+              organizerUserEmail: request.organizerUserEmail
+            })
+          });
+        });
+      }
+      this.logger.info(loggedInUserId, this.updateEventInstances.name, this.fileName, "Batch-updated Microsoft Graph series instances", {
+        mailboxEmail,
+        succeeded: results.filter((result) => !result.error).length,
+        failed: results.filter((result) => result.error).length
+      });
+      return {
+        results
+      };
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.updateEventInstances.name, this.fileName, "Error batch-updating Microsoft Graph series instances", error);
+      throw error;
+    }
+  }
+  /** Splits instance updates into Graph-`$batch`-sized chunks (≤20 sub-requests each). */
+  chunkInstanceUpdates(updates) {
+    const chunks = [];
+    for (let i = 0; i < updates.length; i += GRAPH_BATCH_MAX_SIZE) {
+      chunks.push(updates.slice(i, i + GRAPH_BATCH_MAX_SIZE));
+    }
+    return chunks;
+  }
   async deleteGraphEvent(mailboxEmail, eventId, integration, loggedInUserId) {
     this.assertMailbox(mailboxEmail);
     this.assertEventId(eventId);
@@ -4367,6 +4566,7 @@ var GRAPH_SUBSCRIPTION_KNOWN_KEYS = /* @__PURE__ */ new Set([
   "resource",
   "changeType",
   "notificationUrl",
+  "lifecycleNotificationUrl",
   "expirationDateTime",
   "clientState"
 ]);
@@ -4456,6 +4656,66 @@ exports.MicrosoftCalendarWebhookService = class MicrosoftCalendarWebhookService
       throw error;
     }
   }
+  async batchRefreshSubscriptions(items, integration, loggedInUserId) {
+    if (items.length === 0) {
+      return [];
+    }
+    const batchBody = {
+      requests: items.map((item) => ({
+        id: item.requestId,
+        method: HTTP_METHOD.PATCH,
+        url: MICROSOFT_GRAPH_PATHS.subscription(item.subscriptionId),
+        body: {
+          expirationDateTime: item.expirationDateTime
+        },
+        headers: {
+          ["Content-Type"]: "application/json"
+        }
+      }))
+    };
+    try {
+      this.logger.info(loggedInUserId, this.batchRefreshSubscriptions.name, this.fileName, "Batch refresh Microsoft Graph subscriptions", {
+        count: items.length
+      });
+      const batchResponse = await this.microsoftApiClient.apiCall({
+        apiMethod: HTTP_METHOD.POST,
+        url: "/$batch",
+        body: batchBody
+      }, integration, loggedInUserId);
+      return items.map((item) => {
+        const response = batchResponse.responses.find((entry) => entry.id === item.requestId);
+        if (!response) {
+          return {
+            requestId: item.requestId,
+            subscriptionId: item.subscriptionId,
+            success: false,
+            error: "Missing batch response entry"
+          };
+        }
+        if (response.status >= 200 && response.status < 300) {
+          const subscription = this.fromGraphSubscription(response.body ?? {});
+          return {
+            requestId: item.requestId,
+            subscriptionId: item.subscriptionId,
+            success: true,
+            subscription,
+            status: response.status
+          };
+        }
+        const errorBody = response.body;
+        return {
+          requestId: item.requestId,
+          subscriptionId: item.subscriptionId,
+          success: false,
+          status: response.status,
+          error: errorBody?.error?.message ?? `Graph batch PATCH failed with status ${response.status}`
+        };
+      });
+    } catch (error) {
+      this.logger.error(loggedInUserId, this.batchRefreshSubscriptions.name, this.fileName, "Error batch refreshing subscriptions", error);
+      throw error;
+    }
+  }
   toGraphSubscription(request) {
     const graph = {
       changeType: request.changeTypes.join(","),
@@ -4463,6 +4723,9 @@ exports.MicrosoftCalendarWebhookService = class MicrosoftCalendarWebhookService
       resource: request.resource,
       expirationDateTime: request.expirationDateTime
     };
+    if (request.lifecycleNotificationUrl) {
+      graph.lifecycleNotificationUrl = request.lifecycleNotificationUrl;
+    }
     if (request.clientState !== void 0) {
       graph.clientState = request.clientState;
     }
@@ -4822,6 +5085,18 @@ exports.MicrosoftCalendarBookingHandler = class MicrosoftCalendarBookingHandler
   async getCalendarBookings(request, integration, loggedInUserId) {
     return this.microsoftCalendarBookingService.getEvents(request, integration, loggedInUserId);
   }
+  async getCalendarBooking(request, integration, loggedInUserId) {
+    return this.microsoftCalendarBookingService.getEvent(request, integration, loggedInUserId);
+  }
+  async acceptCalendarBooking(request, integration, loggedInUserId) {
+    return this.microsoftCalendarBookingService.acceptEvent(request, integration, loggedInUserId);
+  }
+  async getCalendarBookingInstances(request, integration, loggedInUserId) {
+    return this.microsoftCalendarBookingService.getEventInstances(request, integration, loggedInUserId);
+  }
+  async updateCalendarBookingInstances(request, integration, loggedInUserId) {
+    return this.microsoftCalendarBookingService.updateEventInstances(request, integration, loggedInUserId);
+  }
 };
 exports.MicrosoftCalendarBookingHandler = _ts_decorate36([
   common.Injectable(),
@@ -5019,6 +5294,31 @@ var ICalendarWebhookHandler = class {
   static {
     __name(this, "ICalendarWebhookHandler");
   }
+  async batchRefreshCalendarWebhooks(items, integration, loggedInUserId) {
+    const results = [];
+    for (const item of items) {
+      try {
+        const response = await this.refreshCalendarWebhook({
+          subscriptionId: item.subscriptionId,
+          expirationDateTime: item.expirationDateTime
+        }, integration, loggedInUserId);
+        results.push({
+          requestId: item.requestId,
+          subscriptionId: item.subscriptionId,
+          success: true,
+          subscription: response.subscription
+        });
+      } catch (error) {
+        results.push({
+          requestId: item.requestId,
+          subscriptionId: item.subscriptionId,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return results;
+  }
 };
 
 // src/providers/microsoft/microsoft-calendar-webhook.handler.ts
@@ -5050,6 +5350,9 @@ exports.MicrosoftCalendarWebhookHandler = class MicrosoftCalendarWebhookHandler
   async deleteCalendarWebhook(request, integration, loggedInUserId) {
     return this.microsoftCalendarWebhookService.deleteSubscription(request, integration, loggedInUserId);
   }
+  async batchRefreshCalendarWebhooks(items, integration, loggedInUserId) {
+    return this.microsoftCalendarWebhookService.batchRefreshSubscriptions(items, integration, loggedInUserId);
+  }
 };
 exports.MicrosoftCalendarWebhookHandler = _ts_decorate42([
   common.Injectable(),
@@ -5210,6 +5513,7 @@ exports.ICalendarResourceHandler = ICalendarResourceHandler;
 exports.ICalendarWebhookHandler = ICalendarWebhookHandler;
 exports.INVOICE_STATUS_ENUM = INVOICE_STATUS_ENUM;
 exports.IntegrationVisitorCredentialMappingDao = IntegrationVisitorCredentialMappingDao;
+exports.MICROSOFT_CALENDAR_DELTA_DEFAULT_WINDOW_YEARS = MICROSOFT_CALENDAR_DELTA_DEFAULT_WINDOW_YEARS;
 exports.MICROSOFT_CLIENT_CREDENTIALS_GRANT_TYPE = MICROSOFT_CLIENT_CREDENTIALS_GRANT_TYPE;
 exports.MICROSOFT_DEFAULT_ACCESS_TOKEN_TYPE = MICROSOFT_DEFAULT_ACCESS_TOKEN_TYPE;
 exports.MICROSOFT_DEFAULT_AUTH_URL = MICROSOFT_DEFAULT_AUTH_URL;