|
|
//Get the data models
|
|
|
const { Supplier, DeliveryBoy, profilePictureSupplier } = require("../models/supplier");
|
|
|
const { FriendRequest } = require("../models/supplier");
|
|
|
const { Tanker,Tankerbooking } = require("../models/tankers");
|
|
|
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 customerId = req.params.customerId;
|
|
|
|
|
|
const {
|
|
|
type_of_water,
|
|
|
capacity: requestedCapacityStr,
|
|
|
quantity: requestedQuantityStr,
|
|
|
date,
|
|
|
time
|
|
|
} = req.body;
|
|
|
|
|
|
const parseCapacity = (value) => parseFloat((value || "0").toString().replace(/,/g, ""));
|
|
|
|
|
|
const requestedCapacity = parseCapacity(requestedCapacityStr);
|
|
|
const requestedQuantity = parseInt(requestedQuantityStr || "0");
|
|
|
const totalRequiredCapacity = requestedCapacity * requestedQuantity;
|
|
|
|
|
|
try {
|
|
|
const tankerBookings = await Tankerbooking.find({ date });
|
|
|
const bookedTankerSet = new Set(
|
|
|
tankerBookings.map(booking => `${booking.supplierId}_${booking.tankerName}`)
|
|
|
);
|
|
|
|
|
|
// 1️⃣ Only filter typeofwater first
|
|
|
let tankers = await Tanker.find({ typeofwater: type_of_water });
|
|
|
|
|
|
// 2️⃣ Exclude booked tankers
|
|
|
tankers = tankers.filter(tanker => {
|
|
|
const key = `${tanker.supplierId}_${tanker.tankerName}`;
|
|
|
return !bookedTankerSet.has(key);
|
|
|
});
|
|
|
|
|
|
// 3️⃣ Group by supplierId
|
|
|
const supplierTankerMap = {};
|
|
|
for (let tanker of tankers) {
|
|
|
if (!supplierTankerMap[tanker.supplierId]) {
|
|
|
supplierTankerMap[tanker.supplierId] = [];
|
|
|
}
|
|
|
supplierTankerMap[tanker.supplierId].push(tanker);
|
|
|
}
|
|
|
|
|
|
// 4️⃣ Aggregate supplier capacities
|
|
|
const qualifiedSuppliers = [];
|
|
|
for (let [supplierId, supplierTankers] of Object.entries(supplierTankerMap)) {
|
|
|
const totalAvailableCapacity = supplierTankers.reduce(
|
|
|
(sum, t) => sum + parseCapacity(t.capacity),
|
|
|
0
|
|
|
);
|
|
|
|
|
|
if (totalAvailableCapacity >= totalRequiredCapacity) {
|
|
|
qualifiedSuppliers.push({ supplierId, tankers: supplierTankers });
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const connected_suppliers = [];
|
|
|
const non_connected_suppliers = [];
|
|
|
|
|
|
for (let supplierObj of qualifiedSuppliers) {
|
|
|
const supplierData = await Supplier.findOne({ supplierId: supplierObj.supplierId });
|
|
|
|
|
|
const responseData = {
|
|
|
supplier: supplierData,
|
|
|
tankers: supplierObj.tankers
|
|
|
};
|
|
|
|
|
|
// 🔥 The correct friend request check:
|
|
|
const friendRequest = await FriendRequest.findOne({
|
|
|
customerId: customerId,
|
|
|
supplierId: supplierObj.supplierId
|
|
|
});
|
|
|
|
|
|
if (friendRequest && friendRequest.status === "accepted") {
|
|
|
connected_suppliers.push(responseData);
|
|
|
} else {
|
|
|
non_connected_suppliers.push(responseData);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
reply.send({
|
|
|
status_code: 200,
|
|
|
connected_suppliers,
|
|
|
non_connected_suppliers
|
|
|
});
|
|
|
|
|
|
} catch (err) {
|
|
|
console.error(err);
|
|
|
reply.send({
|
|
|
status_code: 500,
|
|
|
message: "Something went wrong",
|
|
|
error: err.message
|
|
|
});
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 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.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;
|
|
|
|
|
|
try {
|
|
|
// Get user's favorite suppliers
|
|
|
const user = await User.findOne({ customerId }, 'favorate_suppliers');
|
|
|
const favorateSuppliers = user?.favorate_suppliers || [];
|
|
|
|
|
|
// Get accepted friend requests
|
|
|
const friendRequests = await FriendRequest.find({
|
|
|
customerId,
|
|
|
status: "accepted",
|
|
|
});
|
|
|
|
|
|
const supplierIdsToInclude = friendRequests.map(req => req.supplierId);
|
|
|
|
|
|
// Get suppliers
|
|
|
const suppliers = await Supplier.find({
|
|
|
supplierId: { $in: supplierIdsToInclude }
|
|
|
})
|
|
|
.limit(limit)
|
|
|
.skip(startindex)
|
|
|
.exec();
|
|
|
|
|
|
const supplierIds = suppliers.map(s => s.supplierId);
|
|
|
|
|
|
// Get profile pictures
|
|
|
const profilePictures = await profilePictureSupplier.find({
|
|
|
supplierId: { $in: supplierIds }
|
|
|
});
|
|
|
|
|
|
// Construct final response
|
|
|
const data = suppliers.map((supplier) => {
|
|
|
const profilePicture = profilePictures.find(
|
|
|
(pic) => pic.supplierId === supplier.supplierId
|
|
|
);
|
|
|
const isFavorate = favorateSuppliers.includes(supplier.supplierId);
|
|
|
|
|
|
return {
|
|
|
...supplier.toObject(),
|
|
|
picture: profilePicture ? profilePicture.picture : null,
|
|
|
favorate: isFavorate,
|
|
|
};
|
|
|
});
|
|
|
|
|
|
reply.send({ status_code: 200, data, count: data.length });
|
|
|
} 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.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"],
|
|
|
});
|
|
|
|
|
|
const supplierIdsToInclude = friendRequests.map(
|
|
|
(request) => request.supplierId
|
|
|
);
|
|
|
|
|
|
const timestamps = friendRequests.map((request) => request.timestamp);
|
|
|
|
|
|
const suppliers = await Supplier.find({
|
|
|
supplierId: { $in: supplierIdsToInclude },
|
|
|
})
|
|
|
.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, index) => {
|
|
|
const profilePicture = profilePictures.find(
|
|
|
(picture) => picture.supplierId === supplier.supplierId
|
|
|
);
|
|
|
return {
|
|
|
...supplier.toObject(),
|
|
|
timestamp: timestamps[index],
|
|
|
picture: profilePicture ? profilePicture.picture : null,
|
|
|
};
|
|
|
});
|
|
|
|
|
|
reply.send({ status_code: 200, data, count: data.length });
|
|
|
} 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.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"],
|
|
|
});
|
|
|
|
|
|
const supplierIdsToInclude = friendRequests.map(
|
|
|
(request) => request.supplierId
|
|
|
);
|
|
|
|
|
|
const suppliers = await Supplier.find({
|
|
|
supplierId: { $in: supplierIdsToInclude },
|
|
|
})
|
|
|
.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);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 });
|
|
|
}
|
|
|
});
|
