823 lines
22 KiB
JavaScript
823 lines
22 KiB
JavaScript
const { prisma } = require('../config/database');
|
||
const Product = require('../models/mongodb/Product');
|
||
const {
|
||
RETURN_WINDOW_DAYS,
|
||
ALLOWED_STATUSES,
|
||
} = require('../config/returnPolicy');
|
||
const {
|
||
calculateDeliveryDate,
|
||
} = require('../services/deliveryEstimationService');
|
||
const { reduceStockOnDelivery } = require('../services/inventoryService');
|
||
|
||
// @desc Create new order
|
||
// @route POST /api/orders
|
||
// @access Private
|
||
exports.createOrder = async (req, res, next) => {
|
||
try {
|
||
const { items, shippingAddressId, paymentMethod, couponCode } = req.body;
|
||
const userId = req.user.id;
|
||
console.log('=================================');
|
||
console.log('🎟️ COUPON DEBUG');
|
||
console.log('Received couponCode:', req.body.couponCode);
|
||
console.log('Full body:', req.body);
|
||
console.log('=================================');
|
||
console.log('📦 Creating order for user:', userId);
|
||
console.log('🎟️ Coupon code:', couponCode);
|
||
|
||
// Validate items
|
||
if (!items || items.length === 0) {
|
||
return res.status(400).json({
|
||
success: false,
|
||
message: 'No items in the order',
|
||
});
|
||
}
|
||
|
||
// Validate shipping address
|
||
const address = await prisma.address.findUnique({
|
||
where: { id: shippingAddressId },
|
||
});
|
||
const deliveryEstimation = calculateDeliveryDate(
|
||
address.postalCode,
|
||
new Date(),
|
||
'STANDARD'
|
||
);
|
||
|
||
console.log(
|
||
'📅 Estimated delivery:',
|
||
deliveryEstimation.estimatedDelivery.formatted
|
||
);
|
||
|
||
if (!address || address.userId !== userId) {
|
||
return res.status(400).json({
|
||
success: false,
|
||
message: 'Invalid shipping address',
|
||
});
|
||
}
|
||
|
||
// Fetch product details from MongoDB
|
||
const productIds = items.map(item => item.productId);
|
||
const products = await Product.find({ _id: { $in: productIds } });
|
||
|
||
if (products.length !== productIds.length) {
|
||
return res.status(400).json({
|
||
success: false,
|
||
message: 'Some products not found',
|
||
});
|
||
}
|
||
|
||
// Calculate totals
|
||
let subtotal = 0;
|
||
const orderItems = [];
|
||
|
||
for (const item of items) {
|
||
const product = products.find(p => p._id.toString() === item.productId);
|
||
|
||
if (!product) {
|
||
return res.status(400).json({
|
||
success: false,
|
||
message: `Product ${item.productId} not found`,
|
||
});
|
||
}
|
||
|
||
let price = product.basePrice;
|
||
let sku = product.slug;
|
||
|
||
if (product.hasVariants && product.variants?.length > 0) {
|
||
const variant = product.variants.find(v => v.sku === item.sku);
|
||
if (variant) {
|
||
price = variant.price;
|
||
sku = variant.sku;
|
||
}
|
||
}
|
||
|
||
const itemTotal = price * item.quantity;
|
||
subtotal += itemTotal;
|
||
|
||
orderItems.push({
|
||
productId: item.productId,
|
||
productName: product.name,
|
||
productSku: sku,
|
||
price: price,
|
||
quantity: item.quantity,
|
||
});
|
||
}
|
||
|
||
// Calculate tax and shipping
|
||
const taxRate = 0.18; // 18% GST
|
||
const taxAmount = subtotal * taxRate;
|
||
let shippingAmount = subtotal > 500 ? 0 : 50; // Free shipping above ₹500
|
||
let discountAmount = 0;
|
||
let appliedCoupon = null;
|
||
|
||
// ==========================================
|
||
// VALIDATE AND APPLY COUPON
|
||
// ==========================================
|
||
if (couponCode) {
|
||
console.log('🎟️ Validating coupon:', couponCode);
|
||
|
||
const coupon = await prisma.coupon.findUnique({
|
||
where: { code: couponCode.toUpperCase() },
|
||
});
|
||
|
||
if (coupon) {
|
||
// Validate coupon
|
||
const now = new Date();
|
||
let couponError = null;
|
||
|
||
if (!coupon.isActive) {
|
||
couponError = 'Coupon is not active';
|
||
} else if (now < new Date(coupon.validFrom)) {
|
||
couponError = 'Coupon is not yet valid';
|
||
} else if (now > new Date(coupon.validUntil)) {
|
||
couponError = 'Coupon has expired';
|
||
} else if (coupon.maxUses && coupon.usedCount >= coupon.maxUses) {
|
||
couponError = 'Coupon usage limit reached';
|
||
} else if (
|
||
coupon.minOrderAmount &&
|
||
subtotal < parseFloat(coupon.minOrderAmount)
|
||
) {
|
||
couponError = `Minimum order amount of ₹${coupon.minOrderAmount} required`;
|
||
}
|
||
|
||
if (couponError) {
|
||
console.log('❌ Coupon validation failed:', couponError);
|
||
return res.status(400).json({
|
||
success: false,
|
||
message: couponError,
|
||
});
|
||
}
|
||
|
||
// Calculate discount
|
||
if (coupon.type === 'PERCENTAGE') {
|
||
discountAmount = (subtotal * parseFloat(coupon.value)) / 100;
|
||
} else if (coupon.type === 'FIXED_AMOUNT') {
|
||
discountAmount = Math.min(parseFloat(coupon.value), subtotal);
|
||
} else if (coupon.type === 'FREE_SHIPPING') {
|
||
discountAmount = shippingAmount;
|
||
shippingAmount = 0;
|
||
}
|
||
|
||
appliedCoupon = coupon;
|
||
console.log('✅ Coupon applied:', {
|
||
code: coupon.code,
|
||
type: coupon.type,
|
||
discount: discountAmount,
|
||
});
|
||
} else {
|
||
console.log('❌ Coupon not found');
|
||
return res.status(400).json({
|
||
success: false,
|
||
message: 'Invalid coupon code',
|
||
});
|
||
}
|
||
}
|
||
|
||
// Calculate final total
|
||
const totalAmount = subtotal + taxAmount + shippingAmount - discountAmount;
|
||
|
||
// Generate unique order number
|
||
const orderNumber = `ORD${Date.now()}${Math.floor(Math.random() * 1000)}`;
|
||
|
||
// ==========================================
|
||
// CREATE ORDER IN TRANSACTION
|
||
// ==========================================
|
||
const result = await prisma.$transaction(async tx => {
|
||
// Create order
|
||
const order = await tx.order.create({
|
||
data: {
|
||
orderNumber,
|
||
userId,
|
||
status: 'PENDING',
|
||
subtotal,
|
||
taxAmount,
|
||
shippingAmount,
|
||
discountAmount,
|
||
totalAmount,
|
||
paymentStatus: 'PENDING',
|
||
paymentMethod: paymentMethod || 'PAYTM',
|
||
shippingAddressId,
|
||
items: {
|
||
create: orderItems,
|
||
},
|
||
},
|
||
include: {
|
||
items: true,
|
||
address: true,
|
||
user: {
|
||
select: {
|
||
id: true,
|
||
email: true,
|
||
firstName: true,
|
||
lastName: true,
|
||
phone: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
|
||
// ✅ INCREMENT COUPON USAGE COUNT
|
||
if (appliedCoupon) {
|
||
await tx.coupon.update({
|
||
where: { id: appliedCoupon.id },
|
||
data: {
|
||
usedCount: {
|
||
increment: 1,
|
||
},
|
||
},
|
||
});
|
||
|
||
console.log('✅ Coupon usage incremented:', {
|
||
code: appliedCoupon.code,
|
||
previousCount: appliedCoupon.usedCount,
|
||
newCount: appliedCoupon.usedCount + 1,
|
||
});
|
||
}
|
||
|
||
return order;
|
||
});
|
||
|
||
console.log('✅ Order created:', result.id);
|
||
|
||
// Clear user's cart after order creation
|
||
await prisma.cartItem.deleteMany({
|
||
where: { userId },
|
||
});
|
||
|
||
res.status(201).json({
|
||
success: true,
|
||
message: 'Order created successfully',
|
||
order: result,
|
||
appliedCoupon: appliedCoupon
|
||
? {
|
||
code: appliedCoupon.code,
|
||
discount: discountAmount,
|
||
}
|
||
: null,
|
||
deliveryEstimation,
|
||
});
|
||
} catch (error) {
|
||
console.error('Create order error:', error);
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
// @desc Get user orders
|
||
exports.getUserOrders = async (req, res, next) => {
|
||
try {
|
||
const { page = 1, limit = 10, status } = req.query;
|
||
const skip = (page - 1) * limit;
|
||
const where = { userId: req.user.id };
|
||
if (status) where.status = status;
|
||
|
||
const [orders, total] = await Promise.all([
|
||
prisma.order.findMany({
|
||
where,
|
||
include: { items: true, address: true },
|
||
orderBy: { createdAt: 'desc' },
|
||
skip: parseInt(skip),
|
||
take: parseInt(limit),
|
||
}),
|
||
prisma.order.count({ where }),
|
||
]);
|
||
|
||
// res.json({
|
||
// success: true,
|
||
// data: {
|
||
// orders,
|
||
// pagination: {
|
||
// page: parseInt(page),
|
||
// limit: parseInt(limit),
|
||
// total,
|
||
// pages: Math.ceil(total / limit),
|
||
// },
|
||
// },
|
||
// });
|
||
|
||
return res.status(200).json({
|
||
statusCode: 200,
|
||
status: true,
|
||
message: 'Orders fetched successfully',
|
||
data: {
|
||
orders,
|
||
pagination: {
|
||
page: parseInt(page),
|
||
limit: parseInt(limit),
|
||
total,
|
||
pages: Math.ceil(total / limit),
|
||
},
|
||
},
|
||
});
|
||
} catch (error) {
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
// @desc Get single order
|
||
exports.getOrderById = async (req, res, next) => {
|
||
try {
|
||
const order = await prisma.order.findFirst({
|
||
where: { id: req.params.id, userId: req.user.id },
|
||
include: { items: true, address: true },
|
||
});
|
||
|
||
if (!order) {
|
||
return res.status(404).json({
|
||
// statusCode: 404,
|
||
status: false,
|
||
message: 'Order not found',
|
||
data: null,
|
||
});
|
||
}
|
||
|
||
// 2️⃣ Collect productIds
|
||
const productIds = order.items.map(item => item.productId);
|
||
|
||
// 3️⃣ Fetch products from MongoDB
|
||
const products = await Product.find({
|
||
_id: { $in: productIds },
|
||
}).select('name images');
|
||
|
||
// 4️⃣ Convert products array to map for quick lookup
|
||
const productMap = {};
|
||
products.forEach(product => {
|
||
productMap[product._id.toString()] = product;
|
||
});
|
||
|
||
// 5️⃣ Attach product image to each order item
|
||
const updatedItems = order.items.map(item => {
|
||
const product = productMap[item.productId];
|
||
|
||
return {
|
||
...item,
|
||
productImage: product?.images?.primary || null,
|
||
productGallery: product?.images?.gallery || [],
|
||
};
|
||
});
|
||
|
||
order.items = updatedItems;
|
||
|
||
// res.json({ success: true, data: { order } });
|
||
return res.status(200).json({
|
||
statusCode: 200,
|
||
status: true,
|
||
message: 'Order fetched successfully',
|
||
data: { order },
|
||
});
|
||
} catch (error) {
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
// @desc Update order status (Admin)
|
||
exports.updateOrderStatus = async (req, res, next) => {
|
||
try {
|
||
const { status, trackingNumber } = req.body;
|
||
// if (!status)
|
||
// return res
|
||
// .status(400)
|
||
// .json({ success: false, message: 'Status is required' });
|
||
|
||
if (!status) {
|
||
return res.status(400).json({
|
||
statusCode: 400,
|
||
status: false,
|
||
message: 'Status is required',
|
||
data: null,
|
||
});
|
||
}
|
||
|
||
const order = await prisma.order.findUnique({
|
||
where: { id: req.params.id },
|
||
});
|
||
// if (!order)
|
||
// return res
|
||
// .status(404)
|
||
// .json({ success: false, message: 'Order not found' });
|
||
|
||
if (!order) {
|
||
return res.status(404).json({
|
||
statusCode: 404,
|
||
status: false,
|
||
message: 'Order not found',
|
||
data: null,
|
||
});
|
||
}
|
||
|
||
const updateData = { status };
|
||
if (trackingNumber) updateData.trackingNumber = trackingNumber;
|
||
if (status === 'SHIPPED') updateData.shippedAt = new Date();
|
||
if (status === 'DELIVERED') updateData.deliveredAt = new Date();
|
||
|
||
const updatedOrder = await prisma.order.update({
|
||
where: { id: req.params.id },
|
||
data: updateData,
|
||
include: { items: true, address: true },
|
||
});
|
||
|
||
// res.json({
|
||
// success: true,
|
||
// message: 'Order status updated',
|
||
// data: { order: updatedOrder },
|
||
// });
|
||
return res.status(200).json({
|
||
statusCode: 200,
|
||
status: true,
|
||
message: 'Order status updated successfully',
|
||
data: { order: updatedOrder },
|
||
});
|
||
} catch (error) {
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
// @desc Cancel order
|
||
exports.cancelOrder = async (req, res, next) => {
|
||
try {
|
||
const order = await prisma.order.findFirst({
|
||
where: { id: req.params.id, userId: req.user.id },
|
||
});
|
||
|
||
// if (!order)
|
||
// return res
|
||
// .status(404)
|
||
// .json({ success: false, message: 'Order not found' });
|
||
if (!order) {
|
||
return res.status(404).json({
|
||
statusCode: 404,
|
||
status: false,
|
||
message: 'Order not found',
|
||
data: null,
|
||
});
|
||
}
|
||
|
||
// if (!['PENDING', 'CONFIRMED'].includes(order.status))
|
||
// return res
|
||
// .status(400)
|
||
// .json({ success: false, message: 'Order cannot be cancelled' });
|
||
|
||
if (!['PENDING', 'CONFIRMED'].includes(order.status)) {
|
||
return res.status(400).json({
|
||
statusCode: 400,
|
||
status: false,
|
||
message: 'Order cannot be cancelled',
|
||
data: null,
|
||
});
|
||
}
|
||
|
||
const updatedOrder = await prisma.order.update({
|
||
where: { id: req.params.id },
|
||
data: { status: 'CANCELLED' },
|
||
include: { items: true, address: true },
|
||
});
|
||
|
||
// res.json({
|
||
// success: true,
|
||
// message: 'Order cancelled',
|
||
// data: { order: updatedOrder },
|
||
// });
|
||
return res.status(200).json({
|
||
statusCode: 200,
|
||
status: true,
|
||
message: 'Order cancelled successfully',
|
||
data: { order: updatedOrder },
|
||
});
|
||
} catch (error) {
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
// exports.returnOrder = async (req, res, next) => {
|
||
// try {
|
||
// const order = await prisma.order.findFirst({
|
||
// where: {
|
||
// id: req.params.id,
|
||
// userId: req.user.id,
|
||
// },
|
||
// });
|
||
|
||
// if (!order) {
|
||
// return res.status(404).json({
|
||
// status: false,
|
||
// message: 'Order not found',
|
||
// });
|
||
// }
|
||
|
||
// // ✅ RETURN STATUS CHECK (YOUR CODE GOES HERE)
|
||
// if (!ALLOWED_STATUSES.includes(order.status)) {
|
||
// return res.status(400).json({
|
||
// status: false,
|
||
// message: 'Order not eligible for return',
|
||
// });
|
||
// }
|
||
|
||
// // ✅ RETURN WINDOW CHECK
|
||
// const deliveredAt = order.deliveredAt || order.updatedAt;
|
||
// const diffDays =
|
||
// (Date.now() - new Date(deliveredAt)) / (1000 * 60 * 60 * 24);
|
||
|
||
// if (diffDays > RETURN_WINDOW_DAYS) {
|
||
// return res.status(400).json({
|
||
// status: false,
|
||
// message: `Return allowed within ${RETURN_WINDOW_DAYS} days only`,
|
||
// });
|
||
// }
|
||
|
||
// // ✅ UPDATE ORDER
|
||
// const updatedOrder = await prisma.order.update({
|
||
// where: { id: order.id },
|
||
// data: {
|
||
// status: 'RETURN_REQUESTED',
|
||
// returnRequestedAt: new Date(),
|
||
// },
|
||
// });
|
||
|
||
// return res.status(200).json({
|
||
// status: true,
|
||
// message: 'Return request submitted successfully',
|
||
// data: { order: updatedOrder },
|
||
// });
|
||
// } catch (error) {
|
||
// next(error);
|
||
// }
|
||
// };
|
||
|
||
// @desc Return order
|
||
// @route PUT /api/orders/:id/return
|
||
// @access Private
|
||
exports.returnOrder = async (req, res, next) => {
|
||
try {
|
||
// Find the order belonging to the logged-in user
|
||
const order = await prisma.order.findFirst({
|
||
where: {
|
||
id: req.params.id,
|
||
userId: req.user.id,
|
||
},
|
||
});
|
||
|
||
if (!order) {
|
||
return res.status(404).json({
|
||
status: false,
|
||
message: 'Order not found',
|
||
});
|
||
}
|
||
|
||
// ✅ Check if order status allows return
|
||
const ALLOWED_STATUSES = ['DELIVERED']; // only delivered orders can be returned
|
||
if (!ALLOWED_STATUSES.includes(order.status)) {
|
||
return res.status(400).json({
|
||
status: false,
|
||
message: 'Order not eligible for return',
|
||
});
|
||
}
|
||
|
||
// ✅ Check return window (e.g., 7 days)
|
||
const RETURN_WINDOW_DAYS = 7;
|
||
const deliveredAt = order.deliveredAt || order.updatedAt;
|
||
const diffDays =
|
||
(Date.now() - new Date(deliveredAt)) / (1000 * 60 * 60 * 24);
|
||
|
||
if (diffDays > RETURN_WINDOW_DAYS) {
|
||
return res.status(400).json({
|
||
status: false,
|
||
message: `Return allowed within ${RETURN_WINDOW_DAYS} days only`,
|
||
});
|
||
}
|
||
|
||
// ✅ Update order: set both status and returnStatus
|
||
const updatedOrder = await prisma.order.update({
|
||
where: { id: order.id },
|
||
data: {
|
||
status: 'RETURN_REQUESTED', // OrderStatus
|
||
returnStatus: 'REQUESTED', // ReturnStatus (admin will use this)
|
||
returnRequestedAt: new Date(),
|
||
},
|
||
});
|
||
|
||
return res.status(200).json({
|
||
status: true,
|
||
message: 'Return request submitted successfully',
|
||
data: { order: updatedOrder },
|
||
});
|
||
} catch (error) {
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
// @desc Get all orders (Admin)
|
||
exports.getAllOrdersAdmin = async (req, res, next) => {
|
||
try {
|
||
const { page = 1, limit = 20, status, paymentStatus } = req.query;
|
||
const skip = (page - 1) * limit;
|
||
|
||
const where = {};
|
||
if (status) where.status = status;
|
||
if (paymentStatus) where.paymentStatus = paymentStatus;
|
||
|
||
const [orders, total] = await Promise.all([
|
||
prisma.order.findMany({
|
||
where,
|
||
include: {
|
||
items: true,
|
||
address: true,
|
||
user: {
|
||
select: { id: true, email: true, firstName: true, lastName: true },
|
||
},
|
||
},
|
||
orderBy: { createdAt: 'desc' },
|
||
skip: parseInt(skip),
|
||
take: parseInt(limit),
|
||
}),
|
||
prisma.order.count({ where }),
|
||
]);
|
||
|
||
// res.json({
|
||
// success: true,
|
||
// data: {
|
||
// orders,
|
||
// pagination: {
|
||
// page: parseInt(page),
|
||
// limit: parseInt(limit),
|
||
// total,
|
||
// pages: Math.ceil(total / limit),
|
||
// },
|
||
// },
|
||
// });
|
||
return res.status(200).json({
|
||
statusCode: 200,
|
||
status: true,
|
||
message: 'Orders fetched successfully',
|
||
data: {
|
||
orders,
|
||
pagination: {
|
||
page: parseInt(page),
|
||
limit: parseInt(limit),
|
||
total,
|
||
pages: Math.ceil(total / limit),
|
||
},
|
||
},
|
||
});
|
||
} catch (error) {
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
// @desc Approve or reject a return request
|
||
// @route PUT /api/orders/:id/return/status
|
||
// @access Private/Admin
|
||
exports.updateReturnStatus = async (req, res, next) => {
|
||
try {
|
||
const { id } = req.params;
|
||
const { action } = req.body; // "APPROVE" or "REJECT"
|
||
|
||
const order = await prisma.order.findUnique({ where: { id } });
|
||
|
||
if (!order) {
|
||
return res
|
||
.status(404)
|
||
.json({ status: false, message: 'Order not found' });
|
||
}
|
||
|
||
if (order.returnStatus !== 'REQUESTED') {
|
||
return res
|
||
.status(400)
|
||
.json({ status: false, message: 'No return request pending' });
|
||
}
|
||
|
||
let newStatus;
|
||
if (action === 'APPROVE') newStatus = 'APPROVED';
|
||
else if (action === 'REJECT') newStatus = 'REJECTED';
|
||
else
|
||
return res.status(400).json({ status: false, message: 'Invalid action' });
|
||
|
||
const updatedOrder = await prisma.order.update({
|
||
where: { id },
|
||
data: { returnStatus: newStatus },
|
||
});
|
||
|
||
res.status(200).json({
|
||
status: true,
|
||
message: `Return request ${action.toLowerCase()}ed successfully`,
|
||
data: { order: updatedOrder },
|
||
});
|
||
} catch (error) {
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
// @desc Get all return requests (Admin only)
|
||
// @route GET /api/orders/admin/returns
|
||
// @access Private/Admin
|
||
exports.getAdminReturnRequests = async (req, res) => {
|
||
try {
|
||
const page = Number(req.query.page) || 1;
|
||
const limit = Number(req.query.limit) || 10;
|
||
const skip = (page - 1) * limit;
|
||
|
||
const [returns, count] = await Promise.all([
|
||
prisma.order.findMany({
|
||
where: {
|
||
returnStatus: {
|
||
in: ['REQUESTED', 'APPROVED', 'REJECTED', 'COMPLETED'],
|
||
},
|
||
},
|
||
include: {
|
||
user: true,
|
||
address: true,
|
||
items: true,
|
||
},
|
||
orderBy: { returnRequestedAt: 'desc' },
|
||
skip,
|
||
take: limit,
|
||
}),
|
||
prisma.order.count({
|
||
where: {
|
||
returnStatus: {
|
||
in: ['REQUESTED', 'APPROVED', 'REJECTED', 'COMPLETED'],
|
||
},
|
||
},
|
||
}),
|
||
]);
|
||
|
||
res.json({
|
||
status: true,
|
||
count,
|
||
data: returns,
|
||
});
|
||
} catch (error) {
|
||
console.error('Admin return list error:', error);
|
||
res.status(500).json({
|
||
status: false,
|
||
message: 'Failed to fetch return requests',
|
||
});
|
||
}
|
||
};
|
||
|
||
// @desc Get all returned products (Admin only)
|
||
// @route GET /api/orders/admin/returns/list
|
||
// @access Private/Admin
|
||
exports.getReturnedProducts = async (req, res, next) => {
|
||
try {
|
||
const returnedOrders = await prisma.order.findMany({
|
||
where: {
|
||
returnStatus: { in: ['APPROVED', 'COMPLETED'] },
|
||
},
|
||
include: {
|
||
user: true,
|
||
address: true,
|
||
items: true,
|
||
},
|
||
orderBy: {
|
||
returnRequestedAt: 'desc',
|
||
},
|
||
});
|
||
|
||
res.status(200).json({
|
||
status: true,
|
||
count: returnedOrders.length,
|
||
data: returnedOrders,
|
||
});
|
||
} catch (error) {
|
||
next(error);
|
||
}
|
||
};
|
||
|
||
exports.getReturnRequestById = async (req, res) => {
|
||
try {
|
||
const { id } = req.params;
|
||
|
||
// Fetch the order with related user, address, and items
|
||
const order = await prisma.order.findUnique({
|
||
where: { id },
|
||
include: {
|
||
user: true,
|
||
address: true,
|
||
items: true,
|
||
},
|
||
});
|
||
|
||
if (!order) {
|
||
return res
|
||
.status(404)
|
||
.json({ status: false, message: 'Return request not found' });
|
||
}
|
||
|
||
// Ensure this order is a return request
|
||
if (
|
||
!['RETURN_REQUESTED', 'APPROVED', 'REJECTED', 'COMPLETED'].includes(
|
||
order.returnStatus
|
||
)
|
||
) {
|
||
return res
|
||
.status(400)
|
||
.json({ status: false, message: 'This order is not a return request' });
|
||
}
|
||
|
||
res.json({ status: true, data: order });
|
||
} catch (error) {
|
||
console.error('Error fetching return request:', error);
|
||
res.status(500).json({ status: false, message: 'Server error' });
|
||
}
|
||
};
|
||
|
||
// module.exports = { getReturnRequestById };
|