@7365admin1/layer-common 3.2.7 → 3.2.8-staging.201

package/composables/useRole.ts

@@ -68,6 +68,26 @@ export default function useRole() {
     });
   }
 
+  function getDeletionPreview(_id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/roles/${_id}/deletion-preview`,
+      { method: "GET" }
+    );
+  }
+
+  function deleteWithReassignments(
+    _id: string,
+    reassignments: Array<{ memberId: string; roleId: string }>
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/roles/${_id}/delete-with-reassignments`,
+      {
+        method: "PUT",
+        body: { reassignments },
+      }
+    );
+  }
+
   const role = useState<TRole>("userRole", () => {
     return {
       _id: "",
@@ -103,6 +123,8 @@ export default function useRole() {
     updateRoleById,
     updateRoleFieldById,
     deleteRole,
+    getDeletionPreview,
+    deleteWithReassignments,
     updatePermissionById,
     getRoleByUserId,
   };

package/composables/useServiceProvider.ts

@@ -8,9 +8,9 @@ export default function useServiceProvider() {
     () => []
   );
 
-  const page = useState("page", () => 1);
-  const pages = useState("pages", () => 0);
-  const pageRange = useState("pageRange", () => "-- - -- of --");
+  const page = useState("serviceProviderPage", () => 1);
+  const pages = useState("serviceProviderPages", () => 0);
+  const pageRange = useState("serviceProviderPageRange", () => "-- - -- of --");
 
   const serviceProvider = useState(
     "serviceProvider",

package/composables/useServiceProviderInvitation.ts

@@ -0,0 +1,145 @@
+/**
+ * Service-provider invitations — the list a property manager sees and the
+ * things they can do to a row.
+ *
+ * Separate from `useVerification` because these rows are not generic
+ * verifications any more: they have their own states (waiting for Seven365,
+ * waiting for the provider, not approved, declined) and their own actions,
+ * and the server scopes them to the caller's own organisation.
+ */
+export type TServiceProviderInvitation = {
+  _id: string;
+  email: string;
+  type: string;
+  status: string;
+  statusLabel: string;
+  rejectionReason?: string | null;
+  createdAt?: string;
+  expireAt?: string;
+  deletedAt?: string | null;
+  metadata?: Record<string, any>;
+  history?: Array<{
+    action: string;
+    at: string;
+    byName?: string;
+    reason?: string;
+  }>;
+};
+
+/** The words on screen. Kept beside the server's own list on purpose — a
+ *  status the server invents must never render as a raw stored value. */
+export const SERVICE_PROVIDER_INVITE_LABELS: Record<string, string> = {
+  "awaiting-approval": "Waiting for Seven365",
+  pending: "Waiting for the provider",
+  rejected: "Not approved",
+  complete: "Accepted",
+  declined: "Declined",
+  cancelled: "Cancelled",
+  expired: "Expired",
+};
+
+export function serviceProviderInviteLabel(status?: string) {
+  return SERVICE_PROVIDER_INVITE_LABELS[String(status ?? "")] ?? "Unknown";
+}
+
+export default function useServiceProviderInvitation() {
+  const base = "/api/service-provider-invitations";
+
+  function getInvitations({
+    org = "",
+    status = "",
+    page = 1,
+    limit = 20,
+  } = {}): Promise<{
+    items: TServiceProviderInvitation[];
+    pages: number;
+    pageRange: string;
+  }> {
+    return useNuxtApp().$api(base, {
+      method: "GET",
+      query: { org, status, page, limit },
+    });
+  }
+
+  function cancelInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/cancel`, {
+      method: "PUT",
+    });
+  }
+
+  /** Sends the same invitation again. Never creates a second row. */
+  function resendInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/resend`, {
+      method: "PUT",
+    });
+  }
+
+  /** Soft delete — the row leaves this list, Seven365 keeps the record. */
+  function deleteInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}`, {
+      method: "DELETE",
+    });
+  }
+
+  // ---- Seven365 super admin ------------------------------------------------
+
+  function getApprovals({
+    status = "awaiting-approval",
+    page = 1,
+    limit = 20,
+    includeDeleted = false,
+  } = {}): Promise<{
+    items: TServiceProviderInvitation[];
+    pages: number;
+    pageRange: string;
+    awaitingApprovalCount: number;
+  }> {
+    return useNuxtApp().$api(`${base}/approvals`, {
+      method: "GET",
+      query: { status, page, limit, includeDeleted },
+    });
+  }
+
+  function getApprovalCount(): Promise<{ count: number }> {
+    return useNuxtApp().$api(`${base}/approvals/count`, { method: "GET" });
+  }
+
+  function approveInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/approve`, {
+      method: "PUT",
+    });
+  }
+
+  /** The reason is required — it is what the property manager is shown. */
+  function rejectInvitation(id: string, reason: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/reject`, {
+      method: "PUT",
+      body: { reason },
+    });
+  }
+
+  // ---- the invited service provider ----------------------------------------
+
+  function getInvitation(id: string): Promise<TServiceProviderInvitation> {
+    return useNuxtApp().$api(`${base}/${id}`, { method: "GET" });
+  }
+
+  function declineInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/decline`, {
+      method: "PUT",
+    });
+  }
+
+  return {
+    getInvitations,
+    cancelInvitation,
+    resendInvitation,
+    deleteInvitation,
+    getApprovals,
+    getApprovalCount,
+    approveInvitation,
+    rejectInvitation,
+    getInvitation,
+    declineInvitation,
+  };
+}

package/composables/useSipWebPhone.ts

@@ -0,0 +1,336 @@
+import { computed, onScopeDispose, readonly, ref, shallowRef } from "vue";
+import type { SimpleUser, SimpleUserDelegate, SimpleUserOptions } from "sip.js/lib/platform/web";
+import type { SessionDescriptionHandlerOptions } from "sip.js/lib/platform/web/session-description-handler/session-description-handler-options";
+
+export type SipWebPhoneConfig = {
+  webSocketServer: string;
+  aor: string;
+  authorizationUsername: string;
+  authorizationPassword: string;
+  displayName?: string;
+  video?: boolean;
+};
+
+export type SipWebPhoneMedia = {
+  remoteAudio?: HTMLAudioElement | null;
+  remoteVideo?: HTMLVideoElement | null;
+};
+
+type ConnectionState = "disconnected" | "connecting" | "registered" | "error";
+type CallState = "idle" | "calling" | "incoming" | "active" | "ending";
+
+export default function useSipWebPhone() {
+  const simpleUser = shallowRef<SimpleUser>();
+  const connectionState = ref<ConnectionState>("disconnected");
+  const callState = ref<CallState>("idle");
+  const errorMessage = ref("");
+  const muted = ref(false);
+  const remoteVideoAvailable = ref(false);
+  const currentTarget = ref("");
+  const activeConfig = shallowRef<SipWebPhoneConfig>();
+
+  const isRegistered = computed(() => connectionState.value === "registered");
+  const hasCall = computed(() => callState.value !== "idle");
+  const audioConstraints: MediaTrackConstraints = {
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true,
+    channelCount: 1,
+  };
+
+  async function connect(config: SipWebPhoneConfig, media: SipWebPhoneMedia) {
+    validateConfig(config);
+    await disconnect();
+
+    connectionState.value = "connecting";
+    errorMessage.value = "";
+    activeConfig.value = { ...config };
+    let clearRegistrationTimer = () => {};
+
+    try {
+      const { SimpleUser: SimpleUserConstructor } = await import("sip.js/lib/platform/web");
+      let registrationSettled = false;
+      let resolveRegistration: (() => void) | undefined;
+      let rejectRegistration: ((error: Error) => void) | undefined;
+      const registrationPromise = new Promise<void>((resolve, reject) => {
+        resolveRegistration = resolve;
+        rejectRegistration = reject;
+      });
+      const registrationTimeout = globalThis.setTimeout(() => {
+        if (registrationSettled) return;
+        registrationSettled = true;
+        rejectRegistration?.(new Error("SIP registration timed out. Check the WebSocket server and account credentials."));
+      }, 15000);
+      clearRegistrationTimer = () => globalThis.clearTimeout(registrationTimeout);
+      const settleRegistration = (error?: Error) => {
+        if (registrationSettled) return;
+        registrationSettled = true;
+        clearRegistrationTimer();
+        if (error) rejectRegistration?.(error);
+        else resolveRegistration?.();
+      };
+      const delegate: SimpleUserDelegate = {
+        onCallCreated: () => {
+          if (callState.value !== "incoming") callState.value = "calling";
+        },
+        onCallReceived: () => {
+          callState.value = "incoming";
+          currentTarget.value = "Incoming call";
+        },
+        onCallAnswered: () => {
+          callState.value = "active";
+          ensureMicrophoneSending();
+          syncVideoState();
+        },
+        onCallHangup: () => {
+          const previousState = callState.value;
+          resetCall();
+          if (previousState === "calling") {
+            errorMessage.value = "The call was not answered or was rejected by the destination.";
+          }
+        },
+        onRegistered: () => {
+          connectionState.value = "registered";
+          settleRegistration();
+        },
+        onUnregistered: () => {
+          if (connectionState.value === "connecting") {
+            settleRegistration(new Error("SIP registration was rejected. Check the username and password."));
+          }
+          connectionState.value = "disconnected";
+        },
+        onServerDisconnect: () => {
+          const error = new Error("The SIP WebSocket server disconnected during registration.");
+          connectionState.value = "error";
+          errorMessage.value = error.message;
+          settleRegistration(error);
+          resetCall();
+        },
+      };
+      const options: SimpleUserOptions = {
+        aor: normalizeSipUri(config.aor),
+        delegate,
+        media: {
+          // The browser sends microphone audio and receives HID audio/video.
+          // Do not request a local camera merely because the HID video leg is enabled.
+          constraints: { audio: audioConstraints, video: false },
+          remote: {
+            audio: media.remoteAudio || undefined,
+            video: media.remoteVideo || undefined,
+          },
+        },
+        userAgentOptions: {
+          authorizationUsername: config.authorizationUsername,
+          authorizationPassword: config.authorizationPassword,
+          displayName: config.displayName || config.authorizationUsername,
+        },
+      };
+
+      const user = new SimpleUserConstructor(config.webSocketServer.trim(), options);
+      simpleUser.value = user;
+      await user.connect();
+      await user.register();
+      await registrationPromise;
+    } catch (error) {
+      clearRegistrationTimer();
+      await disconnect(false);
+      connectionState.value = "error";
+      errorMessage.value = getErrorMessage(error);
+      throw error;
+    }
+  }
+
+  async function disconnect(clearError = true) {
+    const user = simpleUser.value;
+    simpleUser.value = undefined;
+
+    if (user) {
+      try {
+        if (hasCall.value) await user.hangup();
+      } catch {
+        // The session may already have ended remotely.
+      }
+      try {
+        await user.unregister();
+      } catch {
+        // Registration may not have completed.
+      }
+      try {
+        await user.disconnect();
+      } catch {
+        // The WebSocket may already be closed.
+      }
+    }
+
+    connectionState.value = "disconnected";
+    activeConfig.value = undefined;
+    resetCall();
+    if (clearError) errorMessage.value = "";
+  }
+
+  async function call(target: string) {
+    const user = requireRegisteredUser();
+    const destination = normalizeDestination(target, activeConfig.value?.aor || "");
+    errorMessage.value = "";
+    currentTarget.value = destination;
+    callState.value = "calling";
+    try {
+      const sessionDescriptionHandlerOptions: SessionDescriptionHandlerOptions = {
+        constraints: { audio: audioConstraints, video: false },
+        offerOptions: {
+          offerToReceiveAudio: true,
+          offerToReceiveVideo: Boolean(activeConfig.value?.video),
+        },
+      };
+      await user.call(destination, { sessionDescriptionHandlerOptions });
+    } catch (error) {
+      resetCall();
+      errorMessage.value = getErrorMessage(error);
+      throw error;
+    }
+  }
+
+  async function answer() {
+    const user = requireRegisteredUser();
+    const sessionDescriptionHandlerOptions: SessionDescriptionHandlerOptions = {
+      constraints: { audio: audioConstraints, video: false },
+      offerOptions: {
+        offerToReceiveAudio: true,
+        offerToReceiveVideo: Boolean(activeConfig.value?.video),
+      },
+    };
+    await user.answer({ sessionDescriptionHandlerOptions });
+  }
+
+  async function decline() {
+    const user = requireUser();
+    callState.value = "ending";
+    await user.decline();
+    resetCall();
+  }
+
+  async function hangup() {
+    const user = requireUser();
+    callState.value = "ending";
+    await user.hangup();
+    resetCall();
+  }
+
+  function toggleMute() {
+    const user = requireUser();
+    const tracks = user.localMediaStream?.getAudioTracks() || [];
+    if (!tracks.length) throw new Error("No microphone track is available for this call.");
+    const enable = muted.value;
+    tracks.forEach((track) => {
+      track.enabled = enable;
+    });
+    muted.value = !enable;
+  }
+
+  function ensureMicrophoneSending() {
+    const tracks = simpleUser.value?.localMediaStream?.getAudioTracks() || [];
+    if (!tracks.length) {
+      errorMessage.value = "The call connected without a microphone track. Reconnect and allow microphone access.";
+      return;
+    }
+    tracks.forEach((track) => {
+      track.enabled = true;
+    });
+    muted.value = false;
+  }
+
+  function syncVideoState() {
+    const user = simpleUser.value;
+    const remoteStream = user?.remoteMediaStream;
+    const remoteTrack = remoteStream?.getVideoTracks()[0];
+
+    const updateState = () => {
+      const currentRemoteTrack = remoteStream?.getVideoTracks()[0];
+      remoteVideoAvailable.value = Boolean(currentRemoteTrack && currentRemoteTrack.readyState === "live");
+    };
+
+    updateState();
+    if (remoteStream) remoteStream.onaddtrack = updateState;
+
+    if (remoteTrack) {
+      remoteTrack.onended = () => {
+        remoteVideoAvailable.value = false;
+      };
+    }
+  }
+
+  function resetCall() {
+    callState.value = "idle";
+    currentTarget.value = "";
+    muted.value = false;
+    remoteVideoAvailable.value = false;
+  }
+
+  function requireRegisteredUser() {
+    const user = requireUser();
+    if (!isRegistered.value) throw new Error("Connect the web phone before making a call.");
+    return user;
+  }
+
+  function requireUser() {
+    if (!simpleUser.value) throw new Error("Web phone is not connected.");
+    return simpleUser.value;
+  }
+
+  onScopeDispose(() => {
+    void disconnect();
+  });
+
+  return {
+    connectionState: readonly(connectionState),
+    callState: readonly(callState),
+    errorMessage: readonly(errorMessage),
+    muted: readonly(muted),
+    remoteVideoAvailable: readonly(remoteVideoAvailable),
+    currentTarget: readonly(currentTarget),
+    isRegistered,
+    hasCall,
+    connect,
+    disconnect,
+    call,
+    answer,
+    decline,
+    hangup,
+    toggleMute,
+  };
+}
+
+function validateConfig(config: SipWebPhoneConfig) {
+  if (!/^wss:\/\//i.test(config.webSocketServer.trim())) {
+    throw new Error("SIP WebSocket URL must use WSS.");
+  }
+  if (!config.aor.trim() || !config.authorizationUsername.trim() || !config.authorizationPassword) {
+    throw new Error("SIP address, username, and password are required.");
+  }
+}
+
+function normalizeSipUri(value: string) {
+  const trimmed = value.trim();
+  return trimmed.toLowerCase().startsWith("sip:") ? trimmed : `sip:${trimmed}`;
+}
+
+function normalizeDestination(target: string, aor: string) {
+  const trimmed = target.trim();
+  if (!trimmed) throw new Error("Enter an extension or SIP address to call.");
+  if (trimmed.toLowerCase().startsWith("sip:")) return trimmed;
+  if (trimmed.includes("@")) return `sip:${trimmed}`;
+
+  const domain = normalizeSipUri(aor).split("@")[1];
+  if (!domain) throw new Error("Enter a full SIP address for the destination.");
+  return `sip:${trimmed}@${domain}`;
+}
+
+function getErrorMessage(error: unknown) {
+  if (error instanceof DOMException && error.name === "NotAllowedError") {
+    return "Microphone permission was denied. Allow microphone access in the browser and reconnect the web phone.";
+  }
+  if (error instanceof DOMException && error.name === "NotFoundError") {
+    return "No microphone was found for this call.";
+  }
+  return error instanceof Error ? error.message : "SIP connection failed.";
+}

package/composables/useSubscriptionPlan.ts

@@ -0,0 +1,62 @@
+export default function useSubscriptionPlan() {
+  function getAll({
+    page = 1,
+    search = "",
+    limit = 10,
+    status = "active",
+    planType = "",
+    billingCycle = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/subscription-plans`, {
+      method: "GET",
+      query: {
+        page,
+        search,
+        limit,
+        status,
+        planType,
+        billingCycle,
+      },
+    });
+  }
+  function add(value: any) {
+    return useNuxtApp().$api<Record<string, any>>("/api/subscription-plans", {
+      method: "POST",
+      body: value,
+    });
+  }
+  function getById(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/subscription-plans/id/${id}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+  function updateById(id: string, value: any) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/subscription-plans/${id}`,
+      {
+        method: "PUT",
+        body: value,
+      }
+    );
+  }
+  function updateStatusById(id: string, status: "active" | "deactive") {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/subscription-plans/${id}/status`,
+      {
+        method: "PATCH",
+        body: { status },
+      }
+    );
+  }
+
+  return {
+    getAll,
+    add,
+    getById,
+    updateById,
+    updateStatusById,
+  };
+}

package/composables/useThemePreference.ts

@@ -0,0 +1,63 @@
+/**
+ * THE USER'S LIGHT/DARK CHOICE, REMEMBERED.
+ *
+ * Until now `Layout/Header.vue` flipped `theme.global.name` and wrote nothing,
+ * so the choice was gone on the next reload.
+ *
+ * A COOKIE, NOT localStorage. The handoff says "persists in localStorage", and
+ * for a single-page prototype that is right - but this product is ELEVEN
+ * applications on eleven hostnames. localStorage is per-origin, so a user who
+ * picked dark mode in Security would land on a white screen in Property
+ * Management, and again in Account, and would have to set it eleven times.
+ *
+ * A cookie written with the layer's own `cookieConfig` carries the parent
+ * domain, which is exactly how `sid`, `user` and `landing-page` already travel
+ * between these applications. So this is the estate's existing preference
+ * mechanism rather than a new one, and it is also the only one that makes the
+ * setting mean what a user expects it to mean.
+ *
+ * NO FLASH OF THE WRONG THEME. Nothing here corrects the theme after mount -
+ * `plugins/vuetify.ts` reads the same cookie BEFORE `createVuetify` and boots
+ * on it, so the first paint is already right. The apps are `ssr: false`, so
+ * there is no server render to disagree with.
+ */
+import { useTheme } from "vuetify";
+import type { CookieOptions } from "#app";
+
+export type TThemeName = "light" | "dark";
+
+/** The one place the cookie is named. `plugins/vuetify.ts` reads the same one. */
+export const THEME_COOKIE = "theme";
+
+export default function useThemePreference() {
+  // `runtimeConfig.public.cookieConfig` is typed `unknown`, so it is narrowed
+  // here rather than at every call site. Same object `sid`, `user` and
+  // `landing-page` are written with - it carries the shared parent domain.
+  const cookieConfig = useRuntimeConfig().public.cookieConfig as CookieOptions<
+    TThemeName | null
+  > & { readonly?: false };
+
+  const vuetifyTheme = useTheme();
+
+  const stored = useCookie<TThemeName | null>(THEME_COOKIE, cookieConfig);
+
+  const current = computed<TThemeName>(() =>
+    vuetifyTheme.global.current.value.dark ? "dark" : "light"
+  );
+
+  /**
+   * Sets the theme AND remembers it. The write is the whole point - a caller
+   * that only wants a temporary theme for one subtree should use
+   * `<v-theme-provider>` instead, which is what `plain-dark` does.
+   */
+  function setTheme(name: TThemeName) {
+    vuetifyTheme.global.name.value = name;
+    stored.value = name;
+  }
+
+  function toggleTheme() {
+    setTheme(current.value === "dark" ? "light" : "dark");
+  }
+
+  return { current, setTheme, toggleTheme, stored };
+}

package/composables/useVisitor.ts

@@ -92,6 +92,7 @@ export default function () {
     checkedOut?: boolean;
     plateNumber?: string;
     tab?: string;
+    passOrKey?: string;
   };
 
   type SearchUncheckedOutUnregisteredVisitorParams = {
@@ -130,6 +131,7 @@ export default function () {
     plateNumber = "",
     checkedOut,
     tab,
+    passOrKey,
   }: GetVisitorsParams = {}) {
     const query = Object.fromEntries(
       Object.entries({
@@ -146,7 +148,10 @@ export default function () {
         plateNumber,
         order,
         tab,
-      }).filter(([, value]) => value !== undefined && value !== null && value !== "")
+        passOrKey,
+      }).filter(
+        ([, value]) => value !== undefined && value !== null && value !== ""
+      )
     );
 
     return await useNuxtApp().$api<Record<string, any>>(