Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Project structure: LitMusic/ ├── static/ │ ├── icons/ │ │ ├── close.webp │ │ ├──…

  1. User

    Project structure:

    LitMusic/ ├── static/ │ ├── icons/ │ │ ├── close.webp │ │ ├── copy.webp │ │ ├── description.webp │ │ └── play.webp │ ├── tracks/ │ │ └── f129b679-90cf-48b1-8e42-71fb3ea869f6.mp3 │ ├── app.js │ └── styles.css ├── templates/ │ └── index.html ├── app.py ├── database.db ├── database.py └── requirements.txt

    Project files:

    app.py

    # app.py
    
    from flask import Flask, request, jsonify, send_from_directory, render_template
    from flask_cors import CORS
    from database import Database
    import os
    import requests
    from urllib.parse import urlparse
    import uuid
    
    app = Flask(__name__, static_folder='static', template_folder='templates')
    CORS(app)
    
    db = Database()
    
    # Убедимся, что папка для хранения треков существует
    TRACKS_DIR = os.path.join(app.static_folder, 'tracks')
    os.makedirs(TRACKS_DIR, exist_ok=True)
    
    # Главная страница
    @app.route('/')
    def index():
        return render_template('index.html')
    
    # Обслуживание статических файлов
    @app.route('/static/<path:path>')
    def send_static_files(path):
        return send_from_directory('static', path)
    
    # 1. Получение всех треков (с пагинацией)
    @app.route('/tracks', methods=['GET'])
    def get_tracks():
        page = request.args.get('page', 1, type=int)
        per_page = 10
        tracks, total = db.get_tracks(page, per_page)
        return jsonify({'tracks': tracks, 'total': total})
    
    # 2. Поиск треков
    @app.route('/tracks/search', methods=['GET'])
    def search_tracks():
        description = request.args.get('description', '', type=str)
        tags = request.args.getlist('tags')
        tracks = db.search_tracks(description, tags)
        return jsonify({'tracks': tracks})
    
    # 3. Добавление нового трека
    @app.route('/tracks', methods=['POST'])
    def add_track():
        data = request.get_json()
        name = data.get('name')
        description = data.get('description')
        original_url = data.get('url')  # Исходная ссылка
        tags = data.get('tags', [])
    
        if not name or not original_url:
            return jsonify({'error': 'Название и ссылка на трек обязательны.'}), 400
    
        # Вставляем трек с временным URL (пустым)
        track_id = db.add_track(name, description, '', original_url, tags)
    
        try:
            # Скачиваем файл по исходной ссылке
            response = requests.get(original_url, stream=True)
            response.raise_for_status()
    
            # Определяем расширение файла из URL или заголовков
            parsed_url = urlparse(original_url)
            _, ext = os.path.splitext(parsed_url.path)
            if not ext:
                # Пытаемся получить из заголовков
                content_type = response.headers.get('Content-Type')
                if content_type:
                    if 'audio/mpeg' in content_type:
                        ext = '.mp3'
                    elif 'audio/wav' in content_type:
                        ext = '.wav'
                    # Добавьте больше типов при необходимости
                    else:
                        ext = ''
                else:
                    ext = ''
    
            # Генерируем уникальное имя файла
            if not ext:
                ext = '.mp3'  # Стандартное расширение
    
            filename = f"{uuid.uuid4()}{ext}"
            file_path = os.path.join(TRACKS_DIR, filename)
    
            # Сохраняем локально
            with open(file_path, 'wb') as f:
                for chunk in response.iter_content(chunk_size=8192):
                    f.write(chunk)
    
            # Обновляем поле 'url' в базе данными о локальном файле
            local_url = f"/static/tracks/{filename}"
            db.update_track_url(track_id, local_url)
    
        except Exception as e:
            # В случае ошибки скачивания удаляем трек из БД
            db.delete_track(track_id)
            return jsonify({'error': f'Не удалось загрузить файл: {str(e)}'}), 400
    
        return jsonify({'message': 'Трек успешно добавлен.', 'track_id': track_id}), 201
    
    # 4. Удаление трека
    @app.route('/tracks/<int:track_id>', methods=['DELETE'])
    def delete_track(track_id):
        # Получаем трек по ID
        track = db.get_track_by_id(track_id)
        if not track:
            return jsonify({'error': 'Трек не найден.'}), 404
    
        # Удаляем трек из базы данных
        db.delete_track(track_id)
    
        # Удаляем локальный файл
        file_path = os.path.join(app.root_path, track['url'].lstrip('/'))
        if os.path.exists(file_path):
            try:
                os.remove(file_path)
            except Exception as e:
                # Можно логировать ошибку или обработать иначе
                pass
    
        return jsonify({'message': 'Трек успешно удален.'}), 200
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=6390)
    

    database.py

    # database.py
    
    import sqlite3
    
    class Database:
        def __init__(self, db_path='database.db'):
            self.db_path = db_path
            self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
            self.init_db()
    
        def init_db(self):
            cursor = self.conn.cursor()
            # Создание таблицы треков с полем original_url
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS tracks (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    name TEXT NOT NULL,
                    description TEXT,
                    url TEXT NOT NULL,
                    original_url TEXT
                )
            ''')
            # Создание таблицы тегов
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS tags (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    name TEXT NOT NULL UNIQUE
                )
            ''')
            # Создание связующей таблицы track_tags
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS track_tags (
                    track_id INTEGER,
                    tag_id INTEGER,
                    FOREIGN KEY(track_id) REFERENCES tracks(id),
                    FOREIGN KEY(tag_id) REFERENCES tags(id),
                    PRIMARY KEY(track_id, tag_id)
                )
            ''')
            self.conn.commit()
    
        # Обновленный метод добавления трека
        def add_track(self, name, description, url, original_url, tags):
            cursor = self.conn.cursor()
            cursor.execute('INSERT INTO tracks (name, description, url, original_url) VALUES (?, ?, ?, ?)', 
                           (name, description, url, original_url))
            track_id = cursor.lastrowid
            for tag_name in tags:
                # Проверяем, существует ли тег
                cursor.execute('SELECT id FROM tags WHERE name = ?', (tag_name,))
                tag_row = cursor.fetchone()
                if tag_row:
                    tag_id = tag_row[0]
                else:
                    cursor.execute('INSERT INTO tags (name) VALUES (?)', (tag_name,))
                    tag_id = cursor.lastrowid
                # Добавляем связь трека и тега
                cursor.execute('INSERT OR IGNORE INTO track_tags (track_id, tag_id) VALUES (?, ?)', (track_id, tag_id))
            self.conn.commit()
            return track_id
    
        # Метод для обновления URL трека
        def update_track_url(self, track_id, url):
            cursor = self.conn.cursor()
            cursor.execute('UPDATE tracks SET url = ? WHERE id = ?', (url, track_id))
            self.conn.commit()
    
        # Метод для получения трека по ID
        def get_track_by_id(self, track_id):
            cursor = self.conn.cursor()
            cursor.execute('SELECT * FROM tracks WHERE id = ?', (track_id,))
            row = cursor.fetchone()
            if row:
                track = {
                    'id': row[0],
                    'name': row[1],
                    'description': row[2],
                    'url': row[3],
                    'original_url': row[4],
                    'tags': self.get_tags_for_track(row[0])
                }
                return track
            return None
    
        # Метод для получения всех треков с пагинацией
        def get_tracks(self, page=1, per_page=10):
            cursor = self.conn.cursor()
            offset = (page - 1) * per_page
            cursor.execute('SELECT * FROM tracks LIMIT ? OFFSET ?', (per_page, offset))
            tracks_rows = cursor.fetchall()
            tracks = []
            for row in tracks_rows:
                track = {
                    'id': row[0],
                    'name': row[1],
                    'description': row[2],
                    'url': row[3],
                    'original_url': row[4],
                    'tags': self.get_tags_for_track(row[0])
                }
                tracks.append(track)
            # Получаем общее количество треков
            cursor.execute('SELECT COUNT(*) FROM tracks')
            total = cursor.fetchone()[0]
            return tracks, total
    
        # Метод для поиска треков по описанию и тегам
        def search_tracks(self, description='', tags=[]):
            cursor = self.conn.cursor()
            query = 'SELECT DISTINCT t.id, t.name, t.description, t.url, t.original_url FROM tracks t'
            params = []
            if tags:
                query += ' INNER JOIN track_tags tt ON t.id = tt.track_id INNER JOIN tags g ON tt.tag_id = g.id'
            query += ' WHERE 1=1'
            if description:
                query += ' AND t.description LIKE ?'
                params.append(f'%{description}%')
            if tags:
                query += ' AND g.name IN ({seq})'.format(seq=','.join(['?']*len(tags)))
                params.extend(tags)
            cursor.execute(query, params)
            tracks_rows = cursor.fetchall()
            tracks = []
            for row in tracks_rows:
                track = {
                    'id': row[0],
                    'name': row[1],
                    'description': row[2],
                    'url': row[3],
                    'original_url': row[4],
                    'tags': self.get_tags_for_track(row[0])
                }
                tracks.append(track)
            return tracks
    
        # Метод для получения тегов трека
        def get_tags_for_track(self, track_id):
            cursor = self.conn.cursor()
            cursor.execute('''
                SELECT g.name FROM tags g
                INNER JOIN track_tags tt ON g.id = tt.tag_id
                WHERE tt.track_id = ?
            ''', (track_id,))
            tags = [row[0] for row in cursor.fetchall()]
            return tags
    
        # Метод для удаления трека
        def delete_track(self, track_id):
            cursor = self.conn.cursor()
            # Удаляем связи из track_tags
            cursor.execute('DELETE FROM track_tags WHERE track_id = ?', (track_id,))
            # Удаляем сам трек
            cursor.execute('DELETE FROM tracks WHERE id = ?', (track_id,))
            self.conn.commit()
    

    requirements.txt

    Flask
    Flask-Cors
    requests
    

    static/app.js

    $(document).ready(function () {
        const $tracksContainer = $('#tracks-container');
        const $addTrackButton = $('#add-track-button');
        const $addTrackDialog = $('#add-track-dialog');
        const $closeAddDialog = $('#close-add-dialog');
        const $addTrackForm = $('#add-track-form');
        const $tagsContainer = $('#tags-container');
        const $addTagButton = $('#add-tag-button');
        const $audioPlayer = $('#audio-player');
        const $audioControl = $('#audio-control');
        const $trackTitle = $('#track-title');
        const $togglePlayerButton = $('#toggle-player-button');
        const $descriptionDialog = $('#description-dialog');
        const $closeDescriptionDialog = $('#close-description-dialog');
        const $descriptionTitle = $('#description-title');
        const $descriptionText = $('#description-text');
        const $copyLinkButton = $('#copy-link-button');
    
    
        let currentPage = 1;
        const animationSpeed = 300; // milliseconds
        // --- Function Declarations ---
        function loadTracks(page = 1) {
            $.getJSON(`/tracks?page=${page}`, function (data) {
                $tracksContainer.empty();
                $.each(data.tracks, function (index, track) {
                    const $trackTile = $('<div class="track-tile"></div>');
                    const $topDiv = $('<div class="top-div"></div>');
                    const $buttons = $('<div class="buttons"></div>');
                    const $title = $('<h3>' + track.name + '</h3>');
    
                    const $playButton = $('<button><img src="../static/icons/play.webp" alt="Play"></button>').click(function () {
                        playTrack(track);
                    });
                    const $copyButton = $('<button><img src="../static/icons/copy.webp" alt="Copy"></button>').click(function () {
                        copyToClipboard(track.original_url);
                    });
                    const $descriptionButton = $('<button><img src="../static/icons/description.webp" alt="Description"></button>').click(function () {
                        showDescription(track);
                    });
                    const $deleteButton = $('<button><img src="../static/icons/close.webp" alt="Delete"></button>').click(function () {
                        deleteTrack(track.id);
                    });
    
                    $topDiv.append($playButton).append($title);
                    $buttons.append($copyButton).append($descriptionButton).append($deleteButton);
                    $trackTile.append($topDiv).append($buttons);
                    $tracksContainer.append($trackTile);
                });
            }).fail(function (jqxhr, textStatus, error) {
                console.error('Error loading tracks:', error);
                alert('Не удалось загрузить треки.');
            });
        }
    
    
        function playTrack(track) {
            $audioControl.attr('src', track.url);
            $trackTitle.text(track.name);
            $audioControl[0].play();  // Access the underlying HTMLAudioElement to call play()
            maximizePlayer();
        }
    
        function maximizePlayer() {
            $audioPlayer.removeClass('minimized').addClass('maximized');
            $togglePlayerButton.addClass('rotated');
        }
    
        function minimizePlayer() {
            $audioPlayer.addClass('minimized').removeClass('maximized');
            $togglePlayerButton.removeClass('rotated');
        }
    
        function showDescription(track) {
            $descriptionTitle.text(track.name);
            $descriptionText.text(track.description || 'Нет описания.');
            $descriptionDialog.fadeIn(animationSpeed);
        }
    
    
        function copyToClipboard(text) {
            navigator.clipboard.writeText(text).then(function () {
                alert('Ссылка скопирована в буфер обмена!');
            }, function (err) {
                console.error('Could not copy text: ', err);
            });
        }
    
    
        function deleteTrack(trackId) {
            if (confirm(`Вы уверены, что хотите удалить трек "${$(`#track-${trackId} .title`).text()}"?`)) {
                $.ajax({
                    url: `/tracks/${trackId}`,
                    type: 'DELETE',
                    success: function (data) {
                        if (data.error) {
                            alert('Ошибка: ' + data.error);
                        } else {
                            alert(data.message);
                            loadTracks(currentPage);
                        }
                    },
                    error: function (jqxhr, textStatus, error) {
                        console.error('Error deleting track:', error);
                        alert('Что-то пошло не так.');
                    }
                });
            }
        }
    
    
        // --- Event Handlers ---
        $addTrackButton.click(function () {
            $addTrackDialog.show();
        });
        $closeAddDialog.click(function () {
            $addTrackDialog.hide();
        });
        $closeDescriptionDialog.click(function () {
            $descriptionDialog.hide();
        });
    
        // --- Event Handlers ---
        $addTrackButton.click(function() { $addTrackDialog.fadeIn(animationSpeed); });
        $closeAddDialog.click(function() { $addTrackDialog.fadeOut(animationSpeed); });
        $closeDescriptionDialog.click(function() { $descriptionDialog.fadeOut(animationSpeed); });
    
        $(window).click(function(event) {
            if (event.target == $addTrackDialog[0]) { $addTrackDialog.fadeOut(animationSpeed); }
            if (event.target == $descriptionDialog[0]) { $descriptionDialog.fadeOut(animationSpeed); }
        });
    
    
        $addTagButton.click(function () {
            const $tagItem = $('<div class="tag-item"></div>');
            const $tagInput = $('<input type="text">');
            const $removeButton = $('<button>Удалить</button>').click(function () {
                $tagItem.remove();
            });
            $tagItem.append($tagInput).append($removeButton);
            $tagsContainer.append($tagItem);
        });
    
    
        $addTrackForm.submit(function (event) {
            event.preventDefault();
    
            const name = $('#track-name').val();
            const description = $('#track-description').val();
            const original_url = $('#track-url').val();
            const tags = [];
            $tagsContainer.find('input').each(function () {
                if ($(this).val().trim()) {
                    tags.push($(this).val().trim());
                }
            });
    
    
            $.ajax({
                url: '/tracks',
                type: 'POST',
                contentType: 'application/json',
                data: JSON.stringify({name, description, url: original_url, tags}),
                success: function(data) {
                    if (data.error) {
                       alert('Ошибка: ' + data.error);
                    } else {
                        alert('Трек успешно добавлен!');
                        $addTrackDialog.fadeOut(animationSpeed); // Animation added here
                        $addTrackForm[0].reset();
                        $tagsContainer.empty();
                        loadTracks();
                    }
                },
                error: function (jqxhr, textStatus, error) {
                    console.error('Error adding track:', error);
                    alert('Что-то пошло не так.');
                }
            });
    
        });
    
    
        $togglePlayerButton.click(function () {
            $audioPlayer.toggleClass('minimized maximized');
            $togglePlayerButton.toggleClass('rotated');
        });
    
    
        $copyLinkButton.click(function () {
            const originalUrl = $audioControl.attr('src');
            if (originalUrl) {
                copyToClipboard(originalUrl);
            } else {
                alert('Нет ссылки для копирования.');
            }
        });
    
        // Initial load
        loadTracks();
    
    
    });
    

    static/styles.css

    body {
        margin: 0;
        font-family: "Roboto", serif;
        background-color: #ffffff;
        color: #333;
    }
    
    header {
        display: flex;
        justify-content: space-between;
        align-items: center;
        padding: 10px;
    }
    
    header h1 {
        margin: 0;
        font-size: 24px;
    }
    
    #add-track-button {
        padding: 10px 20px;
        font-size: 16px;
    }
    
    main {
        display: flex;
        flex-wrap: wrap;
        padding: 10px;
    }
    
    .track-tile {
        /* border: 1px solid #ddd; */
        border-radius: 8px;
        width: 200px;
        margin: 10px;
        padding: 10px;
        text-align: center;
        /* display: flex; */
        background-color: #0000000a;
        display: flex;
        flex-direction: column;
        align-items: flex-start;
        gap: 5px;
    }
    
    .track-tile h3 {
        margin: 0;
    }
    
    .track-tile button {
        /* margin: 5px; */
        /* padding: 5px 10px; */
    }
    
    #audio-player {
        position: fixed;
        bottom: 0;
        width: 100%;
        background-color: #f9f9f9;
        border-top: 1px solid #ddd;
        transition: max-height 0.3s ease;
        overflow: hidden;
    }
    
    #audio-player.minimized {
        max-height: 55px;
    }
    
    #audio-player.maximized {
        max-height: 200px;
    }
    
    #player-header {
        display: flex;
        justify-content: space-between;
        align-items: center;
        padding: 10px;
    }
    
    #now-playing {
        font-size: 16px;
    }
    
    #toggle-player-button {
        font-size: 16px;
        transform: rotate(0deg);
        transition: transform 0.3s ease;
    }
    
    #toggle-player-button.rotated {
        transform: rotate(180deg);
    }
    
    .modal {
        display: none;
        position: fixed;
        z-index: 1000;
        left: 0;
        top: 0;
        width: 100%;
        height: 100%;
        overflow: auto;
        background-color: rgba(0, 0, 0, 0.4);
    }
    
    .modal-content {
        background-color: #fff;
        margin: 50px auto;
        padding: 20px;
        border-radius: 8px;
        max-width: 500px;
    }
    
    .close-button {
        float: right;
        font-size: 28px;
        cursor: pointer;
    }
    
    form label {
        display: block;
        margin: 10px 0 5px 0;
    }
    
    form input[type="text"],
    form input[type="url"],
    form textarea {
        width: 100%;
        padding: 8px;
        box-sizing: border-box;
        border-radius: 17px;
        border: 1px solid #0000002b;
    }
    
    #tags-container {
        display: flex;
        flex-direction: column;
        border-left: 2px solid #00000017;
        padding-left: 5px;
        gap: 5px;
    }
    
    .tag-item {
        display: flex;
        align-items: center;
        /* margin-bottom: 5px; */
    }
    
    .tag-item input {
        flex: 1;
    }
    
    .tag-item button {
        margin-left: 5px;
    }
    
    .track-tile button {
        /* margin: 5px; */
        /* padding: 5px 10px; */
        cursor: pointer;
        background: #00000012;
        width: 30px;
        padding: 5px;
        margin: 0;
        /* border: 1px solid #00000036; */
        display: flex;
        align-items: center;
        justify-content: center;
        border-radius: 5px;
        /* border: none; */
    }
    
    .track-tile button:last-child {
        /* background-color: #e74c3c; */ /* Красный цвет для удаления */
        /* color: white; */
        /* border: none; */
        /* border-radius: 4px; */
    }
    
    button {
        padding: 4px 10px;
        margin: 5px;
        border: none;
        border-radius: 15px;
        background-color: #000000bf;
        color: white;
        font-family: "Roboto", serif;
        font-weight: 600;
    }
    
    button img {
        width: 100%;
    }
    
    .buttons {
        display: flex;
        align-items: center;
        gap: 5px;
        width: 100%;
        justify-content: flex-end;
    }
    
    .buttons button {
        padding: 0;
        background: none;
        width: 25px;
        margin: 0;
        border-radius: 5px;
        border: none;
    }
    
    .buttons button:hover {
        background-color: rgba(0, 0, 0, 0.04); /* Темнее при наведении */
    }
    
    .top-div {
        display: flex;
        align-items: center;
        gap: 5px;
    }
    
    h2 {
        padding: 0;
        margin: 0;
    }
    
    audio {
        width: 100%;
    }
    audio::-webkit-media-controls-panel {
      background-color: transparent; /* Убираем фон панели управления */
    }
    
    @media (max-width: 600px) {
        .track-tile {
            width: 100%;
            margin: 5px 0;
        }
    
        header h1 {
            font-size: 20px;
        }
    
        #add-track-button {
            padding: 8px 16px;
            font-size: 14px;
        }
    }
    

    templates/index.html

    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <title>LitMusic</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <!-- Стили -->
        <link rel="stylesheet" href="../static/styles.css">
        <link rel="preconnect" href="https://fonts.googleapis.com">
        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
        <link href="https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&family=Roboto+Slab:wght@100..900&family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap" rel="stylesheet">
    </head>
    <body>
    
    <!-- Верхняя панель -->
    <header>
        <h1>LitMusic</h1>
        <button id="add-track-button">Добавить Трек</button>
    </header>
    
    <!-- Список треков -->
    <main id="tracks-container"></main>
    
    <!-- Проигрыватель -->
    <div id="audio-player" class="minimized">
        <div id="player-header">
            <span id="now-playing">Сейчас играет: <span id="track-title"></span></span>
            <button id="toggle-player-button">▼</button>
        </div>
        <audio id="audio-control" controls></audio>
    </div>
    
    <!-- Диалоговое окно добавления трека -->
    <div id="add-track-dialog" class="modal">
        <div class="modal-content">
            <span class="close-button" id="close-add-dialog">&times;</span>
            <h2>Добавить Новый Трек</h2>
            <form id="add-track-form">
                <label for="track-name">Название Трека:</label>
                <input type="text" id="track-name" name="name" required>
    
                <label for="track-description">Описание:</label>
                <textarea id="track-description" name="description"></textarea>
    
                <label>Теги:</label>
                <div id="tags-container">
                    <!-- Контейнер тегов -->
                </div>
                <button type="button" id="add-tag-button">+</button>
    
                <label for="track-url">Ссылка на Трек:</label>
                <input type="url" id="track-url" name="url" required>
    
                <button type="submit">Добавить</button>
            </form>
        </div>
    </div>
    
    <!-- Диалоговое окно описания -->
    <div id="description-dialog" class="modal">
        <div class="modal-content">
            <span class="close-button" id="close-description-dialog">&times;</span>
            <h2 id="description-title"></h2>
            <p id="description-text"></p>
        </div>
    </div>
    
    <!-- Скрипты -->
    <script
      src="https://code.jquery.com/jquery-3.7.1.js"
      integrity="sha256-eKhayi8LEQwp4NKxN+CfCh+3qOVUtJn3QNZ0TciWLP4="
      crossorigin="anonymous"></script>
    <script src="../static/app.js"></script>
    
    </body>
    </html>
    

    Сделай так, чтобы на сайте была пагинация. Также, сделай строку поиска на сайте, чтобы она искала по названию, по тегам и по описанию(название приориитетнее) Сделай все красиво, чтобы все было с анимациями(желательно)

  2. Assistant

    To implement pagination and a comprehensive search functionality on your LitMusic website, we'll need to update both the backend (app.py and database.py) and the frontend (index.html, app.js, and styles.css). Below are the detailed steps and the updated code for each file.


    1. Backend Modifications

    a. app.py

    Changes:

    • Enhanced the /tracks/search endpoint to accept name, description, tags, page, and per_page as query parameters.
    • Returned the total number of matching tracks to facilitate pagination on the frontend.
    # app.py
    
    from flask import Flask, request, jsonify, send_from_directory, render_template
    from flask_cors import CORS
    from database import Database
    import os
    import requests
    from urllib.parse import urlparse
    import uuid
    
    app = Flask(__name__, static_folder='static', template_folder='templates')
    CORS(app)
    
    db = Database()
    
    # Ensure the tracks directory exists
    TRACKS_DIR = os.path.join(app.static_folder, 'tracks')
    os.makedirs(TRACKS_DIR, exist_ok=True)
    
    # Home page
    @app.route('/')
    def index():
        return render_template('index.html')
    
    # Serve static files
    @app.route('/static/<path:path>')
    def send_static_files(path):
        return send_from_directory('static', path)
    
    # 1. Get all tracks with pagination
    @app.route('/tracks', methods=['GET'])
    def get_tracks():
        page = request.args.get('page', 1, type=int)
        per_page = 10
        tracks, total = db.get_tracks(page, per_page)
        return jsonify({'tracks': tracks, 'total': total})
    
    # 2. Search tracks with pagination
    @app.route('/tracks/search', methods=['GET'])
    def search_tracks():
        name = request.args.get('name', '', type=str)
        description = request.args.get('description', '', type=str)
        tags = request.args.getlist('tags')
        page = request.args.get('page', 1, type=int)
        per_page = 10
        tracks, total = db.search_tracks(name, description, tags, page, per_page)
        return jsonify({'tracks': tracks, 'total': total})
    
    # 3. Add a new track
    @app.route('/tracks', methods=['POST'])
    def add_track():
        data = request.get_json()
        name = data.get('name')
        description = data.get('description')
        original_url = data.get('url')  # Original URL
        tags = data.get('tags', [])
    
        if not name or not original_url:
            return jsonify({'error': 'Название и ссылка на трек обязательны.'}), 400
    
        # Insert the track with a temporary URL (empty)
        track_id = db.add_track(name, description, '', original_url, tags)
    
        try:
            # Download the file from the original URL
            response = requests.get(original_url, stream=True)
            response.raise_for_status()
    
            # Determine file extension from URL or headers
            parsed_url = urlparse(original_url)
            _, ext = os.path.splitext(parsed_url.path)
            if not ext:
                # Attempt to get from headers
                content_type = response.headers.get('Content-Type')
                if content_type:
                    if 'audio/mpeg' in content_type:
                        ext = '.mp3'
                    elif 'audio/wav' in content_type:
                        ext = '.wav'
                    # Add more types if necessary
                    else:
                        ext = ''
                else:
                    ext = ''
    
            # Generate a unique filename
            if not ext:
                ext = '.mp3'  # Default extension
    
            filename = f"{uuid.uuid4()}{ext}"
            file_path = os.path.join(TRACKS_DIR, filename)
    
            # Save locally
            with open(file_path, 'wb') as f:
                for chunk in response.iter_content(chunk_size=8192):
                    f.write(chunk)
    
            # Update the 'url' field in the database with the local file URL
            local_url = f"/static/tracks/{filename}"
            db.update_track_url(track_id, local_url)
    
        except Exception as e:
            # In case of download failure, delete the track from the DB
            db.delete_track(track_id)
            return jsonify({'error': f'Не удалось загрузить файл: {str(e)}'}), 400
    
        return jsonify({'message': 'Трек успешно добавлен.', 'track_id': track_id}), 201
    
    # 4. Delete a track
    @app.route('/tracks/<int:track_id>', methods=['DELETE'])
    def delete_track(track_id):
        # Get the track by ID
        track = db.get_track_by_id(track_id)
        if not track:
            return jsonify({'error': 'Трек не найден.'}), 404
    
        # Delete the track from the database
        db.delete_track(track_id)
    
        # Delete the local file
        file_path = os.path.join(app.root_path, track['url'].lstrip('/'))
        if os.path.exists(file_path):
            try:
                os.remove(file_path)
            except Exception as e:
                # Optionally log the error
                pass
    
        return jsonify({'message': 'Трек успешно удален.'}), 200
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=6390)
    

    b. database.py

    Changes:

    • Updated the search_tracks method to handle name, description, tags, page, and per_page.
    • Implemented ordering to prioritize tracks that match the name search.
    • Added pagination support by limiting the number of results and calculating the offset.
    • Computed the total number of matching tracks for pagination purposes.
    # database.py
    
    import sqlite3
    
    class Database:
        def __init__(self, db_path='database.db'):
            self.db_path = db_path
            self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
            self.init_db()
    
        def init_db(self):
            cursor = self.conn.cursor()
            # Create tracks table with original_url field
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS tracks (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    name TEXT NOT NULL,
                    description TEXT,
                    url TEXT NOT NULL,
                    original_url TEXT
                )
            ''')
            # Create tags table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS tags (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    name TEXT NOT NULL UNIQUE
                )
            ''')
            # Create association table between tracks and tags
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS track_tags (
                    track_id INTEGER,
                    tag_id INTEGER,
                    FOREIGN KEY(track_id) REFERENCES tracks(id),
                    FOREIGN KEY(tag_id) REFERENCES tags(id),
                    PRIMARY KEY(track_id, tag_id)
                )
            ''')
            self.conn.commit()
    
        # Updated method to add a track
        def add_track(self, name, description, url, original_url, tags):
            cursor = self.conn.cursor()
            cursor.execute('INSERT INTO tracks (name, description, url, original_url) VALUES (?, ?, ?, ?)', 
                           (name, description, url, original_url))
            track_id = cursor.lastrowid
            for tag_name in tags:
                # Check if tag exists
                cursor.execute('SELECT id FROM tags WHERE name = ?', (tag_name,))
                tag_row = cursor.fetchone()
                if tag_row:
                    tag_id = tag_row[0]
                else:
                    cursor.execute('INSERT INTO tags (name) VALUES (?)', (tag_name,))
                    tag_id = cursor.lastrowid
                # Add association
                cursor.execute('INSERT OR IGNORE INTO track_tags (track_id, tag_id) VALUES (?, ?)', (track_id, tag_id))
            self.conn.commit()
            return track_id
    
        # Method to update the URL of a track
        def update_track_url(self, track_id, url):
            cursor = self.conn.cursor()
            cursor.execute('UPDATE tracks SET url = ? WHERE id = ?', (url, track_id))
            self.conn.commit()
    
        # Method to get a track by ID
        def get_track_by_id(self, track_id):
            cursor = self.conn.cursor()
            cursor.execute('SELECT * FROM tracks WHERE id = ?', (track_id,))
            row = cursor.fetchone()
            if row:
                track = {
                    'id': row[0],
                    'name': row[1],
                    'description': row[2],
                    'url': row[3],
                    'original_url': row[4],
                    'tags': self.get_tags_for_track(row[0])
                }
                return track
            return None
    
        # Method to get all tracks with pagination
        def get_tracks(self, page=1, per_page=10):
            cursor = self.conn.cursor()
            offset = (page - 1) * per_page
            cursor.execute('SELECT * FROM tracks ORDER BY id DESC LIMIT ? OFFSET ?', (per_page, offset))
            tracks_rows = cursor.fetchall()
            tracks = []
            for row in tracks_rows:
                track = {
                    'id': row[0],
                    'name': row[1],
                    'description': row[2],
                    'url': row[3],
                    'original_url': row[4],
                    'tags': self.get_tags_for_track(row[0])
                }
                tracks.append(track)
            # Get total number of tracks
            cursor.execute('SELECT COUNT(*) FROM tracks')
            total = cursor.fetchone()[0]
            return tracks, total
    
        # Updated method to search tracks with pagination
        def search_tracks(self, name='', description='', tags=[], page=1, per_page=10):
            cursor = self.conn.cursor()
            query = '''
                SELECT DISTINCT t.id, t.name, t.description, t.url, t.original_url
                FROM tracks t
                LEFT JOIN track_tags tt ON t.id = tt.track_id
                LEFT JOIN tags g ON tt.tag_id = g.id
                WHERE 1=1
            '''
            params = []
            if name:
                query += ' AND t.name LIKE ?'
                params.append(f'%{name}%')
            if description:
                query += ' AND t.description LIKE ?'
                params.append(f'%{description}%')
            if tags:
                placeholders = ','.join(['?']*len(tags))
                query += f' AND g.name IN ({placeholders})'
                params.extend(tags)
            
            # Order by name matches first
            if name:
                query += ' ORDER BY CASE WHEN t.name LIKE ? THEN 0 ELSE 1 END, t.name'
                params.append(f'%{name}%')
            else:
                query += ' ORDER BY t.name'
    
            # Pagination
            offset = (page - 1) * per_page
            query += ' LIMIT ? OFFSET ?'
            params.extend([per_page, offset])
    
            cursor.execute(query, params)
            tracks_rows = cursor.fetchall()
            tracks = []
            for row in tracks_rows:
                track = {
                    'id': row[0],
                    'name': row[1],
                    'description': row[2],
                    'url': row[3],
                    'original_url': row[4],
                    'tags': self.get_tags_for_track(row[0])
                }
                tracks.append(track)
    
            # Get total number of matching tracks
            count_query = '''
                SELECT COUNT(DISTINCT t.id)
                FROM tracks t
                LEFT JOIN track_tags tt ON t.id = tt.track_id
                LEFT JOIN tags g ON tt.tag_id = g.id
                WHERE 1=1
            '''
            count_params = []
            if name:
                count_query += ' AND t.name LIKE ?'
                count_params.append(f'%{name}%')
            if description:
                count_query += ' AND t.description LIKE ?'
                count_params.append(f'%{description}%')
            if tags:
                placeholders = ','.join(['?']*len(tags))
                count_query += f' AND g.name IN ({placeholders})'
                count_params.extend(tags)
            
            cursor.execute(count_query, count_params)
            total = cursor.fetchone()[0]
    
            return tracks, total
    
        # Method to get tags for a track
        def get_tags_for_track(self, track_id):
            cursor = self.conn.cursor()
            cursor.execute('''
                SELECT g.name FROM tags g
                INNER JOIN track_tags tt ON g.id = tt.tag_id
                WHERE tt.track_id = ?
            ''', (track_id,))
            tags = [row[0] for row in cursor.fetchall()]
            return tags
    
        # Method to delete a track
        def delete_track(self, track_id):
            cursor = self.conn.cursor()
            # Delete associations
            cursor.execute('DELETE FROM track_tags WHERE track_id = ?', (track_id,))
            # Delete the track
            cursor.execute('DELETE FROM tracks WHERE id = ?', (track_id,))
            self.conn.commit()
    

    2. Frontend Modifications

    a. templates/index.html

    Changes:

    • Added a search section with inputs for name, description, and dynamic tag fields.
    • Included pagination controls with Previous and Next buttons and display for current and total pages.
    • Ensured each track tile has a unique ID to facilitate specific operations like deletion.
    <!-- templates/index.html -->
    
    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <title>LitMusic</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <!-- Styles -->
        <link rel="stylesheet" href="../static/styles.css">
        <link rel="preconnect" href="https://fonts.googleapis.com">
        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
        <link href="https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&family=Roboto+Slab:wght@100..900&family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap" rel="stylesheet">
    </head>
    <body>
    
    <!-- Header -->
    <header>
        <h1>LitMusic</h1>
        <button id="add-track-button">Добавить Трек</button>
    </header>
    
    <!-- Search Section -->
    <section id="search-section">
        <form id="search-form">
            <input type="text" id="search-name" placeholder="Поиск по названию" />
            <input type="text" id="search-description" placeholder="Поиск по описанию" />
            <div id="search-tags-container">
                <!-- Tags inputs will be dynamically added here -->
            </div>
            <button type="button" id="add-search-tag-button">Добавить тег</button>
            <button type="submit">Поиск</button>
            <button type="button" id="clear-search">Очистить</button>
        </form>
    </section>
    
    <!-- Tracks List -->
    <main id="tracks-container"></main>
    
    <!-- Pagination Controls -->
    <div id="pagination-controls">
        <button id="prev-page" disabled>Предыдущая</button>
        <span id="current-page">1</span> / <span id="total-pages">1</span>
        <button id="next-page" disabled>Следующая</button>
    </div>
    
    <!-- Audio Player -->
    <div id="audio-player" class="minimized">
        <div id="player-header">
            <span id="now-playing">Сейчас играет: <span id="track-title"></span></span>
            <button id="toggle-player-button">▼</button>
        </div>
        <audio id="audio-control" controls></audio>
    </div>
    
    <!-- Add Track Dialog -->
    <div id="add-track-dialog" class="modal">
        <div class="modal-content">
            <span class="close-button" id="close-add-dialog">&times;</span>
            <h2>Добавить Новый Трек</h2>
            <form id="add-track-form">
                <label for="track-name">Название Трека:</label>
                <input type="text" id="track-name" name="name" required>
    
                <label for="track-description">Описание:</label>
                <textarea id="track-description" name="description"></textarea>
    
                <label>Теги:</label>
                <div id="tags-container">
                    <!-- Tags inputs -->
                </div>
                <button type="button" id="add-tag-button">+</button>
    
                <label for="track-url">Ссылка на Трек:</label>
                <input type="url" id="track-url" name="url" required>
    
                <button type="submit">Добавить</button>
            </form>
        </div>
    </div>
    
    <!-- Description Dialog -->
    <div id="description-dialog" class="modal">
        <div class="modal-content">
            <span class="close-button" id="close-description-dialog">&times;</span>
            <h2 id="description-title"></h2>
            <p id="description-text"></p>
        </div>
    </div>
    
    <!-- Scripts -->
    <script
      src="https://code.jquery.com/jquery-3.7.1.js"
      integrity="sha256-eKhayi8LEQwp4NKxN+CfCh+3qOVUtJn3QNZ0TciWLP4="
      crossorigin="anonymous"></script>
    <script src="../static/app.js"></script>
    
    </body>
    </html>
    

    b. static/app.js

    Changes:

    • Implemented state management for currentPage, totalPages, and searchParams.
    • Updated loadTracks function to handle both regular listing and search results.
    • Added event handlers for search form submission, clearing search, and pagination button clicks.
    • Enhanced UI interactions with animations during content loading and transitions.
    // static/app.js
    
    $(document).ready(function () {
        const $tracksContainer = $('#tracks-container');
        const $addTrackButton = $('#add-track-button');
        const $addTrackDialog = $('#add-track-dialog');
        const $closeAddDialog = $('#close-add-dialog');
        const $addTrackForm = $('#add-track-form');
        const $tagsContainer = $('#tags-container');
        const $addTagButton = $('#add-tag-button');
        const $audioPlayer = $('#audio-player');
        const $audioControl = $('#audio-control');
        const $trackTitle = $('#track-title');
        const $togglePlayerButton = $('#toggle-player-button');
        const $descriptionDialog = $('#description-dialog');
        const $closeDescriptionDialog = $('#close-description-dialog');
        const $descriptionTitle = $('#description-title');
        const $descriptionText = $('#description-text');
        const $copyLinkButton = $('#copy-link-button');
    
        // --- New Elements for Search ---
        const $searchForm = $('#search-form');
        const $searchName = $('#search-name');
        const $searchDescription = $('#search-description');
        const $searchTagsContainer = $('#search-tags-container');
        const $addSearchTagButton = $('#add-search-tag-button');
        const $clearSearchButton = $('#clear-search');
        const $paginationControls = $('#pagination-controls');
        const $prevPageButton = $('#prev-page');
        const $nextPageButton = $('#next-page');
        const $currentPageSpan = $('#current-page');
        const $totalPagesSpan = $('#total-pages');
    
        // State Variables
        let currentPage = 1;
        let totalPages = 1;
        let searchParams = {name: '', description: '', tags: []};
        const perPage = 10;
        let isSearching = false;
    
        // Animation Speed
        const animationSpeed = 300; // milliseconds
    
        // --- Function Declarations ---
        function loadTracks(page = 1) {
            // Show loading animation (optional)
            $tracksContainer.fadeOut(animationSpeed, function() {
                $tracksContainer.empty();
    
                let url = '';
                let params = {page: page, per_page: perPage};
    
                if (isSearching) {
                    url = '/tracks/search';
                    params.name = searchParams.name;
                    params.description = searchParams.description;
                    params.tags = searchParams.tags;
                } else {
                    url = '/tracks';
                }
    
                $.ajax({
                    url: url,
                    type: 'GET',
                    data: params,
                    traditional: true, // Allows sending array parameters
                    success: function(data) {
                        const tracks = data.tracks;
                        const total = data.total;
                        totalPages = Math.ceil(total / perPage);
                        currentPage = page;
    
                        // Update Pagination
                        updatePagination();
    
                        if (tracks.length === 0) {
                            $tracksContainer.append('<p>Треки не найдены.</p>');
                        } else {
                            $.each(tracks, function (index, track) {
                                const $trackTile = $(`
                                    <div class="track-tile" id="track-${track.id}">
                                        <div class="top-div">
                                            <button class="play-button" title="Play">
                                                <img src="../static/icons/play.webp" alt="Play">
                                            </button>
                                            <h3 class="title">${track.name}</h3>
                                        </div>
                                        <div class="buttons">
                                            <button class="copy-button" title="Copy">
                                                <img src="../static/icons/copy.webp" alt="Copy">
                                            </button>
                                            <button class="description-button" title="Description">
                                                <img src="../static/icons/description.webp" alt="Description">
                                            </button>
                                            <button class="delete-button" title="Delete">
                                                <img src="../static/icons/close.webp" alt="Delete">
                                            </button>
                                        </div>
                                    </div>
                                `);
    
                                // Play Button Handler
                                $trackTile.find('.play-button').click(function () {
                                    playTrack(track);
                                });
    
                                // Copy Button Handler
                                $trackTile.find('.copy-button').click(function () {
                                    copyToClipboard(track.original_url);
                                });
    
                                // Description Button Handler
                                $trackTile.find('.description-button').click(function () {
                                    showDescription(track);
                                });
    
                                // Delete Button Handler
                                $trackTile.find('.delete-button').click(function () {
                                    deleteTrack(track.id, track.name);
                                });
    
                                $tracksContainer.append($trackTile);
                            });
                        }
    
                        $tracksContainer.fadeIn(animationSpeed);
                    },
                    error: function (jqxhr, textStatus, error) {
                        console.error('Error loading tracks:', error);
                        alert('Не удалось загрузить треки.');
                        $tracksContainer.fadeIn(animationSpeed);
                    }
                });
            });
        }
    
        function updatePagination() {
            $currentPageSpan.text(currentPage);
            $totalPagesSpan.text(totalPages);
    
            // Disable/Enable buttons based on current page
            $prevPageButton.prop('disabled', currentPage <= 1);
            $nextPageButton.prop('disabled', currentPage >= totalPages);
        }
    
        function playTrack(track) {
            $audioControl.attr('src', track.url);
            $trackTitle.text(track.name);
            $audioControl[0].play();  // Access the underlying HTMLAudioElement to play
            maximizePlayer();
        }
    
        function maximizePlayer() {
            $audioPlayer.removeClass('minimized').addClass('maximized');
            $togglePlayerButton.addClass('rotated');
        }
    
        function minimizePlayer() {
            $audioPlayer.addClass('minimized').removeClass('maximized');
            $togglePlayerButton.removeClass('rotated');
        }
    
        function showDescription(track) {
            $descriptionTitle.text(track.name);
            $descriptionText.text(track.description || 'Нет описания.');
            $descriptionDialog.fadeIn(animationSpeed);
        }
    
        function copyToClipboard(text) {
            navigator.clipboard.writeText(text).then(function () {
                alert('Ссылка скопирована в буфер обмена!');
            }, function (err) {
                console.error('Could not copy text: ', err);
            });
        }
    
        function deleteTrack(trackId, trackName) {
            if (confirm(`Вы уверены, что хотите удалить трек "${trackName}"?`)) {
                $.ajax({
                    url: `/tracks/${trackId}`,
                    type: 'DELETE',
                    success: function (data) {
                        if (data.error) {
                            alert('Ошибка: ' + data.error);
                        } else {
                            alert(data.message);
                            // Reload current page
                            loadTracks(currentPage);
                        }
                    },
                    error: function (jqxhr, textStatus, error) {
                        console.error('Error deleting track:', error);
                        alert('Что-то пошло не так.');
                    }
                });
            }
        }
    
        // --- Event Handlers ---
        // Add Track Dialog Handlers
        $addTrackButton.click(function () {
            $addTrackDialog.fadeIn(animationSpeed);
        });
        $closeAddDialog.click(function () {
            $addTrackDialog.fadeOut(animationSpeed);
        });
    
        // Close dialogs when clicking outside
        $(window).click(function(event) {
            if (event.target == $addTrackDialog[0]) { $addTrackDialog.fadeOut(animationSpeed); }
            if (event.target == $descriptionDialog[0]) { $descriptionDialog.fadeOut(animationSpeed); }
        });
    
        // Add Tag in Add Track Form
        $addTagButton.click(function () {
            const $tagItem = $('<div class="tag-item"></div>');
            const $tagInput = $('<input type="text" class="track-tag-input" placeholder="Тег">');
            const $removeButton = $('<button type="button">Удалить</button>').click(function () {
                $tagItem.remove();
            });
            $tagItem.append($tagInput).append($removeButton);
            $tagsContainer.append($tagItem);
        });
    
        // Add Tag in Search Form
        $addSearchTagButton.click(function () {
            const $tagItem = $('<div class="tag-item"></div>');
            const $tagInput = $('<input type="text" class="search-tag-input" placeholder="Тег">');
            const $removeButton = $('<button type="button">Удалить</button>').click(function () {
                $tagItem.remove();
            });
            $tagItem.append($tagInput).append($removeButton);
            $searchTagsContainer.append($tagItem);
        });
    
        // Add Track Form Submission
        $addTrackForm.submit(function (event) {
            event.preventDefault();
    
            const name = $('#track-name').val().trim();
            const description = $('#track-description').val().trim();
            const original_url = $('#track-url').val().trim();
            const tags = [];
            $tagsContainer.find('.track-tag-input').each(function () {
                const tag = $(this).val().trim();
                if (tag) {
                    tags.push(tag);
                }
            });
    
            $.ajax({
                url: '/tracks',
                type: 'POST',
                contentType: 'application/json',
                data: JSON.stringify({name, description, url: original_url, tags}),
                success: function(data) {
                    if (data.error) {
                       alert('Ошибка: ' + data.error);
                    } else {
                        alert('Трек успешно добавлен!');
                        $addTrackDialog.fadeOut(animationSpeed);
                        $addTrackForm[0].reset();
                        $tagsContainer.empty();
                        // Reload the first page to see the new track
                        currentPage = 1;
                        loadTracks(currentPage);
                    }
                },
                error: function (jqxhr, textStatus, error) {
                    console.error('Error adding track:', error);
                    alert('Что-то пошло не так.');
                }
            });
    
        });
    
        // Toggle Player Size
        $togglePlayerButton.click(function () {
            $audioPlayer.toggleClass('minimized maximized');
            $togglePlayerButton.toggleClass('rotated');
        });
    
        // Copy Link Button Handler (if applicable)
        $copyLinkButton.click(function () {
            const originalUrl = $audioControl.attr('src');
            if (originalUrl) {
                copyToClipboard(originalUrl);
            } else {
                alert('Нет ссылки для копирования.');
            }
        });
    
        // --- Search Form Handlers ---
        $searchForm.submit(function (event) {
            event.preventDefault();
            // Collect search parameters
            const name = $searchName.val().trim();
            const description = $searchDescription.val().trim();
            const tags = [];
            $searchTagsContainer.find('.search-tag-input').each(function () {
                const tag = $(this).val().trim();
                if (tag) {
                    tags.push(tag);
                }
            });
    
            // Update searchParams and state
            searchParams = {name, description, tags};
            isSearching = (name || description || tags.length > 0);
            currentPage = 1;
    
            // Load tracks based on search
            loadTracks(currentPage);
        });
    
        // Clear Search Button Handler
        $clearSearchButton.click(function () {
            // Reset search parameters and state
            searchParams = {name: '', description: '', tags: []};
            isSearching = false;
            currentPage = 1;
            // Clear search inputs
            $searchForm[0].reset();
            $searchTagsContainer.empty();
            // Reload all tracks
            loadTracks(currentPage);
        });
    
        // Pagination Buttons Handlers
        $prevPageButton.click(function () {
            if (currentPage > 1) {
                loadTracks(currentPage - 1);
            }
        });
    
        $nextPageButton.click(function () {
            if (currentPage < totalPages) {
                loadTracks(currentPage + 1);
            }
        });
    
        // Initial load
        loadTracks();
    
    });
    

    c. static/styles.css

    Changes:

    • Styled the search section and tag inputs for both search and add track forms.
    • Designed the pagination controls to be user-friendly and visually appealing.
    • Added smooth transition animations for fading and toggling UI elements.
    • Enhanced responsiveness to ensure the UI looks good on various screen sizes.
    /* static/styles.css */
    
    body {
        margin: 0;
        font-family: "Roboto", serif;
        background-color: #ffffff;
        color: #333;
    }
    
    header {
        display: flex;
        justify-content: space-between;
        align-items: center;
        padding: 10px 20px;
        background-color: #f2f2f2;
        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
    }
    
    header h1 {
        margin: 0;
        font-size: 28px;
    }
    
    #add-track-button {
        padding: 10px 20px;
        font-size: 16px;
        cursor: pointer;
        transition: background-color 0.3s ease;
    }
    
    #add-track-button:hover {
        background-color: #e0e0e0;
    }
    
    #search-section {
        padding: 20px;
        background-color: #fafafa;
        border-bottom: 1px solid #ddd;
        animation: fadeIn 0.5s ease;
    }
    
    #search-form {
        display: flex;
        flex-wrap: wrap;
        gap: 10px;
        align-items: flex-end;
    }
    
    #search-form input[type="text"] {
        padding: 8px 12px;
        border-radius: 5px;
        border: 1px solid #ccc;
        flex: 1 1 200px;
        transition: border-color 0.3s ease;
    }
    
    #search-form input[type="text"]:focus {
        border-color: #66afe9;
        outline: none;
    }
    
    #search-tags-container,
    #tags-container {
        display: flex;
        flex-wrap: wrap;
        gap: 5px;
        flex: 1 1 100%;
    }
    
    .tag-item {
        display: flex;
        align-items: center;
        gap: 5px;
    }
    
    .tag-item input {
        padding: 6px 10px;
        border-radius: 5px;
        border: 1px solid #ccc;
        flex: 1;
    }
    
    .tag-item button {
        padding: 6px 10px;
        border: none;
        background-color: #ff4d4d;
        color: white;
        border-radius: 5px;
        cursor: pointer;
        transition: background-color 0.3s ease;
    }
    
    .tag-item button:hover {
        background-color: #e60000;
    }
    
    #add-search-tag-button,
    #add-tag-button {
        padding: 6px 12px;
        border: none;
        background-color: #4CAF50;
        color: white;
        border-radius: 5px;
        cursor: pointer;
        transition: background-color 0.3s ease;
    }
    
    #add-search-tag-button:hover,
    #add-tag-button:hover {
        background-color: #45a049;
    }
    
    #search-form button[type="submit"],
    #search-form button#clear-search {
        padding: 8px 16px;
        border: none;
        background-color: #2196F3;
        color: white;
        border-radius: 5px;
        cursor: pointer;
        transition: background-color 0.3s ease;
    }
    
    #search-form button[type="submit"]:hover,
    #search-form button#clear-search:hover {
        background-color: #0b7dda;
    }
    
    #search-form button#clear-search {
        background-color: #f44336;
    }
    
    #search-form button#clear-search:hover {
        background-color: #da190b;
    }
    
    main {
        display: flex;
        flex-wrap: wrap;
        padding: 20px;
        animation: fadeIn 0.5s ease;
    }
    
    .track-tile {
        border-radius: 8px;
        width: 200px;
        margin: 10px;
        padding: 15px;
        text-align: center;
        background-color: #f9f9f9;
        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
        transition: transform 0.3s ease, box-shadow 0.3s ease;
        display: flex;
        flex-direction: column;
        justify-content: space-between;
    }
    
    .track-tile:hover {
        transform: translateY(-5px);
        box-shadow: 0 4px 10px rgba(0,0,0,0.2);
    }
    
    .track-tile h3 {
        margin: 10px 0;
        font-size: 18px;
        color: #333;
    }
    
    .track-tile button {
        cursor: pointer;
        background: none;
        border: none;
        padding: 5px;
        transition: background-color 0.3s ease;
        border-radius: 5px;
    }
    
    .track-tile button:hover {
        background-color: rgba(0, 0, 0, 0.05);
    }
    
    .buttons {
        display: flex;
        justify-content: space-around;
        margin-top: 10px;
    }
    
    .buttons button img {
        width: 20px;
        height: 20px;
    }
    
    #audio-player {
        position: fixed;
        bottom: 0;
        width: 100%;
        background-color: #ffffff;
        border-top: 1px solid #ddd;
        transition: max-height 0.3s ease, background-color 0.3s ease;
        overflow: hidden;
        box-shadow: 0 -2px 5px rgba(0,0,0,0.1);
    }
    
    #audio-player.minimized {
        max-height: 60px;
    }
    
    #audio-player.maximized {
        max-height: 200px;
    }
    
    #player-header {
        display: flex;
        justify-content: space-between;
        align-items: center;
        padding: 10px 20px;
    }
    
    #now-playing {
        font-size: 16px;
        color: #555;
    }
    
    #toggle-player-button {
        font-size: 16px;
        background: none;
        border: none;
        cursor: pointer;
        transform: rotate(0deg);
        transition: transform 0.3s ease;
    }
    
    #toggle-player-button.rotated {
        transform: rotate(180deg);
    }
    
    .modal {
        display: none;
        position: fixed;
        z-index: 1000;
        left: 0;
        top: 0;
        width: 100%;
        height: 100%;
        overflow: auto;
        background-color: rgba(0, 0, 0, 0.4);
        animation: fadeIn 0.5s ease;
    }
    
    .modal-content {
        background-color: #fff;
        margin: 100px auto;
        padding: 20px;
        border-radius: 8px;
        max-width: 500px;
        position: relative;
        animation: slideDown 0.5s ease;
    }
    
    .close-button {
        position: absolute;
        top: 15px;
        right: 20px;
        font-size: 28px;
        font-weight: bold;
        cursor: pointer;
        color: #aaa;
        transition: color 0.3s ease;
    }
    
    .close-button:hover {
        color: #000;
    }
    
    form label {
        display: block;
        margin: 10px 0 5px 0;
        font-weight: bold;
    }
    
    form input[type="text"],
    form input[type="url"],
    form textarea {
        width: 100%;
        padding: 8px 12px;
        box-sizing: border-box;
        border-radius: 5px;
        border: 1px solid #ccc;
        transition: border-color 0.3s ease;
    }
    
    form input[type="text"]:focus,
    form input[type="url"]:focus,
    form textarea:focus {
        border-color: #66afe9;
        outline: none;
    }
    
    #tags-container .tag-item,
    #search-tags-container .tag-item {
        width: 48%;
    }
    
    button {
        padding: 8px 16px;
        margin: 10px 5px 0 0;
        border: none;
        border-radius: 5px;
        background-color: #4CAF50;
        color: white;
        font-family: "Roboto", serif;
        font-weight: 600;
        cursor: pointer;
        transition: background-color 0.3s ease;
    }
    
    button:hover {
        background-color: #45a049;
    }
    
    button:disabled {
        background-color: #cccccc;
        cursor: not-allowed;
    }
    
    #pagination-controls {
        display: flex;
        justify-content: center;
        align-items: center;
        padding: 20px;
        gap: 10px;
        animation: fadeIn 0.5s ease;
    }
    
    #pagination-controls button {
        padding: 8px 16px;
        background-color: #008CBA;
    }
    
    #pagination-controls button:hover:not(:disabled) {
        background-color: #007B9E;
    }
    
    #pagination-controls button:disabled {
        background-color: #cccccc;
        cursor: not-allowed;
    }
    
    #pagination-controls span {
        font-size: 16px;
        color: #333;
    }
    
    @keyframes fadeIn {
        from { opacity: 0; }
        to { opacity: 1; }
    }
    
    @keyframes slideDown {
        from { transform: translateY(-50px); opacity: 0; }
        to { transform: translateY(0); opacity: 1; }
    }
    
    @media (max-width: 768px) {
        #search-form {
            flex-direction: column;
            align-items: stretch;
        }
    
        #tags-container .tag-item,
        #search-tags-container .tag-item {
            width: 100%;
        }
    
        .track-tile {
            width: 100%;
        }
    
        header h1 {
            font-size: 24px;
        }
    
        #add-track-button {
            padding: 8px 16px;
            font-size: 14px;
        }
    }
    

    3. Summary of Changes

    1. Backend:

      • Enhanced the /tracks/search endpoint to support searching by name, description, and tags with pagination.
      • Updated the search_tracks method in database.py to prioritize tracks matching the name and implement pagination.
    2. Frontend:

      • Added a search section in index.html with inputs for name, description, and dynamic tags.
      • Introduced pagination controls with Previous and Next buttons and indicators for the current and total pages.
      • Updated app.js to handle searching, pagination, and dynamic content loading with animations.
      • Enhanced styles.css to style the search section, pagination controls, and implement smooth animations for better user experience.

    4. Additional Recommendations

    • Loading Indicators: Consider adding a loading spinner or indicator while fetching data to improve user experience during network delays.

    • Validation: Implement frontend validation for search inputs to prevent potential issues, such as excessively long queries.

    • Responsive Design: Ensure that all UI components are responsive and look good on various devices by testing and refining the CSS as needed.

    • Error Handling: Enhance error messages to be more descriptive and user-friendly, possibly using modal dialogs instead of alert for a smoother experience.

    • Accessibility: Ensure that all interactive elements are accessible via keyboard and screen readers to make your website more inclusive.

    By following the above steps and integrating the provided code snippets, your LitMusic website will now support efficient pagination and a robust search functionality, offering users a seamless and aesthetically pleasing experience.