Sindbad~EG File Manager
const jwt = require("jsonwebtoken");
const bcrypt = require("bcrypt");
const db = require("../models");
const { Op } = require("sequelize");
const { col } = require("sequelize");
const bodyParser = require("body-parser");
function calculateDateRange(timeRange) {
const currentDate = new Date();
switch (timeRange) {
case "currentweek":
const currentWeekStartDate = new Date(currentDate);
currentWeekStartDate.setDate(
currentDate.getDate() - currentDate.getDay()
);
currentWeekStartDate.setHours(0, 0, 0, 0);
const currentWeekEndDate = new Date(currentDate);
currentWeekEndDate.setDate(
currentWeekEndDate.getDate() + (6 - currentWeekEndDate.getDay())
);
currentWeekEndDate.setHours(23, 59, 59, 999);
return { startDate: currentWeekStartDate, endDate: currentWeekEndDate };
case "lastweek":
const lastWeekStartDate = new Date(currentDate);
lastWeekStartDate.setDate(
lastWeekStartDate.getDate() - lastWeekStartDate.getDay() - 7
);
lastWeekStartDate.setHours(0, 0, 0, 0);
const lastWeekEndDate = new Date(currentDate);
lastWeekEndDate.setDate(
lastWeekEndDate.getDate() - lastWeekEndDate.getDay() - 1
);
lastWeekEndDate.setHours(23, 59, 59, 999);
return { startDate: lastWeekStartDate, endDate: lastWeekEndDate };
case "last4weeks":
const last4WeeksStartDate = new Date(currentDate);
last4WeeksStartDate.setDate(last4WeeksStartDate.getDate() - 28);
last4WeeksStartDate.setHours(0, 0, 0, 0);
const last4WeeksEndDate = new Date(currentDate);
last4WeeksEndDate.setDate(last4WeeksEndDate.getDate());
last4WeeksEndDate.setHours(23, 59, 59, 999);
return { startDate: last4WeeksStartDate, endDate: last4WeeksEndDate };
case "last12weeks":
const last12WeeksStartDate = new Date(currentDate);
last12WeeksStartDate.setDate(last12WeeksStartDate.getDate() - 84);
last12WeeksStartDate.setHours(0, 0, 0, 0);
const last12WeeksEndDate = new Date(currentDate);
last12WeeksEndDate.setDate(last12WeeksEndDate.getDate());
last12WeeksEndDate.setHours(23, 59, 59, 999);
return { startDate: last12WeeksStartDate, endDate: last12WeeksEndDate };
default:
// Handle other cases or return an error
return null;
}
}
const auctioneerLogin = async (req, res) => {
try {
const { email, password } = req.body;
let result = await db.tblAuctioneer.findAll({
where: {
email: email,
},
});
if (result.length <= 0) {
return res
.status(404)
.json({ status: 404, message: "Invalid credentials" });
}
const isMatched = await bcrypt.compare(password, result[0].password);
if (!isMatched) {
return res
.status(403)
.json({ status: 403, message: "Invalid credentials" });
}
let token = await jwt.sign(
{ email: result[0].email, auctioneerId: result[0].auctioneer_id },
process.env.JWT_KEY
);
return res.json({
status: 200,
message: "Success",
data: [{ token, ...result[0].dataValues }],
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const getAuctioneerProfile = async (req, res) => {
const auctioneer_id = req.params.id;
try {
let [result] = await db.tblAuctioneer.findAll({
where: {
auctioneer_id: auctioneer_id,
},
});
if (!result) {
return res.json({ status: 402, message: "No user Found" });
}
return res.json({
status: 200,
message: "Success",
data: [
{
user_id: result.auctioneer_id,
first_name: result.first_name,
last_name: result.last_name,
email: result.email,
contact: result.contact,
address: result.address,
business_address: result.business_address,
business_name: result.business_name,
username: result.username,
},
],
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const removeAuctioneer = async (req, res) => {
const { email } = req.body;
let transaction;
try {
transaction = await db.sequelize.transaction(); // Start a new transaction
const auctioneer = await db.tblAuctioneer.findOne({
where: { email },
transaction,
});
if (!auctioneer) {
await transaction.rollback(); // Ensure transaction is rolled back if auctioneer does not exist
return res
.status(404)
.json({ status: 404, message: "Auctioneer not found." });
}
const opportunities = await db.tblOpportunity.findAll({
where: { auctioneer_id: auctioneer.auctioneer_id },
transaction,
});
const opportunity_ids = opportunities.map(
(opportunity) => opportunity.opportunity_id
);
vehicle_run = await db.tblVehicleRun.findAll({
where: {
opportunity_id: {
[Op.in]: opportunity_ids, // Use the `Op.in` operator to look for any opportunity_id in the provided array
},
},
transaction,
});
const vehicle_run_ids = vehicle_run.map((item) => item.vehicle_run_id);
const vehicle_run_fee_deleted_count = await db.tblVehicleRunFee.destroy({
where: { vehicle_run_id: vehicle_run_ids },
transaction,
});
const auctioneer_feeses_deleted_count = await db.tblAuctioneerFee.destroy({
where: { auctioneer_id: auctioneer.auctioneer_id },
transaction,
});
const vehicle_run_deleted_count = await db.tblVehicleRun.destroy({
where: { opportunity_id: opportunity_ids },
transaction,
});
const opportunity_deleted_count = await db.tblOpportunity.destroy({
where: { opportunity_id: opportunity_ids },
transaction,
});
const subscription_deleted_count = await db.tblUserSubAuctioneer.destroy({
where: { auctioneer_id: auctioneer.auctioneer_id },
transaction,
});
const auctioneer_deleted_count = await db.tblAuctioneer.destroy({
where: { auctioneer_id: auctioneer.auctioneer_id },
transaction,
});
await transaction.commit(); // Commit all changes
return res.status(200).json({
message: "Auctioneer and related data successfully deleted.",
details: {
vehicle_runs: vehicle_run_deleted_count,
vehicle_runs_fee: vehicle_run_fee_deleted_count,
opportunities: opportunity_deleted_count,
subscriptions: subscription_deleted_count,
auctioneer_fee: auctioneer_feeses_deleted_count,
auctioneer: auctioneer_deleted_count,
},
});
} catch (error) {
if (transaction) {
try {
// Additional safeguard to ensure that we do not call rollback on an already finished transaction.
if (!transaction.finished) {
await transaction.rollback();
}
} catch (rollbackError) {
console.error("Rollback error:", rollbackError);
}
}
return res.status(500).json({
message: "Internal Server Error",
error: error.message,
});
}
};
const updateAuctioneerPassword = async (req, res) => {
try {
let { auctioneer_id, newPassword } = req.body;
if (newPassword) {
const salt = await bcrypt.genSalt(10);
const hashedPassword = await bcrypt.hash(newPassword, salt);
let result = await db.tblAuctioneer.update(
{ password: hashedPassword },
{ where: { auctioneer_id: auctioneer_id } }
);
return res.status(200).json({ status: 200, message: "Success" });
} else {
return res.json({ status: 400, message: "Please enter new password." });
}
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
//Hamza Ali
const GetAuctioneerUsers = async (req, res) => {
try {
let { auctioneerId, weekId, sortBy, orderDirection } = req.body;
if (sortBy === "sold_price") {
sortBy = "vehicle_id";
}
let timeRange;
if (!req.body.timeRange) {
timeRange = "currentweek";
} else {
timeRange = req.body.timeRange;
}
timeRange = timeRange.replace(/\s/g, "");
timeRange = timeRange.toLowerCase();
const currentDate = new Date();
const weekRange = calculateDateRange(timeRange);
const result = await db.tblOpportunity.findAll({
attributes: ["opportunity_id"],
where: {
week_id: weekId,
auctioneer_id: auctioneerId,
},
include: [
{
model: db.tblUser,
attributes: ["user_id", "first_name", "last_name"],
},
{
model: db.tblVehicleRun,
include: [
{
model: db.tblVehicle,
},
{
model: db.tblAuctionLane,
attributes: ["lane_id", "name"],
include: [
{
model: db.tblAuction,
attributes: ["auction_id", "name"],
},
],
},
],
},
],
});
// return res.json(result);
const formattedData = result.map((item) => ({
user_id: item.tblUser.user_id,
first_name: item.tblUser.first_name,
last_name: item.tblUser.last_name,
tblVehicles: item.tblVehicleRuns.map((vehicleRun) => {
const vehicle = vehicleRun.tblVehicle || {};
const auctionLane = vehicleRun.tblAuctionLane || {
lane_id: null,
name: null,
tblAuction: {
auction_id: null,
name: null,
},
};
const auction = auctionLane.tblAuction;
return {
vehicle_id: vehicle.vehicle_id,
vin: vehicle.vin,
year: vehicle.year,
make: vehicle.make,
model: vehicle.model,
trim: vehicle.trim,
mileage: vehicle.mileage,
color: vehicle.color,
color_name: vehicle.color_name || null,
imageUrl: vehicle.imageUrl,
details: vehicle.details || null,
condition_light: vehicleRun.condition_light,
announcements: vehicleRun.announcements,
reserve: vehicleRun.reserve,
sale_price: vehicleRun.sale_price,
vehicle_total_fee: vehicleRun.vehicle_total_fee || null,
net_proceed: vehicleRun.net_proceed || null,
sale_status: vehicleRun.sale_status,
run_no: vehicleRun.run_no,
lane_id: auctionLane.lane_id,
lane_name: auctionLane.name,
auction_name: auction.name,
};
}),
}));
return res.json({
status: 200,
message: "Success",
filter_type: "whole_saler",
data: formattedData,
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const GetAuctioneerUsersOnly = async (req, res) => {
try {
const { auctioneerId, weekId, orderDirection, sortBy } = req.body;
const { sequelize, tblUser, tblOpportunity, tblVehicle } = db;
const result = await tblUser.findAll({
attributes: [
"user_id",
"first_name",
"last_name",
[
sequelize.fn(
"COUNT",
sequelize.col("tblOpportunities.tblVehicleRuns.opportunity_id")
),
"units",
],
],
include: [
{
model: tblOpportunity,
attributes: [],
include: [
{
model: db.tblVehicleRun,
attributes: [],
raw: true,
},
],
where: {
auctioneer_id: auctioneerId,
week_id: parseInt(weekId),
},
},
],
group: ["tblUser.user_id", "tblOpportunities.opportunity_id"],
});
return res.json({
status: 200,
message: "Success",
filter_type: "user",
data: result,
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const updateVehicleStatus = async (req, res) => {
try {
let result;
const vehicle_id = req.body.vehicle_id;
[result] = await db.tblVehicleRun.findAll({
where: {
vehicle_id: vehicle_id,
},
});
if (!result) {
await db.tblVehicleRun.create(req.body);
} else {
await db.tblVehicleRun.update(req.body, {
where: {
vehicle_id: vehicle_id,
},
});
}
return res.json({ status: 200, message: "Success" });
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const updateAuctioneerProfile = async (req, res) => {
const { auctioneer_id, ...data } = req.body;
if (req.body.password) {
const salt = await bcrypt.genSalt(10);
const hashedPassword = await bcrypt.hash(req.body.password, salt);
data.password = hashedPassword;
}
try {
let result = await db.tblAuctioneer.update(data, {
where: {
auctioneer_id: req.body.auctioneer_id,
},
});
return res.json({
status: 200,
message: "profile updated",
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
//Auctioneer Side
const getAllAssignedVehicles = async (req, res) => {
try {
const { auctioneer_id, user_id, weekId } = req.body;
const week_Id = parseInt(weekId);
let timeRange;
if (!req.body.timeRange) {
timeRange = "last4weeks";
} else {
timeRange = req.body.timeRange;
}
timeRange = timeRange.replace(/\s/g, "");
timeRange = timeRange.toLowerCase();
const currentDate = new Date();
const weekRange = calculateDateRange(timeRange);
let result = await db.tblOpportunity.findAll({
attributes: ["opportunity_id"],
where: {
user_id: user_id,
week_id: week_Id,
auctioneer_id: auctioneer_id,
},
include: [
{
model: db.tblVehicle,
raw: true,
where: {
user_id: user_id,
opportunity_id: col("tblOpportunity.opportunity_id"),
},
include: [
{
model: db.tblVehicleRun,
raw: true,
include: [
{
model: db.tblAuctionLane,
attributes: ["lane_id", "name"],
raw: true,
include: [
{
model: db.tblAuction,
attributes: ["auction_id", "name"],
raw: true,
},
],
},
],
},
],
},
],
// order: [["createdAt", "ASC"]]
});
const formattedData = result.flatMap((user) =>
user.tblVehicles.flatMap((vehicle) => {
const run = vehicle.tblVehicleRuns[0];
return {
vehicle_id: vehicle.vehicle_id,
vin: vehicle.vin,
year: vehicle.year,
make: vehicle.make,
model: vehicle.model,
trim: vehicle.trim,
mileage: vehicle.mileage,
color: vehicle.color,
color_name: vehicle.color_name,
details: vehicle.details,
imageUrl: vehicle.imageUrl,
opportunity_id: vehicle.opportunity_id,
user_id: vehicle.user_id,
createdAt: vehicle.createdAt,
updatedAt: vehicle.updatedAt,
vehicle_run_id: run.vehicle_run_id,
condition_light: run.condition_light,
announcements: run.announcements || null,
reserve: run.reserve || null,
sale_price: run.sale_price || null,
auction_fee: run.auction_fee || null,
net_profit: run.net_profit || null,
sale_status: run.sale_status || false,
run_no: run.run_no || null,
lane_id: run.lane_id || null,
lane_name: run.tblAuctionLane
? run.tblAuctionLane.name || null
: null,
auction_id:
run.tblAuctionLane && run.tblAuctionLane.tblAuction
? run.tblAuctionLane.tblAuction.auction_id || null
: null,
auction_name:
run.tblAuctionLane && run.tblAuctionLane.tblAuction
? run.tblAuctionLane.tblAuction.name || null
: null,
};
})
);
return res.json({ status: 200, message: "Success", data: formattedData });
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const getAllAssignedVehiclesOnly = async (req, res) => {
try {
const {
auctioneer_id,
user_id,
weekId,
sortBy = "vehicle_id",
orderDirection = "ASC",
} = req.body;
const week_Id = parseInt(weekId);
let timeRange;
if (!req.body.timeRange) {
timeRange = "last4weeks";
} else {
timeRange = req.body.timeRange;
}
timeRange = timeRange.replace(/\s/g, "");
timeRange = timeRange.toLowerCase();
let result;
result = await db.tblOpportunity.findAll({
attributes: ["opportunity_id"],
where: {
user_id: user_id,
week_id: week_Id,
auctioneer_id: auctioneer_id,
},
include: [
{
model: db.tblVehicleRun,
raw: true,
where: {
opportunity_id: col("tblOpportunity.opportunity_id"),
},
include: [
{
model: db.tblVehicle,
raw: true,
},
{
model: db.tblAuctionLane,
attributes: ["lane_id", "name"],
raw: true,
include: [
{
model: db.tblAuction,
attributes: ["auction_id", "name"],
raw: true,
},
],
},
],
},
],
order: [[db.tblVehicleRun, db.tblVehicle, sortBy, orderDirection]],
});
// return res.json(result);
const transformedData = result.flatMap((opportunity) =>
opportunity.tblVehicleRuns.map((run) => ({
vehicle_id: run.vehicle_id,
vin: run.tblVehicle.vin,
year: run.tblVehicle.year,
make: run.tblVehicle.make,
model: run.tblVehicle.model,
trim: run.tblVehicle.trim,
mileage: run.tblVehicle.mileage,
color: run.tblVehicle.color,
color_name: run.tblVehicle.color_name,
details: run.tblVehicle.details,
imageUrl: run.tblVehicle.imageUrl,
opportunity_id: run.opportunity_id,
user_id: run.tblVehicle.user_id,
vehicle_run_id: run.vehicle_run_id,
condition_light: run.condition_light || 0,
announcements: run.announcements,
reserve: run.reserve || 0,
sale_price: run.sale_price || 0,
vehicle_total_fee: run.vehicle_total_fee || 0,
net_proceed: run.net_proceed || 0,
sale_status: run.sale_status || false,
run_no: run.run_no || null,
auction_fee: run.auction_fee || 300,
lane_id: run.lane_id || null,
// Additional fields from tblAuctionLane and nested tblAuction if present
lane_name: run.tblAuctionLane ? run.tblAuctionLane.name : null,
auction_id:
run.tblAuctionLane && run.tblAuctionLane.tblAuction
? run.tblAuctionLane.tblAuction.auction_id
: null,
auction_name:
run.tblAuctionLane && run.tblAuctionLane.tblAuction
? run.tblAuctionLane.tblAuction.name
: null,
}))
);
return res.json({ status: 200, message: "Success", data: transformedData });
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
//Hamza Ali
const sortAuctioneerVehicles = async (req, res) => {
try {
const { auctioneerId, weekId, orderDirection, sortBy } = req.body;
// Find user_ids from tblOpportunity based on auctioneerId and weekId
const userOpportunityIds = await db.tblOpportunity.findAll({
attributes: ["user_id"],
where: {
auctioneer_id: auctioneerId,
week_id: parseInt(weekId),
},
raw: true,
});
// Extract user_ids from the result
const userIds = userOpportunityIds.map(
(opportunity) => opportunity.user_id
);
// Find user data from tblUser and tblVehicle based on the obtained user_ids
let whereClause = {};
// Adjust the where clause based on sortBy
if (sortBy == "sold_price") {
sortBy = "vehicle_id";
}
const result = await db.tblUser.findAll({
attributes: ["user_id", "first_name", "last_name"],
include: [
{
model: db.tblVehicle,
attributes: [
"vin",
"year",
"make",
"model",
"trim",
"mileage",
"color",
"color_name",
"imageUrl",
"details",
],
include: [
{
model: db.tblOpportunity,
attributes: [],
where: {
auctioneer_id: auctioneerId,
week_id: parseInt(weekId),
},
raw: true,
},
{
model: db.tblVehicleRun,
attributes: [
"reserve",
"sale_status",
"sale_price",
"condition_light",
"announcements",
"auction_fee",
],
raw: true,
include: [
{
model: db.tblAuctionLane,
attributes: ["lane_id", "name"],
raw: true,
include: [
{
model: db.tblAuction,
attributes: ["auction_id", "name"],
raw: true,
},
],
},
],
},
],
raw: true,
where: whereClause,
},
],
order: [[db.tblVehicle, sortBy || "vehicle_id", orderDirection || "ASC"]],
});
// Format the result as needed
const formattedData = result.map((user) => ({
user_id: user.user_id,
first_name: user.first_name,
last_name: user.last_name,
tblVehicles: user.tblVehicles.map((vehicle) => ({
vin: vehicle.vin,
year: vehicle.year,
make: vehicle.make,
model: vehicle.model,
trim: vehicle.trim,
mileage: vehicle.mileage,
color: vehicle.color,
color_name: vehicle.color_name,
imageUrl: vehicle.imageUrl,
details: vehicle.details,
reserve: vehicle.tblVehicleRuns[0].reserve,
sale_status: vehicle.tblVehicleRuns[0].sale_status,
sale_price: vehicle.tblVehicleRuns[0].sale_price,
condition_light: vehicle.tblVehicleRuns[0].condition_light,
announcements: vehicle.tblVehicleRuns[0].announcements,
auction_fee: vehicle.tblVehicleRuns[0].auction_fee,
lane_id: vehicle.tblVehicleRuns[0].tblAuctionLane.lane_id,
lane_name: vehicle.tblVehicleRuns[0].tblAuctionLane.name,
auction_name: vehicle.tblVehicleRuns[0].tblAuctionLane.tblAuction.name,
})),
}));
return res.json({ status: 200, message: "Success", data: formattedData });
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const filterByConditionLight = async (req, res) => {
try {
const { auctioneerId, weekId } = req.body;
const auctioneer_id = auctioneerId;
const week_id = weekId;
let result = await db.sequelize.query(
"CALL aFilterByConditionLight(:auctioneer_id,:week_id)",
{
replacements: { auctioneer_id, week_id },
type: db.Sequelize.QueryTypes.SELECT,
}
);
let data = result[0];
const formattedData = Object.values(data)
.flat()
.filter(
(item) => typeof item === "object" && !item.hasOwnProperty("fieldCount")
);
// return res.json(formattedData);
const conditionLightValues = [0, 1, 2, 3, 4];
// Check for missing condition_light values
const missingValues = conditionLightValues.filter((value) => {
return !formattedData.some((item) => item.condition_light === value);
});
// Add missing values to the existing data
const newData = formattedData.concat(
missingValues.map((value) => ({
condition_light: value,
units: 0,
}))
);
const filteredData = newData.filter((item) => item.condition_light != 0);
// # Sorting the list in-place in ascending order of 'condition_light'
filteredData.sort((a, b) => a.condition_light - b.condition_light);
return res.json({
status: 200,
message: "Success",
filter_type: "condition_light",
data: filteredData,
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const getConditionLightVehicles = async (req, res) => {
try {
const { condition_light, auctioneer_id, week_id, sortBy, orderDirection } =
req.body;
let result;
result = await db.tblOpportunity.findAll({
attributes: ["opportunity_id"],
where: { auctioneer_id, week_id },
include: [
{
model: db.tblVehicleRun,
// required: true, // Use this instead of raw to ensure an INNER JOIN
where: { condition_light: condition_light },
include: [
{
model: db.tblVehicle,
// required: true, // Use this instead of raw to ensure an INNER JOIN
},
{
model: db.tblAuctionLane,
attributes: ["lane_id", "name"],
// required: true, // Use this instead of raw to ensure an INNER JOIN
include: [
{
model: db.tblAuction,
attributes: ["auction_id", "name"],
// required: true, // Use this instead of raw to ensure an INNER JOIN
},
],
},
],
},
],
order: [
// Include the nested order here instead
[db.tblVehicleRun, db.tblVehicle, sortBy, orderDirection],
],
});
if (result.length <= 0) {
return res.json({ status: 200, message: "Success", data: [] });
}
// // Format the result as per the required format
const formattedResult = result.flatMap((item) =>
item.tblVehicleRuns.map((vehicleRun) => {
const vehicle = vehicleRun.tblVehicle || {};
const auctionLane = vehicleRun.tblAuctionLane || {};
const auction = auctionLane.tblAuction || {};
return {
vehicle_id: vehicle.vehicle_id,
year: vehicle.year,
make: vehicle.make,
model: vehicle.model,
vin: vehicle.vin,
mileage: vehicle.mileage,
imageUrl: vehicle.imageUrl,
color: vehicle.color,
color_name: vehicle.color_name,
details: vehicle.details,
condition_light: vehicleRun?.condition_light || 0,
sale_price: vehicleRun?.sale_price || 0,
run_no: vehicleRun?.run_no || null,
sale_status: vehicleRun?.sale_status || false,
lane_id: vehicleRun?.lane_id || null,
auction_fee: vehicleRun?.auction_fee || 300,
net_proceed: vehicleRun?.net_proceed || 0,
vehicle_total_fee: vehicleRun?.vehicle_total_fee || 0,
reserve: vehicleRun?.reserve || 0,
lane_name: auctionLane?.name || null,
auction_id: auction?.auction_id || null,
auction_name: auction?.name || null,
};
})
);
return res.json({ status: 200, message: "Success", data: formattedResult });
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const filterBySaleStatus = async (req, res) => {
try {
const { auctioneerId, weekId } = req.body;
const auctioneer_id = auctioneerId;
const week_id = weekId;
let result = await db.sequelize.query(
"CALL aFilterBySaleStatus(:auctioneer_id,:week_id)",
{
replacements: { auctioneer_id, week_id },
type: db.Sequelize.QueryTypes.SELECT,
}
);
let data = result[0];
const formattedData = Object.values(data)
.flat()
.filter(
(item) => typeof item === "object" && !item.hasOwnProperty("fieldCount")
);
const saleStatusValues = ["true", "false"];
// Initialize newData with default objects if existingData is empty
let newData = [];
if (result.length === 0) {
newData = saleStatusValues.map((value) => ({
opportunity_id: 0,
auctioneer_id: 0,
sale_status: value,
units: 0,
}));
return res.json({
status: 200,
message: "Success",
data: newData,
});
}
const missingValues = saleStatusValues.filter((value) => {
return !formattedData.some((item) => item.sale_status === value);
});
// Add missing values to the existing data
newData = formattedData.concat(
missingValues.map((value) => ({
sale_status: value,
units: 0,
}))
);
return res.json({
status: 200,
message: "Success",
filter_type: "sale_status",
data: newData,
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const getSaleStatusVehicles = async (req, res) => {
try {
const { sale_status, auctioneer_id, week_id, sortBy, orderDirection } =
req.body;
let result;
result = await db.tblOpportunity.findAll({
attributes: ["opportunity_id"],
where: { auctioneer_id, week_id },
include: [
{
model: db.tblVehicleRun,
// required: true, // Use this instead of raw to ensure an INNER JOIN
where: { sale_status: sale_status },
include: [
{
model: db.tblVehicle,
// required: true, // Use this instead of raw to ensure an INNER JOIN
},
{
model: db.tblAuctionLane,
attributes: ["lane_id", "name"],
required: false, // Use this instead of raw to ensure an INNER JOIN
where: { auctioneer_id: auctioneer_id },
include: [
{
model: db.tblAuction,
attributes: ["auction_id", "name"],
// required: true, // Use this instead of raw to ensure an INNER JOIN
},
],
},
],
},
],
order: [
// Include the nested order here instead
[db.tblVehicleRun, db.tblVehicle, sortBy, orderDirection],
],
});
// return res.json(result);
if (result.length <= 0) {
return res.json({ status: 200, message: "Success", data: [] });
}
// // Format the result as per the required format
const formattedResult = result.flatMap((item) =>
item.tblVehicleRuns.map((vehicleRun) => {
const vehicle = vehicleRun.tblVehicle || {};
const auctionLane = vehicleRun.tblAuctionLane || {};
const auction = auctionLane.tblAuction || {};
return {
vehicle_id: vehicle.vehicle_id,
year: vehicle.year,
make: vehicle.make,
model: vehicle.model,
vin: vehicle.vin,
mileage: vehicle.mileage,
imageUrl: vehicle.imageUrl,
color: vehicle.color,
color_name: vehicle.color_name,
details: vehicle.details,
condition_light: vehicleRun?.condition_light || 0,
sale_price: vehicleRun?.sale_price || 0,
run_no: vehicleRun?.run_no || null,
sale_status: vehicleRun?.sale_status || false,
lane_id: vehicleRun?.lane_id || null,
auction_fee: vehicleRun?.auction_fee || 300,
net_proceed: vehicleRun?.net_proceed || 0,
vehicle_total_fee: vehicleRun?.vehicle_total_fee || 0,
reserve: vehicleRun?.reserve || 0,
lane_name: auctionLane?.name || null,
auction_id: auction?.auction_id || null,
auction_name: auction?.name || null,
};
})
);
return res.json({ status: 200, message: "Success", data: formattedResult });
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const filterByAuctioneerAuctions = async (req, res) => {
try {
const { auctioneerId, weekId } = req.body;
const auctioneer_id = auctioneerId;
const week_id = weekId;
let results = await db.sequelize.query(
"CALL aFilterByAuction(:auctioneer_id,:week_id)",
{
replacements: { auctioneer_id, week_id },
}
);
// Returning the result as a response
return res.json({
status: 200,
message: "Success",
filter_type: "auction",
data: results,
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const GetVehicleCountBySaleStatus = async (req, res) => {
try {
const { auctioneerId, weekId } = req.body;
// Find user_ids from tblOpportunity based on auctioneerId and weekId
const userOpportunityIds = await db.tblOpportunity.findAll({
attributes: ["user_id"],
where: {
auctioneer_id: auctioneerId,
week_id: parseInt(weekId),
},
raw: true,
});
// Extract user_ids from the result
const userIds = userOpportunityIds.map(
(opportunity) => opportunity.user_id
);
// Find user data from tblUser and tblVehicle based on the obtained user_ids
const result = await db.tblOpportunity.findAll({
attributes: ["opportunity_id"],
where: {
week_id: weekId,
auctioneer_id: auctioneerId,
},
include: [
{
model: db.tblUser,
attributes: ["user_id", "first_name", "last_name"],
},
{
model: db.tblVehicleRun,
include: [
{
model: db.tblVehicle,
},
{
model: db.tblAuctionLane,
attributes: ["lane_id", "name"],
include: [
{
model: db.tblAuction,
attributes: ["auction_id", "name"],
},
],
},
],
},
],
});
// return res.json(result);
const modifiedData = result.map((item) => {
return {
user_id: item.tblUser.user_id,
first_name: item.tblUser.first_name,
last_name: item.tblUser.last_name,
sold_vehicles: item.tblVehicleRuns
.filter((run) => run.sale_status === true)
.map((run) => {
const vehicle = run.tblVehicle;
return {
vehicle_id: vehicle.vehicle_id,
vin: vehicle.vin,
year: vehicle.year,
make: vehicle.make,
model: vehicle.model,
imageUrl: vehicle.imageUrl,
trim: vehicle.trim,
mileage: vehicle.mileage,
color: vehicle.color,
color_name: vehicle.color_name,
details: vehicle.details,
reserve: run.reserve,
sale_status: run.sale_status,
sale_price: run.sale_price,
condition_light: run.condition_light,
announcements: run.announcements,
auction_fee: run.vehicle_total_fee, // Assuming auction_fee refers to 'vehicle_total_fee' field.
run_no: run.run_no,
lane_id: run.tblAuctionLane.lane_id,
lane_name: run.tblAuctionLane.name,
auction_name: run.tblAuctionLane.tblAuction.name,
};
}),
not_sold_vehicles: item.tblVehicleRuns
.filter((run) => run.sale_status === false)
.map((run) => {
const vehicle = run.tblVehicle;
return {
vin: vehicle.vin,
year: vehicle.year,
make: vehicle.make,
model: vehicle.model,
imageUrl: vehicle.imageUrl,
trim: vehicle.trim,
mileage: vehicle.mileage,
color: vehicle.color,
color_name: vehicle.color_name,
details: vehicle.details,
reserve: run.reserve,
sale_status: run.sale_status,
sale_price: run.sale_price,
condition_light: run.condition_light,
announcements: run.announcements,
auction_fee: run.vehicle_total_fee, // Assuming auction_fee refers to 'vehicle_total_fee' field.
run_no: run.run_no,
lane_id: run.tblAuctionLane ? run.tblAuctionLane.lane_id : null,
lane_name: run.tblAuctionLane ? run.tblAuctionLane.name : null,
auction_name: run.tblAuctionLane
? run.tblAuctionLane.tblAuction.name
: null,
};
}),
};
});
return res.json({
status: 200,
message: "Success",
data: modifiedData,
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const GetVehicleCountByAuction = async (req, res) => {
try {
const { auctioneerId, weekId } = req.body;
// Find user_ids from tblOpportunity based on auctioneerId and weekId
const userOpportunityIds = await db.tblOpportunity.findAll({
attributes: ["user_id"],
where: {
auctioneer_id: auctioneerId,
week_id: parseInt(weekId),
},
raw: true,
});
// Extract user_ids from the result
const userIds = userOpportunityIds.map(
(opportunity) => opportunity.user_id
);
// Find user data from tblUser and tblVehicle based on the obtained user_ids
const [result] = await db.sequelize.query(`
SELECT
o.opportunity_id,
auc.auction_id as auction_id,
auc.name as auction_name,
v.vin,
v.year,
v.make,
v.model,
al.lane_id,
al.name as lane_name,
vr.announcements,
vr.condition_light,
vr.sale_price,
vr.sale_status
from tblopportunities as o
inner join tblauctioneers as a on a.auctioneer_id=o.auctioneer_id
inner join tblauctionlanes as al on al.auctioneer_id=a.auctioneer_id
inner join tblauctions as auc on auc.auction_id=al.auction_id
inner join tblvehicleruns as vr on vr.lane_id=al.lane_id
inner join tblvehicles as v on v.vehicle_id=vr.vehicle_id
where o.auctioneer_id=${auctioneerId} and o.week_id=${weekId};`);
const groupByAuctionID = (data) => {
return data.reduce((acc, currentValue) => {
// Find an auction in the accumulator array.
let auction = acc.find((a) => a.auction_id === currentValue.auction_id);
// If the auction doesn't exist, create it and push it to the accumulator.
if (!auction) {
auction = {
auction_id: currentValue.auction_id,
auction_name: currentValue.auction_name,
data: [],
};
acc.push(auction);
}
// Add the current value to the data array of the found/created auction.
auction.data.push({
opportunity_id: currentValue.opportunity_id,
vin: currentValue.vin.trim(),
year: currentValue.year,
make: currentValue.make.trim(),
model: currentValue.model.trim(),
lane_id: currentValue.lane_id,
lane_name: currentValue.lane_name,
announcements: currentValue.announcements,
condition_light: currentValue.condition_light,
sale_price: currentValue.sale_price,
sale_status: currentValue.sale_status,
});
return acc;
}, []);
};
const transformedData = groupByAuctionID(result);
return res.json({
status: 200,
message: "Success",
data: transformedData,
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const GetVehicleCountByConditionLight = async (req, res) => {
try {
const { auctioneerId, weekId } = req.body;
// Find user_ids from tblOpportunity based on auctioneerId and weekId
const userOpportunityIds = await db.tblOpportunity.findAll({
attributes: ["user_id"],
where: {
auctioneer_id: auctioneerId,
week_id: parseInt(weekId),
},
raw: true,
});
// Extract user_ids from the result
const userIds = userOpportunityIds.map(
(opportunity) => opportunity.user_id
);
// Find user data from tblUser and tblVehicle based on the obtained user_ids
const result = await db.tblOpportunity.findAll({
attributes: ["opportunity_id"],
where: {
week_id: weekId,
auctioneer_id: auctioneerId,
},
include: [
{
model: db.tblUser,
attributes: ["user_id", "first_name", "last_name"],
},
{
model: db.tblVehicleRun,
include: [
{
model: db.tblVehicle,
},
{
model: db.tblAuctionLane,
attributes: ["lane_id", "name"],
include: [
{
model: db.tblAuction,
attributes: ["auction_id", "name"],
},
],
},
],
},
],
});
// return res.json({ data: result });
/* const modifiedData = result.map((item) => {
const redVehicles = item.tblVehicles
.filter((vehicle) =>
vehicle.tblVehicleRuns.some((run) => run.condition_light === 1)
)
.map((vehicle) => {
const run = vehicle.tblVehicleRuns[0];
const lane_details = run.tblAuctionLane || {};
return {
vin: vehicle.get("vin"),
year: vehicle.get("year"),
make: vehicle.get("make"),
model: vehicle.get("model"),
mileage: vehicle.get("mileage"),
trim: vehicle.get("trim"),
imageUrl: vehicle.get("imageUrl"),
condition_light: run.condition_light,
reserve: run.reserve,
announcements: run.announcements,
sale_price: run.sale_price,
sale_status: run.sale_status,
auction_fee: run.auction_fee,
lane_id: run.tblAuctionLane ? run.tblAuctionLane.lane_id : null,
lane_name: run.tblAuctionLane ? run.tblAuctionLane.name : null,
auction_name: run.tblAuctionLane
? run.tblAuctionLane.tblAuction.name
: null,
};
});
const yellowVehicles = item.tblVehicles
.filter((vehicle) =>
vehicle.tblVehicleRuns.some((run) => run.condition_light === 2)
)
.map((vehicle) => {
const run = vehicle.tblVehicleRuns[0];
const lane_details = run.tblAuctionLane || {};
return {
vin: vehicle.get("vin"),
year: vehicle.get("year"),
make: vehicle.get("make"),
model: vehicle.get("model"),
mileage: vehicle.get("mileage"),
trim: vehicle.get("trim"),
imageUrl: vehicle.get("imageUrl"),
condition_light: run.condition_light,
reserve: run.reserve,
announcements: run.announcements,
sale_price: run.sale_price,
sale_status: run.sale_status,
auction_fee: run.auction_fee,
lane_id: run.tblAuctionLane ? run.tblAuctionLane.lane_id : null,
lane_name: run.tblAuctionLane ? run.tblAuctionLane.name : null,
auction_name: run.tblAuctionLane
? run.tblAuctionLane.tblAuction.name
: null,
};
});
const greenVehicles = item.tblVehicles
.filter((vehicle) =>
vehicle.tblVehicleRuns.some((run) => run.condition_light === 3)
)
.map((vehicle) => {
const run = vehicle.tblVehicleRuns[0];
const lane_details = run.tblAuctionLane || {};
return {
vin: vehicle.get("vin"),
year: vehicle.get("year"),
make: vehicle.get("make"),
model: vehicle.get("model"),
mileage: vehicle.get("mileage"),
trim: vehicle.get("trim"),
imageUrl: vehicle.get("imageUrl"),
condition_light: run.condition_light,
reserve: run.reserve,
announcements: run.announcements,
sale_price: run.sale_price,
sale_status: run.sale_status,
auction_fee: run.auction_fee,
lane_id: run.tblAuctionLane ? run.tblAuctionLane.lane_id : null,
lane_name: run.tblAuctionLane ? run.tblAuctionLane.name : null,
auction_name: run.tblAuctionLane
? run.tblAuctionLane.tblAuction.name
: null,
};
});
return {
user_id: item.get("user_id"),
first_name: item.get("first_name"),
last_name: item.get("last_name"),
red_vehicles: redVehicles,
yellow_vehicles: yellowVehicles,
green_vehicles: greenVehicles,
};
}); */
const modifiedData = result.map((opportunity) => {
const { tblUser, tblVehicleRuns } = opportunity;
// Helper function to get vehicles based on condition light
const getVehiclesByConditionLight = (conditionLightValue) =>
tblVehicleRuns
.filter((run) => run.condition_light === conditionLightValue)
.map((run) => {
const { tblVehicle, tblAuctionLane } = run;
return {
vin: tblVehicle.vin,
year: tblVehicle.year,
make: tblVehicle.make,
model: tblVehicle.model,
mileage: tblVehicle.mileage,
trim: tblVehicle.trim,
imageUrl: tblVehicle.imageUrl,
condition_light: run.condition_light,
reserve: run.reserve,
announcements: run.announcements,
sale_price: run.sale_price,
sale_status: run.sale_status,
auction_fee: run.vehicle_total_fee,
lane_id: tblAuctionLane ? tblAuctionLane.lane_id : null,
lane_name: tblAuctionLane ? tblAuctionLane.name : null,
auction_name:
tblAuctionLane && tblAuctionLane.tblAuction
? tblAuctionLane.tblAuction.name
: null,
};
});
// Use the helper function for different condition lights
const redVehicles = getVehiclesByConditionLight(1); // Red condition light vehicles
const yellowVehicles = getVehiclesByConditionLight(2); // Yellow condition light vehicles
const greenVehicles = getVehiclesByConditionLight(3); // Green condition light vehicles
return {
user_id: tblUser.user_id,
first_name: tblUser.first_name,
last_name: tblUser.last_name,
red_vehicles: redVehicles,
yellow_vehicles: yellowVehicles,
green_vehicles: greenVehicles,
};
});
return res.json({
status: 200,
message: "Success",
data: modifiedData,
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
const auctioneerTotalSaleAndNetProceed = async (req, res) => {
try {
let { auctioneer_id } = req.body;
const in_auctioneer_id = auctioneer_id;
let timeRange;
if (!req.body.timeRange) {
timeRange = "currentweek";
} else {
timeRange = req.body.timeRange;
}
timeRange = timeRange.replace(/\s/g, "");
timeRange = timeRange.toLowerCase();
const weekRange = calculateDateRange(timeRange);
const start_date = weekRange.startDate;
const end_date = weekRange.endDate;
let [result] = await db.sequelize.query(
"CALL AuctioneerStats(:auctioneer_id,:start_date,:end_date)",
{
replacements: { auctioneer_id, start_date, end_date },
}
);
if (!result) {
return res.json({
status: 200,
message: "success",
data: {
sold_units: 0,
total_sales: 0,
net_proceeds: 0,
},
});
}
return res.json({
status: 200,
message: "success",
data: {
sold_units: result.sold_units || 0,
total_sales: result.total_sales || 0,
net_proceeds: result.net_proceeds || 0,
},
});
} catch (error) {
return res.status(500).json({
status: 500,
message: "Internal Server Error",
error: error.message,
});
}
};
module.exports = {
auctioneerLogin,
getAuctioneerProfile,
removeAuctioneer,
updateAuctioneerPassword,
GetAuctioneerUsers,
updateVehicleStatus,
updateAuctioneerProfile,
getAllAssignedVehicles,
sortAuctioneerVehicles,
filterByConditionLight,
filterBySaleStatus,
GetVehicleCountBySaleStatus,
GetVehicleCountByConditionLight,
GetAuctioneerUsersOnly,
getAllAssignedVehiclesOnly,
filterByAuctioneerAuctions,
auctioneerTotalSaleAndNetProceed,
getConditionLightVehicles,
getSaleStatusVehicles,
GetVehicleCountByAuction,
};
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists