jp-shared 1.0.0

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

@@ -0,0 +1,144 @@
+const mongoose = require("mongoose");
+const { isIntegerValidator } = require("../../utils");
+const { getDatabaseName } = require("../../constants");
+
+const planSchema = new mongoose.Schema({
+  planName: {
+    type: String,
+    required: [true, "Plan name is required"],
+    minlength: [3, "Plan name must be at least 3 characters long"],
+    maxlength: [100, "Plan name cannot exceed 100 characters"],
+    trim: true,
+  },
+  maxApplicant: {
+    type: Number,
+    required: [true, "Number of applicants is required"],
+    min: [0, "Applicants count must be a positive number"],
+    validate: isIntegerValidator,
+  },
+  amount: {
+    type: Number,
+    required: [true, "Amount is required"],
+    min: [0, "Amount must be a positive number"],
+    validate: isIntegerValidator,
+  },
+  isFree: {
+    type: Boolean,
+    required: [true, "isFree field is required"],
+    default: false, // Assuming plans are paid by default
+  },
+  userAccessCount: {
+    type: Number,
+    required: [true, "User access count is required"],
+    min: [1, "User access count must be at least 1"],
+    validate: isIntegerValidator,
+  },
+  candidateLastActiveMonth: {
+    type: Number,
+    required: [true, "Candidate last active month is required"],
+    min: [1, "Candidate last active month must be between 1 and 12"],
+    max: [12, "Candidate last active month must be between 1 and 12"],
+  },
+  maxResult: {
+    type: Number,
+    required: [true, "Search result count is required"],
+    min: [0, "Search result count must be a positive number"],
+    validate: isIntegerValidator,
+  },
+  maxProfileView: {
+    type: Number,
+    required: [true, "Maximum profile view count is required"],
+    min: [0, "Maximum profile view count must be a positive number"],
+    validate: isIntegerValidator,
+  },
+  isBooleanKeywordSearch: {
+    type: Boolean,
+    required: [true, "Boolean keyword search availability is required"],
+  },
+  isDownloadResume: {
+    type: Boolean,
+    required: [true, "Resume download availability is required"],
+  },
+  isFilter: {
+    type: Boolean,
+    required: [true, "Filter feature availability is required"],
+  },
+  isTag: {
+    type: Boolean,
+    required: [true, "Tag feature availability is required"],
+  },
+  minValidityDay: {
+    type: Number,
+    required: [true, "Minimum validity day is required"],
+    min: [1, "Minimum validity day must be a positive number"],
+    validate: [
+      isIntegerValidator,
+      {
+        validator: function (value) {
+          return !this.maxValidityDay || value < this.maxValidityDay;
+        },
+        message: "Minimum validity day must be less than maximum validity day",
+      },
+    ],
+  },
+  maxValidityDay: {
+    type: Number,
+    required: [true, "Maximum validity day is required"],
+    min: [1, "Maximum validity day must be a positive number"],
+    validate: [
+      isIntegerValidator,
+      {
+        validator: function (value) {
+          return !this.minValidityDay || value > this.minValidityDay;
+        },
+        message:
+          "Maximum validity day must be greater than minimum validity day",
+      },
+    ],
+  },
+  isJobOffer: {
+    type: Boolean,
+    required: [true, "Job offer status is required"],
+    validate: {
+      validator: function () {
+        return this.isFree === false || this.isJobOffer === false;
+      },
+      message: "isJobOffer can only be true if isFree is false",
+    },
+  },
+  jobOfferDetails: {
+    jobOfferValidity: {
+      type: Date,
+      required: function () {
+        return this.isJobOffer;
+      },
+      validate: {
+        validator: function (value) {
+          return !this.isJobOffer || value > new Date();
+        },
+        message: "Job offer validity date must be in the future",
+      },
+    },
+    jobOfferDiscountPercentage: {
+      type: Number,
+      required: function () {
+        return this.isJobOffer;
+      },
+      min: [1, "Discount percentage must be greater than 1%"],
+      max: [99, "Discount percentage must be less than or equal to 99%"],
+      validate: isIntegerValidator,
+    },
+  },
+  submitLabel: {
+    type: String,
+    required: [true, "Submit label is required"],
+    minlength: [3, "Submit label must be at least 3 characters long"],
+    maxlength: [100, "Submit label cannot exceed 100 characters"],
+    trim: true,
+  },
+});
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+const PlanModel = myDB.model("Plan", planSchema);
+
+module.exports = PlanModel;

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

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

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

@@ -0,0 +1,36 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+const { ObjectId } = mongoose.Types;
+
+// Define the schema for Search Appearance History
+const searchAppearanceHistorySchema = new mongoose.Schema(
+  {
+    recruiterId: { type: ObjectId, ref: "recruiter", required: true },
+    searchQuery: {
+      roleIds: { type: [ObjectId], default: [] },
+      skillIds: { type: [ObjectId], default: [] },
+      workStatus: {
+        type: String,
+        enum: ["fresher", "experienced", null],
+        default: null,
+      },
+      yearExperienceStart: { type: Number, default: null },
+      yearExperienceEnd: { type: Number, default: null },
+    },
+    searchDate: { type: Date, default: Date.now },
+  },
+  { timestamps: true }
+);
+
+// Create indexes for efficient querying
+searchAppearanceHistorySchema.index({ recruiterId: 1 });
+searchAppearanceHistorySchema.index({ searchDate: -1 });
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+const SearchAppearanceHistoryModel = myDB.model(
+  "search-appearance-history",
+  searchAppearanceHistorySchema
+);
+
+module.exports = SearchAppearanceHistoryModel;

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

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

package/models/common-models/sms-student-model.js

@@ -0,0 +1,44 @@
+const mongoose = require("mongoose");
+const moment = require("moment");
+
+const admissionSchema = mongoose.Schema({
+  _id: { type: String },
+  name: { type: String },
+  dob: { type: String },
+  mobileNumber: { type: String },
+  address: { type: String },
+  qualification: { type: String },
+  nationality: { type: String },
+  workingDesignation: { type: String },
+  studentCollegeName: { type: String },
+  courseName: { type: String },
+  courseCode: { type: String },
+  email: { type: String },
+  whatsappnumber: { type: String },
+  gender: { type: String },
+  batchname: { type: String },
+  trainerName: { type: String },
+  doj: { type: String },
+  photo: { type: String },
+  date: {
+    type: String,
+    default: moment().utcOffset(330).format("DD-MM-yyy"),
+  },
+  active: { type: Boolean, default: true },
+  archive: { type: Boolean, default: false },
+  coursestatus: { type: String, default: "Learning" },
+  certificateCollectedStatus: { type: String, default: "No" },
+  totalFees: { type: Number },
+  studentId: {
+    type: String,
+    pattern: { type: String },
+    parentNumber: { type: String },
+    regNo: { type: String },
+  },
+});
+
+const myDB = mongoose.connection.useDb("OA_SMS");
+
+const AdmissionModel = myDB.model("admission", admissionSchema);
+
+module.exports = AdmissionModel;

package/models/common-models/speakingLanguage.js

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

package/models/common-models/specialization-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(
+  {
+    courseId: { type: ObjectId, required: true },
+    label: { type: String, required: true },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const SpecializationModel = myDB.model("specialization", schema);
+
+module.exports = SpecializationModel;

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

@@ -0,0 +1,44 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema with validation
+const schema = new mongoose.Schema(
+  {
+    candidateId: {
+      type: ObjectId,
+      required: [true, "Candidate ID is required"],
+      validate: {
+        validator: mongoose.Types.ObjectId.isValid,
+        message: "Invalid Candidate ID",
+      },
+    },
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+      validate: {
+        validator: mongoose.Types.ObjectId.isValid,
+        message: "Invalid Recruiter ID",
+      },
+    },
+    organizationId: {
+      type: ObjectId,
+      required: [true, "Organization ID is required"],
+      validate: {
+        validator: mongoose.Types.ObjectId.isValid,
+        message: "Invalid Organization ID",
+      },
+    },
+  },
+  {
+    timestamps: { createdAt: true, updatedAt: true },
+  }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const ViewedProfileHistory = myDB.model("viewed-profile-history", schema);
+
+module.exports = ViewedProfileHistory;

package/models/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+  ...require("./candidate-models"),
+  ...require("./recruiter-models"),
+  ...require("./common-models"),
+  ...require("./admin-models"),
+  ...require("./organization-models"),
+  ...require("./jobPost-models"),
+};

package/models/jobPost-models/active-model.js

@@ -0,0 +1,71 @@
+const mongoose = require("mongoose");
+const { ObjectId } = mongoose.Schema.Types;
+const {
+  pendingJobPostStep1Schema,
+} = require("../../schemes/pendingJobPostStep1-schema");
+const {
+  pendingJobPostStep2Schema,
+} = require("../../schemes/pendingJobPostStep2-scheme");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    organizationId: {
+      type: ObjectId,
+      required: [true, "Organization ID is required"],
+      validate: {
+        validator: function (v) {
+          return mongoose.Types.ObjectId.isValid(v);
+        },
+        message: "Invalid Organization ID format",
+      },
+    },
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+      validate: {
+        validator: function (v) {
+          return mongoose.Types.ObjectId.isValid(v);
+        },
+        message: "Invalid Recruiter ID format",
+      },
+    },
+    // planId: {
+    //   type: ObjectId,
+    //   required: [true, "Plan ID is required"],
+    //   ref: "plan",
+    //   validate: {
+    //     validator: function (v) {
+    //       return mongoose.Types.ObjectId.isValid(v);
+    //     },
+    //     message: "Invalid Plan ID format",
+    //   },
+    // },
+    jobId: {
+      type: String,
+      required: [true, "Job ID is required"],
+    },
+    paymentHistoryId: {
+      type: ObjectId,
+      required: [true, "Payment History ID is required"],
+      ref: "paymentHistory",
+      validate: {
+        validator: function (v) {
+          return mongoose.Types.ObjectId.isValid(v);
+        },
+        message: "Invalid Payment History ID format",
+      },
+    },
+    ...pendingJobPostStep1Schema.obj,
+    ...pendingJobPostStep2Schema.obj,
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const ActiveJobPostModel = myDB.model("active-jobPost", schema);
+
+module.exports = ActiveJobPostModel;

package/models/jobPost-models/draft-model.js

@@ -0,0 +1,42 @@
+const mongoose = require("mongoose");
+const { ObjectId } = mongoose.Types;
+const {
+  pendingJobPostStep1Schema,
+  pendingJobPostStep2Schema,
+} = require("../../schemes");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+      validate: {
+        validator: function (v) {
+          return mongoose.Types.ObjectId.isValid(v);
+        },
+        message: "Invalid Recruiter ID format",
+      },
+    },
+    step1: {
+      type: pendingJobPostStep1Schema,
+      default: null,
+    },
+    step2: {
+      type: pendingJobPostStep2Schema,
+      default: null,
+    },
+  },
+  {
+    timestamps: { createdAt: true, updatedAt: true },
+    validateBeforeSave: true,
+  }
+);
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const DraftJobPostModel = myDB.model("draft-jobPost", schema);
+
+module.exports = DraftJobPostModel;

package/models/jobPost-models/expired-model.js

@@ -0,0 +1,46 @@
+const mongoose = require("mongoose");
+const { ObjectId } = mongoose.Schema.Types;
+const {
+  pendingJobPostStep1Schema,
+} = require("../../schemes/pendingJobPostStep1-schema");
+const {
+  pendingJobPostStep2Schema,
+} = require("../../schemes/pendingJobPostStep2-scheme");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    organizationId: {
+      type: ObjectId,
+      required: [true, "Organization ID is required"],
+      validate: {
+        validator: function (v) {
+          return mongoose.Types.ObjectId.isValid(v);
+        },
+        message: "Invalid Organization ID format",
+      },
+    },
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+      validate: {
+        validator: function (v) {
+          return mongoose.Types.ObjectId.isValid(v);
+        },
+        message: "Invalid Recruiter ID format",
+      },
+    },
+    expiredAt: { type: Date, default: Date.now }, // Add expiredAt field
+    ...pendingJobPostStep1Schema.obj,
+    ...pendingJobPostStep2Schema.obj,
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const ExpiredJobPostModel = myDB.model("expired-jobPost", schema);
+
+module.exports = ExpiredJobPostModel;

package/models/jobPost-models/index.js

@@ -0,0 +1,10 @@
+module.exports = {
+  ActiveJobPostModel: require("./active-model"),
+  DraftJobPostModel: require("./draft-model"),
+  ExpiredJobPostModel: require("./expired-model"),
+  JobInvitationModel: require("./invitation-model"),
+  OnHoldJobPostModel: require("./onHold-model"),
+  PendingJobPostModel: require("./pending-model"),
+  RejectedJobPostModel: require("./rejected-model"),
+  VerificationJobPostModel: require("./verification-model"),
+};

package/models/jobPost-models/invitation-model.js

@@ -0,0 +1,72 @@
+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: ObjectId.isValid,
+        message: "Invalid Candidate ID format.",
+      },
+    },
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required."],
+      validate: {
+        validator: ObjectId.isValid,
+        message: "Invalid Recruiter ID format.",
+      },
+    },
+    organizationId: {
+      type: ObjectId,
+      required: [true, "Organization ID is required."],
+      validate: {
+        validator: ObjectId.isValid,
+        message: "Invalid Organization ID format.",
+      },
+    },
+    jobPostId: {
+      type: ObjectId,
+      required: [true, "Job Post ID is required."],
+      validate: {
+        validator: ObjectId.isValid,
+        message: "Invalid Job Post ID format.",
+      },
+    },
+    isApplied: {
+      type: Boolean,
+      default: false, // Default to false if not specified
+    },
+    appliedAt: {
+      type: Date,
+      default: null, // Default to null if not specified
+      validate: {
+        // Validate that appliedAt is not set in the future
+        validator: function (value) {
+          return !value || value <= new Date();
+        },
+        message: "Applied date cannot be in the future.",
+      },
+      // Ensure appliedAt is required when isApplied is true
+      required: function () {
+        return this.isApplied;
+      },
+    },
+  },
+  {
+    timestamps: { createdAt: true, updatedAt: true },
+    versionKey: false, // Disable the version key (__v) for this schema
+  }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const JobInvitationModel = myDB.model("job-invitation", schema);
+
+module.exports = JobInvitationModel;

package/models/jobPost-models/onHold-model.js

@@ -0,0 +1,58 @@
+const mongoose = require("mongoose");
+const {
+  pendingJobPostStep1Schema,
+} = require("../../schemes/pendingJobPostStep1-schema");
+const {
+  pendingJobPostStep2Schema,
+} = require("../../schemes/pendingJobPostStep2-scheme");
+const {
+  pendingJobPostStep3Schema,
+} = require("../../schemes/pendingJobPostStep3-scheme");
+const {
+  pendingJobPostStep4Schema,
+} = require("../../schemes/pendingJobPostStep4-scheme");
+const { validateReason } = require("../../utils");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    recruiterId: {
+      type: mongoose.Schema.Types.ObjectId,
+      required: [true, "Recruiter ID is required"],
+      validate: {
+        validator: mongoose.Types.ObjectId.isValid,
+        message: "Invalid recruiter ID",
+      },
+    },
+    step1: {
+      type: pendingJobPostStep1Schema,
+      required: [true, "Step 1 data is required"],
+    },
+    step2: {
+      type: pendingJobPostStep2Schema,
+      required: [true, "Step 2 data is required"],
+    },
+    step3: {
+      type: pendingJobPostStep3Schema,
+      required: [true, "Step 3 data is required"],
+    },
+    step4: {
+      type: pendingJobPostStep4Schema,
+      required: [true, "Step 4 data is required"],
+    },
+    reason: {
+      type: String,
+      required: [true, "Reason is required"],
+      validate: [validateReason, "Reason must be at least 5 characters long"],
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const OnHoldJobPostModel = myDB.model("onHold-jobPost", schema);
+
+module.exports = OnHoldJobPostModel;