watermanagement-backend-prod/src/handlers/supplierHandler.js

//Get the data models
const { Supplier, DeliveryBoy, profilePictureSupplier } = require("../models/supplier");
const { FriendRequest } = require("../models/supplier");
const { ProfilePicture, User } = require("../models/User");
const supplierController = require("../controllers/supplierController");
const customJwtAuth = require("../customAuthJwt");
const fastify = require("fastify")({
  logger: true,
  //disableRequestLogging: true,
  genReqId(req) {
    // you get access to the req here if you need it - must be a synchronous function
    return uuidv4();
  },
});
const moment = require('moment');

const fastifyEnv = require("fastify-env");

const boom = require("boom");
const emailValidator = require("email-validator");
const libphonenumberjs = require("libphonenumber-js");

fastify.register(customJwtAuth);

const schema = {
  type: "object",
  required: ["PORT"],
  properties: {
    PORT: {
      type: "string",
      default: 3000,
    },
    APIVERSION: {
      type: "string",
      default: "1.0.0",
    },
  },
};

const options = {
  confKey: "config", // optional, default: 'config'
  schema: schema,
  // data: data // optional, default: process.env
};
fastify.register(fastifyEnv, options).ready((err) => {
  if (err) console.error(err);

  console.log(fastify.config.PORT); // or fastify[options.confKey]
  // output: { PORT: 3000 }
  fastify.decorate("conf", {
    port: fastify.config.PORT,
    APIVERSION: fastify.config.APIVERSION,
  });
});

const apiversion = "1.0.0";

// fastify.register(require('fastify-cookie'))
// fastify.register(require('fastify-session'), {
//   secret: 'my-secret-key',
//   cookie: { secure: true }
// });

isSupplierFormUrlEncoded = (req) => {
  var isSupplierFormUrlEncoded = false;
  console.log("check is Supplier encoe url funtion");
  // This iterates through the req headers object.
  // could not access req.headers.content-type due to the hyphen in the content-type key.
  // console.log(`${key}: ${value}`);
  for (const [key, value] of Object.entries(req.headers)) {
    if (`${key}` === "content-type") {
      if (`${value}` == "application/x-www-form-urlencoded") {
        // console.log( "data supplied is with content type," , `${value}`)
        // set isUserFormUrlEncoded value to true
        isSupplierFormUrlEncoded = true;

        // create user object with form variables . Password is used from the request object directly.
        s_data = {
          suppliername: req.body.suppliername,
          phone: req.body.phone,
          office_address: req.body.office_address,
          password: req.body.password,
          emails: [
            {
              email: req.body.email,
            },
          ],
          profile: {
            firstName: req.body.firstName,
            lastName: req.body.lastName,
          },
        };

        return {
          isSupplierFormUrlEncoded: isSupplierFormUrlEncoded,
          supplier: s_data,
        };
      } else {
        return { isSupplierFormUrlEncoded: false, s_data: "" };
      }
    }
  }
};

fastify.register((fastify, opts, done) => {
  fastify.addContentTypeParser(
    "application/json",
    { parseAs: "buffer" },
    function (_req, body, done) {
      try {
        done(null, body);
      } catch (error) {
        error.statusCode = 400;
        done(error, undefined);
      }
    }
  );

  done(null);
});

//Login Supplier Handler
exports.loginSupplier = async (request, reply) => {
  loginObject = await supplierController.loginSupplier(request);
  console.log("loginObject...", loginObject);
  if (loginObject.same) {
    const phoneVerified = loginObject.supplier.phoneVerified;
    const oneTimePasswordSetFlag = loginObject.supplier.oneTimePasswordSetFlag;
    console.log(
      "oneTimePasswordSetFlag is ......",
      oneTimePasswordSetFlag,
      typeof oneTimePasswordSetFlag,
      typeof phoneVerified
    );
    if (!phoneVerified) {
      reply.send({
        simplydata: {
          error: false,
          phoneVerified: false,

          phone: loginObject.supplier.phone,
          oneTimePasswordSetFlag: oneTimePasswordSetFlag,
          message: "Please Verify your phone number",
        },
      });
    } else if (oneTimePasswordSetFlag) {
      reply.send({
        simplydata: {
          error: false,
          phoneVerified: phoneVerified,
          phone: loginObject.supplier.phone,
          oneTimePasswordSetFlag: true,
          message: "Password must be reset",
        },
      });
    } else {
      const token = fastify.jwt.sign(
        {
          suppliername: loginObject.supplier.suppliername,
          supplierId: loginObject.supplier._id,
          roles: loginObject.supplier.profile.role,
        },
        //expiresIn: expressed in seconds or a string describing a time span zeit/ms. Eg: 60, "2 days", "10h", "7d".
        //A numeric value is interpreted as a seconds count. If you use a string be sure you provide the time units (days, hours, etc),
        //otherwise milliseconds unit is used by default ("120" is equal to "120ms").
        { expiresIn: "30d" }
      );
      console.log(token, "..token");

      var arr = loginObject.supplier.profile.role;
      var arrayToString = JSON.stringify(Object.assign({}, arr)); // convert array to string
      var stringToJsonObject = JSON.parse(arrayToString); // convert string to json object
      var s_id = loginObject.supplier.supplierId;

      console.log(s_id, "supplierId");
      var profilePicture = await profilePictureSupplier.findOne({ supplierId: s_id });

      // request.session.set('supplierId', loginObject.supplier._id)

      if (!profilePicture) {
        reply.send({
          simplydata: {
            error: false,
            apiversion: fastify.config.APIVERSION,
            access_token: token,

            email: loginObject.supplier.emails,
            phone: loginObject.supplier.phone,
            supplierId: loginObject.supplier.supplierId,
            suppliername: loginObject.supplier.suppliername,
            office_address: loginObject.supplier.profile.office_address,
            phoneVerified: loginObject.supplier.phoneVerified,
            oneTimePasswordSetFlag: loginObject.supplier.oneTimePasswordSetFlag,
            latitude: loginObject.supplier.latitude,
            longitude: loginObject.supplier.longitude,
            type: loginObject.supplier.profile.role,
            description : loginObject.supplier.description,
            typeasobj: stringToJsonObject,
          },
        });
      }
      if (profilePicture) {
        reply.send({
          simplydata: {
            error: false,
            apiversion: fastify.config.APIVERSION,
            access_token: token,
            picture: profilePicture.picture,
            email: loginObject.supplier.emails,
            phone: loginObject.supplier.phone,
            supplierId: loginObject.supplier.supplierId,
            suppliername: loginObject.supplier.suppliername,
            office_address: loginObject.supplier.profile.office_address,
            phoneVerified: loginObject.supplier.phoneVerified,
            oneTimePasswordSetFlag: loginObject.supplier.oneTimePasswordSetFlag,
            latitude: loginObject.supplier.latitude,
            longitude: loginObject.supplier.longitude,
            description : loginObject.supplier.description,
            type: loginObject.supplier.profile.role,
            typeasobj: stringToJsonObject,
          },
        });
      }
    }
  } else {
    error = {
      simplydata: {
        error: true,
        code: 400,
        message: "Invalid SupplierId , Password supplied",
      },
    };
    reply.send(error);
  }
};

//Login Delivery  Handler
exports.loginDeliveryBoy = async (request, reply) => {
  phone = request.body.phone;
  phoneVerificationCode = request.body.phoneVerificationCode;

  // check if user exists in the system. If user exists , display message that
  // username is not available
  console.log(
    "this is the phone and verification code",
    phone,
    phoneVerificationCode
  );
  deliveryBoyExists = await DeliveryBoy.findOne({
    phone: phone,
    phoneVerified: false,
    phoneVerificationCode: phoneVerificationCode,
  });
  console.log(deliveryBoyExists);
  if (deliveryBoyExists) {
    // update the phoneVerified flag to true.
    const filter = {
      phone: phone,
      phoneVerificationCode: phoneVerificationCode,
    };
    const update = { phoneVerified: true };
    const doc = await DeliveryBoy.findOneAndUpdate(filter, update);
    updatedDeliveryBoy = await DeliveryBoy.findOne({ phone: phone });
  }
  loginObject = await supplierController.loginDeliveryBoy(request);
  console.log("loginObject...", loginObject);
  if (loginObject.same) {
    const phoneVerified = loginObject.delivery.phoneVerified;
    const oneTimePasswordSetFlag = loginObject.delivery.oneTimePasswordSetFlag;
    console.log(
      "oneTimePasswordSetFlag is ......",
      oneTimePasswordSetFlag,
      typeof oneTimePasswordSetFlag,
      typeof phoneVerified
    );
    if (!phoneVerified) {
      reply.send({
        simplydata: {
          error: false,
          phoneVerified: false,

          phone: loginObject.delivery.phone,
          oneTimePasswordSetFlag: oneTimePasswordSetFlag,
          message: "Please Verify your phone number",
        },
      });
    } else if (oneTimePasswordSetFlag) {
      reply.send({
        simplydata: {
          error: false,
          phoneVerified: phoneVerified,
          phone: loginObject.delivery.phone,
          oneTimePasswordSetFlag: true,
          message: "Password must be reset",
        },
      });
    } else {
      const token = fastify.jwt.sign(
        {
          deliveryBoyname: loginObject.delivery.name,
          deliveryBoyId: loginObject.delivery._id,
        },
        //expiresIn: expressed in seconds or a string describing a time span zeit/ms. Eg: 60, "2 days", "10h", "7d".
        //A numeric value is interpreted as a seconds count. If you use a string be sure you provide the time units (days, hours, etc),
        //otherwise milliseconds unit is used by default ("120" is equal to "120ms").
        { expiresIn: "30d" }
      );
      console.log(token, "..token");

      var d_id = loginObject.delivery._id;

      console.log(d_id, "deliveryId");
      var profilePicture = await ProfilePicture.findOne({
        deliveryBoyId: d_id,
      });

      // request.session.set('supplierId', loginObject.supplier._id)

      if (!profilePicture) {
        reply.send({
          simplydata: {
            error: false,
            apiversion: fastify.config.APIVERSION,
            access_token: token,

            phone: loginObject.delivery.phone,
            deliveryBoyId: loginObject.delivery.deliveryBoyId,
            deliveryBoyname: loginObject.delivery.name,
            address: loginObject.delivery.address,
            phoneVerified: loginObject.delivery.phoneVerified,
            oneTimePasswordSetFlag: loginObject.delivery.oneTimePasswordSetFlag,
            supplierId: loginObject.delivery.supplierId,
            suppliername: loginObject.delivery.suppliername,
            longitude: loginObject.delivery.longitude,
            latitude: loginObject.delivery.latitude,
          },
        });
      }
      if (profilePicture) {
        reply.send({
          simplydata: {
            error: false,
            apiversion: fastify.config.APIVERSION,
            access_token: token,
            picture: profilePicture.picture,
            phone: loginObject.delivery.phone,
            deliveryBoyId: loginObject.delivery.deliveryBoyId,
            deliveryBoyname: loginObject.delivery.name,
            address: loginObject.delivery.address,
            phoneVerified: loginObject.delivery.phoneVerified,
            oneTimePasswordSetFlag: loginObject.delivery.oneTimePasswordSetFlag,
            supplierId: loginObject.delivery.supplierId,
            suppliername: loginObject.delivery.suppliername,
            longitude: loginObject.delivery.longitude,
            latitude: loginObject.delivery.latitude,
          },
        });
      }
    }
  } else {
    error = {
      simplydata: {
        error: true,
        code: 400,
        message: "Invalid Details",
      },
    };
    reply.send(error);
  }
};

exports.deliveryBoyVerifyPhone = async (req, reply) => {
  console.log("-------------------------------------------------");
  try {
    phone = req.body.phone;
    phoneVerificationCode = req.body.phoneVerificationCode;

    // check if user exists in the system. If user exists , display message that
    // username is not available
    console.log(
      "this is the phone and verification code",
      phone,
      phoneVerificationCode
    );
    deliveryBoyExists = await DeliveryBoy.findOne({
      phone: phone,
      //phoneVerified: false,
      phoneVerificationCode: phoneVerificationCode,
    });
    console.log(deliveryBoyExists);
    if (deliveryBoyExists) {
      // update the phoneVerified flag to true.
      const filter = {
        phone: phone,
        phoneVerificationCode: phoneVerificationCode,
      };
      const update = { phoneVerified: true };
      const doc = await DeliveryBoy.findOneAndUpdate(filter, update);
      updatedDeliveryBoy = await DeliveryBoy.findOne({ phone: phone });

      if (updatedDeliveryBoy.phoneVerified) {
        loginObject = await supplierController.loginDeliveryBoy(req);
        console.log("loginObject...", loginObject);
        if (loginObject.same) {
          const phoneVerified = loginObject.delivery.phoneVerified;
          const oneTimePasswordSetFlag =
            loginObject.delivery.oneTimePasswordSetFlag;
          console.log(
            "oneTimePasswordSetFlag is ......",
            oneTimePasswordSetFlag,
            typeof oneTimePasswordSetFlag,
            typeof phoneVerified
          );
          if (!phoneVerified) {
            reply.send({
              simplydata: {
                error: false,
                phoneVerified: false,

                phone: loginObject.delivery.phone,
                oneTimePasswordSetFlag: oneTimePasswordSetFlag,
                message: "Please Verify your phone number",
              },
            });
          } else if (oneTimePasswordSetFlag) {
            reply.send({
              simplydata: {
                error: false,
                phoneVerified: phoneVerified,
                phone: loginObject.delivery.phone,
                oneTimePasswordSetFlag: true,
                message: "Password must be reset",
              },
            });
          } else {
            const token = fastify.jwt.sign(
              {
                deliveryBoyname: loginObject.delivery.name,
                deliveryBoyId: loginObject.delivery._id,
              },
              //expiresIn: expressed in seconds or a string describing a time span zeit/ms. Eg: 60, "2 days", "10h", "7d".
              //A numeric value is interpreted as a seconds count. If you use a string be sure you provide the time units (days, hours, etc),
              //otherwise milliseconds unit is used by default ("120" is equal to "120ms").
              { expiresIn: "30d" }
            );
            console.log(token, "..token");

            var d_id = loginObject.delivery._id;

            console.log(d_id, "deliveryId");
            var profilePicture = await ProfilePicture.findOne({
              deliveryBoyId: d_id,
            });

            // request.session.set('supplierId', loginObject.supplier._id)

            if (!profilePicture) {
              reply.send({
                simplydata: {
                  error: false,
                  apiversion: fastify.config.APIVERSION,
                  access_token: token,

                  phone: loginObject.delivery.phone,
                  deliveryBoyId: loginObject.delivery.deliveryBoyId,
                  deliveryBoyname: loginObject.delivery.name,
                  address: loginObject.delivery.address,
                  phoneVerified: loginObject.delivery.phoneVerified,
                  oneTimePasswordSetFlag:
                    loginObject.delivery.oneTimePasswordSetFlag,
                  supplierId: loginObject.delivery.supplierId,
                  suppliername: loginObject.delivery.suppliername,
                  longitude: loginObject.delivery.longitude,
                  latitude: loginObject.delivery.latitude,
                },
              });
            }
            if (profilePicture) {
              reply.send({
                simplydata: {
                  error: false,
                  apiversion: fastify.config.APIVERSION,
                  access_token: token,
                  picture: profilePicture.picture,
                  phone: loginObject.delivery.phone,
                  deliveryBoyId: loginObject.delivery.deliveryBoyId,
                  deliveryBoyname: loginObject.delivery.name,
                  address: loginObject.delivery.address,
                  phoneVerified: loginObject.delivery.phoneVerified,
                  oneTimePasswordSetFlag:
                    loginObject.delivery.oneTimePasswordSetFlag,
                  supplierId: loginObject.delivery.supplierId,
                  suppliername: loginObject.delivery.suppliername,
                  longitude: loginObject.delivery.longitude,
                  latitude: loginObject.delivery.latitude,
                },
              });
            }
          }
        } else {
          error = {
            simplydata: {
              error: true,
              code: 400,
              message: "Invalid Details",
            },
          };
          reply.send(error);
        }
      } 
    }else {
      error = {
        armintatankdata: {
          error: true,
          code: 10005,
          message: "10005 - Verification code entered cannot be validated.",
        },
      };
      req.body.regError = error;
      reply.send(error);
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

// Check if all the required fields are supplied by the user

exports.fieldCheck = async (req, reply) => {
  try {
    s_Data = {
      suppliername: req.body.suppliername,
      emails: req.body.emails,
      password: req.body.password,
      services: { password: { bcrypt: req.body.password } },
      phone: req.body.phone,
      profile: {
        firstName: req.body.firstName,
        lastName: req.body.lastName,
        contactNumber: req.body.phone,
        alternativeContactNumber: req.body.alternativeContactNumber,
        country: req.body.country,
        state: req.body.state,
        city: req.body.city,
        office_address: req.body.office_adress,
        zip: req.body.zip,
      },
    };

    var supplier = new Supplier(s_Data);

    console.log(supplier, "..supplier");
    //password is not at the top level in the collection.
    password = req.body.password;

    // capture fields if data is sent via form instead of json encoding

    checkFormEncoding = isSupplierFormUrlEncoded(req);
    if (checkFormEncoding.isSupplierFormUrlEncoded) {
      suppliertobeInserted = checkFormEncoding.supplier;
      supplier.suppliername = suppliertobeInserted.suppliername;
      supplier.phone = suppliertobeInserted.phone;
      supplier.emails = suppliertobeInserted.emails;
      password = suppliertobeInserted.password;
    }
    console.log(
      "User to be inserted is ",
      supplier.suppliername,
      password,
      supplier.phone,
      supplier.profile
    );
    // check if all rerquired fields are passed.
    if (
      !(
        supplier.suppliername &&
        password &&
        supplier.phone &&
        // user.profile.firstName &&
        // user.profile.lastName &&
        // user.profile.address1 &&
        supplier.emails[0].email
      )
    ) {
      console.log(
        supplier.suppliername,
        password,
        supplier.phone,
        // user.profile.firstName,
        // user.profile.lastName,
        supplier.emails[0].email
      );
      // Required Fields are missing
      suppliedvalues =
        supplier.suppliername +
        " ," +
        password +
        " ," +
        supplier.phone +
        " ," +
        supplier.firstName +
        " ," +
        supplier.lastName +
        " ," +
        supplier.emails[0].email;
      error = {
        armintatankdata: {
          error: true,
          code: 10004,
          message:
            "10004 - suppliername, password, phone , firstname , lastname email city country state address1 and zip are required fields. Supplied values are " +
            suppliedvalues,
        },
      };
      req.body.regError = error;
      reply.send(error);
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.validatePhoneFormat = async (req, reply) => {
  try {
    var supplier = new Supplier(req.body);

    // check if user supplied phone is of the right format.
    // Handle if the user data is supplied via a url encoded form
    // capture fields if data is sent via form instead of json encoding

    checkFormEncoding = isSupplierFormUrlEncoded(req);
    console.log(checkFormEncoding);
    if (checkFormEncoding.isSupplierFormUrlEncoded) {
      suppliertobeInserted = checkFormEncoding.supplier;
      supplier.suppliername = suppliertobeInserted.suppliername;
      supplierser.firstName = suppliertobeInserted.firstName;
      supplier.lastName = suppliertobeInserted.lastName;
      supplier.phone = suppliertobeInserted.phone;
      supplier.emails = suppliertobeInserted.emails;
    }
    if (supplier) {
      const phoneNumber = libphonenumberjs.parsePhoneNumber(supplier.phone);
      if (phoneNumber) {
        // access returned collection
        if (!phoneNumber.isValid()) {
          error = {
            armintatankdata: {
              error: true,
              code: 10002,
              message:
                "10002 - Phone # " +
                supplier.phone +
                " is not a valid phone number",
            },
          };
          req.body.regError = error;
          reply.status(406).send(error);
        }
      }
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.verifySupplier = async (req, reply) => {
  try {
    var supplier = new Supplier(req.body);
    // Handle if the user data is supplied via a url encoded form
    // capture fields if data is sent via form instead of json encoding

    checkFormEncoding = isSupplierFormUrlEncoded(req);
    if (checkFormEncoding.isSupplierFormUrlEncoded) {
      suppliertobeInserted = checkFormEncoding.supplier;
      supplier.suppliername = suppliertobeInserted.suppliername;
      supplier.firstName = suppliertobeInserted.firstName;
      supplier.lastName = suppliertobeInserted.lastName;
      supplierr.phone = suppliertobeInserted.phone;
      supplier.emails = suppliertobeInserted.emails;
    }
    phone = supplier.phone;
    supplierpass = req.body.password;

    // check if user exists in the system. If user exists , display message that
    // phone number is not available

    supplierExists = await Supplier.findOne({ phone: phone });
    if (supplierExists) {
      // return user exists message
      error = {
        armintatankdata: {
          error: true,
          code: 10001,
          message:
            "10001 - Phone " +
            supplierExists.phone +
            " is not available. please use a different phone number",
        },
      };
      req.body.regError = error;
      reply.send(error);
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.validateEmailFormat = async (req, reply) => {
  try {
    var supplier = new Supplier(req.body);
    // Handle if the user data is supplied via a url encoded form
    // capture fields if data is sent via form instead of json encoding

    checkFormEncoding = isSupplierFormUrlEncoded(req);
    if (checkFormEncoding.isSupplierFormUrlEncoded) {
      suppliertobeInserted = checkFormEncoding.supplier;
      supplier.suppliername = suppliertobeInserted.suppliername;
      supplier.firstName = suppliertobeInserted.firstName;
      supplier.lastName = suppliertobeInserted.lastName;
      supplierr.phone = suppliertobeInserted.phone;
      supplier.emails = suppliertobeInserted.emails;
    }
    supplieremail = await supplier.emails[0].email;
    // check if user supplied email is of the right format.
    if (supplier) {
      const isValidEmail = emailValidator.validate(supplieremail.trim());
      if (!isValidEmail) {
        // Return email invalid format message
        error = {
          armintatankdata: {
            error: true,
            code: 10003,
            message:
              "10003 - Email " +
              supplier.emails[0].email +
              " is not a valid email",
          },
        };
        req.body.regError = error;
        reply.send(error);
      }
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.logoutsupplier = async (request, reply) => {
  // request.session.delete();

  // // send response to clear token
  // reply.send({ message: 'Successfully logged out' })

  const invalidatedTokens = {};
  const accessToken =
    request.headers.authorization && request.body.access_token;
  invalidatedTokens[accessToken] = true;

  //   // localStorage.removeItem(invalidatedTokens[accessToken])

  reply.send({ message: "Logout successful" });
};

exports.verifyPhone = async (req, reply) => {
  console.log("-------------------------------------------------");
  try {
    phone = req.body.phone;
    phoneVerificationCode = req.body.phoneVerificationCode;

    // check if user exists in the system. If user exists , display message that
    // username is not available
    console.log(
      "this is the phone and verification code",
      phone,
      phoneVerificationCode
    );
    supplierExists = await Supplier.findOne({
      phone: phone,
      phoneVerified: false,
      phoneVerificationCode: phoneVerificationCode,
    });
    console.log(supplierExists);
    if (supplierExists) {
      // update the phoneVerified flag to true.
      const filter = {
        phone: phone,
        phoneVerificationCode: phoneVerificationCode,
      };
      const update = { phoneVerified: true };
      const doc = await Supplier.findOneAndUpdate(filter, update);
      updatedSupplier = await Supplier.findOne({ phone: phone });

      if (updatedSupplier.phoneVerified) {
        reply.send('{"armintatankdata":{"error":false,"verified": true}}');
      } else {
        error = {
          armintatankdata: {
            error: true,
            code: 10005,
            message: "10005 - Verification code entered cannot be validated.",
          },
        };
        req.body.regError = error;
        reply.send(error);
      }
    } else {
      error = {
        armintatankdata: {
          error: true,
          code: 10005,
          message: "10005 - Verification code entered cannot be validated.",
        },
      };
      req.body.regError = error;
      reply.send(error);
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

// exports.deliveryBoyVerifyPhone = async (req, reply) => {
//   console.log("-------------------------------------------------");
//   try {
//     phone = req.body.phone;
//     phoneVerificationCode = req.body.phoneVerificationCode;

//     // check if user exists in the system. If user exists , display message that
//     // username is not available
//     console.log(
//       "this is the phone and verification code",
//       phone,
//       phoneVerificationCode
//     );
//     deliveryBoyExists = await DeliveryBoy.findOne({
//       phone: phone,
//       phoneVerified: false,
//       phoneVerificationCode: phoneVerificationCode,
//     });
//     console.log(deliveryBoyExists);
//     if (deliveryBoyExists) {
//       // update the phoneVerified flag to true.
//       const filter = {
//         phone: phone,
//         phoneVerificationCode: phoneVerificationCode,
//       };
//       const update = { phoneVerified: true };
//       const doc = await DeliveryBoy.findOneAndUpdate(filter, update);
//       updatedDeliveryBoy = await DeliveryBoy.findOne({ phone: phone });

//       if (updatedDeliveryBoy.phoneVerified) {
//         reply.send('{"armintatankdata":{"error":false,"verified": true}}');
//       } else {
//         error = {
//           armintatankdata: {
//             error: true,
//             code: 10005,
//             message: "10005 - Verification code entered cannot be validated.",
//           },
//         };
//         req.body.regError = error;
//         reply.send(error);
//       }
//     }
//   } catch (err) {
//     throw boom.boomify(err);
//   }
// };

//delete selected deliveryboy
exports.deleteDeliveryBoy = async (req, reply) => {
  try {
    var supplierId = req.params.supplierId;
    var phone = req.query.phone;
    const delivery = await DeliveryBoy.findOneAndDelete({
      phone: phone,
      supplierId: supplierId,
    });

    reply.send({ status_code: 200, data: delivery });
    // return tank;
  } catch (err) {
    throw boom.boomify(err);
  }
};

//update selected Delivery Boy Details
exports.updateDeliveryBoy = async (req, reply) => {
  try {
    var supplierId = req.params.supplierId;
    var phone = req.query.phone;
    const delivery = req.body;
    const { ...updateData } = delivery;
    const update = await DeliveryBoy.findOneAndUpdate(
      { phone: phone, supplierId: supplierId },
      updateData,
      { new: true }
    );
    console.log(update);
    //return update;

    reply.send({ status_code: 200, data: update });
  } catch (err) {
    throw boom.boomify(err);
  }
};

// Get current supplier
exports.getCurrentSupplier = async (req, reply) => {
  try {
    const supplierId = req.body.supplierId;
    const suppliers = await Supplier.findOne({ supplierId: supplierId });
    return suppliers;
  } catch (err) {
    throw boom.boomify(err);
  }
};
// Get all suppliers
// exports.getSuppliers = async (req, reply) => {
//   const limit = parseInt(req.query.limit) || 100;
//   const page = parseInt(req.query.page) || 1;
//   const startindex = (page - 1) * limit;
//   try {
//     await Supplier.find()
//       .limit(limit)
//       .skip(startindex)
//       .exec()
//       .then((docs) => {
//         reply.send({ status_code: 200, data: docs, count: docs.length });
//       })
//       .catch((err) => {
//         console.log(err);
//         reply.send({ error: err });
//       });
//   } catch (err) {
//     throw boom.boomify(err);
//   }
// };



exports.getSuppliers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const customerId = req.params.customerId; // Assuming you have already authenticated the user and stored their ID in the request object
  try {
    const friendRequests = await FriendRequest.find({ customerId });
    const supplierIdsToExclude = friendRequests.map(
      (request) => request.supplierId
    );
    const suppliers = await Supplier.find({ supplierId: { $nin: supplierIdsToExclude } })
      .limit(limit)
      .skip(startindex)
      .exec();

    const supplierIds = suppliers.map((supplier) => supplier.supplierId);
    const profilePictures = await profilePictureSupplier.find({
      supplierId: { $in: supplierIds },
    }).exec();

    const data = suppliers.map((supplier) => {
      const profilePicture = profilePictures.find(
        (picture) => picture.supplierId === supplier.supplierId
      );
      return {
        ...supplier.toObject(),
        picture: profilePicture ? profilePicture.picture : null,
      };
    });

    reply.send({ status_code: 200, data, count: data.length });
  } catch (err) {
    throw boom.boomify(err);
  }
};

// Get single user by ID
exports.getSingleSupplier = async (req, reply) => {
  try {
    const supplierId = req.params.supplierId;
    const supplier = await Supplier.findOne({ supplierId: supplierId });
    return supplier;
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getConnectedSuppliers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const customerId = req.params.customerId; // Assuming you have already authenticated the user and stored their ID in the request object
  try {
    const friendRequests = await FriendRequest.find({
      customerId,
      status: "accepted",
    });
    //   console.log(friendRequests,customerId)
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.supplierId
    );
    await Supplier.find({ supplierId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getPendingSuppliers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const customerId = req.params.customerId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      customerId,
      status: ["pending"],
    });
    // console.log(friendRequests,customerId)
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.supplierId
    );
    console.log(supplierIdsToInclude, "SUPLIERINCLUDE");
    
    const timestamps = friendRequests.map(request => request.timestamp);
      console.log(timestamps, "timestamps");
    await Supplier.find({ supplierId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        const customerDataWithTimestamp = docs.map((doc, index) => ({
          ...doc._doc,
          timestamp: timestamps[index],
        }));
        reply.send({
          status_code: 200,
          data: customerDataWithTimestamp,
          count: docs.length,
        });
        //reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getRejectSuppliers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const customerId = req.params.customerId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      customerId,
      status: ["rejected"],
    });
    // console.log(friendRequests,customerId)
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.supplierId
    );
    //   console.log(supplierIdsToInclude)
    await Supplier.find({ supplierId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};



exports.getPendingCustomers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const supplierId = req.params.supplierId;

  try {
    const friendRequests = await FriendRequest.find({
      supplierId,
      status: ["pending"],
    });
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.customerId
    );
    // const timestamps = friendRequests.map(request =>
    //   moment(request.timestamp, "DD-MM-YYYYTHH:mm:ss.SSSZ").format("DD-MM-YYYY hh:mm:ss")
    // );
    const timestamps = friendRequests.map(request => request.timestamp);
    console.log(timestamps, "timestamps");

    await User.find({ customerId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        const customerDataWithTimestamp = docs.map((doc, index) => ({
          ...doc._doc,
          timestamp: timestamps[index],
        }));
        reply.send({
          status_code: 200,
          data: customerDataWithTimestamp,
          count: docs.length,
        });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getRejectCustomers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const supplierId = req.params.supplierId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      supplierId,
      status: ["rejected"],
    });
    console.log(friendRequests, supplierId, "su....");
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.customerId
    );
    console.log(supplierIdsToInclude, "supplierIdsToInclude..");
    await User.find({ customerId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getconnectedCustomers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const supplierId = req.params.supplierId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      supplierId,
      status: ["accepted"],
    });
    console.log(friendRequests, supplierId, "su....");
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.customerId
    );
    console.log(supplierIdsToInclude, "supplierIdsToInclude..");
    await User.find({ customerId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};


// exports.uploadProfilePicture = async (req, reply) => {
//   try {
//      const supplierId = req.params.supplierId;
//     const picture = req.body.picture;
    
//     let profilePicture = await profilePictureSupplier.findOne({ supplierId });

//     console.log(profilePicture,"profile===")
//     if (!profilePicture) {
//       profilePicture = new profilePictureSupplier({
//         supplierId,
//         picture,
//       });
//     } else {
//       profilePicture.picture = picture;
//     }

//     await profilePicture.save();

//     reply.send({ message: 'Profile picture uploaded successfully' });
//   } catch (error) {
//     reply.status(500).send({ error: error.message });
//   }
// };


// const multer = require('multer');
// const fs = require('fs');


// // Multer storage configuration
// const storage = multer.diskStorage({
//   destination: function (req, file, cb) {
//     // Specify the destination folder for storing uploaded files
//     cb(null, './uploads');
//   },
//   filename: function (req, file, cb) {
//     // Generate a unique filename for the uploaded file
//     cb(null, file.originalname);
//   },
// });

// // Multer upload configuration
// const upload = multer({ storage: storage }).single('picture');

// // Handler for uploading profile picture
// exports.uploadProfilePicture = async (req, res) => {
//   try {
//     upload(req, res, async (err) => {
//       if (err) {
//         return res.status(400).send({ error: 'Failed to upload profile picture' });
//       }

//       const supplierId = req.params.supplierId;
//       const picture = req.file.filename;

//       let profilePicture = await ProfilePictureSupplier.findOne({ supplierId });

//       if (!profilePicture) {
//         profilePicture = new ProfilePictureSupplier({
//           supplierId,
//           picture,
//         });
//       } else {
//         profilePicture.picture = picture;
//       }

//       await profilePicture.save();

//       res.send({ message: 'Profile picture uploaded successfully' });
//     });
//   } catch (error) {
//     res.status(500).send({ error: error.message });
//   }
// };


// const { Storage } = require('@google-cloud/storage');

// const storage = new Storage({
//   keyFilename :`/home/bhaskar/Downloads/arminta-tank-0f492875da39.json`,
//   projectId : `arminta-tank`
// });

// const bucketName = 'armintaprofile_picture';

// exports.uploadProfilePicture = async (req, res) => {
//   try {
//     const supplierId = req.params.supplierId;
//     const file = req.body.picture;

//     // Check if the required properties are present
//     if (!file) {
//       return res.status(400).send({ error: 'No picture file provided' });
//     }

//     // Upload the file to the GCS bucket
//     const bucket = storage.bucket(bucketName);
//     const fileName = `${supplierId}/${file.originalname}`;
//     const fileOptions = {
//       metadata: {
//         contentType: 'multipart/form-data',
//       },
//     }; 

//     await bucket.upload(file.path, {
//       destination: `armintaprofile_picture/${fileName}`,
//       ...fileOptions,
//     });

//     const imageUrl = `https://storage.googleapis.com/${bucketName}/${fileName}`;
//     console.log(imageUrl);

//     let profilePicture = await ProfilePictureSupplier.findOne({ supplierId });
//     console.log("profilePicture", profilePicture);
//     if (!profilePicture) {
//       profilePicture = new ProfilePictureSupplier({
//         supplierId,
//         picture: imageUrl,
//       });
//     } else {
//       profilePicture.picture = imageUrl;
//     }

//     await profilePicture.save();

//     // Delete the temporary file after uploading to GCS
//     fs.unlinkSync(file.path);

//     res.send({ message: 'Profile picture uploaded successfully' });
//   } catch (error) {
//     res.status(500).send({ error: error.message });
//   }
// },


// const { Storage } = require('@google-cloud/storage');

// const storage = new Storage({
//   keyFilename: '/home/bhaskar/Downloads/arminta-tank-0f492875da39.json',
//   projectId: 'arminta-tank',
// });

// const bucketName = 'armintaprofile_picture';

// exports.uploadProfilePicture = async (req, res) => {
//   try {
//     const supplierId = req.params.supplierId;

//     // Check if the required properties are present
//     if (!req.files || !req.files.picture) {
//       return res.status(400).send({ error: 'No picture file provided' });
//     }

//     const file = req.files.picture;
//     console.log("file", file)
//     // Upload the file to the GCS bucket
//     const bucket = storage.bucket(bucketName);
//     const fileName = `${supplierId}/${file.name}`;

//     const fileOptions = {
//       metadata: {
//         contentType: file.mimetype,
//       },
//     };

//     await bucket.upload(file.tempFilePath, {
//       destination: fileName,
//       ...fileOptions,
//     });

//     const imageUrl = `https://storage.googleapis.com/${bucketName}/${fileName}`;
//     console.log(imageUrl);

//     let profilePicture = await ProfilePictureSupplier.findOne({ supplierId });
//     console.log('profilePicture', profilePicture);
//     if (!profilePicture) {
//       profilePicture = new ProfilePictureSupplier({
//         supplierId,
//         picture: imageUrl,
//       });
//     } else {
//       profilePicture.picture = imageUrl;
//     }

//     await profilePicture.save();

//     // Delete the temporary file after uploading to GCS
//     fs.unlinkSync(file.tempFilePath);

//     res.send({ message: 'Profile picture uploaded successfully' });
//   } catch (error) {
//     res.status(500).send({ error: error.message });
//   }
// };


const { Storage } = require('@google-cloud/storage');
const fs = require('fs');

const storage = new Storage({
  keyFilename: '/home/bhaskar/Downloads/arminta-tank-3c665db761bc.json',
  projectId: 'arminta-tank',
});

const bucketName = 'armintaprofile_picture';

// exports.uploadProfilePicture = async (req, res) => {
//   try {
//     const supplierId = req.body.supplierId;

//     // Check if the required properties are present
//     if (!req.files || !req.files.picture) {
//       return res.status(400).send({ error: 'No picture file provided' });
//     }

//     const file = `/home/bhaskar/Desktop/download.jpeg`;
//     console.log("file", file)
//     console.log("supplierId", supplierId)
//     // Upload the file to the GCS bucket
//     const bucket = storage.bucket(bucketName);
//     const fileName = `${supplierId}/${file.name}`;

//     const fileOptions = {
//       metadata: {
//         contentType: file.mimetype,
//       },
//     };

//     await bucket.upload(file.tempFilePath, {
//       destination: fileName,
//       ...fileOptions,
//     });

//     const imageUrl = `https://storage.googleapis.com/${bucketName}/${fileName}`;

//     let profilePicture = await profilePictureSupplier.findOne({ supplierId });

//     if (!profilePicture) {
//       profilePicture = new profilePictureSupplier({
//         supplierId,
//         picture: imageUrl,
//       });
//     } else {
//       profilePicture.picture = imageUrl;
//     }

//     await profilePicture.save();

//     // Delete the temporary file after uploading to GCS
//     fs.unlinkSync(file.tempFilePath);

//     res.send({ message: 'Profile picture uploaded successfully' });
//   } catch (error) {
//     res.status(500).send({ error: error.message });
//   }
// };



// exports.uploadProfilePicture = async (req, res) => {
//   try {
//     upload(req, res, async (err) => {
//       if (err) {
//         return res.status(400).send({ error: 'Failed to upload profile picture' });
//       }

//       const supplierId = req.params.supplierId;
//       const picture = req.file; // Assuming the file field in the request is named 'picture'

//       // Upload the file to the GCS bucket
//       const bucket = storage.bucket(bucketName);
//       const fileName = `${supplierId}/${file.originalname}`;
//       const fileOptions = {
//         metadata: {
//           contentType: file.mimetype,
//         },
//       };

//       await bucket.upload(filepath, {
//         destination: `armintaprofile_picture/${picture}`,
//         ...fileOptions,
//       });

//       const imageUrl = `https://storage.googleapis.com/${bucketName}/${fileName}`;
//       console.log(imageUrl)

//       let profilePicture = await ProfilePictureSupplier.findOne({ supplierId });
//       console.log("profilePicture", profilePicture)
//       if (!profilePicture) {
//         profilePicture = new ProfilePictureSupplier({
//           supplierId,
//           picture: imageUrl,
//         });
//       } else {
//         profilePicture.picture = imageUrl;
//       }

//       await profilePicture.save();

//       // Delete the temporary file after uploading to GCS
//       fs.unlinkSync(file.path);

//       res.send({ message: 'Profile picture uploaded successfully' });
//     });
//   } catch (error) {
//     res.status(500).send({ error: error.message });
//   }
// };

// exports.uploadProfilePicture = async (req, res) => {
//   try {
//     upload(req, res, async (err) => {
//       if (err) {
//         return res.status(400).send({ error: 'Failed to upload profile picture' });
//       }

//       const supplierId = req.params.supplierId;
//       const picture = req.file.filename; // Assuming the file field in the request is named 'picture'

//       // Upload the picture to the GCP bucket
//       const bucketName = 'armintaprofile_picture';
//       const bucket = storage.bucket(bucketName);
//       const uploadPath = `armintaprofile_picture/${picture}`;

//       await bucket.upload(req.file.path, {
//         destination: uploadPath,
//       });
//       console.log("bucket",bucket)
//       console.log(uploadPath, "uploadPath")
//       // Get the public URL of the uploaded picture
//       const file = bucket.file(uploadPath);
//       const [metadata] = await file.getMetadata();
//       const pictureUrl = metadata.mediaLink;

//       let profilePicture = await profilePictureSupplier.findOne({ supplierId });
//       if (!profilePicture) {
//         profilePicture = new profilePictureSupplier({
//           supplierId,
//           picture: pictureUrl,
//         });
//       } else {
//         profilePicture.picture = pictureUrl;
//       }

//       await profilePicture.save();

//       res.send({ message: 'Profile picture uploaded successfully' });
//     });
//   } catch (error) {
//     res.status(500).send({ error: error.message });
//   }
// };

// Route for fetching profile picture data
fastify.get('/api/users/profile-picture-supplier/:supplierId', async (req, res) => {
  try {
    const supplierId = req.params.supplierId;
    const profilePicture = await ProfilePictureSupplier.findOne({ supplierId });

    if (!profilePicture) {
      return res.status(404).send({ error: 'Profile picture not found' });
    }

    // Send the profile picture data as a response
    res.send({ picture: profilePicture.picture });
  } catch (error) {
    res.status(500).send({ error: error.message });
  }
});