async def create_playlist(window: Window):
playlists_count = db.get_session().query(Playlist).count()
default_name = f'playlist {playlists_count + 1}'
playlist_name = await window.input('new playlist name:', default_name)
playlist = Playlist(name=playlist_name)
db.get_session().add(playlist)
db.get_session().commit()
def wrapper(update: Update, context: CallbackContext) -> Any:
result = None
try:
session = get_session()
message: Message = update.effective_message
user = get_user(session, update.effective_user)
if user.banned:
message.chat.send_message("Anda dibanned!")
return result
core_context = CoreContext.from_data(update, context, session,
user)
result = func(update, core_context)
except BaseException:
msg = "Gagal menghubungi elearning! Coba beberapa saat lagi."
if update.callback_query:
update.callback_query.answer(msg, show_alert=True)
else:
update.effective_message.reply_text(msg)
except RollbackException as e:
session.rollback()
if update.callback_query:
update.callback_query.answer(e.message)
else:
update.effective_message.reply_text(e.message)
except Exception as e:
if not ignore_exception(e):
allert_devs(update, context)
finally:
if "session" in locals():
session.close()
return result
def open_playlist(self, playlist_name: str):
playlist = (
db.get_session()
.query(Playlist)
.filter(Playlist.name == playlist_name)
.one()
)
if not playlist:
logger.error(f"Unable to open playlist {playlist_name}")
return
tabs_layout = self.app.ui.tabs_layout
tab = tabs_layout.get_tab(playlist.name)
if tab:
self.remove_current_tab_from_stack()
tabs_layout.switch_to_tab(tab)
self.app.window.focus(tab.component)
else:
tracks_view = PlaylistTracksComponent(playlist)
self.remove_current_tab_from_stack()
self.app.ui.tabs_layout.add_tab(
Tab(title=playlist.name, component=tracks_view)
)
self.app.window.focus(tracks_view)
def get_user(username):
"""
查询用户
"""
db = get_session()
user = db.query(User).filter(User.username == username).first()
db.close()
return user
def filter(self, query: str):
session = db.get_session()
query = f"%{query}%"
self.data = self.query(
session.query(Playlist.name).filter(
Playlist.name.ilike(query)).scalar())
self.mark_for_redraw()
def on_delete(self, tracks: List[Track]):
session = db.get_session()
self.get_query().filter(
PlaylistTrack.track_id.in_(
t.id for t in tracks)).delete(synchronize_session=False)
session.commit()
self.load_playlist()
async def on_delete(self, playlists_names: List[str]):
session = db.get_session()
app = App.get_instance()
yesno = (await
app.window.input("Delete selected playlists? (y/n)") == "y")
if yesno:
session.query(Playlist).filter(
Playlist.name.in_(playlists_names)).delete(
synchronize_session=False)
session.commit()
self.load_playlists()
def create_operate_record(username, ip, old_object=None, new_object=None):
"""
创建修改记录
@param old_object: 修改前的类
@param new_object: 修改后的类
@param username: 修改用户名
@param ip: 修改ip
@return:
"""
# 获取修改的类名
operate_object = new_object.__class__.__name__ if new_object else old_object.__class__.__name__
# 判断修改的类型
if not old_object:
operate_type = "新增"
operate_detail = new_object.__dict__
operate_detail.pop("_sa_instance_state")
# ensure_ascii设为False,这样存入数据库不会变成unicode码
operate_detail = json.dumps(operate_detail, ensure_ascii=False)
elif not new_object:
operate_type = "删除"
operate_detail = old_object.__dict__
operate_detail.pop("_sa_instance_state")
operate_detail = json.dumps(operate_detail, ensure_ascii=False)
else:
operate_type = "修改"
# __dict__获取所有类所有属性
old_object_dict = old_object.__dict__
old_object_dict.pop("_sa_instance_state")
new_object_dict = new_object.__dict__
new_object_dict.pop("_sa_instance_state")
operate_detail = []
for field in old_object_dict.keys():
if old_object_dict[field] != new_object_dict[field]:
operate_detail.append({
"name": field,
"old": old_object_dict[field],
"new": new_object_dict[field]
})
if len(operate_detail) == 0:
# 说明没有修改,不必记录
return
operate_detail = json.dumps(operate_detail, ensure_ascii=False)
record_dict = {
"operate_object": operate_object,
"operate_type": operate_type,
"operate_detail": operate_detail,
"operate_ip": ip,
"operate_username": username
}
db = get_session()
operate_record = OperateRecords(**record_dict)
db.add(operate_record)
db.commit()
def wrapper(context: CallbackContext) -> Any:
result = None
try:
session = get_session()
result = func(context, session)
except Exception as e:
if not ignore_exception(e):
raise e
finally:
if "session" in locals():
session.close()
return result
def on_paste(self, tracks: List[Track]):
session = db.get_session()
start_index = self.get_query().count()
playlist_tracks = [
PlaylistTrack(
playlist_id=self.playlist.id,
track_id=track.id,
order=start_index + index,
) for index, track in enumerate(tracks)
]
session.bulk_save_objects(playlist_tracks)
session.commit()
self.load_playlist()
def __init__(self, **kwargs):
super().__init__(**kwargs)
session = db.get_session()
self.data = list(session.query(Track))
async def push_all_tracks(tracks_component: TracksComponent, force=False):
all_tracks = get_session().query(Track).all()
await CloudSynchronizer().push_tracks(all_tracks, force)
def get_query(self):
session = db.get_session()
return session.query(PlaylistTrack).filter(
PlaylistTrack.playlist_id == self.playlist.id)
def _mark_as_synced(self, track: Track):
track.cloud_synced = True
get_session().commit()
