biz-slide-core 1.1.7 → 1.1.9

package/dist/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "biz-slide-core",
-  "version": "1.1.7",
-  "description": "",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "express": "^4.18.2",
-    "joi": "^17.11.0",
-    "jsonwebtoken": "^9.0.2",
-    "typescript": "^5.3.3"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.21",
-    "@types/jsonwebtoken": "^9.0.5"
-  }
-}

package/src/entity/image.entity.ts

@@ -1,32 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface IImageSchema {
-  focusPoint: { x: number, y: number };
-  url: string;
-  radius: string;
-  keywords: [string] | null;
-  title: string;
-  userId: Types.ObjectId;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date;
-}
-
-const ImageSchema = new Schema<IImageSchema>(
-  {
-    focusPoint: { x: Number, y: Number },
-    url: { type: String, required: true },
-    radius: { type: String, required: true },
-    keywords: { type: [String], default: [] },
-    title: { type: String, required: true },
-    userId: { type: Schema.Types.ObjectId, ref: "user" },
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const ImageModel = model<IImageSchema>("image", ImageSchema);

package/src/entity/index.ts

@@ -1,11 +0,0 @@
-export * from "./image.entity";
-export * from "./png-svg.entity";
-export * from "./ppt-event.entity";
-export * from "./ppt-slide.entity";
-export * from "./ppt.entity";
-export * from "./slide-layout.entity";
-export * from "./slide.entity";
-export * from "./socket.entity";
-export * from "./template.entity";
-export * from "./template-type.entity";
-export * from "./user.entity";

package/src/entity/png-svg.entity.ts

@@ -1,34 +0,0 @@
-import { Schema, model } from "mongoose";
-
-export interface IPngSvgSchema {
-  title: string;
-  styleCategory: string;
-  styleSubCategory: string;
-  colors: Array<string>;
-  userId: string;
-  isLocked?: boolean;
-  isCompleted?: boolean;
-  createdAt?: Date;
-  updatedAt?: Date;
-  deletedAt?: Date;
-}
-
-const PngSvgSchema = new Schema<IPngSvgSchema>(
-  {
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-    isLocked: { type: Boolean, default: false },
-    isCompleted: { type: Boolean, default: false },
-    userId: { type: String, default: null },
-    title: { type: String, default: null },
-    styleCategory: { type: String, default: null },
-    styleSubCategory: { type: String, default: null },
-    colors: { type: [{ type: String, default: null }], default: null, _id: false }
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const PngSvgModel = model<IPngSvgSchema>("png-svg", PngSvgSchema);

package/src/entity/ppt-event.entity.ts

@@ -1,23 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-
-export interface IPPTEventSchema {
-    pptRef: Types.ObjectId;
-    message: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-}
-
-const PPTEventSchema = new Schema<IPPTEventSchema>(
-    {
-      createdAt: { type: Date, default: Date.now() },
-      updatedAt: { type: Date, default: Date.now() },
-      pptRef: { type: Schema.Types.ObjectId, ref: 'ppt' },
-      message: { type: String, default: null }
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const PPTSlideEventModel = model<IPPTEventSchema>("ppt-event", PPTEventSchema);

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

@@ -1,31 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-export interface IPPTSlideSchema {
-    pptRef: Types.ObjectId;
-    slideRef: Types.ObjectId;
-    slideLayoutRef: Types.ObjectId;
-    title: string;
-    rawData: string;
-    images: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-    deletedAt?: Date;
-}
-
-const PPTSlideSchema = new Schema<IPPTSlideSchema>(
-    {
-      createdAt: { type: Date, default: Date.now() },
-      updatedAt: { type: Date, default: Date.now() },
-      deletedAt: { type: Date, default: null },
-      pptRef: { type: Schema.Types.ObjectId, ref: 'ppt' },
-      slideRef: { type: Schema.Types.ObjectId, ref: 'slide' },
-      slideLayoutRef: { type: Schema.Types.ObjectId, ref: 'slide-layout' },
-      title: { type: String, default: null },
-      rawData: { type: String, default: "{}" },
-      images: { type: String, default: "{}" },
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const PPTSlideModel = model<IPPTSlideSchema>("ppt-slide", PPTSlideSchema);

package/src/entity/ppt.entity.ts

@@ -1,42 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface IPPTSchema {
-    systemGeneratedtopics: Array<string>;
-    colors: Array<string>;
-    slideRefs: Types.ObjectId[];
-    templateRef: Types.ObjectId;
-    template_type: string;
-    prompt: string;
-    userId: string;
-    questions: Array<string>;
-    isLocked?: boolean;
-    fileCreated?: boolean;
-    isCompleted?: boolean;
-    createdAt?: Date;
-    updatedAt?: Date;
-    deletedAt?: Date;
-}
-
-const PPTSchema = new Schema<IPPTSchema>(
-    {
-      createdAt: { type: Date, default: Date.now() },
-      updatedAt: { type: Date, default: Date.now() },
-      deletedAt: { type: Date, default: null },
-      isLocked: { type: Boolean, default: false },
-      isCompleted: { type: Boolean, default: false },
-      fileCreated: { type: Boolean, default: false },
-      userId: { type: String, default: null },
-      template_type: { type: String, default: null },
-      systemGeneratedtopics: { type: [String], default: [], _id: false },
-      questions: { type: [String], default: [], _id: false },
-      colors: { type: [String], default: [], _id: false },
-      prompt: { type: String, default: null },
-      templateRef: { type: Schema.Types.ObjectId, ref: 'template' },
-      slideRefs: {type: [{ type: Schema.Types.ObjectId, ref: 'ppt-slide' }], default: [], _id: false}
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const PPTModel = model<IPPTSchema>("ppt", PPTSchema);

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

@@ -1,24 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface ISlideLayoutSchema {
-  name: string;
-  templateId: Types.ObjectId;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date;
-}
-
-const SlideLayoutSchema = new Schema<ISlideLayoutSchema>(
-  {
-    name: { type: String, default: "", required: true },
-    templateId: { type: Schema.Types.ObjectId, ref: "template" },
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const SlideLayoutModel = model<ISlideLayoutSchema>("slide-layout", SlideLayoutSchema);

package/src/entity/slide.entity.ts

@@ -1,47 +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;
-}
-
-const SlideSchema = new Schema<ISlideSchema>(
-  {
-    name: { type: String, default: "", required: true },
-    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" },
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const SlideModel = model<ISlideSchema>("slide", SlideSchema);

package/src/entity/socket.entity.ts

@@ -1,22 +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>(
-    {
-      createdAt: { type: Date, default: Date.now() },
-      updatedAt: { type: Date, default: Date.now() },
-      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,53 +0,0 @@
-import { Schema, model } from "mongoose";
-
-interface IQuestionSchema {
-  question: string;
-  systemMessage: string;
-}
-
-export interface ITemplateLayout {
-  title: string;
-  layoutType: string;
-}
-export interface ITemplateTypeSchema{
-  name: string;
-  questions: Array<IQuestionSchema>;
-  predefineSystemMessage: string;
-  layouts: Array<ITemplateLayout>;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date;
-}
-
-const questionSchema = new Schema<IQuestionSchema>({
-  question: { type: String },
-  systemMessage: { type: String },
-}, {
-  timestamps: false,
-  _id: false
-})
-
-const layoutsSchema = new Schema<ITemplateLayout>({
-  title: { type: String },
-  layoutType: { type: String },
-}, {
-  timestamps: false,
-  _id: false
-})
-
-const TemplateTypeSchema = new Schema<ITemplateTypeSchema>(
-  {
-    name: { type: String, default: "", required: true },
-    questions: [questionSchema],
-    predefineSystemMessage: {type: String, default: ""},
-    layouts: [layoutsSchema],
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const TemplateTypeModel = model<ITemplateTypeSchema>("template-type", TemplateTypeSchema);

package/src/entity/template.entity.ts

@@ -1,24 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface ITemplateSchema{
-  name: string;
-  template_type: Types.ObjectId;
-  createdAt: Date,
-  updatedAt: Date,
-  deletedAt: Date
-}
-
-const TemplateSchema = new Schema<ITemplateSchema>(
-  {
-    name: { type: String, default: "", required: true },
-    template_type: { type: Schema.Types.ObjectId, ref: "template-type" },
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const TemplateModel = model<ITemplateSchema>("template", TemplateSchema);

package/src/entity/user.entity.ts

@@ -1,26 +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 },
-    createdAt: { type: Date, default: Date.now()},
-    updatedAt: { type: Date, default: Date.now()},
-    deletedAt: { type: Date, default: null},
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const UserModel = model<IUser>("user", UserSchema);

package/src/index.ts

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

package/src/middleware/authentication.ts

@@ -1,62 +0,0 @@
-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' })
-      }
-
-      req.user = {
-        userId: token.value.email || token.value.customer_id
-      }
-
-      next();
-    }
-  }
-}
-
-export {authorize, authorizeWithSlideApp};

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,44 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-
-export class BadRequestError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'BadRequestError';
-  }
-}
-
-export class NotFoundRequestError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'NotFoundRequestError';
-  }
-}
-
-
-
-// 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;
-  }
-
-  // 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) {
-    if (retryCount <= 0) throw error;
-    console.log(failedMessage)
-    return callWithRetries(retryCount - 1, failedMessage, functionRef, ...args);
-  }
-}

package/src/utilities/createFolder.ts

@@ -1,12 +0,0 @@
-import fs from "fs";
-
-export async function createFolder(folderPath: string) {
-  try {
-    if (!fs.existsSync(folderPath)) {
-      fs.mkdirSync(folderPath);
-    }
-    console.log(`Folder "${folderPath}" is ready.`);
-  } 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];
-    jwt.verify(
-      jwtToken,
-      process.env.JWTSECRET || 'secret',
-      (err, decoded) => {
-        if (err) {
-          console.log(err)
-          resolve(null);
-        } else {
-          resolve(decoded);
-        }
-      },
-    );
-  });
-
-export { signUid, verifyUid }

package/src/utilities/index.ts

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