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