jp-shared 1.0.0

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

@@ -0,0 +1,44 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+const {
+  Schema,
+  Types: { ObjectId },
+} = mongoose;
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    recruiterId: {
+      type: ObjectId,
+      required: [true, "Recruiter ID is required"],
+    },
+    mobileNumber: {
+      type: String,
+      required: [true, "Mobile number is required"],
+      unique: true,
+      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"],
+    },
+    countryCode: {
+      type: String,
+      required: [true, "Country code is required"],
+      enum: ["+91"],
+    },
+    deleteAt: {
+      type: Date,
+      default: null,
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const PendingRecruiterModel = myDB.model("pending-recruiter", schema);
+
+// Ensure TTL index is created
+schema.index({ deleteAt: 1 }, { expireAfterSeconds: 0 });
+
+module.exports = PendingRecruiterModel;

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

@@ -0,0 +1,75 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    mobileNumber: {
+      type: String,
+      required: [true, "Mobile number is required"],
+      unique: true,
+      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
+    },
+    OTP: {
+      type: String,
+      required: [true, "OTP is required"],
+      // minlength: [24, "Encrypted OTP must be at least 24 characters long"],
+      maxlength: [6, "OTP must be at most 6 characters long"],
+    },
+    requests: [
+      {
+        date: {
+          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,
+        },
+      },
+    ],
+    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 } }
+);
+
+// Add indexes
+schema.index({ mobileNumber: 1, countryCode: 1 }); // Compound index on mobileNumber and countryCode
+schema.index({ deleteAt: 1 }, { expireAfterSeconds: 0 }); // TTL index for automatic deletion
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Create the model
+const RequestRecruiterModel = myDB.model("request-recruiter", schema);
+
+module.exports = RequestRecruiterModel;

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

@@ -0,0 +1,15 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { ObjectId } = mongoose.Types;
+
+const schema = new mongoose.Schema({
+  token: { type: String, required: true },
+  recruiterId: { type: ObjectId, required: true },
+});
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const RecruiterTokenModel = myDB.model("recruiter-token", schema);
+
+module.exports = { RecruiterTokenModel };

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

@@ -0,0 +1,63 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const { Schema } = mongoose;
+
+// Define the schema
+const schema = new Schema(
+  {
+    fullName: {
+      type: String,
+      required: [true, "Full name is optional"], // Optional field
+      minlength: [2, "Full name must be at least 2 characters long"],
+      maxlength: [50, "Full name 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
+    },
+    email: {
+      type: String,
+      required: [true, "Email is optional"],
+      match: [/^\S+@\S+\.\S+$/, "Invalid email format"],
+    },
+    password: {
+      type: String,
+      required: [true, "Password is optional"],
+      minlength: [6, "Password must be at least 6 characters long"],
+      select: false, // Do not include password in queries by default
+    },
+    organizationId: {
+      type: Schema.Types.ObjectId,
+      required: [false, "Organization ID is optional"],
+      ref: "organization-verification",
+      default: null,
+    },
+    avatar: { type: String, required: true },
+    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"],
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+
+// Create the model
+const myDB = mongoose.connection.useDb(getDatabaseName());
+const VerificationRecruiterModel = myDB.model("verification-recruiter", schema);
+
+module.exports = VerificationRecruiterModel;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "jp-shared",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "peerDependencies": {
+    "axios": "^1.8.1",
+    "bcrypt": "^5.1.1",
+    "dotenv": "^16.4.7",
+    "express-validator": "^7.2.1",
+    "firebase-admin": "^13.2.0",
+    "jsonwebtoken": "^9.0.2",
+    "moment": "^2.30.1",
+    "mongoose": "^8.12.1",
+    "nodemailer": "^6.10.0",
+    "puppeteer": "^23.11.0",
+    "puppeteer-core": "^10.4.0",
+    "chrome-aws-lambda": "^10.1.0",
+    "validator": "^13.12.0",
+    "to-words": "^4.2.0"
+  }
+}

package/schemes/address-schema.js

@@ -0,0 +1,43 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const addressSchema = new Schema({
+  city: {
+    type: String,
+    required: [true, "City is required"],
+    minlength: [2, "City must be at least 2 characters long"],
+    maxlength: [50, "City cannot exceed 50 characters"],
+  },
+  state: {
+    type: String,
+    required: [true, "State is required"],
+    minlength: [2, "State must be at least 2 characters long"],
+    maxlength: [50, "State cannot exceed 50 characters"],
+  },
+  country: {
+    type: String,
+    required: [true, "Country is required"],
+    minlength: [2, "Country must be at least 2 characters long"],
+    maxlength: [50, "Country cannot exceed 50 characters"],
+  },
+  street: {
+    type: String,
+    required: [true, "Street is required"],
+    minlength: [2, "Street must be at least 2 characters long"],
+    maxlength: [100, "Street cannot exceed 100 characters"],
+  },
+  area: {
+    type: String,
+    minlength: [2, "Area must be at least 2 characters long"],
+    maxlength: [100, "Area cannot exceed 100 characters"],
+  },
+  pincode: {
+    type: Number,
+    required: [true, "Pincode is required"],
+    minlength: [6, "Pincode must be exactly 6 characters long"],
+    maxlength: [6, "Pincode must be exactly 6 characters long"],
+    match: [/^\d{6}$/, "Pincode must be exactly 6 digits"],
+  },
+});
+
+module.exports = { addressSchema };

package/schemes/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  ...require("./pendingJobPostStep1-schema"),
+  ...require("./pendingJobPostStep2-scheme"),
+  ...require("./pendingJobPostStep3-scheme"),
+  ...require("./pendingJobPostStep4-scheme"),
+  ...require("./address-schema"),
+};

package/schemes/pendingJobPostStep1-schema.js

@@ -0,0 +1,192 @@
+const mongoose = require("mongoose");
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const pendingJobPostStep1Schema = new mongoose.Schema(
+  {
+    jobTitle: {
+      type: String,
+      required: [true, "Job title is required"],
+      minlength: [3, "Job title must be at least 3 characters long"],
+      maxlength: [100, "Job title cannot exceed 100 characters"],
+    },
+    jobRoleIds: {
+      type: [{ type: ObjectId, ref: "role", required: true }],
+      validate: {
+        validator: function (v) {
+          return Array.isArray(v) && v.length > 0;
+        },
+        message: "At least one job role ID is required",
+      },
+    },
+    jobSkillIds: {
+      type: [{ type: ObjectId, ref: "skill", required: true }],
+      validate: {
+        validator: function (v) {
+          return Array.isArray(v) && v.length > 0;
+        },
+        message: "At least one job skill ID is required",
+      },
+    },
+    jobPreferredSkillIds: {
+      type: [{ type: ObjectId, ref: "skill", required: true }],
+      validate: {
+        validator: function (v) {
+          return Array.isArray(v) && v.length > 0;
+        },
+        message: "At least one job preferred skill ID is required",
+      },
+    },
+    jobLocation: {
+      type: String,
+      required: [true, "Job location is required"],
+      minlength: [2, "Job location must be at least 2 characters long"],
+      maxlength: [100, "Job location cannot exceed 100 characters"],
+    },
+    jobMode: {
+      type: [{ type: String, required: true }],
+      validate: {
+        validator: function (v) {
+          const validModes = ["Remote", "On-site", "Hybrid"];
+          return v.every((mode) => validModes.includes(mode));
+        },
+        message: "Invalid job mode",
+      },
+    },
+    jobType: {
+      type: [{ type: String, required: true }],
+      validate: {
+        validator: function (v) {
+          const validTypes = [
+            "Full-time",
+            "Part-time",
+            "Contract",
+            "Internship",
+          ];
+          return v.every((type) => validTypes.includes(type));
+        },
+        message: "Invalid job type",
+      },
+    },
+    jobShift: {
+      type: String,
+      required: [true, "Job shift is required"],
+      enum: {
+        values: ["Day", "Night", "Flexible"],
+        message: "Invalid job shift",
+      },
+    },
+    isJobSalaryToShow: {
+      type: Boolean,
+      required: [true, "Salary display preference is required"],
+    },
+    jobSalaryDetails: {
+      type: {
+        jobSalaryCurrency: {
+          type: String,
+          required: function () {
+            return this.isJobSalaryToShow;
+          },
+          enum: {
+            values: ["USD", "INR"],
+            message: "Job salary currency must be either 'USD' or 'INR'",
+          },
+        },
+        jobMaximumSalary: {
+          type: Number,
+          required: function () {
+            return this.isJobSalaryToShow;
+          },
+          min: [0, "Job maximum salary must be a positive number"],
+        },
+        jobMinimumSalary: {
+          type: Number,
+          required: function () {
+            return this.isJobSalaryToShow;
+          },
+          min: [0, "Job minimum salary must be a positive number"],
+          validate: {
+            validator: function (v) {
+              return this.isJobSalaryToShow
+                ? v <= this.jobSalaryDetails.jobMaximumSalary
+                : true;
+            },
+            message:
+              "Job minimum salary must be less than or equal to maximum salary",
+          },
+        },
+      },
+      validate: {
+        validator: function (v) {
+          if (this.isJobSalaryToShow) {
+            return (
+              v.jobSalaryCurrency && v.jobMaximumSalary && v.jobMinimumSalary
+            );
+          }
+          return true;
+        },
+        message:
+          "All job salary details are required when salary display preference is enabled",
+      },
+    },
+    jobDescription: {
+      type: String,
+      required: [true, "Job description is required"],
+      minlength: [10, "Job description must be at least 10 characters long"],
+      maxlength: [2000, "Job description cannot exceed 2000 characters"],
+    },
+    jobResponsibility: {
+      type: [{ type: String, required: true }],
+      validate: {
+        validator: function (v) {
+          return Array.isArray(v) && v.length > 0;
+        },
+        message: "At least one job responsibility is required",
+      },
+    },
+    jobRequirement: {
+      type: [{ type: String, required: true }],
+      validate: {
+        validator: function (v) {
+          return Array.isArray(v) && v.length > 0;
+        },
+        message: "At least one job requirement is required",
+      },
+    },
+    isFeeCollecting: {
+      type: Boolean,
+      required: [true, "Fee collecting status is required"],
+    },
+    feeDetails: {
+      amount: {
+        type: Number,
+        required: function () {
+          return this.isFeeCollecting;
+        },
+        min: [0, "Fee amount must be a positive number"],
+      },
+      reasons: {
+        type: [{ type: String, required: true }],
+        required: function () {
+          return this.isFeeCollecting;
+        },
+        validate: {
+          validator: function (v) {
+            return this.isFeeCollecting
+              ? Array.isArray(v) && v.length > 0
+              : true;
+          },
+          message: "At least one reason for the fee is required",
+        },
+      },
+      feePaymentSchedule: {
+        type: String,
+        enum: ["Before giving job", "After giving job"],
+        required: false,
+      },
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+module.exports = { pendingJobPostStep1Schema };

package/schemes/pendingJobPostStep2-scheme.js

@@ -0,0 +1,117 @@
+const mongoose = require("mongoose");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const pendingJobPostStep2Schema = new mongoose.Schema(
+  {
+    qualificationIds: {
+      type: [ObjectId],
+      required: [true, "Qualification ID is required"],
+      validate: {
+        validator: function (v) {
+          return v.every((id) => ObjectId.isValid(id));
+        },
+        message: "Invalid Qualification ID format",
+      },
+    },
+    courseIds: {
+      type: [ObjectId],
+      required: [true, "Course ID is required"],
+      validate: {
+        validator: function (v) {
+          return v.every((id) => ObjectId.isValid(id));
+        },
+        message: "Invalid Course ID format",
+      },
+    },
+    specializationIds: {
+      type: [ObjectId],
+      required: [true, "Specialization ID is required"],
+      validate: {
+        validator: function (v) {
+          return v.every((id) => ObjectId.isValid(id));
+        },
+        message: "Invalid Specialization ID format",
+      },
+    },
+    preferredGender: {
+      type: String,
+      required: [true, "Preferred gender is required"],
+      enum: {
+        values: ["Male", "Female", "Other", "Any"],
+        message: "Preferred gender must be 'Male', 'Female', 'Other', or 'Any'",
+      },
+      minlength: [3, "Preferred gender must be at least 3 characters"],
+      maxlength: [6, "Preferred gender must be at most 6 characters"],
+    },
+    jobOpeningCount: {
+      type: Number,
+      required: [true, "Job opening count is required"],
+      min: [1, "Job opening count must be at least 1"],
+      validate: {
+        validator: Number.isInteger,
+        message: "Job opening count must be an integer",
+      },
+    },
+    experienceLevel: {
+      type: String,
+      enum: {
+        values: ["Fresher", "Experienced", "Any"],
+        message: "Experience level must be 'Fresher', 'Experienced', or 'Any'",
+      },
+      required: [true, "Experience level is required"],
+      minlength: [3, "Experience level must be at least 3 characters"],
+      maxlength: [11, "Experience level must be at most 11 characters"],
+    },
+    experience: {
+      type: {
+        min: {
+          type: Number,
+          required: function () {
+            return this.experienceLevel === "Experienced";
+          },
+          min: [0, "Minimum experience must be a non-negative number"],
+          validate: {
+            validator: Number.isInteger,
+            message: "Minimum experience must be an integer",
+          },
+        },
+        max: {
+          type: Number,
+          required: function () {
+            return this.experienceLevel === "Experienced";
+          },
+          min: [0, "Maximum experience must be a non-negative number"],
+          validate: {
+            validator: Number.isInteger,
+            message: "Maximum experience must be an integer",
+          },
+        },
+      },
+      validate: {
+        validator: function (v) {
+          if (
+            this.experienceLevel === "Fresher" ||
+            this.experienceLevel === "Any"
+          ) {
+            return !v || (v.min === undefined && v.max === undefined);
+          }
+          return v.min <= v.max;
+        },
+        message: function (props) {
+          if (
+            this.experienceLevel === "Fresher" ||
+            this.experienceLevel === "Any"
+          ) {
+            return "Experience field should not be provided for 'Fresher' or 'Any' experience levels";
+          }
+          return "Minimum experience must be less than or equal to maximum experience";
+        },
+      },
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+module.exports = { pendingJobPostStep2Schema };

package/schemes/pendingJobPostStep3-scheme.js

@@ -0,0 +1,21 @@
+const mongoose = require("mongoose");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const pendingJobPostStep3Schema = new mongoose.Schema(
+  {
+    organizationId: {
+      type: ObjectId,
+      // ref : "verification-organization",
+      required: [true, "Organization ID is required"],
+      validate: {
+        validator: mongoose.Types.ObjectId.isValid,
+        message: "Invalid organization ID",
+      },
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+module.exports = { pendingJobPostStep3Schema };

package/schemes/pendingJobPostStep4-scheme.js

@@ -0,0 +1,22 @@
+const mongoose = require("mongoose");
+
+const { ObjectId } = mongoose.Types;
+
+// Define the schema
+const pendingJobPostStep4Schema = new mongoose.Schema(
+  {
+    planId: {
+      type: ObjectId,
+      required: [true, "Plan ID is required"],
+      validate: {
+        validator: function (v) {
+          return mongoose.Types.ObjectId.isValid(v);
+        },
+        message: "Invalid Plan ID format",
+      },
+    },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+module.exports = { pendingJobPostStep4Schema };

package/utils/env-utils.js

@@ -0,0 +1,12 @@
+const isProduction = () => process.env.NODE_ENV === "prod";
+
+const isDev = () => process.env.NODE_ENV === "dev";
+
+const isTest = () => process.env.NODE_ENV === "test";
+
+
+module.exports = {
+    isProduction,
+    isDev,
+    isTest,
+};