biz-slide-core 1.2.85 → 1.2.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "biz-slide-core",
-  "version": "1.2.85",
+  "version": "1.2.86",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/entity/analytic.entity.ts

@@ -1,62 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface ILayoutAnalyticsSchema {
-  name: string;
-  count: number;
-  percentage: number;
-}
-
-export interface IEventsSchema {
-  name: string;
-  count: number;
-}
-
-export interface IAnalyticSchema {
-  appName: string;
-  noOfPPT: number;
-  totalDownloaded: number;
-  navigateFromGPT: number;
-  noOfGuestPPT: number;
-  events: Array<IEventsSchema>;
-  totalSlides: number;
-  layouts: Array<ILayoutAnalyticsSchema>;
-  analyticsDate: Date;
-  templateTypeId: Types.ObjectId;
-}
-
-const eventSchema = new Schema<IEventsSchema>({
-  name: { type: String, required: true },
-  count: { type: Number, default: 0 }
-}, {
-  timestamps: false,
-  _id: false
-})
-
-const layoutAnalyticsSchema = new Schema<ILayoutAnalyticsSchema>({
-  name: { type: String, required: true },
-  count: { type: Number, default: 0 },
-  percentage: { type: Number, default: 0 }
-}, {
-  timestamps: false,
-  _id: false
-});
-
-const AnalyticSchema = new Schema<IAnalyticSchema>(
-  {
-    templateTypeId: { type: Schema.Types.ObjectId, ref: "template-type" },
-    appName: { type: String, required: true },
-    noOfPPT: { type: Number, default: 0 },
-    totalDownloaded: { type: Number, default: 0 },
-    navigateFromGPT: { type: Number, default: 0 },
-    noOfGuestPPT: { type: Number, default: 0 },
-    events: { type: [eventSchema], default: [] },
-    totalSlides: { type: Number, default: 0 },
-    layouts: {type: [layoutAnalyticsSchema], default: []},
-    analyticsDate: { type: Date, default: Date.now }
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const AnalyticModel = model<IAnalyticSchema>("analytic", AnalyticSchema);

package/src/entity/common.ts

@@ -1,19 +0,0 @@
-export interface IMessageSchema {
-  message: string;
-  keys: Array<string>;
-}
-export interface ISystemLayout {
-system: IMessageSchema;
-user: IMessageSchema;
-}
-
-export interface IVariantsSystemLayout {
-single: {
-  system: IMessageSchema;
-  user: IMessageSchema;
-},
-multiple: {
-  system: IMessageSchema;
-  user: IMessageSchema;
-}
-}

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/cron.entity.ts

@@ -1,22 +0,0 @@
-import { Schema, model } from "mongoose";
-
-export interface ICronSchema {
-  name: string;
-  status: boolean;
-}
-
-
-const CronSchema = new Schema<ICronSchema>(
-  {
-    name: { type: String, required: true },
-    status: { type: Boolean, default: false}
-  },
-  {
-    timestamps: true,
-  }
-);
-
-CronSchema.index({userId: 1});
-
-
-export const CronModel = model<ICronSchema>("cron", CronSchema);

package/src/entity/customer.entity.ts

@@ -1,40 +0,0 @@
-import { Schema, model } from "mongoose";
-
-export interface IEmailTemplateStatus {
-  sent: boolean;
-}
-
-
-export interface ICustomerSchema {
-  appName: string;
-  userId: string;
-  emailId: string;
-  emailTemplateStatus: Record<string, IEmailTemplateStatus>
-}
-
-const EmailTemplateStatusSchema = new Schema<IEmailTemplateStatus>(
-  {
-    sent: { type: Boolean, default: false },
-  },
-  {
-    timestamps: false,
-    _id: false
-  }
-);
-
-const CustomerSchema = new Schema<ICustomerSchema>(
-  {
-    appName: { type: String, required: true },
-    userId: { type: String, required: true},
-    emailId: { type: String, default: "" },
-    emailTemplateStatus: {type: Map, of: EmailTemplateStatusSchema}
-  },
-  {
-    timestamps: true,
-  }
-);
-
-CustomerSchema.index({userId: 1});
-
-
-export const CustomerModel = model<ICustomerSchema>("customer", CustomerSchema);

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,20 +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";
-export * from "./analytic.entity";
-export * from "./ppt-email-queue.entity";
-export * from "./customer.entity";
-export * from "./cron.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,44 +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;
-  appName: string;
-}
-
-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 },
-    appName: { type: String, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const PngSvgModel = model<IPngSvgSchema>("png-svg", PngSvgSchema);

package/src/entity/ppt-email-queue.entity.ts

@@ -1,22 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface IPPTEmailQueueSchema {
-  pptRef: Types.ObjectId;
-  emailType: string;
-  sent: boolean;
-}
-
-const PPTEmailQueueSchema = new Schema<IPPTEmailQueueSchema>(
-  {
-    pptRef: { type: Schema.Types.ObjectId, ref: 'ppt' },
-    emailType: { type: String, required: true },
-    sent: { type: Boolean, default: false }
-  },
-  {
-    timestamps: true,
-  }
-);
-
-PPTEmailQueueSchema.index({sent: 1, createdAt: 1});
-
-export const PPTEmailQueueModel = model<IPPTEmailQueueSchema>("ppt-email-queue", PPTEmailQueueSchema);

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

@@ -1,25 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-
-export interface IPPTEventSchema {
-    pptRef: Types.ObjectId;
-    event: string;
-    message: string;
-    appName: 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 },
-      appName: { type: String, default: null }
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const PPTSlideEventModel = model<IPPTEventSchema>("ppt-event", PPTEventSchema);

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

@@ -1,40 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-export interface IPPTSlideSchema {
-    pptRef: Types.ObjectId;
-    slideRef: Types.ObjectId;
-    slideLayoutRef: Types.ObjectId;
-    title: string;
-    rawData: string;
-    originalData: string;
-    images: string;
-    staticData: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-    deletedAt?: Date;
-    istmp?: boolean;
-    appName: string;
-}
-
-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: "{}" },
-      originalData: { type: String, default: "{}" },
-      staticData: {type: String, default: "{}" },
-      images: { type: String, default: "{}" },
-      istmp: { type: Boolean, default: false },
-      appName: { type: String, default: null },
-    },
-    {
-        timestamps: true,
-    }
-);
-
-PPTSlideSchema.index({ createdAt: 1,istmp: 1})
-
-
-export const PPTSlideModel = model<IPPTSlideSchema>("ppt-slide", PPTSlideSchema);

package/src/entity/ppt.entity.ts

@@ -1,79 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface IPPTSchema {
-    systemGeneratedtopics: Array<string>;
-    userSelectedTopics: Array<string>;
-    userLanguageTopics: Array<string>;
-    colors: Array<string>;
-    slideRefs: Types.ObjectId[];
-    templateId: Types.ObjectId;
-    templateTypeId: Types.ObjectId;
-    prompt: string;
-    promptAlias: string;
-    userId: string;
-    userReaction: number;
-    userFeedback: string;
-    isLocked?: boolean;
-    fileCreated?: boolean;
-    isCompleted?: boolean;
-    createdAt?: Date;
-    updatedAt?: Date;
-    deletedAt?: Date;
-    hasError?: boolean;
-    version?: string;
-    noOfSlides: number;
-    trackIP: string;
-    sessionId: string;
-    fileCreateCount: number; 
-    language: string;
-    info: string;
-    addtionalInfoUrl: string;
-    appName: string;
-    navigateFromGPT: boolean;
-    googleDriveId: string;
-    isPartialFile: boolean;
-    isEditable: 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 }, // S3 file creation
-      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 },
-      userLanguageTopics: { type: [String], default: [], _id: false },
-      userReaction: { type: Number, default: 0 },
-      userFeedback: { type: String, default: null },
-      colors: { type: [String], default: [], _id: false },
-      templateId: { type: Schema.Types.ObjectId, ref: 'template' },
-      hasError: { type: Boolean, default: false },
-      slideRefs: {type: [{ type: Schema.Types.ObjectId, ref: 'ppt-slide' }], default: [], _id: false},
-      version: { type: String, default: null },
-      trackIP: { type: String, default: null },
-      sessionId: { type: String, default: null },
-      fileCreateCount: { type: Number, default: 0},
-      language: { type: String, default: "English" },
-      addtionalInfoUrl: { type: String, default: null },
-      info: { type: String, default: null },
-      prompt: { type: String, default: null },
-      promptAlias: { type: String, default: null },
-      noOfSlides: { type: Number, default: null },
-      appName: { type: String, default: null },
-      navigateFromGPT: { type: Boolean, default: false },
-      googleDriveId: { type: String, default: null }, // google file creation
-      isPartialFile: { type: Boolean, default: false }, // was free file created
-      isEditable: { type: Boolean, default: false } // if is editable is true them menas user will get PPT in editable format
-    },
-    {
-        timestamps: true,
-    }
-);
-
-PPTSchema.index({userId: 1, isCompleted: 1, hasError: 1, isLocked: 1});
-
-
-export const PPTModel = model<IPPTSchema>("ppt", PPTSchema);

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);