Merge branch 'Docker' into Dev

# Conflicts:
#	main.py

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3
+ADD main.py /
+ADD requirements.txt /
+ADD templates /templates
+
+VOLUME /download/
+
+RUN pip install -r requirements.txt
+RUN pip install manga-py
+
+
+
+CMD ["python", "./main.py"]

Downloader.py

@@ -1,67 +0,0 @@
-from manga_py1.parser import Parser
-from manga_py1.info import Info
-
-
-my_awesome_handler = open('my-handler')
-
-
-class MyAwesomeInfo(Info):
-    pass
-
-
-# main class (you will have your own)
-class MyAwesomeClass:
-    args = {}
-    """
-    is just a Namespace or dict with arguments
-     (filled below. You can implement your implementation. The main thing is to have all keys possible)
-    see manga_py.cli.args.get_cli_arguments()
-    """
-
-    parser = None  # the found parser gets here (see below)
-
-    def get_info(self):
-        MyAwesomeInfo(self.args)  # use the Info class from manga-py or overload the Info class from manga-py
-
-    def start(self):
-        self.parser = Parser(self.args)
-        try:
-            self.parser.init_provider(
-                progress=self.progress,
-                log=self.print,
-                quest=self.quest,
-                quest_password=self.quest_password,
-                info=self.get_info(),
-            )
-        except AttributeError as e:
-            raise e
-        self.parser.start()  # provider main method
-
-    def progress(self, items_count: int, current_item: int, re_init: bool = False): # the same progress function. re_init = True means "next chapter"
-        # simple progress
-        pass
-
-    def print(self, text, **kwargs):
-        """
-        Not used everywhere. Better reload global print method
-        """
-        print(text, **kwargs, file=my_awesome_handler)
-
-    def quest(self, variants: enumerate, title: str, select_type=0):  # 0 = single, 1 = multiple
-        if select_type == 0:
-            print(' Question ')
-            return 'Answer'
-        else:
-            print(' Question multiple answers')
-            return [
-                'Answer 1',
-                'Answer 2',
-                ...
-            ]
-
-    def quest_password(self, title):
-        """
-        used to ask user password
-        """
-        print(title)
-        return 'my_awesome_password'

main.py

@@ -1,64 +1,86 @@
-import sqlalchemy as db
+from flask_sqlalchemy import SQLAlchemy
+from flask import Flask, jsonify, render_template, request
 import json
-# from  manga_py1.parser import Parser
-# from manga_py1.info import Info
-# from Downloader import my_awesome_handler
 import os
+import subprocess
+from waitress import serve
 
+PATH = '/download'
+
+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():
-    db_URI = 'mysql+pymysql://mdownload:mdownload@192.168.86.198:3306/Downloads'
+    updated = []
 
-    engine = db.create_engine(db_URI)
+    result = db.session.query(manga, url_metadata).filter_by(active=1).join(url_metadata, manga.url_flag==url_metadata.flag).all()
-    con = engine.connect()
 
-    metadata = db.MetaData()
+    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'
 
-    url_metadata = db.Table('url_metadata', metadata, autoload = True, autoload_with= engine)
+        # os.system(execute)
-    manga = db.Table('manga', metadata, autoload=True, autoload_with=engine)
+        # exec_command = subprocess.Popen(execute, stdout=subprocess.PIPE)
-    # query = db.select([manga.columns.url, url_metadata.columns.base_url, manga.columns.url_flag])
+        # book['output'] = exec_command.communicate()
-    query = db.text(""" select manga.url, url_metadata.base_url , manga.name from manga join url_metadata on manga.url_flag = url_metadata.flag """)
+        exec_command.communicate()
-    result = con.execute(query).fetchall()
+        book['command'] = exec_command.args
-    y=0
-    url = []
-    base = []
-    name = []
-    PATH = '/Volumes/Manga'
-    # PATH = 'smb://MediaServer._smb._tcp.local/Downloads/Manga/'
-    for x in result:
-        # print(result[y][0])
-        url.append(result[y][0])
-        base.append(result[y][1])
-        name.append(result[y][2])
 
-        # print(base[y]+url[y])
+        updated.append(book)
-        query = """ select active from manga where manga_id = """ + str(y+1)
-        try:
-            active = con.execute(query).fetchone()
-        except engine.Error as e:
-            if 'MySQL server has gone away' in str(e):
-                con = engine.connect()
 
-        if active[0] != 0:
+    missing = check(passin=1)
-            print("""manga-py """ + base[y]+url[y] + """ -n \"""" + name[y] + """\" -d \"""" + PATH + """\" -z -g """)
+    return jsonify(manga=updated, missingFlags=missing[0], missingManga=missing[1])
-            execute = """manga-py """ + base[y]+url[y] + """ -n \"""" + name[y] + """\" -d \"""" + PATH + """\" -z -N """
-            os.system(execute)
-        y = y+1
 
+@app.route('/upload', methods=['GET'])
 def upload_jason():
     url = []
     base = []
     name = []
     y = 0
     z = 0
+    added = []
 
-    db_URI = 'mysql+pymysql://mdownload:mdownload@192.168.86.198:3306/Downloads'
+    with open(PATH+"/tach.json", "r") as tf:
-
+    # with open("tach.json", "r") as tf:
-    engine = db.create_engine(db_URI)
-    con = engine.connect()
-    metadata = db.MetaData()
-    manga = db.Table('manga', metadata, autoload=True, autoload_with=engine)
-
-    with open("tach.json", "r") as tf:
         data = json.load(tf)
         for x in data["mangas"]:
             # Manga Name
@@ -68,27 +90,147 @@ def upload_jason():
             # Mange Base URL
             base.append(data["mangas"][y]["manga"][2])
             y=y+1
-        # query = """ Delete from manga"""
-        # con.execute(query)
-        # query = """ Alter table manga auto_increment = 1 """
-        # con.execute(query)
-        for x in name:
-            query = """select name from manga where name = \"""" + name[z] + """\""""
-            exists = con.execute(query).fetchone()
-            if exists == None  or exists[0] != name[z]:
-                query = """ insert into manga(name, url, url_flag, view_format, unknown_value) values (\"""" + name[z] + """\",\"""" + url[z] + """\",\"""" + str(base[z]) + """\",\"0\",\"0\")"""
-                print(query)
-                con.execute(query)
-            else:
-                continue
-            z=z+1
 
-while True:
+        for each in name:
-    print("1. Download \n 2. Upload\n 3. Exit")
+            # print('start')
-    val = input(">>>")
+            if not manga.query.filter_by(name=name[z]).first():
-    if val == "1":
+                new_manga={}
-        download()
+                query = manga(name=name[z], url=url[z], url_flag=str(base[z]), view_format=0, unknown_value=0)
-    elif val == "2":
+                new_manga['title'] = name[z]
-        upload_jason()
+                added.append(new_manga)
-    elif val == "3":
+                db.session.add(query)
-        exit()
+            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 + "/tach.json", "r") as tf:
+        # with open("tach.json", "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 + "/tach.json", "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)

requirements.txt

@@ -0,0 +1,26 @@
+aiocontextvars==0.2.2
+certifi==2020.4.5.1
+chardet==3.0.4
+click==7.1.1
+colorama==0.4.3
+contextvars==2.4
+cssselect==1.1.0
+Flask==1.1.2
+Flask-SQLAlchemy==2.4.1
+idna==2.9
+immutables==0.11
+itsdangerous==1.1.0
+Jinja2==2.11.2
+loguru==0.4.1
+lxml==4.5.0
+MarkupSafe==1.1.1
+Pillow==7.1.1
+PyMySQL==0.9.3
+requests==2.23.0
+SQLAlchemy==1.3.16
+style==1.1.6
+update==0.0.1
+urllib3==1.25.9
+waitress==1.4.3
+Werkzeug==1.0.1
+win32-setctime==1.0.1

templates/index.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+</head>
+<body>
+ <button>Butttttton</button>
+</body>
+</html>