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

API #1

Merged
ParkSuMin merged 3 commits from API into master 2026-01-03 16:18:53 +01:00
Conversation 0 Commits 3 Files Changed 2 +273 -90
1 changed files with 273 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 13fe841e54 - Show all commits

359
server/db/database.js
View File

@@ -24,7 +24,7 @@ export default class DBAdapter {
#dbName = 'N';
#dbUserLogin = 'u';
#dbUserPassword = 'p';
#dbClient = null;
#pool = null;
constructor({
dbHost,
@@ -38,40 +38,43 @@ export default class DBAdapter {
this.#dbName = dbName;
this.#dbUserLogin = dbUserLogin;
this.#dbUserPassword = dbUserPassword;
this.#dbClient = new mdb.createPool({
this.#pool = mdb.createPool({
host: this.#dbhost,
port: this.#dbPort,
database: this.#dbName,
user: this.#dbUserLogin,
password: this.#dbUserPassword,
dateStrings: true
dateStrings: true,
acquireTimeout: 10000,
});
}
async #getConnection() {
return await this.#pool.getConnection();
}
async connect() {
try {
// Проверяем подключение, выполняя простой запрос
const conn = await this.#dbClient.getConnection();
const conn = await this.#pool.getConnection();
console.log("✅ Database connection test successful");
conn.release();
} catch (err) {
console.error("❌ Database connection failed:", err.message);
// Пробрасываем ошибку дальше
return Promise.reject();
}
}
async disconnect() {
await this.#dbClient.end();
await this.#pool.end();
console.log("DISCONNECT");
}
async stock(){
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) {
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,
product.id
]);
@@ -86,8 +89,7 @@ export default class DBAdapter {
async getProducts() {
try {
const products = await this.#dbClient.query('SELECT * FROM products ORDER BY name');
console.log("All products:", products);
const products = await this.#pool.query('SELECT * FROM products ORDER BY name');
return products;
} catch(err){
console.log(`WHOOPS`);
@@ -97,14 +99,12 @@ export default class DBAdapter {
async getOrders() {
try {
const raw_orders = await this.#dbClient.query('SELECT * FROM orders ORDER BY order_date ASC');
console.log("All orders:", raw_orders);
const raw_orders = await this.#pool.query('SELECT * FROM orders ORDER BY order_date ASC');
const items = await this.#dbClient.query(
const items = await this.#pool.query(
`SELECT order_items.*, products.name AS product_name FROM order_items
JOIN products ON order_items.product_id = products.id`
);
console.log("All order items:", items);
const groupedItems = {};
if (items && items.length > 0) {
@@ -132,7 +132,7 @@ export default class DBAdapter {
}
async addOrder({ id, customer_name, orderDate} ){
if (!customer_name || !orderDate){
if (!id || !customer_name || !orderDate){
return Promise.reject({
type: DB_USER_ERROR,
error: new Error("Empty in customer name or order date")
@@ -146,7 +146,7 @@ export default class DBAdapter {
});
}
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]
);
} catch(err){
@@ -159,7 +159,7 @@ export default class DBAdapter {
async getOrdersByDate(date){
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;
} catch(err){
return Promise.reject();
@@ -175,7 +175,7 @@ export default class DBAdapter {
try {
const placeholders = orderIds.map(() => '?').join(',');
const result = await this.#dbClient.query(
const result = await this.#pool.query(
`DELETE FROM orders WHERE id IN (${placeholders})`,
orderIds
);
@@ -188,11 +188,12 @@ export default class DBAdapter {
}
}
async changeOrderInfo({ id, customer_name, orderDate }){
if (!id) {
async changeOrderInfo({ id, customer_name, orderDate }) {
if (!id || !customer_name || !orderDate) {
return Promise.reject({
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) {
return Promise.reject({
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 {
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({
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 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]
);
} catch(err){
} catch(err) {
console.error('Database error in changeOrderInfo:', err);
return Promise.reject({
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 {
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 = ?`,
[order_id]
);
for (const item of orderItems){
await this.#dbClient.query('UPDATE products SET quantity = quantity + ? WHERE id = ?',
for (const item of orderItems) {
await connection.query(
'UPDATE products SET quantity = quantity + ? WHERE 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 = ?`,
[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({
type: DB_INTERNAL_ERROR,
error: new Error("Server error")
error: new Error("Failed to delete order"),
details: err.message
});
}
}
async addOrderItem({ orderId, productId, quantity }){
await this.#dbClient.query('BEGIN');
async addOrderItem({ orderId, productId, quantity }) {
let connection;
try {
const product = await this.#dbClient.query(
'SELECT quantity FROM products WHERE id = ?', [productId]
connection = await this.#pool.getConnection();
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];
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({
type: DB_USER_ERROR,
error: new Error("Insufficient product quantity")
});
}
const result = await this.#dbClient.query(
'INSERT INTO order_items (order_id, product_id, quantity) VALUES (?, ?, ?)',
[orderId, productId, quantity]
);
await this.#dbClient.query(
await connection.query(
'UPDATE products SET quantity = quantity - ? WHERE id = ?',
[quantity, productId]
);
await this.#dbClient.query('COMMIT');
} catch (err){
await this.#dbClient.query('ROLLBACK');
return Promise.reject();
const result = await connection.query(
'INSERT INTO order_items (order_id, product_id, quantity) VALUES (?, ?, ?)',
[orderId, productId, quantity]
);
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 }){
await this.#dbClient.query('BEGIN');
async updateOrderItem({ itemId, quantity }) {
let connection;
try {
const item = await this.#dbClient.query(
'SELECT product_id, quantity FROM order_items WHERE id = ?', [itemId]
connection = await this.#pool.getConnection();
await connection.beginTransaction();
const item = await connection.query(
'SELECT product_id, quantity FROM order_items WHERE id = ? FOR UPDATE',
[itemId]
);
const itemRow = item?.[0];
if (!itemRow){
if (!itemRow) {
await connection.rollback();
connection.release();
return Promise.reject({
type: DB_USER_ERROR,
error: new Error("Order item not found")
@@ -302,100 +408,177 @@ export default class DBAdapter {
const diff = quantity - itemRow.quantity;
if (diff > 0){
const product = await this.#dbClient.query(
'SELECT quantity FROM products WHERE id = ?', [itemRow.product_id]
if (diff > 0) {
const product = await connection.query(
'SELECT quantity FROM products WHERE id = ? FOR UPDATE',
[itemRow.product_id]
);
const productRow = product?.[0];
if (!productRow || productRow.quantity < diff){
if (!productRow || productRow.quantity < diff) {
await connection.rollback();
connection.release();
return Promise.reject({
type: DB_USER_ERROR,
error: new Error("Insufficient product quantity")
});
}
await this.#dbClient.query(
await connection.query(
'UPDATE products SET quantity = quantity - ? WHERE id = ?',
[diff, itemRow.product_id]
);
}
if (diff < 0) {
await this.#dbClient.query(
await connection.query(
'UPDATE products SET quantity = quantity + ? WHERE id = ?',
[-diff, itemRow.product_id]
);
}
await this.#dbClient.query(
await connection.query(
'UPDATE order_items SET quantity = ? WHERE id = ?',
[quantity, itemId]
);
await this.#dbClient.query('COMMIT');
} catch (err){
await this.#dbClient.query('ROLLBACK');
return Promise.reject();
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({
type: DB_INTERNAL_ERROR,
error: new Error("Failed to update order item"),
details: err.message
});
}
}
async deleteOrderItem(itemId){
await this.#dbClient.query('BEGIN');
async deleteOrderItem(itemId) {
let connection;
try {
const item = await this.#dbClient.query(
'SELECT product_id, quantity FROM order_items WHERE id = ?', [itemId]
connection = await this.#pool.getConnection();
await connection.beginTransaction();
const item = await connection.query(
'SELECT product_id, quantity FROM order_items WHERE id = ? FOR UPDATE',
[itemId]
);
const itemRow = item?.[0];
if (!itemRow){
if (!itemRow) {
await connection.rollback();
connection.release();
return Promise.reject({
type: DB_USER_ERROR,
error: new Error("Order item not found")
});
}
await this.#dbClient.query(
await connection.query(
'UPDATE products SET quantity = quantity + ? WHERE id = ?',
[itemRow.quantity, itemRow.product_id]
);
await this.#dbClient.query(
await connection.query(
'DELETE FROM order_items WHERE id = ?',
[itemId]
);
await this.#dbClient.query('COMMIT');
} catch (err){
await this.#dbClient.query('ROLLBACK');
return Promise.reject();
await connection.commit();
connection.release();
} 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 }){
await this.#dbClient.query('BEGIN');
async moveOrderItem({ itemId, targetOrderId }) {
let connection;
try {
const item = await this.#dbClient.query(
'SELECT id, order_id FROM order_items WHERE id = ?', [itemId]
connection = await this.#pool.getConnection();
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];
if (!itemRow){
if (!itemRow) {
await connection.rollback();
connection.release();
return Promise.reject({
type: DB_USER_ERROR,
error: new Error("Order item not found")
});
}
await this.#dbClient.query(
await connection.query(
'UPDATE order_items SET order_id = ? WHERE id = ?',
[targetOrderId, itemId]
);
await this.#dbClient.query('COMMIT');
} catch (err){
await this.#dbClient.query('ROLLBACK');
return Promise.reject();
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({
type: DB_INTERNAL_ERROR,
error: new Error("Failed to move order item"),
details: err.message
});
}
}
}