def add_content_to_playlist(content_type, content_id, playlist_id, position=None): playlist = Playlist.query.get(playlist_id) if not isinstance(playlist, Playlist): return error_message("bad_argument", "Unable to read playlist.") if content_type == "media": content = Media.query.get(content_id) elif content_type == "action": content = Action.query.get(content_id) else: return error_message("bad_argument", "Wrong content_type.") playlist_element = PlaylistElement.build_from_content(content) if not playlist_element: return error_message("bad_argument", "Failed to create playlist element.") with redis_instance.lock("playlist_{}_add_lock".format(playlist_id)): if position: playlist.insert_element(playlist_element, position) else: playlist.add_element(playlist_element) db.session.add(playlist_element) db.session.commit() return ok()
def select_studio(element_id=None, studio_id=None): if element_id: current_element = PlaylistElement.query.get(element_id) if not current_element: return error_message("bad_argument") studio = current_element.playlist.studio elif studio_id: studio = Studio.query.get(studio_id) if not studio: return error_message("bad_argument") else: return error_message("bad_argument") liq.set_var("selected", studio.slug) # TODO: ensure all other studios are not selected anymore studio.selected = True studio.mark_as_changed() if element_id: # noinspection PyUnboundLocalVariable current_element.mark_as_done() studio.jukebox.curpos += 1 studio.mark_as_changed() db.session.commit() play_current_element.delay(studio.id)
def add_to_playlist(playlist_id): media_id = request.args.get('media_id') action_id = request.args.get('action_id') action_slug = request.args.get('action_slug') position = request.args.get('position') if position: position = int(position) if media_id: return handle_errors( tasks.add_content_to_playlist("media", int(media_id), int(playlist_id), position)) elif action_id: return handle_errors( tasks.add_content_to_playlist("action", int(action_id), int(playlist_id), position)) elif action_slug: action = Action.query.filter_by(slug=action_slug).first() if action: return handle_errors( tasks.add_content_to_playlist("action", action.id, int(playlist_id), position)) else: return jsonify(error_message("bad_argument")), 400 else: return jsonify(error_message("missing_parameters")), 400
def upload_media(): kind = request.args.get('kind') username = '******' # FIXME: Add account support uploaded_file = request.files['file'] if uploaded_file: filename = utilities.secure_filename(uploaded_file.filename) filename = decorate_filename(filename, kind, username) new_path = os.path.join(app.config['MEDIA_ROOT'], 'uploads', filename) uploaded_file.save(new_path) if not allowed_file( uploaded_file.filename) or not allowed_file_type(new_path): os.remove(new_path) return jsonify(error_message("not_allowed")) squack() return jsonify({ "status": "done", "result": new_path.replace(app.config['MEDIA_ROOT'], app.config['MEDIA_URL']) }) else: return jsonify(error_message("not_received_file"))
def skip(studio_id, element_id): studio = Studio.query.get(studio_id) element = PlaylistElement.query.get(element_id) if not isinstance(studio, Studio): return error_message("bad_argument") current_element = studio.jukebox.current_element if current_element != element: return error_message( "bad_argument", "This playlist element is not the current element anymore.") liq.send_command("{}_jukebox_stereo.skip".format(studio.slug)) current_element.mark_as_done(skipped=True) studio.jukebox.curpos += 1 studio.jukebox.mark_as_changed() studio.mark_as_changed() db.session.commit() play_current_element.delay(studio.id) return ok()
def play_media_as_bed(studio_id, media_id): studio = Studio.query.get(studio_id) media = Media.query.get(media_id) if not isinstance(studio, Studio): return error_message("bad_argument") if not isinstance(media, Media): return error_message("bad_argument") liq.set_var("{}.bed.switch".format(studio.slug), True) logger.debug("Setting media {} as bed on studio {}".format(media.id, studio.id)) load_media("bed_{}".format(studio.id), media, studio.bed_liqname) timer = max(media.length - 2, 1) logger.warning("Scheduling bed looping in {} seconds...".format(timer)) loop_bed.s(studio.id, media.id).apply_async(countdown=timer) studio.bed_on_air_since = datetime.datetime.now() studio.bed = media studio.mark_as_changed() db.session.commit() return ok(and_squack=True)
def end_record(element_id=None, studio_id=None, recorder=None): if element_id: current_element = PlaylistElement.query.get(element_id) if not current_element: return error_message("bad_argument") studio = current_element.playlist.studio elif studio_id: studio = Studio.query.get(studio_id) else: return error_message("bad_argument") if not isinstance(studio, Studio) or recorder not in ("gold", "show"): return error_message("bad_argument") recorder_name = "{}_recorder_{}".format(studio.slug, recorder) if liq.send_command("{}.status".format(recorder_name)) != "off": liq.send_command("{}.stop".format(recorder_name)) else: logger.warn("Recorder {} was already off!".format(recorder_name)) if element_id: # noinspection PyUnboundLocalVariable current_element.mark_as_done() studio.jukebox.curpos += 1 studio.mark_as_changed() db.session.commit() return ok()
def add_to_library(): filename = request.args.get("filename") tags = request.form["tags"] uploads_dir = os.path.join(app.config.get("MEDIA_ROOT"), "uploads") if filename not in os.listdir(uploads_dir): return jsonify(error_message("not_allowed")) try: tags = json.loads(tags) except ValueError: return jsonify(error_message("bad_request")) # FIXME: Filter allowed tags tags["ORIGINALFILENAME"] = filename.split("__", 2)[2] filepath = os.path.join(uploads_dir, filename) utilities.write_tags(filepath, tags) new_path = utilities.generate_new_path(filepath) if not os.path.isdir(os.path.dirname(new_path)): os.makedirs(os.path.dirname(new_path)) os.rename(filepath, new_path) utilities.rescan() return jsonify({"status": "done"})
def add_to_library(): filename = request.args.get('filename') tags = request.form['tags'] uploads_dir = os.path.join(app.config.get('MEDIA_ROOT'), "uploads") if filename not in os.listdir(uploads_dir): return jsonify(error_message("not_allowed")) try: tags = json.loads(tags) except ValueError: return jsonify(error_message("bad_request")) # FIXME: Filter allowed tags tags["ORIGINALFILENAME"] = filename.split('__', 2)[2] filepath = os.path.join(uploads_dir, filename) utilities.write_tags(filepath, tags) new_path = utilities.generate_new_path(filepath) if not os.path.isdir(os.path.dirname(new_path)): os.makedirs(os.path.dirname(new_path)) os.rename(filepath, new_path) utilities.rescan() return jsonify({"status": "done"})
def add_to_playlist(playlist_id): media_id = request.args.get('media_id') action_id = request.args.get('action_id') action_slug = request.args.get('action_slug') position = request.args.get('position') if position: position = int(position) if media_id: return handle_errors(tasks.add_content_to_playlist("media", int(media_id), int(playlist_id), position)) elif action_id: return handle_errors(tasks.add_content_to_playlist("action", int(action_id), int(playlist_id), position)) elif action_slug: action = Action.query.filter_by(slug=action_slug).first() if action: return handle_errors(tasks.add_content_to_playlist("action", action.id, int(playlist_id), position)) else: return jsonify(error_message("bad_argument")), 400 else: return jsonify(error_message("missing_parameters")), 400
def play_media_as_bed(studio_id, media_id): studio = Studio.query.get(studio_id) media = Media.query.get(media_id) if not isinstance(studio, Studio): return error_message("bad_argument") if not isinstance(media, Media): return error_message("bad_argument") liq.set_var("{}.bed.switch".format(studio.slug), True) logger.debug("Setting media {} as bed on studio {}".format( media.id, studio.id)) load_media("bed_{}".format(studio.id), media, studio.bed_liqname) timer = max(media.length - 2, 1) logger.warning("Scheduling bed looping in {} seconds...".format(timer)) loop_bed.s(studio.id, media.id).apply_async(countdown=timer) studio.bed_on_air_since = datetime.datetime.now() studio.bed = media studio.mark_as_changed() db.session.commit() return ok(and_squack=True)
def play_current_element(studio_id): studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") current_element = studio.jukebox.current_element if current_element is None: logger.warning("Nothing to play or to do. Sleeping...") return ok() with redis_instance.lock("element_{}_play".format(current_element.id)): logger.debug("Refreshing current element {} (status={})".format( current_element.id, current_element.status)) # Current element may have changed since we waited for the lock db.session.expire_all() current_element = db.session.query(PlaylistElement).get( studio.jukebox.current_element.id) logger.debug("Playing current element {} (status={})".format( current_element.id, current_element.status)) if current_element.status == 'playing': logger.warning("Already playing (current_element={})...".format( current_element.id)) return error_message("already_playing") elif current_element.status in ('ready', 'loaded'): if current_element.media: if liq.get_var("{}.jukebox.switch".format( studio.slug)) != "true": logger.warn("Jukebox was not active, activating...") liq.set_var("{}.jukebox.switch".format(studio.slug), True) if current_element.status == 'ready': load_media(current_element.id, current_element.media, studio.jukebox_liqname) current_element.status = 'playing' current_element.on_air_since = datetime.datetime.now() studio.jukebox.mark_as_changed() db.session.commit() if current_element.media: timer = max(current_element.media.length - 2, 1) logger.warning( "Scheduling task for {} seconds...".format(timer)) check_next_element.s( studio.id, current_element.id).apply_async(countdown=timer) elif current_element.action: task_name_to_schedule = current_element.action.task celery.send_task(task_name_to_schedule, kwargs={"element_id": current_element.id}) return ok()
def play_current_element(studio_id): studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") current_element = studio.jukebox.current_element if current_element is None: logger.warning("Nothing to play or to do. Sleeping...") return ok() with redis_instance.lock("element_{}_play".format(current_element.id)): logger.debug("Refreshing current element {} (status={})".format(current_element.id, current_element.status)) # Current element may have changed since we waited for the lock db.session.expire_all() current_element = db.session.query(PlaylistElement).get(studio.jukebox.current_element.id) logger.debug("Playing current element {} (status={})".format(current_element.id, current_element.status)) if current_element.status == 'playing': logger.warning("Already playing (current_element={})...".format(current_element.id)) return error_message("already_playing") elif current_element.status in ('ready', 'loaded'): if current_element.media: if liq.get_var("{}.jukebox.switch".format(studio.slug)) != "true": logger.warn("Jukebox was not active, activating...") liq.set_var("{}.jukebox.switch".format(studio.slug), True) if current_element.status == 'ready': load_media(current_element.id, current_element.media, studio.jukebox_liqname) current_element.status = 'playing' current_element.on_air_since = datetime.datetime.now() studio.jukebox.mark_as_changed() db.session.commit() if current_element.media: timer = max(current_element.media.length - 2, 1) logger.warning("Scheduling task for {} seconds...".format(timer)) check_next_element.s(studio.id, current_element.id).apply_async(countdown=timer) elif current_element.action: task_name_to_schedule = current_element.action.task celery.send_task(task_name_to_schedule, kwargs={"element_id": current_element.id}) return ok()
def remove_element_from_playlist(playlist_element_id, playlist_id): playlist_element = PlaylistElement.query.get(playlist_element_id) playlist = Playlist.query.get(playlist_id) if not playlist_element or not isinstance(playlist_element, PlaylistElement) or not isinstance(playlist, Playlist): return error_message("bad_argument") try: playlist.remove_element(playlist_element) db.session.delete(playlist_element) db.session.commit() return ok(and_squack=True) except CantDeleteError, exception: return error_message("cant_delete", exception.message)
def move_element_inside_playlist(playlist_element_id, position, playlist_id): playlist_element = PlaylistElement.query.get(playlist_element_id) playlist = Playlist.query.get(playlist_id) if not playlist_element or not isinstance(playlist_element, PlaylistElement) \ or not isinstance(playlist, Playlist) or not isinstance(position, int): return error_message("bad_argument") try: playlist.move_element(playlist_element, position) db.session.commit() return ok() except CantMoveError, exception: return error_message("cant_move", exception.message)
def remove_from_playlist(playlist_id): playlist = Playlist.query.get(int(playlist_id)) if playlist is None: return jsonify(error_message("unknown_playlist")), 400 if request.args.get('element_id'): playlist_element = PlaylistElement.query.get(int(request.args.get('element_id'))) if not playlist_element: return jsonify(error_message("unknown_element")), 400 return handle_errors(tasks.remove_element_from_playlist(playlist_element.id, playlist.id)) else: return jsonify(error_message("missing_parameters")), 400
def loop_bed(studio_id, media_id): studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") with redis_instance.lock("studio_{}_bed_lock".format(studio.id)): media = Media.query.get(studio.bed_id) if not isinstance(media, Media): return error_message("bad_argument") if media.id == media_id and studio.bed_on_air_since: last_reload_delta = (datetime.datetime.now() - studio.bed_on_air_since).total_seconds() if last_reload_delta < media.length - 10: logger.warning("Looping bed too fast! {} <= {}".format( last_reload_delta, media.length - 10)) else: if studio.bed_repeat: logger.debug("Looping media {} as bed on studio {}".format( media.id, studio.id)) load_media("bed_{}".format(studio.id), media, studio.bed_liqname) timer = max( (media.length - last_reload_delta) + media.length - 2, 1) logger.warning( "Scheduling bed looping in {} seconds...".format( timer)) loop_bed.s(studio.id, media.id).apply_async(countdown=timer) studio.bed_on_air_since = datetime.datetime.now( ) + datetime.timedelta( seconds=max(0, media.length - last_reload_delta)) else: studio.bed_on_air_since = None studio.mark_as_changed() db.session.commit() return ok(and_squack=True) pass
def move_inside_playlist(playlist_id): playlist = Playlist.query.get(int(playlist_id)) if playlist is None: return jsonify(error_message("unknown_playlist")), 400 if request.args.get('element_id') and request.args.get('position') is not None: playlist_element = PlaylistElement.query.get(int(request.args.get('element_id'))) position = int(request.args.get('position')) if not playlist_element: return jsonify(error_message("unknown_element")), 400 return handle_errors(tasks.move_element_inside_playlist(playlist_element.id, position, playlist.id)) else: return jsonify(error_message("missing_parameters")), 400
def run_studio(studio_id): studio = Studio.query.get(int(studio_id)) if studio is None: return jsonify(error_message("unknown_studio")), 400 tasks.play_current_element.delay(studio.id) return handle_errors(ok())
def remove_element_from_playlist(playlist_element_id, playlist_id): playlist_element = PlaylistElement.query.get(playlist_element_id) playlist = Playlist.query.get(playlist_id) if not playlist_element or not isinstance( playlist_element, PlaylistElement) or not isinstance( playlist, Playlist): return error_message("bad_argument") try: playlist.remove_element(playlist_element) db.session.delete(playlist_element) db.session.commit() return ok(and_squack=True) except CantDeleteError, exception: return error_message("cant_delete", exception.message)
def stop_record_gold(studio_id): studio = Studio.query.get(int(studio_id)) if studio is None: return jsonify(error_message("unknown_studio")), 400 tasks.end_record.delay(studio_id=studio.id, recorder="gold") return handle_errors(ok())
def stop_bed(studio_id): studio = Studio.query.get(int(studio_id)) if studio is None: return jsonify(error_message("unknown_studio")), 400 tasks.stop_bed.delay(studio.id) return handle_errors(ok())
def update_element(element_id): playlist_element = PlaylistElement.query.get(int(element_id)) if playlist_element is None: return jsonify(error_message("unknown_element")), 400 return handle_errors(tasks.update_element(playlist_element.id, live_content=request.form.get('live_content'), comment=request.form.get('comment')))
def select_and_run_studio(studio_id): studio = Studio.query.get(int(studio_id)) if studio is None: return jsonify(error_message("unknown_studio")), 400 tasks.select_studio.delay(studio_id=studio.id) return handle_errors(ok())
def start_bed(studio_id): studio = Studio.query.get(int(studio_id)) media_id = request.args.get('media_id') if studio is None: return jsonify(error_message("unknown_studio")), 400 tasks.play_media_as_bed.delay(studio.id, media_id) return handle_errors(ok())
def check_next_element(studio_id, element_id): db.session.expire_all() studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") current_element = studio.jukebox.current_element if not current_element: return error_message("no_current_element") if current_element.id != element_id: return error_message("probably_expired") pending_time = current_element.pending_time if pending_time > 0: next_element = studio.jukebox.element_by_position( studio.jukebox.curpos + 1) if next_element and next_element.media and next_element.status == 'ready': load_media(next_element.id, next_element.media, studio.jukebox_liqname) next_element.status = 'loaded' studio.jukebox.mark_as_changed() db.session.commit() logger.warning( "Re-scheduling task for {} seconds...".format(pending_time)) check_next_element.s( studio.id, current_element.id).apply_async(countdown=pending_time) else: logger.warning("Current element is done.") current_element.mark_as_done() studio.jukebox.curpos += 1 studio.mark_as_changed() db.session.commit() play_current_element.delay(studio.id) return ok()
def update_element(element_id): playlist_element = PlaylistElement.query.get(int(element_id)) if playlist_element is None: return jsonify(error_message("unknown_element")), 400 return handle_errors( tasks.update_element(playlist_element.id, live_content=request.form.get('live_content'), comment=request.form.get('comment')))
def remove_from_playlist(playlist_id): playlist = Playlist.query.get(int(playlist_id)) if playlist is None: return jsonify(error_message("unknown_playlist")), 400 if request.args.get('element_id'): playlist_element = PlaylistElement.query.get( int(request.args.get('element_id'))) if not playlist_element: return jsonify(error_message("unknown_element")), 400 return handle_errors( tasks.remove_element_from_playlist(playlist_element.id, playlist.id)) else: return jsonify(error_message("missing_parameters")), 400
def skip(studio_id): studio = Studio.query.get(int(studio_id)) element_id = request.args.get('element_id') if studio is None: return jsonify(error_message("unknown_studio")), 400 tasks.skip.delay(studio.id, element_id) return handle_errors(ok())
def set_bed_options(studio_id): studio = Studio.query.get(int(studio_id)) repetition = request.args.get('repetition', None) if repetition is not None: repetition = repetition == "true" if studio is None: return jsonify(error_message("unknown_studio")), 400 tasks.set_bed_options.delay(studio.id, repetition=repetition) return handle_errors(ok())
def start_live(element_id=-1): playlist_element = PlaylistElement.query.get(element_id) if not playlist_element: return error_message("bad_argument") studio = playlist_element.playlist.studio liq.set_var("{}.jukebox.switch".format(studio.slug), False) liq.set_var("{}.plateau.volume".format(studio.slug), 1.0) return ok()
def move_inside_playlist(playlist_id): playlist = Playlist.query.get(int(playlist_id)) if playlist is None: return jsonify(error_message("unknown_playlist")), 400 if request.args.get('element_id') and request.args.get( 'position') is not None: playlist_element = PlaylistElement.query.get( int(request.args.get('element_id'))) position = int(request.args.get('position')) if not playlist_element: return jsonify(error_message("unknown_element")), 400 return handle_errors( tasks.move_element_inside_playlist(playlist_element.id, position, playlist.id)) else: return jsonify(error_message("missing_parameters")), 400
def upload_media(): kind = request.args.get("kind") username = "******" # FIXME: Add account support uploaded_file = request.files["file"] if uploaded_file: filename = utilities.secure_filename(uploaded_file.filename) filename = decorate_filename(filename, kind, username) new_path = os.path.join(app.config["MEDIA_ROOT"], "uploads", filename) uploaded_file.save(new_path) if not allowed_file(uploaded_file.filename) or not allowed_file_type(new_path): os.remove(new_path) return jsonify(error_message("not_allowed")) squack() return jsonify( {"status": "done", "result": new_path.replace(app.config["MEDIA_ROOT"], app.config["MEDIA_URL"])} ) else: return jsonify(error_message("not_received_file"))
def set_bed_options(studio_id, repetition=None): studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") if repetition is not None: studio.bed_repeat = repetition studio.mark_as_changed() db.session.commit() return ok(and_squack=True)
def stop_bed(studio_id): studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") studio.bed_on_air_since = None flush_bed(studio) studio.mark_as_changed() db.session.commit() return ok(and_squack=True)
def analyze_file(): filename = request.args.get("filename") uploads_dir = os.path.join(app.config.get("MEDIA_ROOT"), "uploads") if filename not in os.listdir(uploads_dir): return jsonify(error_message("not_allowed")) filepath = os.path.join(uploads_dir, filename) tags = utilities.tags_for_file(filepath) return jsonify(dict({"status": "done"}.items() + tags.items()))
def check_next_element(studio_id, element_id): db.session.expire_all() studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") current_element = studio.jukebox.current_element if not current_element: return error_message("no_current_element") if current_element.id != element_id: return error_message("probably_expired") pending_time = current_element.pending_time if pending_time > 0: next_element = studio.jukebox.element_by_position(studio.jukebox.curpos + 1) if next_element and next_element.media and next_element.status == 'ready': load_media(next_element.id, next_element.media, studio.jukebox_liqname) next_element.status = 'loaded' studio.jukebox.mark_as_changed() db.session.commit() logger.warning("Re-scheduling task for {} seconds...".format(pending_time)) check_next_element.s(studio.id, current_element.id).apply_async(countdown=pending_time) else: logger.warning("Current element is done.") current_element.mark_as_done() studio.jukebox.curpos += 1 studio.mark_as_changed() db.session.commit() play_current_element.delay(studio.id) return ok()
def analyze_file(): filename = request.args.get('filename') uploads_dir = os.path.join(app.config.get('MEDIA_ROOT'), "uploads") if filename not in os.listdir(uploads_dir): return jsonify(error_message("not_allowed")) filepath = os.path.join(uploads_dir, filename) tags = utilities.tags_for_file(filepath) return jsonify(dict({ "status": "done", }.items() + tags.items()))
def loop_bed(studio_id, media_id): studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") with redis_instance.lock("studio_{}_bed_lock".format(studio.id)): media = Media.query.get(studio.bed_id) if not isinstance(media, Media): return error_message("bad_argument") if media.id == media_id and studio.bed_on_air_since: last_reload_delta = (datetime.datetime.now() - studio.bed_on_air_since).total_seconds() if last_reload_delta < media.length - 10: logger.warning("Looping bed too fast! {} <= {}".format(last_reload_delta, media.length - 10)) else: if studio.bed_repeat: logger.debug("Looping media {} as bed on studio {}".format(media.id, studio.id)) load_media("bed_{}".format(studio.id), media, studio.bed_liqname) timer = max((media.length - last_reload_delta) + media.length - 2, 1) logger.warning("Scheduling bed looping in {} seconds...".format(timer)) loop_bed.s(studio.id, media.id).apply_async(countdown=timer) studio.bed_on_air_since = datetime.datetime.now() + datetime.timedelta(seconds=max(0, media.length - last_reload_delta)) else: studio.bed_on_air_since = None studio.mark_as_changed() db.session.commit() return ok(and_squack=True) pass
def skip(studio_id, element_id): studio = Studio.query.get(studio_id) element = PlaylistElement.query.get(element_id) if not isinstance(studio, Studio): return error_message("bad_argument") current_element = studio.jukebox.current_element if current_element != element: return error_message("bad_argument", "This playlist element is not the current element anymore.") liq.send_command("{}_jukebox_stereo.skip".format(studio.slug)) current_element.mark_as_done(skipped=True) studio.jukebox.curpos += 1 studio.jukebox.mark_as_changed() studio.mark_as_changed() db.session.commit() play_current_element.delay(studio.id) return ok()
def update_element(element_id, live_content=None, comment=None): playlist_element = PlaylistElement.query.get(int(element_id)) if not isinstance(playlist_element, PlaylistElement): return error_message("bad_argument") if live_content is not None: playlist_element.live_content = live_content if comment is not None: playlist_element.comment = comment if playlist_element.playlist: playlist_element.playlist.mark_as_changed() db.session.commit() return ok()
def end_studio(element_id=-1): current_element = PlaylistElement.query.get(element_id) if not current_element: return error_message("bad_argument") studio = current_element.playlist.studio liq.set_var("selected", "permanent") studio.selected = False studio.mark_as_changed() current_element.mark_as_done() studio.jukebox.curpos += 1 studio.mark_as_changed() db.session.commit() # DO NOT PLAY NEXT ELEMENT (stop here) liq.set_var("{}.jukebox.switch".format(studio.slug), False) return ok()
def end_live(studio_id): studio = Studio.query.get(studio_id) if not isinstance(studio, Studio): return error_message("bad_argument") flush_bed(studio) liq.set_var("{}.jukebox.switch".format(studio.slug), True) liq.set_var("{}.jukebox.volume".format(studio.slug), 1.0) liq.set_var("{}.plateau.volume".format(studio.slug), 0.0) current_element = studio.jukebox.current_element current_element.mark_as_done() studio.jukebox.curpos += 1 studio.mark_as_changed() db.session.commit() play_current_element.delay(studio.id) return ok(and_squack=True)