@7365admin1/core 3.41.1 → 3.42.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @iservice365/core
 
+## 3.42.0
+
+### Minor Changes
+
+- ff7b915: release changes in payment api
+
 ## 3.41.1
 
 ### Patch Changes

package/dist/index.d.ts

@@ -6907,6 +6907,9 @@ declare function useRedDotPaymentController(): {
     redirectPaymentTransaction: (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
     enquirePaymentTransaction: (req: Request, res: Response) => Promise<Response<any, Record<string, any>>>;
     createPayment: (req: Request, res: Response, next: NextFunction) => Promise<Response<any, Record<string, any>> | undefined>;
+    getPaymentByReference: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    updateStatus: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getPaidBills: (req: Request, res: Response, next: NextFunction) => Promise<void>;
 };
 
 interface IDirectPayment extends IBaseModel {
@@ -6945,6 +6948,8 @@ declare const useRedDotPaymentSvc: () => {
 type TBillingItems = {
     _id: ObjectId | string;
     name: string;
+    amount: number;
+    referenceNumber: string;
 };
 type TBillingPayments = {
     _id?: ObjectId;
@@ -6967,11 +6972,27 @@ type TBillingPayments = {
 
 declare const useRedDotPaymentRepo: () => {
     paySingleUnitBill: (refId: string, payload: Partial<TUnitBilling>) => Promise<mongodb.WithId<bson.Document> | null>;
-    createPayment: (type: string, payload: Partial<TBillingPayments>, session?: ClientSession) => Promise<ObjectId | undefined>;
+    createPayment: (type: string, payload: Partial<TBillingPayments>, session?: ClientSession) => Promise<string | undefined>;
     payMultipleUnitBill: (refId: string[], payload: Partial<TUnitBilling>) => Promise<{
         message: string;
         remainingBalance: number;
     }>;
+    getPaidBills: ({ search, page, limit, sort, month, year, unitId, }: {
+        search?: string | undefined;
+        page?: number | undefined;
+        limit?: number | undefined;
+        sort?: Record<string, any> | undefined;
+        month?: string | undefined;
+        year?: string | undefined;
+        unitId: string | ObjectId;
+    }, session?: ClientSession) => Promise<{
+        items: any[];
+        pages: number;
+        pageRange: string;
+    }>;
+    createIndexes: () => Promise<void>;
+    getPaymentByReference: (referenceNumber: string, session?: ClientSession) => Promise<TBillingPayments>;
+    updateStatus: (referenceNumber: string, status: string, session?: ClientSession) => Promise<mongodb.UpdateResult<bson.Document>>;
 };
 
 declare enum VerificationType {

package/dist/index.js

@@ -536,13 +536,13 @@ var require_logger = __commonJS({
     "use strict";
     exports.__esModule = true;
     var _utils = require_utils();
-    var logger201 = {
+    var logger202 = {
       methodMap: ["debug", "info", "warn", "error"],
       level: "info",
       // Maps a given level value to the `methodMap` indexes above.
       lookupLevel: function lookupLevel(level) {
         if (typeof level === "string") {
-          var levelMap = _utils.indexOf(logger201.methodMap, level.toLowerCase());
+          var levelMap = _utils.indexOf(logger202.methodMap, level.toLowerCase());
           if (levelMap >= 0) {
             level = levelMap;
           } else {
@@ -553,9 +553,9 @@ var require_logger = __commonJS({
       },
       // Can be overridden in the host environment
       log: function log(level) {
-        level = logger201.lookupLevel(level);
-        if (typeof console !== "undefined" && logger201.lookupLevel(logger201.level) <= level) {
-          var method = logger201.methodMap[level];
+        level = logger202.lookupLevel(level);
+        if (typeof console !== "undefined" && logger202.lookupLevel(logger202.level) <= level) {
+          var method = logger202.methodMap[level];
           if (!console[method]) {
             method = "log";
           }
@@ -566,7 +566,7 @@ var require_logger = __commonJS({
         }
       }
     };
-    exports["default"] = logger201;
+    exports["default"] = logger202;
     module2.exports = exports["default"];
   }
 });
@@ -64884,9 +64884,19 @@ var import_mongodb135 = require("mongodb");
 var import_node_server_utils223 = require("@7365admin1/node-server-utils");
 var import_mongodb134 = require("mongodb");
 var import_joi126 = __toESM(require("joi"));
+var BillingPaymentStatus = /* @__PURE__ */ ((BillingPaymentStatus2) => {
+  BillingPaymentStatus2["PENDING"] = "pending";
+  BillingPaymentStatus2["SUCCESS"] = "success";
+  BillingPaymentStatus2["FAILED"] = "failed";
+  BillingPaymentStatus2["PARTIAL"] = "partial";
+  BillingPaymentStatus2["CANCELLED"] = "cancelled";
+  return BillingPaymentStatus2;
+})(BillingPaymentStatus || {});
 var schemaBillingItems = import_joi126.default.object({
   _id: import_joi126.default.string().hex().optional(),
-  name: import_joi126.default.string().optional().allow(null, "")
+  name: import_joi126.default.string().optional().allow(null, ""),
+  amount: import_joi126.default.number().optional().allow(null, ""),
+  referenceNumber: import_joi126.default.string().optional().allow(null, "")
 });
 var schemaBillingPayments = import_joi126.default.object({
   _id: import_joi126.default.string().hex().optional(),
@@ -64993,12 +65003,60 @@ var useRedDotPaymentRepo = () => {
   const redDotMerchantCollection = () => {
     return getDB2().collection("payment-gateways");
   };
+  async function createIndexes() {
+    try {
+      await paymentCollection().createIndexes([
+        // A referenceNumber-prefixed compound index serves both the lookup by
+        // reference alone and the { referenceNumber, status } lookups used by
+        // the pay single / pay multiple flows.
+        {
+          key: { referenceNumber: 1, status: 1 },
+          name: "referenceNumber_1_status_1"
+        }
+      ]);
+    } catch (error) {
+      import_node_server_utils224.logger.log({
+        level: "error",
+        message: error.message
+      });
+      throw new import_node_server_utils224.InternalServerError(
+        "Failed to create index on billing payments."
+      );
+    }
+  }
+  async function getPaymentByReference(referenceNumber, session) {
+    const reference = typeof referenceNumber === "string" ? referenceNumber.trim() : "";
+    if (!reference) {
+      throw new import_node_server_utils224.BadRequestError("Reference number is required.");
+    }
+    try {
+      const payment = await paymentCollection().findOne(
+        {
+          referenceNumber: reference
+        },
+        { session }
+      );
+      if (!payment) {
+        throw new import_node_server_utils224.NotFoundError("Payment not found.");
+      }
+      return payment;
+    } catch (error) {
+      if (error instanceof import_node_server_utils224.AppError) {
+        throw error;
+      }
+      import_node_server_utils224.logger.log({
+        level: "error",
+        message: error.message
+      });
+      throw new import_node_server_utils224.InternalServerError("Failed to get payment.");
+    }
+  }
   async function createPayment(type, payload, session) {
     if (type == "single") {
       try {
         payload = MBillingItems(payload);
-        const res = await paymentCollection().insertOne(payload, { session });
-        return res.insertedId;
+        await paymentCollection().insertOne(payload, { session });
+        return payload.referenceNumber;
       } catch (error) {
         import_node_server_utils224.logger.log({
           level: "error",
@@ -65027,7 +65085,7 @@ var useRedDotPaymentRepo = () => {
           { $set: { referenceNumber } },
           { session }
         );
-        return res.insertedId;
+        return referenceNumber;
       } catch (error) {
         import_node_server_utils224.logger.log({
           level: "error",
@@ -65045,6 +65103,76 @@ var useRedDotPaymentRepo = () => {
       }
     }
   }
+  async function getPaidBills({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    month,
+    year,
+    unitId
+  }, session) {
+    let _unitId;
+    try {
+      _unitId = new import_mongodb135.ObjectId(unitId);
+    } catch {
+      throw new import_node_server_utils224.BadRequestError("Invalid unit ID format.");
+    }
+    page = page > 0 ? page - 1 : 0;
+    let dateExpr = {};
+    const datePaidRange = buildDatePaidRange(month, year);
+    if (datePaidRange) {
+      dateExpr.datePaid = datePaidRange;
+    }
+    const query = {
+      unitId: _unitId,
+      status: "success",
+      ...search && {
+        $or: [
+          { referenceNumber: { $regex: search, $options: "i" } },
+          { unitOwner: { $regex: search, $options: "i" } },
+          { method: { $regex: search, $options: "i" } },
+          { transaction_id: { $regex: search, $options: "i" } },
+          { "unitBillingItems.name": { $regex: search, $options: "i" } },
+          {
+            $expr: {
+              $regexMatch: {
+                input: { $toString: "$totalAmount" },
+                regex: search,
+                options: "i"
+              }
+            }
+          }
+        ]
+      },
+      ...dateExpr
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    try {
+      const basePipeline = [
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ];
+      const [items, countResult] = await Promise.all([
+        paymentCollection().aggregate(basePipeline, { session }).toArray(),
+        paymentCollection().aggregate([{ $match: query }, { $count: "total" }], { session }).toArray()
+      ]);
+      const totalCount = countResult[0]?.total || 0;
+      const data = (0, import_node_server_utils224.paginate)(items, page, limit, totalCount);
+      return data;
+    } catch (error) {
+      if (error instanceof import_node_server_utils224.AppError) {
+        throw error;
+      }
+      import_node_server_utils224.logger.log({
+        level: "error",
+        message: error.message
+      });
+      throw new import_node_server_utils224.InternalServerError("Failed to retrieve paid bills.");
+    }
+  }
   async function paySingleUnitBill(refId, payload) {
     const session = import_node_server_utils224.useAtlas.getClient()?.startSession();
     try {
@@ -65207,6 +65335,52 @@ var useRedDotPaymentRepo = () => {
       session?.endSession();
     }
   }
+  function buildDatePaidRange(month, year) {
+    if (!year)
+      return null;
+    const yearNum = Number(year);
+    if (!Number.isInteger(yearNum) || yearNum < 1970 || yearNum > 9999) {
+      throw new import_node_server_utils224.BadRequestError("Invalid year filter.");
+    }
+    if (month) {
+      const monthNum = Number(month);
+      if (!Number.isInteger(monthNum) || monthNum < 1 || monthNum > 12) {
+        throw new import_node_server_utils224.BadRequestError("Invalid month filter.");
+      }
+      return {
+        $gte: new Date(yearNum, monthNum - 1, 1),
+        $lt: new Date(yearNum, monthNum, 1)
+      };
+    }
+    return {
+      $gte: new Date(yearNum, 0, 1),
+      $lt: new Date(yearNum + 1, 0, 1)
+    };
+  }
+  async function updateStatus(referenceNumber, status, session) {
+    const reference = typeof referenceNumber === "string" ? referenceNumber.trim() : "";
+    if (!reference) {
+      throw new import_node_server_utils224.BadRequestError("Reference number is required.");
+    }
+    try {
+      const res = await paymentCollection().updateOne(
+        { referenceNumber: reference, status: "pending" },
+        { $set: { status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      if (res.matchedCount === 0) {
+        throw new import_node_server_utils224.NotFoundError(
+          "Payment not found or is no longer pending."
+        );
+      }
+      return res;
+    } catch (error) {
+      if (error instanceof import_node_server_utils224.AppError) {
+        throw error;
+      }
+      throw new import_node_server_utils224.InternalServerError("Failed to update payment status.");
+    }
+  }
   function formatDateString(today) {
     today = typeof today === "string" ? new Date(today) : today;
     let month = today.getMonth() + 1;
@@ -65215,7 +65389,15 @@ var useRedDotPaymentRepo = () => {
     const formattedDate = `${month.toString().padStart(2, "0")}${day.toString().padStart(2, "0")}${year}`;
     return formattedDate;
   }
-  return { paySingleUnitBill, createPayment, payMultipleUnitBill };
+  return {
+    paySingleUnitBill,
+    createPayment,
+    payMultipleUnitBill,
+    getPaidBills,
+    createIndexes,
+    getPaymentByReference,
+    updateStatus
+  };
 };
 
 // src/services/reddot-payment.service.ts
@@ -65325,7 +65507,7 @@ var useRedDotPaymentSvc = () => {
         const success = {
           ...basePayload,
           paymentStatus: "paid" /* PAID */,
-          amountPaid: parseInt(amount)
+          amountPaid: Number(amount)
         };
         if (isBulk) {
           await payMultipleUnitBill(refId, success);
@@ -65359,7 +65541,12 @@ var useRedDotPaymentSvc = () => {
 var import_joi127 = __toESM(require("joi"));
 var import_node_server_utils226 = require("@7365admin1/node-server-utils");
 function useRedDotPaymentController() {
-  const { createPayment: _createPayment } = useRedDotPaymentRepo();
+  const {
+    createPayment: _createPayment,
+    updateStatus: _updateStatus,
+    getPaymentByReference: _getPaymentByReference,
+    getPaidBills: _getPaidBills
+  } = useRedDotPaymentRepo();
   const redirectPaymentTransaction = async (req, res) => {
     try {
       const data = req.body;
@@ -65423,17 +65610,86 @@ function useRedDotPaymentController() {
     try {
       const payment = await _createPayment(type, value);
       res.status(201).json({
-        message: "Payment created successfully.",
+        message: "success",
         data: payment
       });
     } catch (error) {
-      next(error);
+      const status = error?.statusCode ?? 500;
+      res.status(status).json({ message: "failed" });
+    }
+  }
+  async function updateStatus(req, res, next) {
+    const schema2 = import_joi127.default.object({
+      referenceNumber: import_joi127.default.string().required(),
+      status: import_joi127.default.string().valid(...Object.values(BillingPaymentStatus)).required()
+    });
+    const { error, value } = schema2.validate({
+      referenceNumber: req.params.id,
+      status: req.body.status
+    });
+    if (error) {
+      import_node_server_utils226.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils226.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _updateStatus(value.referenceNumber, value.status);
+      res.status(200).json({ message: "success", data });
+      return;
+    } catch (error2) {
+      import_node_server_utils226.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getPaymentByReference(req, res, next) {
+    const schema2 = import_joi127.default.object({
+      referenceNumber: import_joi127.default.string().required()
+    });
+    const { error, value } = schema2.validate(req.params);
+    if (error) {
+      next(new import_node_server_utils226.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const payment = await _getPaymentByReference(value.referenceNumber);
+      res.json({ data: payment });
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
+  async function getPaidBills(req, res, next) {
+    const schema2 = import_joi127.default.object({
+      unitId: import_joi127.default.string().hex().length(24).required(),
+      page: import_joi127.default.number().integer().min(1).default(1),
+      limit: import_joi127.default.number().integer().min(1).max(100).default(10),
+      search: import_joi127.default.string().trim().allow("").default(""),
+      month: import_joi127.default.string().pattern(/^(0?[1-9]|1[0-2])$/).allow("").optional(),
+      year: import_joi127.default.string().pattern(/^\d{4}$/).allow("").optional()
+    });
+    const { error, value } = schema2.validate({ ...req.params, ...req.query });
+    if (error) {
+      next(new import_node_server_utils226.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const bills = await _getPaidBills(value);
+      res.json({ data: bills });
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
     }
   }
   return {
     redirectPaymentTransaction,
     enquirePaymentTransaction,
-    createPayment
+    createPayment,
+    getPaymentByReference,
+    updateStatus,
+    getPaidBills
   };
 }