add server code

server/app/api.py

@@ -0,0 +1,335 @@
+import os
+from re import sub
+import requests
+import urllib
+import time
+
+
+from progress.bar import Bar
+from mutagen.flac import MutagenError
+from flask import Blueprint, request, send_from_directory
+
+from app.models import AllSongs, Folders, Artists
+from app.configs import default_configs
+
+from app.helpers import (
+    all_songs_instance,
+    convert_one_to_json,
+    getTags,
+    convert_to_json,
+    remove_duplicates,
+    save_image,
+    isValidFile,
+    create_config_dir,
+    extract_thumb,
+    home_dir, app_dir,
+    run_fast_scandir
+)
+
+bp = Blueprint('api', __name__, url_prefix='')
+
+artist_instance = Artists()
+folder_instance = Folders()
+
+
+def main_whatever():
+    create_config_dir()
+
+
+main_whatever()
+
+
+@bp.route('/search')
+def search_by_title():
+    if not request.args.get('q'):
+        query = "mexican girl"
+    else:
+        query = request.args.get('q')
+
+    songs = all_songs_instance.find_song_by_title(query)
+    all_songs = convert_to_json(songs)
+
+    albums = all_songs_instance.find_songs_by_album(query)
+    all_songs.append(convert_to_json(albums))
+
+    artists = all_songs_instance.find_songs_by_artist(query)
+    all_songs.append(convert_to_json(artists))
+
+    songs = remove_duplicates(all_songs)
+
+    return {'songs': songs}
+
+
+@bp.route('/populate')
+def populate():
+    sub_dirs, files = run_fast_scandir(home_dir, [".flac", ".mp3"])
+
+    bar = Bar('Processing', max=len(files))
+    for file in files:
+        file_in_db_obj = all_songs_instance.find_song_by_path(file)
+        song_obj = convert_one_to_json(file_in_db_obj)
+
+        try:
+            image = song_obj['image']
+        except:
+            image = None
+
+        if image is None:
+            try:
+                getTags(file)
+            except MutagenError:
+                pass
+
+        if image is not None and not os.path.exists(image):
+
+            extract_thumb(file)
+
+        bar.next()
+
+    bar.finish()
+
+    # dirs = []
+    # files = []
+
+    # for dir in sub_dirs:
+
+    #     files_in_dir = run_fast_scandir(dir, [".flac", ".mp3"])[1]
+
+    #     if len(files_in_dir) != 0:
+    #         dir_content = os.scandir(dir)
+
+    #         for entry in dir_content:
+    #             dirs = []
+    #             files = []
+
+    #             if entry.is_dir() and not entry.name.startswith('.'):
+    #                 print(dir)
+    #                 files_in_dir = run_fast_scandir(entry.path, [".flac", ".mp3"])[1]
+
+    #                 if len(files_in_dir) != 0:
+    #                     dir_data = {
+    #                         "name": entry.name,
+    #                         "count": len(files_in_dir),
+    #                         "path": entry.path.replace(home_dir, "")
+    #                     }
+
+    #                     dirs.append(dir_data)
+
+    #             if entry.is_file():
+    #                 if isValidFile(entry.name) == True:
+    #                     files.append(entry.path)
+
+    #             print(dirs)
+
+    # return {"info": ''}
+
+
+@bp.route('/file/<file_id>')
+def send_audio(file_id):
+    song_obj = all_songs_instance.get_song_by_id(file_id)
+    loaded_song = convert_one_to_json(song_obj)
+
+    filepath = loaded_song['filepath'].split('/')[-1]
+    print(loaded_song['folder'] + filepath)
+
+    return send_from_directory(home_dir + loaded_song['folder'], filepath)
+
+
+@bp.route("/folder/artists")
+def get_folder_artists():
+    dir = request.args.get('dir')
+
+    songs = all_songs_instance.find_songs_by_folder(dir)
+    songs_array = convert_to_json(songs)
+    without_duplicates = remove_duplicates(songs_array)
+
+    artists = []
+
+    for song in without_duplicates:
+        this_artists = song['artists'].split(', ')
+
+        for artist in this_artists:
+            
+            if artist not in artists:
+                artists.append(artist)
+
+    final_artists = []
+
+    for artist in artists[:15]:
+        artist_obj = artist_instance.find_artists_by_name(artist)
+
+        if artist_obj != []:
+            final_artists.append(convert_to_json(artist_obj))
+
+    return {'artists': final_artists}
+
+
+@bp.route("/populate/images")
+def populate_images():
+    all_songs = all_songs_instance.get_all_songs()
+    songs_array = convert_to_json(all_songs)
+    remove_duplicates(songs_array)
+
+    artists = []
+
+    for song in songs_array:
+        this_artists = song['artists'].split(', ')
+
+        for artist in this_artists:
+            if artist not in artists:
+                artists.append(artist)
+
+    bar = Bar('Processing images', max=len(artists))
+    for artist in artists:
+        file_path = app_dir + '/images/artists/' + artist + '.jpg'
+
+        if not os.path.exists(file_path):
+            url = 'https://api.deezer.com/search/artist?q={}'.format(artist)
+            response = requests.get(url)
+            data = response.json()
+
+            try:
+                image_path = data['data'][0]['picture_xl']
+            except:
+                image_path = None
+
+            if image_path is not None:
+                try:
+                    save_image(image_path, file_path)
+                    artist_obj = {
+                        'name': artist
+                    }
+
+                    artist_instance.insert_artist(artist_obj)
+                except:
+                    pass
+        else:
+            pass
+
+        bar.next()
+
+    bar.finish()
+
+    artists_in_db = artist_instance.get_all_artists()
+    artists_in_db_array = convert_to_json(artists_in_db)
+
+    return {'sample': artists_in_db_array[:25]}
+
+
+@bp.route("/artist")
+def getArtistData():
+    artist = urllib.parse.unquote(request.args.get('q'))
+    artist_obj = artist_instance.find_artists_by_name(artist)
+    artist_obj_json = convert_to_json(artist_obj)
+
+    def getArtistSongs():
+        songs = all_songs_instance.find_songs_by_artist(artist)
+        songs_array = convert_to_json(songs)
+
+        return songs_array
+
+    artist_songs = getArtistSongs()
+    songs = remove_duplicates(artist_songs)
+
+    def getArtistAlbums():
+        artist_albums = []
+        albums_with_count = []
+
+        albums = all_songs_instance.find_songs_by_album_artist(artist)
+        albums_array = convert_to_json(albums)
+
+        for song in songs:
+            song['artists'] = song['artists'].split(', ')
+
+        for song in albums_array:
+            if song['album'] not in artist_albums:
+                artist_albums.append(song['album'])
+
+        for album in artist_albums:
+            count = 0
+            length = 0
+
+            for song in artist_songs:
+                if song['album'] == album:
+                    count = count + 1
+                    length = length + song['length']
+
+            album_ = {
+                "title": album,
+                "count": count,
+                "length": length
+            }
+
+            albums_with_count.append(album_)
+
+        return albums_with_count
+
+    return {'artist': artist_obj_json, 'songs': songs, 'albums': getArtistAlbums()}
+
+
+@bp.route("/")
+def getFolderTree():
+    start = time.time()
+
+    req_dir = request.args.get('f')
+
+    if req_dir is not None:
+        requested_dir = home_dir + req_dir
+    else:
+        requested_dir = home_dir
+
+    dir_content = os.scandir(requested_dir)
+
+    folders = []
+    files = []
+
+    for entry in dir_content:
+        if entry.is_dir() and not entry.name.startswith('.'):
+            files_in_dir = run_fast_scandir(entry.path, [".flac", ".mp3"])[1]
+            
+            if len(files_in_dir) != 0:
+                dir = {
+                    "name": entry.name,
+                    "count": len(files_in_dir),
+                    "path": entry.path.replace(home_dir, "")
+                }
+
+                folders.append(dir)
+
+        if entry.is_file():
+            if isValidFile(entry.name) == True:
+                songs_array = all_songs_instance.find_songs_by_folder(req_dir)
+                songs = convert_to_json(songs_array)
+                for song in songs:
+                    song['artists'] = song['artists'].split(', ')
+
+                files = songs
+
+    for file in files:
+        del file['filepath']
+
+    dir_content.close()
+    end = time.time()
+    print(end - start)
+    return {"requested": req_dir, "files": files[:25], "folders": folders}
+
+
+@bp.route('/image/<img_type>/<image_id>')
+def send_image(img_type, image_id):
+    if img_type == "thumbnail":
+        song_obj = all_songs_instance.get_song_by_id(image_id)
+        loaded_song = convert_one_to_json(song_obj)
+
+        img_dir = app_dir + "/images/thumbnails"
+        image = loaded_song['image']
+
+    if img_type == "artist":
+        artist_obj = artist_instance.get_artist_by_id(image_id)
+        artist = convert_one_to_json(artist_obj)
+
+        img_dir = app_dir + "/images/artists"
+
+        image = artist['name'] + ".jpg"
+        print(img_dir + image)
+
+    return send_from_directory(img_dir, image)