488 lines
16 KiB
Python
Executable File
488 lines
16 KiB
Python
Executable File
# -*- coding: utf-8 -*-
|
|
#########################################################
|
|
# 고정영역
|
|
#########################################################
|
|
# python
|
|
import os
|
|
import sys
|
|
import traceback
|
|
import json
|
|
|
|
# third-party
|
|
from flask import (
|
|
Blueprint,
|
|
request,
|
|
Response,
|
|
render_template,
|
|
redirect,
|
|
jsonify,
|
|
url_for,
|
|
send_from_directory,
|
|
)
|
|
from flask_login import login_required
|
|
from flask_socketio import SocketIO, emit, send
|
|
|
|
# sjva 공용
|
|
from framework.logger import get_logger
|
|
from framework import app, db, scheduler, socketio, path_app_root
|
|
from framework.util import Util, AlchemyEncoder
|
|
from system.logic import SystemLogic
|
|
|
|
|
|
# 패키지
|
|
|
|
from .logic import Logic
|
|
from .logic_inflearn import LogicInflearn
|
|
from .logic_queue import QueueEntity, LogicQueue
|
|
from .model import ModelSetting, ModelInflearn
|
|
|
|
# blueprint = Blueprint(package_name,
|
|
# package_name,
|
|
# url_prefix='/%s' % package_name,
|
|
# template_folder=os.path.join(os.path.dirname(__file__),
|
|
# 'templates'))
|
|
|
|
package_name = __name__.split(".")[0]
|
|
logger = get_logger(package_name)
|
|
|
|
#########################################################
|
|
# 플러그인 공용
|
|
#########################################################
|
|
blueprint = Blueprint(
|
|
package_name,
|
|
package_name,
|
|
url_prefix="/%s" % package_name,
|
|
template_folder=os.path.join(os.path.dirname(__file__), "templates"),
|
|
static_folder=os.path.join(os.path.dirname(__file__), "static"),
|
|
)
|
|
|
|
|
|
def plugin_load():
|
|
Logic.plugin_load()
|
|
|
|
|
|
def plugin_unload():
|
|
Logic.plugin_unload()
|
|
|
|
|
|
# 메뉴 구성.
|
|
menu = {
|
|
"main": [package_name, "inflearn"],
|
|
"sub": [
|
|
["setting", "설정"],
|
|
["request", "요청"],
|
|
["category", "검색"],
|
|
["queue", "큐"],
|
|
["excel", "액셀"],
|
|
["list", "목록"],
|
|
["log", "로그"],
|
|
],
|
|
"category": "vod",
|
|
# 'sub2': {
|
|
# 'linkkf-yommi': [
|
|
# ['setting', u'설정'], ['request', u'요청'], ['queue', u'큐'], ['list', u'목록']
|
|
# ],
|
|
# }
|
|
}
|
|
|
|
plugin_info = {
|
|
"version": "0.0.1.0",
|
|
"name": "inflearn",
|
|
"category_name": "vod",
|
|
"icon": "",
|
|
"developer": "projectdx",
|
|
"description": "인프런 강좌 사이트 에서 강좌 다운로드",
|
|
"home": "https://github.com/projectdx75/linkkf-yommi",
|
|
"more": "",
|
|
}
|
|
|
|
|
|
#########################################################
|
|
|
|
|
|
# def plugin_load():
|
|
# Logic.plugin_load()
|
|
# #
|
|
# # LogicQueue.queue_load()
|
|
#
|
|
#
|
|
# def plugin_unload():
|
|
# Logic.plugin_unload()
|
|
|
|
|
|
#########################################################
|
|
# WEB Menu
|
|
#########################################################
|
|
@blueprint.route("/")
|
|
def home():
|
|
# return redirect('/%s/setting' % package_name)
|
|
return redirect("/%s/category" % package_name)
|
|
|
|
|
|
@blueprint.route("/<sub>", methods=["GET", "POST"])
|
|
@login_required
|
|
def detail(sub):
|
|
# arg = {
|
|
# "package_name": package_name,
|
|
# "template_name": "%s_%s" % (package_name, sub),
|
|
# }
|
|
if sub == "setting":
|
|
setting_list = db.session.query(ModelSetting).all()
|
|
arg = Util.db_list_to_dict(setting_list)
|
|
arg["package_name"] = package_name
|
|
arg["sub"] = "setting"
|
|
arg["scheduler"] = str(scheduler.is_include(package_name))
|
|
arg["is_running"] = str(scheduler.is_running(package_name))
|
|
arg["template_name"] = "%s_%s" % (package_name, sub)
|
|
return render_template("%s_%s.html" % (package_name, sub), arg=arg)
|
|
elif sub == "request":
|
|
setting_list = db.session.query(ModelSetting).all()
|
|
arg = Util.db_list_to_dict(setting_list)
|
|
arg["package_name"] = package_name
|
|
logger.debug(f"current_code: {LogicInflearn.current_data}")
|
|
arg["current_code"] = (
|
|
LogicInflearn.current_data["code"]
|
|
if LogicInflearn.current_data is not None
|
|
else ""
|
|
)
|
|
|
|
# arg["template_name"] = "%s_%s" % (package_name, sub)
|
|
arg["template_name"] = f"{package_name}_{sub}"
|
|
|
|
logger.debug(f"arg: {arg}")
|
|
return render_template("%s_%s.html" % (package_name, sub), arg=arg)
|
|
|
|
elif sub in ["queue", "list"]:
|
|
setting_list = db.session.query(ModelSetting).all()
|
|
arg = Util.db_list_to_dict(setting_list)
|
|
arg["package_name"] = package_name
|
|
logger.debug(f"current_code: {LogicInflearn.current_data}")
|
|
arg["current_code"] = (
|
|
LogicInflearn.current_data["code"]
|
|
if LogicInflearn.current_data is not None
|
|
else ""
|
|
)
|
|
|
|
# arg["template_name"] = "%s_%s" % (package_name, sub)
|
|
arg["template_name"] = f"{package_name}_{sub}"
|
|
|
|
logger.debug(f"arg: \n{arg}")
|
|
return render_template("%s_%s.html" % (package_name, sub), arg=arg)
|
|
elif sub == "category":
|
|
|
|
setting_list = db.session.query(ModelSetting).all()
|
|
arg = Util.db_list_to_dict(setting_list)
|
|
arg["package_name"] = package_name
|
|
arg["template_name"] = "%s_%s" % (package_name, sub)
|
|
# logger.debug(f"arg:: {arg}")
|
|
return render_template("%s_%s.html" % (package_name, sub), arg=arg)
|
|
elif sub == "excel":
|
|
|
|
setting_list = db.session.query(ModelSetting).all()
|
|
arg = Util.db_list_to_dict(setting_list)
|
|
arg["package_name"] = package_name
|
|
arg["template_name"] = "%s_%s" % (package_name, sub)
|
|
# logger.debug(f"arg:: {arg}")
|
|
return render_template("%s_%s.html" % (package_name, sub), arg=arg)
|
|
elif sub == "log":
|
|
return render_template("log.html", package=package_name)
|
|
return render_template("sample.html", title="%s - %s" % (package_name, sub))
|
|
|
|
|
|
#########################################################
|
|
# For UI (보통 웹에서 요청하는 정보에 대한 결과를 리턴한다.)
|
|
#########################################################
|
|
@blueprint.route("/ajax/<sub>", methods=["GET", "POST"])
|
|
def ajax(sub):
|
|
logger.debug("AJAX %s %s", package_name, sub)
|
|
if sub == "setting_save":
|
|
try:
|
|
ret = Logic.setting_save(request)
|
|
return jsonify(ret)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
elif sub == "scheduler":
|
|
go = request.form["scheduler"]
|
|
logger.debug("scheduler :%s", go)
|
|
if go == "true":
|
|
Logic.scheduler_start()
|
|
else:
|
|
Logic.scheduler_stop()
|
|
return jsonify(go)
|
|
# 요청
|
|
elif sub == "analysis":
|
|
try:
|
|
|
|
code = request.form["code"]
|
|
data = LogicInflearn.get_title_info(code)
|
|
# logger.debug("data::> %s", data)
|
|
LogicInflearn.current_data = data
|
|
|
|
# return jsonify(data)
|
|
# logger.debug(data)
|
|
if data["ret"] == "error":
|
|
return jsonify(data)
|
|
else:
|
|
return jsonify({"ret": "success", "data": data})
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
# except IndexError as e:
|
|
# logger.error("Exception:%s", e)
|
|
# logger.error(traceback.format_exc())
|
|
return jsonify({"ret": "error", "log": e})
|
|
elif sub == "excel_list":
|
|
try:
|
|
data = LogicInflearn.get_excel_info()
|
|
logger.debug(f"data[]: {data}")
|
|
return jsonify({"ret": "success", "data": data})
|
|
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
return jsonify({"ret": "error", "log": e})
|
|
|
|
elif sub == "search":
|
|
try:
|
|
query = request.form["query"]
|
|
logger.debug("query::>> %s", query)
|
|
data = LogicInflearn.get_search_result(str(query))
|
|
|
|
return jsonify(data)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
# elif sub == "anime_list":
|
|
# try:
|
|
# # logger.debug(request.form)
|
|
# page = request.form["page"]
|
|
# cate = request.form["type"]
|
|
# # data = LogicLinkkfYommi.get_screen_movie_info(page)
|
|
# data = LogicInflearn.get_lecture_list_info(cate, page)
|
|
# dummy_data = {"ret": "success", "data": data}
|
|
# return jsonify(data)
|
|
# except Exception as e:
|
|
# logger.error("Exception:%s", e)
|
|
# logger.error(traceback.format_exc())
|
|
elif sub == "get_lecture_list":
|
|
try:
|
|
# logger.debug(request.form)
|
|
page = request.form["page"]
|
|
cate = request.form["type"]
|
|
data = LogicInflearn.get_lecture_list_info(cate, page)
|
|
# dummy_data = {"ret": "success", "data": data}
|
|
logger.debug(f"lecture_list:: {data}")
|
|
return jsonify(data)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
|
|
elif sub == "screen_movie_list":
|
|
try:
|
|
logger.debug("request:::> %s", request.form["page"])
|
|
page = request.form["page"]
|
|
data = LogicInflearn.get_screen_movie_info(page)
|
|
dummy_data = {"ret": "success", "data": data}
|
|
return jsonify(data)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
elif sub == "complete_anilist":
|
|
try:
|
|
logger.debug("request:::> %s", request.form["page"])
|
|
page = request.form["page"]
|
|
data = LogicInflearn.get_complete_anilist_info(page)
|
|
dummy_data = {"ret": "success", "data": data}
|
|
return jsonify(data)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
elif sub == "apply_new_title":
|
|
try:
|
|
new_title = request.form["new_title"]
|
|
ret = LogicInflearn.apply_new_title(new_title)
|
|
return jsonify(ret)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
elif sub == "apply_new_season":
|
|
try:
|
|
new_season = request.form["new_season"]
|
|
ret = LogicInflearn.apply_new_season(new_season)
|
|
return jsonify(ret)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
elif sub == "add_whitelist":
|
|
try:
|
|
# params = request.get_data()
|
|
# logger.debug(f"params: {params}")
|
|
# data_code = request.args.get("data_code")
|
|
params = request.get_json()
|
|
logger.debug(params)
|
|
if params is not None:
|
|
code = params["data_code"]
|
|
logger.debug(f"params: {code}")
|
|
ret = LogicInflearn.add_whitelist(code)
|
|
else:
|
|
ret = LogicInflearn.add_whitelist()
|
|
return jsonify(ret)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
elif sub == "add_download":
|
|
# logger.debug("add_download:: %s", request.form)
|
|
ret = LogicInflearn.download(request.form)
|
|
return jsonify(ret)
|
|
elif sub == "add_queue":
|
|
try:
|
|
ret = {}
|
|
# info = json.loads(request.form["data"])
|
|
# logger.info("test::", info)
|
|
# logger.info("_id", info["_id"])
|
|
# return False
|
|
|
|
code = request.form["code"]
|
|
# 해당 code로 db조회후 info 변수에 담는다
|
|
info = LogicInflearn.get_info_by_code(code)
|
|
# info = LogicLinkkfYommi.get_info_by_code(info)
|
|
# logger.debug(info)
|
|
# return False
|
|
|
|
logger.debug(f"info::> {info}")
|
|
|
|
# ret["ret"] = "debugging"
|
|
|
|
if info is not None:
|
|
from .logic_queue import LogicQueue
|
|
|
|
tmp = LogicQueue.add_queue(info)
|
|
logger.debug("add_queue : tmp >> %s", tmp)
|
|
# ret["ret"] = "success" if tmp else "fail"
|
|
ret["ret"] = tmp
|
|
else:
|
|
ret["ret"] = "no_data"
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
ret["ret"] = "fail"
|
|
ret["log"] = str(e)
|
|
return jsonify(ret)
|
|
elif sub == "add_queue_checked_list":
|
|
ret = {}
|
|
infos = {"code": request.form["lecture_id"]}
|
|
try:
|
|
from .logic_queue import LogicQueue
|
|
|
|
code = request.form["code"]
|
|
logger.debug("code:: %s", code)
|
|
code_list = code.split(",")
|
|
logger.debug(f"code_list[]: {code_list}")
|
|
count = 0
|
|
for c in code_list:
|
|
info = LogicInflearn.get_info_by_code(c)
|
|
if info is not None:
|
|
infos["data"] = info
|
|
tmp = LogicQueue.add_checked_youtube_queue(infos)
|
|
count += 1
|
|
ret["ret"] = "success"
|
|
ret["log"] = str(count)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
ret["ret"] = "fail"
|
|
ret["log"] = str(e)
|
|
return jsonify(ret)
|
|
# 큐
|
|
elif sub == "program_auto_command":
|
|
try:
|
|
from .logic_queue import LogicQueue
|
|
|
|
ret = LogicQueue.program_auto_command(request)
|
|
return jsonify(ret)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
|
|
elif sub == "web_list":
|
|
try:
|
|
# # logger.info(request)
|
|
# data = []
|
|
# logger.info("db :::>", ModelLinkkf.web_list(request))
|
|
data = [{}]
|
|
dummy_data = {"ret": "success", "method": "web_list", "data": data}
|
|
return jsonify(ModelInflearn.web_list(request))
|
|
# return jsonify(dummy_data)
|
|
except Exception as e:
|
|
logger.error("Exception: %s", e)
|
|
logger.error(traceback.format_exc())
|
|
elif sub == "db_remove":
|
|
return jsonify(ModelInflearn.delete_by_id(request.form["id"]))
|
|
# reset_db
|
|
elif sub == "reset_db":
|
|
ret = {}
|
|
res = False
|
|
try:
|
|
res = LogicInflearn.reset_db()
|
|
if res:
|
|
ret["ret"] = "success"
|
|
|
|
return jsonify(ret)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
|
|
|
|
#########################################################
|
|
# API
|
|
#########################################################
|
|
@blueprint.route("/api/<sub>", methods=["GET", "POST"])
|
|
def api(sub):
|
|
logger.debug("api %s %s", package_name, sub)
|
|
|
|
|
|
#########################################################
|
|
# socketio
|
|
#########################################################
|
|
sid_list = []
|
|
|
|
|
|
@socketio.on("connect", namespace="/%s" % package_name)
|
|
def connect():
|
|
try:
|
|
sid_list.append(request.sid)
|
|
tmp = None
|
|
from .logic_queue import QueueEntity
|
|
|
|
data = [_.__dict__ for _ in QueueEntity.entity_list]
|
|
tmp = json.dumps(data, cls=AlchemyEncoder)
|
|
tmp = json.loads(tmp)
|
|
emit("on_connect", tmp, namespace="/%s" % package_name)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
|
|
|
|
@socketio.on("disconnect", namespace="/%s" % package_name)
|
|
def disconnect():
|
|
try:
|
|
sid_list.remove(request.sid)
|
|
except Exception as e:
|
|
logger.error("Exception:%s", e)
|
|
logger.error(traceback.format_exc())
|
|
|
|
|
|
def socketio_callback(cmd, data):
|
|
if sid_list:
|
|
tmp = json.dumps(data, cls=AlchemyEncoder)
|
|
tmp = json.loads(tmp)
|
|
socketio.emit(cmd, tmp, namespace="/%s" % package_name, broadcast=True)
|
|
|
|
|
|
def socketio_list_refresh():
|
|
data = [_.__dict__ for _ in QueueEntity.entity_list]
|
|
tmp = json.dumps(data, cls=AlchemyEncoder)
|
|
tmp = json.loads(tmp)
|
|
socketio_callback("list_refresh", tmp)
|