mangaDownloader/main.py

from flask_sqlalchemy import SQLAlchemy
from flask import Flask, jsonify, render_template, request
import json
import os
import subprocess
from waitress import serve

#variable path information for linux
PATH = '/download'
FILE = '/tach.json'

app = Flask(__name__,
            template_folder="templates")

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://mdownload:mdownload@192.168.86.198:3306/Downloads'

db = SQLAlchemy(app)


class downloaderSettings(db.Model):
    ID = db.Column(db.Integer, primary_key=True)
    path = db.Column(db.Text)


class manga(db.Model):
   manga_id = db.Column(db.Integer, primary_key=True)
   name = db.Column(db.Text)
   url = db.Column(db.Text)
   url_flag = db.Column(db.Text)
   view_format = db.Column(db.Integer)
   unknown_value = db.Column(db.Integer)
   active = db.Column(db.Boolean, default=1)


class url_metadata(db.Model):
    url_id = db.Column(db.Integer, primary_key=True)
    source_name = db.Column(db.VARCHAR(length=10000))
    flag = db.Column(db.Text)
    base_url = db.Column(db.VARCHAR(length=10000))

@app.route('/', methods=['GET'])
def index():
    return render_template("index.html")

@app.route('/download', methods=['GET'])
def download():
    updated = []
    notupdated = []
    result = db.session.query(manga, url_metadata).filter_by(active=1).join(url_metadata, manga.url_flag==url_metadata.flag).all()

    for each in result:
        book={}
        if 'http' in each.manga.name or 'https' in each.manga.url:
            # execute = """manga-py """ + each.manga.url + """ -n \"""" + each.manga.name + """\" -d \"""" + PATH + """\" -z -N --print-json"""
            exec_command = subprocess.Popen(['manga-py', each.manga.url, '-n', each.manga.name, '-d', PATH, '-z', '-N', '--print-json'], stdout=subprocess.PIPE)
        else:
            print('nothing')
            # execute = """manga-py """ + each.url_metadata.base_url+each.manga.url + """ -n \"""" + each.manga.name.strip('?') + """\" -d \"""" + PATH + """\" -z -N --print-json"""
            exec_command = subprocess.Popen(['manga-py', each.url_metadata.base_url+each.manga.url, '-n', each.manga.name.strip('?'), '-d', PATH, '-z', '-N', '--print-json'], stdout=subprocess.PIPE)
        book['title'] = each.manga.name
        # book['command'] = 'nothing'

        exec_command.communicate()
        # output = exec_command.stdout.readline()
        book['command'] = exec_command.args
        # if str(output) in 'No new chapters found':
        #     notupdated.append(book['title'] + 'not updated')
        updated.append(book)

    missing = check(passin=1)
    return jsonify(manga=updated, missingFlags=missing[0], missingManga=missing[1], notupdated=notupdated)

@app.route('/upload', methods=['GET'])
def upload_jason():
    url = []
    base = []
    name = []
    y = 0
    z = 0
    added = []

    with open(PATH + FILE, "r") as tf:
        data = json.load(tf)
        for x in data["mangas"]:
            # Manga Name
            name.append(data["mangas"][y]["manga"][1])
            # Mange URL
            url.append(data["mangas"][y]["manga"][0])
            # Mange Base URL
            base.append(data["mangas"][y]["manga"][2])
            y=y+1

        for each in name:
            # print('start')
            if not manga.query.filter_by(name=name[z]).first():
                new_manga={}
                query = manga(name=name[z], url=url[z], url_flag=str(base[z]), view_format=0, unknown_value=0)
                new_manga['title'] = name[z]
                added.append(new_manga)
                db.session.add(query)
            z = z + 1
        db.session.commit()
    return jsonify(added=added)


@app.route('/active', methods=['GET'])
def active():
    activbooks=[]

    result = manga.query.filter_by(active=1).all()

    for each in result:
        book={}
        book['id'] = each.manga_id
        book['title'] = each.name
        book['url'] = each.url
        book['url_flag'] = each.url_flag
        activbooks.append(book)

    return jsonify(active=activbooks)

@app.route('/check', methods=['GET'])
def check(passin=0):
    passin=passin
    missingManga = []
    missingFlags = []
    providerFlags = []
    mangaFlags = manga.query.with_entities(manga.url_flag).distinct()
    providerFlagResult = url_metadata.query.all()
    for each in providerFlagResult:
        providerFlags.append(each.flag)
    for each in mangaFlags:
        if each.url_flag not in providerFlags:
            missingFlags.append(each.url_flag)
    for each in missingFlags:
        mangaInfo = {}
        badManga = manga.query.filter_by(url_flag=each).all()
        for each in badManga:
            mangaInfo['name'] = each.name
            mangaInfo['url_flag'] = each.url_flag
            mangaInfo['active'] = each.active
        missingManga.append(mangaInfo)

    if passin == 1:
        return missingFlags, missingManga
    else:
        return jsonify(missingFlags=missingFlags, missingManga=missingManga)

@app.route('/add', methods=['PUT'])
def add():
    data = request.get_json()
    added = []

    if 'http' or 'https' not in data['url']:
        return jsonify(error='invalid url')
    if not manga.query.filter_by(name=data['name']).first():
        new_manga={}
        query = manga(name=data['name'], url=data['url'], url_flag='000000', view_format=0, unknown_value=0)
        new_manga['title'] = data['name']
        added.append(new_manga)
        db.session.add(query)
    db.session.commit()
    return jsonify(added=added)

@app.route('/upgrade', methods=['PUT'])
def upgrade():
    os.system('pip install --upgrade manga-py')
    return jsonify(status='manga-py upgrade ran')

@app.route('/ood', methods=['GET'])
def ood():
    updated = []
    unadded = []
    url = []
    base = []
    name = []
    y = 0
    z = 0

    with open(PATH + FILE, "r") as tf:
        data = json.load(tf)
        for x in data["mangas"]:
            # Manga Name
            name.append(data["mangas"][y]["manga"][1])
            # Mange URL
            url.append(data["mangas"][y]["manga"][0])
            # Mange Base URL
            base.append(data["mangas"][y]["manga"][2])
            y = y + 1

        for each in name:
            # print('start')
            if manga.query.filter_by(name=name[z]).first():
                result = manga.query.filter_by(name=name[z]).first()
                if result.url != url[z]:
                    new_manga={}
                    # print('----' + name[z])
                    # print(url[z])
                    # print(result.url)
                    # query = manga(name=name[z], url=url[z], url_flag=str(base[z]), view_format=0, unknown_value=0)
                    result.url = url[z]
                    new_manga['title'] = name[z]
                    updated.append(new_manga)
            else:
                new_manga = {}
                new_manga['title'] = name[z]
                unadded.append(new_manga)
            z = z + 1
            db.session.commit()
    return jsonify(updated=updated, unadded=unadded)

@app.route('/test', methods=['GET'])
def test():
    y = 0
    mangaInfo=[]
    mangaName = manga.query.all()

    with open(PATH + FILE, "r") as tf:
        data = json.load(tf)
        for x in data["mangas"]:
            watchedManga = {}
            # Manga Name
            watchedManga['name']=data["mangas"][y]["manga"][1]
            # Mange URL
            watchedManga['url']=data["mangas"][y]["manga"][0]
            # Mange Base URL
            watchedManga['base']=data["mangas"][y]["manga"][2]
            y = y + 1
            mangaInfo.append(watchedManga)
    return jsonify(mangaInfo)

if __name__ == "__main__":
    # app.run(host='0.0.0.0', debug=True)
    serve(app, host='0.0.0.0', port=8000)