jp-shared 1.0.0

package/configs/firebase-admin.js

@@ -0,0 +1,24 @@
+require("dotenv").config();
+const admin = require("firebase-admin");
+
+// console.log(process.env.MY_FIREBASE_SERVICE_ACCOUNT, "serviceAccount");
+
+const serviceAccount = JSON.parse(process.env.MY_FIREBASE_SERVICE_ACCOUNT);
+
+if (!serviceAccount) {
+  console.error(
+    "MY_FIREBASE_SERVICE_ACCOUNT is not set in the environment or is invalid."
+  );
+  process.exit(1); // Exit the process if the service account is not set
+}
+
+// Initialize Firebase Admin SDK
+admin.initializeApp({
+  credential: admin.credential.cert(serviceAccount),
+  storageBucket: process.env.STORAGE_BUCKET_NAME, // Ensure this matches your Firebase storage bucket
+});
+
+const storage = admin.storage();
+const bucket = storage.bucket();
+
+module.exports = { bucket };

package/configs/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require("./firebase-admin"),
+};

package/constants/configuration.js

@@ -0,0 +1,6 @@
+module.exports = {
+    // Configuration constants
+    REGION: "asia-south1",
+    MONGO_URI: `mongodb+srv://${process.env.MONGODB_USERNAME}:${process.env.MONGODB_PASSWORD}@oceanacademy.atrtb.mongodb.net/?retryWrites=true&w=majority&appName=OceanAcademy`,
+    MONGO_OPTIONS: { maxPoolSize: 20 }, // Connection Pooling
+};

package/constants/database.js

@@ -0,0 +1,6 @@
+const { isProduction } = require("../utils/env-utils");
+
+module.exports = {
+    // Database constants
+    getDatabaseName: () => isProduction() ? "OA_Job_Portal_API" : "OA_Job_Portal_API_TEST",
+};

package/constants/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+  ...require("./time-constant"),
+  ...require("./database"),
+  ...require("./configuration"),
+  ...require("./org"),
+};

package/constants/org.js

@@ -0,0 +1,30 @@
+const COMPANY_NAME = "Ocean Academy IT Solution";
+const COMPANY_ADDRESS =
+    "No. 10, 2nd Floor, 45 Feet Road, Vengateswara Nagar, Near HDFC Bank, Saram, Puducherry-605013.";
+const LOGO_URL =
+    "https://recruiter.oceanacademy.co.in/assets/recuiterLogo-Pau498dW.png";
+const SUPPORT_EMAIL = "Oceanacademy@gmail.com";
+const SUPPORT_MOBILE = "9458348957";
+const GST_NUMBER = "85734985fhjd92347128";
+const TERMS_URL = "https://recruiter.oceanacademy.co.in/terms-condition";
+
+const OUR_ORG_INFO = {
+    companyName: COMPANY_NAME,
+    companyAddress: COMPANY_ADDRESS,
+    logoUrl: LOGO_URL,
+    supportEmail: SUPPORT_EMAIL,
+    supportMobile: SUPPORT_MOBILE,
+    gstNumber: GST_NUMBER,
+    termsUrl: TERMS_URL,
+};
+
+module.exports = {
+    OUR_ORG_INFO,
+    LOGO_URL,
+    COMPANY_ADDRESS,
+    COMPANY_NAME,
+    SUPPORT_EMAIL,
+    SUPPORT_MOBILE,
+    GST_NUMBER,
+    TERMS_URL,
+};

package/constants/time-constant.js

@@ -0,0 +1,4 @@
+const TEN_MINUTES_IN_MS = 10 * 60 * 1000;
+const TWO_MINUTES_IN_MS = 2 * 60 * 1000;
+
+module.exports = { TEN_MINUTES_IN_MS, TWO_MINUTES_IN_MS };

package/helpers/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  ...require("./otp-helper"),
+  ...require("./validateMongoId"),
+};

package/helpers/otp-helper.js

@@ -0,0 +1,48 @@
+// Helper function to send OTP via SMS
+const axios = require("axios");
+
+const sendOTPviaSMS = async (name, mobileNumber, otpCode) => {
+  // Validate name
+  if (!name || typeof name !== "string" || name.trim().length === 0) {
+    throw new Error(
+      "Invalid or missing name. Name must be a non-empty string."
+    );
+  }
+
+  // Validate mobile number
+  if (
+    !mobileNumber ||
+    typeof mobileNumber !== "string" ||
+    !/^\d{10}$/.test(mobileNumber)
+  ) {
+    throw new Error(
+      "Invalid or missing mobile number. It must be exactly 10 digits."
+    );
+  }
+
+  // Validate OTP code as a string
+  if (!otpCode || typeof otpCode !== "string" || !/^\d{4,6}$/.test(otpCode)) {
+    throw new Error(
+      "Invalid or missing OTP. OTP must be a string with 4 to 6 digits."
+    );
+  }
+
+  // Construct the message
+  const message = `Dear ${name}, Your OTP is: ${otpCode}. Please enter this code to verify your identity. Do not share this OTP with anyone. - OCEAN ACADEMY`;
+
+  // Construct the SMS URL
+  const smsUrl = `https://sapteleservices.com/SMS_API/sendsms.php?username=oceanacademy&password=Ocean@123&mobile=${mobileNumber}&sendername=OCEAJP&message=${encodeURIComponent(
+    message
+  )}&routetype=1&tid=1707172233290230214`;
+
+  try {
+    // Send the SMS
+    await axios.get(smsUrl);
+  } catch (error) {
+    // Log and rethrow the error
+    console.error("Error in sendOTPviaSMS:", error.message);
+    throw new Error("Failed to send OTP. Reason: " + error.message);
+  }
+};
+
+module.exports = { sendOTPviaSMS };

package/helpers/validateMongoId.js

@@ -0,0 +1,13 @@
+const mongoose = require("mongoose");
+
+// Helper function to check if an array contains valid MongoDB ObjectIds
+const areValidObjectIds = (ids) =>
+  ids.every((id) => mongoose.Types.ObjectId.isValid(id));
+
+// Helper function to check if it contains valid MongoDB ObjectIds
+const isValidObjectId = (id) => mongoose.Types.ObjectId.isValid(id);
+
+module.exports = {
+  areValidObjectIds,
+  isValidObjectId,
+};

package/index.js

@@ -0,0 +1,15 @@
+const configs = require("./configs");
+const constants = require("./constants");
+const helpers = require("./helpers");
+const models = require("./models");
+const schemes = require("./schemes");
+const utils = require("./utils");
+
+module.exports = {
+    configs,
+    constants,
+    helpers,
+    models,
+    schemes,
+    utils,
+};

package/models/admin-models/admin-model.js

@@ -0,0 +1,62 @@
+const mongoose = require("mongoose");
+const { hashPassword } = require("../../utils");
+const { getDatabaseName } = require("../../constants");
+
+// Define the schema with validation and best practices
+const schema = new mongoose.Schema(
+  {
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true,
+      validate: {
+        validator: function (v) {
+          return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v);
+        },
+        message: (props) => `${props.value} is not a valid email!`,
+      },
+    },
+    otp: {
+      type: String,
+      required: true,
+      // minlength: 6, // Ensure a minimum OTP length
+      // maxlength: 6, // Ensure a maximum OTP length
+    },
+    sentAt: {
+      type: Date,
+      required: true,
+      default: Date.now,
+    },
+    expiresAt: {
+      type: Date,
+      required: true,
+    },
+  },
+  {
+    timestamps: true, // Automatically adds createdAt and updatedAt fields
+  }
+);
+
+// Pre-save hook to hash the OTP before saving
+schema.pre("save", async function (next) {
+  if (!this.isModified("otp")) {
+    return next();
+  }
+
+  try {
+    this.otp = await hashPassword(this.otp); // Hash the OTP
+    next();
+  } catch (error) {
+    next(error); // Pass the error to the next middleware
+  }
+});
+
+// Using a separate database instance
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+// Model definition
+const AdminModel = myDB.model("Admin", schema);
+
+module.exports = AdminModel;

package/models/admin-models/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  AdminModel: require("./admin-model"),
+  AdminTokenModel: require("./token-model"),
+};

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

@@ -0,0 +1,20 @@
+const mongoose = require("mongoose");
+const { getDatabaseName } = require("../../constants");
+
+const schema = new mongoose.Schema({
+  adminId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Admin", // Reference to the Admin model
+    required: true,
+  },
+  token: {
+    type: String,
+    required: true,
+  },
+});
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+const AdminTokenModel = myDB.model("admin-token", schema);
+
+module.exports = AdminTokenModel;

package/models/candidate-models/candidateModel.js

@@ -0,0 +1,375 @@
+const mongoose = require("mongoose");
+const { percentageWeights } = require("../../utils");
+const { getDatabaseName } = require("../../constants");
+const { ObjectId } = mongoose.Types;
+
+// Enum Definitions
+const WORK_STATUS = ["fresher", "experienced", null];
+const MARITAL_STATUS = [
+  "married",
+  "unmarried",
+  "widowed",
+  "divorced",
+  "separated",
+  "other",
+  null,
+];
+const GENDER = ["male", "female", "other", null];
+const PROJECT_STATUS = ["completed", "notCompleted", null];
+
+const educationSchema = new mongoose.Schema({
+  _id: { type: ObjectId, auto: true },
+  qualificationId: { type: ObjectId, required: true },
+  // qualification: { type: String, required: true },
+  specializationId: {
+    type: ObjectId,
+    required: function () {
+      return !this.isOther;
+    },
+    default: null,
+  },
+  // specialization: { type: String, required: true },
+  courseId: {
+    type: ObjectId,
+    required: function () {
+      return !this.isOther;
+    },
+    default: null,
+  },
+  // course: { type: String, required: true },
+  institute: { type: String, required: true },
+  courseType: { type: String, required: true },
+  courseStartYear: {
+    type: Number,
+    required: true,
+    validate: {
+      validator: Number.isInteger,
+      message: "Course start year must be an integer.",
+    },
+  },
+  courseEndYear: {
+    type: Number,
+    required: true,
+    validate: [
+      {
+        validator: Number.isInteger,
+        message: "Course end year must be an integer.",
+      },
+      {
+        validator: function (value) {
+          return this.courseStartYear <= value;
+        },
+        message:
+          "Course start year must be less than or equal to course end year.",
+      },
+    ],
+  },
+  courseStartMonth: {
+    type: Number,
+    required: true,
+    min: 1,
+    max: 12,
+  },
+  courseEndMonth: {
+    type: Number,
+    required: true,
+    min: 1,
+    max: 12,
+    validate: {
+      validator: function (value) {
+        if (this.courseStartYear === this.courseEndYear) {
+          return this.courseStartMonth <= value;
+        }
+        return true;
+      },
+      message:
+        "Course start month must be less than or equal to course end month within the same year.",
+    },
+  },
+  markPercentage: { type: Number, default: null },
+  isPrimary: { type: Boolean, required: true },
+  isOther: { type: Boolean, default: false },
+});
+
+const schoolSchema = new mongoose.Schema({
+  _id: { type: ObjectId, auto: true },
+  qualification: { type: String, required: true },
+  schoolBoard: { type: String, required: true },
+  schoolPassedOutYear: {
+    type: Number,
+    required: true,
+    validate: {
+      validator: Number.isInteger,
+      message: "School passed-out year must be an integer.",
+    },
+  },
+  schoolPassedOutMonth: {
+    type: Number,
+    required: true,
+    min: 1,
+    max: 12,
+    validate: {
+      validator: Number.isInteger,
+      message: "School passed-out month must be an integer.",
+    },
+  },
+  schoolMedium: {
+    type: String,
+    default: null,
+    validate: {
+      validator: function (value) {
+        return value === null || value.trim().length > 0;
+      },
+      message: "School medium cannot be an empty string.",
+    },
+  },
+  markPercentage: {
+    type: Number,
+    default: null,
+    min: 0,
+    max: 100,
+    validate: {
+      validator: function (value) {
+        if (value !== null && (value < 0 || value > 100)) {
+          return false;
+        }
+        return true;
+      },
+      message: "Mark percentage must be between 0 and 100.",
+    },
+  },
+});
+
+// Define the schema
+const schema = new mongoose.Schema(
+  {
+    profilePercentage: { type: Number, default: 0 },
+    skillIds: { type: [ObjectId], ref: "skill", default: [] },
+    roleIds: { type: [ObjectId], ref: "role", default: [] },
+    resume: {
+      type: {
+        resumeName: { type: String, default: null },
+        resumeLink: { type: String, default: null },
+        createdAt: { type: Date, default: Date.now },
+      },
+      default: null,
+    },
+    linkedIn: { type: String, default: null },
+    workStatus: {
+      type: String,
+      enum: WORK_STATUS,
+      default: null,
+      validate: {
+        validator: function (value) {
+          return WORK_STATUS.includes(value);
+        },
+        message: "Invalid work status",
+      },
+    },
+    experience: {
+      type: {
+        years: {
+          type: Number,
+          default: null,
+          validate: {
+            validator: function (value) {
+              return (
+                this.workStatus === "fresher" || (value !== null && value >= 0)
+              );
+            },
+            message: "Years of experience must be at least 0 for non-freshers.",
+          },
+        },
+        months: {
+          type: Number,
+          default: null,
+          validate: {
+            validator: function (value) {
+              return (
+                this.workStatus === "fresher" || (value !== null && value >= 0)
+              );
+            },
+            message:
+              "Months of experience must be at least 0 for non-freshers.",
+          },
+        },
+      },
+      default: null,
+      validate: {
+        validator: function (value) {
+          if (this.workStatus === "fresher") {
+            return (
+              value === null || (value.years === null && value.months === null)
+            );
+          }
+          return true;
+        },
+        message: "Experience should be null for freshers.",
+      },
+    },
+    currentSalary: {
+      type: Number,
+      default: null,
+      validate: {
+        validator: function (value) {
+          return this.workStatus !== "fresher" || value === null;
+        },
+        message: "currentSalary is required for non-freshers",
+      },
+    },
+    salaryExpectation: {
+      type: Number,
+      default: null,
+      validate: {
+        validator: function (value) {
+          return value === null || value > 0;
+        },
+        message: "Salary expectation must be a positive number.",
+      },
+    },
+    noticePeriod: { type: String, default: null },
+    profileSummary: { type: String, default: null },
+    avatar: { type: String, default: null },
+    fullName: { type: String, default: null },
+    mobileNumber: { type: Number, default: null },
+    email: { type: String, default: null, required: true },
+    countryCode: { type: String, default: "+91" },
+    maritalStatus: {
+      type: String,
+      enum: MARITAL_STATUS,
+      default: null,
+      validate: {
+        validator: function (value) {
+          return MARITAL_STATUS.includes(value);
+        },
+        message: "Invalid marital status",
+      },
+    },
+    gender: {
+      type: String,
+      enum: GENDER,
+      default: null,
+      validate: {
+        validator: function (value) {
+          return GENDER.includes(value);
+        },
+        message: "Invalid gender",
+      },
+    },
+    dob: { type: Date, default: null },
+    address: {
+      type: {
+        city: { type: String, default: null },
+        area: { type: String, default: null },
+        street: { type: String, default: null },
+        pincode: { type: Number, default: null },
+      },
+      default: null,
+    },
+    speakingLanguageIds: {
+      type: [ObjectId],
+      ref: "speaking-language",
+      default: [],
+    },
+    educations: {
+      type: [educationSchema],
+      default: [],
+    },
+    // Fields for 10th and 12th qualifications
+    schools: {
+      type: [schoolSchema],
+      default: [],
+      validate: {
+        validator: function (schools) {
+          // Count how many entries are there for 10th and 12th grades
+          const count10th = schools.filter(
+            (school) => school.qualification === "10th"
+          ).length;
+          const count12th = schools.filter(
+            (school) => school.qualification === "12th"
+          ).length;
+
+          // Ensure there's exactly one entry for 10th and one entry for 12th
+          return count10th <= 1 && count12th <= 1;
+        },
+        message:
+          "Candidate must have exactly one school entry for 10th grade and one entry for 12th grade.",
+      },
+    },
+    projects: {
+      type: [
+        {
+          _id: { type: ObjectId, auto: true },
+          projectName: { type: String, default: null },
+          projectStatus: {
+            type: String,
+            enum: PROJECT_STATUS,
+            default: null,
+            validate: {
+              validator: function (value) {
+                return PROJECT_STATUS.includes(value);
+              },
+              message: "Invalid project status",
+            },
+          },
+          projectURL: { type: String, default: null },
+          projectDescription: { type: String, default: null },
+          projectStartYear: { type: Number, default: null },
+          projectStartMonth: { type: Number, default: null },
+          projectEndYear: {
+            type: Number,
+            default: null,
+            validate: {
+              validator: function (value) {
+                // Allow non-null value only if the project status is 'completed'
+                if (this.projectStatus === "completed" && value === null) {
+                  return false;
+                }
+                // Ensure projectEndYear is null if projectStatus is not 'completed'
+                if (this.projectStatus !== "completed" && value !== null) {
+                  return false;
+                }
+                return true;
+              },
+              message:
+                "projectEndYear must be provided only for completed projects.",
+            },
+          },
+          projectEndMonth: {
+            type: Number,
+            default: null,
+            validate: {
+              validator: function (value) {
+                if (this.projectStatus === "completed" && value === null) {
+                  return false;
+                }
+                if (this.projectStatus !== "completed" && value !== null) {
+                  return false;
+                }
+                return true;
+              },
+              message:
+                "projectEndMonth must be provided only for completed projects.",
+            },
+          },
+        },
+      ],
+      default: [],
+    },
+    isActive: { type: Boolean, default: true },
+    isVerified: { type: Boolean, default: true },
+    password: { type: String, default: null },
+    isResetPassword: { type: Boolean, default: false },
+  },
+  { timestamps: { createdAt: true, updatedAt: true } }
+);
+
+const myDB = mongoose.connection.useDb(getDatabaseName());
+
+schema.index({ isActive: 1 });
+schema.index({ profilePercentage: 1 });
+
+// Create the model
+const CandidateModel = myDB.model("candidate", schema);
+
+module.exports = CandidateModel;

package/models/candidate-models/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+  CandidateModel: require("./candidateModel"),
+  CandidateMobileOTPModel: require("./mobileOTPModel"),
+  CandidateOTPModel: require("./otpModel"),
+  CandidateRequestModel: require("./requestModel"),
+  CandidateSavedJobModel: require("./savedJobModel"),
+  SearchAppearanceModel: require("./searchAppearanceModel"),
+};