indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/activity/notifications/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Notifications API Module
+ * Exports notification functionality
+ */
+export { default as NotificationsAPI } from './notifications.js';
+export { default as RemindersAPI } from './reminders.js';
+export type { ReminderModule, ReminderStatus } from './reminders.js';
+export * from './types.js';
+export { notifyApprovalStatusChanged, notifyEnquiryConverted, notifyQuotationSaved, notifyQuotationMailSent, notifyQuotationDeleted, notifyEnquiryCreated, notifyEnquiryAssigned, notifyEnquiryUpdated, notifyEnquiryDeleted, notifyUserCrud, notifyPasswordChanged, notifyMasterCrud } from './send.js';

package/dist/lib/api/activity/notifications/index.js

@@ -0,0 +1,9 @@
+'use client';
+/**
+ * Notifications API Module
+ * Exports notification functionality
+ */
+export { default as NotificationsAPI } from './notifications.js';
+export { default as RemindersAPI } from './reminders.js';
+export * from './types.js';
+export { notifyApprovalStatusChanged, notifyEnquiryConverted, notifyQuotationSaved, notifyQuotationMailSent, notifyQuotationDeleted, notifyEnquiryCreated, notifyEnquiryAssigned, notifyEnquiryUpdated, notifyEnquiryDeleted, notifyUserCrud, notifyPasswordChanged, notifyMasterCrud } from './send.js';

package/dist/lib/api/activity/notifications/notifications.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Notifications API Client
+ *
+ * Handles user notifications (create, list, mark-as-read, delete)
+ */
+import type { APIResponse } from '../../core/types.js';
+import type { NotificationRequest, NotificationResponse, NotificationFilters } from './types.js';
+/**
+ * Notifications API
+ */
+declare class NotificationsAPI {
+    /**
+     * Create a new notification
+     * POST /api/notifications
+     */
+    static create(request: NotificationRequest, session: any, baseURL?: string): Promise<APIResponse<{
+        notificationId: number;
+    }>>;
+    /**
+     * Get notifications for current user
+     * GET /api/notifications
+     */
+    static getList(filters: NotificationFilters, session: any, baseURL?: string): Promise<APIResponse<NotificationResponse[]>>;
+    /**
+     * Get unread notification count
+     * GET /api/notifications/unread-count
+     */
+    static getUnreadCount(session: any): Promise<APIResponse<number>>;
+    /**
+     * Mark notifications as read
+     * POST /api/notifications/mark-read
+     */
+    static markAsRead(notificationIds: number[], session: any, baseURL?: string): Promise<APIResponse<{
+        count: number;
+    }>>;
+    /**
+     * Mark all notifications as read
+     * POST /api/notifications/mark-all-read
+     */
+    static markAllAsRead(session: any, baseURL?: string): Promise<APIResponse<{
+        count: number;
+    }>>;
+    /**
+     * Delete a notification
+     * POST /api/notifications/delete/{id}
+     */
+    static delete(notificationId: number, session: any, baseURL?: string): Promise<APIResponse<{
+        notificationId: number;
+    }>>;
+    /**
+     * Clear all read notifications
+     * POST /api/notifications/clear-read
+     */
+    static clearRead(session: any, baseURL?: string): Promise<APIResponse<{
+        count: number;
+    }>>;
+}
+export default NotificationsAPI;
+export { NotificationsAPI };

package/dist/lib/api/activity/notifications/notifications.js

@@ -0,0 +1,218 @@
+'use client';
+/**
+ * Notifications API Client
+ *
+ * Handles user notifications (create, list, mark-as-read, delete)
+ */
+import APIClient from '../../core/client.js';
+import { fromBackendNotification, toBackendNotificationRequest } from './types.js';
+/**
+ * Notifications API
+ */
+class NotificationsAPI {
+    /**
+     * Create a new notification
+     * POST /api/notifications
+     */
+    static async create(request, session, baseURL) {
+        try {
+            const backendRequest = toBackendNotificationRequest(request);
+            const response = await APIClient.post('/api/notifications', backendRequest, session, baseURL);
+            if (response.success && response.data) {
+                return {
+                    success: true,
+                    data: {
+                        notificationId: response.data.NotificationID
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to create notification'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Get notifications for current user
+     * GET /api/notifications
+     */
+    static async getList(filters = {}, session, baseURL) {
+        try {
+            const queryParams = new URLSearchParams();
+            if (filters.limit)
+                queryParams.append('limit', filters.limit.toString());
+            if (filters.unreadOnly)
+                queryParams.append('unreadOnly', 'true');
+            if (filters.type)
+                queryParams.append('type', filters.type);
+            if (filters.module)
+                queryParams.append('module', filters.module);
+            if (filters.priority)
+                queryParams.append('priority', filters.priority);
+            if (filters.category)
+                queryParams.append('category', filters.category);
+            const url = `/api/notifications${queryParams.toString() ? '?' + queryParams.toString() : ''}`;
+            const response = await APIClient.get(url, session, baseURL);
+            if (response.success && response.data) {
+                const notifications = Array.isArray(response.data)
+                    ? response.data.map(fromBackendNotification)
+                    : [];
+                return {
+                    success: true,
+                    data: notifications
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to fetch notifications'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Get unread notification count
+     * GET /api/notifications/unread-count
+     */
+    static async getUnreadCount(session) {
+        try {
+            const response = await APIClient.get('/api/notifications/unread-count', session);
+            if (response.success && response.data) {
+                return {
+                    success: true,
+                    data: response.data.UnreadCount
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to fetch unread count'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Mark notifications as read
+     * POST /api/notifications/mark-read
+     */
+    static async markAsRead(notificationIds, session, baseURL) {
+        try {
+            const response = await APIClient.post('/api/notifications/mark-read', { NotificationIDs: notificationIds }, session, baseURL);
+            if (response.success && response.data) {
+                return {
+                    success: true,
+                    data: {
+                        count: response.data.Count
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to mark notifications as read'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Mark all notifications as read
+     * POST /api/notifications/mark-all-read
+     */
+    static async markAllAsRead(session, baseURL) {
+        try {
+            const response = await APIClient.post('/api/notifications/mark-all-read', {}, session, baseURL);
+            if (response.success && response.data) {
+                return {
+                    success: true,
+                    data: {
+                        count: response.data.Count
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to mark all notifications as read'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Delete a notification
+     * POST /api/notifications/delete/{id}
+     */
+    static async delete(notificationId, session, baseURL) {
+        try {
+            const response = await APIClient.post(`/api/notifications/delete/${notificationId}`, {}, session, baseURL);
+            if (response.success && response.data) {
+                return {
+                    success: true,
+                    data: {
+                        notificationId: response.data.NotificationID
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to delete notification'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Clear all read notifications
+     * POST /api/notifications/clear-read
+     */
+    static async clearRead(session, baseURL) {
+        try {
+            const response = await APIClient.post('/api/notifications/clear-read', {}, session, baseURL);
+            if (response.success && response.data) {
+                return {
+                    success: true,
+                    data: {
+                        count: response.data.Count
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to clear read notifications'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+}
+export default NotificationsAPI;
+export { NotificationsAPI };

package/dist/lib/api/activity/notifications/reminders.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reminders API Client
+ *
+ * Shared reminder + escalation across modules. Reminders are stored as
+ * Notifications rows (Category='Reminder' / 'Escalation', keyed Module +
+ * DocumentID), so state is derived rather than duplicated in another table.
+ *
+ * Flow: the raiser sends up to two manual reminders; if the assignee still
+ * has not responded 24h after the second, the server sweep escalates to the
+ * assignee's manager (UserMaster.UnderUserID).
+ */
+import type { APIResponse } from '../../core/types.js';
+/** Modules the reminder system knows about (see ModuleMap in ReminderController). */
+export type ReminderModule = 'RateEnquiry' | 'Costing';
+export interface ReminderStatus {
+    module: ReminderModule;
+    documentId: number;
+    documentNo: string;
+    reminderCount: number;
+    maxReminders: number;
+    remaining: number;
+    lastReminderAt: string | null;
+    escalated: boolean;
+    escalatesAt: string | null;
+    isOpen: boolean;
+    assignedToUserId: number;
+    /** True only for the raiser, while open, with reminders left and someone assigned. */
+    canRemind: boolean;
+}
+declare class RemindersAPI {
+    static getStatus(module: ReminderModule, documentId: number, session?: any): Promise<APIResponse<ReminderStatus>>;
+    static send(module: ReminderModule, documentId: number, session?: any): Promise<APIResponse>;
+    static escalate(module: ReminderModule, documentId: number, session?: any): Promise<APIResponse>;
+}
+export default RemindersAPI;

package/dist/lib/api/activity/notifications/reminders.js

@@ -0,0 +1,25 @@
+'use client';
+/**
+ * Reminders API Client
+ *
+ * Shared reminder + escalation across modules. Reminders are stored as
+ * Notifications rows (Category='Reminder' / 'Escalation', keyed Module +
+ * DocumentID), so state is derived rather than duplicated in another table.
+ *
+ * Flow: the raiser sends up to two manual reminders; if the assignee still
+ * has not responded 24h after the second, the server sweep escalates to the
+ * assignee's manager (UserMaster.UnderUserID).
+ */
+import APIClient from '../../core/client.js';
+class RemindersAPI {
+    static async getStatus(module, documentId, session) {
+        return APIClient.get(`api/notifications/reminder/status/${module}/${documentId}`, session);
+    }
+    static async send(module, documentId, session) {
+        return APIClient.post('api/notifications/reminder/send', { Module: module, DocumentID: documentId }, session);
+    }
+    static async escalate(module, documentId, session) {
+        return APIClient.post('api/notifications/reminder/escalate', { Module: module, DocumentID: documentId }, session);
+    }
+}
+export default RemindersAPI;

package/dist/lib/api/activity/notifications/send.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Notification Trigger Helpers
+ *
+ * Fire-and-forget functions that send notifications after business events.
+ * These NEVER block the calling flow — errors are silently swallowed.
+ *
+ * Usage:
+ *   import { notifyApprovalStatusChanged, notifyEnquiryConverted } from './send.js'
+ *   // After successful API response:
+ *   notifyApprovalStatusChanged({ ... }, session)
+ */
+interface ApprovalNotificationParams {
+    action: 'Approve' | 'Reject' | 'Rework' | 'Pending';
+    bookingNo: string;
+    bookingId: string | number;
+    /** The user who performed the action */
+    actorUserName: string;
+    /** The user who created/owns the quotation (receives notification) */
+    targetUserId?: number;
+    targetUserName?: string;
+    remarks?: string;
+}
+export declare function notifyApprovalStatusChanged(params: ApprovalNotificationParams, session: any): void;
+interface CostApprovedParams {
+    approvalNo: string;
+    bookingNo: string;
+    clientName?: string;
+    jobName?: string;
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyCostApproved(params: CostApprovedParams, session: any): void;
+interface EnquiryConversionParams {
+    enquiryNo: string;
+    enquiryId: number;
+    bookingNo?: string;
+    jobName?: string;
+    /** Who converted it */
+    actorUserName: string;
+    /** Who should be notified (e.g. enquiry creator, sales person) */
+    targetUserId?: number;
+    targetUserName?: string;
+}
+export declare function notifyEnquiryConverted(params: EnquiryConversionParams, session: any): void;
+interface QuotationSavedParams {
+    bookingNo: string;
+    jobName?: string;
+    clientName?: string;
+    mode: 'new' | 'clone';
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyQuotationSaved(params: QuotationSavedParams, session: any): void;
+interface QuotationMailSentParams {
+    bookingNo: string;
+    clientName?: string;
+    jobName?: string;
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyQuotationMailSent(params: QuotationMailSentParams, session: any): void;
+interface QuotationDeletedParams {
+    quoteNo: string;
+    jobName?: string;
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyQuotationDeleted(params: QuotationDeletedParams, session: any): void;
+interface EnquiryCreatedParams {
+    enquiryNo: string;
+    jobName?: string;
+    clientName?: string;
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyEnquiryCreated(params: EnquiryCreatedParams, session: any): void;
+interface EnquiryAssignedParams {
+    enquiryId: number;
+    enquiryNo?: string;
+    assignedToUserId: number;
+    assignedToUserName: string;
+    actorUserName: string;
+}
+export declare function notifyEnquiryAssigned(params: EnquiryAssignedParams, session: any): void;
+interface EnquiryUpdatedParams {
+    enquiryNo: string;
+    jobName?: string;
+    clientName?: string;
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyEnquiryUpdated(params: EnquiryUpdatedParams, session: any): void;
+interface EnquiryDeletedParams {
+    enquiryNo: string;
+    jobName?: string;
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyEnquiryDeleted(params: EnquiryDeletedParams, session: any): void;
+interface UserCrudParams {
+    action: 'Created' | 'Updated' | 'Deleted';
+    userName: string;
+    loginUserName?: string;
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyUserCrud(params: UserCrudParams, session: any): void;
+interface PasswordChangedParams {
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyPasswordChanged(params: PasswordChangedParams, session: any): void;
+interface MasterCrudParams {
+    action: 'Created' | 'Updated' | 'Deleted';
+    masterType: 'Machine' | 'Process' | 'Item' | 'Ledger' | 'Category';
+    name: string;
+    code?: string;
+    actorUserName: string;
+    targetUserId?: number;
+}
+export declare function notifyMasterCrud(params: MasterCrudParams, session: any): void;
+export {};