class ModelScheduler2(db.Model):
__tablename__ = '%s_scheduler2' % 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)
site_id = db.Column(db.Integer, db.ForeignKey('%s_site.id' % package_name))
sitename = db.Column(db.String)
board_id = db.Column(db.String)
include_scheduler = db.Column(db.Boolean)
use_proxy = db.Column(db.Boolean)
use_torrent_info = db.Column(db.Boolean)
group_id = db.Column(db.Integer,
db.ForeignKey('%s_group.id' % package_name))
bbs = db.relationship('ModelBbs2', backref='scheduler', lazy=True)
def __init__(self, site_instance):
self.created_time = datetime.now()
self.site_id = site_instance.id
self.sitename = site_instance.name
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')
return ret
@staticmethod
def get_list(by_dict=False):
try:
tmp = db.session.query(ModelScheduler2).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 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 ModelItem(db.Model):
__tablename__ = '%s_item' % P.package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = P.package_name
id = db.Column(db.Integer, primary_key=True)
created_time = db.Column(db.DateTime)
reserved = db.Column(db.JSON)
# 수신받은 데이터 전체
data = db.Column(db.JSON)
# 토렌트 정보
name = db.Column(db.String)
filename = db.Column(db.String)
dirname = db.Column(db.String)
magnet = db.Column(db.String)
file_count = db.Column(db.Integer)
total_size = db.Column(db.Integer)
url = db.Column(db.String)
# 공용
av_type = db.Column(db.String)
title = db.Column(db.String)
poster = db.Column(db.String)
code = db.Column(db.String)
studio = db.Column(db.String)
genre = db.Column(db.String)
performer = db.Column(db.String)
meta_type = db.Column(db.String)
date = db.Column(db.String)
# 다운로드 정보
download_status = db.Column(db.String)
plex_key = db.Column(db.String)
downloader_item_id = db.Column(db.Integer,
db.ForeignKey('plugin_downloader_item.id'))
downloader_item = db.relationship('ModelDownloaderItem')
download_check_time = db.Column(db.DateTime)
log = db.Column(db.String)
plex_info = db.Column(db.JSON)
# 2 버전 추가
server_id = db.Column(db.Integer)
folderid = db.Column(db.String)
folderid_time = db.Column(db.DateTime)
share_copy_time = db.Column(db.DateTime)
share_copy_complete_time = db.Column(db.DateTime)
def __init__(self):
self.created_time = datetime.now()
self.download_status = ''
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['download_check_time'] = self.download_check_time.strftime(
'%m-%d %H:%M:%S') if self.download_check_time is not None else None
ret['downloader_item'] = self.downloader_item.as_dict(
) if self.downloader_item is not None else None
ret['folderid_time'] = self.folderid_time.strftime(
'%m-%d %H:%M:%S') if self.folderid_time is not None else None
ret['share_copy_time'] = self.share_copy_time.strftime(
'%m-%d %H:%M:%S') if self.share_copy_time is not None else None
ret['share_copy_complete_time'] = self.share_copy_complete_time.strftime(
'%m-%d %H:%M:%S'
) if self.share_copy_complete_time is not None else None
return ret
def save(self):
try:
db.session.add(self)
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def process_telegram_data(data):
try:
if not ModelSetting.get_bool('%s_receive' % data['av_type']):
return
magnet = 'magnet:?xt=urn:btih:' + data['t']['hash']
entity = db.session.query(ModelItem).filter_by(
magnet=magnet).first()
if entity is not None:
logger.debug('magnet exist')
return
try:
allow_duplicate2 = ModelSetting.get('%s_allow_duplicate2' %
data['av_type'])
logger.debug('allow_duplicate2 : %s' % allow_duplicate2)
if allow_duplicate2 == '1' and 'av' in data:
entities = db.session.query(ModelItem).filter_by(
code=data['av']['code_show']).all()
# Max 쿼리로 변경해야함.
is_max_size = True
for entity in entities:
logger.debug('entity.total_size : %s',
entity.total_size)
if entity.total_size > data['t']['size']:
is_max_size = False
break
if is_max_size:
logger.debug('duplicate is_max_size=True: %s',
data['av']['code_show'])
else:
logger.debug('duplicate is_max_size=False: %s',
data['av']['code_show'])
return
elif allow_duplicate2 == '2' and 'av' in data:
entity = db.session.query(ModelItem).filter_by(
code=data['av']['code_show']).first()
if entity is not None:
logger.debug('duplicate : %s', data['av']['code_show'])
return
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
logger.debug('***********')
logger.debug(data)
#return
entity = ModelItem()
entity.server_id = data['server_id']
entity.data = data
entity.av_type = data['av_type']
entity.name = data['t']['name']
entity.total_size = data['t']['size']
entity.file_count = data['t']['num']
entity.magnet = magnet
entity.filename = data['t']['filename']
entity.dirname = data['t']['dirname']
entity.url = data['t']['url']
if 'av' in data:
entity.title = data['av']['title']
entity.poster = data['av']['poster']
entity.code = data['av']['code_show']
entity.studio = data['av']['studio']
entity.genre = '|'.join(data['av']['genre'])
entity.performer = '|'.join(data['av']['performer'])
entity.meta_type = data['av']['meta']
entity.date = data['av']['date']
db.session.add(entity)
db.session.commit()
return entity
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@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']
option = req.form['option']
order = req.form['order'] if 'order' in req.form else 'desc'
av_type = req.form['av_type']
query = ModelItem.make_query(search=search,
option=option,
order=order,
av_type=av_type)
count = query.count()
query = query.limit(page_size).offset((page - 1) * page_size)
logger.debug('ModelItem 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.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def api_list(req):
try:
option = req.args.get('option')
search = req.args.get('search')
count = req.args.get('count')
av_type = req.args.get('type')
server_id_mod = req.args.get('server_id_mod')
if count is None or count == '':
count = 100
query = ModelItem.make_query(option=option,
search=search,
av_type=av_type,
server_id_mod=server_id_mod)
query = (query.order_by(desc(ModelItem.id)).limit(count))
lists = query.all()
return lists
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def make_query(search='',
option='all',
order='desc',
av_type='all',
server_id_mod=None):
query = db.session.query(ModelItem)
if search is not None and search != '':
if search.find('|') != -1:
tmp = search.split('|')
conditions = []
for tt in tmp:
if tt != '':
conditions.append(
ModelItem.code.like('%' + tt.strip() + '%'))
query = query.filter(or_(*conditions))
elif search.find(',') != -1:
tmp = search.split(',')
for tt in tmp:
if tt != '':
query = query.filter(
ModelItem.code.like('%' + tt.strip() + '%'))
else:
query = query.filter(
or_(ModelItem.code.like('%' + search + '%'),
ModelItem.filename.like('%' + search + '%'),
ModelItem.performer.like('%' + search + '%')))
if av_type is not None and av_type != '' and av_type != 'all':
query = query.filter(ModelItem.av_type == av_type)
if option == 'wait':
query = query.filter(ModelItem.download_status == '')
elif option == 'true':
query = query.filter(
ModelItem.download_status.like('true%'),
not_(ModelItem.download_status.like('true_only_status%')))
elif option == 'false':
query = query.filter(
ModelItem.download_status.like('false%'),
not_(ModelItem.download_status.like('false_only_status%')))
elif option == 'true_only_status':
query = query.filter(
ModelItem.download_status.like('true_only_status%'))
elif option == 'false_only_status':
query = query.filter(
ModelItem.download_status.like('false_only_status%'))
elif option == 'no':
query = query.filter(ModelItem.download_status.like('no%'))
elif option == 'share_received':
query = query.filter(ModelItem.folderid != None)
elif option == 'share_no_received':
query = query.filter(ModelItem.folderid == None)
elif option == 'share_request_incompleted':
query = query.filter(ModelItem.share_copy_time != None).filter(
ModelItem.share_copy_complete_time == None)
elif option == 'share_request_completed':
query = query.filter(ModelItem.share_copy_time != None).filter(
ModelItem.share_copy_complete_time != None)
if order == 'desc':
query = query.order_by(desc(ModelItem.id))
else:
query = query.order_by(ModelItem.id)
if server_id_mod is not None and server_id_mod != '':
tmp = server_id_mod.split('_')
if len(tmp) == 2:
query = query.filter(ModelBotDownloaderKtvItem.server_id %
int(tmp[0]) == int(tmp[1]))
return query
@staticmethod
def remove(id):
try:
entity = db.session.query(ModelItem).filter_by(id=id).first()
if entity is not None:
db.session.delete(entity)
db.session.commit()
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return False
@staticmethod
def get_by_id(id):
try:
return db.session.query(ModelItem).filter_by(id=id).first()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def receive_share_data(data):
try:
query = db.session.query(ModelItem).filter(
ModelItem.server_id == int(data['server_id']))
query = query.filter(
ModelItem.magnet.like('%' + data['magnet_hash']))
entity = query.with_for_update().first()
if entity is not None:
#logger.debug(entity)
if entity.folderid is not None:
return True
entity.folderid = data['folderid']
entity.folderid_time = datetime.now()
db.session.commit()
module = P.logic.get_module('receive')
module.process_gd(entity)
return True
return False
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return False
@classmethod
def set_gdrive_share_completed(cls, id):
entity = cls.get_by_id(id)
if entity is not None:
entity.share_copy_complete_time = datetime.now()
entity.download_status = 'true_gdrive_share_completed'
entity.save()
logger.debug('true_gdrive_share_completed %s', id)
@classmethod
def get_share_incompleted_list(cls):
#수동인 True_manual_gdrive_share과 분리 \
# .filter(cls.download_status == 'true_gdrive_share') \
query = db.session.query(cls) \
.filter(cls.share_copy_time != None).filter() \
.filter(cls.share_copy_time > datetime.now() + timedelta(days=-1)) \
.filter(cls.share_copy_complete_time == None)
return query.all()
class ModelMovieItem(db.Model):
__tablename__ = '%s_item' % 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)
# 수신받은 데이터 전체
data = db.Column(db.JSON)
# 자막
sub = db.Column(db.JSON)
# 토렌트 정보
name = db.Column(db.String)
filename = db.Column(db.String)
dirname = db.Column(db.String)
magnet = db.Column(db.String)
file_count = db.Column(db.Integer)
total_size = db.Column(db.Integer)
url = db.Column(db.String)
# guessit
guessit = db.Column(db.JSON)
# 메타
movie_title = db.Column(db.String)
movie_target = db.Column(db.String)
movie_id = db.Column(db.String)
movie_kor = db.Column(db.Boolean)
movie_year = db.Column(db.Integer)
daum_poster = db.Column(db.String)
daum_country = db.Column(db.String)
daum_eng_title = db.Column(db.String)
daum_rate = db.Column(db.String)
daum_genre = db.Column(db.String)
# 다운로드 정보
download_status = db.Column(db.String)
plex_key = db.Column(db.String)
downloader_item_id = db.Column(db.Integer,
db.ForeignKey('plugin_downloader_item.id'))
downloader_item = db.relationship('ModelDownloaderItem')
download_check_time = db.Column(db.DateTime)
log = db.Column(db.String)
plex_info = db.Column(db.JSON)
# 2 버전 추가
server_id = db.Column(db.Integer)
# 2 버전 추가
folderid = db.Column(db.String)
folderid_time = db.Column(db.DateTime)
share_copy_time = db.Column(db.DateTime)
share_copy_complete_time = db.Column(db.DateTime)
def __init__(self):
self.created_time = datetime.now()
self.download_status = ''
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['download_check_time'] = self.download_check_time.strftime(
'%m-%d %H:%M:%S') if self.download_check_time is not None else None
ret['downloader_item'] = self.downloader_item.as_dict(
) if self.downloader_item is not None else None
ret['folderid_time'] = self.folderid_time.strftime(
'%m-%d %H:%M:%S') if self.folderid_time is not None else None
ret['share_copy_time'] = self.share_copy_time.strftime(
'%m-%d %H:%M:%S') if self.share_copy_time is not None else None
ret['share_copy_complete_time'] = self.share_copy_complete_time.strftime(
'%m-%d %H:%M:%S'
) if self.share_copy_complete_time is not None else None
return ret
def save(self):
try:
db.session.add(self)
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def process_telegram_data(data):
try:
magnet = 'magnet:?xt=urn:btih:' + data['t']['hash']
#entity = db.session.query(ModelMovieItem).filter_by(magnet=magnet).first()
entity = db.session.query(ModelMovieItem).filter_by(
magnet=magnet).all()
if len(entity) == 0:
entity = None
else:
entity = entity[-1]
if entity is not None:
if 's' not in data: # 새로받은게 자막이 없다면
return
if entity.sub is not None: # 새로받은게 자막이 있지만, 기존것도 자막이 있다면
return
entity = ModelMovieItem()
entity.server_id = data['server_id']
entity.data = data
entity.name = data['t']['name']
entity.total_size = data['t']['size']
entity.file_count = data['t']['num']
entity.magnet = magnet
entity.filename = data['t']['filename']
entity.dirname = data['t']['dirname']
entity.url = data['t']['url']
from guessit import guessit
entity.guessit = guessit(entity.filename)
for key, value in entity.guessit.items():
entity.guessit[key] = str(value)
"""
if 'language' in entity.guessit:
entity.guessit['language'] = str(entity.guessit['language'])
if 'subtitle_language' in entity.guessit:
entity.guessit['subtitle_language'] = str(entity.guessit['subtitle_language'])
if 'audio_bit_rate' in entity.guessit:
entity.guessit['audio_bit_rate'] = str(entity.guessit['audio_bit_rate'])
if 'size' in entity.guessit:
entity.guessit['size'] = str(entity.guessit['size'])
if 'country' in entity.guessit:
entity.guessit['country'] = str(entity.guessit['country'])
"""
if 'm' in data:
entity.movie_title = data['m']['title']
entity.movie_target = data['m']['target']
entity.movie_kor = data['m']['kor']
entity.movie_year = data['m']['year']
entity.movie_id = data['m']['id']
if entity.movie_target != 'imdb':
entity.daum_country = data['m']['daum']['country']
entity.daum_poster = data['m']['daum']['poster']
entity.daum_eng_title = data['m']['daum']['eng']
entity.daum_rate = data['m']['daum']['rate']
entity.daum_genre = data['m']['daum']['genre']
if 's' in data:
entity.sub = data['s']
if entity.movie_target is not None and entity.movie_target != 'imdb':
entity.plex_info = ModelMovieItem.get_plex_info(
entity.movie_title, entity.movie_id)
db.session.add(entity)
db.session.commit()
return entity
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get_plex_info(title, daum_id):
logger.debug('get_plex_info : %s %s', title, daum_id)
try:
ret = []
import plex
plex_videos = plex.Logic.library_search_movie(title, daum_id)
if plex_videos:
for v in plex_videos:
entity = {}
entity['key'] = v.key
entity['exist_smi'] = False
entity['exist_srt'] = False
sub_list = v.subtitleStreams()
for sub in sub_list:
if sub.format == 'srt':
entity['exist_srt'] = True
elif sub.format == 'smi':
entity['exist_smi'] = True
entity['media'] = []
for m in v.media:
tmp = '%s / %s / %s / %s' % (
m.videoResolution, m.videoCodec, m.audioCodec,
m.videoFrameRate)
entity['media'].append({
'info': tmp,
'file': m.parts[0].file
})
ret.append(entity)
return ret
except Exception as e:
logger.error('Exception:%s', e)
#logger.error(traceback.format_exc())
@staticmethod
def web_list(req):
try:
ret = {}
page = 1
page_size = ModelSetting.get_int('web_page_size')
job_id = ''
search = ''
if 'page' in req.form:
page = int(req.form['page'])
if 'search_word' in req.form:
search = req.form['search_word']
option = req.form['option']
order = req.form['order'] if 'order' in req.form else 'desc'
query = ModelMovieItem.make_query(search=search,
option=option,
order=order)
count = query.count()
query = query.limit(page_size).offset((page - 1) * page_size)
logger.debug('ModelMovieItem 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, e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelEpgMakerProgram(db.Model):
__tablename__ = '%s_program' % 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)
json = db.Column(db.JSON)
#############################################
#channel_id = db.Column(db.Integer, db.ForeignKey('%s_channel.id' % package_name))
#channel_name = db.Column(db.Integer, db.ForeignKey('epg.%s_channel.name' % package_name))
channel_name = db.Column(db.Integer,
db.ForeignKey('%s_channel.name' % package_name))
#channel = db.relationship('ModelEpgMakerChannel')
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
title = db.Column(db.String)
episode_number = db.Column(db.String)
part_number = db.Column(db.String)
rate = db.Column(db.String)
re = db.Column(db.Boolean)
is_movie = db.Column(db.Boolean)
#daum_href = db.Column(db.String)
#daum_is_movie = db.Column(db.Boolean)
#daum_title = db.Column(db.String)
#daum_id = db.Column(db.String)
#daum_id = db.Column(db.String, db.ForeignKey('epg.%s_daum.daum_id' % package_name))
daum_id = db.Column(db.String,
db.ForeignKey('%s_daum.daum_id' % package_name))
daum_info = db.relationship('ModelEpgMakerDaum',
backref='programs',
lazy=True)
#daum_poster = db.Column(db.String)
#daum_desc = db.Column(db.String)
# 다음 이외의 것들
poster = db.Column(db.String)
desc = db.Column(db.String)
genre = db.Column(db.String)
actor = db.Column(db.String)
def __init__(self):
self.created_time = datetime.now()
self.is_movie = 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['json'] = ret['json'] if isinstance(
ret['json'], dict) else json.loads(ret['json'])
return ret
@staticmethod
def save(data):
try:
data = data['list']
for d in data:
c = ModelEpgMakerChannel(d)
db.session.add(c)
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelSite2(db.Model):
__tablename__ = '%s_site' % 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)
info_type = db.Column(db.String)
name = db.Column(db.String)
info = db.Column(db.JSON)
content = db.Column(db.String)
schedulers = db.relationship('ModelScheduler2', backref='site', lazy=True)
def __init__(self, info_type, info, content):
self.created_time = datetime.now()
self.info_type = info_type
self.name = info['NAME']
self.info = info
self.content = content
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')
return ret
@staticmethod
def save(info_type, info, content):
try:
ret = {}
if 'NAME' in info:
name = info['NAME']
entity = db.session.query(ModelSite2).filter_by(
name=name, info=info, content=content).first()
if entity is not None:
ret['ret'] = "already_save"
ret['log'] = "이미 저장되어 있습니다."
else:
entity = db.session.query(ModelSite2).filter_by(
name=name).with_for_update().first()
if entity is not None:
entity.info = info
entity.content = content
entity.info_type = info_type
flag_modified(entity, "info")
db.session.commit()
ret['ret'] = "update"
ret['log'] = "업데이트하였습니다."
else:
entity = ModelSite2(info_type, info, content)
db.session.add(entity)
db.session.commit()
ret['ret'] = "add"
ret['log'] = "추가하였습니다."
except Exception, e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
ret['ret'] = "exception"
ret['log'] = "DB 저장에 실패하였습니다."
try:
count = db.session.query(ModelSite2).filter_by(
info_type='web').count()
ret['log'] += '<br>' + '총 %s개의 웹 연동 정보가 있습니다.' % (count)
return ret
except Exception, e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelMovieItem(db.Model):
__tablename__ = '%s_item' % 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)
# 수신받은 데이터 전체
data = db.Column(db.JSON)
# 자막
sub = db.Column(db.JSON)
# 토렌트 정보
name = db.Column(db.String)
filename = db.Column(db.String)
dirname = db.Column(db.String)
magnet = db.Column(db.String)
file_count = db.Column(db.Integer)
total_size = db.Column(db.Integer)
url = db.Column(db.String)
# guessit
guessit = db.Column(db.JSON)
# 메타
movie_title = db.Column(db.String)
movie_target = db.Column(db.String)
movie_id = db.Column(db.String)
movie_kor = db.Column(db.Boolean)
movie_year = db.Column(db.Integer)
daum_poster = db.Column(db.String)
daum_country = db.Column(db.String)
daum_eng_title = db.Column(db.String)
daum_rate = db.Column(db.String)
daum_genre = db.Column(db.String)
# 다운로드 정보
download_status = db.Column(db.String)
plex_key = db.Column(db.String)
downloader_item_id = db.Column(db.Integer,
db.ForeignKey('plugin_downloader_item.id'))
downloader_item = db.relationship('ModelDownloaderItem')
download_check_time = db.Column(db.DateTime)
log = db.Column(db.String)
plex_info = db.Column(db.JSON)
# 2 버전 추가
server_id = db.Column(db.Integer)
# 2 버전 추가
folderid = db.Column(db.String)
folderid_time = db.Column(db.DateTime)
share_copy_time = db.Column(db.DateTime)
share_copy_complete_time = db.Column(db.DateTime)
def __init__(self):
self.created_time = datetime.now()
self.download_status = ''
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['download_check_time'] = self.download_check_time.strftime(
'%m-%d %H:%M:%S') if self.download_check_time is not None else None
ret['downloader_item'] = self.downloader_item.as_dict(
) if self.downloader_item is not None else None
ret['folderid_time'] = self.folderid_time.strftime(
'%m-%d %H:%M:%S') if self.folderid_time is not None else None
ret['share_copy_time'] = self.share_copy_time.strftime(
'%m-%d %H:%M:%S') if self.share_copy_time is not None else None
ret['share_copy_complete_time'] = self.share_copy_complete_time.strftime(
'%m-%d %H:%M:%S'
) if self.share_copy_complete_time is not None else None
return ret
def save(self):
try:
db.session.add(self)
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def process_telegram_data(data):
try:
magnet = 'magnet:?xt=urn:btih:' + data['t']['hash']
#entity = db.session.query(ModelMovieItem).filter_by(magnet=magnet).first()
entity = db.session.query(ModelMovieItem).filter_by(
magnet=magnet).all()
if len(entity) == 0:
entity = None
else:
entity = entity[-1]
if entity is not None:
if 's' not in data: # 새로받은게 자막이 없다면
return
if entity.sub is not None: # 새로받은게 자막이 있지만, 기존것도 자막이 있다면
return
entity = ModelMovieItem()
entity.server_id = data['server_id']
entity.data = data
entity.name = data['t']['name']
entity.total_size = data['t']['size']
entity.file_count = data['t']['num']
entity.magnet = magnet
entity.filename = data['t']['filename']
entity.dirname = data['t']['dirname']
entity.url = data['t']['url']
from guessit import guessit
entity.guessit = guessit(entity.filename)
for key, value in entity.guessit.items():
entity.guessit[key] = str(value)
"""
if 'language' in entity.guessit:
entity.guessit['language'] = str(entity.guessit['language'])
if 'subtitle_language' in entity.guessit:
entity.guessit['subtitle_language'] = str(entity.guessit['subtitle_language'])
if 'audio_bit_rate' in entity.guessit:
entity.guessit['audio_bit_rate'] = str(entity.guessit['audio_bit_rate'])
if 'size' in entity.guessit:
entity.guessit['size'] = str(entity.guessit['size'])
if 'country' in entity.guessit:
entity.guessit['country'] = str(entity.guessit['country'])
"""
if 'm' in data:
entity.movie_title = data['m']['title']
entity.movie_target = data['m']['target']
entity.movie_kor = data['m']['kor']
entity.movie_year = data['m']['year']
entity.movie_id = data['m']['id']
if entity.movie_target != 'imdb':
entity.daum_country = data['m']['daum']['country']
entity.daum_poster = data['m']['daum']['poster']
entity.daum_eng_title = data['m']['daum']['eng']
entity.daum_rate = data['m']['daum']['rate']
entity.daum_genre = data['m']['daum']['genre']
if 's' in data:
entity.sub = data['s']
if entity.movie_target is not None and entity.movie_target != 'imdb':
entity.plex_info = ModelMovieItem.get_plex_info(
entity.movie_title, entity.movie_id)
db.session.add(entity)
db.session.commit()
return entity
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get_plex_info(title, daum_id):
logger.debug('get_plex_info : %s %s', title, daum_id)
try:
ret = []
import plex
plex_videos = plex.Logic.library_search_movie(title, daum_id)
if plex_videos:
for v in plex_videos:
entity = {}
entity['key'] = v.key
entity['exist_smi'] = False
entity['exist_srt'] = False
sub_list = v.subtitleStreams()
for sub in sub_list:
if sub.format == 'srt':
entity['exist_srt'] = True
elif sub.format == 'smi':
entity['exist_smi'] = True
entity['media'] = []
for m in v.media:
tmp = '%s / %s / %s / %s' % (
m.videoResolution, m.videoCodec, m.audioCodec,
m.videoFrameRate)
entity['media'].append({
'info': tmp,
'file': m.parts[0].file
})
ret.append(entity)
return ret
except Exception as e:
logger.error('Exception:%s', e)
#logger.error(traceback.format_exc())
@staticmethod
def web_list(req):
try:
ret = {}
page = 1
page_size = ModelSetting.get_int('web_page_size')
job_id = ''
search = ''
if 'page' in req.form:
page = int(req.form['page'])
if 'search_word' in req.form:
search = req.form['search_word']
option = req.form['option']
order = req.form['order'] if 'order' in req.form else 'desc'
query = ModelMovieItem.make_query(search=search,
option=option,
order=order)
count = query.count()
query = query.limit(page_size).offset((page - 1) * page_size)
logger.debug('ModelMovieItem 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.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def api_list(req):
try:
option = req.args.get('option')
search = req.args.get('search')
count = req.args.get('count')
if count is None or count == '':
count = 100
server_id_mod = req.args.get('server_id_mod')
query = ModelMovieItem.make_query(option=option,
search=search,
server_id_mod=server_id_mod)
query = (query.order_by(desc(ModelMovieItem.id)).limit(count))
lists = query.all()
return lists
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def make_query(search='', option='all', order='desc', server_id_mod=None):
query = db.session.query(ModelMovieItem)
if search is not None and search != '':
if search.find('|') != -1:
tmp = search.split('|')
conditions = []
for tt in tmp:
if tt != '':
conditions.append(
ModelMovieItem.filename.like('%' + tt.strip() +
'%'))
query = query.filter(or_(*conditions))
elif search.find(',') != -1:
tmp = search.split(',')
for tt in tmp:
if tt != '':
query = query.filter(
ModelMovieItem.filename.like('%' + tt.strip() +
'%'))
else:
query = query.filter(
or_(ModelMovieItem.filename.like('%' + search + '%'),
ModelMovieItem.movie_title.like('%' + search + '%')))
if option == 'wait':
query = query.filter(ModelMovieItem.download_status == '')
elif option == 'true':
query = query.filter(
ModelMovieItem.download_status.like('true%'),
not_(ModelMovieItem.download_status.like('true_only_status%')))
elif option == 'false':
query = query.filter(
ModelMovieItem.download_status.like('false%'),
not_(
ModelMovieItem.download_status.like('false_only_status%')))
elif option == 'true_only_status':
query = query.filter(
ModelMovieItem.download_status.like('true_only_status%'))
elif option == 'false_only_status':
query = query.filter(
ModelMovieItem.download_status.like('false_only_status%'))
elif option == 'no':
query = query.filter(ModelMovieItem.download_status.like('no%'))
elif option == 'share_received':
query = query.filter(ModelMovieItem.folderid != None)
elif option == 'share_no_received':
query = query.filter(ModelMovieItem.folderid == None)
elif option == 'share_request_incompleted':
query = query.filter(
ModelMovieItem.share_copy_time != None).filter(
ModelMovieItem.share_copy_complete_time == None)
elif option == 'share_request_completed':
query = query.filter(
ModelMovieItem.share_copy_time != None).filter(
ModelMovieItem.share_copy_complete_time != None)
if order == 'desc':
query = query.order_by(desc(ModelMovieItem.id))
else:
query = query.order_by(ModelMovieItem.id)
if server_id_mod is not None and server_id_mod != '':
tmp = server_id_mod.split('_')
if len(tmp) == 2:
query = query.filter(ModelBotDownloaderKtvItem.server_id %
int(tmp[0]) == int(tmp[1]))
return query
@staticmethod
def remove(id):
try:
entity = db.session.query(ModelMovieItem).filter_by(id=id).first()
if entity is not None:
db.session.delete(entity)
db.session.commit()
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return False
@staticmethod
def get_by_id(id):
try:
return db.session.query(ModelMovieItem).filter_by(id=id).first()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def receive_share_data(data):
try:
query = db.session.query(ModelMovieItem).filter(
ModelMovieItem.server_id == int(data['server_id']))
query = query.filter(
ModelMovieItem.magnet.like('%' + data['magnet_hash']))
entity = query.with_for_update().first()
if entity is not None:
#logger.debug(entity)
if entity.folderid is not None:
return True
entity.folderid = data['folderid']
entity.folderid_time = datetime.now()
db.session.commit()
from .logic_normal import LogicNormal
LogicNormal.process_gd(entity)
return True
return False
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return False
@classmethod
def set_gdrive_share_completed(cls, id):
entity = cls.get_by_id(id)
if entity is not None:
entity.share_copy_complete_time = datetime.now()
entity.download_status = 'true_gdrive_share_completed'
entity.save()
logger.debug('true_gdrive_share_completed %s', id)
@classmethod
def get_share_incompleted_list(cls):
#수동인 True_manual_gdrive_share과 분리 \
# .filter(cls.download_status == 'true_gdrive_share') \
query = db.session.query(cls) \
.filter(cls.share_copy_time != None).filter() \
.filter(cls.share_copy_time > datetime.now() + timedelta(days=-1)) \
.filter(cls.share_copy_complete_time == None)
return query.all()
class ModelScheduler2(db.Model):
__tablename__ = '%s_scheduler2' % 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)
site_id = db.Column(db.Integer, db.ForeignKey('%s_site.id' % package_name))
sitename = db.Column(db.String)
board_id = db.Column(db.String)
include_scheduler = db.Column(db.Boolean)
use_proxy = db.Column(db.Boolean)
use_torrent_info = db.Column(db.Boolean)
group_id = db.Column(db.Integer,
db.ForeignKey('%s_group.id' % package_name))
bbs = db.relationship('ModelBbs2', backref='scheduler', lazy=True)
# 2버전추가
priority = db.Column(db.Integer)
scheduler_interval = db.Column(
db.Integer
) # 스케쥴러 몇회마다 한번씩 수행할지 결정할 값 0:매번수행, 1: 실행-실행 2: 실행-패스-실행 , 3:실행-패스-패스-실행
#scheduler_interval_current = db.Column(db.Integer) #
def __init__(self, site_instance):
self.created_time = datetime.now()
self.site_id = site_instance.id
self.sitename = site_instance.name
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')
return ret
@staticmethod
def get_list(by_dict=False):
try:
query = db.session.query(ModelScheduler2)
query = query.order_by(ModelScheduler2.priority)
query = query.order_by(ModelScheduler2.id)
tmp = query.all()
if by_dict:
tmp = [x.as_dict() for x in tmp]
return tmp
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get(site_id, board_id, by_dict=False):
try:
site_id = int(site_id)
tmp = db.session.query(ModelScheduler2).filter_by(
site_id=site_id).filter_by(board_id=board_id).first()
if by_dict:
return tmp.as_dict()
else:
return tmp
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get2(sitename=None, board_id=None, by_dict=False):
try:
tmp = db.session.query(ModelScheduler2).filter_by(
sitename=sitename).filter_by(board_id=board_id).first()
if by_dict:
return tmp.as_dict()
else:
return tmp
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def get_last_bbs(self):
try:
if 'USING_BOARD_CHAR_ID' not in self.site.info['EXTRA']:
max_id = db.session.query(db.func.max(
ModelBbs2.board_id)).filter_by(
site=self.sitename, board=self.board_id).scalar()
if max_id > 0:
return db.session.query(ModelBbs2).filter_by(
site=self.sitename,
board=self.board_id,
board_id=max_id).first()
else:
if self.bbs:
return self.bbs[-1]
return None
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelOffcloud2Job(db.Model):
__tablename__ = '%s_job' % 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)
name = db.Column(db.String)
rss_url = db.Column(db.String)
username = db.Column(db.String)
folderid = db.Column(db.String)
mode = db.Column(db.String) #0:cache, 1:all, 2:on_cache_test
cache_confirm_day = db.Column(db.Integer) # 며칠간 cache를 확인하겠는가?
include_keyword = db.Column(db.String)
exclude_keyword = db.Column(db.String)
rss_list = db.relationship('ModelOffcloud2Item', backref='job', lazy=True)
# db_version 4
use_tracer = db.Column(db.Boolean)
mount_path = db.Column(db.String)
move_path = db.Column(db.String)
call_job = db.Column(db.String)
# db_version 5
is_http_torrent_rss = db.Column(db.Boolean)
# db_version 6
rss_mode = db.Column(db.Boolean) # True : 화이트리스트 , False : 블랙리스트
rss_regex = db.Column(
db.String) # \n 구분 블랙리스트이고 비어있으면 다 받음. 블랙리스트 매칭되면 안 받음.
# 화이트리스트이고 비어있으면 안 받음
# 화이트리스트고 매칭되면 받음
# db_version 7
username2 = db.Column(db.String) # 계정 분산 처리용
add_to_cloud = db.Column(db.String) # Cloud 추가 지연시간
def __init__(self):
self.created_time = datetime.datetime.now()
self.use_tracer = False
self.is_http_torrent_rss = 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')
return ret
@staticmethod
def save(req):
try:
job_id = req.form['job_id']
if job_id == '-1':
job = ModelOffcloud2Job()
else:
job = db.session.query(ModelOffcloud2Job).filter_by(
id=job_id).first()
job.name = req.form['job_name']
job.rss_url = req.form['job_rss_url']
job.rss_mode = (req.form['job_rss_mode'] == 'True')
job.rss_regex = req.form['job_rss_regex']
job.username = req.form['job_username']
job.username2 = req.form['job_username2']
job.folderid = req.form['job_folderid']
job.mode = req.form['job_mode']
job.cache_confirm_day = int(req.form['job_cache_confirm_day'])
# logger.debug(req.form['job_use_tracer'])
job.use_tracer = (req.form['job_use_tracer'] == 'True')
job.mount_path = req.form['job_mount_path']
job.move_path = req.form['job_move_path']
job.call_job = req.form['job_call_job']
job.add_to_cloud = req.form['job_add_to_cloud']
db.session.add(job)
db.session.commit()
return 'success'
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return 'fail'
@staticmethod
def get_list(by_dict=False):
try:
tmp = db.session.query(ModelOffcloud2Job).all()
if by_dict:
tmp = [x.as_dict() for x in tmp]
return tmp
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)
job = db.session.query(ModelOffcloud2Job).filter_by(
id=job_id).first()
db.session.delete(job)
db.session.commit()
return 'success'
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return 'fail'
@staticmethod
def get_by_name(name):
try:
return db.session.query(ModelOffcloud2Job).filter_by(
name=name).first()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelBotDownloaderKtvItem(db.Model):
__tablename__ = '%s_item' % 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)
# 수신받은 데이터 전체
data = db.Column(db.JSON)
# 토렌트 정보
filename = db.Column(db.String)
magnet = db.Column(db.String)
file_count = db.Column(db.Integer)
total_size = db.Column(db.Integer)
files = db.Column(db.JSON)
# 파일처리 정보
filename_rule = db.Column(db.String)
filename_name = db.Column(db.String)
filename_number = db.Column(db.Integer)
filename_release = db.Column(db.String)
filename_date = db.Column(db.String)
filename_quality = db.Column(db.String)
# 메타
daum_genre = db.Column(db.String)
daum_id = db.Column(db.String)
daum_title = db.Column(db.String)
daum_poster_url = db.Column(db.String)
# 다운로드 정보
download_status = db.Column(db.String)
plex_key = db.Column(db.String)
downloader_item_id = db.Column(db.Integer,
db.ForeignKey('plugin_downloader_item.id'))
downloader_item = db.relationship('ModelDownloaderItem')
# 1 버전 추가
download_check_time = db.Column(db.DateTime)
delay_time = db.Column(db.DateTime)
# 2 버전 추가
log = db.Column(db.String)
def __init__(self):
self.created_time = datetime.now()
self.download_status = ''
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['download_check_time'] = self.download_check_time.strftime(
'%m-%d %H:%M:%S') if self.download_check_time is not None else None
ret['delay_time'] = self.delay_time.strftime(
'%m-%d %H:%M:%S') if self.delay_time is not None else None
ret['downloader_item'] = self.downloader_item.as_dict(
) if self.downloader_item is not None else None
return ret
@staticmethod
def process_telegram_data(data):
try:
magnet = 'magnet:?xt=urn:btih:' + data['hash']
entity = db.session.query(ModelBotDownloaderKtvItem).filter_by(
magnet=magnet).first()
# 수동 방송은 어떻게 해야할까..
if data['broadcast_type'] == 'auto':
if entity is not None:
return
else:
# 수동 방송 장르가 꼭 있는 걸로 가정
if entity is not None:
if entity.daum_genre == data['daum']['genre']:
# 같은 마그넷, 같은 장르라면 패스
return
entity = ModelBotDownloaderKtvItem()
entity.data = data
entity.filename = data['filename']
entity.magnet = magnet
entity.file_count = data['file_count']
entity.total_size = data['total_size']
entity.files = data['files']
entity.filename_rule = data['ktv']['filename_rule']
entity.filename_name = data['ktv']['name']
entity.filename_number = data['ktv']['number']
entity.filename_release = data['ktv']['release']
entity.filename_date = data['ktv']['date']
entity.filename_quality = data['ktv']['quality']
if data['daum'] is not None:
entity.daum_genre = data['daum']['genre']
entity.daum_id = data['daum']['daum_id']
entity.daum_title = data['daum']['title']
entity.daum_poster_url = data['daum']['poster_url']
db.session.add(entity)
db.session.commit()
return entity
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelBotDownloaderKtvItem(db.Model):
__tablename__ = '%s_item' % (P.package_name)
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = P.package_name
id = db.Column(db.Integer, primary_key=True)
created_time = db.Column(db.DateTime)
reserved = db.Column(db.JSON)
# 수신받은 데이터 전체
data = db.Column(db.JSON)
# 토렌트 정보
filename = db.Column(db.String)
magnet = db.Column(db.String)
file_count = db.Column(db.Integer)
total_size = db.Column(db.Integer)
files = db.Column(db.JSON)
# 파일처리 정보
filename_rule = db.Column(db.String)
filename_name = db.Column(db.String)
filename_number = db.Column(db.Integer)
filename_release = db.Column(db.String)
filename_date = db.Column(db.String)
filename_quality = db.Column(db.String)
# 메타
daum_genre = db.Column(db.String)
daum_id = db.Column(db.String)
daum_title = db.Column(db.String)
daum_poster_url = db.Column(db.String)
# 다운로드 정보
download_status = db.Column(db.String)
plex_key = db.Column(db.String)
downloader_item_id = db.Column(db.Integer,
db.ForeignKey('plugin_downloader_item.id'))
downloader_item = db.relationship('ModelDownloaderItem')
# 1 버전 추가
download_check_time = db.Column(db.DateTime)
delay_time = db.Column(db.DateTime)
# 2 버전 추가
log = db.Column(db.String)
# 3 버전 추가
server_id = db.Column(db.Integer)
folderid = db.Column(db.String) # 3 버전 추가
folderid_time = db.Column(db.DateTime) # 4 버전 추가
share_copy_time = db.Column(db.DateTime) # 5 버전 추가
share_copy_completed_time = db.Column(db.DateTime) # 6
def __init__(self):
self.created_time = datetime.now()
self.download_status = ''
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['download_check_time'] = self.download_check_time.strftime(
'%m-%d %H:%M:%S') if self.download_check_time is not None else None
ret['delay_time'] = self.delay_time.strftime(
'%m-%d %H:%M:%S') if self.delay_time is not None else None
ret['downloader_item'] = self.downloader_item.as_dict(
) if self.downloader_item is not None else None
ret['folderid_time'] = self.folderid_time.strftime(
'%m-%d %H:%M:%S') if self.folderid_time is not None else None
ret['share_copy_time'] = self.share_copy_time.strftime(
'%m-%d %H:%M:%S') if self.share_copy_time is not None else None
ret['share_copy_completed_time'] = self.share_copy_completed_time.strftime(
'%m-%d %H:%M:%S'
) if self.share_copy_completed_time is not None else None
return ret
def save(self):
try:
if self.log is not None:
self.log = u'%s' % self.log
db.session.add(self)
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def process_telegram_data(data):
try:
magnet = 'magnet:?xt=urn:btih:' + data['hash']
entity = db.session.query(ModelBotDownloaderKtvItem).filter_by(
magnet=magnet).first()
# 수동 방송은 어떻게 해야할까..
if data['broadcast_type'] == 'auto':
if entity is not None:
return
else:
# 수동 방송 장르가 꼭 있는 걸로 가정
if entity is not None:
if entity.daum_genre == data['daum']['genre']:
# 같은 마그넷, 같은 장르라면 패스
return
# 2020-08-03 동일 파일명 수신하지 않음.
entity = db.session.query(ModelBotDownloaderKtvItem).filter_by(
filename=data['filename']).first()
if entity is not None:
return
entity = ModelBotDownloaderKtvItem()
entity.server_id = data['server_id']
entity.data = data
entity.filename = data['filename']
entity.magnet = magnet
entity.file_count = data['file_count']
entity.total_size = data['total_size']
entity.files = data['files']
entity.filename_rule = data['ktv']['filename_rule']
entity.filename_name = data['ktv']['name']
entity.filename_number = data['ktv']['number']
entity.filename_release = data['ktv']['release']
entity.filename_date = data['ktv']['date']
entity.filename_quality = data['ktv']['quality']
if data['daum'] is not None:
entity.daum_genre = data['daum']['genre']
entity.daum_id = data['daum']['daum_id']
entity.daum_title = data['daum']['title']
entity.daum_poster_url = data['daum']['poster_url']
else:
entity.daum_genre = u'미분류'
db.session.add(entity)
db.session.commit()
return entity
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def filelist(req):
try:
ret = {}
page = 1
page_size = ModelSetting.get_int('web_page_size')
job_id = ''
search = ''
if 'page' in req.form:
page = int(req.form['page'])
if 'search_word' in req.form:
search = req.form['search_word']
option = req.form['option']
order = req.form['order'] if 'order' in req.form else 'desc'
query = ModelBotDownloaderKtvItem.make_query(search, option, order)
count = query.count()
query = query.limit(page_size).offset((page - 1) * page_size)
logger.debug('ModelBotDownloaderKtvItem 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.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def make_query(search, option, order, genre=None, server_id_mod=None):
query = db.session.query(ModelBotDownloaderKtvItem)
if search is not None and search != '':
if search.find('|') != -1:
tmp = search.split('|')
conditions = []
for tt in tmp:
if tt != '':
conditions.append(
ModelBotDownloaderKtvItem.filename.like(
'%' + tt.strip() + '%'))
query = query.filter(or_(*conditions))
elif search.find(',') != -1:
tmp = search.split(',')
for tt in tmp:
if tt != '':
query = query.filter(
ModelBotDownloaderKtvItem.filename.like(
'%' + tt.strip() + '%'))
else:
query = query.filter(
or_(
ModelBotDownloaderKtvItem.filename.like('%' + search +
'%'),
ModelBotDownloaderKtvItem.daum_title == search))
if genre is not None and genre != '':
if genre.find('|') != -1:
tmp = genre.split('|')
conditions = []
for tt in tmp:
if tt != '':
conditions.append(
ModelBotDownloaderKtvItem.daum_genre.like(
'%' + tt.strip() + '%'))
query = query.filter(or_(*conditions))
elif genre.find(',') != -1:
tmp = genre.split(',')
for tt in tmp:
if tt != '':
query = query.filter(
ModelBotDownloaderKtvItem.daum_genre.like(
'%' + tt.strip() + '%'))
else:
query = query.filter(
or_(
ModelBotDownloaderKtvItem.daum_genre.like('%' + genre +
'%'),
ModelBotDownloaderKtvItem.daum_genre == genre))
if option == 'request_True':
query = query.filter(
ModelBotDownloaderKtvItem.download_status.like('True%'))
elif option == 'request_False':
query = query.filter(
ModelBotDownloaderKtvItem.download_status.like('False%'))
elif option == 'by_plex_on':
query = query.filter(ModelBotDownloaderKtvItem.plex_key != None)
elif option == 'by_plex_off':
query = query.filter(ModelBotDownloaderKtvItem.plex_key == None)
elif option == 'by_plex_episode_off':
query = query.filter(ModelBotDownloaderKtvItem.plex_key != None)
query = query.filter(
not_(ModelBotDownloaderKtvItem.plex_key.like('E%')))
#실패. 아래 동작 안함.
#elif option == 'torrent_incomplted':
# query = query.filter(ModelBotDownloaderKtvItem.downloader_item_id != None)
#elif option == 'torrent_completed':
# from downloader.model import ModelDownloaderItem
# query = query.filter(ModelBotDownloaderKtvItem.downloader_item_id != None).filter(ModelBotDownloaderKtvItem.downloader_item_id == ModelDownloaderItem.id).filter(ModelDownloaderItem.completed_time != None)
elif option == 'share_received':
query = query.filter(ModelBotDownloaderKtvItem.folderid != None)
elif option == 'share_no_received':
query = query.filter(ModelBotDownloaderKtvItem.folderid == None)
elif option == 'share_request_incompleted':
query = query.filter(
ModelBotDownloaderKtvItem.share_copy_time != None).filter(
ModelBotDownloaderKtvItem.share_copy_completed_time ==
None)
elif option == 'share_request_completed':
query = query.filter(
ModelBotDownloaderKtvItem.share_copy_time != None).filter(
ModelBotDownloaderKtvItem.share_copy_completed_time != None
)
if order == 'desc':
query = query.order_by(desc(ModelBotDownloaderKtvItem.id))
else:
query = query.order_by(ModelBotDownloaderKtvItem.id)
if server_id_mod is not None and server_id_mod != '':
tmp = server_id_mod.split('_')
if len(tmp) == 2:
query = query.filter(ModelBotDownloaderKtvItem.server_id %
int(tmp[0]) == int(tmp[1]))
return query
@staticmethod
def itemlist_by_api(req):
try:
search = req.args.get('search')
logger.debug(search)
option = req.args.get('option')
order = 'desc'
genre = req.args.get('genre')
count = req.args.get('count')
if count is None or count == '':
count = 100
server_id_mod = req.args.get('server_id_mod')
query = ModelBotDownloaderKtvItem.make_query(
search,
option,
order,
genre=genre,
server_id_mod=server_id_mod)
query = query.limit(count)
lists = query.all()
return lists
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def remove(db_id):
try:
entity = db.session.query(ModelBotDownloaderKtvItem).filter(
ModelBotDownloaderKtvItem.id == db_id).first()
db.session.delete(entity)
db.session.commit()
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return False
@staticmethod
def receive_share_data(data):
try:
query = db.session.query(ModelBotDownloaderKtvItem).filter(
ModelBotDownloaderKtvItem.server_id == int(data['server_id']))
query = query.filter(
ModelBotDownloaderKtvItem.magnet.like('%' +
data['magnet_hash']))
entity = query.with_for_update().first()
if entity is not None:
#logger.debug(entity)
if entity.folderid is not None:
return True
entity.folderid = data['folderid']
entity.folderid_time = datetime.now()
db.session.commit()
module = P.logic.get_module('torrent')
module.process_gd(entity)
return True
return False
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return False
@classmethod
def get_by_id(cls, id):
return db.session.query(cls).filter_by(id=id).first()
@classmethod
def set_gdrive_share_completed(cls, id):
entity = cls.get_by_id(id)
if entity is not None:
entity.share_copy_completed_time = datetime.now()
entity.download_status = 'True_gdrive_share_completed'
entity.save()
logger.debug('True_gdrive_share_completed %s', id)
@classmethod
def get_share_incompleted_list(cls):
#수동인 True_manual_gdrive_share과 분리 \
#.filter(cls.download_status == 'True_gdrive_share') \
#.filter(cls.share_copy_completed_time != None)
query = db.session.query(cls) \
.filter(cls.share_copy_time != None).filter() \
.filter(cls.share_copy_time > datetime.now() + timedelta(days=-1)) \
.filter(cls.share_copy_completed_time == None)
return query.all()
class ModelBotDownloaderKtvItem(db.Model):
__tablename__ = '%s_item' % (P.package_name)
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = P.package_name
id = db.Column(db.Integer, primary_key=True)
created_time = db.Column(db.DateTime)
reserved = db.Column(db.JSON)
# 수신받은 데이터 전체
data = db.Column(db.JSON)
# 토렌트 정보
filename = db.Column(db.String)
magnet = db.Column(db.String)
file_count = db.Column(db.Integer)
total_size = db.Column(db.Integer)
files = db.Column(db.JSON)
# 파일처리 정보
filename_rule = db.Column(db.String)
filename_name = db.Column(db.String)
filename_number = db.Column(db.Integer)
filename_release = db.Column(db.String)
filename_date = db.Column(db.String)
filename_quality = db.Column(db.String)
# 메타
daum_genre = db.Column(db.String)
daum_id = db.Column(db.String)
daum_title = db.Column(db.String)
daum_poster_url = db.Column(db.String)
# 다운로드 정보
download_status = db.Column(db.String)
plex_key = db.Column(db.String)
downloader_item_id = db.Column(db.Integer, db.ForeignKey('plugin_downloader_item.id'))
downloader_item = db.relationship('ModelDownloaderItem')
# 1 버전 추가
download_check_time = db.Column(db.DateTime)
delay_time = db.Column(db.DateTime)
# 2 버전 추가
log = db.Column(db.String)
# 3 버전 추가
server_id = db.Column(db.Integer)
folderid = db.Column(db.String) # 3 버전 추가
folderid_time = db.Column(db.DateTime) # 4 버전 추가
share_copy_time = db.Column(db.DateTime) # 5 버전 추가
share_copy_completed_time = db.Column(db.DateTime) # 6
def __init__(self):
self.created_time = datetime.now()
self.download_status = ''
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['download_check_time'] = self.download_check_time.strftime('%m-%d %H:%M:%S') if self.download_check_time is not None else None
ret['delay_time'] = self.delay_time.strftime('%m-%d %H:%M:%S') if self.delay_time is not None else None
ret['downloader_item'] = self.downloader_item.as_dict() if self.downloader_item is not None else None
ret['folderid_time'] = self.folderid_time.strftime('%m-%d %H:%M:%S') if self.folderid_time is not None else None
ret['share_copy_time'] = self.share_copy_time.strftime('%m-%d %H:%M:%S') if self.share_copy_time is not None else None
ret['share_copy_completed_time'] = self.share_copy_completed_time.strftime('%m-%d %H:%M:%S') if self.share_copy_completed_time is not None else None
return ret
def save(self):
try:
if self.log is not None:
self.log = u'%s' % self.log
db.session.add(self)
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def process_telegram_data(data):
try:
magnet = 'magnet:?xt=urn:btih:' + data['hash']
entity = db.session.query(ModelBotDownloaderKtvItem).filter_by(magnet=magnet).first()
# 수동 방송은 어떻게 해야할까..
if data['broadcast_type'] == 'auto':
if entity is not None:
return
else:
# 수동 방송 장르가 꼭 있는 걸로 가정
if entity is not None:
if entity.daum_genre == data['daum']['genre']:
# 같은 마그넷, 같은 장르라면 패스
return
# 2020-08-03 동일 파일명 수신하지 않음.
entity = db.session.query(ModelBotDownloaderKtvItem).filter_by(filename=data['filename']).first()
if entity is not None:
return
entity = ModelBotDownloaderKtvItem()
entity.server_id = data['server_id']
entity.data = data
entity.filename = data['filename']
entity.magnet = magnet
entity.file_count = data['file_count']
entity.total_size = data['total_size']
entity.files = data['files']
entity.filename_rule = data['ktv']['filename_rule']
entity.filename_name = data['ktv']['name']
entity.filename_number = data['ktv']['number']
entity.filename_release = data['ktv']['release']
entity.filename_date = data['ktv']['date']
entity.filename_quality = data['ktv']['quality']
if data['daum'] is not None:
entity.daum_genre = data['daum']['genre']
entity.daum_id = data['daum']['daum_id']
entity.daum_title = data['daum']['title']
entity.daum_poster_url = data['daum']['poster_url']
else:
entity.daum_genre = u'미분류'
db.session.add(entity)
db.session.commit()
return entity
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def filelist(req):
try:
ret = {}
page = 1
page_size = ModelSetting.get_int('web_page_size')
job_id = ''
search = ''
if 'page' in req.form:
page = int(req.form['page'])
if 'search_word' in req.form:
search = req.form['search_word']
option = req.form['option']
order = req.form['order'] if 'order' in req.form else 'desc'
query = ModelBotDownloaderKtvItem.make_query(search, option, order)
count = query.count()
query = query.limit(page_size).offset((page-1)*page_size)
logger.debug('ModelBotDownloaderKtvItem 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, e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelItem(db.Model):
__tablename__ = '%s_item' % 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)
# 수신받은 데이터 전체
data = db.Column(db.JSON)
# 토렌트 정보
name = db.Column(db.String)
filename = db.Column(db.String)
dirname = db.Column(db.String)
magnet = db.Column(db.String)
file_count = db.Column(db.Integer)
total_size = db.Column(db.Integer)
url = db.Column(db.String)
# 공용
av_type = db.Column(db.String)
title = db.Column(db.String)
poster = db.Column(db.String)
code = db.Column(db.String)
studio = db.Column(db.String)
genre = db.Column(db.String)
performer = db.Column(db.String)
meta_type = db.Column(db.String)
date = db.Column(db.String)
# 다운로드 정보
download_status = db.Column(db.String)
plex_key = db.Column(db.String)
downloader_item_id = db.Column(db.Integer, db.ForeignKey('plugin_downloader_item.id'))
downloader_item = db.relationship('ModelDownloaderItem')
download_check_time = db.Column(db.DateTime)
log = db.Column(db.String)
plex_info = db.Column(db.JSON)
# 2 버전 추가
server_id = db.Column(db.Integer)
def __init__(self):
self.created_time = datetime.now()
self.download_status = ''
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['download_check_time'] = self.download_check_time.strftime('%m-%d %H:%M:%S') if self.download_check_time is not None else None
ret['downloader_item'] = self.downloader_item.as_dict() if self.downloader_item is not None else None
return ret
@staticmethod
def process_telegram_data(data):
try:
if not ModelSetting.get_bool('%s_receive' % data['av_type']):
return
magnet = 'magnet:?xt=urn:btih:' + data['t']['hash']
entity = db.session.query(ModelItem).filter_by(magnet=magnet).first()
if entity is not None:
logger.debug('magnet exist')
return
"""
try:
if not ModelSetting.get_bool('%s_allow_duplicate' % data['av_type']) and 'av' in data:
entity = db.session.query(ModelItem).filter_by(code=data['av']['code_show']).first()
if entity is not None:
logger.debug('duplicate : %s', data['av']['code_show'])
return
except:
logger.debug('***********')
logger.debug(data)
#return
"""
try:
allow_duplicate2 = ModelSetting.get('%s_allow_duplicate2' % data['av_type'])
logger.debug('allow_duplicate2 : %s' % allow_duplicate2)
if allow_duplicate2 == '1' and 'av' in data:
entities = db.session.query(ModelItem).filter_by(code=data['av']['code_show']).all()
# Max 쿼리로 변경해야함.
is_max_size = True
for entity in entities:
logger.debug('entity.total_size : %s', entity.total_size)
if entity.total_size > data['t']['size']:
is_max_size = False
break
if is_max_size:
logger.debug('duplicate is_max_size=True: %s', data['av']['code_show'])
else:
logger.debug('duplicate is_max_size=False: %s', data['av']['code_show'])
return
elif allow_duplicate2 == '2' and 'av' in data:
entity = db.session.query(ModelItem).filter_by(code=data['av']['code_show']).first()
if entity is not None:
logger.debug('duplicate : %s', data['av']['code_show'])
return
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
logger.debug('***********')
logger.debug(data)
#return
entity = ModelItem()
entity.server_id = data['server_id']
entity.data = data
entity.av_type = data['av_type']
entity.name = data['t']['name']
entity.total_size = data['t']['size']
entity.file_count = data['t']['num']
entity.magnet = magnet
entity.filename = data['t']['filename']
entity.dirname = data['t']['dirname']
entity.url = data['t']['url']
if 'av' in data:
entity.title = data['av']['title']
entity.poster = data['av']['poster']
entity.code = data['av']['code_show']
entity.studio = data['av']['studio']
entity.genre = '|'.join(data['av']['genre'])
entity.performer = '|'.join(data['av']['performer'])
entity.meta_type = data['av']['meta']
entity.date = data['av']['date']
db.session.add(entity)
db.session.commit()
return entity
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get_plex_info(title, daum_id):
logger.debug('get_plex_info : %s %s', title, daum_id)
try:
ret = []
import plex
plex_videos = plex.Logic.library_search_movie(title, daum_id)
if plex_videos:
for v in plex_videos:
entity = {}
entity['key'] = v.key
entity['exist_smi'] = False
entity['exist_srt'] = False
sub_list = v.subtitleStreams()
for sub in sub_list:
if sub.format == 'srt':
entity['exist_srt'] = True
elif sub.format == 'smi':
entity['exist_smi'] = True
entity['media'] = []
for m in v.media:
tmp = '%s / %s / %s / %s' % (m.videoResolution, m.videoCodec, m.audioCodec, m.videoFrameRate)
entity['media'].append({'info':tmp, 'file':m.parts[0].file})
ret.append(entity)
return ret
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def web_list(req):
try:
ret = {}
page = 1
page_size = ModelSetting.get_int('web_page_size')
job_id = ''
search = ''
if 'page' in req.form:
page = int(req.form['page'])
if 'search_word' in req.form:
search = req.form['search_word']
option = req.form['option']
order = req.form['order'] if 'order' in req.form else 'desc'
av_type = req.form['av_type']
query = ModelItem.make_query(search=search, option=option, order=order, av_type=av_type)
count = query.count()
query = query.limit(page_size).offset((page-1)*page_size)
logger.debug('ModelItem 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, e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
class ModelRss(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)
update_time = db.Column(db.DateTime)
name = db.Column(db.String)
rss_url = db.Column(db.String)
download_program = db.Column(db.String)
download_path = db.Column(db.String)
download_mode = db.Column(db.String) #0:필터 사용 1:모두 받기. 2: RSS만 저장,
include_keyword = db.Column(db.String)
exclude_keyword = db.Column(db.String)
use_filename_filter = db.Column(db.Boolean)
filename_include_keyword = db.Column(db.String) #정규식 혹은 키워드 || 폴더
filename_exclude_keyword = db.Column(db.String)
feed_list = db.relationship('ModelFeed', backref='rss', lazy=True)
def __init__(self):
self.created_time = datetime.datetime.now()
self.use_filename_filter = 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['update_time'] = '' if self.update_time is None else self.created_time.strftime(
'%m-%d %H:%M:%S')
ret['name'] = self.name if self.name is not None else self.id
return ret
@staticmethod
def save(req):
try:
rss_id = req.form['rss_id']
if rss_id == '-1':
entity = ModelRss()
else:
entity = db.session.query(ModelRss).filter_by(
id=rss_id).first()
entity.name = req.form['name']
entity.rss_url = req.form['rss_url']
entity.download_program = req.form['download_program']
entity.download_path = req.form['download_path']
entity.download_mode = req.form['download_mode']
entity.include_keyword = req.form['include_keyword']
entity.exclude_keyword = req.form['exclude_keyword']
"""
entity.use_filename_filter = (req.form['use_filename_filter'] == 'True')
entity.filename_include_keyword = req.form['filename_include_keyword']
entity.filename_exclude_keyword = req.form['filename_exclude_keyword']
"""
db.session.add(entity)
db.session.commit()
return 'success'
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return 'fail'
@staticmethod
def get_list(by_dict=False):
try:
tmp = db.session.query(ModelRss).all()
if by_dict:
tmp = [x.as_dict() for x in tmp]
return tmp
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def remove(rss_id):
try:
logger.debug('remove_rss id:%s', rss_id)
entity = db.session.query(ModelRss).filter_by(id=rss_id).first()
db.session.delete(entity)
db.session.commit()
return 'success'
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return 'fail'
"""
class ModelEpgMakerChannel(db.Model):
__tablename__ = '%s_channel' % 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)
update_time = db.Column(db.DateTime)
json = db.Column(db.JSON)
#############################################
name = db.Column(db.String)
category = db.Column(db.String)
search_name = db.Column(db.String)
epg_from = db.Column(db.String)
icon = db.Column(db.String)
daum_name = db.Column(db.String)
daum_id = db.Column(db.String)
lgu_name = db.Column(db.String)
lgu_id = db.Column(db.String)
skb_name = db.Column(db.String)
skb_id = db.Column(db.String)
kt_name = db.Column(db.String)
kt_id = db.Column(db.String)
wavve_name = db.Column(db.String)
wavve_id = db.Column(db.String)
tving_name = db.Column(db.String)
tving_id = db.Column(db.String)
videoportal_name = db.Column(db.String)
videoportal_id = db.Column(db.String)
everyon_name = db.Column(db.String)
everyon_id = db.Column(db.String)
programs = db.relationship('ModelEpgMakerProgram',
backref='channel',
lazy=True)
def __init__(self, d, site_count):
self.created_time = datetime.now()
self.json = d
self.name = d['name']
self.category = d['category']
self.search_name = '|'.join(d['search_name_list'])
self.icon = d['icon']
if 'daum' in d['site_info']:
self.daum_name = d['site_info']['daum'][0]
self.daum_id = d['site_info']['daum'][1]
site_count['daum'] += 1
if 'lgu' in d['site_info']:
self.lgu_name = d['site_info']['lgu'][0]
self.lgu_id = d['site_info']['lgu'][1]
site_count['lgu'] += 1
if 'skb' in d['site_info']:
self.skb_name = d['site_info']['skb'][0]
self.skb_id = d['site_info']['skb'][1]
site_count['skb'] += 1
if 'kt' in d['site_info']:
self.kt_name = d['site_info']['kt'][0]
self.kt_id = d['site_info']['kt'][1]
site_count['kt'] += 1
if 'wavve' in d['site_info']:
self.wavve_name = d['site_info']['wavve'][0]
self.wavve_id = d['site_info']['wavve'][1]
site_count['wavve'] += 1
if 'tving' in d['site_info']:
self.tving_name = d['site_info']['tving'][0]
self.tving_id = d['site_info']['tving'][1]
site_count['tving'] += 1
if 'videoportal' in d['site_info']:
self.videoportal_name = d['site_info']['videoportal'][0]
self.videoportal_id = d['site_info']['videoportal'][1]
site_count['videoportal'] += 1
if 'everyon' in d['site_info']:
self.everyon_name = d['site_info']['everyon'][0]
self.everyon_id = d['site_info']['everyon'][1]
site_count['everyon'] += 1
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['update_time'] = self.update_time.strftime(
'%m-%d %H:%M:%S') if self.update_time is not None else None
ret['json'] = ret['json'] if isinstance(
ret['json'], dict) else json.loads(ret['json'])
return ret
@staticmethod
def save(data):
site_count = {
"daum": 0,
"skb": 0,
"lgu": 0,
"kt": 0,
"wavve": 0,
"tving": 0,
"videoportal": 0,
"everyon": 0
}
try:
data = data['list']
for d in data:
c = ModelEpgMakerChannel(d, site_count)
db.session.add(c)
db.session.commit()
return site_count
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get_instance_by_name(name):
try:
return db.session.query(ModelEpgMakerChannel).filter_by(
name=name).first()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get_channel_list():
try:
channel_list = db.session.query(ModelEpgMakerChannel).all()
#ret = [x.as_dict() for x in channel_list]
return channel_list
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get_match_name(search_name):
try:
search_name = ModelEpgMakerChannel.util_get_search_name(
search_name)
channel_list = db.session.query(ModelEpgMakerChannel).all()
for c in channel_list:
tmp = c.search_name.split('|')
for t in tmp:
if search_name == ModelEpgMakerChannel.util_get_search_name(
t):
return [c.name, c.category]
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def util_get_search_name(s):
return s.lower().replace('uhd',
'').strip().replace('-', '').replace(' ', '')
class ModelFeed(db.Model):
__tablename__ = '%s_feed' % 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)
rss_id = db.Column(db.Integer, db.ForeignKey('%s_rss.id' % package_name))
title = db.Column(db.String)
link = db.Column(db.String)
description = db.Column(db.String)
guid = db.Column(db.String)
pubDate = db.Column(db.DateTime)
status = db.Column(
db.Integer
) # 0: 최초상태. 1:요청 실패 10 : 요청 성공 11 : rss만 저장, 12:필터 조건 False
downloader_item_id = db.Column(db.Integer,
db.ForeignKey('plugin_downloader_item.id'))
downloader_item = db.relationship('ModelDownloaderItem')
log = db.Column(db.String)
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
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['rss'] = self.rss.as_dict()
try:
ret['downloader_item'] = self.downloader_item.as_dict()
except:
pass
return ret
@staticmethod
def get_feed_list_by_scheduler(rss):
try:
query = db.session.query(ModelFeed) \
.filter(ModelFeed.rss_id == rss.id ) \
.filter(ModelFeed.status < 10 ) \
.filter(ModelFeed.created_time > datetime.datetime.now() + datetime.timedelta(days=-7))
# \
#.filter(ModelFeed.oc_status != 'NOSTATUS')
return query.all()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
"""
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 = info['filename']
self.dirname = info['dirname']
self.filecount = tmp['num_files']
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return False
"""
@staticmethod
def remove(rss_id):
try:
db.session.query(ModelFeed).filter_by(rss_id=rss_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']
rss_select = 'all'
if 'rss_select' in req.form:
rss_select = req.form['rss_select']
option = 'all'
if 'option' in req.form:
option = req.form['option']
query = ModelFeed.make_query(rss_id=rss_select,
option=option,
search=search)
count = query.count()
query = (query.order_by(desc(
ModelFeed.id)).limit(page_size).offset((page - 1) * page_size))
logger.debug('ModelFeed 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 = ModelFeed.make_query(job_name=job, option=option, search=search)
query = (query.order_by(desc(ModelFeed.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(rss_id='all', option='all', search=''):
try:
query = db.session.query(ModelFeed)
job = None
if rss_id != 'all':
query = query.filter_by(rss_id=rss_id)
if search is not None and search != '':
if search.find('|') != -1:
tmp = search.split('|')
conditions = []
for tt in tmp:
if tt != '':
conditions.append(
ModelFeed.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(
ModelFeed.title.like('%' + tt.strip() + '%'))
else:
query = query.filter(
ModelFeed.title.like('%' + search + '%'))
if option != 'all':
query = query.filter(ModelFeed.status == int(option))
return query
except Exception as e:
logger.debug('Exception:%s', e)
logger.debug(traceback.format_exc())
class ModelClientAVSubFile(db.Model):
__tablename__ = '%s_av_sub_file' % 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)
uploader = db.Column(db.String)
# ffprobe
filename = db.Column(db.String)
filesize = db.Column(db.Integer)
duration = db.Column(db.Integer)
width = db.Column(db.Integer)
height = db.Column(db.Integer)
ffprobe_json = db.Column(db.JSON)
# 2
bitrate = db.Column(db.Integer)
codec_name = db.Column(db.String)
item_id = db.Column(db.Integer,
db.ForeignKey('%s_av_sub_item.id' % package_name))
item = db.relationship('ModelClientAVSubItem', backref='files', lazy=True)
def __init__(self, id, item_id):
self.id = id
self.item_id = item_id
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')
return ret
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_by_filename(filename):
try:
return db.session.query(ModelClientAVSubFile).filter_by(
filename=filename).first()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def get_by_id(id):
try:
return db.session.query(ModelClientAVSubFile).filter_by(
id=id).first()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
@staticmethod
def insert(server_json, item_id):
try:
data = ModelClientAVSubFile.get_by_id(server_json['id'])
if data is None:
data = ModelClientAVSubFile(server_json['id'], item_id)
data.created_time = datetime.strptime(server_json['created_time'],
'%Y-%m-%d %H:%M:%S')
data.reserved = server_json['reserved']
data.uploader = server_json['uploader']
data.filename = server_json['filename']
data.filesize = server_json['filesize']
data.duration = server_json['duration']
data.width = server_json['width']
data.height = server_json['height']
data.ffprobe_json = server_json['ffprobe_json']
data.bitrate = server_json['bitrate']
data.codec_name = server_json['codec_name']
flag_modified(data, 'ffprobe_json')
#logger.debug(json.dumps(server_json, indent=2))
db.session.add(data)
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
