ParkSuMin/DELIVER_MAN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: ParkSuMin:45e07d6413627bd1a3156fb8c0a1c93bf3525d2d
Branches Tags
ParkSuMin:master ParkSuMin:API
..
compare: ParkSuMin:API
Branches Tags
ParkSuMin:master ParkSuMin:API

4 Commits
45e07d6413 ... API

Author SHA1 Message Date
ParkSuMin
13fe841e54 Database 2026-01-03 18:17:29 +03:00
ParkSuMin
58b88c05a7 CORS problem resolve 2026-01-03 18:16:18 +03:00
ParkSuMin
85d1a9f046 API check 2026-01-03 18:15:52 +03:00
ParkSuMin
363798ca44 Ready index.html 2026-01-03 18:11:02 +03:00
4 changed files with 491 additions and 154 deletions
Expand all files Collapse all files

59
public/index.html
View File

@@ -1,24 +1,59 @@
<!DOCTYPE html> <!DOCTYPE html>
<html lang="ru"> <html lang="ru">
<head> <head>
<meta charset="utf-8" /> <meta charset="UTF-8" />
<title>Личный кабинет</title> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css" <title>Личный кабинет склада — Заказы</title>
<link
href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css"
rel="stylesheet" rel="stylesheet"
integrity="sha384-sRIl4kxILFvY47J16cr9ZwB07vP4J8+LH7qKQnuqkuIAvNWLzeN8tE5YBujZqJLB"
crossorigin="anonymous"
/> />
</head> <link href="/styles.css" rel="stylesheet" />
<body class="bg-light"> <script src="./app.js" defer></script>
</head>
<body class="bg-light">
<div class="container py-4"> <div class="container py-4">
<div class="d-flex flex-wrap gap-3 align-items-center justify-content-between mb-4"> <div class="d-flex flex-wrap gap-3 align-items-center justify-content-between mb-4">
<div> <div>
<h1 class="h3 mb-1">Заказы склада</h1> <h1 class="h3 mb-1">Заказы склада</h1>
<p class="text-muted mb-0">Текущая дата: <span id="current-date">{ empty }</span></p> <p class="text-muted mb-0">Текущая дата: <span id="current-date">—</span></p>
</div> </div>
<button id="advance-date" class="btn btn-outline-primary">Следующий день</button> <button id="advance-date" class="btn btn-outline-primary">Переключить дату +1</button>
</div>
<div id="notification" class="alert d-none" role="alert"></div>
<div class="row g-4">
<div class="col-lg-4">
<div class="card shadow-sm">
<div class="card-body">
<h2 class="h5">Создать заказ</h2>
<form id="order-form" class="d-grid gap-2">
<div>
<label class="form-label" for="customer-name">ФИО заказчика</label>
<input type="text" class="form-control" id="customer-name" required />
</div>
<div>
<label class="form-label" for="order-date">Дата заказа</label>
<input type="date" class="form-control" id="order-date" required />
</div>
<button type="submit" class="btn btn-primary">Добавить</button>
</form>
</div> </div>
</div> </div>
</body>
<div class="card shadow-sm mt-4">
<div class="card-body">
<h2 class="h5">Остатки склада</h2>
<ul id="inventory" class="list-group list-group-flush"></ul>
</div>
</div>
</div>
<div class="col-lg-8">
<div id="orders" class="d-grid gap-3"></div>
</div>
</div>
</div>
</body>
</html> </html>

15
public/styles.css Normal file
View File

@@ -0,0 +1,15 @@
body {
font-family: "Inter", "Segoe UI", sans-serif;
}
.order-card {
border-left: 4px solid #0d6efd;
}
.order-meta {
font-size: 0.9rem;
}
.item-actions {
min-width: 220px;
}

359
server/db/database.js
View File

@@ -24,7 +24,7 @@ export default class DBAdapter {
#dbName = 'N'; #dbName = 'N';
#dbUserLogin = 'u'; #dbUserLogin = 'u';
#dbUserPassword = 'p'; #dbUserPassword = 'p';
#dbClient = null; #pool = null;
constructor({ constructor({
dbHost, dbHost,
@@ -38,40 +38,43 @@ export default class DBAdapter {
this.#dbName = dbName; this.#dbName = dbName;
this.#dbUserLogin = dbUserLogin; this.#dbUserLogin = dbUserLogin;
this.#dbUserPassword = dbUserPassword; this.#dbUserPassword = dbUserPassword;
this.#dbClient = new mdb.createPool({ this.#pool = mdb.createPool({
host: this.#dbhost, host: this.#dbhost,
port: this.#dbPort, port: this.#dbPort,
database: this.#dbName, database: this.#dbName,
user: this.#dbUserLogin, user: this.#dbUserLogin,
password: this.#dbUserPassword, password: this.#dbUserPassword,
dateStrings: true dateStrings: true,
acquireTimeout: 10000,
}); });
} }
async #getConnection() {
return await this.#pool.getConnection();
}
async connect() { async connect() {
try { try {
// Проверяем подключение, выполняя простой запрос const conn = await this.#pool.getConnection();
const conn = await this.#dbClient.getConnection();
console.log("✅ Database connection test successful"); console.log("✅ Database connection test successful");
conn.release(); conn.release();
} catch (err) { } catch (err) {
console.error("❌ Database connection failed:", err.message); console.error("❌ Database connection failed:", err.message);
// Пробрасываем ошибку дальше
return Promise.reject(); return Promise.reject();
} }
} }
async disconnect() { async disconnect() {
await this.#dbClient.end(); await this.#pool.end();
console.log("DISCONNECT"); console.log("DISCONNECT");
} }
async stock(){ async stock(){
try { try {
const products = await this.#dbClient.query('SELECT id FROM products'); const products = await this.#pool.query('SELECT id FROM products');
for (const product of products) { for (const product of products) {
const increment = Random_Increase(); const increment = Random_Increase();
await this.#dbClient.query('UPDATE products SET quantity = quantity + ? WHERE id = ?', [ await this.#pool.query('UPDATE products SET quantity = quantity + ? WHERE id = ?', [
increment, increment,
product.id product.id
]); ]);
@@ -86,8 +89,7 @@ export default class DBAdapter {
async getProducts() { async getProducts() {
try { try {
const products = await this.#dbClient.query('SELECT * FROM products ORDER BY name'); const products = await this.#pool.query('SELECT * FROM products ORDER BY name');
console.log("All products:", products);
return products; return products;
} catch(err){ } catch(err){
console.log(`WHOOPS`); console.log(`WHOOPS`);
@@ -97,14 +99,12 @@ export default class DBAdapter {
async getOrders() { async getOrders() {
try { try {
const raw_orders = await this.#dbClient.query('SELECT * FROM orders ORDER BY order_date ASC'); const raw_orders = await this.#pool.query('SELECT * FROM orders ORDER BY order_date ASC');
console.log("All orders:", raw_orders);
const items = await this.#dbClient.query( const items = await this.#pool.query(
`SELECT order_items.*, products.name AS product_name FROM order_items `SELECT order_items.*, products.name AS product_name FROM order_items
JOIN products ON order_items.product_id = products.id` JOIN products ON order_items.product_id = products.id`
); );
console.log("All order items:", items);
const groupedItems = {}; const groupedItems = {};
if (items && items.length > 0) { if (items && items.length > 0) {
@@ -132,7 +132,7 @@ export default class DBAdapter {
} }
async addOrder({ id, customer_name, orderDate} ){ async addOrder({ id, customer_name, orderDate} ){
if (!customer_name || !orderDate){ if (!id || !customer_name || !orderDate){
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Empty in customer name or order date") error: new Error("Empty in customer name or order date")
@@ -146,7 +146,7 @@ export default class DBAdapter {
}); });
} }
try { try {
await this.#dbClient.query('INSERT INTO orders (id, customer_name, order_date) VALUES (?, ?, ?)', await this.#pool.query('INSERT INTO orders (id, customer_name, order_date) VALUES (?, ?, ?)',
[id, customer_name, orderDate] [id, customer_name, orderDate]
); );
} catch(err){ } catch(err){
@@ -159,7 +159,7 @@ export default class DBAdapter {
async getOrdersByDate(date){ async getOrdersByDate(date){
try { try {
const order_ids = await this.#dbClient.query('SELECT id FROM orders WHERE order_date = ?', [date]); const order_ids = await this.#pool.query('SELECT id FROM orders WHERE order_date = ?', [date]);
return order_ids; return order_ids;
} catch(err){ } catch(err){
return Promise.reject(); return Promise.reject();
@@ -175,7 +175,7 @@ export default class DBAdapter {
try { try {
const placeholders = orderIds.map(() => '?').join(','); const placeholders = orderIds.map(() => '?').join(',');
const result = await this.#dbClient.query( const result = await this.#pool.query(
`DELETE FROM orders WHERE id IN (${placeholders})`, `DELETE FROM orders WHERE id IN (${placeholders})`,
orderIds orderIds
); );
@@ -188,11 +188,12 @@ export default class DBAdapter {
} }
} }
async changeOrderInfo({ id, customer_name, orderDate }){ async changeOrderInfo({ id, customer_name, orderDate }) {
if (!id) { if (!id || !customer_name || !orderDate) {
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Order ID is required") error: new Error("Order ID, name or date is required!"),
message: "Order ID, name or date is required!" // Добавляем message напрямую
}); });
} }
@@ -200,100 +201,205 @@ export default class DBAdapter {
if (orderDate < currentDate) { if (orderDate < currentDate) {
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Order date cannot be less than current date") error: new Error("Order date cannot be less than current date"),
message: "Order date cannot be less than current date"
}); });
} }
try { try {
const order = await this.#dbClient.query('SELECT * FROM orders WHERE id = ?', [id]); const order = await this.#pool.query('SELECT * FROM orders WHERE id = ?', [id]);
if (!order){ if (!order || order.length === 0) { // Исправлено: проверяем length
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Order not found") error: new Error("Order not found"),
message: "Order not found"
}); });
} }
const updatedName = customer_name; const updatedName = customer_name;
const updatedDate = orderDate; const updatedDate = orderDate;
await this.#dbClient.query('UPDATE orders SET customer_name = ?, order_date = ? WHERE id = ?', await this.#pool.query('UPDATE orders SET customer_name = ?, order_date = ? WHERE id = ?',
[updatedName, updatedDate, id] [updatedName, updatedDate, id]
); );
} catch(err){ } catch(err) {
console.error('Database error in changeOrderInfo:', err);
return Promise.reject({ return Promise.reject({
type: DB_INTERNAL_ERROR, type: DB_INTERNAL_ERROR,
error: new Error("Server error") error: new Error("Server error"),
message: err.message || "Database operation failed",
details: err.message
}); });
} }
} }
async deleteOrderById(order_id){ async deleteOrderById(order_id) {
let connection;
try { try {
const orderItems = await this.#dbClient.query( connection = await this.#pool.getConnection();
await connection.beginTransaction();
const orderItems = await connection.query(
`SELECT product_id, quantity FROM order_items WHERE order_id = ?`, `SELECT product_id, quantity FROM order_items WHERE order_id = ?`,
[order_id] [order_id]
); );
for (const item of orderItems){ for (const item of orderItems) {
await this.#dbClient.query('UPDATE products SET quantity = quantity + ? WHERE id = ?', await connection.query(
'UPDATE products SET quantity = quantity + ? WHERE id = ?',
[item.quantity, item.product_id] [item.quantity, item.product_id]
); );
} }
await this.#dbClient.query(
await connection.query(
`DELETE FROM order_items WHERE order_id = ?`,
[order_id]
);
await connection.query(
`DELETE FROM orders WHERE id = ?`, `DELETE FROM orders WHERE id = ?`,
[order_id] [order_id]
); );
} catch(err){
await connection.commit();
connection.release();
} catch (err) {
if (connection) {
try {
await connection.rollback();
} catch (rollbackErr) {
console.error('Rollback error:', rollbackErr.message);
}
connection.release();
}
return Promise.reject({ return Promise.reject({
type: DB_INTERNAL_ERROR, type: DB_INTERNAL_ERROR,
error: new Error("Server error") error: new Error("Failed to delete order"),
details: err.message
}); });
} }
} }
async addOrderItem({ orderId, productId, quantity }){ async addOrderItem({ orderId, productId, quantity }) {
await this.#dbClient.query('BEGIN'); let connection;
try { try {
const product = await this.#dbClient.query( connection = await this.#pool.getConnection();
'SELECT quantity FROM products WHERE id = ?', [productId]
await connection.beginTransaction();
const orderCheck = await connection.query(
'SELECT id FROM orders WHERE id = ?',
[orderId]
);
if (!orderCheck || orderCheck.length === 0) {
await connection.rollback();
connection.release();
return Promise.reject({
type: DB_USER_ERROR,
error: new Error("Order not found")
});
}
const product = await connection.query(
'SELECT id, quantity FROM products WHERE id = ? FOR UPDATE',
[productId]
); );
const productRow = product?.[0]; const productRow = product?.[0];
if (!productRow || productRow.quantity < quantity){
if (!productRow) {
await connection.rollback();
connection.release();
return Promise.reject({
type: DB_USER_ERROR,
error: new Error("Product not found")
});
}
if (productRow.quantity < quantity) {
await connection.rollback();
connection.release();
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Insufficient product quantity") error: new Error("Insufficient product quantity")
}); });
} }
const result = await this.#dbClient.query( await connection.query(
'INSERT INTO order_items (order_id, product_id, quantity) VALUES (?, ?, ?)',
[orderId, productId, quantity]
);
await this.#dbClient.query(
'UPDATE products SET quantity = quantity - ? WHERE id = ?', 'UPDATE products SET quantity = quantity - ? WHERE id = ?',
[quantity, productId] [quantity, productId]
); );
await this.#dbClient.query('COMMIT'); const result = await connection.query(
} catch (err){ 'INSERT INTO order_items (order_id, product_id, quantity) VALUES (?, ?, ?)',
await this.#dbClient.query('ROLLBACK'); [orderId, productId, quantity]
return Promise.reject(); );
await connection.commit();
connection.release();
return result.insertId;
} catch (err) {
if (connection) {
try {
await connection.rollback();
} catch (rollbackErr) {
console.error('Rollback error:', rollbackErr.message);
}
connection.release();
}
console.error('Transaction error:', err);
let errorType = DB_INTERNAL_ERROR;
let userMessage = "Database operation failed";
let retryable = false;
if (err.code === 'ER_LOCK_WAIT_TIMEOUT' || err.errno === 1205) {
errorType = 'DB_CONFLICT';
userMessage = "System is busy. Please try again in a moment.";
retryable = true;
} else if (err.code === 'ER_DUP_ENTRY') {
errorType = DB_USER_ERROR;
userMessage = "Item already exists in the order";
}
return Promise.reject({
type: errorType,
error: new Error(userMessage),
details: err.message,
code: err.code,
retryable: retryable,
originalError: err
});
} }
} }
async updateOrderItem({ itemId, quantity }){ async updateOrderItem({ itemId, quantity }) {
await this.#dbClient.query('BEGIN'); let connection;
try { try {
const item = await this.#dbClient.query( connection = await this.#pool.getConnection();
'SELECT product_id, quantity FROM order_items WHERE id = ?', [itemId] await connection.beginTransaction();
const item = await connection.query(
'SELECT product_id, quantity FROM order_items WHERE id = ? FOR UPDATE',
[itemId]
); );
const itemRow = item?.[0]; const itemRow = item?.[0];
if (!itemRow){ if (!itemRow) {
await connection.rollback();
connection.release();
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Order item not found") error: new Error("Order item not found")
@@ -302,100 +408,177 @@ export default class DBAdapter {
const diff = quantity - itemRow.quantity; const diff = quantity - itemRow.quantity;
if (diff > 0){ if (diff > 0) {
const product = await this.#dbClient.query( const product = await connection.query(
'SELECT quantity FROM products WHERE id = ?', [itemRow.product_id] 'SELECT quantity FROM products WHERE id = ? FOR UPDATE',
[itemRow.product_id]
); );
const productRow = product?.[0]; const productRow = product?.[0];
if (!productRow || productRow.quantity < diff){ if (!productRow || productRow.quantity < diff) {
await connection.rollback();
connection.release();
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Insufficient product quantity") error: new Error("Insufficient product quantity")
}); });
} }
await this.#dbClient.query( await connection.query(
'UPDATE products SET quantity = quantity - ? WHERE id = ?', 'UPDATE products SET quantity = quantity - ? WHERE id = ?',
[diff, itemRow.product_id] [diff, itemRow.product_id]
); );
} }
if (diff < 0) { if (diff < 0) {
await this.#dbClient.query( await connection.query(
'UPDATE products SET quantity = quantity + ? WHERE id = ?', 'UPDATE products SET quantity = quantity + ? WHERE id = ?',
[-diff, itemRow.product_id] [-diff, itemRow.product_id]
); );
} }
await this.#dbClient.query( await connection.query(
'UPDATE order_items SET quantity = ? WHERE id = ?', 'UPDATE order_items SET quantity = ? WHERE id = ?',
[quantity, itemId] [quantity, itemId]
); );
await this.#dbClient.query('COMMIT'); await connection.commit();
} catch (err){ connection.release();
await this.#dbClient.query('ROLLBACK');
return Promise.reject(); } catch (err) {
if (connection) {
try {
await connection.rollback();
} catch (rollbackErr) {
console.error('Rollback error:', rollbackErr.message);
}
connection.release();
}
return Promise.reject({
type: DB_INTERNAL_ERROR,
error: new Error("Failed to update order item"),
details: err.message
});
} }
} }
async deleteOrderItem(itemId){ async deleteOrderItem(itemId) {
await this.#dbClient.query('BEGIN'); let connection;
try { try {
const item = await this.#dbClient.query( connection = await this.#pool.getConnection();
'SELECT product_id, quantity FROM order_items WHERE id = ?', [itemId] await connection.beginTransaction();
const item = await connection.query(
'SELECT product_id, quantity FROM order_items WHERE id = ? FOR UPDATE',
[itemId]
); );
const itemRow = item?.[0]; const itemRow = item?.[0];
if (!itemRow){ if (!itemRow) {
await connection.rollback();
connection.release();
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Order item not found") error: new Error("Order item not found")
}); });
} }
await this.#dbClient.query( await connection.query(
'UPDATE products SET quantity = quantity + ? WHERE id = ?', 'UPDATE products SET quantity = quantity + ? WHERE id = ?',
[itemRow.quantity, itemRow.product_id] [itemRow.quantity, itemRow.product_id]
); );
await this.#dbClient.query( await connection.query(
'DELETE FROM order_items WHERE id = ?', 'DELETE FROM order_items WHERE id = ?',
[itemId] [itemId]
); );
await this.#dbClient.query('COMMIT'); await connection.commit();
} catch (err){ connection.release();
await this.#dbClient.query('ROLLBACK');
return Promise.reject(); } catch (err) {
if (connection) {
try {
await connection.rollback();
} catch (rollbackErr) {
console.error('Rollback error:', rollbackErr.message);
}
connection.release();
}
console.error('Delete order item error:', err);
return Promise.reject({
type: DB_INTERNAL_ERROR,
error: new Error("Failed to delete order item"),
details: err.message,
itemId: itemId
});
} }
} }
async moveOrderItem( {itemId, targetOrderId }){ async moveOrderItem({ itemId, targetOrderId }) {
await this.#dbClient.query('BEGIN'); let connection;
try { try {
const item = await this.#dbClient.query( connection = await this.#pool.getConnection();
'SELECT id, order_id FROM order_items WHERE id = ?', [itemId] await connection.beginTransaction();
// Проверяем существование целевого заказа
const targetOrderCheck = await connection.query(
'SELECT id FROM orders WHERE id = ?',
[targetOrderId]
);
if (!targetOrderCheck || targetOrderCheck.length === 0) {
await connection.rollback();
connection.release();
return Promise.reject({
type: DB_USER_ERROR,
error: new Error("Target order not found")
});
}
const item = await connection.query(
'SELECT id, order_id FROM order_items WHERE id = ? FOR UPDATE',
[itemId]
); );
const itemRow = item?.[0]; const itemRow = item?.[0];
if (!itemRow){ if (!itemRow) {
await connection.rollback();
connection.release();
return Promise.reject({ return Promise.reject({
type: DB_USER_ERROR, type: DB_USER_ERROR,
error: new Error("Order item not found") error: new Error("Order item not found")
}); });
} }
await this.#dbClient.query( await connection.query(
'UPDATE order_items SET order_id = ? WHERE id = ?', 'UPDATE order_items SET order_id = ? WHERE id = ?',
[targetOrderId, itemId] [targetOrderId, itemId]
); );
await this.#dbClient.query('COMMIT'); await connection.commit();
} catch (err){ connection.release();
await this.#dbClient.query('ROLLBACK');
return Promise.reject(); } catch (err) {
if (connection) {
try {
await connection.rollback();
} catch (rollbackErr) {
console.error('Rollback error:', rollbackErr.message);
}
connection.release();
}
return Promise.reject({
type: DB_INTERNAL_ERROR,
error: new Error("Failed to move order item"),
details: err.message
});
} }
} }
} }

182
server/server.js
View File

@@ -20,6 +20,16 @@ const appPort = 3000;
const app = express(); const app = express();
app.use(express.json()); app.use(express.json());
app.use((req, res, next) => {
res.setHeader('Access-Control-Allow-Origin', '*');
res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
res.setHeader('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE');
if (req.method === 'OPTIONS') {
res.sendStatus(204);
return;
}
next();
});
const adapter = new DBAdapter({ const adapter = new DBAdapter({
dbHost: HOST, dbHost: HOST,
@@ -40,31 +50,6 @@ app.get('/api/current-date', async (req, res) => {
res.json({ currentDate }); res.json({ currentDate });
}); });
app.get('/api/products', async(req, res) => {
try {
const db_products = await adapter.getProducts();
const products = db_products.map(
( {id, name, quantity} ) => ({
ID: id,
pr_name: name,
count: quantity
})
);
res.statusCode = 200;
res.message = "OK";
res.json(products);
} catch (err){
res.statusCode = 500;
res.message = "WHOOPS";
res.json({
timeStamp: new Date().toISOString(),
statusCode: 500,
error : `${err}`
})
}
});
app.post('/api/current-date/advance', async (req, res) => { app.post('/api/current-date/advance', async (req, res) => {
let currentDate = getCurrentDate(); let currentDate = getCurrentDate();
try { try {
@@ -88,7 +73,32 @@ app.post('/api/current-date/advance', async (req, res) => {
} }
}); });
app.get('/api/orders', async(req, res) => { app.get('/api/products', async (req, res) => {
try {
const db_products = await adapter.getProducts();
const products = db_products.map(
( {id, name, quantity} ) => ({
ID: id,
pr_name: name,
count: quantity
})
);
res.statusCode = 200;
res.message = "OK";
res.json(products);
} catch (err){
res.statusCode = 500;
res.message = "WHOOPS";
res.json({
timeStamp: new Date().toISOString(),
statusCode: 500,
error : `${err}`
})
}
});
app.get('/api/orders', async (req, res) => {
try { try {
const db_orders = await adapter.getOrders(); const db_orders = await adapter.getOrders();
@@ -100,6 +110,7 @@ app.get('/api/orders', async(req, res) => {
status: status, status: status,
total: total_amount, total: total_amount,
items: items ? items.map(item => ({ items: items ? items.map(item => ({
id: item.id,
product_id: item.product_id, product_id: item.product_id,
product_name: item.product_name || item.name, product_name: item.product_name || item.name,
quantity: item.quantity, quantity: item.quantity,
@@ -170,6 +181,64 @@ app.post('/api/orders', async (req, res) => {
} }
}); });
app.put('/api/orders/:id', async (req, res) => {
const { customerName, orderDate } = req.body;
const orderId = req.params.id;
if (!customerName || !orderDate) {
return res.status(400).json({
timeStamp: new Date().toISOString(),
statusCode: 400,
error: "Customer name and order date are required"
});
}
try {
await adapter.changeOrderInfo({
id: orderId,
customer_name: customerName,
orderDate
});
return res.json({
id: orderId,
customer_name: customerName,
order_date: orderDate
});
} catch(err) {
console.error('Error updating order:', err);
const errorMessage = err.message ||
err.error?.message ||
"Unknown error occurred";
switch(err.type) {
case DB_INTERNAL_ERROR:
return res.status(500).json({
timeStamp: new Date().toISOString(),
statusCode: 500,
error: errorMessage,
details: err.details || "Internal server error"
});
case DB_USER_ERROR:
return res.status(400).json({
timeStamp: new Date().toISOString(),
statusCode: 400,
error: errorMessage
});
default:
return res.status(500).json({
timeStamp: new Date().toISOString(),
statusCode: 500,
error: errorMessage
});
}
}
});
app.delete('/api/orders/:id', async (req, res) => { app.delete('/api/orders/:id', async (req, res) => {
try { try {
await adapter.deleteOrderById(req.params.id); await adapter.deleteOrderById(req.params.id);
@@ -191,25 +260,52 @@ app.post('/api/orders/:orderId/items', async (req, res) => {
let orderId = req.params.orderId; let orderId = req.params.orderId;
let { productId, quantity } = req.body; let { productId, quantity } = req.body;
if (!productId || !quantity || quantity <= 0) {
return res.status(400).json({
timeStamp: new Date().toISOString(),
statusCode: 400,
error: "Invalid productId or quantity"
});
}
try { try {
await adapter.addOrderItem({ const itemId = await adapter.addOrderItem({
orderId, orderId,
productId, productId,
quantity quantity
}); });
res.status(201).json({ return res.status(201).json({
itemId: itemId.toString(),
orderId, orderId,
productId, productId,
quantity quantity
}); });
} catch (err) { } catch (err) {
// TODO console.error('Error adding order item:', err);
res.status(500).json({
if (err.type === DB_USER_ERROR) {
return res.status(400).json({
timeStamp: new Date().toISOString(),
statusCode: 400,
error: err.error?.message || "Invalid request",
details: err.details
});
} else if (err.type === DB_INTERNAL_ERROR) {
return res.status(500).json({
timeStamp: new Date().toISOString(), timeStamp: new Date().toISOString(),
statusCode: 500, statusCode: 500,
error: "Internal server error",
details: err.error?.message
}); });
} else {
return res.status(500).json({
timeStamp: new Date().toISOString(),
statusCode: 500,
error: "Internal server error"
});
}
} }
}); });
@@ -229,10 +325,10 @@ app.put('/api/orders/:orderId/items/:itemId', async (req, res) => {
}); });
} catch (err) { } catch (err) {
// TODO res.json({
res.status(500).json({
timeStamp: new Date().toISOString(), timeStamp: new Date().toISOString(),
statusCode: 500, statusCode: 500,
error: err.message
}); });
} }
}); });
@@ -240,17 +336,25 @@ app.put('/api/orders/:orderId/items/:itemId', async (req, res) => {
app.delete('/api/orders/:orderId/items/:itemId', async (req, res) => { app.delete('/api/orders/:orderId/items/:itemId', async (req, res) => {
try { try {
await adapter.deleteOrderItem(req.params.itemId); await adapter.deleteOrderItem(req.params.itemId);
res.status(204).end(); return res.status(204).end();
} catch (err){ } catch (err) {
res.statusCode = 500; if (err.type === DB_INTERNAL_ERROR) {
res.message = "WHOOPS"; return res.status(500).json({
res.json({
timeStamp: new Date().toISOString(), timeStamp: new Date().toISOString(),
statusCode: 500, statusCode: 500,
error: `${err}` error: "Server error",
details: err.error.message
});
} else {
return res.status(500).json({
timeStamp: new Date().toISOString(),
statusCode: 500,
error: "Internal server error",
details: err.message
}); });
} }
}) }
});
app.post('/api/order-items/:itemId/move', async (req, res) => { app.post('/api/order-items/:itemId/move', async (req, res) => {
let itemId = req.params.itemId; let itemId = req.params.itemId;