402 lines
12 KiB
JavaScript
402 lines
12 KiB
JavaScript
import mdb from "mariadb"
|
|
|
|
export const DB_INTERNAL_ERROR = 'INTERNAL';
|
|
export const DB_USER_ERROR = 'USER';
|
|
|
|
let currentDate = (new Date()).toISOString().slice(0, 10);
|
|
|
|
export function getCurrentDate() {
|
|
return currentDate;
|
|
}
|
|
|
|
function Random_Increase() {
|
|
return Math.floor(Math.random() * 5) + 1;
|
|
}
|
|
|
|
export async function setCurrentDate(newDate) {
|
|
currentDate = newDate;
|
|
console.log(`📅 Date changed to: ${currentDate}`);
|
|
}
|
|
|
|
export default class DBAdapter {
|
|
#dbhost = 'localhost';
|
|
#dbPort = 3306;
|
|
#dbName = 'N';
|
|
#dbUserLogin = 'u';
|
|
#dbUserPassword = 'p';
|
|
#dbClient = null;
|
|
|
|
constructor({
|
|
dbHost,
|
|
dbPort,
|
|
dbName,
|
|
dbUserLogin,
|
|
dbUserPassword
|
|
}) {
|
|
this.#dbhost = dbHost;
|
|
this.#dbPort = dbPort;
|
|
this.#dbName = dbName;
|
|
this.#dbUserLogin = dbUserLogin;
|
|
this.#dbUserPassword = dbUserPassword;
|
|
this.#dbClient = new mdb.createPool({
|
|
host: this.#dbhost,
|
|
port: this.#dbPort,
|
|
database: this.#dbName,
|
|
user: this.#dbUserLogin,
|
|
password: this.#dbUserPassword,
|
|
dateStrings: true
|
|
});
|
|
}
|
|
|
|
async connect() {
|
|
try {
|
|
// Проверяем подключение, выполняя простой запрос
|
|
const conn = await this.#dbClient.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();
|
|
console.log("DISCONNECT");
|
|
}
|
|
|
|
async stock(){
|
|
try {
|
|
const products = await this.#dbClient.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 = ?', [
|
|
increment,
|
|
product.id
|
|
]);
|
|
}
|
|
} catch (err){
|
|
return Promise.reject({
|
|
type: err
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
async getProducts() {
|
|
try {
|
|
const products = await this.#dbClient.query('SELECT * FROM products ORDER BY name');
|
|
console.log("All products:", products);
|
|
return products;
|
|
} catch(err){
|
|
console.log(`WHOOPS`);
|
|
return Promise.reject();
|
|
}
|
|
}
|
|
|
|
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 items = await this.#dbClient.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) {
|
|
items.forEach(item => {
|
|
const orderId = item.order_id;
|
|
if (!groupedItems[orderId]) {
|
|
groupedItems[orderId] = [];
|
|
}
|
|
groupedItems[orderId].push(item);
|
|
});
|
|
}
|
|
|
|
const ordersWithItems = raw_orders.map(order => {
|
|
return {
|
|
...order,
|
|
items: groupedItems[order.id] || []
|
|
};
|
|
});
|
|
|
|
return ordersWithItems;
|
|
} catch(err) {
|
|
console.log(`WHOOPS: ${err.message}`);
|
|
return Promise.reject(err);
|
|
}
|
|
}
|
|
|
|
async addOrder({ id, customer_name, orderDate} ){
|
|
if (!customer_name || !orderDate){
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Empty in customer name or order date")
|
|
});
|
|
}
|
|
const currentDate = await getCurrentDate();
|
|
if (orderDate < currentDate){
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Invalid order date")
|
|
});
|
|
}
|
|
try {
|
|
await this.#dbClient.query('INSERT INTO orders (id, customer_name, order_date) VALUES (?, ?, ?)',
|
|
[id, customer_name, orderDate]
|
|
);
|
|
} catch(err){
|
|
return Promise.reject({
|
|
type: DB_INTERNAL_ERROR,
|
|
error: new Error("Server error")
|
|
});
|
|
}
|
|
}
|
|
|
|
async getOrdersByDate(date){
|
|
try {
|
|
const order_ids = await this.#dbClient.query('SELECT id FROM orders WHERE order_date = ?', [date]);
|
|
return order_ids;
|
|
} catch(err){
|
|
return Promise.reject();
|
|
}
|
|
}
|
|
|
|
async clearOrders(orderIds) {
|
|
if (!orderIds || orderIds.length === 0) {
|
|
console.log("No orders to delete");
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const placeholders = orderIds.map(() => '?').join(',');
|
|
|
|
const result = await this.#dbClient.query(
|
|
`DELETE FROM orders WHERE id IN (${placeholders})`,
|
|
orderIds
|
|
);
|
|
|
|
console.log(`✅ Deleted ${result.affectedRows} orders with IDs:`, orderIds);
|
|
|
|
} catch(err) {
|
|
console.error(`❌ Error deleting orders:`, err.message);
|
|
return Promise.reject();
|
|
}
|
|
}
|
|
|
|
async changeOrderInfo({ id, customer_name, orderDate }){
|
|
if (!id) {
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Order ID is required")
|
|
});
|
|
}
|
|
|
|
const currentDate = await getCurrentDate();
|
|
if (orderDate < currentDate) {
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Order date cannot be less than current date")
|
|
});
|
|
}
|
|
|
|
try {
|
|
const order = await this.#dbClient.query('SELECT * FROM orders WHERE id = ?', [id]);
|
|
|
|
if (!order){
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Order not found")
|
|
});
|
|
}
|
|
|
|
const updatedName = customer_name;
|
|
const updatedDate = orderDate;
|
|
|
|
await this.#dbClient.query('UPDATE orders SET customer_name = ?, order_date = ? WHERE id = ?',
|
|
[updatedName, updatedDate, id]
|
|
);
|
|
|
|
} catch(err){
|
|
return Promise.reject({
|
|
type: DB_INTERNAL_ERROR,
|
|
error: new Error("Server error")
|
|
});
|
|
}
|
|
}
|
|
|
|
async deleteOrderById(order_id){
|
|
try {
|
|
const orderItems = await this.#dbClient.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 = ?',
|
|
[item.quantity, item.product_id]
|
|
);
|
|
}
|
|
await this.#dbClient.query(
|
|
`DELETE FROM orders WHERE id = ?`,
|
|
[order_id]
|
|
);
|
|
} catch(err){
|
|
return Promise.reject({
|
|
type: DB_INTERNAL_ERROR,
|
|
error: new Error("Server error")
|
|
});
|
|
}
|
|
}
|
|
|
|
async addOrderItem({ orderId, productId, quantity }){
|
|
await this.#dbClient.query('BEGIN');
|
|
try {
|
|
const product = await this.#dbClient.query(
|
|
'SELECT quantity FROM products WHERE id = ?', [productId]
|
|
);
|
|
|
|
const productRow = product?.[0];
|
|
if (!productRow || productRow.quantity < quantity){
|
|
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(
|
|
'UPDATE products SET quantity = quantity - ? WHERE id = ?',
|
|
[quantity, productId]
|
|
);
|
|
|
|
await this.#dbClient.query('COMMIT');
|
|
} catch (err){
|
|
await this.#dbClient.query('ROLLBACK');
|
|
return Promise.reject();
|
|
}
|
|
}
|
|
|
|
async updateOrderItem({ itemId, quantity }){
|
|
await this.#dbClient.query('BEGIN');
|
|
try {
|
|
const item = await this.#dbClient.query(
|
|
'SELECT product_id, quantity FROM order_items WHERE id = ?', [itemId]
|
|
);
|
|
|
|
const itemRow = item?.[0];
|
|
if (!itemRow){
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Order item not found")
|
|
});
|
|
}
|
|
|
|
const diff = quantity - itemRow.quantity;
|
|
|
|
if (diff > 0){
|
|
const product = await this.#dbClient.query(
|
|
'SELECT quantity FROM products WHERE id = ?', [itemRow.product_id]
|
|
);
|
|
|
|
const productRow = product?.[0];
|
|
if (!productRow || productRow.quantity < diff){
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Insufficient product quantity")
|
|
});
|
|
}
|
|
|
|
await this.#dbClient.query(
|
|
'UPDATE products SET quantity = quantity - ? WHERE id = ?',
|
|
[diff, itemRow.product_id]
|
|
);
|
|
}
|
|
|
|
if (diff < 0) {
|
|
await this.#dbClient.query(
|
|
'UPDATE products SET quantity = quantity + ? WHERE id = ?',
|
|
[-diff, itemRow.product_id]
|
|
);
|
|
}
|
|
|
|
await this.#dbClient.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();
|
|
}
|
|
}
|
|
|
|
async deleteOrderItem(itemId){
|
|
await this.#dbClient.query('BEGIN');
|
|
try {
|
|
const item = await this.#dbClient.query(
|
|
'SELECT product_id, quantity FROM order_items WHERE id = ?', [itemId]
|
|
);
|
|
|
|
const itemRow = item?.[0];
|
|
if (!itemRow){
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Order item not found")
|
|
});
|
|
}
|
|
|
|
await this.#dbClient.query(
|
|
'UPDATE products SET quantity = quantity + ? WHERE id = ?',
|
|
[itemRow.quantity, itemRow.product_id]
|
|
);
|
|
|
|
await this.#dbClient.query(
|
|
'DELETE FROM order_items WHERE id = ?',
|
|
[itemId]
|
|
);
|
|
|
|
await this.#dbClient.query('COMMIT');
|
|
} catch (err){
|
|
await this.#dbClient.query('ROLLBACK');
|
|
return Promise.reject();
|
|
}
|
|
}
|
|
|
|
async moveOrderItem( {itemId, targetOrderId }){
|
|
await this.#dbClient.query('BEGIN');
|
|
try {
|
|
const item = await this.#dbClient.query(
|
|
'SELECT id, order_id FROM order_items WHERE id = ?', [itemId]
|
|
);
|
|
|
|
const itemRow = item?.[0];
|
|
if (!itemRow){
|
|
return Promise.reject({
|
|
type: DB_USER_ERROR,
|
|
error: new Error("Order item not found")
|
|
});
|
|
}
|
|
|
|
await this.#dbClient.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();
|
|
}
|
|
}
|
|
}
|