def condition_check_filename(item):
try:
condition_quality = ModelSetting.get('condition_quality')
if condition_quality != '' and condition_quality is not None:
condition_qualitys = [
x.strip().replace(' ', '').strip()
for x in condition_quality.replace(',', '|').split('|')
]
condition_qualitys = Util.get_list_except_empty(
condition_qualitys)
if item.filename_quality not in condition_qualitys:
item.download_status = 'False_not_match_condition_quality'
item.log += u'\n화질 조건에 맞지 않음. 다운:Off. 조건:%s' % ','.join(
condition_qualitys)
return False
condition_include_keyword = ModelSetting.get(
'condition_include_keyword')
if condition_include_keyword != '' and condition_include_keyword is not None:
condition_include_keywords = [
x.strip().replace(' ', '').strip() for x in
condition_include_keyword.replace('\n', '|').split('|')
]
condition_include_keywords = Util.get_list_except_empty(
condition_include_keywords)
download_flag = False
for t in condition_include_keywords:
if item.filename.find(t) != -1:
item.log += u'\n단어 포함 조건 만족 : %s' % t
download_flag = True
break
if download_flag == False:
item.download_status = 'False_not_match_condition_include_keyword'
item.log += u'\n단어 포함 조건에 맞지 않음. 다운:Off. 조건:%s' % ','.join(
condition_include_keywords)
return False
condition_except_keyword = ModelSetting.get(
'condition_except_keyword')
if condition_except_keyword != '' and condition_except_keyword is not None:
condition_except_keywords = [
x.strip().replace(' ', '').strip() for x in
condition_except_keyword.replace('\n', '|').split('|')
]
condition_except_keywords = Util.get_list_except_empty(
condition_except_keywords)
for t in condition_except_keywords:
if item.filename.find(t) != -1:
item.download_status = 'False_match_condition_except_keyword'
item.log += u'\n단어 제외 조건. 다운:Off. 조건:%s' % t
return False
item.log += u'\n단어 제외 조건 해당사항 없음.'
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return True
def scheduler_function():
# 자동 추가 목록에 따라 큐에 집어넣음.
try:
whitelists = [
x.strip().replace(' ', '') for x in ModelSetting.get(
'whitelist').replace('\n', '|').split('|')
]
whitelists = Util.get_list_except_empty(whitelists)
blacklists = [
x.strip().replace(' ', '') for x in ModelSetting.get(
'blacklist').replace('\n', '|').split('|')
]
blacklists = Util.get_list_except_empty(blacklists)
url = 'https://comic.naver.com/webtoon/weekday.nhn'
data = LogicNormal.get_html(url)
tree = html.fromstring(data)
tags = tree.xpath('//div[@class="thumb"]')
logger.debug(whitelists)
for tag in tags:
href = tag.xpath('a')[0].attrib['href']
em = tag.xpath('a/em')
if em:
if em[0].attrib['class'] == 'ico_updt':
title = tag.xpath(
'following-sibling::a')[0].attrib['title'].strip()
title_id = href.split('titleId=')[1].split(
'&')[0].strip()
flag = False
if len(whitelists) == 0 or title.replace(
' ', '') in whitelists:
flag = True
if flag and len(blacklists) > 0 and title.replace(
' ', '') in blacklists:
flag = False
#logger.debug(title)
#logger.debug(flag)
if flag:
data = LogicNormal.analysis(title_id, '1')
if data['ret'] == 'success' and data[
'is_adult'] == False:
last_entity = ModelItem.get(
title_id, data['episodes'][0]['no'])
if last_entity is None:
from .logic_queue import LogicQueue
LogicQueue.add_queue(
title_id, data['episodes'][0]['no'])
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def process_telegram_data(data):
try:
logger.debug('receive data')
logger.debug(data)
type_list = ModelSetting.get('cache_save_type_list').split('|')
type_list = Util.get_list_except_empty(type_list)
if len(type_list) == 0 or data['t'] in type_list:
ret = ModelOffcloud2Cache.add(data)
if ret is not None:
logger.debug('Offcloud2 %s append' % ret.name)
if ModelSetting.get_bool(
'cache_receive_info_send_telegram'):
msg = '😉 Offcloud2 캐쉬 정보 수신\n'
msg += 'Type : %s\n' % data['t']
msg += '%s\n' % data['n']
from system.model import ModelSetting as SystemModelSetting
ddns = SystemModelSetting.get('ddns')
url = '%s/%s/api/cache_download?id=%s' % (
ddns, package_name, ret.id)
if SystemModelSetting.get_bool('auth_use_apikey'):
url += '&apikey=%s' % SystemModelSetting.get(
'auth_apikey')
msg += '➕ 리모트 다운로드 추가\n<%s>' % url
import framework.common.notify as Notify
Notify.send_message(
msg, message_id='offcloud2_cache_receive')
except Exception as e:
logger.error(e)
logger.error(traceback.format_exc())
def get_list(key):
try:
value = ModelSetting.get(key)
values = [x.strip().strip() for x in value.replace('\n', '|').split('|')]
values = Util.get_list_except_empty(values)
return values
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
logger.error('Error Key:%s Value:%s', key, value)
def tving_programs():
try:
import datetime
from tving.model import ModelSetting as ModelTvingSetting
from tving.model import Episode as ModelTvingEpisode
whitelist_program = ModelTvingSetting.get('whitelist_program')
whitelist_programs = [
x.strip()
for x in whitelist_program.replace('\n', ',').split(',')
]
whitelist_programs = Util.get_list_except_empty(whitelist_programs)
month_ago = (datetime.date.today() -
datetime.timedelta(days=30)).strftime('%y%m%d')
# query = ModelTvingEpisode.query.filter((ModelTvingEpisode.call == 'auto') & (ModelTvingEpisode.broadcast_date > month_ago))
query = db.session.query(ModelTvingEpisode.program_name,
ModelTvingEpisode.channel_name)
query = query.filter((ModelTvingEpisode.call == 'auto') & (
ModelTvingEpisode.broadcast_date > month_ago))
query = query.group_by(ModelTvingEpisode.program_name)
tmp = query.all()
data = []
count = 0
for item in tmp:
data_item = {}
data_item['channel_name'] = item.channel_name
data_item['program_name'] = item.program_name.strip()
data_item['display'] = '[' + data_item[
'channel_name'] + '] ' + data_item['program_name']
if data_item['program_name'] in whitelist_programs:
data_item['whitelist'] = '1'
count = count + 1
whitelist_programs.remove(data_item['program_name'])
else:
data_item['whitelist'] = '0'
data.append(data_item)
for item in list(set(whitelist_programs)):
data_item = {}
data_item['channel_name'] = ''
data_item['program_name'] = item.strip()
data_item['display'] = data_item['program_name']
data_item['whitelist'] = '1'
count = count + 1
data.append(data_item)
data.sort(key=lambda elem: elem['display'])
return {'data': data, 'count': count, 'total': len(data)}
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def get_list(key, delimeter='\n', comment=' #'):
try:
value = ModelSetting.get(key).replace('\n', delimeter)
if comment is None:
values = [x.strip() for x in value.split(delimeter)]
else:
values = [
x.split(comment)[0].strip()
for x in value.split(delimeter)
]
values = Util.get_list_except_empty(values)
return values
except Exception as exception:
logger.error('Exception:%s', exception)
logger.error(traceback.format_exc())
logger.error('Error Key:%s Value:%s', key, value)
def get_filter(f, is_include):
tmps = [
x.strip().replace(' ', '').strip()
for x in f.replace('\n', '||').split('||')
]
tmps = Util.get_list_except_empty(tmps)
if is_include:
ret = []
for t in tmps:
tt = t.split('>>')
if len(tt) == 1:
ret.append([tt[0], None])
else:
ret.append([tt[0], tt[1]])
return ret
else:
return tmps
def scheduler_function():
try:
#logger.debug('start scheduler_function')
import ffmpeg
page = ModelSetting.get_int('auto_page')
max_pf_count = ModelSetting.get('max_pf_count')
save_path = ModelSetting.get('auto_save_path')
default_quality = Tving.get_quality_to_tving(ModelSetting.get('auto_quality'))
retry_user_abort = ModelSetting.get_bool('retry_user_abort')
except_channel = ModelSetting.get('except_channel')
except_program = ModelSetting.get(key='except_program')
download_qvod = ModelSetting.get_bool('download_qvod')
download_program_in_qvod = ModelSetting.get('download_program_in_qvod')
download_mode = ModelSetting.get(key='download_mode')
whitelist_program = ModelSetting.get('whitelist_program')
whitelist_first_episode_download = ModelSetting.get_bool('whitelist_first_episode_download')
except_channels = [x.strip() for x in except_channel.replace('\n', ',').split(',')]
except_programs = [x.strip().replace(' ', '') for x in except_program.replace('\n', ',').split(',')]
download_program_in_qvods = [x.strip().replace(' ', '') for x in download_program_in_qvod.replace('\n', ',').split(',')]
whitelist_programs = [x.strip().replace(' ', '') for x in whitelist_program.replace('\n', ',').split(',')]
except_channels = Util.get_list_except_empty(except_channels)
except_programs = Util.get_list_except_empty(except_programs)
download_program_in_qvods = Util.get_list_except_empty(download_program_in_qvods)
whitelist_programs = Util.get_list_except_empty(whitelist_programs)
logger.debug('except_channels:%s', except_channels)
logger.debug('except_programs:%s', except_programs)
logger.debug('download_qvod :%s %s', download_qvod, type(download_qvod))
logger.debug('download_program_in_qvods:%s', download_program_in_qvods)
for i in range(1, page+1):
vod_list = Tving.get_vod_list(page=i)["body"]["result"]
for vod in vod_list:
try:
if not scheduler.is_include('tving_recent'):
logger.debug('not in scheduler')
return
code = vod["episode"]["code"]
with db.session.no_autoflush:
# 2019-01-11 720권한만 있을 때 1080p를 받으려고 하면 계속 episode를 생성
#episode = db.session.query(Episode).filter_by(episode_code=code, quality=default_quality).with_for_update().first()
#episode = db.session.query(Episode).filter_by(episode_code=code).with_for_update().first()
# 2020-02-14 qvod episode_code 고정
episode = db.session.query(Episode).filter_by(episode_code=code, broadcast_date=str(vod["episode"]["broadcast_date"])[2:]).with_for_update().first()
if episode is not None:
logger.debug('program_name:%s frequency:%s %s %s', episode.program_name, episode.frequency, episode.user_abort, episode.retry)
if episode.completed:
logger.debug('COMPLETED')
continue
elif episode.user_abort:
if retry_user_abort:
episode.user_abort = False
else:
continue
elif episode.etc_abort > 10:
# 1:알수없는이유 시작실패, 2 타임오버, 3, 강제스톱.킬
# 12:제외채널, 13:제외프로그램
# 14:화이트리스트
# 9 : retry
# 8 : qvod
logger.debug('ETC ABORT:%s', episode.etc_abort)
continue
elif episode.retry > 20:
logger.debug('retry 20')
episode.etc_abort = 15
continue
# URL때문에 DB에 있어도 다시 JSON을 받아야함.
json_data, url = TvingBasic.get_episode_json(code, default_quality)
if episode is None:
logger.debug('EPISODE is none')
episode = Episode('auto')
episode = TvingBasic.make_episode_by_json(episode, json_data, url)
db.session.add(episode)
else:
episode = TvingBasic.make_episode_by_json(episode, json_data, url)
# qvod 체크
is_qvod = False
if url.find('quickvod') != -1:
is_qvod = True
# 채널, 프로그램 체크
flag_download = True
if is_qvod:
if not download_qvod:
flag_download = False
for program_name in download_program_in_qvods:
if episode.program_name.replace(' ', '').find(program_name) != -1:
episode.etc_abort = 0
flag_download = True
logger.debug('is qvod.. %s %s', program_name, flag_download)
break
if not flag_download:
episode.etc_abort = 8
db.session.commit()
logger.debug('is qvod.. pass')
continue
if download_mode == '0':
for program_name in except_programs:
if episode.program_name.replace(' ', '').find(program_name) != -1:
episode.etc_abort = 13
flag_download = False
break
if episode.channel_name in except_channels:
episode.etc_abort = 12
flag_download = False
else:
if flag_download: #무조건 탐
find_in_whitelist = False
for program_name in whitelist_programs:
if episode.program_name.replace(' ', '').find(program_name) != -1:
find_in_whitelist = True
break
if not find_in_whitelist:
episode.etc_abort = 14
flag_download = False
if not flag_download and whitelist_first_episode_download and episode.frequency == 1:
flag_download = True
if flag_download:
episode.etc_abort = 0
episode.retry += 1
episode.pf = 0 # 재시도
episode.save_path = save_path
episode.start_time = datetime.now()
db.session.commit()
else:
db.session.commit()
time.sleep(2)
continue
logger.debug('FFMPEG Start.. id:%s', episode.id)
if episode.id is None:
logger.debug('PROGRAM:%s', episode.program_name)
f = ffmpeg.Ffmpeg(url, episode.filename, plugin_id=episode.id, listener=TvingBasic.ffmpeg_listener, max_pf_count=max_pf_count, call_plugin='%s_recent' % package_name, save_path=save_path)
f.start_and_wait()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
#break
#logger.debug('end scheduler_function')
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def scheduler_function_torrent_check(self):
try:
last_id = ModelSetting.get_int('last_id')
except_program = ModelSetting.get('except_program')
except_programs = [x.strip().replace(' ', '').strip() for x in except_program.replace('\n', '|').split('|')]
except_programs = Util.get_list_except_empty(except_programs)
whitelist_program = ModelSetting.get('whitelist_program')
whitelist_programs = [x.strip().replace(' ', '').strip() for x in whitelist_program.replace('\n', '|').split('|')]
whitelist_programs = Util.get_list_except_empty(whitelist_programs)
except_genre = ModelSetting.get('except_genre')
except_genres = [x.strip() for x in except_genre.replace('\n', '|').split('|')]
except_genres = Util.get_list_except_empty(except_genres)
whitelist_genre = ModelSetting.get('whitelist_genre')
whitelist_genres = [x.strip() for x in whitelist_genre.replace('\n', '|').split('|')]
whitelist_genres = Util.get_list_except_empty(whitelist_genres)
# rssbot에서 데이터를 가져온다.
flag_first = False
if last_id == -1:
flag_first = True
# 최초 실행은 -1로 판단하고, 봇을 설정안했다면 0으로
query = db.session.query(ModelBotDownloaderKtvItem) \
.filter(ModelBotDownloaderKtvItem.created_time > datetime.datetime.now() + datetime.timedelta(days=-1))
items = query.all()
else:
condition = []
tmp = datetime.datetime.now() - datetime.timedelta(minutes=ModelSetting.get_int('delay_time'))
#condition.append( and_(ModelBotDownloaderKtvItem.id > last_id, (ModelBotDownloaderKtvItem.created_time + datetime.timedelta(minutes=ModelSetting.get_int('delay_time'))) < datetime.datetime.now() ))
condition.append( and_( ModelBotDownloaderKtvItem.id > last_id, ModelBotDownloaderKtvItem.created_time < tmp ))
condition.append( and_(ModelBotDownloaderKtvItem.download_status.like('Delay'), ModelBotDownloaderKtvItem.delay_time < datetime.datetime.now() ))
query = db.session.query(ModelBotDownloaderKtvItem)
query = query.filter(or_(*condition))
items = query.all()
# 하나씩 판단....
logger.debug('XXX %s count :%s', last_id, len(items))
for item in items:
try:
flag_download = False
item.download_status = ''
item.downloader_item_id = None
item.log = u''
logger.debug('title:%s daum:%s date:%s no:%s', item.daum_title, item.daum_id, item.filename_date, item.filename_number)
option_auto_download = ModelSetting.get('option_auto_download')
if option_auto_download == '0':
item.download_status = 'no'
else:
if item.daum_genre is None:
item.download_status = 'False_no_meta'
else:
# PLEX
if ModelSetting.get_bool('use_plex_data'):
self.search_plex_data(item)
flag_download = self.condition_check_plex(item)
if not flag_download and not item.download_status.startswith('False'):
flag_download = self.condition_check_download_mode(item, except_genres, whitelist_genres, except_programs, whitelist_programs)
if flag_download:
flag_download = self.condition_check_duplicate(item)
if flag_download:
flag_download = self.condition_check_filename(item)
if flag_download:
flag_download = self.condition_check_delay(item)
if flag_download == False and item.download_status == 'Delay':
continue
if flag_download:
flag_download = self.condition_check_server_id_mod(item)
#다운로드
if flag_download:
if option_auto_download == '1':
if item.folderid is not None and ModelSetting.get('share_receive_option') == '3':
try:
from gd_share_client.logic_user import LogicUser
#ret = LogicUser.torrent_copy(item.folderid, '', '', my_remote_path=ModelSetting.get('remote_path'))
ret = LogicUser.copy_with_json(item.folderid, ModelSetting.get('remote_path'))
item.download_status = 'True_gdrive_share'
item.share_copy_time = datetime.datetime.now()
except:
pass
else:
import downloader
logger.debug(u'다운로드 요청')
downloader_item_id = downloader.Logic.add_download2(item.magnet, ModelSetting.get('torrent_program'), ModelSetting.get('path'), request_type=package_name, request_sub_type='', server_id='ktv_%s_%s_%s' % (item.server_id, item.file_count, item.total_size))['downloader_item_id']
item.downloader_item_id = downloader_item_id
else:
item.download_status = 'True_only_status'
else:
if option_auto_download == '1':
item.download_status = 'False'
else:
item.download_status = 'False_only_status'
if ModelSetting.get_bool('download_start_send_telegram'):
flag_notify = True
if ModelSetting.get_bool('download_start_send_telegram_only_true'):
if item.download_status != 'True':
flag_notify = False
if flag_notify:
self.send_telegram_message(item)
item.download_check_time = datetime.datetime.now()
db.session.add(item)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
finally:
logger.debug('item status : %s', item.download_status)
new_last_id = last_id
if flag_first and len(items) == 0:
new_last_id = '0'
else:
if len(items) > 0:
new_last_id = '%s' % items[len(items)-1].id
if new_last_id != last_id:
ModelSetting.set('last_id', str(new_last_id))
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def scheduler_function():
try:
logger.debug('Wavve scheduler_function start..')
LogicBasic.login()
page = int(ModelSetting.get('auto_page'))
max_pf_count = ModelSetting.get('max_pf_count')
save_path = ModelSetting.get('auto_save_path')
auto_quality = ModelSetting.get('auto_quality')
retry_user_abort = (ModelSetting.get('retry_user_abort') == 'True')
credential = ModelSetting.get('credential')
qvod_download = (ModelSetting.get('qvod_download') == 'True')
except_channel = ModelSetting.get('except_channel')
except_program = ModelSetting.get('except_program')
download_program_in_qvod = ModelSetting.get(
'download_program_in_qvod')
download_mode = ModelSetting.get('download_mode')
whitelist_program = ModelSetting.get('whitelist_program')
whitelist_first_episode_download = (
ModelSetting.get('whitelist_first_episode_download') == 'True')
except_channels = [
x.strip() for x in except_channel.replace('\n', ',').split(',')
]
except_programs = [
x.strip().replace(' ', '')
for x in except_program.replace('\n', ',').split(',')
]
download_program_in_qvods = [
x.strip().replace(' ', '')
for x in download_program_in_qvod.replace('\n', ',').split(',')
]
whitelist_programs = [
x.strip().replace(' ', '')
for x in whitelist_program.replace('\n', ',').split(',')
]
Util.get_list_except_empty(except_channels)
except_channels = Util.get_list_except_empty(except_channels)
except_programs = Util.get_list_except_empty(except_programs)
download_program_in_qvods = Util.get_list_except_empty(
download_program_in_qvods)
whitelist_programs = Util.get_list_except_empty(whitelist_programs)
logger.debug('except_channels:%s', except_channels)
logger.debug('except_programs:%s', except_programs)
logger.debug('qvod_download :%s %s', qvod_download,
type(qvod_download))
for i in range(1, page + 1):
vod_list = Wavve.vod_newcontents(page=i)['list']
#logger.debug(vod_list)
logger.debug('Page:%s vod len:%s', page, len(vod_list))
for vod in vod_list:
try:
while True:
if LogicRecent.current_auto_count_ffmpeg < int(
ModelSetting.get('auto_count_ffmpeg')):
break
time.sleep(10)
#logger.debug('wavve wait : %s', LogicRecent.current_auto_count_ffmpeg)
#logger.debug(vod)
contentid = vod["contentid"]
contenttype = 'onairvod' if vod[
'type'] == 'onair' else 'vod'
episode = db.session.query(ModelWavveEpisode) \
.filter((ModelWavveEpisode.call == 'auto') | (ModelWavveEpisode.call == None)) \
.filter_by(contentid=contentid) \
.with_for_update().first() \
if episode is not None:
if episode.completed:
continue
elif episode.user_abort:
if retry_user_abort:
episode.user_abort = False
else:
#사용자 중지로 중단했고, 다시받기가 false이면 패스
continue
elif episode.etc_abort > 10:
# 1:알수없는이유 시작실패, 2 타임오버, 3, 강제스톱.킬
# 11:제외채널, 12:제외프로그램
# 13:장르제외, 14:화이트리스트 제외, 7:권한없음, 6:화질다름
#logger.debug('EPC Abort : %s', episode.etc_abort)
continue
elif episode.retry > 20:
logger.debug('retry 20')
episode.etc_abort = 9
continue
# URL때문에 DB에 있어도 다시 JSON을 받아야함.
for episode_try in range(3):
json_data = Wavve.streaming(
contenttype, contentid, auto_quality,
credential)
try:
tmp = json_data['playurl']
except:
try:
LogicBasic.login()
json_data = Wavve.streaming(
contenttype, contentid, auto_quality,
credential)
except:
pass
if json_data is None:
logger.debug('episode fail.. %s', episode_try)
time.sleep(20)
else:
break
if episode is None:
if json_data is None:
episode = ModelWavveEpisode(
'auto', info=vod, streaming=json_data)
db.session.add(episode)
db.session.commit()
continue
else:
episode = ModelWavveEpisode(
'auto', info=vod, streaming=json_data)
db.session.add(episode)
else:
if json_data is None:
continue
else:
episode.set_streaming(json_data)
if json_data['playurl'].find('preview') != -1:
episode.etc_abort = 7
db.session.commit()
continue
# 채널, 프로그램 체크
flag_download = True
if contenttype == 'onairvod':
if not qvod_download:
episode.etc_abort = 11
flag_download = False
for programtitle in download_program_in_qvods:
if episode.programtitle.replace(
' ', '').find(programtitle) != -1:
flag_download = True
episode.etc_abort = 0
break
# 시간체크
if flag_download:
logger.debug(episode.episodetitle)
match = re.compile(
r'Quick\sVOD\s(?P<time>\d{2}\:\d{2})\s'
).search(episode.episodetitle)
if match:
dt_now = datetime.now()
logger.debug(dt_now)
dt_tmp = datetime.strptime(
match.group('time'), '%H:%M')
dt_start = datetime(
dt_now.year, dt_now.month, dt_now.day,
dt_tmp.hour, dt_tmp.minute, 0, 0)
logger.debug(dt_start)
if (dt_now - dt_start).seconds < 0:
dt_start = dt_start + timedelta(
days=-1)
#detail = Wavve.vod_contents_contentid(episode.contentid)
if 'detail' not in episode.contents_json:
episode.contents_json[
'detail'] = Wavve.vod_contents_contentid(
episode.contentid)
qvod_playtime = episode.contents_json[
'detail']['playtime']
delta = (dt_now - dt_start).seconds
if int(qvod_playtime) > delta:
flag_download = False
episode.etc_abort = 8
logger.debug('QVOD %s %s %s %s',
flag_download,
match.group('time'),
qvod_playtime, delta)
else:
logger.debug('QVOD fail..')
flag_download = False
episode.etc_abort = 7
if download_mode == '0':
for program_name in except_programs:
if episode.programtitle.replace(
' ', '').find(program_name) != -1:
episode.etc_abort = 13
flag_download = False
break
if episode.channelname in except_channels:
episode.etc_abort = 12
flag_download = False
else:
if flag_download:
find_in_whitelist = False
for program_name in whitelist_programs:
if episode.programtitle.replace(
' ', '').find(program_name) != -1:
find_in_whitelist = True
break
if not find_in_whitelist:
episode.etc_abort = 14
flag_download = False
if not flag_download and whitelist_first_episode_download and episode.episodenumber == '1':
flag_download = True
#logger.debug(episode.quality)
if flag_download and episode.quality != auto_quality:
if auto_quality == '2160p' and episode.quality == '1080p' and ModelSetting.get_bool(
'2160_receive_1080'):
if episode.created_time + timedelta(
minutes=ModelSetting.get_int(
'2160_wait_minute')
) < datetime.now():
logger.debug('1080p download')
pass
else:
episode.etc_abort = 5
db.session.commit()
continue
else:
episode.etc_abort = 6
db.session.commit()
continue
if flag_download:
episode.etc_abort = 0
episode.retry += 1
episode.pf = 0 # 재시도
episode.save_path = save_path
episode.start_time = datetime.now()
db.session.commit()
else:
db.session.commit()
continue
logger.debug('FFMPEG Start.. id:%s', episode.id)
if episode.id is None:
logger.debug('PROGRAM:%s', episode.programtitle)
tmp = Wavve.get_prefer_url(episode.playurl)
f = ffmpeg.Ffmpeg(tmp,
episode.filename,
plugin_id=episode.id,
listener=LogicBasic.ffmpeg_listener,
max_pf_count=max_pf_count,
call_plugin='%s_recent' %
package_name,
save_path=save_path)
f.start()
LogicRecent.current_auto_count_ffmpeg += 1
#f.start_and_wait()
time.sleep(20)
#return
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
#db.session.rollback()
logger.debug(
'ROLLBACK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
finally:
#logger.debug('wait..')
pass
logger.debug('=======================================')
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def scheduler_function():
try:
#logger.debug('%s scheduler_function', package_name)
last_id = ModelSetting.get_int('last_id')
except_program = ModelSetting.get('except_program')
except_programs = [
x.strip().replace(' ', '').strip()
for x in except_program.replace('\n', '|').split('|')
]
except_programs = Util.get_list_except_empty(except_programs)
whitelist_program = ModelSetting.get('whitelist_program')
whitelist_programs = [
x.strip().replace(' ', '').strip()
for x in whitelist_program.replace('\n', '|').split('|')
]
whitelist_programs = Util.get_list_except_empty(whitelist_programs)
except_genre = ModelSetting.get('except_genre')
except_genres = [
x.strip() for x in except_genre.replace('\n', '|').split('|')
]
except_genres = Util.get_list_except_empty(except_genres)
whitelist_genre = ModelSetting.get('whitelist_genre')
whitelist_genres = [
x.strip()
for x in whitelist_genre.replace('\n', '|').split('|')
]
whitelist_genres = Util.get_list_except_empty(whitelist_genres)
# rssbot에서 데이터를 가져온다.
flag_first = False
if last_id == -1:
flag_first = True
# 최초 실행은 -1로 판단하고, 봇을 설정안했다면 0으로
query = db.session.query(ModelBotDownloaderKtvItem) \
.filter(ModelBotDownloaderKtvItem.created_time > datetime.datetime.now() + datetime.timedelta(days=-1))
items = query.all()
else:
condition = []
condition.append(
and_(
ModelBotDownloaderKtvItem.id > last_id,
ModelBotDownloaderKtvItem.created_time +
datetime.timedelta(
minutes=ModelSetting.get_int('delay_time')) <
datetime.datetime.now()))
#condition.append( and_(ModelBotDownloaderKtvItem.id > last_id ))
condition.append(
and_(
ModelBotDownloaderKtvItem.download_status.like(
'Delay'), ModelBotDownloaderKtvItem.delay_time <
datetime.datetime.now()))
query = db.session.query(ModelBotDownloaderKtvItem)
query = query.filter(or_(*condition))
#logger.debug(query)
items = query.all()
# 하나씩 판단....
logger.debug('XXX %s count :%s', last_id, len(items))
for item in items:
try:
flag_download = False
item.download_status = ''
item.downloader_item_id = None
item.log = ''
logger.debug('title:%s daum:%s date:%s no:%s',
item.daum_title, item.daum_id,
item.filename_date, item.filename_number)
if item.daum_genre is None:
item.download_status = 'False_no_meta'
else:
LogicNormal.search_plex_data(item)
# PLEX
if ModelSetting.get_bool('use_plex_data'):
flag_download = LogicNormal.condition_check_plex(
item)
if not flag_download and not item.download_status.startswith(
'False'):
flag_download = LogicNormal.condition_check_download_mode(
item, except_genres, whitelist_genres,
except_programs, whitelist_programs)
if flag_download:
flag_download = LogicNormal.condition_check_duplicate(
item)
if flag_download:
flag_download = LogicNormal.condition_check_filename(
item)
if flag_download:
flag_download = LogicNormal.condition_check_delay(
item)
#다운로드
if flag_download:
import downloader
logger.debug(u'다운로드 요청')
downloader_item_id = downloader.Logic.add_download2(
item.magnet,
ModelSetting.get('torrent_program'),
ModelSetting.get('path'),
request_type=package_name,
request_sub_type='')['downloader_item_id']
item.downloader_item_id = downloader_item_id
if ModelSetting.get_bool(
'download_start_send_telegram'):
LogicNormal.send_telegram_message(item)
item.download_check_time = datetime.datetime.now()
db.session.add(item)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
new_last_id = last_id
if flag_first and len(items) == 0:
new_last_id = '0'
else:
if len(items) > 0:
new_last_id = '%s' % items[len(items) - 1].id
if new_last_id != last_id:
ModelSetting.set('last_id', str(new_last_id))
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
