biz-slide-core 1.2.85 → 1.2.86

package/src/entity/template.entity.ts

@@ -1,38 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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

package/src/middleware/authentication.ts

@@ -1,150 +0,0 @@
-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

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

package/src/middleware/role.ts

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

package/src/middleware/schemaValidate.ts

@@ -1,20 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

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

package/src/resHandler/successHandler.ts

@@ -1,11 +0,0 @@
-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

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

package/src/types/IRequest.ts

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

package/src/types/index.ts

@@ -1,11 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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

package/src/utilities/pngSvgCategories.ts

@@ -1,167 +0,0 @@
-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/tsconfig.json

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