my-typescript-library-rahul52us 1.3.4 → 1.3.6

package/src/repository/schemas/accounts.schema.ts

@@ -1,39 +1,40 @@
 import mongoose, { Schema, Document, Model } from "mongoose";
 import passportLocalMongoose from "passport-local-mongoose";
 
-// Define the Account Interface
-export interface IAccount extends Document {
+// Interface definition for the Account Document
+interface IAccount extends Document {
   name: string;
   username: string;
   moNumber: string;
-  role?: string; // Changed to `string` since it appears to represent roles like "admin"
+  role?: string;
   userType?: string;
   approvalType?: string;
   avatarUrl?: string;
   is_active?: boolean;
-  createdAt?: string;
-  updatedAt?: string;
-  deletedAt?: string;
-  company?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  deletedAt?: Date;
+  company?: mongoose.Types.ObjectId;
   permission?: string[];
-  setPassword(password: string, cb: (err: any, user: this) => void): void;
-  clientOrg?: string; // Fixed the incorrect type definition
+  clientOrg?: string;
+
+  // Added missing fields
+  designation?: string;
+  level?: string;
+  defaultWorkflow?: mongoose.Types.ObjectId;
+  userPermission?: string[];
 }
 
-// Define the Account Model Interface with Static Methods from passport-local-mongoose
+// Extend the Mongoose Model interface to include `register`
 interface IAccountModel extends Model<IAccount> {
-  register(user: Partial<IAccount>, password: string): Promise<IAccount>;
-  authenticate(): (
-    username: string,
-    password: string,
-    cb: (err: any, user?: IAccount | false) => void
-  ) => void;
-  serializeUser(): (user: IAccount, done: (err: any, id?: any) => void) => void;
-  deserializeUser(): (id: any, done: (err: any, user?: IAccount | null) => void) => void;
-}
+  register(email: string, password: string): Promise<IAccount>;
+  authenticate: any;
+  serializeUser: any;
+  deserializeUser: any;
 
-// Define the Mongoose Schema
-const AccountSchema: Schema = new Schema({
+}
+// Define your schema
+const AccountSchema: Schema = new mongoose.Schema<IAccount>({
   name: {
     type: String,
     trim: true,
@@ -44,14 +45,14 @@ const AccountSchema: Schema = new Schema({
     trim: true,
     lowercase: true,
     unique: true,
-    required: [true, "Email address is required"],
+    required: [true, 'Email address is required'],
   },
   designation: {
     type: String,
   },
   userType: {
     type: String,
-    default: "user",
+    default: 'user',
   },
   role: {
     type: String,
@@ -59,7 +60,7 @@ const AccountSchema: Schema = new Schema({
   },
   level: {
     type: String,
-    default: "admin",
+    default: 'admin',
   },
   avatarUrl: {
     type: String,
@@ -79,12 +80,12 @@ const AccountSchema: Schema = new Schema({
     type: Date,
   },
   company: {
-    type: mongoose.Types.ObjectId,
-    ref: "Organisation",
+    type: mongoose.Schema.Types.ObjectId, // Fixed type issue here
+    ref: 'Organisation',
   },
   defaultWorkflow: {
     type: mongoose.Schema.Types.ObjectId,
-    ref: "WorkFlow",
+    ref: 'WorkFlow',
   },
   permission: {
     type: [String],
@@ -94,7 +95,7 @@ const AccountSchema: Schema = new Schema({
   },
 });
 
-// Add passport-local-mongoose Plugin
+// Apply the passportLocalMongoose plugin
 AccountSchema.plugin(passportLocalMongoose);
 
 let AccountModel: IAccountModel;
@@ -105,6 +106,4 @@ if (mongoose.models.Account) {
   AccountModel = mongoose.model<IAccount, IAccountModel>("Account", AccountSchema);
 }
 
-export default AccountModel;
-
-
+export default AccountModel;

package/src/repository/schemas/document.schema.ts

@@ -1,4 +1,4 @@
-import mongoose, { Schema } from "mongoose";
+import mongoose, { Schema, Document } from "mongoose";
 
 export interface IDocument extends Document {
   documentId?: string;
@@ -13,7 +13,9 @@ export interface IDocument extends Document {
   user?: string;
   tags?: any;
   additionalFiles?: any;
+  isguaranteed?:boolean
 }
+
 export interface IApproval extends Document {
   comment?: string;
   status: string;
@@ -22,7 +24,7 @@ export interface IApproval extends Document {
   userId?: mongoose.Types.ObjectId;
   createdAt: any;
 }
-export const ApprovalSchema: Schema = new mongoose.Schema({
+const ApprovalSchema: Schema = new mongoose.Schema({
   comment: {
     type: String,
     default: "",
@@ -55,7 +57,7 @@ export const ApprovalSchema: Schema = new mongoose.Schema({
   },
   createdAt: {
     type: Date,
-    default: new Date(),
+    default : new Date()
   },
   updatedAt: {
     type: Date,
@@ -71,17 +73,9 @@ export const DocumentSchema: Schema = new mongoose.Schema({
     type: mongoose.Schema.Types.ObjectId,
     default: "WorkFlow",
   },
-  partnerName : {
-    type : String,
-    default : ""
-  },
-  partnerId : {
-    type : String,
-    default : ""
-  },
-  order_taken_by:{
-    type : String,
-    default : ""
+  isguaranteed:{
+    type : Boolean,
+    default : false
   },
   company: {
     type: mongoose.Schema.Types.ObjectId,
@@ -135,6 +129,7 @@ export const DocumentSchema: Schema = new mongoose.Schema({
   },
   status: {
     type: String,
+    default : 'pending'
   },
   helpInfo: {
     type: mongoose.Schema.Types.Mixed,
@@ -142,14 +137,16 @@ export const DocumentSchema: Schema = new mongoose.Schema({
   }
 });
 
-let DocumentModel: mongoose.Model<IDocument> | null = null;
+
+let DocumentModal: mongoose.Model<any> | null = null;
 
 if (mongoose.models.Document) {
   console.log("Document model already exists.");
-  DocumentModel = mongoose.models.Document;
+  DocumentModal = mongoose.models.Document;
 } else {
   console.log("Creating Document model fallback.");
-  DocumentModel = mongoose.model<IDocument>("Document", DocumentSchema);
+  DocumentModal = mongoose.model<any>("Document", DocumentSchema);
 }
 
-export default DocumentModel
+export default DocumentModal;
+

package/src/repository/schemas/extracted.schema.ts

@@ -1,38 +1,35 @@
-import mongoose, { Schema, Document } from "mongoose";
+import mongoose, { Schema, Document, Date } from "mongoose";
 
-// Define the interface for Extracted
 export interface IExtracted extends Document {
-  created_At?: Date;
-  updated_At?: Date;
-  deleted_At?: Date;
-  fileId?: mongoose.Types.ObjectId;
-  data: Record<string, any>;
+    created_At?: Date;
+    updated_At?: Date;
+    deleted_At?: Date;
+    fileId?: string;
+    data: object;
 }
 
-// Define the extracted schema
-const extractedSchema: Schema = new Schema({
-  created_At: {
-    type: Date,
-    default: Date.now,
-  },
-  updated_At: {
-    type: Date,
-    default: Date.now,
-  },
-  deleted_At: {
-    type: Date,
-  },
-  fileId: {
-    type: mongoose.Types.ObjectId,
-    ref: "fs.files",
-  },
-  data: {
-    type: Object,
-    required: true,
-  },
-});
+const extractedSchema = new Schema({
+    created_At: {
+        type: Date,
+        default: Date.now,
+    },
+    updated_At: {
+        type: Date,
+        default: Date.now,
+    },
+    deleted_At: {
+        type: Date,
+    },
+    fileId: {
+        type: mongoose.Types.ObjectId,
+        ref: "fs.files"
+    },
+    data: {
+        type: Object,
+        required: true
+    }
+})
 
-// Handle model initialization
 let ExtractedModel: mongoose.Model<IExtracted> | null = null;
 
 if (mongoose.models.Extracted) {
@@ -43,4 +40,4 @@ if (mongoose.models.Extracted) {
   ExtractedModel = mongoose.model<IExtracted>("Extracted", extractedSchema);
 }
 
-export default ExtractedModel;
+export default ExtractedModel;

package/src/repository/schemas/fileSystem.schema.ts

@@ -1,30 +1,27 @@
 import mongoose, { Document, Model, Schema } from "mongoose";
 
-// Define the TypeScript Interface for the Schema
-export interface IFileSystemSchema extends Document {
+interface IfileSystemSchema extends Document {
   fileId: mongoose.Types.ObjectId;
 }
 
-// Define the Mongoose Schema
-export const fileSystemSchema: Schema = new Schema(
+const fileSystemSchema: Schema = new Schema(
   {
     fileId: {
       type: mongoose.Types.ObjectId,
       index: true,
-      required: true, // Ensure it's a required field to align with interface expectations
     },
   },
   { timestamps: true }
 );
 
 // Handle Model Initialization
-let FileSystemModel: Model<IFileSystemSchema> | null = null;
+let FileSystemModel: Model<any> | null = null;
 
 // Check if the model already exists to avoid overwriting during hot reloads
 if (mongoose.models.FileSystem) {
   FileSystemModel = mongoose.models.FileSystem;
 } else {
-  FileSystemModel = mongoose.model<IFileSystemSchema>("FileSystem", fileSystemSchema);
+  FileSystemModel = mongoose.model<any>("FileSystem", fileSystemSchema);
 }
 
 export default FileSystemModel;

package/src/repository/schemas/form.schema.ts

@@ -31,5 +31,4 @@ const formSchema = new mongoose.Schema({
     },
 })
 
-export default mongoose.models.Form || mongoose.model('Form', formSchema);
-
+export default mongoose.model('Form',formSchema)

package/src/repository/schemas/log.schema.ts

@@ -1,28 +1,26 @@
 import mongoose, { Schema, Document } from "mongoose";
 
-// Define interface
 export interface ILog extends Document {
   message: string;
   type: string;
   logtype: string;
   created_At: Date;
-  company?: string; // Made optional
-  user?: string; // Made optional
+  company?: string;
+  user?: string;
   statuscode?: number;
 }
 
-// Define schema
 export const LogSchema: Schema = new mongoose.Schema({
   statuscode: {
     type: Number,
   },
   message: {
     type: String,
-    required: [true, "Message is required"], // Ensure message is required
   },
   type: {
     type: String,
-    required: [true, "Type is required"],
+    value: String,
+    required: [true, "type is required"],
     enum: ["log", "error", "warning", "info", "success"],
   },
   logtype: {
@@ -31,10 +29,12 @@ export const LogSchema: Schema = new mongoose.Schema({
   },
   company: {
     type: mongoose.Types.ObjectId,
+    required: [true, "User is not logged in"],
     ref: "Organisation",
   },
   user: {
     type: mongoose.Types.ObjectId,
+    required: [true, "User is not logged in"],
     ref: "Account",
   },
   created_At: {
@@ -43,7 +43,6 @@ export const LogSchema: Schema = new mongoose.Schema({
   },
 });
 
-// Model initialization safely
 let LogModal: mongoose.Model<ILog>;
 
 if (mongoose.models.Log) {

package/src/repository/schemas/notifications.schema.ts

@@ -1,6 +1,5 @@
 import mongoose, { Schema, Document } from "mongoose";
 
-// Interface for type safety
 export interface INotifications extends Document {
   role?: string;
   user?: string;
@@ -12,7 +11,6 @@ export interface INotifications extends Document {
   deletedAt?: any;
 }
 
-// Define Notifications Schema
 const NotificationsSchema: Schema = new mongoose.Schema(
   {
     workflow: {
@@ -37,9 +35,9 @@ const NotificationsSchema: Schema = new mongoose.Schema(
         ref: "Account",
       },
     ],
-    notificationType: {
+    type: {
       type: String,
-      required: true,
+      default: null,
     },
     documentId: {
       type: String,

package/src/repository/schemas/organisation.schema.ts

@@ -1,12 +1,11 @@
 import mongoose, { Schema, Document } from "mongoose";
 
-// Interfaces
-export interface IGSTInformation {
+interface IGSTInformation {
   gsttreatment: string;
   businessgst: string;
 }
 
-export type Address = {
+type address = {
   billing?: {
     street: string;
     city: string;
@@ -24,22 +23,20 @@ export type Address = {
     phone: string;
   };
 };
-
-export interface IComplianceItem {
-  date: string;
-  status: string;
-  moreinfo: string;
-}
-
-export interface ICompliance {
+interface ICompliance {
   type: string;
   file: string;
   info: object;
   compliant: IComplianceItem[];
 }
 
-// Organisation interface extending Document
-export interface IOrganisation extends Document {
+interface IComplianceItem {
+  date: string;
+  status: string;
+  moreinfo: string;
+}
+
+interface IOrganisation extends Document {
   name: string;
   compliances: ICompliance[];
   domain?: string;
@@ -47,14 +44,13 @@ export interface IOrganisation extends Document {
   gstin: string;
   pan?: string;
   license: string;
-  address: Address;
+  address: address;
   gstinformation?: IGSTInformation[];
   customerOrg?: string;
-  deposits?: Record<string, any>;
+  deposits?: object;
 }
 
-// Define Organisation schema
-const OrganisationSchema: Schema = new Schema({
+const OrganisationSchema: Schema = new mongoose.Schema({
   name: {
     type: String,
     trim: true,
@@ -65,19 +61,27 @@ const OrganisationSchema: Schema = new Schema({
   compliances: {
     type: [
       {
-        type: String,
-        file: String,
-        info: Schema.Types.Mixed,
+        file: {
+          type: String,
+        },
+        info: {
+          type: Object,
+        },
         compliant: [
           {
-            date: String,
-            status: String,
-            moreinfo: String,
+            date: {
+              type: String,
+            },
+            status: {
+              type: String,
+            },
+            moreinfo: {
+              type: String,
+            },
           },
         ],
       },
     ],
-    default: [],
   },
   gstin: {
     type: String,
@@ -107,34 +111,24 @@ const OrganisationSchema: Schema = new Schema({
   },
   address: {
     billing: {
-      street: { type: String },
-      city: { type: String },
-      state: { type: String },
-      pin: { type: String },
-      country: { type: String },
-      phone: { type: String },
+      type: Object,
     },
     shipping: {
-      street: { type: String },
-      city: { type: String },
-      state: { type: String },
-      pin: { type: String },
-      country: { type: String },
-      phone: { type: String },
+      type: Object,
     },
   },
   bankDetails: {
-    type: Schema.Types.Mixed,
+    type: Object,
   },
   deposits: {
-    type: Schema.Types.Mixed,
+    type: Object,
   },
   certificates: {
     msme: [
       {
         files: [
           {
-            type: mongoose.Schema.Types.ObjectId,
+            type: Schema.Types.ObjectId,
             ref: "fs.files",
           },
         ],
@@ -144,7 +138,7 @@ const OrganisationSchema: Schema = new Schema({
       {
         files: [
           {
-            type: mongoose.Schema.Types.ObjectId,
+            type: Schema.Types.ObjectId,
             ref: "fs.files",
           },
         ],
@@ -154,30 +148,29 @@ const OrganisationSchema: Schema = new Schema({
       {
         files: [
           {
-            type: mongoose.Schema.Types.ObjectId,
+            type: Schema.Types.ObjectId,
             ref: "fs.files",
           },
         ],
       },
     ],
     cancelledCheque: [
-      {
-        files: [
-          {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: "fs.files",
-          },
-        ],
-      },
+        {
+          files: [
+            {
+              type: Schema.Types.ObjectId,
+              ref: "fs.files",
+            },
+          ],
+        },
     ],
   },
   customerOrg: {
     type: mongoose.Schema.Types.ObjectId,
-    ref: "Organisation",
+    ref: "organisation",
   },
 });
 
-// Export the mongoose model with generic typing and fallback logic
 let OrganisationModel: mongoose.Model<IOrganisation>;
 
 if (mongoose.models.Organisation) {

package/src/repository/schemas/profile.schema.ts

@@ -62,5 +62,4 @@ const profileSchema: Schema = new mongoose.Schema({
     }
 })
 
-export default mongoose.models.Profile || mongoose.model('Profile', profileSchema);
-
+export default mongoose.model<profile>('Profile', profileSchema)

package/src/repository/schemas/role.schema.ts

@@ -42,5 +42,4 @@ const RoleSchema: Schema = new mongoose.Schema({
     }
 });
 
-export default mongoose.models.Role || mongoose.model('Role', RoleSchema);
-
+export default mongoose.model<IRole>('Role', RoleSchema);

package/src/repository/schemas/tokens.schema.ts

@@ -1,25 +1,25 @@
 import mongoose, { Schema, Document } from "mongoose";
 
 interface ISession extends Document {
-  userId: Schema.Types.ObjectId;
-  type: string;
-  created_at: Date;
-}
+    userId: Schema.Types.ObjectId;
+    type: string;
+    created_at: Date;
+};
 
 const TokensSchema: Schema = new mongoose.Schema({
-  userId: {
-    type: Schema.Types.ObjectId,
-    required: true,
-  },
-  type: {
-    type: String,
-    required: true,
-  },
-  created_at: {
-    type: Date,
-    default: Date.now,
-  },
-});
+    userId: {
+        type: Schema.Types.ObjectId,
+        required: true
+    },
+    type: {
+        type: String
+    },
+    created_at:{
+        type: Date,
+        default: Date.now
+    }
+
+})
 
 // Safe way to dynamically fetch or initialize the model
 let TokenModel : any = null;
@@ -32,6 +32,4 @@ if (mongoose.models.Token) {
   TokenModel = mongoose.model<ISession>('Token', TokensSchema);
 }
 
-export default TokenModel;
-
-
+export default TokenModel;

package/src/repository/schemas/userrole.schema.ts

@@ -89,5 +89,4 @@ const UserRoleSchema: Schema = new mongoose.Schema({
     }
 });
 
-export default mongoose.models.UserRole || mongoose.model('UserRole', UserRoleSchema);
-
+export default mongoose.model<IUserRole>('UserRole', UserRoleSchema);