You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
794 lines
22 KiB
794 lines
22 KiB
const { Tanker, Tankerbooking,Bore,GovtPipeLine,UserSupplierAccounts } = require('../models/tankers')
|
|
const { User,Counter, generateBookingId,resetCounter,generateCustomerId } = require('../models/User')
|
|
|
|
const { Supplier, generateSupplierId, FriendRequest,DeliveryBoy} = require("../models/supplier")
|
|
|
|
//const User = require("../models/User");
|
|
const boom = require("boom");
|
|
|
|
|
|
const fastify = require("fastify")({
|
|
logger: true,
|
|
});
|
|
|
|
|
|
|
|
|
|
exports.addTankers = async (req, reply) => {
|
|
try {
|
|
|
|
//const username = req.params.username;
|
|
|
|
console.log(req.params);
|
|
const supplierId = req.params.supplierId;
|
|
//console.log(loginObject.user.username)
|
|
// const userInfo = await User.findOne({ username: username.toString() });
|
|
// const updateData = req.body;
|
|
|
|
|
|
// console.log("This is the reply in the handler after the validations", reply);
|
|
tankersData = {
|
|
supplierId:supplierId,
|
|
|
|
supplier_name:req.body.supplier_name,
|
|
supplier_address : req.body.supplier_address,
|
|
tankerName: req.body.tankerName,
|
|
phoneNumber: req.body.phoneNumber,
|
|
alternative_phoneNumber: req.body.alternative_phoneNumber,
|
|
typeofwater: req.body.typeofwater,
|
|
capacity: req.body.capacity,
|
|
price: req.body.price,
|
|
status: req.body.status
|
|
};
|
|
console.log(req.body.typeofwater,req.body.capacity)
|
|
|
|
var tanker_Name = req.body.tankerName
|
|
var i_tank = await Tanker.findOne({ tankerName: tanker_Name,supplierId:supplierId})
|
|
if(i_tank){
|
|
throw new Error('tankername already exists');
|
|
}
|
|
else {
|
|
|
|
var tankers = new Tanker(tankersData);
|
|
|
|
checkFormEncoding = isUserFormUrlEncoded(req);
|
|
if (checkFormEncoding.isUserFormUrlEncoded) {
|
|
usertobeInserted = checkFormEncoding.tankers;
|
|
console.log("thsi true url string");
|
|
tankers.supplier_name = usertobeInserted.supplier_name;
|
|
tankers.supplier_address = usertobeInserted.supplier_address;
|
|
tankers.tankerName = usertobeInserted.tankerName;
|
|
tankers.phoneNumber = usertobeInserted.phoneNumber;
|
|
tankers.alternative_phoneNumber = usertobeInserted.alternative_phoneNumber;
|
|
tankers.capacity = usertobeInserted.capacity;
|
|
tankers.typeofwater = usertobeInserted.typeofwater;
|
|
tankers.price = usertobeInserted.price;
|
|
tankers.status = usertobeInserted.status;
|
|
}
|
|
}
|
|
const insertedTanker = await tankers.save();
|
|
|
|
return insertedTanker;
|
|
|
|
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
exports.deleteTankerInfo1 = async (req, reply) => {
|
|
try {
|
|
|
|
//const username = req.params.username;
|
|
|
|
console.log(req.params);
|
|
const supplierId = req.params.supplierId;
|
|
//console.log(loginObject.user.username)
|
|
// const userInfo = await User.findOne({ username: username.toString() });
|
|
// const updateData = req.body;
|
|
|
|
|
|
// console.log("This is the reply in the handler after the validations", reply);
|
|
tankersData = {
|
|
supplierId:supplierId,
|
|
|
|
supplier_name:req.body.supplier_name,
|
|
supplier_address : req.body.supplier_address,
|
|
tankerName: req.body.tankerName,
|
|
phoneNumber: req.body.phoneNumber,
|
|
alternative_phoneNumber: req.body.alternative_phoneNumber,
|
|
typeofwater: req.body.typeofwater,
|
|
capacity: req.body.capacity,
|
|
price: req.body.price,
|
|
status: req.body.status
|
|
};
|
|
console.log(req.body.typeofwater,req.body.capacity)
|
|
|
|
var tanker_Name = req.body.tankerName
|
|
var i_tank = await Tanker.findOne({ tankerName: tanker_Name,supplierId:supplierId})
|
|
if(i_tank){
|
|
throw new Error('tankername already exists');
|
|
}
|
|
else {
|
|
|
|
var tankers = new Tanker(tankersData);
|
|
|
|
checkFormEncoding = isUserFormUrlEncoded(req);
|
|
if (checkFormEncoding.isUserFormUrlEncoded) {
|
|
usertobeInserted = checkFormEncoding.tankers;
|
|
console.log("thsi true url string");
|
|
tankers.supplier_name = usertobeInserted.supplier_name;
|
|
tankers.supplier_address = usertobeInserted.supplier_address;
|
|
tankers.tankerName = usertobeInserted.tankerName;
|
|
tankers.phoneNumber = usertobeInserted.phoneNumber;
|
|
tankers.alternative_phoneNumber = usertobeInserted.alternative_phoneNumber;
|
|
tankers.capacity = usertobeInserted.capacity;
|
|
tankers.typeofwater = usertobeInserted.typeofwater;
|
|
tankers.price = usertobeInserted.price;
|
|
tankers.status = usertobeInserted.status;
|
|
}
|
|
}
|
|
const insertedTanker = await tankers.save();
|
|
|
|
return insertedTanker;
|
|
|
|
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
//update selected tanker
|
|
exports.updateTankersInfo = async (req, reply) => {
|
|
|
|
try {
|
|
var supplierId = req.params.supplierId;
|
|
var tankerName = req.query.tankerName;
|
|
var tanker = req.body;
|
|
const { ...updateData } = tanker;
|
|
const update = await Tanker.findOneAndUpdate({ supplierId:supplierId,tankerName: tankerName, }, updateData, { new: true });
|
|
//console.log(update.username)
|
|
//return update;
|
|
|
|
reply.send({ status_code: 200, data: update });
|
|
|
|
|
|
}
|
|
catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
//delete selected tanker
|
|
exports.deleteTankerInfo = async (req, reply) => {
|
|
try {
|
|
var supplierId = req.params.supplierId;
|
|
var tankerName = req.query.tankerName;
|
|
const tanker = await Tanker.findOneAndDelete({ supplierId:supplierId,tankerName: tankerName, });
|
|
reply.send({ status_code: 200, data: tanker});
|
|
// return tanker;
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.tankerBooking = async (req, reply) => {
|
|
|
|
try {
|
|
const customerId = req.params.customerId;
|
|
const tankerName = req.body.tankerName;
|
|
var b_id = await generateBookingId()
|
|
const date = new Date()
|
|
const year = date.getFullYear()
|
|
const month = (date.getMonth() + 1).toString().padStart(2, '0')
|
|
const day = date.getDate().toString().padStart(2, '0')
|
|
const bookingId = `ARM${year}${month}${day}${b_id}`
|
|
// const customer = await User.findOne({customerId:customerId})
|
|
// const customer_mobile = customer.phone
|
|
// const customer_name = customer.username
|
|
// const supplier = await Supplier.findOne({supplierId:req.body.supplierId})
|
|
// console.log(supplier, "11")
|
|
// const supplier_name = supplier.suppliername
|
|
// const supplier_mobile = supplier.phone
|
|
// console.log(supplier_mobile, "==========")
|
|
|
|
const customer = await User.findOne({customerId:customerId})
|
|
const customerPhone = customer.phone
|
|
const customerName = customer.username
|
|
const supplier = await Supplier.findOne({supplierId:req.body.supplierId})
|
|
const supplierName = supplier.suppliername
|
|
const supplierPhone = supplier.phone
|
|
var booking_id = await Tankerbooking.findOne({ bookingid: bookingId})
|
|
if(booking_id){
|
|
b_id= await generateBookingId()
|
|
}
|
|
else {
|
|
|
|
|
|
bookingsData = {
|
|
tankerName:tankerName,
|
|
customerId:customerId,
|
|
bookingid : bookingId,
|
|
typeofwater: req.body.typeofwater,
|
|
capacity: req.body.capacity,
|
|
address: req.body.address,
|
|
dateOfOrder: req.body.dateOfOrder,
|
|
price:req.body.price,
|
|
supplierId:req.body.supplierId,
|
|
tankName:req.body.tankName,
|
|
tankLocation:req.body.tankLocation,
|
|
latitude: req.body.latitude,
|
|
longitude: req.body.longitude,
|
|
//date: req.body.date,
|
|
// time: req.body.time,
|
|
customerPhone : customerPhone,
|
|
supplierPhone : supplierPhone,
|
|
customerName : customerName,
|
|
supplierName : supplierName,
|
|
|
|
};
|
|
|
|
var tankersBookingData = new Tankerbooking(bookingsData);
|
|
|
|
checkFormEncoding = isUserFormUrlEncoded(req);
|
|
if (checkFormEncoding.isUserFormUrlEncoded) {
|
|
usertobeInserted = checkFormEncoding.tankersBookingData;
|
|
console.log("thsi true url string");
|
|
tankersBookingData.customerId = customerId;
|
|
tankersBookingData.tankerName = tankerName;
|
|
tankersBookingData.bookingid = bookingId;
|
|
tankersBookingData.capacity = usertobeInserted.capacity;
|
|
tankersBookingData.typeofwater = usertobeInserted.typeofwater;
|
|
tankersBookingData.address = usertobeInserted.address;
|
|
tankersBookingData.dateOfOrder = usertobeInserted.dateOfOrder;
|
|
tankersBookingData.price = usertobeInserted.price;
|
|
tankersBookingData.supplierId = usertobeInserted.supplierId;
|
|
tankersBookingData.tankName = usertobeInserted.tankName;
|
|
tankersBookingData.tankLocation = usertobeInserted.tankLocation;
|
|
//tankersBookingData.date = usertobeInserted.date;
|
|
//tankersBookingData.time = usertobeInserted.time;
|
|
tankersBookingData.customerPhone = customerPhone;
|
|
tankersBookingData.supplierPhone = supplierPhone;
|
|
tankersBookingData.customerName = customerName;
|
|
tankersBookingData.supplierName = supplierName;
|
|
tankersBookingData.latitude =usertobeInserted.latitude
|
|
tankersBookingData.longitude=usertobeInserted.longitude
|
|
|
|
}
|
|
}
|
|
|
|
const booking_data = await tankersBookingData.save();
|
|
reply.send({ status_code: 200, data: booking_data });
|
|
|
|
return booking_data;
|
|
|
|
|
|
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.getTanker = async (req, reply) => {
|
|
try {
|
|
await Tanker.find({supplierId: req.query.supplierId})
|
|
.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.getallTanker = async (req, reply) => {
|
|
try {
|
|
await Tanker.find()
|
|
.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.getTankersBookingdetails = async (req, reply) => {
|
|
try {
|
|
const customerId = req.params.customerId
|
|
const tankerName = req.query.tankerName
|
|
|
|
await Tankerbooking.find({ customerId:customerId,tankerName: tankerName, })
|
|
.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.getAllTankersBookingdetails = 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 {
|
|
await Tankerbooking.find( { supplierId:supplierId })
|
|
.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.getAllTankersaccepted = 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 {
|
|
await Tankerbooking.find( { supplierId, orderStatus: ["accepted","rejected"] })
|
|
.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.addBores = async (req, reply) => {
|
|
try {
|
|
|
|
|
|
var customerId = req.params.customerId;
|
|
//console.log(customerId);
|
|
//const username = loginObject.user.username;
|
|
|
|
boresData = {
|
|
// InstallerId:InstallerId,
|
|
// customerId:req.body.customerId,
|
|
customerId:customerId,
|
|
boreName: req.body.boreName,
|
|
capacity: req.body.capacity,
|
|
typeofwater: req.body.typeofwater,
|
|
description: req.body.description,
|
|
};
|
|
|
|
|
|
var bore_Name = req.body.boreName
|
|
var i_bore = await Bore.findOne({ boreName: bore_Name,customerId:customerId})
|
|
if(i_bore){
|
|
throw new Error('Bore already exists');
|
|
}
|
|
else {
|
|
|
|
var bores = new Bore(boresData);
|
|
|
|
checkFormEncoding = isUserFormUrlEncoded(req);
|
|
if (checkFormEncoding.isUserFormUrlEncoded) {
|
|
usertobeInserted = checkFormEncoding.bores;
|
|
console.log("thsi true url string");
|
|
|
|
// bores.InstallerId = usertobeInserted.InstallerId
|
|
|
|
bores.customerId = usertobeInserted.customerId
|
|
bores.boreName = usertobeInserted.boreName;
|
|
bores.capacity = usertobeInserted.capacity;
|
|
bores.typeofwater = usertobeInserted.typeofwater;
|
|
bores.description = usertobeInserted.description;
|
|
}
|
|
}
|
|
const insertedBore = await bores.save();
|
|
|
|
return insertedBore;
|
|
|
|
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.getBores = async (req, reply) => {
|
|
try {
|
|
await Bore.find({customerId: req.query.customerId})
|
|
.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.getBoresbyInstaller = async (req, reply) => {
|
|
try {
|
|
await Bore.find({InstallerId: req.query.InstallerId})
|
|
.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.deleteBoresInfo = async (req, reply) => {
|
|
try {
|
|
|
|
|
|
await Bore.findOneAndDelete({customerId: req.params.customerId,boreName: req.query.boreName});
|
|
//console.log(Bore)
|
|
|
|
reply.send({ status_code: 200},);
|
|
// return Bore;
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
exports.updateBoresInfo = async (req, reply) => {
|
|
|
|
try {
|
|
var customerId = req.params.customerId;
|
|
var boreName = req.query.boreName;
|
|
const bore = req.body;
|
|
const { ...updateData } = bore;
|
|
const update = await Bore.findOneAndUpdate({ customerId:customerId,boreName: boreName, }, updateData, { new: true });
|
|
//console.log(update.username)
|
|
//return update;
|
|
|
|
reply.send({ status_code: 200, data: update });
|
|
|
|
|
|
}
|
|
catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
exports.addGovtPIpeline = async (req, reply) => {
|
|
try {
|
|
|
|
|
|
var customerId = req.params.customerId;
|
|
//console.log(customerId);
|
|
//const username = loginObject.user.username;
|
|
|
|
pipelineData = {
|
|
customerId:customerId,
|
|
Name: req.body.Name,
|
|
capacity: req.body.capacity,
|
|
typeofwater: req.body.typeofwater,
|
|
description: req.body.description,
|
|
};
|
|
|
|
|
|
var pipeline_Name = req.body.Name
|
|
var i_pipe = await GovtPipeLine.findOne({ Name: pipeline_Name,customerId:customerId})
|
|
if(i_pipe){
|
|
throw new Error('Pipeline already exists');
|
|
}
|
|
else {
|
|
|
|
var pipe_line = new GovtPipeLine(pipelineData);
|
|
|
|
checkFormEncoding = isUserFormUrlEncoded(req);
|
|
if (checkFormEncoding.isUserFormUrlEncoded) {
|
|
usertobeInserted = checkFormEncoding.pipe_line;
|
|
console.log("thsi true url string");
|
|
pipe_line.customerId = usertobeInserted.customerId
|
|
pipe_line.Name = usertobeInserted.Name;
|
|
pipe_line.capacity = usertobeInserted.capacity;
|
|
pipe_line.typeofwater = usertobeInserted.typeofwater;
|
|
pipe_line.description = usertobeInserted.description;
|
|
}
|
|
}
|
|
const insertedpipeline = await pipe_line.save();
|
|
|
|
return insertedpipeline;
|
|
|
|
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
exports.getPipeline = async (req, reply) => {
|
|
try {
|
|
await GovtPipeLine.find({customerId: req.query.customerId})
|
|
.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.deletePipelineInfo = async (req, reply) => {
|
|
try {
|
|
|
|
|
|
await GovtPipeLine.findOneAndDelete({customerId: req.params.customerId,Name: req.query.Name});
|
|
//console.log(Bore)
|
|
|
|
reply.send({ status_code: 200});
|
|
// return Bore;
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
exports.updatePipelineInfo = async (req, reply) => {
|
|
|
|
try {
|
|
var customerId = req.params.customerId;
|
|
var Name = req.query.Name;
|
|
const pipeline = req.body;
|
|
const { ...updateData } = pipeline;
|
|
const update = await GovtPipeLine.findOneAndUpdate({ customerId:customerId,Name: Name, }, updateData, { new: true });
|
|
//console.log(update.username)
|
|
//return update;
|
|
|
|
reply.send({ status_code: 200, data: update });
|
|
|
|
|
|
}
|
|
catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.status = async (req, reply) => {
|
|
|
|
try {
|
|
var status = req.query.status;
|
|
|
|
if (status === 'connected') {
|
|
try {
|
|
const tankers = await Tanker.find({});
|
|
console.log("tankers...", tankers)
|
|
reply.send(tankers);
|
|
} catch (err) {
|
|
reply.send({ message: err });
|
|
}
|
|
} else {
|
|
reply.send({ message: 'Not Connected' });
|
|
}
|
|
|
|
}
|
|
catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.connectionStatus = async (req, reply) => {
|
|
try {
|
|
// query the database to check if the customer and supplier are connected
|
|
const isConnected = await User.findOne({ customerId: req.query.customerId })
|
|
.populate('supplier', null, { supplierId: req.query.supplierId })
|
|
.exec()
|
|
.then(customer => customer.supplier !== null);
|
|
|
|
console.log("isconne..", isConnected)
|
|
|
|
if (isConnected) {
|
|
// if customer and supplier are connected, return list of tankers
|
|
const tankers = await Tanker.find({ }).exec();
|
|
console.log("tankers..", tankers)
|
|
reply.send({ tankers });
|
|
} else {
|
|
// if customer and supplier are not connected, return error
|
|
reply.status(403).send({ error: 'Forbidden' });
|
|
}
|
|
//res.send({ tankers });
|
|
} catch (err) {
|
|
console.error(err);
|
|
reply.status(500).send({ error: 'Internal server error' });
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
exports.connectstatus = async (req, reply) => {
|
|
|
|
try {
|
|
const customerId = req.params.customerId;
|
|
const supplierId = req.query.supplierId;
|
|
|
|
console.log(req.params.customerId)
|
|
console.log(req.query.supplierId)
|
|
const data = await FriendRequest.findOne({ customerId: customerId, supplierId: supplierId });
|
|
let connection_status = "not requested";
|
|
if (data) {
|
|
connection_status = data.status;
|
|
}
|
|
reply.send({ status_code: 200, customerId: customerId, supplierId: supplierId, status: connection_status });
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
//delete selected bookingid
|
|
exports.deleteBookingInfo = async (req, reply) => {
|
|
try {
|
|
var bookingid = req.params.bookingid;
|
|
|
|
const booking = await Tankerbooking.findOneAndDelete({ bookingid:bookingid });
|
|
|
|
reply.send({ status_code: 200, data: booking});
|
|
// return tank;
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.distrubanceStatus = async (req, reply) => {
|
|
try {
|
|
const bookingid = req.params.bookingid;
|
|
const action = req.body.action
|
|
const booking = await Tankerbooking.findOne({ bookingid:bookingid });
|
|
const distrubance_price = parseInt(booking.distrubance_price .replace(/,/g, ''), 10)
|
|
const price = parseInt(booking.price.replace(/,/g, ''), 10)
|
|
const amount_due = parseInt(booking.amount_due .replace(/,/g, ''), 10)
|
|
const price_variation = price-distrubance_price
|
|
if (action === "accept") {
|
|
await Tankerbooking.findOneAndUpdate({ bookingid:bookingid }, { $set: { amount_due: distrubance_price,amount_difference:price_variation},distrubance_status:"1" });
|
|
|
|
}
|
|
if (action === "reject") {
|
|
|
|
|
|
await Tankerbooking.findOneAndUpdate({ bookingid:bookingid }, { $set: { amount_due: price,amount_difference:"0",distrubance_status:"0" } });
|
|
|
|
}
|
|
|
|
|
|
reply.send({ status_code: 200, data: booking});
|
|
// return tank;
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
exports.UserSupplierAccounts = async (req, reply) => {
|
|
try {
|
|
const customerId = req.params.customerId;
|
|
const supplierId = req.body.supplierId
|
|
const booking = await Tankerbooking.find({ customerId:customerId,supplierId:supplierId,orderStatus:"delivered"});
|
|
const delivered_tankers = booking.length
|
|
console.log(delivered_tankers, booking.length)
|
|
let amount_due = 0
|
|
let amount_advance = 0
|
|
let TotalAmountPaid = 0
|
|
for (let i = 0; i < booking.length; i++) {
|
|
let order = booking[i];
|
|
|
|
TotalAmountPaid += parseInt(order.amount_paid.replace(/,/g, ''), 10)
|
|
amount_due += parseInt(order.amount_due.replace(/,/g, ''), 10)
|
|
|
|
}
|
|
|
|
console.log("TotalAmountPaid:", TotalAmountPaid);
|
|
console.log("amount_due:", amount_due);
|
|
|
|
const user_accounts = await UserSupplierAccounts.findOne({ customerId:customerId,supplierId:supplierId });
|
|
if (user_accounts) {
|
|
|
|
|
|
await UserSupplierAccounts.findOneAndUpdate({ customerId:customerId,supplierId:supplierId }, { $set: { amount_due: amount_due,amount_paid:TotalAmountPaid,delivered_tankers:delivered_tankers } });
|
|
}
|
|
else{
|
|
|
|
UserSupplierData = {
|
|
customerId:customerId,
|
|
supplierId: supplierId,
|
|
amount_due: amount_due,
|
|
amount_paid: TotalAmountPaid,
|
|
amount_advance: amount_advance,
|
|
delivered_tankers:delivered_tankers
|
|
};
|
|
|
|
|
|
var user_supplier_accounts = new UserSupplierAccounts(UserSupplierData);
|
|
|
|
checkFormEncoding = isUserFormUrlEncoded(req);
|
|
if (checkFormEncoding.isUserFormUrlEncoded) {
|
|
|
|
user_supplier_accounts.customerId = customerId
|
|
user_supplier_accounts.supplierId = supplierId;
|
|
user_supplier_accounts.amount_due = amount_due;
|
|
user_supplier_accounts.amount_paid = TotalAmountPaid;
|
|
user_supplier_accounts.amount_advance = amount_advance;
|
|
user_supplier_accounts.delivered_tankers = delivered_tankers;
|
|
|
|
}
|
|
|
|
const inserteduser_supplier_accounts_data = await user_supplier_accounts.save();
|
|
|
|
|
|
}
|
|
reply.send({ status_code: 200, count: booking.length, data: booking,TotalAmountPaid:TotalAmountPaid,amount_due:amount_due });
|
|
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|