vr-commons 1.0.96 → 1.0.98

package/dist/utils/admin.device.utils.d.ts

@@ -0,0 +1,59 @@
+import { UserRole } from "vr-models";
+import { Transaction } from "sequelize";
+import { StockChangeResult } from "./types";
+export declare const stockUtil: {
+    /**
+     * Increment stock when devices are added/created
+     */
+    incrementStock(productId: string, quantity?: number, options?: {
+        transaction?: Transaction;
+        reason?: string;
+        actorId?: string;
+        actorType: UserRole;
+    }): Promise<StockChangeResult>;
+    /**
+     * Decrement stock when devices are removed/deleted/assigned
+     */
+    decrementStock(productId: string, quantity?: number, options?: {
+        transaction?: Transaction;
+        reason?: string;
+        actorId?: string;
+        allowNegative?: boolean;
+        actorType: UserRole;
+    }): Promise<StockChangeResult>;
+    /**
+     * Set stock to specific value
+     */
+    setStock(productId: string, newStock: number, options?: {
+        transaction?: Transaction;
+        reason?: string;
+        actorId?: string;
+        actorType: UserRole;
+    }): Promise<StockChangeResult>;
+    /**
+     * Validate if product has enough stock
+     */
+    hasEnoughStock(productId: string, quantity?: number, transaction?: Transaction): Promise<boolean>;
+    /**
+     * Get current stock level
+     */
+    getStockLevel(productId: string, transaction?: Transaction): Promise<number>;
+    /**
+     * Bulk update stock for multiple products
+     */
+    bulkUpdateStock(updates: Array<{
+        productId: string;
+        change: number;
+        reason?: string;
+    }>, actorType: UserRole, options?: {
+        transaction?: Transaction;
+        actorId?: string;
+    }): Promise<Record<string, StockChangeResult>>;
+    /**
+     * Sync stock based on actual device count
+     */
+    syncStockWithDeviceCount(productId: string, actorType: UserRole, options?: {
+        transaction?: Transaction;
+        actorId?: string;
+    }): Promise<StockChangeResult>;
+};

package/dist/utils/admin.device.utils.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stockUtil = void 0;
+// src/utils/stock.util.ts
+const vr_models_1 = require("vr-models");
+const eventLog_utils_1 = require("./eventLog.utils");
+exports.stockUtil = {
+    /**
+     * Increment stock when devices are added/created
+     */
+    async incrementStock(productId, quantity = 1, options) {
+        const product = await vr_models_1.Product.findByPk(productId, {
+            transaction: options?.transaction,
+        });
+        if (!product) {
+            throw new Error(`Product with ID ${productId} not found`);
+        }
+        const previousStock = product.stock;
+        // Use the model's instance method if available, otherwise direct update
+        if (typeof product.incrementStock === "function") {
+            await product.incrementStock(quantity);
+        }
+        else {
+            product.stock += quantity;
+            await product.save({ transaction: options?.transaction });
+        }
+        // Log stock change
+        if (options?.actorId) {
+            await (0, eventLog_utils_1.logEvent)({
+                actorId: options.actorId,
+                actorType: options.actorType,
+                action: "PRODUCT_STOCK_INCREMENTED",
+                entity: "Product",
+                entityId: productId,
+                deviceSession: null,
+                metadata: {
+                    quantity,
+                    previousStock,
+                    newStock: product.stock,
+                    reason: options.reason || "Device added to inventory",
+                },
+                transaction: options?.transaction,
+            });
+        }
+        return {
+            success: true,
+            previousStock,
+            newStock: product.stock,
+            productId: product.id,
+            productName: product.name,
+        };
+    },
+    /**
+     * Decrement stock when devices are removed/deleted/assigned
+     */
+    async decrementStock(productId, quantity = 1, options) {
+        const product = await vr_models_1.Product.findByPk(productId, {
+            transaction: options?.transaction,
+        });
+        if (!product) {
+            throw new Error(`Product with ID ${productId} not found`);
+        }
+        // Check if enough stock (unless allowNegative is true)
+        if (!options?.allowNegative && product.stock < quantity) {
+            throw new Error(`Insufficient stock. Available: ${product.stock}, Requested: ${quantity}`);
+        }
+        const previousStock = product.stock;
+        // Use the model's instance method if available
+        if (typeof product.decrementStock === "function") {
+            await product.decrementStock(quantity);
+        }
+        else {
+            product.stock -= quantity;
+            await product.save({ transaction: options?.transaction });
+        }
+        // Log stock change
+        if (options?.actorId) {
+            await (0, eventLog_utils_1.logEvent)({
+                actorId: options.actorId,
+                actorType: options.actorType,
+                action: "PRODUCT_STOCK_DECREMENTED",
+                entity: "Product",
+                entityId: productId,
+                deviceSession: null,
+                metadata: {
+                    quantity,
+                    previousStock,
+                    newStock: product.stock,
+                    reason: options.reason || "Device removed from inventory",
+                },
+                transaction: options?.transaction,
+            });
+        }
+        return {
+            success: true,
+            previousStock,
+            newStock: product.stock,
+            productId: product.id,
+            productName: product.name,
+        };
+    },
+    /**
+     * Set stock to specific value
+     */
+    async setStock(productId, newStock, options) {
+        const product = await vr_models_1.Product.findByPk(productId, {
+            transaction: options?.transaction,
+        });
+        if (!product) {
+            throw new Error(`Product with ID ${productId} not found`);
+        }
+        if (newStock < 0) {
+            throw new Error("Stock cannot be negative");
+        }
+        const previousStock = product.stock;
+        product.stock = newStock;
+        await product.save({ transaction: options?.transaction });
+        // Log stock change
+        if (options?.actorId) {
+            await (0, eventLog_utils_1.logEvent)({
+                actorId: options.actorId,
+                actorType: options.actorType,
+                action: "PRODUCT_STOCK_SET_MANUALLY",
+                entity: "Product",
+                entityId: productId,
+                deviceSession: null,
+                metadata: {
+                    previousStock,
+                    newStock,
+                    reason: options.reason || "Manual stock adjustment",
+                },
+                transaction: options?.transaction,
+            });
+        }
+        return {
+            success: true,
+            previousStock,
+            newStock: product.stock,
+            productId: product.id,
+            productName: product.name,
+        };
+    },
+    /**
+     * Validate if product has enough stock
+     */
+    async hasEnoughStock(productId, quantity = 1, transaction) {
+        const product = await vr_models_1.Product.findByPk(productId, { transaction });
+        if (!product)
+            return false;
+        return product.stock >= quantity;
+    },
+    /**
+     * Get current stock level
+     */
+    async getStockLevel(productId, transaction) {
+        const product = await vr_models_1.Product.findByPk(productId, {
+            transaction,
+            attributes: ["stock"],
+        });
+        return product?.stock || 0;
+    },
+    /**
+     * Bulk update stock for multiple products
+     */
+    async bulkUpdateStock(updates, actorType, options) {
+        const results = {};
+        for (const update of updates) {
+            try {
+                if (update.change > 0) {
+                    results[update.productId] = await this.incrementStock(update.productId, update.change, {
+                        transaction: options?.transaction,
+                        reason: update.reason,
+                        actorId: options?.actorId,
+                        actorType: actorType,
+                    });
+                }
+                else if (update.change < 0) {
+                    results[update.productId] = await this.decrementStock(update.productId, Math.abs(update.change), {
+                        transaction: options?.transaction,
+                        reason: update.reason,
+                        actorId: options?.actorId,
+                        actorType: actorType,
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`Failed to update stock for product ${update.productId}:`, error);
+                results[update.productId] = {
+                    success: false,
+                    previousStock: 0,
+                    newStock: 0,
+                    productId: update.productId,
+                    productName: "Unknown",
+                };
+            }
+        }
+        return results;
+    },
+    /**
+     * Sync stock based on actual device count
+     */
+    async syncStockWithDeviceCount(productId, actorType, options) {
+        // Count total devices for this product
+        const totalDevices = await vr_models_1.Device.count({
+            where: { productId },
+            transaction: options?.transaction,
+        });
+        // Count devices that are in use (have active payment plans)
+        const inUseDevices = await vr_models_1.Device.count({
+            where: { productId },
+            include: [
+                {
+                    model: vr_models_1.DevicePaymentPlan,
+                    as: "paymentPlans",
+                    where: { status: "ACTIVE" },
+                    required: true,
+                },
+            ],
+            transaction: options?.transaction,
+        });
+        // Available devices = total - inUse
+        const availableDevices = totalDevices - inUseDevices;
+        // Set stock to available devices
+        return await this.setStock(productId, availableDevices, {
+            transaction: options?.transaction,
+            reason: "Stock synced with actual device count",
+            actorId: options?.actorId,
+            actorType: actorType,
+        });
+    },
+};

package/dist/utils/admin.devicePayment.utils.d.ts

@@ -0,0 +1,46 @@
+import { DevicePaymentPlan } from "vr-models";
+import { Transaction } from "sequelize";
+export interface DeleteCheckResult {
+    canDelete: boolean;
+    reason?: string;
+}
+export declare const DPP_OperationsUtil: {
+    /**
+     * Check if a payment plan can be deleted
+     * Rule: Can only delete if NO payments have been made
+     */
+    canDeletePlan(planId: string, transaction?: Transaction): Promise<DeleteCheckResult>;
+    /**
+     * Check if plan can be updated (before payments)
+     */
+    canUpdatePlan(plan: DevicePaymentPlan): {
+        canUpdate: boolean;
+        reason?: string;
+    };
+    /**
+     * Validate payment amount against next pending installment
+     */
+    validatePaymentAmount(plan: DevicePaymentPlan, amount: number, transaction?: Transaction): Promise<{
+        valid: boolean;
+        reason?: string;
+        nextInstallment?: any;
+    }>;
+    /**
+     * Calculate new values after payment
+     */
+    calculatePaymentEffects(plan: DevicePaymentPlan, amount: number): {
+        newPaidAmount: number;
+        newOutstandingAmount: number;
+        isNowCompleted: boolean;
+        progress: number;
+        statusChanged: boolean;
+    };
+    /**
+     * Generate installments for a hire purchase plan
+     */
+    generateInstallments(plan: DevicePaymentPlan, transaction?: Transaction): Promise<void>;
+    /**
+     * Format plan for operation response
+     */
+    formatPlanForOps(plan: DevicePaymentPlan | null): any;
+};

package/dist/utils/admin.devicePayment.utils.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DPP_OperationsUtil = void 0;
+// src/utils/admin.devicePayment.utils.ts
+const vr_models_1 = require("vr-models");
+exports.DPP_OperationsUtil = {
+    /**
+     * Check if a payment plan can be deleted
+     * Rule: Can only delete if NO payments have been made
+     */
+    async canDeletePlan(planId, transaction) {
+        // Check if any payments exist for this plan
+        const paymentCount = await vr_models_1.Payment.count({
+            where: { devicePaymentPlanId: planId },
+            transaction,
+        });
+        if (paymentCount > 0) {
+            return {
+                canDelete: false,
+                reason: `Cannot delete plan with ${paymentCount} payment(s) already recorded`,
+            };
+        }
+        // Also check if any installments are paid
+        const paidInstallments = await vr_models_1.Installment.count({
+            where: {
+                devicePaymentPlanId: planId,
+                status: "PAID",
+            },
+            transaction,
+        });
+        if (paidInstallments > 0) {
+            return {
+                canDelete: false,
+                reason: "Cannot delete plan with paid installments",
+            };
+        }
+        return { canDelete: true };
+    },
+    /**
+     * Check if plan can be updated (before payments)
+     */
+    canUpdatePlan(plan) {
+        if (plan.paidAmount > 0) {
+            return {
+                canUpdate: false,
+                reason: "Cannot update plan after payments have been made",
+            };
+        }
+        if (plan.status !== "ACTIVE") {
+            return {
+                canUpdate: false,
+                reason: `Cannot update plan with status: ${plan.status}`,
+            };
+        }
+        return { canUpdate: true };
+    },
+    /**
+     * Validate payment amount against next pending installment
+     */
+    async validatePaymentAmount(plan, amount, transaction) {
+        const InstallmentModel = vr_models_1.Installment;
+        const nextInstallment = await InstallmentModel.findOne({
+            where: {
+                devicePaymentPlanId: plan.id,
+                status: "PENDING",
+            },
+            order: [["dueDate", "ASC"]],
+            transaction,
+        });
+        if (!nextInstallment) {
+            return {
+                valid: false,
+                reason: "No pending installments found",
+            };
+        }
+        // For now, require exact installment amount
+        // Could be modified to allow overpayment later
+        if (amount !== nextInstallment.amount) {
+            return {
+                valid: false,
+                reason: `Payment amount must equal the next installment amount of ${nextInstallment.amount}`,
+                nextInstallment,
+            };
+        }
+        return { valid: true, nextInstallment };
+    },
+    /**
+     * Calculate new values after payment
+     */
+    calculatePaymentEffects(plan, amount) {
+        const newPaidAmount = plan.paidAmount + amount;
+        const newOutstandingAmount = Math.max(0, plan.outstandingAmount - amount);
+        const wasCompleted = plan.status === "COMPLETED";
+        const isNowCompleted = newOutstandingAmount <= 0;
+        const totalAmount = plan.pricingSnapshot.totalAmount;
+        const progress = (newPaidAmount / totalAmount) * 100;
+        return {
+            newPaidAmount,
+            newOutstandingAmount,
+            isNowCompleted,
+            progress,
+            statusChanged: !wasCompleted && isNowCompleted,
+        };
+    },
+    /**
+     * Generate installments for a hire purchase plan
+     */
+    async generateInstallments(plan, transaction) {
+        const pricing = plan.pricingSnapshot;
+        if (pricing.type !== "HIRE_PURCHASE" || !pricing.installmentCount) {
+            return; // No installments for full payment plans
+        }
+        const InstallmentModel = vr_models_1.Installment;
+        const installments = [];
+        const dueDate = new Date(); // First installment due after creation
+        if (pricing.installmentFrequency === "DAILY") {
+            dueDate.setDate(dueDate.getDate() + 1);
+        }
+        else if (pricing.installmentFrequency === "WEEKLY") {
+            dueDate.setDate(dueDate.getDate() + 7);
+        }
+        else if (pricing.installmentFrequency === "MONTHLY") {
+            dueDate.setMonth(dueDate.getMonth() + 1);
+        }
+        for (let i = 1; i <= pricing.installmentCount; i++) {
+            installments.push({
+                devicePaymentPlanId: plan.id,
+                installmentNumber: i,
+                amount: Number(pricing.installmentAmount),
+                dueDate: new Date(dueDate),
+                status: "PENDING",
+                isAutoGenerated: true,
+            });
+            // Calculate next due date
+            if (pricing.installmentFrequency === "DAILY") {
+                dueDate.setDate(dueDate.getDate() + 1);
+            }
+            else if (pricing.installmentFrequency === "WEEKLY") {
+                dueDate.setDate(dueDate.getDate() + 7);
+            }
+            else if (pricing.installmentFrequency === "MONTHLY") {
+                dueDate.setMonth(dueDate.getMonth() + 1);
+            }
+        }
+        await InstallmentModel.bulkCreate(installments, { transaction });
+        // Set the first installment as next due
+        plan.nextInstallmentDueAt = installments[0]?.dueDate || null;
+        await plan.save({ transaction });
+    },
+    /**
+     * Format plan for operation response
+     */
+    formatPlanForOps(plan) {
+        if (!plan)
+            return null;
+        // Safely extract data without using toJSON() which exposes internal types
+        const planData = {
+            id: plan.id,
+            userId: plan.userId,
+            pricingSnapshot: plan.pricingSnapshot,
+            paidAmount: plan.paidAmount,
+            outstandingAmount: plan.outstandingAmount,
+            lastPaymentAt: plan.lastPaymentAt,
+            nextInstallmentDueAt: plan.nextInstallmentDueAt,
+            status: plan.status,
+            completedAt: plan.completedAt,
+            createdAt: plan.createdAt,
+            updatedAt: plan.updatedAt,
+            devices: plan.devices || [],
+            user: plan.user || null,
+            installments: plan.installments || [],
+        };
+        const totalAmount = planData.pricingSnapshot?.totalAmount || 0;
+        const hasInstallments = (planData.installments?.length ?? 0) > 0;
+        return {
+            id: planData.id,
+            userId: planData.userId,
+            pricingSnapshot: {
+                type: planData.pricingSnapshot?.type || null,
+                totalAmount: planData.pricingSnapshot?.totalAmount || 0,
+                downPayment: planData.pricingSnapshot?.downPayment || 0,
+                installmentAmount: planData.pricingSnapshot?.installmentAmount || null,
+                installmentFrequency: planData.pricingSnapshot?.installmentFrequency || null,
+                installmentCount: planData.pricingSnapshot?.installmentCount || null,
+                gracePeriodDays: planData.pricingSnapshot?.gracePeriodDays || 2,
+                autoLockOnMiss: planData.pricingSnapshot?.autoLockOnMiss ?? true,
+            },
+            paidAmount: planData.paidAmount || 0,
+            outstandingAmount: planData.outstandingAmount || 0,
+            lastPaymentAt: planData.lastPaymentAt,
+            nextInstallmentDueAt: planData.nextInstallmentDueAt,
+            status: planData.status || "ACTIVE",
+            completedAt: planData.completedAt,
+            createdAt: planData.createdAt,
+            updatedAt: planData.updatedAt,
+            devices: planData.devices || [],
+            user: planData.user || null,
+            installments: planData.installments || [],
+            progress: totalAmount > 0 ? (plan.paidAmount / totalAmount) * 100 : 0,
+            canEdit: plan.paidAmount === 0,
+            canDelete: plan.paidAmount === 0,
+            isOverdue: false,
+            hasInstallments,
+        };
+    },
+};

package/dist/utils/index.d.ts

@@ -9,5 +9,7 @@ export { suspensionUtil } from "./suspension.utils";
 export { createDeviceSession } from "./session.utils";
 export { generateOTP, getOTPExpiry, getVerificationMethod, sendEmail, sendSMS, sendVerificationCode, } from "./verification.utils";
 export { getUserLevel, isRankEqual, isSubordinate, isSubordinateOrEqual, isSuperior, isSuperiorOrEqual, validateHierarchy, } from "./hierarchy.utils";
+export { stockUtil } from "./admin.device.utils";
 export { cloudinaryUtil } from "./product.utils";
-export { PendingRegistration, VerificationMethod, ConfirmResponse, UploadResult, } from "./types";
+export { DPP_OperationsUtil } from "./admin.devicePayment.utils";
+export { PendingRegistration, VerificationMethod, ConfirmResponse, UploadResult, StockChangeResult, } from "./types";

package/dist/utils/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRankEqual = exports.getUserLevel = exports.sendVerificationCode = exports.sendSMS = exports.sendEmail = exports.getVerificationMethod = exports.getOTPExpiry = exports.generateOTP = exports.createDeviceSession = exports.suspensionUtil = exports.banUtil = exports.hasHigherAuthority = exports.getModeratableRoles = exports.canModerateUser = exports.canModerate = exports.softDeleteUser = exports.hashPassword = exports.validatePassword = exports.validateUniqueFields = exports.generateJacketId = exports.getSortOrder = exports.generateEventSearchConditions = exports.generateUserSearchConditions = exports.findSecurityClearanceByRole = exports.getUsersByRole = exports.getUserById = exports.isAccountAccessible = exports.canModifyAccount = exports.hasAllPermissions = exports.hasAnyPermission = exports.hasPermission = exports.hasRole = exports.formatUserListResponse = exports.formatUserProfile = exports.sendErrorResponse = exports.sendSuccessResponse = exports.logEvent = exports.formatTimeRemaining = exports.getTokenTimeRemaining = exports.generateToken = exports.shouldRefreshToken = exports.verifyToken = exports.generateRiderToken = exports.generatePassengerToken = exports.generateAdminToken = exports.checkSuspensionStatus = exports.checkIsUserBannedOrSuspended = exports.checkBanStatus = exports.hasActiveDependencies = exports.checkAccountDependencies = void 0;
-exports.cloudinaryUtil = exports.validateHierarchy = exports.isSuperiorOrEqual = exports.isSuperior = exports.isSubordinateOrEqual = exports.isSubordinate = void 0;
+exports.DPP_OperationsUtil = exports.cloudinaryUtil = exports.stockUtil = exports.validateHierarchy = exports.isSuperiorOrEqual = exports.isSuperior = exports.isSubordinateOrEqual = exports.isSubordinate = void 0;
 var account_utils_1 = require("./account.utils");
 Object.defineProperty(exports, "checkAccountDependencies", { enumerable: true, get: function () { return account_utils_1.checkAccountDependencies; } });
 Object.defineProperty(exports, "hasActiveDependencies", { enumerable: true, get: function () { return account_utils_1.hasActiveDependencies; } });
@@ -75,5 +75,9 @@ Object.defineProperty(exports, "isSubordinateOrEqual", { enumerable: true, get:
 Object.defineProperty(exports, "isSuperior", { enumerable: true, get: function () { return hierarchy_utils_1.isSuperior; } });
 Object.defineProperty(exports, "isSuperiorOrEqual", { enumerable: true, get: function () { return hierarchy_utils_1.isSuperiorOrEqual; } });
 Object.defineProperty(exports, "validateHierarchy", { enumerable: true, get: function () { return hierarchy_utils_1.validateHierarchy; } });
+var admin_device_utils_1 = require("./admin.device.utils");
+Object.defineProperty(exports, "stockUtil", { enumerable: true, get: function () { return admin_device_utils_1.stockUtil; } });
 var product_utils_1 = require("./product.utils");
 Object.defineProperty(exports, "cloudinaryUtil", { enumerable: true, get: function () { return product_utils_1.cloudinaryUtil; } });
+var admin_devicePayment_utils_1 = require("./admin.devicePayment.utils");
+Object.defineProperty(exports, "DPP_OperationsUtil", { enumerable: true, get: function () { return admin_devicePayment_utils_1.DPP_OperationsUtil; } });

package/dist/utils/types.d.ts

@@ -27,3 +27,10 @@ export interface UploadResult {
     url: string;
     publicId: string;
 }
+export interface StockChangeResult {
+    success: boolean;
+    previousStock: number;
+    newStock: number;
+    productId: string;
+    productName: string;
+}