biz-slide-core 1.2.84 → 1.2.85

package/src/entity/slide.entity.ts

@@ -0,0 +1,61 @@
+import { Schema, model, Types } from "mongoose";
+
+interface layer {
+  metaType: String;
+  optionsMeta: String;
+  chatMeta: string;
+}
+
+const layerSchema = new Schema<layer>({
+  metaType: { type: String, enum: ['text', 'image', 'shape', 'list', 'table'] },
+  optionsMeta: { type: String },
+  chatMeta: { type: String },
+}, {
+  timestamps: false,
+  _id: false
+})
+
+export interface ISlideSchema {
+  name: string;
+  postfix: string;
+  rules: string;
+  slideLayoutId: Types.ObjectId;
+  templateId: Types.ObjectId;
+  layers: layer[];
+  createdAt: Date;
+  updatedAt: Date;
+  deletedAt: Date;
+  isDelete: boolean;
+  published: boolean;
+  stage: string;
+  isDefault: boolean;
+  category: string;
+}
+
+const SlideSchema = new Schema<ISlideSchema>(
+  {
+    name: { type: String, default: "", required: true },
+    published: { type: Boolean, default: false },
+    postfix: { type: String, default: "" },
+    rules: { type: String, default: "" },
+    layers: [layerSchema],
+    slideLayoutId: { type: Schema.Types.ObjectId, ref: "slide-layout" },
+    templateId: { type: Schema.Types.ObjectId, ref: "template" },
+    deletedAt: { type: Date, default: null },
+    isDelete: { type: Boolean, default: false },
+    stage: { type: String, default: ""},
+    isDefault: { type: Boolean, default: false },
+    category: { type: String, default: "Default"}
+  },
+  {
+    timestamps: true,
+  }
+);
+
+SlideSchema.index({ name: 1, slideLayoutId: 1, templateId: 1 });
+SlideSchema.index({ slideLayoutId: 1, templateId: 1 });
+SlideSchema.index({ templateId: 1 });
+SlideSchema.index({ name: 1, templateId: 1, slideLayoutId: 1, published: 1 });
+SlideSchema.index({ slideLayoutId: 1, templateId: 1, published: 1, isDelete: 1 });
+
+export const SlideModel = model<ISlideSchema>("slide", SlideSchema);

package/src/entity/socket.entity.ts

@@ -0,0 +1,20 @@
+import { Schema, model, Types } from "mongoose";
+
+export interface ISocketSchema {
+  userId: string;
+  socketIds: Array<string>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const SocketSchema = new Schema<ISocketSchema>(
+    {
+      userId: { type: String, default: null },
+      socketIds: { type: [String], default: [] }
+    },
+    {
+        timestamps: true,
+    }
+);
+
+export const SocketModel = model<ISocketSchema>("socket", SocketSchema);

package/src/entity/template-type.entity.ts

@@ -0,0 +1,87 @@
+import { Schema, model } from "mongoose";
+import { IVariantsSystemLayout, ISystemLayout, IMessageSchema } from "./common";
+
+export interface ITemplateLayout {
+  title: string;
+  layoutType: string;
+}
+
+
+export interface ITemplateTypeSchema{
+  name: string;
+  layouts: Array<ITemplateLayout>;
+  createdAt: Date;
+  updatedAt: Date;
+  deletedAt: Date;
+  suggestionPrompts: Array<string>;
+  topicPrompt: IVariantsSystemLayout;
+  layoutPrompt: IVariantsSystemLayout;
+  insertTopicPrompt: ISystemLayout;
+  slidePrompt: IMessageSchema; // Predefine systame message
+  defaultLayout: string;
+  published: boolean;
+  colorPalletes: Array<Array<string>>;
+}
+
+const layoutsSchema = new Schema<ITemplateLayout>({
+  title: { type: String },
+  layoutType: { type: String },
+}, {
+  timestamps: false,
+  _id: false
+})
+
+
+
+const messageSchema = new Schema<IMessageSchema>({
+  message: { type: String },
+  keys: { type: [String] },
+}, {
+  timestamps: false,
+  _id: false
+})
+
+const systemSchema = new Schema<ISystemLayout>({
+  system: messageSchema,
+  user: messageSchema
+}, {
+  timestamps: false,
+  _id: false
+})
+
+const variantsSystemSchema = new Schema<IVariantsSystemLayout>({
+  single: systemSchema,
+  multiple: systemSchema
+}, {
+  timestamps: false,
+  _id: false
+})
+
+const TemplateTypeSchema = new Schema<ITemplateTypeSchema>(
+  {
+    published: { type: Boolean, default: false },
+    name: { type: String, default: "", required: true },
+    layouts: [layoutsSchema],
+    suggestionPrompts: {type: [String], default: [], _id: false},
+    slidePrompt: messageSchema,
+    topicPrompt: variantsSystemSchema,
+    layoutPrompt: variantsSystemSchema,
+    insertTopicPrompt: systemSchema,
+    defaultLayout: { type: String, default: "" },
+    deletedAt: { type: Date, default: null },
+    colorPalletes: {
+      type: [
+        {
+          type: [String],
+          default: [],
+          _id: false
+        }
+      ], default: [], _id: false
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+export const TemplateTypeModel = model<ITemplateTypeSchema>("template-type", TemplateTypeSchema);

package/src/entity/template.entity.ts

@@ -0,0 +1,38 @@
+import { Schema, model, Types } from "mongoose";
+
+export interface ITemplateSchema{
+  name: string;
+  templateTypeId: Types.ObjectId;
+  createdAt: Date,
+  updatedAt: Date,
+  deletedAt: Date,
+  defaultColorPallete: Array<string>;
+  colorPalletes: Array<Array<string>>;
+  staticImageDir: string;
+  published: boolean;
+}
+
+const TemplateSchema = new Schema<ITemplateSchema>(
+  {
+    name: { type: String, default: "", required: true },
+    published: { type: Boolean, default: false },
+    templateTypeId: { type: Schema.Types.ObjectId, ref: "template-type" },
+    defaultColorPallete: { type: [String], default: [], _id: false },
+    colorPalletes: {
+      type: [
+        {
+          type: [String],
+          default: [],
+          _id: false
+        }
+      ], default: [], _id: false
+    },
+    deletedAt: { type: Date, default: null },
+    staticImageDir: { type: String, default: "", required: true }
+  },
+  {
+    timestamps: true,
+  }
+);
+
+export const TemplateModel = model<ITemplateSchema>("template", TemplateSchema);

package/src/entity/training-queue.entity.ts

@@ -0,0 +1,26 @@
+import { Schema, model, Types } from "mongoose";
+
+interface ITrainingQueue {
+  filename: string,
+  isCompleted: boolean,
+  isLocked: boolean,
+  userId: Types.ObjectId;
+  createdAt: Date,
+  updatedAt: Date,
+  deletedAt: Date
+}
+
+const TrainingQueueSchema = new Schema<ITrainingQueue>(
+  {
+    filename: { type: String, default: null },
+    isCompleted: { type: Boolean, default: false },
+    userId: { type: Schema.Types.ObjectId, ref: "user" },
+    isLocked: { type: Boolean, default: false },
+    deletedAt: { type: Date, default: null},
+  },
+  {
+    timestamps: true,
+  }
+);
+
+export const TrainingQueueModel = model<ITrainingQueue>("training-queue", TrainingQueueSchema);

package/src/entity/user.entity.ts

@@ -0,0 +1,24 @@
+import { Schema, model } from "mongoose";
+
+interface IUser {
+  email: string | null;
+  password: string,
+  role: string,
+  createdAt: Date,
+  updatedAt: Date,
+  deletedAt: Date
+}
+
+const UserSchema = new Schema<IUser>(
+  {
+    email: { type: String, unique: true, sparse: true },
+    password: { type: String, default: null },
+    role: { type: String, default: null },
+    deletedAt: { type: Date, default: null},
+  },
+  {
+    timestamps: true,
+  }
+);
+
+export const UserModel = model<IUser>("user", UserSchema);

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from "./entity";
+export * from "./middleware";
+export * from "./resHandler";
+export * from "./types";
+
+export * from "./utilities";

package/src/middleware/authentication.ts

@@ -0,0 +1,150 @@
+import { Response, NextFunction } from "express";
+import { verifyUid } from "../utilities";
+import { IRequest } from "../types";
+import { UserModel, CustomerModel } 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 createUser = async (emailId: string, userId: string, appName: string) => {
+  const customer = await CustomerModel.findOne({userId});
+  if(!customer) {
+    const newCustomer = new CustomerModel({
+      appName: appName || "default",
+      emailId,
+      emailTemplateStatus: {},
+      userId
+    })
+    await newCustomer.save();
+  }
+}
+
+const authorizeWithSlideApp = () => {
+  return async function (req: IRequest, res: Response, next: NextFunction) {
+    const ipAddress = req.headers['x-forwarded-for'] || (req as any).connection.remoteAddress;
+    const sessionId = req.headers['x-fingerprint-key'];
+
+    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,
+        sessionId,
+        ipAddress,
+        appName: req.headers['x-app-name'],
+        email: token?.customer_email || ""
+      }
+
+      await createUser(req.user.email, req.user.userId, req.user.appName);
+      next();
+    }
+  }
+}
+
+const nonAuthorizeWithSlideApp = () => {
+  return async function (req: IRequest, res: Response, next: NextFunction) {
+    const ipAddress = req.headers['x-forwarded-for'] || (req as any).connection.remoteAddress;
+    const sessionId = req.headers['x-fingerprint-key'];
+    let userId = "guest";
+    let email = "";
+    
+    if (req.headers.authorization) {
+      const token = await verifyUid(req.headers.authorization);
+      if (!token) {
+        return res.status(401).json({ message: 'Session Expired' })
+      }
+
+      userId = token?.customer_id || token?.value?.email;
+      email = token?.customer_email || "";
+      if(!userId) {
+        return res.status(401).json({ message: 'userId not found' })
+      }
+      await createUser(email, userId, req.headers['x-app-name'] as string);
+    } else {
+      if(!ipAddress || !sessionId) {
+        return res.status(401).json({ message: 'We are not able to track your actions'})
+      }
+    }
+
+    req.user = {
+      userId,
+      sessionId,
+      ipAddress,
+      appName: req.headers['x-app-name'],
+      email
+    }
+
+    next();
+  }
+}
+
+// TODO: Delete It 
+const authorizeWithGpt = () => {
+  return async function (req: IRequest, res: Response, next: NextFunction) {
+    const secret = req.headers['authorization'];
+    const secretKey: Array<string> = secret ? secret.split(":") : undefined!;
+
+    if(secretKey && secretKey.length === 2 &&  secretKey[0]!==`Bearer ${process.env.GPT_API_KEY}`) {
+      return res.status(401).json({ message: 'keys not matching' })
+    }
+
+    const ipAddress = req.headers['x-forwarded-for'] || (req as any).connection.remoteAddress;
+    let userId = "guest";
+
+    req.user = {
+      userId,
+      ipAddress,
+      appName: secretKey[1],
+      navigateFromGPT: true
+    }
+    next();
+  }
+}
+
+export {authorize, authorizeWithSlideApp, nonAuthorizeWithSlideApp, authorizeWithGpt};

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,66 @@
+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
+) => {
+
+  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;
+  } else {
+    console.error(err.stack); // Log the error for debugging
+  }
+
+  // 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 || error)
+    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,5 @@
+export * from "./callWithRetries";
+export * from "./createFolder";
+export * from "./encryptionUtils";
+export * from "./pngSvgCategories";
+export * from "./hasAbusiveWords";