create-easy-stack 1.0.3

package/templates/node-express/files/src/controllers/discount.controller.js

@@ -0,0 +1,68 @@
+const { SuccessResponse } = require("../core/success.response");
+const DiscountService = require("../services/discount.service");
+
+class DiscountController {
+  createDiscount = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await DiscountService.createDiscountCode({
+        ...req.body,
+        shop_id: req.user.userId,
+      }),
+    }).send(res);
+  };
+
+  updateDiscount = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await DiscountService.updateDiscountCode(req.body),
+    }).send(res);
+  };
+
+  getAllDiscountCodeByShop = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await DiscountService.getAllDiscountCodeByShop({
+        limit: req.query.limit || 50,
+        page: req.query.page || 1,
+        shop_id: req.user.userId,
+      }),
+    }).send(res);
+  };
+
+  getProductsByDiscount = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await DiscountService.getProductsByDiscount({
+        limit: req.query.limit,
+        page: req.query.page,
+        shop_id: req.params.shopId,
+        code: req.params.code,
+        user_id: "",
+      }),
+    }).send(res);
+  };
+
+  getDiscountAmount = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await DiscountService.getDiscountAmount(req.body),
+    }).send(res);
+  };
+
+  deleteDiscount = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await DiscountService.deleteDiscount(req.body),
+    }).send(res);
+  };
+
+  cancelDiscount = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await DiscountService.cancelDiscount(req.body),
+    });
+  };
+}
+
+module.exports = new DiscountController();

package/templates/node-express/files/src/controllers/email.controller.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const EmailService = require("../services/email.service");
+const { SuccessResponse } = require("../core/success.response");
+
+class EmailController {
+  static async sendEmail(req, res, next) {
+    const { email } = req.body;
+    new SuccessResponse({
+      message: "Email sent successfully",
+      metadata: await EmailService.sendEmail({ email }),
+    }).send(res);
+  }
+}
+
+module.exports = EmailController;

package/templates/node-express/files/src/controllers/inventory.controller.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const { SuccessResponse } = require("../core/success.response");
+const InventoryService = require("../services/inventory.service");
+
+class InventoryController {
+  async addStockToInventory(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await InventoryService.addStockToInventory(req.body),
+    }).send(res);
+  }
+}
+
+module.exports = new InventoryController();

package/templates/node-express/files/src/controllers/notification.controller.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const { SuccessResponse } = require("../core/success.response");
+const NotificationService = require("../services/notification.service");
+
+class NotificationController {
+  async getListNotiByUser(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await NotificationService.listNotiByUser(req.body),
+    }).send(res);
+  }
+}
+
+module.exports = new NotificationController();

package/templates/node-express/files/src/controllers/product.controller.js

@@ -0,0 +1,175 @@
+"use strict";
+
+const { SuccessResponse } = require("../core/success.response");
+const ProductService = require("../services/product.service.js");
+const SPUService = require("../services/spu.service");
+const SKUService = require("../services/sku.service");
+const { BadRequestError } = require("../core/error.response");
+class ProductController {
+  /** SPU, SKU */
+  /*
+    {
+      spu_name: "string",
+      spu_description: "string",
+      spu_images: ["string"],
+      spu_category: "string",
+      spu_price: 1000,
+      spu_shop: "string",
+      spu_category: [number],
+      spu_attributes: [
+        {
+          "attribute_id": "string",
+          "attribute_values": ["string"]
+        }
+      ],
+      spu_variations: [
+        {
+          "images": ["string"],
+          "name": "string",
+          "options": ["string"]
+        },
+        {
+          "images": ["string"],
+          "name": "string",
+          "options": ["string"]
+        }
+      ],
+      sku_list: [
+        {
+          "sku_id": "string",
+          "sku_name": "string",
+          "sku_price": 1000,
+          "sku_tier_index": [number, number],
+          "sku_shop": "string",
+        }
+      ]
+    }
+  */
+  createNewSpu = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Created a new spu successfully",
+      metadata: await SPUService.createNewSpu(req.body),
+    }).send(res);
+  };
+
+  getDetailSpu = async (req, res, next) => {
+    const { spu_id } = req.query;
+    if (!spu_id) {
+      throw BadRequestError("Missing query params");
+    }
+    new SuccessResponse({
+      message: "Get detail spu successfully",
+      metadata: await SPUService.getDetailSpu({ spu_id }),
+    }).send(res);
+  };
+
+  getListSkuBySpuId = async (req, res, next) => {
+    const { spu_id } = req.query;
+    if (!spu_id) {
+      throw BadRequestError("Missing query params");
+    }
+    new SuccessResponse({
+      message: "Get list sku by spu id successfully",
+      metadata: await SKUService.getListSkuBySpuId({ spu_id }),
+    }).send(res);
+  };
+
+  getDetailSku = async (req, res, next) => {
+    const { sku_id, spu_id } = req.query;
+    if (!sku_id || !spu_id) {
+      throw BadRequestError("Missing query params");
+    }
+    new SuccessResponse({
+      message: "Get detail sku successfully",
+      metadata: await SKUService.getDetailSku({ sku_id, spu_id }),
+    }).send(res);
+  };
+
+  /** END SPU, SKU */
+
+  createNewProduct = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Created a new product successfully",
+      metadata: await ProductService.createProduct(req.body.product_type, {
+        ...req.body,
+        product_shop: req.user.userId,
+      }),
+    }).send(res);
+  };
+
+  getAllDraftProducts = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await ProductService.findAllDraftProducts({
+        product_shop: req.user.userId,
+      }),
+    }).send(res);
+  };
+
+  getAllPulishedProducts = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await ProductService.findAllPublishedProducts({
+        product_shop: req.user.userId,
+      }),
+    }).send(res);
+  };
+
+  publishProduct = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await ProductService.publishProductByShop({
+        product_shop: req.user.userId,
+        product_id: req.params.id,
+      }),
+    }).send(res);
+  };
+
+  unpublishProduct = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await ProductService.unpublishProductByShop({
+        product_shop: req.user.userId,
+        product_id: req.params.id,
+      }),
+    }).send(res);
+  };
+
+  searchProductsByUser = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await ProductService.searchProducts({
+        keySearch: req.params.keySearch,
+      }),
+    }).send(res);
+  };
+
+  findAllProducts = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await ProductService.findAllProducts(req.query),
+    }).send(res);
+  };
+
+  findDetailProduct = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await ProductService.findDetailProduct({
+        product_id: req.params.id,
+      }),
+    }).send(res);
+  };
+
+  updateProductById = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await ProductService.updateProduct({
+        product_type: req.body.product_type,
+        product_id: req.params.id,
+        bodyUpdate: req.body.bodyUpdate,
+      }),
+    }).send(res);
+  };
+}
+
+module.exports = new ProductController();

package/templates/node-express/files/src/controllers/profile.controller.js

@@ -0,0 +1,65 @@
+"use strict";
+
+const { SuccessResponse } = require("../core/success.response");
+
+const dataProfiles = [
+  {
+    user_id: 1,
+    user_name: "CR7",
+    user_avatar:
+      "https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png",
+    user_email: "cr7@gmail.com",
+    user_phone: "0987654321",
+    user_address: "123 Main St, Anytown, USA",
+    user_role: "admin",
+  },
+  {
+    user_id: 2,
+    user_name: "Messi",
+    user_avatar:
+      "https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png",
+    user_email: "messi@gmail.com",
+    user_phone: "0987654321",
+    user_address: "123 Main St, Anytown, USA",
+    user_role: "admin",
+  },
+  {
+    user_id: 3,
+    user_name: "Ronaldo",
+    user_avatar:
+      "https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png",
+    user_email: "ronaldo@gmail.com",
+    user_phone: "0987654321",
+    user_address: "123 Main St, Anytown, USA",
+    user_role: "admin",
+  },
+];
+
+class ProfileController {
+  // admin
+  profiles = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: dataProfiles,
+    }).send(res);
+  };
+
+  // shop
+  profile = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Success",
+      metadata: {
+        user_id: 2,
+        user_name: "Messi",
+        user_avatar:
+          "https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png",
+        user_email: "messi@gmail.com",
+        user_phone: "0987654321",
+        user_address: "123 Main St, Anytown, USA",
+        user_role: "admin",
+      },
+    }).send(res);
+  };
+}
+
+module.exports = new ProfileController();

package/templates/node-express/files/src/controllers/rbac.controller.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const { CREATED, SuccessResponse } = require("../core/success.response");
+const {
+  createRole,
+  createResource,
+  resourceList,
+  roleList,
+} = require("../services/rbac.service");
+
+class AccessController {
+  createNewRole = async (req, res, next) => {
+    new CREATED({
+      message: "Successfully created new role",
+      metadata: await createRole(req.body),
+    }).send(res);
+  };
+
+  createNewResource = async (req, res, next) => {
+    new CREATED({
+      message: "Successfully created new resource",
+      metadata: await createResource(req.body),
+    }).send(res);
+  };
+
+  getResourceList = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Successfully fetched resource list",
+      metadata: await resourceList(req.body),
+    }).send(res);
+  };
+
+  getRoleList = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Successfully fetched role list",
+      metadata: await roleList(req.body),
+    }).send(res);
+  };
+}
+
+module.exports = new AccessController();

package/templates/node-express/files/src/controllers/template.controller.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const TemplateService = require("../services/template.service");
+const { SuccessResponse } = require("../core/success.response");
+
+class TemplateController {
+  static async createTemplate(req, res, next) {
+    const { template_id, template_name, template_html } = req.body;
+    new SuccessResponse({
+      message: "Template created successfully",
+      metadata: await TemplateService.createTemplate({
+        template_name,
+        template_html,
+        template_id,
+      }),
+    }).send(res);
+  }
+}
+
+module.exports = new TemplateController();

package/templates/node-express/files/src/controllers/upload.controller.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const { BadRequestError } = require("../core/error.response");
+const { SuccessResponse } = require("../core/success.response");
+const UploadAwsService = require("../services/upload.s3.service");
+const UploadService = require("../services/upload.service");
+
+class UploadController {
+  async uploadImgFromUrl(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await UploadService.uploadImageFromUrl(req.body),
+    }).send(res);
+  }
+
+  async uploadImgFromLocal(req, res, next) {
+    const { file } = req;
+    if (!file) {
+      throw new BadRequestError("Error uploading image from local");
+    }
+    new SuccessResponse({
+      message: "Success",
+      metadata: await UploadService.uploadImageFromLocal({
+        path: file.path,
+      }),
+    }).send(res);
+  }
+
+  async uploadImagesFromLocal(req, res, next) {
+    const { files } = req;
+    if (!files) {
+      throw new BadRequestError("Error uploading image from local");
+    }
+    new SuccessResponse({
+      message: "Success",
+      metadata: await UploadService.uploadImagesFromLocal({
+        files,
+      }),
+    }).send(res);
+  }
+
+  async uploadImgFromLocalS3(req, res, next) {
+    const { file } = req;
+    if (!file) {
+      throw new BadRequestError("Error uploading image from local");
+    }
+    new SuccessResponse({
+      message: "Success",
+      metadata: await UploadAwsService.uploadImageFromLocalS3({
+        file,
+      }),
+    }).send(res);
+  }
+}
+
+module.exports = new UploadController();

package/templates/node-express/files/src/controllers/user.controller.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const EmailService = require("../services/email.service");
+const { SuccessResponse } = require("../core/success.response");
+const { User } = require("../models/user.model");
+const { BadRequestError } = require("../core/error.response");
+
+class UserController {
+  // new User
+  async newUser(req, res, next) {
+    const { email } = req.body;
+    const user = await User.findOne({ email }).lean().exec();
+    if (user) {
+      throw new BadRequestError("Email already registered");
+    }
+    new SuccessResponse({
+      message: "User created successfully",
+      metadata: await EmailService.sendEmail({ email }),
+    }).send(res);
+  }
+  // check user token via email
+  async checkRegisterEmailToken(req, res, next) {
+    const { email, token } = req.query;
+
+    if (!email || !token) {
+      throw new BadRequestError("Invalid email or token");
+    }
+
+    new SuccessResponse({
+      message: "Verify email successfully",
+      metadata: await UserService.checkRegisterEmailToken({ email, token }),
+    }).send(res);
+  }
+}
+
+module.exports = new UserController();

package/templates/node-express/files/src/core/error.response.js

@@ -0,0 +1,84 @@
+"use strict";
+const myloggerLog = require("../logger/mylogger.log.js");
+const logger = require("../logger/winston.log.js");
+const reasonPhrases = require("../utils/reasonPhrases.js");
+const statusCodes = require("../utils/statusCodes.js");
+
+class ErrorResponse extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+
+    // TODO: log error use winston
+    // logger.error(`[${this.status}] - ${this.message}`);
+    myloggerLog.error(`[${this.status}] - ${this.message}`, {
+      context: "/path",
+      requestId: "ID_REQUEST",
+      message: this.message,
+      status: this.status,
+      metadata: {},
+    });
+  }
+}
+
+class ConflictRequestError extends ErrorResponse {
+  constructor(
+    message = reasonPhrases.CONFLICT,
+    statusCode = statusCodes.CONFLICT
+  ) {
+    super(message, statusCode);
+  }
+}
+
+class BadRequestError extends ErrorResponse {
+  constructor(
+    message = reasonPhrases.BAD_REQUEST,
+    statusCode = statusCodes.BAD_REQUEST
+  ) {
+    super(message, statusCode);
+  }
+}
+
+class AuthFailureError extends ErrorResponse {
+  constructor(
+    message = reasonPhrases.UNAUTHORIZED,
+    statusCode = statusCodes.UNAUTHORIZED
+  ) {
+    super(message, statusCode);
+  }
+}
+
+class NotFoundError extends ErrorResponse {
+  constructor(
+    message = reasonPhrases.NOT_FOUND,
+    statusCode = statusCodes.NOT_FOUND
+  ) {
+    super(message, statusCode);
+  }
+}
+
+class ForbiddenError extends ErrorResponse {
+  constructor(
+    message = reasonPhrases.FORBIDDEN,
+    statusCode = statusCodes.FORBIDDEN
+  ) {
+    super(message, statusCode);
+  }
+}
+
+class RedisConnectionError extends ErrorResponse {
+  constructor(
+    message = reasonPhrases.INTERNAL_SERVER_ERROR,
+    statusCode = statusCodes.INTERNAL_SERVER_ERROR
+  ) {
+    super(message, statusCode);
+  }
+}
+
+module.exports = {
+  ConflictRequestError,
+  BadRequestError,
+  AuthFailureError,
+  NotFoundError,
+  ForbiddenError,
+};

package/templates/node-express/files/src/core/success.response.js

@@ -0,0 +1,44 @@
+"use strict";
+const reasonPhrases = require("../utils/reasonPhrases.js");
+const statusCodes = require("../utils/statusCodes.js");
+
+class SuccessResponse {
+  constructor({
+    message,
+    statusCode = statusCodes.OK,
+    reasonPhrase = reasonPhrases.OK,
+    metadata = {},
+  }) {
+    this.message = message ? message : reasonPhrase;
+    this.statusCode = statusCode;
+    this.reasonPhrase = reasonPhrase;
+    this.metadata = metadata;
+  }
+
+  send(res, headers = {}) {
+    return res.status(this.statusCode).json(this);
+  }
+}
+
+class OK extends SuccessResponse {
+  constructor({ message, metadata = {} }) {
+    super({ message, metadata });
+  }
+}
+
+class CREATED extends SuccessResponse {
+  constructor({
+    message,
+    statusCode = statusCodes.CREATED,
+    reasonPhrase = reasonPhrases.CREATED,
+    metadata = {},
+  }) {
+    super({ message, reasonPhrase, statusCode, metadata });
+  }
+}
+
+module.exports = {
+  OK,
+  CREATED,
+  SuccessResponse
+};

package/templates/node-express/files/src/database/init.mongodb.level0.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const mongoose = require("mongoose");
+const dotenv = require("dotenv");
+dotenv.config();
+
+const connectDB = async () => {
+  try {
+    const conn = await mongoose.connect(process.env.MONGO_URI);
+    console.log(`MongoDB connected success: ${conn.connection.host}`);
+  } catch (error) {
+    console.log("Error connect to mongo db");
+  }
+};
+
+module.exports = connectDB;

package/templates/node-express/files/src/database/init.mongodb.level1.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const mongoose = require("mongoose");
+const dotenv = require("dotenv");
+const { countConnect } = require("../helpers/check.connect");
+dotenv.config();
+
+class Database {
+  constructor() {
+    this.connect();
+  }
+
+  async connect(type = "mongodb") {
+    try {
+      if (1 === 1) {
+        mongoose.set("debug", true);
+        mongoose.set("debug", { color: true });
+      }
+      const conn = await mongoose.connect(process.env.MONGO_URI);
+      console.log(`MongoDB connected success: ${conn.connection.host}`);
+      countConnect();
+    } catch (error) {
+      console.log("Error connect to mongo db");
+    }
+  }
+
+  static getInstance() {
+    if (!Database.instance) {
+      Database.instance = new Database();
+    }
+    return Database.instance;
+  }
+}
+
+const instanceMongodb = Database.getInstance();
+module.exports = instanceMongodb;