biz-slide-core 1.2.28 → 1.2.30

package/src/middleware/authentication.ts

@@ -0,0 +1,68 @@
+import { Response, NextFunction } from "express";
+import { verifyUid } from "../utilities";
+import { IRequest } from "../types";
+import { UserModel } from "../entity";
+
+
+const authorize = (roles: string[]) => {
+  return async function (req: IRequest, res: Response, next: NextFunction) {
+    if (!req.headers.authorization) {
+      return res.status(401).json({ message: 'Unauthorized' })
+    }
+    if (!roles.length) {
+      return res.status(401).json({ message: 'Unauthorized' })
+    }
+    if (req.headers.authorization) {
+      const token = await verifyUid(req.headers.authorization);
+      if (!token) {
+        return res.status(401).json({ message: 'Session Expired' })
+      }
+
+      let user: any = await UserModel.findOne({ email: token.value.email })
+
+      if (!user) {
+        return res.status(401).json({ message: 'No User Found' })
+      }
+
+      const hasAccess = roles.find(role => role === user.role);
+
+      if (!hasAccess) {
+        return res.status(403).json({ message: 'Forbbiden' })
+      }
+
+      const { createdAt, updatedAt, deletedAt, password,  ...rest } = user.toObject();
+      
+      req.user = {...rest, userId: rest.email};
+      next();
+    }
+  }
+}
+
+const authorizeWithSlideApp = () => {
+  return async function (req: IRequest, res: Response, next: NextFunction) {
+    if (!req.headers.authorization) {
+      return res.status(401).json({ message: 'Unauthorized' })
+    }
+    
+    if (req.headers.authorization) {
+      const token = await verifyUid(req.headers.authorization);
+      if (!token) {
+        return res.status(401).json({ message: 'Session Expired' })
+      }
+
+      const userId = token?.customer_id || token?.value?.email;
+
+      if(!userId) {
+        return res.status(401).json({ message: 'userId not found' })
+      }
+
+      req.user = {
+        userId: userId
+      }
+
+      next();
+    }
+  }
+}
+
+export {authorize, authorizeWithSlideApp};

package/src/middleware/index.ts

@@ -0,0 +1,3 @@
+export * from "./authentication";
+export * from "./role";
+export * from "./schemaValidate";

package/src/middleware/role.ts

@@ -0,0 +1,5 @@
+export const ROLES = {
+  User: 'User',
+  Admin: 'Admin',
+  SuperAdmin: 'SuperAdmin'
+}

package/src/middleware/schemaValidate.ts

@@ -0,0 +1,20 @@
+import { NextFunction, Response } from "express";
+import Joi from 'joi';
+
+import { IRequest } from "../types";
+
+export const validateSchema = (schema: Joi.ObjectSchema<any>) => {
+  return async function (req: IRequest, res: Response, next: NextFunction) {
+
+    const { error } = schema.validate(req.body, { abortEarly: false });
+
+    if(error) {
+      const errorMessage = error.details.map((err) => err.message).join(', ');
+      return res.status(400).json({ message: errorMessage });
+    } else {
+      next();
+    }
+  }
+}
+
+

package/src/resHandler/errorHandler.ts

@@ -0,0 +1,65 @@
+import { Request, Response, NextFunction } from 'express';
+
+export class BadRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    Object.setPrototypeOf(this, BadRequestError.prototype);
+    this.name = 'BadRequestError';
+  }
+}
+
+export class NotFoundRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    Object.setPrototypeOf(this, NotFoundRequestError.prototype);
+    this.name = 'NotFoundRequestError';
+  }
+}
+
+export class CustomRequestError  {
+  name: string;
+  message: {
+    title: string,
+    description: string
+  };
+
+  constructor(title: string, description: string) {
+    this.name = 'CustomRequestError';
+    this.message = {
+      title,
+      description
+    };
+  }
+}
+
+
+
+// Custom error handler middleware
+export const errorHandler = (
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  console.error(err.stack); // Log the error for debugging
+
+  let statusCode = 500; // Default status code
+  let errorMessage = 'Internal Server Error'; // Default error message
+
+  if (err instanceof BadRequestError) {
+    statusCode = 400;
+    errorMessage = err.message;
+  } else if(err instanceof NotFoundRequestError) {
+    statusCode = 404;
+    errorMessage = err.message;
+  } else if(err instanceof CustomRequestError) {
+    statusCode = 422;
+    errorMessage = err.message;
+  }
+
+  // Send an error response
+  res.status(statusCode).json({
+    message: errorMessage,
+    error: err.name // Optionally send the error name/type
+  });
+};

package/src/resHandler/index.ts

@@ -0,0 +1,2 @@
+export * from "./errorHandler";
+export * from "./successHandler";

package/src/resHandler/successHandler.ts

@@ -0,0 +1,11 @@
+import { Request, Response, NextFunction } from 'express';
+
+// Generic success handler middleware
+export const successHandler = (
+  data: any,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  res.status(200).json(data);
+};

package/src/types/IController.ts

@@ -0,0 +1,6 @@
+import { Response } from "express";
+import { IRequest } from "./IRequest";
+
+export interface IController {
+  (req: IRequest, res: Response): void;
+}

package/src/types/IRequest.ts

@@ -0,0 +1,8 @@
+import { Request } from "express";
+
+export interface IRequest extends Request {
+    user?: any,
+    token?: any,
+    role?: any,
+    file?:any
+}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+export * from "./IController";
+export * from "./IRequest";
+
+export enum QUEUES {
+  IMAGE_MODEL_BULK = "image-model-bulk", // Will be used for bulk training model
+  IMAGE_MODEL_SINGLE = "image-model-single", // Will be used for single image training
+  NOTIFICATION = "notification", // Notify to user
+  THUMBNAIL = "thumbnail", // To create thubmnail
+  PPT = "ppt", // to call PPT Service
+  PNG_SVG = "png-svg" // to convert raster to vector image
+}

package/src/utilities/callWithRetries.ts

@@ -0,0 +1,9 @@
+export async function callWithRetries(retryCount: number, failedMessage: string, functionRef: Function, ...args: any): Promise<any> {
+  try {
+    return  await functionRef(...args)
+   } catch (error: any) {
+    if (retryCount <= 0) throw error;
+    console.log("callWithRetries", error?.message)
+    return callWithRetries(retryCount - 1, failedMessage, functionRef, ...args);
+  }
+}

package/src/utilities/createFolder.ts

@@ -0,0 +1,11 @@
+import fs from "fs";
+
+export async function createFolder(folderPath: string) {
+  try {
+    if (!fs.existsSync(folderPath)) {
+      fs.mkdirSync(folderPath);
+    }
+  } catch (error: any) {
+    console.error(`Error: ${error.message}`);
+  }
+}

package/src/utilities/encryptionUtils.ts

@@ -0,0 +1,26 @@
+import jwt from 'jsonwebtoken';
+
+const signUid = (value: object) => {
+  return jwt.sign({ value }, process.env.JWTSECRET || 'secret', {
+    expiresIn: '8h' // expires in 8 hours
+  });
+};
+
+const verifyUid = async (token: string): Promise<any> =>
+  new Promise(resolve => {
+    const jwtToken = token.split(" ")[1] || token;
+    jwt.verify(
+      jwtToken,
+      process.env.JWTSECRET || 'secret',
+      (err, decoded) => {
+        if (err) {
+          console.log("error verifyUid", err)
+          resolve(null);
+        } else {
+          resolve(decoded);
+        }
+      },
+    );
+  });
+
+export { signUid, verifyUid }

package/src/utilities/hasAbusiveWords.ts

@@ -0,0 +1,33 @@
+export function hasExactMatch(str: string, word: string) {
+  // Construct a regular expression to match the word as a whole word
+  const regex = new RegExp('\\b' + word + '\\b', 'i'); // 'i' for case-insensitive matching
+
+  // Test if the word has an exact match in the string
+  return regex.test(str);
+}
+
+export function hasSpecialCharacter(str: string) {
+  // Define a regular expression with a character class containing special characters
+  const regex = /[!@#$%^&*()_+\-=\[\]{};:\\|<>\/?]/;
+
+  // Test if the string contains any special character
+  return regex.test(str);
+}
+
+
+export function hasAbusiveWords(str: string, words: string[]) {
+  // Convert the string to lowercase for case-insensitive matching
+  const lowerStr = str.toLowerCase();
+  
+  if(hasSpecialCharacter(lowerStr)) {
+  	return true;
+  }
+
+  // Check if any abusive word exists in the string
+  for (const word of words) {
+  	if(hasExactMatch(lowerStr, word.toLowerCase())) {
+    	return true
+    }
+  }
+  return false;
+}

package/src/utilities/index.ts

@@ -0,0 +1,6 @@
+export * from "./callWithRetries";
+export * from "./createFolder";
+export * from "./encryptionUtils";
+export * from "./pngSvgCategories";
+export * from "./hasAbusiveWords";
+export * from "./sendEmail";

package/src/utilities/pngSvgCategories.ts

@@ -0,0 +1,167 @@
+export const pngSvgCategories = {
+  "Logo": {
+    "Outline": {
+      "alias": ""
+    },
+    "Monogram": {
+      "alias": ""
+    },
+    "Wordmark": {
+      "alias": ""
+    },
+    "Emblem": {
+      "alias": ""
+    },
+    "Abstract Logo": {
+      "alias": ""
+    },
+    "Mascot": {
+      "alias": ""
+    }
+  },
+  "Icons": {
+    "Outline": {
+      "alias": ""
+    },
+    "Pictogram": {
+      "alias": ""
+    },
+    "Broken Line": {
+      "alias": ""
+    },
+    "Gradient Line": {
+      "alias": ""
+    },
+    "Gradient Shape": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme."
+    },
+    "Doodle": {
+      "alias": ""
+    },
+    "Flat": {
+      "alias": ""
+    },
+    "Minimalistic": {
+      "alias": ""
+    },
+    "Isometric": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "3D Icons": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme."
+    }
+  },
+  "Illustrations": {
+    "Hand Drawn": {
+      "alias": ""
+    },
+    "Glow": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "Pixel Art": {
+      "alias": ""
+    },
+    "Watercolour": {
+      "alias": ""
+    },
+    "Psychedelic": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "80's": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "Digital Art": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "Abstract": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "Realistic": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "Comic Style": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "Fantasy": {
+      "alias": "The icon should have strong and dramatic lighting and have a clean look on white background and should have only the suggested colour scheme. "
+    },
+    "Anime": {
+      "alias": ""
+    },
+    "Minimalist": {
+      "alias": ""
+    },
+    "Pencil Sketch": {
+      "alias": ""
+    },
+  },
+  "3D illustration": {
+    "Wireframe": {
+      "alias": ""
+    },
+    "Low Poly": {
+      "alias": ""
+    },
+    "Cartoon 3D": {
+      "alias": ""
+    },
+    "Plastic 3D": {
+      "alias": ""
+    },
+    "3D render": {
+      "alias": ""
+    },
+  },
+  "Photorealism": {
+    "Photorealistic Painting": {
+      "alias": ""
+    },
+    "Photorealistic Drawing": {
+      "alias": ""
+    },
+    "Hyperealism": {
+      "alias": ""
+    },
+    "Photorealism": {
+      "alias": ""
+    },
+  },
+  "Vector Art": {
+    "Line Art": {
+      "alias": ""
+    },
+    "Cartoon": {
+      "alias": ""
+    },
+    "Vector Kawai": {
+      "alias": ""
+    },
+    "Linocut": {
+      "alias": ""
+    },
+    "Engraving": {
+      "alias": ""
+    },
+    "Doodle Line Art": {
+      "alias": ""
+    },
+    "Geometric": {
+      "alias": ""
+    },
+    "Abstract": {
+      "alias": ""
+    },
+    "Vintage": {
+      "alias": ""
+    },
+    "Minimalist": {
+      "alias": ""
+    },
+    "Stylized": {
+      "alias": ""
+    },
+    "Flat Design": {
+      "alias": ""
+    },
+  }
+}

package/src/utilities/sendEmail.ts

@@ -0,0 +1,30 @@
+import nodemailer from "nodemailer";
+
+export async function sendEmail(to: string[], subject: string, text: string, attachments: [{ filename: string, path?: string, content?: any }]) {
+  // Create a Nodemailer transporter using AWS SES SMTP credentials
+  const transporter = nodemailer.createTransport({
+    host: process.env.EMAIL_HOST, // SES SMTP endpoint for your region
+    port: 465,
+    secure: true, // use TLS
+    auth: {
+      user: process.env.EMAIL_USER, // SMTP username (not used but still required)
+      pass: process.env.EMAIL_PASS // Access token
+    }
+  });
+
+  // Define email options
+  const mailOptions: any = {
+    from: process.env.EMAIL_SUPPORT, // sender email address
+    to, // recipient email address
+    subject, // subject of the email
+    text, // plaintext body
+    attachments: attachments || []
+  };
+  try {
+    const info = await transporter.sendMail(mailOptions);
+    console.log('Email sent:', info.response);
+  } catch (error) {
+    console.error('Error sending email: ', error);
+    return undefined;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "outDir": "./dist", // Specify your desired output directory
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}