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 ModelCustom(db.Model):
__tablename__ = '%s_custom' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
json = db.Column(db.JSON)
created_time = db.Column(db.DateTime)
source = db.Column(db.String)
source_id = db.Column(db.String)
epg_id = db.Column(db.Integer) # 이건 단순히 sort만을 위한거다.
epg_name = db.Column(db.String, db.ForeignKey('epg_channel.name'))
#epg_name = db.Column(db.String)
#epg_name2 = db.Column(db.String, db.ForeignKey('epg_channel.name'))
#epg_entity = db.relationship('ModelEpgMakerChannel', lazy=True)
title = db.Column(db.String)
quality = db.Column(db.String)
number = db.Column(db.Integer)
#number2 = db.Column(db.Integer)
group = db.Column(db.String)
def __init__(self):
self.number = 0
self.created_time = datetime.now()
self.quality = 'default'
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') if ret['created_time'] is not None else None
return ret
def get_m3u8(self, ddns, mode, apikey):
tmp = '%s/%s/api/url.m3u8?m=%s&s=%s&i=%s&q=%s' % (
ddns, package_name, mode, self.source, self.source_id,
self.quality)
if apikey is not None:
tmp += '&apikey=%s' % apikey
return tmp
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 ModelBbs2(db.Model):
__tablename__ = '%s_bbs2' % 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)
site = db.Column(db.String)
board = db.Column(db.String) # 게시판 이름.
board_id = db.Column(db.Integer) # 게시판에서의 ID
board_char_id = db.Column(db.String)
title = db.Column(db.String)
url = db.Column(db.String)
magnet_count = db.Column(db.Integer)
file_count = db.Column(db.Integer)
magnet = db.Column(db.String) #구분자 |
files = db.Column(db.String) # url|filename||url|filename
torrent_info = db.Column(db.JSON)
scheduler_id = db.Column(db.Integer,
db.ForeignKey('%s_scheduler2.id' % package_name))
def __init__(self, scheduler_instance):
self.scheduler = scheduler_instance
self.created_time = datetime.now()
self.files = None
self.torrent_info = None
self.site = scheduler_instance.site.info['NAME']
self.board = scheduler_instance.board_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')
if ret['magnet'] is not None:
ret['magnet'] = self.magnet.split('|')
if len(ret['magnet']) == 1 and ret['magnet'][0] == '':
ret['magnet'] = None
if ret['files'] is not None:
tmp = self.files.split('||')
ret['files'] = []
for t in tmp:
if t == '':
continue
ret['files'].append(t.split('|'))
return ret
@staticmethod
def get(id=None, site=None, board=None, board_id=None, board_char_id=None):
try:
#entity = db.session.query(ModelBbs2).filter_by(id=id).first()
query = db.session.query(ModelBbs2)
if id is not None:
query = query.filter_by(id=id)
if site is not None:
query = query.filter_by(site=site)
if board is not None:
query = query.filter_by(board=board)
if board_id is not None:
query = query.filter_by(board_id=board_id)
if board_char_id is not None:
query = query.filter_by(board_char_id=board_char_id)
entity = query.first()
return entity
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
#bbs = db.relationship("TbUser", backref=backref("addresses", order_by=id))
bbs = db.relationship('ModelBbs2', backref='plugin_%s_bbs' % package_name, lazy=True)
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
"""
group_scheduler2 = db.Table(
'plugin_%s_group_scheduler2' % package_name,
db.Column('group_id', db.Integer,
db.ForeignKey('%s_group.id' % package_name)),
db.Column('scheduler_id', db.Integer,
db.ForeignKey('%s_scheduler2.id' % package_name)))
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)
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 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 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())
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 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 ModelCustom(db.Model):
__tablename__ = '%s_custom' % package_name
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
__bind_key__ = package_name
id = db.Column(db.Integer, primary_key=True)
json = db.Column(db.JSON)
created_time = db.Column(db.DateTime)
source = db.Column(db.String)
source_id = db.Column(db.String)
epg_id = db.Column(db.Integer) # 이건 단순히 sort만을 위한거다.
epg_name = db.Column(db.String, db.ForeignKey('epg_channel.name'))
#epg_name = db.Column(db.String)
#epg_name2 = db.Column(db.String, db.ForeignKey('epg_channel.name'))
#epg_entity = db.relationship('ModelEpgMakerChannel', lazy=True)
title = db.Column(db.String)
quality = db.Column(db.String)
number = db.Column(db.Integer)
#number2 = db.Column(db.Integer)
group = db.Column(db.String)
is_drm_channel = db.Column(db.Boolean)
def __init__(self):
self.number = 0
self.created_time = datetime.now()
self.quality = 'default'
self.is_drm_channel = 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') if ret['created_time'] is not None else None
return ret
def get_m3u8(self, ddns, mode, apikey):
tmp = '%s/%s/api/url.m3u8?m=%s&s=%s&i=%s&q=%s' % (ddns, package_name, mode, self.source, self.source_id, self.quality)
if self.is_drm_channel:
tmp = tmp.replace('url.m3u8', 'url.mpd')
if apikey is not None:
tmp += '&apikey=%s' % apikey
return tmp
@staticmethod
def get(source, source_id):
return db.session.query(ModelCustom).filter_by(source=source).filter_by(source_id=source_id).first()
def set_play_info(self, quality, data):
try:
save_data = self.json
if save_data is None:
save_data = {}
save_data[quality] = data
flag_modified(self, "json")
db.session.add(self)
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
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 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 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 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())
