create-easy-stack 1.0.3

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

@@ -0,0 +1,71 @@
+"use strict";
+
+const OtpService = require("./otp.service");
+const TemplateService = require("./template.service");
+const transporter = require("../config/config.nodemailer");
+const { replacePlaceholder } = require("../utils/template.html");
+const { NotFoundError, BadRequestError } = require("../core/error.response");
+
+class EmailService {
+  static sendEmailUsingThirdParty({
+    toEmail = null,
+    html = null,
+    subject = "Xác thực tài khoản email của bạn",
+  }) {
+    try {
+      // send email using nodemailer
+      transporter.sendMail(
+        {
+          from: "ShopDEV <thuyphuocthinhtpt1@gmail.com>",
+          to: toEmail,
+          subject,
+          html,
+        },
+        (error, info) => {
+          if (error) {
+            throw new BadRequestError("Failed to send email");
+          }
+          console.log("Message sent: %s", info.messageId);
+        }
+      );
+    } catch (error) {
+      throw new BadRequestError("Failed to send email");
+    }
+  }
+
+  static async sendEmail({ email = null }) {
+    try {
+      // get token from otp
+      const otp = await OtpService.newOtp({ email });
+
+      // get template
+      const template = await TemplateService.getTemplate({
+        template_name: "HTML_EMAIL_TOKEN",
+      });
+
+      if (!template) {
+        throw new NotFoundError("Template not found");
+      }
+
+      // replace placeholder
+      const html = replacePlaceholder(template.template_html, {
+        verify_link: `http://localhost:3000/api/v1/user/verify-email?email=${email}&token=${otp.otp_token}`,
+      });
+
+      // send email
+      EmailService.sendEmailUsingThirdParty({
+        toEmail: email,
+        html: html,
+        subject: "Xác thực tài khoản email của bạn",
+      });
+
+      return {
+        message: "Email sent successfully, please check your email",
+      };
+    } catch (error) {
+      throw new BadRequestError("Failed to send email");
+    }
+  }
+}
+
+module.exports = EmailService;

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

@@ -0,0 +1,35 @@
+"use strict";
+
+const { NotFoundError } = require("../core/error.response");
+const inventoryModel = require("../models/inventory.model");
+const { getProductById } = require("../models/repository/product.repo");
+
+class InventoryService {
+  static async addStockToInventory({
+    stock,
+    productId,
+    shopId,
+    location = "14 Doan Uan, Danang city",
+  }) {
+    const product = await getProductById({ productId });
+    if (!product) {
+      throw new NotFoundError("Product does not exist");
+    }
+    const query = {
+      inventory_shop_id: shopId,
+      inventory_product_id: productId,
+    };
+    const updateSet = {
+      $inc: {
+        inventory_stock: +stock,
+      },
+      $set: {
+        inventory_location: location,
+      },
+    };
+    const options = { upsert: true, new: true };
+    return await inventoryModel.findOneAndUpdate(query, updateSet, options);
+  }
+}
+
+module.exports = InventoryService;

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

@@ -0,0 +1,77 @@
+"use strict";
+
+const { Types } = require("mongoose");
+const KeyTokenModel = require("../models/KeyToken.model");
+
+class KeyTokenService {
+  static createKeyToken = async ({
+    userId,
+    publicKey,
+    privateKey,
+    refreshToken,
+  }) => {
+    try {
+      // const tokens = await KeyTokenModel.create({
+      //   user: userId,
+      //   publicKey,
+      //   privateKey,
+      // });
+      // return tokens ? tokens : null;
+      const filter = { user: userId };
+      const update = {
+        publicKey,
+        privateKey,
+        refreshTokenUsed: [],
+        refreshToken,
+      };
+      const options = { upsert: true, new: true };
+      const tokens = await KeyTokenModel.findOneAndUpdate(
+        filter,
+        update,
+        options
+      );
+      return tokens ? tokens.publicKey : null;
+    } catch (error) {
+      return error;
+    }
+  };
+
+  static getKeyPair = async ({ userId }) => {
+    const keyPair = await KeyTokenModel.findOne({ user: userId });
+    return {
+      privateKey: keyPair.privateKey,
+      publicKey: keyPair.publicKey,
+    };
+  };
+
+  static findByUserId = async ({ userId }) => {
+    const found = await KeyTokenModel.findOne({
+      user: new Types.ObjectId(userId),
+    });
+    return found;
+  };
+
+  static removeKeyTokenById = async (id) => {
+    return await KeyTokenModel.deleteOne({ _id: id });
+  };
+
+  static findByRefreshTokenUsed = async (refreshToken) => {
+    return await KeyTokenModel.findOne({
+      refreshTokenUsed: refreshToken,
+    }).lean();
+  };
+
+  static findByRefreshToken = async (refreshToken) => {
+    return await KeyTokenModel.findOne({
+      refreshToken: refreshToken,
+    });
+  };
+
+  static deleteKeyByUserId = async (userId) => {
+    return await KeyTokenModel.findOneAndDelete({
+      user: new Types.ObjectId(userId),
+    });
+  };
+}
+
+module.exports = KeyTokenService;

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

@@ -0,0 +1,58 @@
+"use strict";
+
+const notificationModel = require("../models/notification.model");
+const { convertToObjectId } = require("../utils");
+
+const NOTI_TYPE_CONTENT = {
+  "SHOP-001": "Vừa mới thêm một sản phẩm",
+  "ORDER-001": "Đặt hàng thành công",
+  "ORDER-002": "Đặt hàng thất bại",
+  "ORDER-003": "Giao hàng thành công",
+  "PROMOTION-001": "Vừa mới thêm voucher mới",
+};
+
+class NotificationService {
+  static async pushNotiToSystem({
+    type = "SHOP-001",
+    receiverId,
+    senderId,
+    options = {},
+  }) {
+    let noti_content = NOTI_TYPE_CONTENT[type];
+    const newNoti = await notificationModel({
+      noti_content,
+      noti_type: type,
+      noti_receiverId: receiverId,
+      noti_senderId: convertToObjectId(senderId),
+      noti_options: options,
+    });
+    return newNoti;
+  }
+
+  static async listNotiByUser({ userId = 1, type = "ALL", isRead = 0 }) {
+    const match = {
+      noti_receiverId: userId,
+    };
+    if (type !== "ALL") {
+      match["noti_type"] = type;
+    }
+
+    return await notificationModel.aggregate([
+      {
+        $match: match,
+      },
+      {
+        $project: {
+          noti_type: 1,
+          noti_senderId: 1,
+          noti_receiverId: 1,
+          noti_content: 1,
+          createdAt: 1,
+          noti_options: 1,
+        },
+      },
+    ]);
+  }
+}
+
+module.exports = NotificationService;

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

@@ -0,0 +1,36 @@
+"use strict";
+
+const { Otp } = require("../models/otp.model");
+const { BadRequestError } = require("../core/error.response");
+const crypto = require("crypto");
+
+class OtpService {
+  static async generateToken() {
+    return crypto.randomInt(0, Math.pow(2, 32));
+  }
+
+  static async newOtp({ email = null }) {
+    // generate token
+    const token = await OtpService.generateToken();
+
+    // new otp
+    const newOtp = await Otp.create({
+      otp_email: email,
+      otp_token: token,
+    });
+
+    return newOtp;
+  }
+
+  static async checkOtp({ email = null, token = null }) {
+    const otp = await Otp.findOne({ email, otp_token: token }).lean().exec();
+    if (!otp) {
+      throw new BadRequestError("Invalid token");
+    }
+    // delete because we only use one time - and otp is valid
+    await Otp.deleteOne({ email, otp_token: token });
+    return otp;
+  }
+}
+
+module.exports = OtpService;

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

@@ -0,0 +1,228 @@
+"use strict";
+
+const { BadRequestError } = require("../core/error.response");
+const {
+  product,
+  clothing,
+  electronic,
+  furniture,
+} = require("../models/product.model");
+const { insertInventory } = require("../models/repository/inventory.repo");
+const {
+  findAllDraftProducts,
+  publishProductByShop,
+  findAllPublishedProducts,
+  unpublishProductByShop,
+  searchProductsByUser,
+  findAllProducts,
+  findDetailProduct,
+  updateProductById,
+} = require("../models/repository/product.repo");
+const { removeBadValue, updateNestedObjectParser } = require("../utils");
+const NotificationService = require("./notification.service");
+const TYPES = {
+  Electronics: "Electronics",
+  Clothing: "Clothing",
+  Furniture: "Furniture",
+};
+// Define Factory class to create product
+class ProductFactory {
+  static productRegistry = {}; // key : class
+
+  static registerProductType(type, classRef) {
+    ProductFactory.productRegistry[type] = classRef;
+  }
+
+  static async createProduct(type, payload) {
+    const productType = ProductFactory.productRegistry[type];
+    console.log(">>> productType:::", productType);
+    if (!productType)
+      throw new BadRequestError(`Invalid Product Type::${type}`);
+    return new productType(payload).createProduct();
+  }
+
+  static async findAllDraftProducts({ product_shop, limit = 50, skip = 0 }) {
+    const query = { product_shop, isDraft: true };
+    return await findAllDraftProducts({ query, limit, skip });
+  }
+
+  static async publishProductByShop({ product_shop, product_id }) {
+    return await publishProductByShop({ product_shop, product_id });
+  }
+
+  static async findAllPublishedProducts({
+    product_shop,
+    limit = 50,
+    skip = 0,
+  }) {
+    const query = { product_shop, isPublished: true };
+    return await findAllPublishedProducts({ query, limit, skip });
+  }
+
+  static async unpublishProductByShop({ product_shop, product_id }) {
+    return await unpublishProductByShop({ product_shop, product_id });
+  }
+
+  static async searchProducts({ keySearch }) {
+    return await searchProductsByUser({ keySearch });
+  }
+
+  static async findAllProducts({
+    limit = 50,
+    sort = "ctime",
+    page = 1,
+    filter = { isPublished: true },
+  }) {
+    return await findAllProducts({
+      limit,
+      sort,
+      page,
+      filter,
+      select: ["product_name", "product_thumb", "product_price"],
+    });
+  }
+
+  static async findDetailProduct({ product_id }) {
+    return await findDetailProduct({ product_id, unSelect: ["__v"] });
+  }
+
+  static async updateProduct({ product_type, product_id, bodyUpdate }) {
+    const productType = ProductFactory.productRegistry[product_type];
+    if (!productType) {
+      throw new BadRequestError(`Invalid Product Type::${productType}`);
+    }
+    console.log(">>> productType:::", productType);
+    return new productType(bodyUpdate).updateProduct({
+      product_id,
+      bodyUpdate,
+    });
+  }
+}
+
+// Define base Product class
+class Product {
+  constructor({
+    product_name,
+    product_thumb,
+    product_description,
+    product_price,
+    product_quantity,
+    product_type,
+    product_shop,
+    product_attributes,
+  }) {
+    this.product_name = product_name;
+    this.product_thumb = product_thumb;
+    this.product_description = product_description;
+    this.product_price = product_price;
+    this.product_quantity = product_quantity;
+    this.product_type = product_type;
+    this.product_shop = product_shop;
+    this.product_attributes = product_attributes;
+  }
+
+  async createProduct(product_id) {
+    const newProduct = await product.create({ ...this, _id: product_id });
+    if (newProduct) {
+      await insertInventory({
+        product_id: newProduct._id,
+        shop_id: newProduct.product_shop,
+        stock: newProduct.product_quantity,
+        location: "Danang, Vietnam",
+      });
+      // noti new product is created here
+      // push noti to noti system
+      NotificationService.pushNotiToSystem({
+        type: "SHOP-001",
+        senderId: this.product_attributes,
+        receiverId: 1,
+        options: {
+          product_name: this.product_name,
+          shop_name: this.product_shop,
+        },
+      })
+        .then((res) => console.log(res))
+        .catch((err) => console.log(err));
+      return newProduct;
+    }
+  }
+
+  async updateProduct({ product_id, bodyUpdate }) {
+    return await updateProductById({ product_id, bodyUpdate, model: product });
+  }
+}
+
+// Define Clothing
+class Clothing extends Product {
+  async createProduct() {
+    const newClothing = await clothing.create({
+      ...this.product_attributes,
+      product_shop: this.product_shop,
+    });
+    if (!newClothing) {
+      throw new BadRequestError("Create new Clothing error");
+    }
+    const newProduct = await super.createProduct(newClothing._id);
+    if (!newProduct) {
+      throw new BadRequestError("Create new Product error");
+    }
+    return newProduct;
+  }
+
+  async updateProduct({ product_id, bodyUpdate }) {
+    // 1. Remove undefined, null attributes
+    let payload = updateNestedObjectParser(bodyUpdate);
+    payload = removeBadValue(payload);
+    // 2. Check xem update o cho nao
+    if (bodyUpdate.product_attributes) {
+      // update child
+      await updateProductById({ product_id, payload, model: clothing });
+    }
+    // update parent
+    const updateProduct = await super.updateProduct({ product_id, payload });
+    return updateProduct;
+  }
+}
+
+// Define Electronic
+class Electronics extends Product {
+  async createProduct() {
+    const newElectronics = await electronic.create({
+      ...this.product_attributes,
+      product_shop: this.product_shop,
+    });
+    if (!newElectronics) {
+      throw new BadRequestError("Create new Electronics error");
+    }
+    const newProduct = await super.createProduct(newElectronics._id);
+    if (!newProduct) {
+      throw new BadRequestError("Create new Product error");
+    }
+    return newProduct;
+  }
+}
+
+// Define Furniture
+class Furniture extends Product {
+  async createProduct() {
+    const newFurniture = await furniture.create({
+      ...this.product_attributes,
+      product_shop: this.product_shop,
+    });
+    if (!newFurniture) {
+      throw new BadRequestError("Create new Furniture error");
+    }
+    const newProduct = await super.createProduct(newFurniture._id);
+    if (!newProduct) {
+      throw new BadRequestError("Create new Product error");
+    }
+    return newProduct;
+  }
+}
+
+// Regiter productType
+ProductFactory.registerProductType(TYPES.Clothing, Clothing);
+ProductFactory.registerProductType(TYPES.Electronics, Electronics);
+ProductFactory.registerProductType(TYPES.Furniture, Furniture);
+
+module.exports = ProductFactory;

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

@@ -0,0 +1,143 @@
+"use strict";
+
+const { BadRequestError } = require("../core/error.response");
+const Resource = require("../models/resource.model");
+const Role = require("../models/role.model");
+
+/**
+ *
+ * @param {string} resource_name
+ * @param {string} resource_slug
+ * @param {string} resource_description
+ * @returns
+ */
+
+const createResource = async ({
+  resource_name = "profile",
+  resource_slug = "p000001",
+  resource_description = "profile description",
+}) => {
+  try {
+    // 1. Check if resource already exists
+    const foundResource = await Resource.findOne({ resource_slug });
+    if (foundResource) {
+      throw new BadRequestError("Resource already exists");
+    }
+    // 2. If not, create new resource
+    const newResource = await Resource.create({
+      resource_name,
+      resource_slug,
+      resource_description,
+    });
+    // 3. Return new resource
+    return newResource;
+  } catch (error) {
+    throw new BadRequestError(error.message);
+  }
+};
+
+const resourceList = async ({
+  userId = 0,
+  limit = 30,
+  offset = 0,
+  search = "",
+}) => {
+  try {
+    // 1. get list resource
+    const resources = await Resource.aggregate([
+      {
+        $project: {
+          _id: 0,
+          resource_name: "$resource_name",
+          resource_slug: "$resource_slug",
+          resource_description: "$resource_description",
+          resourceId: "$_id",
+          createdAt: 1,
+        },
+      },
+    ]);
+    // 3. Return list resource
+    return resources;
+  } catch (error) {
+    throw new BadRequestError(error.message);
+  }
+};
+
+const createRole = async ({
+  role_name = "admin",
+  role_slug = "r000001",
+  role_description = "admin description",
+  role_grants = [],
+}) => {
+  try {
+    // 1. Check if role already exists
+    const foundRole = await Role.findOne({ role_slug });
+    if (foundRole) {
+      throw new BadRequestError("Role already exists");
+    }
+    // 2. If not, create new role
+    const newRole = await Role.create({
+      role_name,
+      role_slug,
+      role_description,
+      role_grants,
+    });
+    // 3. Return new role
+    return newRole;
+  } catch (error) {
+    throw new BadRequestError(error.message);
+  }
+};
+
+const roleList = async ({
+  userId = 0,
+  limit = 30,
+  offset = 0,
+  search = "",
+}) => {
+  try {
+    // list roles
+    const roles = await Role.aggregate(
+      {
+        $unwind: "$role_grants",
+      },
+      {
+        $lookup: {
+          from: "resources",
+          localField: "role_grants.resource_id",
+          foreignField: "_id",
+          as: "resource",
+        },
+      },
+      {
+        $unwind: "$resource",
+      },
+      {
+        $project: {
+          role: "$role_name",
+          resource: "$resource.resource_name",
+          actions: "$role_grants.actions",
+          attributes: "$role_grants.attributes",
+        },
+      },
+      {
+        $unwind: "$actions",
+      },
+      {
+        $project: {
+          _id: 0,
+          role: 1,
+          resource: 1,
+          actions: "$actions",
+          attributes: 1,
+        },
+      }
+    );
+
+    return roles;
+  } catch (error) {
+    throw new BadRequestError(error.message);
+  }
+};
+
+module.exports = { createResource, resourceList, createRole, roleList };

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

@@ -0,0 +1,57 @@
+"use strict";
+
+const redis = require("redis");
+const { promisify } = require("util");
+const { reservationInventory } = require("../models/repository/inventory.repo");
+const redisClient = redis.createClient();
+
+redisClient.ping((err, res) => {
+  if (err) {
+    console.log("err:::error connecting to redis", err);
+  } else {
+    console.log("res:::connected to redis", res);
+  }
+});
+
+const pexpire = promisify(redisClient.pExpire).bind(redisClient);
+const setnxAsync = promisify(redisClient.setNX).bind(redisClient);
+
+const acquireLock = async (productId, quantity, cartId) => {
+  const key = `lock_v2024_${productId}`;
+  const retryTimes = 10;
+  const expireTime = 3000; // 3 seconds thoi gian tam lock
+  for (let index = 0; index < retryTimes.length; index++) {
+    // tao mot key, thang nao giu key nay duoc vao thanh toan
+    const result = await setnxAsync(key, expireTime);
+    console.log("result:::", result);
+    if (result === 1) {
+      // dang co nguoi nam giu key
+      // thao tac voi inventory
+      const isReserved = await reservationInventory({
+        productId,
+        cartId,
+        quantity,
+      });
+      // neu reserve trong kho hang thanh cong => giai phong key de nguoi khac co the su dung
+      if (isReserved.modifiedCount > 0) {
+        await pexpire(key, expireTime);
+        return key;
+      }
+      return null;
+    } else {
+      // chua co ai co key
+      // thu ket noi lay key 10 lan
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+  }
+};
+
+const releaseLock = async (keyLock) => {
+  const delAsyncKey = promisify(redisClient.del).bind(redisClient);
+  return await delAsyncKey(keyLock);
+};
+
+module.exports = {
+  acquireLock,
+  releaseLock,
+};