biz-slide-core 1.2.83 → 1.2.85

package/dist/utilities/pngSvgCategories.d.ts

@@ -0,0 +1,168 @@
+export declare const pngSvgCategories: {
+    Logo: {
+        Outline: {
+            alias: string;
+        };
+        Monogram: {
+            alias: string;
+        };
+        Wordmark: {
+            alias: string;
+        };
+        Emblem: {
+            alias: string;
+        };
+        "Abstract Logo": {
+            alias: string;
+        };
+        Mascot: {
+            alias: string;
+        };
+    };
+    Icons: {
+        Outline: {
+            alias: string;
+        };
+        Pictogram: {
+            alias: string;
+        };
+        "Broken Line": {
+            alias: string;
+        };
+        "Gradient Line": {
+            alias: string;
+        };
+        "Gradient Shape": {
+            alias: string;
+        };
+        Doodle: {
+            alias: string;
+        };
+        Flat: {
+            alias: string;
+        };
+        Minimalistic: {
+            alias: string;
+        };
+        Isometric: {
+            alias: string;
+        };
+        "3D Icons": {
+            alias: string;
+        };
+    };
+    Illustrations: {
+        "Hand Drawn": {
+            alias: string;
+        };
+        Glow: {
+            alias: string;
+        };
+        "Pixel Art": {
+            alias: string;
+        };
+        Watercolour: {
+            alias: string;
+        };
+        Psychedelic: {
+            alias: string;
+        };
+        "80's": {
+            alias: string;
+        };
+        "Digital Art": {
+            alias: string;
+        };
+        Abstract: {
+            alias: string;
+        };
+        Realistic: {
+            alias: string;
+        };
+        "Comic Style": {
+            alias: string;
+        };
+        Fantasy: {
+            alias: string;
+        };
+        Anime: {
+            alias: string;
+        };
+        Minimalist: {
+            alias: string;
+        };
+        "Pencil Sketch": {
+            alias: string;
+        };
+    };
+    "3D illustration": {
+        Wireframe: {
+            alias: string;
+        };
+        "Low Poly": {
+            alias: string;
+        };
+        "Cartoon 3D": {
+            alias: string;
+        };
+        "Plastic 3D": {
+            alias: string;
+        };
+        "3D render": {
+            alias: string;
+        };
+    };
+    Photorealism: {
+        "Photorealistic Painting": {
+            alias: string;
+        };
+        "Photorealistic Drawing": {
+            alias: string;
+        };
+        Hyperealism: {
+            alias: string;
+        };
+        Photorealism: {
+            alias: string;
+        };
+    };
+    "Vector Art": {
+        "Line Art": {
+            alias: string;
+        };
+        Cartoon: {
+            alias: string;
+        };
+        "Vector Kawai": {
+            alias: string;
+        };
+        Linocut: {
+            alias: string;
+        };
+        Engraving: {
+            alias: string;
+        };
+        "Doodle Line Art": {
+            alias: string;
+        };
+        Geometric: {
+            alias: string;
+        };
+        Abstract: {
+            alias: string;
+        };
+        Vintage: {
+            alias: string;
+        };
+        Minimalist: {
+            alias: string;
+        };
+        Stylized: {
+            alias: string;
+        };
+        "Flat Design": {
+            alias: string;
+        };
+    };
+};
+//# sourceMappingURL=pngSvgCategories.d.ts.map

package/dist/utilities/pngSvgCategories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pngSvgCategories.d.ts","sourceRoot":"","sources":["../../src/utilities/pngSvgCategories.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsK5B,CAAA"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "biz-slide-core",
-  "version": "1.2.83",
+  "version": "1.2.85",
   "description": "",
+  "main": "dist/index.js",
   "scripts": {
     "build": "tsc",
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/entity/analytic.entity.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,56 @@
+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);