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

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

const db = new sqlite3.Database(path.resolve(dbPath));

class Animal {
    // Получение всех животных
    static async findAll(filters = {}, limit = 100, offset = 0) {
        const { type, habitat, diet, conservationStatus } = filters;
        let whereClauses = [];
        const params = [];

        if (type) {
            whereClauses.push('type = ?');
            params.push(type);
        }

        if (habitat) {
            whereClauses.push('habitat LIKE ?');
            params.push(`%${habitat}%`);
        }

        if (diet) {
            whereClauses.push('diet LIKE ?');
            params.push(`%${diet}%`);
        }

        if (conservationStatus) {
            whereClauses.push('conservation_status = ?');
            params.push(conservationStatus);
        }

        const whereClause = whereClauses.length > 0
            ? `WHERE ${whereClauses.join(' AND ')}`
            : '';

        return new Promise((resolve, reject) => {
            const sql = `
        SELECT * FROM animals 
        ${whereClause}
        ORDER BY popularity DESC, name ASC
        LIMIT ? OFFSET ?
      `;

            db.all(sql, [...params, limit, offset], (err, rows) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(rows);
                }
            });
        });
    }

    // Поиск животного по ID
    static async findById(animalId) {
        return new Promise((resolve, reject) => {
            const sql = `SELECT * FROM animals WHERE animal_id = ?`;
            db.get(sql, [animalId], (err, row) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(row);
                }
            });
        });
    }

    // Поиск животных
    static async search(query, limit = 50) {
        return new Promise((resolve, reject) => {
            const sql = `
        SELECT * FROM animals 
        WHERE name LIKE ? OR scientific_name LIKE ? OR description LIKE ?
        ORDER BY popularity DESC
        LIMIT ?
      `;

            db.all(sql, [`%${query}%`, `%${query}%`, `%${query}%`, limit], (err, rows) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(rows);
                }
            });
        });
    }

    // Увеличение популярности
    static async incrementPopularity(animalId) {
        return new Promise((resolve, reject) => {
            const sql = `UPDATE animals SET popularity = popularity + 1 WHERE animal_id = ?`;
            db.run(sql, [animalId], function(err) {
                if (err) {
                    reject(err);
                } else {
                    resolve(this.changes > 0);
                }
            });
        });
    }

    // Получение животных по типу
    static async findByType(type, limit = 50) {
        return new Promise((resolve, reject) => {
            const sql = `
        SELECT * FROM animals 
        WHERE type = ? 
        ORDER BY popularity DESC 
        LIMIT ?
      `;

            db.all(sql, [type, limit], (err, rows) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(rows);
                }
            });
        });
    }

    // Получение статистики
    static async getStats() {
        return new Promise((resolve, reject) => {
            const sql = `
        SELECT 
          COUNT(*) as total_animals,
          COUNT(DISTINCT type) as types_count,
          COUNT(DISTINCT habitat) as habitats_count,
          AVG(popularity) as avg_popularity,
          MAX(popularity) as max_popularity
        FROM animals
      `;

            db.get(sql, (err, row) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(row);
                }
            });
        });
    }

    // Получение животных по статусу сохранения
    static async findByConservationStatus(status, limit = 50) {
        return new Promise((resolve, reject) => {
            const sql = `
        SELECT * FROM animals 
        WHERE conservation_status = ? 
        ORDER BY popularity DESC 
        LIMIT ?
      `;

            db.all(sql, [status, limit], (err, rows) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(rows);
                }
            });
        });
    }

    // Получение случайных животных
    static async getRandom(limit = 5) {
        return new Promise((resolve, reject) => {
            const sql = `
        SELECT * FROM animals 
        ORDER BY RANDOM() 
        LIMIT ?
      `;

            db.all(sql, [limit], (err, rows) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(rows);
                }
            });
        });
    }

    // Получение самых популярных животных
    static async getMostPopular(limit = 10) {
        return new Promise((resolve, reject) => {
            const sql = `
        SELECT * FROM animals 
        ORDER BY popularity DESC 
        LIMIT ?
      `;

            db.all(sql, [limit], (err, rows) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(rows);
                }
            });
        });
    }

    // Создание животного (только для админов)
    static async create(animalData) {
        const {
            animal_id,
            name,
            scientific_name,
            type,
            habitat,
            diet,
            description,
            size,
            lifespan,
            conservation_status,
            image_url,
            sound_url,
            video_url,
            fun_fact,
            feeding_time,
            show_schedule
        } = animalData;

        return new Promise((resolve, reject) => {
            const sql = `
        INSERT INTO animals (
          animal_id, name, scientific_name, type, habitat, diet,
          description, size, lifespan, conservation_status,
          image_url, sound_url, video_url, fun_fact,
          feeding_time, show_schedule
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      `;

            db.run(sql, [
                animal_id,
                name,
                scientific_name || null,
                type,
                habitat || null,
                diet || null,
                description || null,
                size || null,
                lifespan || null,
                conservation_status || null,
                image_url || null,
                sound_url || null,
                video_url || null,
                fun_fact || null,
                feeding_time || null,
                show_schedule || null
            ], function(err) {
                if (err) {
                    reject(err);
                } else {
                    resolve(this.lastID);
                }
            });
        });
    }

    // Обновление животного (только для админов)
    static async update(animalId, updates) {
        const fields = [];
        const values = [];
        const validFields = [
            'name', 'scientific_name', 'type', 'habitat', 'diet',
            'description', 'size', 'lifespan', 'conservation_status',
            'image_url', 'sound_url', 'video_url', 'fun_fact',
            'feeding_time', 'show_schedule', 'popularity'
        ];

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

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

        values.push(animalId);

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

    // Удаление животного (только для админов)
    static async delete(animalId) {
        return new Promise((resolve, reject) => {
            const sql = `DELETE FROM animals WHERE animal_id = ?`;
            db.run(sql, [animalId], function(err) {
                if (err) {
                    reject(err);
                } else {
                    resolve(this.changes > 0);
                }
            });
        });
    }
}

module.exports = Animal;