jp-shared 1.0.0

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

@@ -0,0 +1,45 @@
+const mongoose = require("mongoose");
+const {
+  pendingJobPostStep1Schema,
+  pendingJobPostStep2Schema,
+  pendingJobPostStep3Schema,
+  pendingJobPostStep4Schema,
+} = require("../../schemes");
+const { getDatabaseName } = require("../../constants");
+const { ObjectId } = mongoose.Schema.Types;
+
+const schema = new mongoose.Schema(
+  {
+    recruiterId: {
+      type: 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: pendingJobPostStep4Schema, // This will not be required
+  },
+  {
+    timestamps: { createdAt: true, updatedAt: true },
+  }
+);
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const PendingJobPostModel = myDB.model("pending-jobPost", schema);
+
+module.exports = PendingJobPostModel;

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

@@ -0,0 +1,51 @@
+const mongoose = require("mongoose");
+const {
+  pendingJobPostStep1Schema,
+  pendingJobPostStep2Schema,
+  pendingJobPostStep3Schema,
+  pendingJobPostStep4Schema,
+} = require("../../schemes");
+const { validateReason } = require("../../utils");
+const { getDatabaseName } = require("../../constants");
+const { ObjectId } = mongoose.Schema.Types;
+
+const schema = new mongoose.Schema(
+  {
+    recruiterId: {
+      type: 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: pendingJobPostStep4Schema, // This will not be 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 RejectedJobPostModel = myDB.model("rejected-jobPost", schema);
+
+module.exports = RejectedJobPostModel;

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

@@ -0,0 +1,50 @@
+const mongoose = require("mongoose");
+const {
+  pendingJobPostStep1Schema,
+  pendingJobPostStep2Schema,
+  pendingJobPostStep3Schema,
+  pendingJobPostStep4Schema,
+} = require("../../schemes");
+const { getDatabaseName } = require("../../constants");
+const { ObjectId } = mongoose.Schema.Types;
+
+const schema = new mongoose.Schema(
+  {
+    recruiterId: {
+      type: 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"],
+    },
+  },
+  {
+    timestamps: { createdAt: true, updatedAt: true },
+  }
+);
+
+schema.index({ recruiterId: 1 });
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const VerificationJobPostModel = myDB.model("verification-jobPost", schema);
+
+module.exports = VerificationJobPostModel;

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

@@ -0,0 +1,111 @@
+const mongoose = require("mongoose");
+const { addressSchema } = require("../../schemes");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Schema.Types;
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+      ref: "RecruiterModel",
+    },
+    organizationLogo: {
+      type: String,
+      required: [true, "Organization logo is required"],
+      // match: [
+      //   /^(https?:\/\/.*\.(?:png|jpg|jpeg|svg))$/i,
+      //   "Organization logo must be a valid URL and of type png, jpg, jpeg, or svg",
+      // ],
+    },
+    organizationName: {
+      type: String,
+      required: [true, "Organization name is required"],
+      trim: true,
+      minlength: [2, "Organization name must be at least 2 characters long"],
+      maxlength: [100, "Organization name cannot exceed 100 characters"],
+    },
+    normalizedOrganizationName: {
+      type: String,
+      trim: true,
+      minlength: [
+        2,
+        "Normalized organization name must be at least 2 characters long",
+      ],
+      maxlength: [
+        100,
+        "Normalized organization name cannot exceed 100 characters",
+      ],
+      lowercase: true, // Ensuring normalization for consistent database querying
+    },
+    about: {
+      type: String,
+      required: [true, "About section is required"],
+      trim: true,
+      minlength: [10, "About section must be at least 10 characters long"],
+      maxlength: [1000, "About section cannot exceed 1000 characters"],
+    },
+    websiteLink: {
+      type: String,
+      required: [true, "Website link is required"],
+      // match: [
+      //   /^(https?:\/\/)?(www\.)?([a-zA-Z0-9]+)(\.[a-z]{2,})+(\/[^\s]*)?$/,
+      //   "Website link must be a valid URL",
+      // ],
+      trim: true,
+    },
+    gallery: {
+      type: [String],
+      validate: {
+        validator: function (v) {
+          return Array.isArray(v) && v.length >= 3 && v.length <= 6;
+        },
+        message:
+          "Gallery should have at least 3 images and a maximum of 6 images.",
+      },
+    },
+    teamSize: {
+      type: String,
+      required: [true, "Team size is required"],
+      // enum: {
+      //   values: ["1-10", "11-50", "51-200", "201-500", "501-1000", "1001+"],
+      //   message: "Team size must be one of the predefined values",
+      // },
+    },
+    foundedYear: {
+      type: Number,
+      required: [true, "Founded year is required"],
+      min: [1800, "Founded year cannot be before 1800"],
+      max: [new Date().getFullYear(), "Founded year cannot be in the future"],
+    },
+    address: {
+      type: addressSchema,
+      required: [true, "Address is required"],
+    },
+    gstNumber: {
+      type: String,
+      required: [true, "GST number is required"],
+      match: [
+        /^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}[Z]{1}[A-Z0-9]{1}$/,
+        "Invalid GST number format",
+      ],
+      unique: true, // Ensures that the GST number is unique in the collection
+    },
+  },
+  {
+    timestamps: { createdAt: true, updatedAt: true },
+  }
+);
+
+// Indexing for better performance
+schema.index({ recruiterId: 1 });
+schema.index({ normalizedOrganizationName: 1 });
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const ActiveOrganizationModel = myDB.model("active-organization", schema);
+
+module.exports = ActiveOrganizationModel;

package/models/organization-models/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  ActiveOrganizationModel: require("./active-model"),
+  OrganizationVerificationModel: require("./verification-model"),
+};

package/models/organization-models/verification-model.js

@@ -0,0 +1,52 @@
+const mongoose = require("mongoose");
+const { addressSchema } = require("../../schemes");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Schema.Types;
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    recruiterId: { type: ObjectId, required: true },
+    organizationLogo: { type: String, required: true },
+    organizationName: { type: String, required: true }, // For display purposes
+    normalizedOrganizationName: { type: String }, // For database queries and comparisons
+    about: { type: String, required: true },
+    websiteLink: {
+      type: String,
+      required: true,
+    },
+    gallery: {
+      type: [String],
+      validate: {
+        validator: function (v) {
+          return Array.isArray(v) && v.length >= 3 && v.length <= 6;
+        },
+        message:
+          "Gallery should have at least 3 images and a maximum of 6 images.",
+      },
+    },
+    teamSize: { type: String, required: true },
+    foundedYear: { type: Number, required: true },
+    address: { type: addressSchema, required: true },
+    gstNumber: {
+      type: String,
+      required: [true, "GST number is required"],
+      match: [
+        /^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}[Z]{1}[A-Z0-9]{1}$/,
+        "Invalid GST number format",
+      ],
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const OrganizationVerificationModel = myDB.model(
+  "verification-organization",
+  schema
+);
+
+module.exports = OrganizationVerificationModel;

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

@@ -0,0 +1,45 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Schema.Types;
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    avatar: { type: String, required: true },
+    fullName: { type: String, required: true, minlength: 2, maxlength: 50 },
+    designation: { type: String, required: true, minlength: 2, maxlength: 50 },
+    email: {
+      type: String,
+      required: true,
+      match: /^\S+@\S+\.\S+$/,
+      unique: true, // Unique index (no need for manual index)
+      lowercase: true, // Ensure case-insensitive uniqueness
+      trim: true, // Remove accidental spaces
+    },
+    countryCode: { type: String, required: true, enum: ["+91"] },
+    mobileNumber: {
+      type: String,
+      required: true,
+      minlength: 10,
+      maxlength: 10,
+      unique: true,  // Unique index (no need for manual index)
+    },
+    password: { type: String, required: true },
+    organizationId: {
+      type: ObjectId,
+      required: true,
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+// Indexing for performance
+schema.index({ organizationId: 1 });
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const ActiveRecruiterModel = myDB.model("active-recruiter", schema);
+
+module.exports = ActiveRecruiterModel;

package/models/recruiter-models/basicDetail-model.js

@@ -0,0 +1,113 @@
+const mongoose = require("mongoose");
+const bcrypt = require("bcrypt");
+const { isMobilePhone } = require("validator");
+const { getDatabaseName } = require("../../constants");
+const {
+  Schema,
+  Types: { ObjectId },
+} = mongoose;
+
+// Define the schema
+const schema = new Schema(
+  {
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+    },
+    fullName: {
+      type: String,
+      required: [true, "Full name is required"],
+      trim: true,
+      minlength: [3, "Full name must be at least 3 characters long"],
+      maxlength: [50, "Full name must be at most 50 characters long"],
+    },
+    designation: {
+      type: String,
+      required: [true, "Designation is optional"], // Optional field
+      minlength: [2, "Designation must be at least 2 characters long"],
+      maxlength: [50, "Designation cannot exceed 50 characters"],
+    },
+    // mobileNumber: {
+    //   type: String,
+    //   required: [true, "Mobile number is required"],
+    //   minlength: [10, "Mobile number must be exactly 10 digits long"],
+    //   maxlength: [10, "Mobile number must be exactly 10 digits long"],
+    //   match: [/^\d{10}$/, "Mobile number must be exactly 10 digits"],
+    //   unique: true, // Ensure mobileNumber is unique
+    // },
+    // countryCode: {
+    //   type: String,
+    //   required: [true, "Country code is required"],
+    //   minlength: [1, "Country code must be at least 1 character long"],
+    //   maxlength: [4, "Country code cannot exceed 4 characters"],
+    //   enum: ["+91"], // Only allow +91
+    // },
+    password: {
+      type: String,
+      required: [true, "Password is required"],
+    },
+    email: {
+      type: String,
+      required: [true, "Email is required"],
+      unique: true,
+      match: [
+        /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+        "Please enter a valid email address",
+      ],
+      maxlength: 100,
+    },
+    OTP: {
+      type: String,
+      required: [true, "OTP is required"],
+    },
+    requests: [
+      {
+        date: {
+          type: Date,
+          required: [true, "Request date is required"],
+          default: Date.now,
+        },
+        attempts: {
+          type: Number,
+          default: 0,
+          min: [0, "Attempts cannot be negative"],
+        },
+        successful: {
+          type: Boolean,
+          default: false,
+        },
+      },
+    ],
+    expiryDate: {
+      type: Date,
+      required: [true, "Expiry date is required"],
+      validate: {
+        validator: function (v) {
+          return v > Date.now();
+        },
+        message: "Expiry date must be in the future.",
+      },
+    },
+    deleteAt: {
+      type: Date,
+      required: [true, "Deletion time is required"],
+      validate: {
+        validator: function (v) {
+          return v > Date.now();
+        },
+        message: "Deletion time must be in the future.",
+      },
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+// Define indexes for TTL and other fields
+schema.index({ deleteAt: 1 }, { expireAfterSeconds: 0 });
+schema.index({ recruiterId: 1 });
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+const RecruiterBasicDetailModel = myDB.model("recruiter-basic-detail", schema);
+
+module.exports = { RecruiterBasicDetailModel };

package/models/recruiter-models/counter-model.js

@@ -0,0 +1,13 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const counterSchema = new mongoose.Schema({
+  _id: { type: String, required: true },
+  sequenceValue: { type: Number, default: 0 },
+});
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+const CounterModel = myDB.model("counter", counterSchema);
+
+module.exports = { CounterModel };

package/models/recruiter-models/emailOTP-model.js

@@ -0,0 +1,68 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+const {
+  Schema,
+  Types: { ObjectId },
+} = mongoose;
+
+// Define the schema
+const schema = new Schema(
+  {
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+    },
+    email: { type: String, required: true },
+    OTP: {
+      type: String, // Encrypted OTP
+      required: [true, "OTP is required"],
+      maxlength: [6, "OTP must be 6 digits"], // Adjust based on encryption
+    },
+    attempts: [
+      {
+        date: {
+          type: Date,
+          required: [true, "Attempt date is required"],
+        },
+        successful: {
+          type: Boolean,
+          default: false,
+        },
+      },
+    ],
+    expiry: {
+      type: Date,
+      required: [true, "Expiry date is required"],
+      validate: {
+        validator: function (v) {
+          return v > new Date(); // Ensure expiry is in the future
+        },
+        message: "Expiry must be a future date.",
+      },
+    },
+
+    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 } }
+);
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+const RecruiterEmailOTPModel = myDB.model("recruiter-email-otp", schema);
+
+// Ensure deleteAt index is created (for document expiry)
+schema.index({ deleteAt: 1 }, { expireAfterSeconds: 0 });
+
+// Consider adding indexes for frequently queried fields
+schema.index({ recruiterId: 1 });
+
+module.exports = { RecruiterEmailOTPModel };

package/models/recruiter-models/index.js

@@ -0,0 +1,10 @@
+module.exports = {
+  ActiveRecruiterModel: require("./active-model"),
+  PendingRecruiterModel: require("./pending-model"),
+  RecruiterBasicDetailModel: require("./basicDetail-model"),
+  RecruiterTokenModel: require("./token-model"),
+  CounterModel: require("./counter-model"),
+  RequestRecruiterModel: require("./request-model"),
+  VerificationRecruiterModel: require("./verification-model"),
+  RecruiterMobileOTPModel: require("./mobileOTP-model"),
+};

package/models/recruiter-models/mobileOTP-model.js

@@ -0,0 +1,88 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+const {
+  Schema,
+  Types: { ObjectId },
+} = mongoose;
+
+// Define the schema
+const schema = new Schema(
+  {
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+    },
+    mobileNumber: {
+      type: String,
+      required: [true, "Mobile number is required"],
+      validate: {
+        validator: function (v) {
+          return /^\d{10}$/.test(v); // Example validation for a 10-digit number
+        },
+        message: "Invalid mobile number format.",
+      },
+    },
+    countryCode: {
+      type: String,
+      required: [true, "Country code is required"],
+      validate: {
+        validator: function (v) {
+          return /^\+\d{1,4}$/.test(v); // Example validation for country code (e.g., +1, +44)
+        },
+        message: "Invalid country code format.",
+      },
+    },
+    OTP: {
+      type: String, // Encrypted OTP
+      required: [true, "OTP is required"],
+      maxlength: [6, "OTP must be 6 digits"], // Adjust based on encryption
+    },
+    attempts: [
+      {
+        date: {
+          type: Date,
+          required: [true, "Attempt date is required"],
+        },
+        successful: {
+          type: Boolean,
+          default: false,
+        },
+      },
+    ],
+    expiry: {
+      type: Date,
+      required: [true, "Expiry date is required"],
+      validate: {
+        validator: function (v) {
+          return v > new Date(); // Ensure expiry is in the future
+        },
+        message: "Expiry must be a future date.",
+      },
+    },
+    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 } }
+);
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+const RecruiterMobileOTPModel = myDB.model("recruiter-mobile-otp", schema);
+
+// Ensure deleteAt index is created (for document expiry)
+schema.index({ deleteAt: 1 }, { expireAfterSeconds: 0 });
+
+// Consider adding indexes for frequently queried fields
+schema.index({ recruiterId: 1 });
+schema.index({ mobileNumber: 1 });
+schema.index({ countryCode: 1 });
+
+module.exports = RecruiterMobileOTPModel;