create-easy-stack 1.0.3

package/templates/node-express/files/src/services/checkout.service.js

@@ -0,0 +1,218 @@
+"use strict";
+
+const { NotFoundError, BadRequestError } = require("../core/error.response");
+const orderModel = require("../models/order.model");
+const { findCartById } = require("../models/repository/cart.repo");
+const { checkProductServer } = require("../models/repository/product.repo");
+const { removeAllProductsFromCart } = require("./cart.service");
+const { getDiscountAmount } = require("./discount.service");
+const { acquireLock, releaseLock } = require("./redis.service");
+
+class CheckoutService {
+  /*
+    {
+        cartId,
+        userId,
+        shop_order_ids: [
+            {
+                shopId,
+                shop_discount: [],
+                item_products: [
+                    {
+                        price,
+                        quantity,
+                        productId
+                    }
+                ]
+            },
+            {
+                shopId,
+                shop_discount: [
+                    {
+                        shopId,
+                        discountId,
+                        discountCode
+                    }
+                ],
+                item_products: [
+                    {
+                        price,
+                        quantity,
+                        productId
+                    }
+                ]
+            }
+        ]
+    }
+  */
+  static async checkoutReview({ cartId, userId, shop_order_ids }) {
+    // Check cartId ton tai hay khong
+    const foundCart = await findCartById(cartId);
+    if (!foundCart) {
+      throw new NotFoundError("Cart does not exist");
+    }
+
+    // tinh toan checkout_order
+    const checkout_order = {
+      total_price: 0,
+      total_discount: 0,
+      fee_ship: 0,
+      total_paid: 0,
+    };
+
+    const shop_order_ids_new = [];
+
+    // Tinh tong tien total_price
+    // Moi item trong shop_order_ids chua cac san pham cua cung 1 shop
+    for (let i = 0; i < shop_order_ids.length; i++) {
+      const {
+        shopId,
+        shop_discounts = [],
+        item_products = [],
+      } = shop_order_ids[i];
+      // check tung san pham trong order cua tung shop co ton tai hay khong
+      const checkProduct = await checkProductServer(item_products);
+      checkProduct.forEach((product) => {
+        if (!product) throw new BadRequestError("Order Wrong");
+      });
+      // tinh tong tien don hang ban dau cua tung shop
+      const checkoutPrice = checkProduct.reduce((total, product) => {
+        return total + product.quantity * product.price;
+      }, 0);
+      checkout_order.total_price += checkoutPrice;
+      const itemCheckout = {
+        shopId,
+        shop_discounts,
+        priceBeforeDiscount: checkoutPrice,
+        priceApplyDiscount: checkoutPrice,
+        item_products: checkProduct,
+      };
+      // check su hop le cua shop_discounts
+      if (shop_discounts.length > 0) {
+        for (const discount of shop_discounts) {
+          const { discount_amount } = await getDiscountAmount({
+            code: discount.code,
+            userId,
+            shopId,
+            products: checkProduct,
+          });
+          if (discount_amount > 0) {
+            checkout_order.total_discount += discount_amount;
+            itemCheckout.priceApplyDiscount = checkoutPrice - discount_amount;
+          }
+        }
+      }
+
+      // tong thanh toan cuoi cung cua tung shop
+      checkout_order.total_paid += itemCheckout.priceApplyDiscount;
+      shop_order_ids_new.push(itemCheckout);
+    }
+
+    // tong thanh toan cuoi cung (tong tien - tong discount + tong fee ship)
+    checkout_order.total_paid += checkout_order.fee_ship;
+    return {
+      shop_order_ids,
+      shop_order_ids_new,
+      checkout_order,
+    };
+  }
+
+  // ~ place_order
+  static async placeOrderByUser({
+    shop_order_ids,
+    cartId,
+    userId,
+    user_address = {},
+    user_payment = {},
+  }) {
+    // review again
+    const { shop_order_ids_new, checkout_order } = await this.checkoutReview({
+      cartId,
+      userId,
+      shop_order_ids,
+    });
+    // check lai mot lan nua xem san pham co vuot ton kho hay khong
+    // get new array products (dung flatMap)
+    const products = shop_order_ids_new.flatMap((order) => order.item_products);
+    const acquireProducts = [];
+    for (const product of products) {
+      const { productId, quantity } = product;
+      // su dung optimistic, pessimitic => kiem tra ton kho qua ban
+      const keyLock = await acquireLock(productId, quantity, cartId);
+      acquireProducts.push(keyLock ? true : false);
+      if (keyLock) {
+        await releaseLock(keyLock);
+      }
+    }
+
+    // check if co mot san pham het hang trong kho
+    if (acquireProducts.includes(false)) {
+      throw new BadRequestError(
+        "Mot so san pham da duoc cap nhat, vui long quay lai gio hang"
+      );
+    }
+
+    // Neu thanh cong het => tao mot new order
+    const newOrder = new orderModel({
+      order_user_id: userId,
+      order_checkout: checkout_order,
+      order_products: shop_order_ids_new,
+      order_payment: {},
+      order_shipping: {
+        city: "Danang",
+        country: "Vietnam",
+        state: "Danang",
+        street: "14 Doan Uan",
+      },
+    });
+    await newOrder.save();
+
+    // Neu tao order thanh cong => remove product trong cart
+    await removeAllProductsFromCart({ cartId, userId });
+
+    return newOrder;
+  }
+
+  // User lay many order da dat
+  static async getOrdersByUser({}) {}
+
+  // User lay one order da dat
+  static async getOrderByUser({}) {}
+
+  // User cancel order
+  static async cancelOrderByUser({}) {}
+
+  // Cap nhat order
+  // Luu y: Cap nhat status van chuyen la do he thong + 3rd-party chu khong phai do shop
+  static async updateOrderByShop({}) {}
+}
+
+module.exports = CheckoutService;
+
+
+/*
+  Luồng đi từ lúc user click vào xem chi tiết giỏ hàng
+  1. Xem chi tiết giỏ hàng => lúc này user có thể update quantity, xóa product...
+  2. Chuyển qua trang checkout
+  - Khi user chuyển qua trang checkout, FE + BE không cho phép cập nhật danh sách sản phẩm nữa
+  - User có quyền điền thông tin vận chuyển, chọn hình thức thanh toán, chọn các voucher discount nếu có
+  - BE sẽ kiểm tra thông tin giỏ hàng lại một lần nữa
+  + BE kiểm tra sản phẩm có thật sự tồn tại không, giá đúng không, số lượng còn không
+  + BE tính toán trả ra giá trị đơn hàng, giá trị chưa và đã có discount, tổng discount, phí ship
+  3. Tiến hành đặt hàng
+  - BE sẽ check lại thông tin sản phẩm đơn hàng một lần nữa
+  + Sử dụng khóa lạc quan để chặn không cho user khác đặt khi user này đang đặt hàng
+  + Sử dụng khóa lạc quan kiểm tra xem sản phẩm thật sự còn hàng trong kho không, chỉ cho phép đặt hàng nếu tất cả sản phẩm còn hàng, nếu một trong
+  các sản phẩm hết hàng => yêu cầu user quay lại trang giỏ hàng để cập nhật
+  + Sử dụng khóa lạc quan => kiểm tra cập nhật tức thời của sản phẩm
+  - BE thêm reserve sản phẩm trong kho hàng
+  - BE tính toán lại giá cả lần nữa
+  => Nếu tất cả thành công
+  - BE tạo order
+  - BE xóa sản phẩm trong giỏ hàng
+  4. Order còn có các chức năng
+  - Cập nhật status (do hệ thống cập nhật trạng thái vận chuyển, còn trạng thái đang xử lí ... có thể do shop tự làm hoặc tự động do hệ thống)
+  - Hủy đơn hàng
+  - User có thể xem thông tin chi tiết đơn hàng
+  ....
+*/

package/templates/node-express/files/src/services/comment.service.js

@@ -0,0 +1,185 @@
+"use strict";
+
+const { NotFoundError } = require("../core/error.response");
+const commentModel = require("../models/comment.model");
+const { getProductById } = require("../models/repository/product.repo");
+const { convertToObjectId } = require("../utils");
+
+/*
+    + add comment [User, Shop]
+    + get a list of comments [User, Shop]
+    + delete a comment [User, Shop, Admin]
+*/
+class CommentService {
+  static async createComment({
+    productId,
+    userId,
+    content,
+    parentCommentId = null,
+  }) {
+    const comment = new commentModel({
+      comment_productId: productId,
+      comment_userId: userId,
+      comment_content: content,
+      comment_parentId: parentCommentId,
+    });
+
+    let rightValue;
+    if (parentCommentId) {
+      // reply comment
+      const parentComment = await commentModel.findById(parentCommentId);
+      if (!parentComment) {
+        throw new NotFoundError("Parent comment not found");
+      }
+      rightValue = parentComment.comment_right;
+
+      // updateMany comments
+      await Promise.all([
+        commentModel.updateMany(
+          {
+            comment_productId: convertToObjectId(productId),
+            comment_right: { $gte: rightValue },
+          },
+          {
+            $inc: {
+              comment_right: 2,
+            },
+          }
+        ),
+        commentModel.updateMany(
+          {
+            comment_productId: convertToObjectId(productId),
+            comment_left: { $gt: rightValue },
+          },
+          {
+            $inc: {
+              comment_left: 2,
+            },
+          }
+        ),
+      ]);
+    } else {
+      // insert a new comment
+      const maxRightValue = await commentModel.findOne(
+        {
+          comment_productId: convertToObjectId(productId),
+        },
+        "comment_right",
+        { sort: { comment_right: -1 } }
+      );
+      if (maxRightValue) {
+        rightValue = maxRightValue.comment_right + 1;
+      } else {
+        rightValue = 1;
+      }
+    }
+
+    // insert comment
+    comment.comment_left = rightValue;
+    comment.comment_right = rightValue + 1;
+
+    await comment.save();
+    return comment;
+  }
+
+  static async getCommentsByParentId({
+    productId,
+    parentCommentId = null,
+    limit = 50,
+    offset = 0,
+  }) {
+    let comments;
+    if (parentCommentId) {
+      const parent = await commentModel.findById(parentCommentId);
+      if (!parent) {
+        throw new NotFoundError("Not found comment for product");
+      }
+      comments = await commentModel
+        .find({
+          comment_parentId: convertToObjectId(parentCommentId),
+          comment_productId: convertToObjectId(productId),
+          comment_left: { $gt: parent.comment_left },
+          comment_right: { $lt: parent.comment_right },
+        })
+        .select({
+          comment_left: 1,
+          comment_right: 1,
+          comment_content: 1,
+          comment_userId: 1,
+          comment_parentId: 1,
+        })
+        .skip(offset)
+        .limit(limit)
+        .sort({ createdAt: 1 });
+    } else {
+      comments = await commentModel
+        .find({
+          comment_parentId: parentCommentId,
+          comment_productId: convertToObjectId(productId),
+        })
+        .select({
+          comment_left: 1,
+          comment_right: 1,
+          comment_content: 1,
+          comment_userId: 1,
+          comment_parentId: 1,
+        })
+        .skip(offset)
+        .limit(limit)
+        .sort({ createdAt: 1 });
+    }
+    return comments;
+  }
+
+  static async deleteComment({ commentId, productId }) {
+    // check product exists in the db
+    const foundProduct = await getProductById({ productId });
+    if (!foundProduct) {
+      throw new NotFoundError("Product not found");
+    }
+    // 1. Xac dinh left va right cua commentId
+    const comment = await commentModel.findById(commentId);
+    if (!comment) {
+      throw new NotFoundError("Comment not found");
+    }
+    const left = comment.comment_left;
+    const right = comment.comment_right;
+    // 2. Tinh width = right most - left most + 1
+    const width = right - left + 1;
+    // 3. Xoa tat cac commentId con (bao gom ca chinh no)
+    await commentModel.deleteMany({
+      comment_productId: convertToObjectId(productId),
+      comment_left: { $gte: left, $lte: right },
+    });
+    // 4. Cap nhat left, right cho cac node con lai trong cay
+    // Cap nhat right_value cua cac node to tien cua node bi xoa
+    // Cap nhat right, left cuar cac node nam ben phai cua cay node bi xoa
+    await Promise.all([
+      commentModel.updateMany(
+        {
+          comment_productId: convertToObjectId(productId),
+          comment_right: { $gt: right },
+        },
+        {
+          $inc: {
+            comment_right: -width,
+          },
+        }
+      ),
+      commentModel.updateMany(
+        {
+          comment_productId: convertToObjectId(productId),
+          comment_left: { $gt: right },
+        },
+        {
+          $inc: {
+            comment_left: -width,
+          },
+        }
+      ),
+    ]);
+    return true;
+  }
+}
+
+module.exports = CommentService;

package/templates/node-express/files/src/services/discount.service.js

@@ -0,0 +1,282 @@
+/**
+ * 1. Generate discount code [Admin | Shop]
+ * 2. Get all discount codes [User | Shop]
+ * 3. Get all products by discount code [User]
+ * 4. Get discount amount [User]
+ * 5. Delete discount code [Admin | Shop]
+ * 6. Cancel discount code [User]
+ */
+
+"use strict";
+
+const { Types } = require("mongoose");
+const { BadRequestError, NotFoundError } = require("../core/error.response");
+const discountModel = require("../models/discount.model");
+const {
+  convertToObjectId,
+  updateNestedObjectParser,
+  removeBadValue,
+} = require("../utils");
+const { findAllProducts } = require("../models/repository/product.repo");
+const {
+  findAllDiscountCodeUnselect,
+  updateDiscountByCode,
+  checkDiscountExists,
+} = require("../models/repository/discount.repo");
+
+class DiscountService {
+  static async createDiscountCode(payload) {
+    const {
+      code,
+      start_date,
+      end_date,
+      is_active,
+      shop_id,
+      applied_for,
+      min_order_value,
+      product_ids = [],
+      name,
+      description,
+      type,
+      value,
+      max_uses,
+      used_count,
+      max_uses_per_user,
+    } = payload;
+    // Kiem tra
+    console.log(">>> payload: ", payload);
+
+    if (new Date() < new Date(start_date) || new Date() > new Date(end_date)) {
+      throw new BadRequestError("Discount code has expired");
+    }
+    if (new Date(start_date) >= new Date(end_date)) {
+      throw new BadRequestError("Start_date must be before end_date");
+    }
+    // Tao discount
+    const foundDiscount = await discountModel
+      .findOne({
+        discount_code: code,
+        discount_shop_id: convertToObjectId(shop_id),
+      })
+      .lean();
+    if (foundDiscount && foundDiscount.discount_is_active) {
+      throw new BadRequestError("Discount code already exists");
+    }
+    const newDiscount = await discountModel.create({
+      discount_name: name,
+      discount_code: code,
+      discount_description: description,
+      discount_type: type,
+      discount_value: value,
+      discount_min_order_value: min_order_value,
+      discount_start_date: new Date(start_date),
+      discount_end_date: new Date(end_date),
+      discount_is_active: is_active,
+      discount_applied_for: applied_for,
+      discount_max_uses_per_user: max_uses_per_user,
+      discount_max_uses: max_uses,
+      discount_used_count: used_count,
+      discount_product_ids: applied_for === "ALL" ? [] : product_ids,
+      discount_shop_id: shop_id,
+    });
+    return newDiscount;
+  }
+
+  static async updateDiscountCode({ code, bodyUpdate }) {
+    let body = updateNestedObjectParser(bodyUpdate);
+    body = removeBadValue(body);
+    return await updateDiscountByCode({
+      code,
+      body,
+    });
+  }
+
+  static async getAllDiscountCodeByShop({ limit, page, shop_id }) {
+    return findAllDiscountCodeUnselect({
+      filter: {
+        discount_shop_id: convertToObjectId(shop_id),
+        discount_is_active: true,
+      },
+      limit: limit,
+      page: +page,
+      model: discountModel,
+      unSelect: ["__v"],
+    });
+  }
+
+  static async getProductsByDiscount({ code, shop_id, user_id, limit, page }) {
+    const foundDiscount = await discountModel
+      .findOne({
+        discount_code: code,
+        discount_shop_id: convertToObjectId(shop_id),
+      })
+      .lean();
+
+    if (!foundDiscount || !foundDiscount.discount_is_active) {
+      throw new NotFoundError("Discount does not exist or has expired");
+    }
+    // applied_for === "ALL" or "SPECIFIC"
+    const { discount_applied_for, discount_product_ids } = foundDiscount;
+    let products;
+    if (discount_applied_for === "ALL") {
+      // get all products
+      products = await findAllProducts({
+        filter: {
+          product_shop: convertToObjectId(shop_id),
+          isPublished: true,
+        },
+        limit,
+        sort: "ctime",
+        page,
+        select: ["product_name", "product_price", "product_thumb"],
+      });
+    } else if (discount_applied_for === "SPECIFIC") {
+      products = await findAllProducts({
+        filter: {
+          _id: { $in: discount_product_ids },
+          product_shop: convertToObjectId(shop_id),
+          isPublished: true,
+        },
+        limit,
+        sort: "ctime",
+        page,
+        select: ["product_name", "product_price", "product_thumb"],
+      });
+    }
+    return products;
+  }
+
+  /*
+    products = [
+      {
+        productId,
+        shopId,
+        quantity,
+        name,
+        price
+      }
+    ]
+  */
+  static async getDiscountAmount({ code, userId, shopId, products }) {
+    // ham nay dung de tinh so tien giam sau khi ap dung discount cho danh sach san pham
+    const foundDisount = await checkDiscountExists({
+      model: discountModel,
+      filter: {
+        discount_code: code,
+        discount_shop_id: convertToObjectId(shopId),
+      },
+    });
+    if (!foundDisount) {
+      throw new NotFoundError("Discount does not exist");
+    }
+
+    const {
+      discount_is_active,
+      discount_max_uses,
+      discount_used_count,
+      discount_end_date,
+      discount_start_date,
+      discount_min_order_value,
+      discount_max_uses_per_user,
+      discount_users_used,
+      discount_type,
+      discount_value,
+    } = foundDisount;
+    if (!discount_is_active) {
+      throw new NotFoundError("Discount expired");
+    }
+    if (!discount_max_uses) {
+      throw new NotFoundError("Discount is out");
+    }
+    if (discount_used_count > discount_max_uses) {
+      throw new NotFoundError("Discount is out");
+    }
+    if (
+      new Date() < new Date(discount_start_date) ||
+      new Date() > new Date(discount_end_date)
+    ) {
+      throw new NotFoundError("Discount expired");
+    }
+
+    // Neu tong gia tri that don hang < tong don hang toi thieu
+    let total_oder = 0;
+    if (discount_min_order_value > 0) {
+      total_oder = products.reduce((total, product) => {
+        return total + product.quantity * product.price;
+      }, 0);
+      if (total_oder < discount_min_order_value) {
+        throw new NotFoundError(
+          `Discount requires a min order value of ${discount_min_order_value}`
+        );
+      }
+    }
+
+    // neu user da su dung ma discount, kiem tra so lan da su dung
+    if (discount_max_uses_per_user > 0) {
+      const userUsed = discount_users_used.find((id) => id === userId);
+      if (userUsed) {
+        const userUsedCount = discount_users_used.reduce((total, item) => {
+          return item === userId ? total + 1 : total;
+        }, 0);
+        if (userUsedCount >= discount_max_uses_per_user) {
+          throw new BadRequestError("User overused discount");
+        }
+      }
+    }
+
+    // kiem tra type cua discount de tinh so tien giam
+    const discount_amount =
+      discount_type === "FIXED_AMOUNT"
+        ? discount_value
+        : total_oder * (discount_value / 100);
+
+    return {
+      total_oder,
+      discount_amount,
+      total_price: total_oder - discount_amount,
+    };
+  }
+
+  static async deleteDiscount({ code, shopId }) {
+    // xóa discount => thực tế phải kiểm tra xem discount này có đơn hàng nào đang sử dụng không
+    // phải đảm bảo không còn đơn hàng nào sử dụng thì mới xóa
+    // xóa => đưa vào một database mới thay vì thêm trường isDeleted (tốn index)
+    const deleted = await discountModel.findOneAndDelete({
+      discount_code: code,
+      discount_shop_id: convertToObjectId(shopId),
+    });
+    return deleted;
+  }
+
+  static async cancelDiscount({ code, shopId, userId }) {
+    const foundDiscount = await checkDiscountExists({
+      model: discountModel,
+      filter: {
+        discount_code: code,
+        discount_shop_id: convertToObjectId(shopId),
+      },
+    });
+
+    if (!foundDiscount) {
+      throw new NotFoundError("Discount does not exist");
+    }
+
+    const { discount_is_active } = foundDiscount;
+    if (!discount_is_active) {
+      throw new BadRequestError("Discount expired");
+    }
+
+    const result = await discountModel.findByIdAndUpdate(foundDiscount._id, {
+      $pull: {
+        discount_users_used: userId,
+      },
+      $inc: {
+        discount_used_count: -1,
+      },
+    });
+
+    return result;
+  }
+}
+
+module.exports = DiscountService;