biz-slide-core 1.2.30 → 1.2.32

package/dist/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "biz-slide-core",
-  "version": "1.2.30",
-  "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/config.enity.ts

@@ -1,18 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface IConfigSchema {
-  configType: string;
-  value: string;
-}
-
-const CongigSchema = new Schema<IConfigSchema>(
-  {
-    configType: { type: String, required: true },
-    value: { type: String, required: true },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const ConfigModel = model<IConfigSchema>("config", CongigSchema);

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;
-  aliasName: 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 },
-    aliasName: { type: String, required: true },
-    keywords: { type: [String], default: [] },
-    title: { type: String, required: true },
-    userId: { type: Schema.Types.ObjectId, ref: "user" },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const ImageModel = model<IImageSchema>("image", ImageSchema);

package/src/entity/index.ts

@@ -1,16 +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";
-export * from "./training-queue.entity";
-export * from "./config.enity";
-export * from "./logs.entity";
-
-

package/src/entity/logs.entity.ts

@@ -1,20 +0,0 @@
-import { Schema, model } from "mongoose";
-
-export interface ILogsSchema {
-  type: string;
-  event: string;
-  message: string;
-}
-
-const LogsSchema = new Schema<ILogsSchema>(
-  {
-    type: { type: String, required: true },
-    event: { type: String, required: true },
-    message: { type: String, required: true },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const LogsModel = model<ILogsSchema>("logs", LogsSchema);

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

@@ -1,42 +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;
-  isDownloaded?: boolean;
-  hasError?: boolean;
-  optionsDownloaded: any;
-  userReaction: number;
-  userFeedback: string;
-  createdAt?: Date;
-  updatedAt?: Date;
-  deletedAt?: Date;
-}
-
-const PngSvgSchema = new Schema<IPngSvgSchema>(
-  {
-    deletedAt: { type: Date, default: null },
-    isLocked: { type: Boolean, default: false },
-    optionsDownloaded: Schema.Types.Mixed,
-    isDownloaded: { type: Boolean, default: false },
-    isCompleted: { type: Boolean, default: false },
-    hasError: { type: Boolean, default: false },
-    userId: { type: String, default: null },
-    userReaction: { type: Number, default: 0 },
-    userFeedback: { 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;
-    event: string;
-    message: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-}
-
-const PPTEventSchema = new Schema<IPPTEventSchema>(
-    {
-      pptRef: { type: Schema.Types.ObjectId, ref: 'ppt' },
-      message: { type: String, default: null },
-      event: { type: String, default: null },
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const PPTSlideEventModel = model<IPPTEventSchema>("ppt-event", PPTEventSchema);

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

@@ -1,29 +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>(
-    {
-      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,48 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface IPPTSchema {
-    systemGeneratedtopics: Array<string>;
-    userSelectedTopics: Array<string>;
-    colors: Array<string>;
-    slideRefs: Types.ObjectId[];
-    templateId: Types.ObjectId;
-    templateTypeId: Types.ObjectId;
-    prompt: string;
-    userId: string;
-    userReaction: number;
-    userFeedback: string;
-    questions: Array<string>;
-    isLocked?: boolean;
-    fileCreated?: boolean;
-    isCompleted?: boolean;
-    createdAt?: Date;
-    updatedAt?: Date;
-    deletedAt?: Date;
-    hasError?: boolean;
-}
-
-const PPTSchema = new Schema<IPPTSchema>(
-    {
-      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 },
-      templateTypeId: { type: Schema.Types.ObjectId, ref: "template-type" },
-      systemGeneratedtopics: { type: [String], default: [], _id: false },
-      userSelectedTopics: { type: [String], default: [], _id: false },
-      userReaction: { type: Number, default: 0 },
-      userFeedback: { type: String, default: null },
-      questions: { type: [String], default: [], _id: false },
-      colors: { type: [String], default: [], _id: false },
-      prompt: { type: String, default: null },
-      templateId: { type: Schema.Types.ObjectId, ref: 'template' },
-      hasError: { type: Boolean, default: false },
-      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,22 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface ISlideLayoutSchema {
-  name: string;
-  templateTypeId: Types.ObjectId;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date;
-}
-
-const SlideLayoutSchema = new Schema<ISlideLayoutSchema>(
-  {
-    name: { type: String, default: "", required: true },
-    templateTypeId: { type: Schema.Types.ObjectId, ref: "template-type" },
-    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;
-  isDelete: boolean;
-}
-
-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" },
-    deletedAt: { type: Date, default: null },
-    isDelete: { type: Boolean, default: false }
-  },
-  {
-    timestamps: true,
-  }
-);
-
-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,57 +0,0 @@
-import { Schema, model } from "mongoose";
-
-interface IQuestionSchema {
-  question: string;
-  systemMessage: string;
-  keyId: string;
-  placeholder: 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;
-  suggestionPrompts: Array<string>;
-}
-
-const questionSchema = new Schema<IQuestionSchema>({
-  question: { type: String },
-  systemMessage: { type: String },
-  keyId: { type: String },
-  placeholder: { 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],
-    suggestionPrompts: {type: [String], default: [], _id: false},
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    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,68 +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' })
-      }
-
-      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

@@ -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,65 +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
-) => {
-  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

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