biz-slide-core 1.2.85 → 1.2.87

package/src/entity/slide-layout.entity.ts

@@ -1,56 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-import { ISystemLayout, IMessageSchema } from "./common";
-
-
-export interface ISlideLayoutSchema {
-  name: string;
-  alias: string[];
-  templateTypeId: Types.ObjectId;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date;
-  published: boolean;
-  insertSelectionPrompt: ISystemLayout;
-  newSelectionPrompt: ISystemLayout;
-  slideSelectionQuestion: string;
-  category: string;
-  subCategory: string[];
-  displayName: string;
-}
-
-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 SlideLayoutSchema = new Schema<ISlideLayoutSchema>(
-  {
-    published: { type: Boolean, default: false },
-    name: { type: String, default: "", required: true },
-    displayName: { type: String, default: "" },
-    alias: { type: [String], default: [], _id: false },
-    templateTypeId: { type: Schema.Types.ObjectId, ref: "template-type" },
-    deletedAt: { type: Date, default: null },
-    insertSelectionPrompt: systemSchema,
-    newSelectionPrompt: systemSchema,
-    category: { type: String, default: "Default"},
-    subCategory: { type: [String], default: [], _id: false },
-    slideSelectionQuestion: { type: String, default: ""}
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const SlideLayoutModel = model<ISlideLayoutSchema>("slide-layout", SlideLayoutSchema);

package/src/entity/slide.entity.ts

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

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

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

@@ -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 }