class ModelSetting(db.Model):
__tablename__ = 'plugin_%s_setting' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
key = db.Column(db.String(100), unique=True, nullable=False)
value = db.Column(db.String, nullable=False)
def __init__(self, key, value):
self.key = key
self.value = value
def __repr__(self):
return repr(self.as_dict())
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
@staticmethod
def get(key):
try:
return db.session.query(ModelSetting).filter_by(key=key).first().value
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
class ModelGroup2(db.Model):
__tablename__ = '%s_group' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
created_time = db.Column(db.DateTime)
reserved = db.Column(db.JSON)
groupname = db.Column(db.String())
#schedulers = db.relationship('ModelScheduler2', backref='plugin_%s_scheduler2' % package_name, lazy=True)
schedulers = db.relationship('ModelScheduler2',
backref='groups',
lazy=True)
query = db.Column(db.String())
#schedulers = db.relationship('ModelScheduler2', secondary=group_scheduler2, backref=db.backref('ModelGroup2'))
def __init__(self):
self.created_time = datetime.now()
def __repr__(self):
return repr(self.as_dict())
def as_dict(self):
ret = {x.name: getattr(self, x.name) for x in self.__table__.columns}
ret['schedulers'] = []
for f in self.schedulers:
ret['schedulers'].append(f.as_dict())
return ret
@staticmethod
def get_list(by_dict=False):
try:
tmp = db.session.query(ModelGroup2).all()
if by_dict:
tmp = [x.as_dict() for x in tmp]
return tmp
except Exception, e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelSetting(db.Model):
__tablename__ = 'plugin_%s_setting' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
key = db.Column(db.String(100), unique=True, nullable=False)
value = db.Column(db.String, nullable=False)
def __init__(self, key, value):
self.key = key
self.value = value
def __repr__(self):
return repr(self.as_dict())
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
class ModelSetting(db.Model):
__tablename__ = '%s_setting' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
key = db.Column(db.String(100), unique=True, nullable=False)
value = db.Column(db.String, nullable=False)
def __init__(self, key, value):
self.key = key
self.value = value
def __repr__(self):
return repr(self.as_dict())
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
@staticmethod
def get(key):
try:
return db.session.query(ModelSetting).filter_by(key=key).first().value.strip()
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def get_int(key):
try:
return int(ModelSetting.get(key))
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def get_bool(key):
try:
return (ModelSetting.get(key) == 'True')
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def set(key, value):
try:
item = db.session.query(ModelSetting).filter_by(key=key).with_for_update().first()
if item is not None:
item.value = value.strip()
db.session.commit()
else:
db.session.add(ModelSetting(key, value.strip()))
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def to_dict():
try:
from framework.util import Util
return Util.db_list_to_dict(db.session.query(ModelSetting).all())
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def setting_save(req):
try:
for key, value in req.form.items():
if key in ['scheduler', 'is_running']:
continue
if key.startswith('tmp_'):
continue
logger.debug('Key:%s Value:%s', key, value)
entity = db.session.query(ModelSetting).filter_by(key=key).with_for_update().first()
entity.value = value
db.session.commit()
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
logger.debug('Error Key:%s Value:%s', key, value)
return False
@staticmethod
def get_list(key):
try:
value = ModelSetting.get(key)
values = [x.strip().strip() for x in value.replace('\n', '|').split('|')]
values = Util.get_list_except_empty(values)
return values
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
logger.error('Error Key:%s Value:%s', key, value)
class Episode(db.Model):
__tablename__ = 'plugin_%s_auto_episode' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
episode_code = db.Column(db.String(20), unique=False, nullable=False)
quality = db.Column(db.String(10), unique=False, nullable=False)
program_name = db.Column(db.String(30))
program_code = db.Column(db.String(20))
frequency = db.Column(db.Integer)
broadcast_date = db.Column(db.String(6))
channel_id = db.Column(db.String(10))
channel_name = db.Column(db.String(20))
duration = db.Column(db.Integer)
json = db.Column(db.JSON)
filename = db.Column(db.String(), unique=False, nullable=False)
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
download_time = db.Column(db.Integer)
completed = db.Column(db.Boolean)
user_abort = db.Column(db.Boolean)
pf_abort = db.Column(db.Boolean)
etc_abort = db.Column(db.Integer) #ffmpeg 원인 1, 채널, 프로그램
ffmpeg_status = db.Column(db.Integer)
temp_path = db.Column(db.String())
save_path = db.Column(db.String())
pf = db.Column(db.Integer)
retry = db.Column(db.Integer)
filesize = db.Column(db.Integer)
filesize_str = db.Column(db.String(10))
download_speed = db.Column(db.String(10))
call = db.Column(db.String(10))
vod_url = db.Column(db.String)
def __init__(self, call):
self.completed = False
self.user_abort = False
self.pf_abort = False
self.etc_abort = 0
self.ffmpeg_status = -1
self.pf = 0
self.retry = 0
self.call = call
def __repr__(self):
#return "<Episode(id:%s, episode_code:%s, quality:%s)>" % (self.id, self.episode_code, self.quality)
return repr(self.as_dict())
def as_dict(self):
ret = {x.name: getattr(self, x.name) for x in self.__table__.columns}
ret['start_time'] = self.start_time.strftime(
'%m-%d %H:%M:%S') if self.start_time is not None else ''
ret['end_time'] = self.end_time.strftime(
'%m-%d %H:%M:%S') if self.end_time is not None else ''
return ret
class ModelSetting(db.Model):
__tablename__ = 'plugin_%s_setting' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
key = db.Column(db.String(100), unique=True, nullable=False)
value = db.Column(db.String, nullable=False)
def __init__(self, key, value):
self.key = key
self.value = value
def __repr__(self):
return repr(self.as_dict())
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
@staticmethod
def get(key):
try:
return db.session.query(ModelSetting).filter_by(
key=key).first().value.strip()
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def get_int(key):
try:
return int(ModelSetting.get(key))
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def get_bool(key):
try:
return (ModelSetting.get(key) == 'True')
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def set(key, value):
try:
item = db.session.query(ModelSetting).filter_by(
key=key).with_for_update().first()
if item is not None:
item.value = '%s' % value.strip()
db.session.commit()
else:
db.session.add(ModelSetting(key, value.strip()))
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def to_dict():
try:
return Util.db_list_to_dict(db.session.query(ModelSetting).all())
except Exception as e:
logger.error('Exception:%s %s', e, key)
logger.error(traceback.format_exc())
class ModelOffcloud2Item(db.Model):
__tablename__ = '%s_rss' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
created_time = db.Column(db.DateTime)
reserved = db.Column(db.JSON)
job_id = db.Column(db.Integer, db.ForeignKey('%s_job.id' % package_name))
created_time = db.Column(db.DateTime)
title = db.Column(db.String())
link = db.Column(db.String())
status = db.Column(db.Integer)
remote_time = db.Column(db.DateTime)
completed_time = db.Column(db.DateTime)
oc_folderid = db.Column(db.String)
oc_requestId = db.Column(db.String)
oc_status = db.Column(db.String)
oc_createdOn = db.Column(db.String)
oc_fileName = db.Column(db.String)
oc_fileSize = db.Column(db.Integer)
oc_error = db.Column(db.String)
oc_retry_count = db.Column(db.Integer)
oc_cached = db.Column(db.Boolean)
oc_json = db.Column(db.JSON)
#job = db.relationship('ModelOffcloud2Job', lazy=True)
# DB Version 3
link_to_notify_status = db.Column(db.String) #1이면 보고함.
# DB Version 4
torrent_info = db.Column(db.JSON)
filename = db.Column(db.String)
dirname = db.Column(db.String)
filecount = db.Column(db.Integer)
def __init__(self):
self.created_time = datetime.datetime.now()
self.status = 0
self.oc_status = ''
self.oc_cached = False
def __repr__(self):
return repr(self.as_dict())
def as_dict(self):
ret = {x.name: getattr(self, x.name) for x in self.__table__.columns}
ret['created_time'] = self.created_time.strftime('%m-%d %H:%M:%S')
ret['remote_time'] = self.remote_time.strftime(
'%m-%d %H:%M:%S') if self.remote_time is not None else ''
ret['completed_time'] = self.completed_time.strftime(
'%m-%d %H:%M:%S') if self.completed_time is not None else ''
ret['job'] = self.job.as_dict()
try:
ret['oc_fileSize'] = Util.sizeof_fmt(
int(ret['oc_fileSize'])
) if ret['oc_fileSize'] is not None else ret['oc_fileSize']
except:
pass
return ret
def make_torrent_info(self):
try:
if self.job.use_tracer and self.torrent_info is None and self.link.startswith(
'magnet'):
from torrent_info import Logic as TorrentInfoLogic
tmp = TorrentInfoLogic.parse_magnet_uri(self.link)
if tmp is not None:
self.torrent_info = tmp
flag_modified(self, "torrent_info")
info = Util.get_max_size_fileinfo(tmp)
self.filename = u'%s' % info['filename']
self.dirname = u'%s' % info['dirname']
self.filecount = u'%s' % tmp['num_files']
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return False
@staticmethod
def get_rss_list_by_scheduler(job):
try:
query = db.session.query(ModelOffcloud2Item) \
.filter(ModelOffcloud2Item.job_id == job.id ) \
.filter(ModelOffcloud2Item.status < 11 ) \
.filter(ModelOffcloud2Item.created_time > datetime.datetime.now() + datetime.timedelta(days=job.cache_confirm_day*-1))
# \
#.filter(ModelOffcloud2Item.oc_status != 'NOSTATUS')
return query.all()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def remove(job_id):
try:
logger.debug('remove_job id:%s', job_id)
db.session.query(ModelOffcloud2Item).filter_by(
job_id=job_id).delete()
db.session.commit()
return 'success'
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return 'fail'
@staticmethod
def web_list(req):
try:
ret = {}
page = 1
page_size = 30
job_id = ''
search = ''
if 'page' in req.form:
page = int(req.form['page'])
if 'search_word' in req.form:
search = req.form['search_word']
job_select = 'all'
if 'job_select' in req.form:
job_select = req.form['job_select']
option = 'all'
if 'option' in req.form:
option = req.form['option']
query = ModelOffcloud2Item.make_query(job_name=job_select,
option=option,
search=search)
last_list_option_rss = '%s|%s|%s|%s' % (search, job_select, option,
page)
ModelSetting.set('last_list_option_rss', last_list_option_rss)
count = query.count()
query = (query.order_by(desc(
ModelOffcloud2Item.id)).limit(page_size).offset(
(page - 1) * page_size))
logger.debug('ModelOffcloud2Item count:%s', count)
lists = query.all()
ret['list'] = [item.as_dict() for item in lists]
ret['paging'] = Util.get_paging_info(count, page, page_size)
return ret
except Exception as e:
logger.debug('Exception:%s', e)
logger.debug(traceback.format_exc())
@staticmethod
def api_list(req):
try:
job = req.args.get('job')
option = req.args.get('option')
search = req.args.get('search')
count = req.args.get('count')
if count is None or count == '':
count = 100
query = ModelOffcloud2Item.make_query(job_name=job,
option=option,
search=search)
query = (query.order_by(desc(ModelOffcloud2Item.id)).limit(count))
lists = query.all()
return lists
except Exception as e:
logger.debug('Exception:%s', e)
logger.debug(traceback.format_exc())
@staticmethod
def make_query(job_name='all', option='all', search=''):
try:
query = db.session.query(ModelOffcloud2Item)
job = None
if job_name != 'all' and job_name is not None and job_name != '':
job = ModelOffcloud2Job.get_by_name(job_name)
query = query.filter_by(job_id=job.id)
if search is not None and search != '':
if search.startswith('magnet:?'): # 마그넷 검색을 위해서 추가한 부분
query = query.filter(
ModelOffcloud2Item.link.like(
'%' + search + '%')) # 마그넷 검색을 위해서 추가한 부분
elif search.find('|') != -1:
tmp = search.split('|')
conditions = []
for tt in tmp:
if tt != '':
conditions.append(
ModelOffcloud2Item.title.like('%' +
tt.strip() +
'%'))
query = query.filter(or_(*conditions))
elif search.find(',') != -1:
tmp = search.split(',')
for tt in tmp:
if tt != '':
query = query.filter(
ModelOffcloud2Item.title.like('%' +
tt.strip() +
'%'))
else:
query = query.filter(
ModelOffcloud2Item.title.like('%' + search + '%'))
if option == 'request_false':
query = query.filter(ModelOffcloud2Item.status < 6)
elif option == 'request':
query = query.filter(ModelOffcloud2Item.status < 11,
ModelOffcloud2Item.status >= 6)
elif option == 'completed':
query = query.filter_by(status=11)
elif option == 'expire':
if job is not None:
query = query.filter(
ModelOffcloud2Item.created_time <=
datetime.datetime.now() +
datetime.timedelta(days=job.cache_confirm_day * -1))
query = query.filter(ModelOffcloud2Item.status < 6)
pass
elif option == 'no_status':
query = query.filter(ModelOffcloud2Item.status >= 13)
return query
except Exception as e:
logger.debug('Exception:%s', e)
logger.debug(traceback.format_exc())
class ModelSetting(db.Model):
__tablename__ = '%s_setting' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
key = db.Column(db.String(100), unique=True, nullable=False)
value = db.Column(db.String, nullable=False)
def __init__(self, key, value):
self.key = key
self.value = value
def __repr__(self):
return repr(self.as_dict())
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
@staticmethod
def get(key):
try:
return db.session.query(ModelSetting).filter_by(
key=key).first().value.strip()
except Exception as e:
logger.error('[gallery-dl] Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def get_int(key):
try:
return int(ModelSetting.get(key))
except Exception as e:
logger.error('[gallery-dl] Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def get_bool(key):
try:
return (ModelSetting.get(key) == 'True')
except Exception as e:
logger.error('[gallery-dl] Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def set(key, value):
try:
item = db.session.query(ModelSetting).filter_by(
key=key).with_for_update().first()
if item is not None:
item.value = value.strip()
db.session.commit()
else:
db.session.add(ModelSetting(key, value.strip()))
except Exception as e:
logger.error('[gallery-dl] Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def to_dict():
try:
from framework.util import Util
return Util.db_list_to_dict(db.session.query(ModelSetting).all())
except Exception as e:
logger.error('[gallery-dl] Exception:%s %s', e, key)
logger.error(traceback.format_exc())
@staticmethod
def setting_save(req):
try:
for key, value in req.form.items():
if key in ['scheduler', 'is_running']:
continue
if key == "gallery-dl_option_value":
with open(
os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'gallery-dl.conf'), 'w') as gdl_conf:
gdl_conf.write(value)
gdl_conf.close()
else:
if key == 'interval':
value = str(int(value) * 60)
logger.debug('[gallery-dl] Key:%s Value:%s', key, value)
entity = db.session.query(ModelSetting).filter_by(
key=key).with_for_update().first()
entity.value = value
db.session.commit()
return True
except Exception as e:
logger.error('[gallery-dl] Exception:%s', e)
logger.error(traceback.format_exc())
logger.debug('Error Key:%s Value:%s', key, value)
return False
class ModelSetting(db.Model):
__tablename__ = 'system_setting'
id = db.Column(db.Integer, primary_key=True)
key = db.Column(db.String(100), unique=True, nullable=False)
value = db.Column(db.String(100), nullable=False)
def __init__(self, key, value):
self.key = key
self.value = value
def __repr__(self):
return "<SystemSetting(id:%s, key:%s, value:%s)>" % (self.id, self.key,
self.value)
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
@staticmethod
def get(key):
try:
ret = db.session.query(ModelSetting).filter_by(key=key).first()
if ret is not None:
return ret.value.strip()
else:
return ''
except Exception as exception:
logger.error('Exception:%s %s', exception, key)
logger.error(traceback.format_exc())
@staticmethod
def get_int(key):
try:
return int(ModelSetting.get(key))
except Exception as exception:
logger.error('Exception:%s %s', exception, key)
logger.error(traceback.format_exc())
@staticmethod
def get_bool(key):
try:
return (ModelSetting.get(key) == 'True')
except Exception as exception:
logger.error('Exception:%s %s', exception, key)
logger.error(traceback.format_exc())
@staticmethod
def set(key, value):
try:
logger.debug(key)
item = db.session.query(ModelSetting).filter_by(
key=key).with_for_update().first()
if item is not None:
item.value = value.strip() if value is not None else value
db.session.commit()
else:
db.session.add(ModelSetting(key, value.strip()))
except Exception as exception:
logger.error('Exception:%s %s', exception, key)
logger.error(traceback.format_exc())
@staticmethod
def to_dict():
try:
from framework.util import Util
arg = Util.db_list_to_dict(db.session.query(ModelSetting).all())
arg['package_name'] = package_name
return arg
except Exception as exception:
logger.error('Exception:%s', exception)
logger.error(traceback.format_exc())
@staticmethod
def setting_save(req):
try:
for key, value in req.form.items():
if key in ['scheduler', 'is_running']:
continue
if key.startswith('tmp_'):
continue
logger.debug('Key:%s Value:%s', key, value)
entity = db.session.query(ModelSetting).filter_by(
key=key).with_for_update().first()
entity.value = value
db.session.commit()
return True
except Exception as exception:
logger.error('Exception:%s', exception)
logger.error(traceback.format_exc())
logger.debug('Error Key:%s Value:%s', key, value)
return False
@staticmethod
def get_list(key):
try:
value = ModelSetting.get(key)
values = [
x.strip().replace(' ', '').strip()
for x in value.replace('\n', '|').split('|')
]
values = Util.get_list_except_empty(values)
return values
except Exception as exception:
logger.error('Exception:%s', exception)
logger.error(traceback.format_exc())
logger.error('Error Key:%s Value:%s', key, value)
@staticmethod
def make_apikey(url):
url = url.format(ddns=ModelSetting.get('ddns'))
if ModelSetting.get_bool('auth_use_apikey'):
if url.find('?') == -1:
url += '?'
else:
url += '&'
url += 'apikey=%s' % ModelSetting.get('auth_apikey')
return url
