backend/models/User.js - master - varsl/HTML-CSS

backend/models/User.js
273 строки9 KB
varsl
Создание модели данных для приложения
21 дек 2025, 23:52
21 дек 2025, 23:52c2bb487
const bcrypt = require('bcryptjs');
const sqlite3 = require('sqlite3').verbose();
const path = require('path');
const { dbPath } = require('../config');

// Создаем подключение к базе данных
const db = new sqlite3.Database(path.resolve(dbPath), (err) => {
    if (err) {
        console.error('Error opening database in User model:', err);
    }
});

class User {
    static async create(userData) {
        const { email, password, name, phone, birthDate, newsletter = false } = userData;

        try {
            const hashedPassword = await bcrypt.hash(password, 10);

            return new Promise((resolve, reject) => {
                const sql = `
                    INSERT INTO users (
                        email, password, name, phone, birth_date,
                        newsletter, created_at, updated_at
                    ) VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
                `;

                db.run(sql, [
                    email,
                    hashedPassword,
                    name,
                    phone || null,
                    birthDate || null,
                    newsletter ? 1 : 0
                ], function(err) {
                    if (err) {
                        reject(err);
                    } else {
                        resolve(this.lastID);
                    }
                });
            });
        } catch (error) {
            throw error;
        }
    }

    static async findByEmail(email) {
        return new Promise((resolve, reject) => {
            const sql = `SELECT * FROM users WHERE email = ?`;
            db.get(sql, [email], (err, row) => {
                if (err) {
                    reject(err);
                } else {
                    if (row) {
                        row.newsletter = row.newsletter === 1;
                    }
                    resolve(row);
                }
            });
        });
    }

    static async findById(id) {
        return new Promise((resolve, reject) => {
            const sql = `
                SELECT id, email, name, phone, birth_date, newsletter, role,
                       created_at, updated_at
                FROM users WHERE id = ?
            `;
            db.get(sql, [id], (err, row) => {
                if (err) {
                    reject(err);
                } else {
                    if (row) {
                        row.newsletter = row.newsletter === 1;
                    }
                    resolve(row);
                }
            });
        });
    }

    static async update(id, updates) {
        const fields = [];
        const values = [];
        const validFields = ['name', 'password', 'phone', 'birth_date', 'newsletter', 'avatar'];

        for (const [key, value] of Object.entries(updates)) {
            if (validFields.includes(key) && value !== undefined) {
                fields.push(`${key} = ?`);
                if (key === 'newsletter') {
                    values.push(value ? 1 : 0);
                } else {
                    values.push(value);
                }
            }
        }

        if (fields.length === 0) {
            return Promise.resolve(false);
        }

        fields.push('updated_at = CURRENT_TIMESTAMP');
        values.push(id);

        return new Promise((resolve, reject) => {
            const sql = `UPDATE users SET ${fields.join(', ')} WHERE id = ?`;
            db.run(sql, values, function(err) {
                if (err) {
                    reject(err);
                } else {
                    resolve(this.changes > 0);
                }
            });
        });
    }

    static async verifyPassword(plainPassword, hashedPassword) {
        return bcrypt.compare(plainPassword, hashedPassword);
    }

    static async delete(id) {
        return new Promise((resolve, reject) => {
            const sql = `DELETE FROM users WHERE id = ?`;
            db.run(sql, [id], function(err) {
                if (err) {
                    reject(err);
                } else {
                    resolve(this.changes > 0);
                }
            });
        });
    }

    static async findAll(limit = 100, offset = 0) {
        return new Promise((resolve, reject) => {
            const sql = `
                SELECT id, email, name, phone, newsletter, role, created_at
                FROM users LIMIT ? OFFSET ?
            `;
            db.all(sql, [limit, offset], (err, rows) => {
                if (err) {
                    reject(err);
                } else {
                    rows.forEach(row => {
                        row.newsletter = row.newsletter === 1;
                    });
                    resolve(rows);
                }
            });
        });
    }

    static async searchByName(query, limit = 50) {
        return new Promise((resolve, reject) => {
            const sql = `
                SELECT id, email, name, phone, newsletter, role, created_at
                FROM users WHERE name LIKE ? LIMIT ?
            `;
            db.all(sql, [`%${query}%`, limit], (err, rows) => {
                if (err) {
                    reject(err);
                } else {
                    rows.forEach(row => {
                        row.newsletter = row.newsletter === 1;
                    });
                    resolve(rows);
                }
            });
        });
    }

    static async emailExists(email) {
        return new Promise((resolve, reject) => {
            const sql = `SELECT COUNT(*) as count FROM users WHERE email = ?`;
            db.get(sql, [email], (err, row) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(row.count > 0);
                }
            });
        });
    }

    static async getStats(userId) {
        return new Promise((resolve, reject) => {
            const stats = {};

            // Получаем количество билетов
            db.get('SELECT COUNT(*) as count FROM tickets WHERE user_id = ? AND status = ?',
                [userId, 'active'], (err, row) => {
                    if (err) {
                        stats.tickets = 0;
                    } else {
                        stats.tickets = row.count;
                    }

                    // Получаем количество посещений
                    db.get('SELECT COUNT(*) as count FROM visits WHERE user_id = ?',
                        [userId], (err, row) => {
                            if (err) {
                                stats.visits = 0;
                            } else {
                                stats.visits = row.count;
                            }

                            // Получаем количество избранных
                            db.get('SELECT COUNT(*) as count FROM favorites WHERE user_id = ?',
                                [userId], (err, row) => {
                                    if (err) {
                                        stats.favorites = 0;
                                    } else {
                                        stats.favorites = row.count;
                                    }

                                    // Получаем количество отзывов
                                    db.get('SELECT COUNT(*) as count FROM reviews WHERE user_id = ?',
                                        [userId], (err, row) => {
                                            if (err) {
                                                stats.reviews = 0;
                                            } else {
                                                stats.reviews = row.count;
                                            }

                                            resolve(stats);
                                        });
                                });
                        });
                });
        });
    }

    static async getRecentActivity(userId, limit = 5) {
        return new Promise((resolve, reject) => {
            db.all(
                `SELECT 
                    'ticket' as type,
                    'Куплен билет' as title,
                    created_at as timestamp
                 FROM tickets 
                 WHERE user_id = ?
                 UNION ALL
                 SELECT 
                    'visit' as type,
                    'Посещение зоопарка' as title,
                    created_at as timestamp
                 FROM visits 
                 WHERE user_id = ?
                 UNION ALL
                 SELECT 
                    'review' as type,
                    'Оставлен отзыв' as title,
                    created_at as timestamp
                 FROM reviews 
                 WHERE user_id = ?
                 ORDER BY timestamp DESC
                 LIMIT ?`,
                [userId, userId, userId, limit],
                (err, rows) => {
                    if (err) {
                        reject(err);
                    } else {
                        resolve(rows);
                    }
                }
            );
        });
    }
}

module.exports = User;