C4M/ITRIMOBE_API
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

commande

Browse Source
This commit is contained in:
Stephane 2025-08-02 11:56:10 +03:00
parent 2c87acd607
commit a2b682e161
4 changed files with 489 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

454
controllers/commandeController.js
View File

@ -1,8 +1,23 @@
// controllers/commandesController.js
const Commande = require('../models/Commande');
const CommandeItem = require('../models/CommandeItem');
const Menu = require('../models/Menu');
const { Op } = require('sequelize');
const sequelize = require('../config/database');
// Get all commandes
// Helper function to validate and convert numbers
const validateNumber = (value, defaultValue = 0) => {
const num = parseFloat(value);
return isNaN(num) ? defaultValue : num;
};
// Helper function to validate integer
const validateInteger = (value, defaultValue = 1) => {
const num = parseInt(value);
return isNaN(num) ? defaultValue : num;
};
// Get all commandes with menu details
const getAllCommandes = async (req, res) => {
try {
const page = parseInt(req.query.page) || 1;
@ -41,6 +56,40 @@ const getAllCommandes = async (req, res) => {
order: [['date_commande', 'DESC']]
});
// Fetch items with menu details for each commande
const commandeIds = rows.map(c => c.id);
let itemsWithMenus = [];
if (commandeIds.length > 0) {
itemsWithMenus = await sequelize.query(`
SELECT
ci.*,
m.nom as menu_nom,
m.commentaire as menu_description,
m.prix as menu_prix_actuel
FROM commande_items ci
LEFT JOIN menus m ON ci.menu_id = m.id
WHERE ci.commande_id IN (${commandeIds.join(',')})
ORDER BY ci.id
`, {
type: sequelize.QueryTypes.SELECT
});
}
// Group items by commande_id
const itemsByCommandeId = itemsWithMenus.reduce((acc, item) => {
if (!acc[item.commande_id]) {
acc[item.commande_id] = [];
}
acc[item.commande_id].push(item);
return acc;
}, {});
// Add items to each commande
rows.forEach(commande => {
commande.dataValues.items = itemsByCommandeId[commande.id] || [];
});
res.status(200).json({
success: true,
data: {
@ -54,6 +103,7 @@ const getAllCommandes = async (req, res) => {
}
});
} catch (error) {
console.error('Error in getAllCommandes:', error);
res.status(500).json({
success: false,
message: 'Erreur lors de la récupération des commandes',
@ -62,7 +112,7 @@ const getAllCommandes = async (req, res) => {
}
};
// Get commande by ID
// Get commande by ID with menu details
const getCommandeById = async (req, res) => {
try {
const commande = await Commande.findByPk(req.params.id);
@ -74,11 +124,30 @@ const getCommandeById = async (req, res) => {
});
}
// Fetch items with menu details
const itemsWithMenus = await sequelize.query(`
SELECT
ci.*,
m.nom as menu_nom,
m.commentaire as menu_description,
m.prix as menu_prix_actuel
FROM commande_items ci
LEFT JOIN menus m ON ci.menu_id = m.id
WHERE ci.commande_id = :commandeId
ORDER BY ci.id
`, {
replacements: { commandeId: req.params.id },
type: sequelize.QueryTypes.SELECT
});
commande.dataValues.items = itemsWithMenus;
res.status(200).json({
success: true,
data: commande
});
} catch (error) {
console.error('Error in getCommandeById:', error);
res.status(500).json({
success: false,
message: 'Erreur lors de la récupération de la commande',
@ -87,9 +156,16 @@ const getCommandeById = async (req, res) => {
}
};
// Create new commande
// Create new commande with items (fetch prices from menu)
const createCommande = async (req, res) => {
let transaction;
try {
// Start transaction
transaction = await sequelize.transaction();
console.log('Received data:', JSON.stringify(req.body, null, 2));
const {
client_id,
table_id,
@ -103,31 +179,181 @@ const createCommande = async (req, res) => {
commentaires,
serveur,
date_commande,
date_service
date_service,
items // Array of items with menu_id and quantite
} = req.body;
const newCommande = await Commande.create({
client_id,
table_id,
reservation_id,
numero_commande,
statut: statut || 'en_attente',
total_ht: total_ht || 0.00,
total_tva: total_tva || 0.00,
total_ttc: total_ttc || 0.00,
mode_paiement,
commentaires,
serveur,
date_commande: date_commande || new Date(),
date_service
// Validate required fields
if (!table_id) {
return res.status(400).json({
success: false,
message: 'table_id est requis'
});
}
// Create the commande first
const commandeData = {
client_id: client_id || null,
table_id: validateInteger(table_id),
reservation_id: reservation_id || null,
numero_commande: numero_commande || null,
statut: statut || 'en_attente',
total_ht: validateNumber(total_ht, 0).toFixed(2),
total_tva: validateNumber(total_tva, 0).toFixed(2),
total_ttc: validateNumber(total_ttc, 0).toFixed(2),
mode_paiement: mode_paiement || null,
commentaires: commentaires || null,
serveur: serveur || null,
date_commande: date_commande || new Date(),
date_service: date_service || null
};
console.log('Validated commande data:', JSON.stringify(commandeData, null, 2));
const newCommande = await Commande.create(commandeData, { transaction });
// If items are provided, create them with prices from menu
if (items && Array.isArray(items) && items.length > 0) {
console.log('Processing items:', JSON.stringify(items, null, 2));
const commandeItems = [];
let calculatedTotal = 0;
// Get all menu IDs from items
const menuIds = items.map(item => validateInteger(item.menu_id)).filter(id => id > 0);
if (menuIds.length === 0) {
return res.status(400).json({
success: false,
message: 'Aucun menu_id valide fourni'
});
}
// Fetch menu prices
const menus = await Menu.findAll({
where: {
id: { [Op.in]: menuIds }
},
attributes: ['id', 'nom', 'prix', 'disponible'],
transaction
});
// Create a map of menu_id to menu data
const menuMap = menus.reduce((acc, menu) => {
acc[menu.id] = menu;
return acc;
}, {});
// Process each item
for (const item of items) {
const menu_id = validateInteger(item.menu_id);
const quantite = validateInteger(item.quantite, 1);
if (menu_id === 0) {
return res.status(400).json({
success: false,
message: 'menu_id invalide',
invalidItem: item
});
}
// Check if menu exists
const menu = menuMap[menu_id];
if (!menu) {
return res.status(400).json({
success: false,
message: `Menu avec ID ${menu_id} n'existe pas`,
invalidItem: item
});
}
// Check if menu is available
if (!menu.disponible) {
return res.status(400).json({
success: false,
message: `Menu "${menu.nom}" n'est plus disponible`,
invalidItem: item
});
}
// Use price from menu table
const prix_unitaire = validateNumber(menu.prix, 0);
const total_item = prix_unitaire * quantite;
if (prix_unitaire === 0) {
return res.status(400).json({
success: false,
message: `Prix invalide pour le menu "${menu.nom}"`,
invalidItem: item
});
}
const validatedItem = {
commande_id: newCommande.id,
menu_id: menu_id,
quantite: quantite,
prix_unitaire: prix_unitaire.toFixed(2),
total_item: total_item.toFixed(2),
commentaires: item.commentaires || null,
statut: item.statut || 'commande'
};
commandeItems.push(validatedItem);
calculatedTotal += total_item;
}
console.log('Validated items:', JSON.stringify(commandeItems, null, 2));
await CommandeItem.bulkCreate(commandeItems, { transaction });
// Auto-calculate totals if not provided
if (validateNumber(total_ttc, 0) === 0) {
await newCommande.update({
total_ht: calculatedTotal.toFixed(2),
total_ttc: calculatedTotal.toFixed(2)
}, { transaction });
}
}
// Commit the transaction
await transaction.commit();
// Now fetch the created commande with items and menu details (outside of transaction)
const createdCommande = await Commande.findByPk(newCommande.id);
const createdItemsWithMenus = await sequelize.query(`
SELECT
ci.*,
m.nom as menu_nom,
m.commentaire as menu_description,
m.prix as menu_prix_actuel
FROM commande_items ci
LEFT JOIN menus m ON ci.menu_id = m.id
WHERE ci.commande_id = :commandeId
ORDER BY ci.id
`, {
replacements: { commandeId: newCommande.id },
type: sequelize.QueryTypes.SELECT
});
createdCommande.dataValues.items = createdItemsWithMenus;
res.status(201).json({
success: true,
message: 'Commande créée avec succès',
data: newCommande
data: createdCommande
});
} catch (error) {
// Only rollback if transaction exists and hasn't been finished
if (transaction && !transaction.finished) {
try {
await transaction.rollback();
} catch (rollbackError) {
console.error('Error rolling back transaction:', rollbackError);
}
}
console.error('Error in createCommande:', error);
res.status(400).json({
success: false,
message: 'Erreur lors de la création de la commande',
@ -136,11 +362,15 @@ const createCommande = async (req, res) => {
}
};
// Update commande
// Update commande (also fetch prices from menu)
const updateCommande = async (req, res) => {
let transaction;
try {
transaction = await sequelize.transaction();
const commandeId = req.params.id;
const updateData = req.body;
const { items, ...commandeData } = req.body;
const commande = await Commande.findByPk(commandeId);
@ -151,14 +381,126 @@ const updateCommande = async (req, res) => {
});
}
await commande.update(updateData);
// Validate numeric fields in commandeData
if (commandeData.total_ht !== undefined) {
commandeData.total_ht = validateNumber(commandeData.total_ht, 0).toFixed(2);
}
if (commandeData.total_tva !== undefined) {
commandeData.total_tva = validateNumber(commandeData.total_tva, 0).toFixed(2);
}
if (commandeData.total_ttc !== undefined) {
commandeData.total_ttc = validateNumber(commandeData.total_ttc, 0).toFixed(2);
}
// Update commande
await commande.update(commandeData, { transaction });
// If items are provided, update them with current menu prices
if (items && Array.isArray(items) && items.length > 0) {
// Delete existing items
await CommandeItem.destroy({
where: { commande_id: commandeId },
transaction
});
// Get menu prices
const menuIds = items.map(item => validateInteger(item.menu_id)).filter(id => id > 0);
const menus = await Menu.findAll({
where: {
id: { [Op.in]: menuIds }
},
attributes: ['id', 'nom', 'prix', 'est_disponible'],
transaction
});
const menuMap = menus.reduce((acc, menu) => {
acc[menu.id] = menu;
return acc;
}, {});
// Create new items with validation
const commandeItems = [];
let calculatedTotal = 0;
for (const item of items) {
const menu_id = validateInteger(item.menu_id);
const quantite = validateInteger(item.quantite, 1);
const menu = menuMap[menu_id];
if (!menu) {
return res.status(400).json({
success: false,
message: `Menu avec ID ${menu_id} n'existe pas`
});
}
const prix_unitaire = validateNumber(menu.prix, 0);
const total_item = prix_unitaire * quantite;
const validatedItem = {
commande_id: commandeId,
menu_id: menu_id,
quantite: quantite,
prix_unitaire: prix_unitaire.toFixed(2),
total_item: total_item.toFixed(2),
commentaires: item.commentaires || null,
statut: item.statut || 'commande'
};
commandeItems.push(validatedItem);
calculatedTotal += total_item;
}
await CommandeItem.bulkCreate(commandeItems, { transaction });
// Recalculate totals if not provided
if (!commandeData.total_ttc) {
await commande.update({
total_ht: calculatedTotal.toFixed(2),
total_ttc: calculatedTotal.toFixed(2)
}, { transaction });
}
}
await transaction.commit();
// Fetch updated commande with items and menu details (outside of transaction)
const updatedCommande = await Commande.findByPk(commandeId);
const updatedItemsWithMenus = await sequelize.query(`
SELECT
ci.*,
m.nom as menu_nom,
m.commentaire as menu_description,
m.prix as menu_prix_actuel
FROM commande_items ci
LEFT JOIN menus m ON ci.menu_id = m.id
WHERE ci.commande_id = :commandeId
ORDER BY ci.id
`, {
replacements: { commandeId },
type: sequelize.QueryTypes.SELECT
});
updatedCommande.dataValues.items = updatedItemsWithMenus;
res.status(200).json({
success: true,
message: 'Commande mise à jour avec succès',
data: commande
data: updatedCommande
});
} catch (error) {
// Only rollback if transaction exists and hasn't been finished
if (transaction && !transaction.finished) {
try {
await transaction.rollback();
} catch (rollbackError) {
console.error('Error rolling back transaction:', rollbackError);
}
}
console.error('Error in updateCommande:', error);
res.status(400).json({
success: false,
message: 'Erreur lors de la mise à jour de la commande',
@ -169,7 +511,11 @@ const updateCommande = async (req, res) => {
// Delete commande
const deleteCommande = async (req, res) => {
let transaction;
try {
transaction = await sequelize.transaction();
const commandeId = req.params.id;
const commande = await Commande.findByPk(commandeId);
@ -181,13 +527,32 @@ const deleteCommande = async (req, res) => {
});
}
await commande.destroy();
// Delete items first
await CommandeItem.destroy({
where: { commande_id: commandeId },
transaction
});
// Delete commande
await commande.destroy({ transaction });
await transaction.commit();
res.status(200).json({
success: true,
message: 'Commande supprimée avec succès'
});
} catch (error) {
if (transaction && !transaction.finished) {
try {
await transaction.rollback();
} catch (rollbackError) {
console.error('Error rolling back transaction:', rollbackError);
}
}
console.error('Error in deleteCommande:', error);
res.status(500).json({
success: false,
message: 'Erreur lors de la suppression de la commande',
@ -231,6 +596,7 @@ const updateStatut = async (req, res) => {
data: commande
});
} catch (error) {
console.error('Error in updateStatut:', error);
res.status(400).json({
success: false,
message: 'Erreur lors de la mise à jour du statut',
@ -239,7 +605,7 @@ const updateStatut = async (req, res) => {
}
};
// Get commandes by status
// Get commandes by status with menu details
const getCommandesByStatut = async (req, res) => {
try {
const { statut } = req.params;
@ -249,11 +615,43 @@ const getCommandesByStatut = async (req, res) => {
order: [['date_commande', 'DESC']]
});
// Fetch items with menu details for each commande
if (commandes.length > 0) {
const commandeIds = commandes.map(c => c.id);
const itemsWithMenus = await sequelize.query(`
SELECT
ci.*,
m.nom as menu_nom,
m.commentaire as menu_description,
m.prix as menu_prix_actuel
FROM commande_items ci
LEFT JOIN menus m ON ci.menu_id = m.id
WHERE ci.commande_id IN (${commandeIds.join(',')})
ORDER BY ci.id
`, {
type: sequelize.QueryTypes.SELECT
});
const itemsByCommandeId = itemsWithMenus.reduce((acc, item) => {
if (!acc[item.commande_id]) {
acc[item.commande_id] = [];
}
acc[item.commande_id].push(item);
return acc;
}, {});
commandes.forEach(commande => {
commande.dataValues.items = itemsByCommandeId[commande.id] || [];
});
}
res.status(200).json({
success: true,
data: commandes
});
} catch (error) {
console.error('Error in getCommandesByStatut:', error);
res.status(500).json({
success: false,
message: 'Erreur lors de la récupération des commandes par statut',
@ -281,7 +679,8 @@ const getDailyStats = async (req, res) => {
[sequelize.fn('COUNT', sequelize.col('id')), 'count'],
[sequelize.fn('SUM', sequelize.col('total_ttc')), 'total_amount']
],
group: ['statut']
group: ['statut'],
raw: true
});
res.status(200).json({
@ -291,7 +690,9 @@ const getDailyStats = async (req, res) => {
statistics: stats
}
});
} catch (error) {
console.error('Error in getDailyStats:', error);
res.status(500).json({
success: false,
message: 'Erreur lors de la récupération des statistiques',
@ -300,7 +701,6 @@ const getDailyStats = async (req, res) => {
}
};
// IMPORTANT: Make sure this export is at the very end of the file
module.exports = {
getAllCommandes,
getCommandeById,

2
models/Commande.js
View File

@ -22,7 +22,7 @@ const Commande = sequelize.define('Commande', {
},
numero_commande: {
type: DataTypes.STRING,
allowNull: false,
allowNull: true,
unique: true
},
statut: {

29
models/CommandeItem.js
View File

@ -1,7 +1,7 @@
// models/CommandeItem.js (note the capital C and I)
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
module.exports = (sequelize) => {
const CommandeItem = sequelize.define('CommandeItem', {
id: {
type: DataTypes.INTEGER,
@ -18,22 +18,12 @@ const CommandeItem = sequelize.define('CommandeItem', {
},
menu_id: {
type: DataTypes.INTEGER,
allowNull: false,
references: {
model: 'menus',
key: 'id'
}
allowNull: false
},
quantite: {
type: DataTypes.INTEGER,
allowNull: false,
defaultValue: 1,
validate: {
min: {
args: [1],
msg: 'La quantité doit être au moins de 1'
}
}
defaultValue: 1
},
prix_unitaire: {
type: DataTypes.DECIMAL(10, 2),
@ -49,13 +39,20 @@ const CommandeItem = sequelize.define('CommandeItem', {
},
statut: {
type: DataTypes.ENUM('commande', 'en_preparation', 'pret', 'servi'),
allowNull: true,
defaultValue: 'commande'
}
}, {
tableName: 'commande_items',
timestamps: true,
createdAt: 'created_at',
updatedAt: 'updated_at'
updatedAt: 'updated_at',
hooks: {
beforeSave: (item) => {
// Auto-calculate total_item
item.total_item = parseFloat(item.prix_unitaire) * parseInt(item.quantite);
}
}
});
return CommandeItem;
}
module.exports = CommandeItem;

12
models/associations.js
View File

@ -135,6 +135,18 @@ const defineAssociations = () => {
});
}
Commande.hasMany(CommandeItem, {
foreignKey: 'commande_id',
as: 'items',
onDelete: 'CASCADE'
});
CommandeItem.belongsTo(Commande, {
foreignKey: 'commande_id',
as: 'commande'
});
if (Reservation) {