jp-shared 1.0.0

package/models/candidate-models/mobileOTPModel.js

@@ -0,0 +1,75 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+const {
+  Schema,
+  Types: { ObjectId },
+} = mongoose;
+
+// Define the schema
+const schema = new Schema(
+  {
+    candidateId: {
+      type: ObjectId,
+      required: [true, "Candidate ID is required"],
+    },
+    OTP: {
+      type: String,
+      required: [true, "OTP is required"],
+      maxlength: [6, "OTP must be 6 digits"],
+    },
+    requests: [
+      {
+        mobileNumber: {
+          type: String,
+          required: [true, "Mobile number is required"],
+          match: [/^\d{10}$/, "Mobile number must be exactly 10 digits"],
+        },
+        countryCode: {
+          type: String,
+          required: [true, "Country code is required"],
+          enum: ["+91"], // Consider expanding this if needed
+        },
+        createdAt: {
+          type: Date,
+          required: [true, "Request date is required"],
+          default: Date.now,
+        },
+        attempts: {
+          type: Number,
+          default: 0, // Initialize attempts with 0
+          min: [0, "Attempts cannot be negative"],
+        },
+        successful: {
+          type: Boolean,
+          default: false,
+        },
+      },
+    ],
+    deleteAt: {
+      type: Date,
+      required: [true, "DeleteAt date is required"],
+      validate: {
+        validator: function (v) {
+          return v > new Date(); // Ensure deleteAt is in the future
+        },
+        message: "DeleteAt must be a future date.",
+      },
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+// Ensure TTL index is created
+// Ensure deleteAt index is created (for document expiry)
+schema.index({ deleteAt: 1 }, { expireAfterSeconds: 0 });
+
+// Consider adding indexes for frequently queried fields
+schema.index({ candidateId: 1 });
+schema.index({ mobileNumber: 1 });
+schema.index({ countryCode: 1 });
+
+const CandidateMobileOTPModel = mongoose.connection
+  .useDb(getDatabaseName())
+  .model("candidate-mobile-otp", schema);
+
+module.exports = CandidateMobileOTPModel;

package/models/candidate-models/otpModel.js

@@ -0,0 +1,75 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+const {
+  Schema,
+  Types: { ObjectId },
+} = mongoose;
+
+const schema = new Schema(
+  {
+    candidateId: { type: ObjectId, required: true },
+    contactInfo: {
+      type: String,
+      required: [
+        true,
+        "Contact information (email or mobile number) is required",
+      ],
+      validate: {
+        validator: function (v) {
+          const emailRegex = /^\S+@\S+\.\S+$/;
+          const mobileRegex = /^\d{10}$/;
+          return emailRegex.test(v) || mobileRegex.test(v);
+        },
+        message:
+          "Invalid contact information. Must be a valid email address or a 10-digit mobile number.",
+      },
+    },
+    type: {
+      type: String,
+      enum: ["email", "mobile"],
+      required: [true, "OTP type (email or mobile) is required"],
+    },
+    purpose: {
+      type: String,
+      enum: ["creation", "change"],
+      required: [true, "Purpose (creation or change) is required"],
+    },
+    OTP: {
+      type: Number,
+      required: [true, "OTP is required"],
+      minlength: [4, "OTP must be at least 4 digits long"],
+      maxlength: [6, "OTP must be at most 6 digits long"],
+      match: [/^\d{4,6}$/, "OTP must be 4 to 6 digits long"],
+    },
+    expiryDate: {
+      type: Date,
+      required: [true, "Expiry date is required"],
+    },
+    attempts: {
+      type: Number,
+      default: 0,
+      required: [true, "Attempts count is required"],
+      min: [0, "Attempts count cannot be negative"],
+    },
+    deleteAt: {
+      type: Date,
+      required: [true, "Deletion time is required"], // TTL field for automatic deletion
+      validate: {
+        validator: function (v) {
+          return v > this.expiryDate;
+        },
+        message: "Deletion time must be after the expiry date.",
+      },
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+// Ensure TTL index is created
+schema.index({ deleteAt: 1 }, { expireAfterSeconds: 0 });
+
+const CandidateOTPModel = mongoose.connection
+  .useDb(getDatabaseName())
+  .model("recruiter-otp", schema);
+
+module.exports = CandidateOTPModel;

package/models/candidate-models/requestModel.js

@@ -0,0 +1,26 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    fullName: { type: String, required: true },
+    email: { type: String, required: true },
+    password: { type: String, required: true },
+    expireAt: {
+      type: Date,
+      default: () => new Date(+new Date() + 60 * 60 * 1000), // Set to expire after one hour
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: false } }
+);
+
+// Create the TTL index
+schema.index({ expireAt: 1 }, { expireAfterSeconds: 0 });
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const CandidateRequestModel = myDB.model("candidate-request", schema);
+
+module.exports = CandidateRequestModel;

package/models/candidate-models/savedJobModel.js

@@ -0,0 +1,20 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    candidateId: { type: ObjectId, required: true },
+    jobPostId: { type: ObjectId, required: true },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const CandidateSavedJobModel = myDB.model("candidate-saved-job", schema);
+
+module.exports = CandidateSavedJobModel;

package/models/candidate-models/searchAppearanceModel.js

@@ -0,0 +1,50 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+const Schema = mongoose.Schema;
+
+const SearchAppearanceSchema = new Schema(
+  {
+    recruiterId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "recruiter",
+      required: true,
+    },
+    candidateId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "candidate",
+      required: true,
+    },
+    appearanceCount: {
+      type: Number,
+      default: 1,
+    },
+    // Field to track expiration date
+    expiresAt: {
+      type: Date,
+      required: true,
+      default: () => {
+        // Set the default expiration time to 30 days from now
+        return new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
+      },
+    },
+  },
+  { timestamps: true } // Adds createdAt and updatedAt fields
+);
+
+// Add an index to improve performance of frequent searches
+SearchAppearanceSchema.index(
+  { recruiterId: 1, candidateId: 1 },
+  { unique: true }
+);
+
+// Create a TTL index on the expiresAt field
+SearchAppearanceSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const SearchAppearanceModel = myDB.model(
+  "search-appearance-history",
+  SearchAppearanceSchema
+);
+
+module.exports = SearchAppearanceModel;

package/models/candidate-models/tokenModel.js

@@ -0,0 +1,20 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const schema = new mongoose.Schema(
+  {
+    candidateId: { type: mongoose.Schema.Types.ObjectId, required: true },
+    sessionId: { type: String, required: true },
+  },
+  {
+    timestamps: true, // Adds createdAt and updatedAt fields
+  }
+);
+
+const myDB = mongoose.connection.useDb("OA_Job_Portal_API");
+
+schema.index({ candidateId: 1, sessionId: 1 });
+
+const CandidateToken = myDB.model(getDatabaseName, schema);
+
+module.exports = { CandidateToken };

package/models/common-models/course-model.js

@@ -0,0 +1,20 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    educationId: { type: ObjectId, required: true },
+    label: { type: String, required: true },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const CourseModel = myDB.model("course", schema);
+
+module.exports = CourseModel;

package/models/common-models/downloadedResumeHistory-model.js

@@ -0,0 +1,54 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    candidateId: {
+      type: ObjectId,
+      required: [true, "Candidate ID is required"],
+      validate: {
+        validator: (value) => mongoose.isValidObjectId(value),
+        message: "Invalid Candidate ID",
+      },
+    },
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+      validate: {
+        validator: (value) => mongoose.isValidObjectId(value),
+        message: "Invalid Recruiter ID",
+      },
+    },
+    organizationId: {
+      type: ObjectId,
+      required: [true, "Organization ID is required"],
+      validate: {
+        validator: (value) => mongoose.isValidObjectId(value),
+        message: "Invalid Organization ID",
+      },
+    },
+    createdAt: {
+      type: Date,
+      default: Date.now,
+    },
+  },
+  {
+    timestamps: true, // Automatically creates createdAt and updatedAt fields
+  }
+);
+
+// Define the TTL index for the createdAt field
+schema.index({ createdAt: 1 }, { expireAfterSeconds: 2592000 }); // 30 days in seconds
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const DownloadedResumeHistoryModel = myDB.model(
+  "downloaded-resume-history",
+  schema
+);
+
+module.exports = DownloadedResumeHistoryModel;

package/models/common-models/education-model.js

@@ -0,0 +1,17 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    label: { type: String, required: true },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const EducationModel = myDB.model("education", schema);
+
+module.exports = EducationModel;

package/models/common-models/index.js

@@ -0,0 +1,19 @@
+module.exports = {
+  EducationModel: require("./education-model"),
+  CourseModel: require("./course-model"),
+  JobApplicationModel: require("./jobApplication-model"),
+  JobApprochModel: require("./jobApproach-model"),
+  JobTypeModel: require("./jobType-model"),
+  NoticePeriodModel: require("./noticePeriod"),
+  RoleModel: require("./role-model"),
+  SkillModel: require("./skill-model"),
+  SearchAppearanceHistoryModel: require("./searchAppearanceHistory-model"),
+  AdmissionModel: require("./sms-student-model"),
+  ViewedProfileHistory: require("./viewedProfileHistory-model"),
+  SpecializationModel: require("./specialization-model"),
+  SpeakingLanguageModel: require("./speakingLanguage"),
+  JobOfferModel: require("./jobOffer-model"),
+  PlanModel: require("./plan-model"),
+  DownloadedResumeHistoryModel: require("./downloadedResumeHistory-model"),
+  PaymentHistoryModel: require("./paymentHistory-model"),
+};

package/models/common-models/jobApplication-model.js

@@ -0,0 +1,57 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema with status as an array of objects
+const schema = new mongoose.Schema(
+  {
+    candidateId: {
+      type: ObjectId,
+      required: true,
+      validate: {
+        validator: mongoose.Types.ObjectId.isValid,
+        message: "Invalid candidate ID format.",
+      },
+    },
+    jobPostId: {
+      type: ObjectId,
+      required: true,
+      validate: {
+        validator: mongoose.Types.ObjectId.isValid,
+        message: "Invalid job post ID format.",
+      },
+    },
+    status: {
+      type: [
+        {
+          process: {
+            type: String,
+            required: true,
+            enum: ["sent", "viewed", "shortlisted"],
+          },
+          createdAt: {
+            type: Date,
+            required: true,
+            default: Date.now,
+          },
+        },
+      ],
+      default: [{ process: "sent", createdAt: Date.now() }],
+      validate: {
+        validator: function (value) {
+          return value.length <= 3;
+        },
+        message: "Status array can contain a maximum of 3 objects.",
+      },
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const JobApplicationModel = myDB.model("job-application", schema);
+
+module.exports = JobApplicationModel;

package/models/common-models/jobApproach-model.js

@@ -0,0 +1,14 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema({
+  jobApproach: { type: String, required: true },
+});
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const JobApprochModel = myDB.model("job-approach", schema);
+
+module.exports = JobApprochModel;

package/models/common-models/jobOffer-model.js

@@ -0,0 +1,20 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    candidateId: { type: ObjectId, required: true },
+    jobPostId: { type: ObjectId, required: true },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const JobOfferModel = myDB.model("job-offer", schema);
+
+module.exports = JobOfferModel;

package/models/common-models/jobType-model.js

@@ -0,0 +1,22 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema({
+  jobType: { type: String, required: true },
+});
+
+// Modify the toJSON method to exclude __v
+schema.set("toJSON", {
+  transform: (doc, ret) => {
+    delete ret.__v;
+    return ret;
+  },
+});
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const JobTypeModel = myDB.model("jobType", schema);
+
+module.exports = JobTypeModel;

package/models/common-models/noticePeriod.js

@@ -0,0 +1,14 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema({
+  noticePeriod: { type: String, required: true },
+});
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const NoticePeriodModel = myDB.model("notice-period", schema);
+
+module.exports = NoticePeriodModel;

package/models/common-models/paymentHistory-model.js

@@ -0,0 +1,128 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const paymentHistorySchema = new mongoose.Schema(
+  {
+    billNumber: {
+      type: String,
+      required: true,
+      trim: true,
+      unique: true, // Ensure bill numbers are unique
+      match: /^OAJP\d+$/, // Regular expression to match "OAJP" followed by digits
+      minlength: 5,
+      maxlength: 20, // Adjust this as per your requirements
+    },
+    jobPostId: {
+      type: ObjectId,
+      required: true,
+    },
+    recruiterId: {
+      type: ObjectId,
+      required: true,
+    },
+    organizationId: {
+      type: ObjectId,
+      required: true,
+    },
+    amount: {
+      type: Number,
+      required: true,
+      min: 0, // Ensure amount is non-negative
+    },
+    planName: {
+      type: String,
+      required: true,
+      trim: true,
+      maxlength: 100, // Limit the length of plan name
+    },
+    maxApplicant: {
+      type: Number,
+      required: true,
+      min: 0, // Ensure non-negative value
+    },
+    userAccessCount: {
+      type: Number,
+      required: true,
+      min: 0, // Ensure non-negative value
+    },
+    candidateLastActiveMonth: {
+      type: Number,
+      required: true,
+      min: 0, // Ensure non-negative value
+    },
+    maxResult: {
+      type: Number,
+      required: true,
+      min: 0, // Ensure non-negative value
+    },
+    maxProfileView: {
+      type: Number,
+      required: true,
+      min: 0, // Ensure non-negative value
+    },
+    isDownloadResume: {
+      type: Boolean,
+      default: false,
+    },
+    isFilter: {
+      type: Boolean,
+      default: false,
+    },
+    isTag: {
+      type: Boolean,
+      default: false,
+    },
+    minValidityDay: {
+      type: Number,
+      required: true,
+      min: 1, // Minimum validity should be at least 1 day
+    },
+    maxValidityDay: {
+      type: Number,
+      required: true,
+      min: 1, // Minimum validity should be at least 1 day
+    },
+    isFree: {
+      type: Boolean,
+      required: [true, "isFree field is required"],
+      default: false, // Assuming plans are paid by default
+    },
+    isJobOffer: {
+      type: Boolean,
+      required: [true, "Job offer status is required"],
+    },
+    jobOfferDiscountPercentage: {
+      type: Number,
+      required: function () {
+        return this.isJobOffer === true; // Only required if isJobOffer is true
+      },
+      min: [1, "Discount percentage must be greater than 1%"],
+      max: [99, "Discount percentage must be less than or equal to 99%"],
+      validate: {
+        validator: function (value) {
+          // Allow null when isJobOffer is false
+          return this.isJobOffer === true ? value !== null : true;
+        },
+        message: "Discount percentage is required when isJobOffer is true",
+      },
+    },
+  },
+  {
+    timestamps: true, // Automatically manage createdAt and updatedAt
+  }
+);
+
+// Indexing frequently queried fields for performance
+paymentHistorySchema.index({ recruiterId: 1 });
+paymentHistorySchema.index({ organizationId: 1 });
+
+// Connect to the specific database
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const PaymentHistoryModel = myDB.model("payment-history", paymentHistorySchema);
+
+module.exports = PaymentHistoryModel;