def save(self, w2req): w2changes: List = w2req.get('changes', None) pkey = self.primarycol.model_column model = self.primarycol.model_column.class_ updates = [] try: for row in w2changes: recid = row['recid'] if recid < 0: record = model() else: record = session.query(model).filter(pkey == recid).first() for k, v in row.items(): if k != 'recid': w2c = self.w2columns[k] setattr(record, w2c.model_column.key, v) if recid < 0: session.add(record) session.flush() newid = getattr(record, pkey.key) updated_row = self.query.filter(pkey == newid).first() else: updated_row = self.query.filter(pkey == recid).first() updates.append( dict(recid=recid, record=self.row_as_dict(updated_row))) session.commit() return jsonify(dict(status="success", updates=updates)) except SQLAlchemyError as e: session.rollback() return jsonify(dict(status="error", message=str(e)))
def get(self): args = parser.events_get_parser.parse_args(strict=True) session = g.Session() try: events = session.query(db.Events).filter( db.Events.related_class_id == args.get("class_id")).all() msg = { "i_status": 1, "err_code": -1, "msg": "", "deliver": json.dumps(events, cls=db.AlchemyEncoder) } except Exception as e: l.error(e) session.rollback() msg = { "i_status": 0, "err_code": 15, "msg": "Events query error.", "deliver": [] } finally: session.close() return msg
def teardown_request(exception): session = meta.scoped_session() if exception: session.rollback() else: session.commit() meta.scoped_session.remove()
def login(): form = LoginForm() if form.validate_on_submit(): db.engine.dispose() user = Admin.query.filter_by(email=form.email.data).first() if user == None: return render_template('login.html', men=flash('Usuario o contrasenia invalidos', 'danger'), form=form) if form.email.data == user.email and user.check_password( form.password.data): try: db.engine.dispose() login_user(user) flash('ENTRASTE', 'info') except: session.rollback() print('hubo una excepcion, y se hizo session.rollback()') next = request.args.get('next') if next == None or not next[0] == '/': next = url_for('.listado') return redirect(next) return render_template('login.html', form=form)
def restart_task(): """Reastart a task: run a task with params of another task.""" try: id = request.form['id'] filename = redisconnection.get('titles:' + id) assert filename, 'Task does not exist' assert id in \ redisconnection.lrange('tasks:' + session['username'], 0, -1), \ 'Task must belong to you.' restarted = redisconnection.get('restarted:' + id) assert not restarted, \ 'Task has already been restarted with id ' + restarted params = redisconnection.get('params:' + id) assert params, 'Could not extract the task parameters.' newid = run_task_internal(filename, pickle.loads(params)) redisconnection.set('restarted:' + id, newid) return jsonify(restart='success', id=id, taskid=newid) except Exception, e: session.rollback() return jsonify(restart='error', error=format_exception(e), traceback=traceback.format_exc())
def changeInstOp(): """ Alter an existing instrument's operator. This action can only be preformed by a system administrator .. :quickref: Alter instrument's user; Alter an instrument's operator user :param: newUsername : (String) new instrument username :param: instid : (Integer) unique instrument identifier """ Session = sessionmaker(bind=current_user.engineObj) session = Session() if('instid' in request.form): instid = request.form['instid'] elif('instid' in request.args): instid = request.args['instid'] else: raise InvalidUsage('No instrument ID provided', status_code=500) if('newUsername' in request.form): operation = request.form['newUsername'] elif('newUsername' in request.args): operation = request.args['newUsername'] else: raise InvalidUsage('No new username provided', status_code=500) try: theInst = session.query(daqbrokerDatabase.instruments).filter_by(instid=instid).first() theInst.username = operation session.commit() except Exception as e: session.rollback() raise InvalidUsage('Error : ' + str(e), status_code=500) return jsonify('done')
def delete(): repo_id = request.args.get('repo_id', '') build_id = request.args.get('build_id', '') user_id = request.args.get('user_id', '') session = request.db_session delete_target = None if build_id: delete_target = session.query(Build).get(build_id) if not request.user.can_manage: return abort(403) elif repo_id: delete_target = session.query(Repository).get(repo_id) if not request.user.can_manage: return abort(403) elif user_id: delete_target = session.query(User).get(user_id) if delete_target and delete_target.id != request.user.id and not request.user.can_manage: return abort(403) if not delete_target: return abort(404) try: session.delete(delete_target) session.commit() except Build.CanNotDelete as exc: session.rollback() utils.flash(str(exc)) referer = request.headers.get('Referer', url_for('dashboard')) return redirect(referer) utils.flash('{} deleted'.format(type(delete_target).__name__)) return redirect(url_for('dashboard'))
def list(): if request.method == 'POST': task = request.form["task"] name = request.form["name"] taskData = session.query(Task).all() engine.connect() # if user exist, do not store in users table. # otherwise insert into the table. user_id = _searchUserNumber(name) if (not _isUserExist(name)): session.add(Users(id=user_id, name=name)) session.commit() session.add( Task(task_id=len(taskData) + 1, task=task, isdone=False, user_id=user_id)) session.commit() else: session.add( Task(task_id=len(taskData) + 1, task=task, isdone=False, user_id=user_id)) session.commit() session.rollback() return redirect('http://localhost:8080/') else: return _get()
def delete(self): if not g.get('admin'): msg = { "i_status": 0, "err_code": 11, "msg": "Not login." } return msg args = class_delete_parser.parse_args(strict=True) session = g.Session() try: Class2Del = session.query(db.Classes).filter(db.Classes.id == args.get('class_id')).one() session.delete(Class2Del) session.commit() msg = { "i_status": 1, "err_code": -1, "msg": "" } except Exception as e: l.error(e) session.rollback() msg = { "i_status": 0, "err_code": 18, "msg": "Class delete err" } finally: session.close() return msg
def setActiveInstrument(): """ Toggles the current active monitoring state of an instrument .. :quickref: Toggle active state; Toggles an instrument on or off to be monitored :param: instid : (Integer) unique instrument identifier. Used to edit an existing instrument :returns: (Boolean) The resulting new monitoring state of the instrument """ Session = sessionmaker(bind=current_user.engineObj) session = Session() if('instid' in request.form): instid = request.form['instid'] elif('instid' in request.args): instid = request.args['instid'] else: raise InvalidUsage('No instrument ID provided', status_code=500) try: theInstrument = session.query(daqbrokerDatabase.instruments).filter_by(instid=instid).first() if current_user.type != 1: if theInstrument.username != current_user.username: raise InvalidUsage("You are not this instrument's operator", status_code=400) theInstrument.active = not theInstrument.active session.commit() return jsonify(theInstrument.active) except Exception as e: session.rollback() raise InvalidUsage(str(e), status_code=400)
def restart_task(): """Reastart a task: run a task with params of another task.""" try: id = request.form['id'] filename = redisconnection.get('titles:' + id) assert filename, 'Task does not exist' assert id in \ redisconnection.lrange('tasks:' + session['username'], 0, -1), \ 'Task must belong to you.' restarted = redisconnection.get('restarted:' + id) assert not restarted, \ 'Task has already been restarted with id ' + restarted params = redisconnection.get('params:' + id) assert params, 'Could not extract the task parameters.' newid = run_task_internal(filename, pickle.loads(params)) redisconnection.set('restarted:' + id, newid) return jsonify(restart='success', id=id, taskid=newid) except Exception, e: session.rollback() return jsonify( restart='error', error=format_exception(e), traceback=traceback.format_exc() )
def post(self): if g.get('admin'): msg = { "i_status": 0, "err_code": 5, "msg": "Already login." } return msg args = event_post_parser.parse_args(strict=True) session = g.Session() try: event = db.Events( related_class_id = args.get("related_class_id"), event_type = args.get("event_type"), event_title = args.get("event_title"), event_msg = args.get("event_msg"), ) session.add(event) msg = { "i_status": 1, "err_code": -1, "msg": "", } except Exception as e: l.error(e) session.rollback() msg = { "i_status": 0, "err_code": 13, "msg": "Event add err.", } finally: session.close() return msg
def toggleDatabase(): """ Toggle the active state of an existing DAQBroker database. When active, databases will have their instruments monitored for new data. .. :quickref: Toggle database status; Toggle DAQBroker database monitoring status :param: dbname : (String) database name """ Session = sessionmaker(bind=current_user.engineObjSettings) session = Session() if 'dbname' in request.form: dbname = request.form['dbname'] elif 'dbname' in request.args: dbname = request.args['dbname'] else: raise InvalidUsage('No database name provided', status_code=500) try: theDatabase = session.query( daqbrokerSettings.databases).filter_by(dbname=dbname).first() theDatabase.active = not theDatabase.active except Exception as e: session.rollback() raise InvalidUsage(str(e), status_code=500) session.commit() return jsonify('done')
def abort_task(): """Abort a task.""" try: id = request.form['id'] username = session['username'] adminabort = False try: assert id in \ redisconnection.lrange('tasks:' + username, 0, -1), \ 'Task must belong to you.' except AssertionError: if is_sudoer(username): adminabort = True else: raise worker.main.AsyncResult(id).abort() if adminabort: redisconnection.set('restarted:' + id, 'ADMINABORT') return jsonify(remove='success', id=id) except Exception, e: session.rollback() return jsonify( remove='error', error=format_exception(e), traceback=traceback.format_exc() )
def sign_in(): if current_user.is_authenticated: return redirect('/') form = LoginForm() if form.validate_on_submit(): user = Accounts.login_check(request.form.get('user_email'), request.form.get('user_password')) if user: login_user(user) try: db.session.add(user) db.session.commit() except: flash("The Database error!") traceback.print_exc(file=sys.stdout) session.rollback() return redirect('/sign_in') if current_user.UserName: flash('Welcome back: ' + current_user.UserName) else: flash('Welcome back: ' + current_user.Email) return redirect('/') else: flash('Login failed, Your name is not exist!') return redirect('/sign_in') return render_template("sign_in.html", title="Sign In", form=form)
def signup(): form = ReusableForm(request.form) if request.method == 'POST': #Creating session for user registration to send form data to database Session = sessionmaker(bind=engine) session = Session() name=request.form['name'] password=request.form['password'] email=request.form['email'] role = 'enduser' #Pass the form data to user database user = User(name,password,email,role) #Add user to the session session.add(user) if form.validate(): #Commit user data to database and rolls back and logs on exception try: session.commit() except Exception as e: session.rollback() print(e) finally: return sendEmail(name,password,email) else: #display error message in case of incorrect form data flash('Error: All the form fields are required OR Enter correct email address ') return render_template('signup.html', form=form)
def error_json(e): """Get a JSON responce on error.""" session.rollback() if isinstance(e, BaseException): return jsonify(step='error', error=format_exception(e), traceback=traceback.format_exc()) else: return jsonify(step='error', error=e, traceback=None)
def create_user(email, password, name): try: user = User(created=dt.datetime.now()) user.auth = UserAuth(name=name, password=password, email=email) session.add(user) session.commit() except IntegrityError as err: session.rollback() raise err.orig
def sessionScope(sessionClass=Session): session = sessionClass() try: yield session session.commit() except: session.rollback() raise finally: session.close()
def wrapper(self, *args, **kwargs): session = self.Session() try: result = f(self, session, *args, **kwargs) return result except IntegrityError: session.rollback() raise Exception("Error") finally: session.expunge_all() session.close()
def dbsession_scope(self): """Provide a transactional scope around a series of operations.""" session = self.Session() try: yield session session.commit() except: session.rollback() raise finally: session.close()
def insertLogComment(): """ Add an entry into an instrument's virtual log book .. :quickref: Add virtual log entry; Add an entry to an instrument's virtual log :param: instid: (integer) unique instrument identifier :param: entry: object containing the following keys: | ``date`` : (Integer) New entry timestamp (if same as ``oldDAte`` date doesn't change) | ``author`` : (String) Entry author | ``entry`` : (String) Entry text """ Session = sessionmaker(bind=current_user.engineObj) session = Session() if('instid' in request.form): instid = request.form['instid'] elif('instid' in request.args): instid = request.args['instid'] else: raise InvalidUsage('No instrument ID provided', status_code=400) if('entry' in request.form): entry = request.form['entry'] elif('entry' in request.args): entry = request.args['entry'] else: raise InvalidUsage('No log entry provided', status_code=400) if('date' in request.form): date = request.form['date'] elif('date' in request.args): date = request.args['date'] else: raise InvalidUsage('No date provided', status_code=400) if('author' in request.form): author = request.form['author'] elif('author' in request.args): author = request.args['author'] else: raise InvalidUsage('No author provided', status_code=400) try: theInst = session.query(daqbrokerDatabase.instruments).filter_by(instid=instid).first() if theInst.log: log = json.loads(theInst.log) else: log = [] log.append({'entry': entry, 'date': date, 'author': author}) theInst.log = json.dumps(log) session.commit() except Exception as e: traceback.print_exc() session.rollback() raise InvalidUsage('Error : ' + str(e), status_code=500) return jsonify('done')
def with_db(Session): session = Session() try: yield session except: session.rollback() raise else: session.commit() finally: session.close()
def deleteInstrument(): """ Delete an instrument and its data. Only instrument owners and instrument administrators are allowed to delete instruments .. :quickref: Delete instrument; Deletes an instrument and its data :param: instid: (Integer) unique instrument identifier """ Session = sessionmaker(bind=current_user.engineObj) session = Session() if request.is_json: requestCheck = request.get_json() else: requestCheck = request.form if 'instid' in requestCheck: instid = requestCheck['instid'] else: raise InvalidUsage('No instrument ID provided', status_code=400) try: theInstrument = session.query(daqbrokerDatabase.instruments).filter_by(instid=instid).first() if current_user.type != 1: if theInstrument.username != current_user.username: raise InvalidUsage("You are not this instrument's operator", status_code=400) BACKUPPATH = '' IMPORTPATH = '' ADDONPATH = '' context = zmq.Context() newPaths = checkPaths(context, BACKUPPATH, IMPORTPATH, ADDONPATH, 15000) paths = {"BACKUPPATH": newPaths[0], "IMPORTPATH": newPaths[1], "ADDONPATH": newPaths[2]} pathDel = os.path.join(paths["BACKUPPATH"], current_user.server, current_user.database, theInstrument.Name) try: shutil.rmtree(pathDel) except BaseException: traceback.print_exc() tablesDrop = [] tablesDropKeys = [] for table in daqbrokerDatabase.daqbroker_database.metadata.tables.keys(): if table == theInstrument.Name + '_data' or table == theInstrument.Name + '_custom': tablesDrop.append(daqbrokerDatabase.daqbroker_database.metadata.tables[table]) tablesDropKeys.append(table) daqbrokerDatabase.daqbroker_database.metadata.drop_all(current_user.engineObj, tables=tablesDrop) for table in tablesDropKeys: daqbrokerDatabase.daqbroker_database.metadata.remove( daqbrokerDatabase.daqbroker_database.metadata.tables[table]) session.delete(theInstrument) session.commit() return jsonify('done') except Exception as e: session.rollback() raise InvalidUsage(str(e), status_code=400)
def get(self): args = judge_commit_parser.parse_args(strict=True) session = g.Session() try: exam = session.query(db.Exams).filter(db.Exams.id == args.get("examresult_id")).one() scoreConf = func.getScoreInfo(exam.info) judgements = session.query(db.Judgement).filter(db.Judgement.related_examresults_id == args.get('examresult_id')).all() judgements = json.dumps(judgements, cls=db.AlchemyEncoder) eachPart = {} eachPercent = {} # get score conf for t in scoreConf: eachPercent[t['type']] = t['percentage'] eachPart[t['type']] = 0 eachPart[t['type'] + 'Count'] = 0 # caculate all scores for judgement in judgements: q_type = session.query(db.Questions).filter(db.Questions.id == judgement.get('q_id')).one().question_type eachPart[q_type] += judgement.score eachPart[q_type + "Count"] += 1 for t in eachPercent.keys(): score += eachPart[t] / eachPart[t + 'Count'] * eachPercent[t] score = db.Scores( stu_id = args.get('stu_id'), score = score ) session.add(score) msg = { "i_status": 1, "err_code": -1, "msg": "" } except Exception as e: l.error(e) session.rollback() msg = { "i_status": 0, "err_code": 16, "msg": "Judge commiment err." } finally: session.close() return msg
def delete(self, w2req): rowids = w2req.get('selected', None) try: for rowid in rowids: if rowid > 0: dbrec = session.query(self.model).filter( self.primarycol.model_column == rowid).first() if dbrec is not None: session.delete(dbrec) session.commit() return jsonify(dict(status="success")) except SQLAlchemyError as e: session.rollback() return jsonify(dict(status="error", message=str(e)))
def session_scope(): """Provide a transactional scope around a series of operations.""" session = Session() session.expire_on_commit = False try: yield session session.commit() except: print('LS: Roll back.') session.rollback() raise finally: print('LS: Expunge all and close') session.expunge_all() session.close()
def error_json(e): """Get a JSON responce on error.""" session.rollback() if isinstance(e, BaseException): return jsonify( step='error', error=format_exception(e), traceback=traceback.format_exc() ) else: return jsonify( step='error', error=e, traceback=None )
def sign_up(): print('sign up ing') form = SignUpForm() account = Accounts() session = db.session() if form.validate_on_submit(): account.UserName = request.form.get('user_name') account.PassWord = request.form.get('user_password') account.Type = request.form.get('account_type') account.Email = request.form.get('user_email') account.CreditCardNumber = request.form.get('credit_card') account.LastName = request.form.get('last_name') account.FirstName = request.form.get('first_name') account.Address = request.form.get('address') account.ZipCode = request.form.get('zipcode') account.Phone = None if not request.form.get( 'phone') else request.form.get('phone') register_check = Accounts.login_check(account.UserName, account.PassWord) if register_check: flash("error: The user's name or email already exists!") return redirect('/') zipcode_check = session.query(Location).filter_by( ZipCode=account.ZipCode).first() if not zipcode_check: newLocation = Location() newLocation.ZipCode = account.ZipCode newLocation.City = request.form.get('city') newLocation.State = request.form.get('state') session.add(newLocation) session.commit() try: session.add(account) session.commit() except: flash("Database error!") traceback.print_exc(file=sys.stdout) session.rollback() return redirect('/') login_user(account) flash("Sign up successful!") return redirect('/') return render_template( "profile.html", title='PROFILE', action=0, #sign up form=form)
def personaldata(user_id): form = PersonalDataForm() if form.validate_on_submit(): #personal data and bankaccount get created user = db.session.query(Users).filter_by(user_id=int(user_id)).first() pd = Personal_data(fname=form.fname.data, lname=form.lname.data, tax_nr=form.tax_nr.data, phone_nr=form.phone_nr.data, ssn=form.ssn.data, city=form.city.data, street=form.street.data, zip_code=form.zip_code.data) bank_id = uuid.uuid4() bank = Bankaccount(acc_address="FR03 " + str(bank_id), acc_number=bank_id, credit_limit=0, volume=0) #database transaction to add bankacc and personal data to database and update users, personal data and bankacc session = db.session() try: session.add(pd) session.add(bank) print("personal data und bankacc erstellt") user.ssn = pd.ssn user.acc_number = bank.acc_number pd.user_id = user.user_id bank.user_id = user.user_id print("updates durchgeführt") session.commit() except: print("rollback") session.rollback() raise finally: print("Nutzer erstllt") session.close # print(user_id) return redirect(url_for("login")) else: print("Daten falsch") return render_template("personaldata.html", title="Personal Data", form=form)
def setupSettings(): """ Create a global settings DAQBroker database on a supplied database server .. :quickref: Create global settings; create global DAQBroker settings database """ try: databaseCreated = False engineURL = current_user.engine + '://' + current_user.username + ':' + \ current_user.password + "@" + current_user.server + "/daqbroker_settings" create_database(engineURL) dbEngine = create_engine(engineURL) databaseCreated = True daqbrokerSettings.daqbroker_settings.metadata.create_all(dbEngine) mainUser = daqbrokerSettings.users(username=current_user.username, type=1) Session = sessionmaker(bind=dbEngine) session = Session() session.add(mainUser) if 'postgres' in current_user.engine: # F*****g ridiculous postgres session.execute("CREATE ROLE DAQBROKER_OPERATOR") session.execute( "GRANT SELECT ON ALL TABLES IN SCHEMA public TO DAQBROKER_OPERATOR" ) session.execute("CREATE ROLE DAQBROKER_ADMIN") session.execute( "GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO DAQBROKER_ADMIN" ) session.execute("ALTER USER DAQBROKER_ADMIN CREATEROLE CREATEDB") session.execute("CREATE ROLE DAQBROKER_USER") session.execute( "GRANT SELECT ON ALL TABLES IN SCHEMA public TO DAQBROKER_USER" ) session.execute( "ALTER DATABASE daqbroker_settings OWNER TO DAQBROKER_ADMIN") for tableName in app.tablesToActSettings: session.execute("ALTER TABLE " + tableName + " OWNER TO DAQBROKER_ADMIN") session.commit() return jsonify('done') except Exception as e: if databaseCreated: drop_database(engineURL) session.rollback() raise InvalidUsage(str(e), status_code=500) else: raise InvalidUsage("Could not connect to database", status_code=400)
def edit_movie(movie_id=None): form = PublishMovieForm() session = db.session() if not current_user.is_authenticated() or not current_user.is_admin(): return redirect('/') if movie_id: movie = session.query(Movie).filter_by(Id=movie_id).first() else: movie_id = None movie = Movie() if form.validate_on_submit(): movie.Name = request.form.get('name') movie.Type = request.form.get('movie_type') movie.NumCopies = request.form.get('copies') movie.ImageUrl = request.form.get('posterUrl') movie.TrailerUrl = request.form.get('trailerUrl') movie.Language = request.form.get('language') movie.Length = request.form.get('length') movie.Director = request.form.get('director') movie.ReleaseDate = request.form.get('releaseDate') movie.ImdbId = request.form.get('imdbId') movie.Synopsis = request.form.get('synopsis') if not movie_id: session.add(movie) try: session.commit() except: flash("Database error!") traceback.print_exc(file=sys.stdout) session.rollback() return redirect('/') print('return pro') flash(movie.Name + " is Added!") return redirect('/') form.name.data = movie.Name form.movie_type.data = movie.Type form.copies.data = movie.NumCopies form.posterUrl.data = movie.ImageUrl form.trailerUrl.data = movie.TrailerUrl form.language.data = movie.Language form.length.data = movie.Length form.director.data = movie.Director form.releaseDate.data = movie.ReleaseDate form.imdbId.data = movie.ImdbId form.synopsis.data = movie.Synopsis return render_template("publish_movie.html", movie_id=movie_id, form=form)
def session_scope(session): """ Provide a transactional scope around a series of operations. (Taken from http://docs.sqlalchemy.org/en/latest/orm/session_basics.html) WARNING: this implementation doesn't create new session, but reuses existing like: with session_scope(db.session): ... """ try: yield session.commit() except: session.rollback() raise finally: session.close()
def update_sequence_file(sequence_id, sequence_data): sequence = Sequence.query.filter_by(SequenceID=sequence_id).first() if sequence: session = db.session try: seq_components = Component.query.filter_by( SequenceID=sequence_id).all() for comp in seq_components: session.delete(comp) for reg in sequence.reagents: session.delete(reg) model_helpers.update_components(sequence_id, sequence_data) session.commit() except Exception as e: session.rollback() raise e return sequence
def main(): session = dbsession() try: req = Request() req.blind_id_header = request.headers['X-D0-Blind-Id-Detached-Signature'] req.ip_addr = request.remote_addr req.body = request.data req.create_dt = datetime.utcnow() req.next_check = datetime.utcnow() + timedelta(minutes=1) req.next_interval = 2 if not submit_request(req): session.add(req) session.commit() except Exception as e: print e session.rollback() abort(500) return "Success!"
def remove_task(): """Revove a task from list of tasks.""" try: id = request.form['id'] username = session['username'] assert id in \ redisconnection.lrange('tasks:' + username, 0, -1), \ 'Task must belong to you.' redisconnection.lrem('alltasks', id) # not StrictRedis redisconnection.lrem('tasks:' + username, id) # not StrictRedis redisconnection.delete('titles:' + id) redisconnection.delete('params:' + id) redisconnection.delete('restarted:' + id) return jsonify(remove='success', id=id) except Exception, e: session.rollback() return jsonify( remove='error', error=format_exception(e), traceback=traceback.format_exc() )
def internal_error(error): session.rollback() return render_template('errors/500.html'), 500
def submit_task(): """Handle task parameters.""" banned = check_banned() if banned: return jsonify( step='error', error='You are banned from using this tool! Reason: ' + banned ) try: if 'newtasks' not in session: session['newtasks'] = {} # Asserts if 'id' not in request.form: return jsonify( step='error', error='Your submitted data cannot be parsed. Please try again.' ) id = request.form['id'] if id not in session['newtasks']: return jsonify( step='error', error='We could not process your data due to loss of ' + 'session data. Please reload the page and try again.' ) for data in [ 'url', 'extractor', 'audio', 'video', 'subtitles', 'filename', 'format', 'formats', 'filedesc' ]: if data not in session['newtasks'][id]: return jsonify( step='error', error='We could not process your data due to loss of ' + 'session data. Please reload the page and try again.' ) # Save current data step = request.form['step'] if step == 'source': if not request.form['url'].strip(): return jsonify(step='error', error='URL cannot be empty!') formaudio = request.form['audio'] in \ [True, 'true', 'TRUE', 'True', 1, '1'] formvideo = request.form['video'] in \ [True, 'true', 'TRUE', 'True', 1, '1'] formsubtitles = request.form['subtitles'] in \ [True, 'true', 'TRUE', 'True', 1, '1'] # re-extract url data via youtube-dl need_rextract = \ request.form['url'].strip() != session['newtasks'][id]['url'] session['newtasks'][id]['url'] = request.form['url'].strip() session['newtasks'][id]['audio'] = formaudio session['newtasks'][id]['video'] = formvideo session['newtasks'][id]['subtitles'] = formsubtitles if need_rextract: rextract_url(id) relist_formats(id) elif step == 'target': if request.form['format'].strip() not in \ session['newtasks'][id]['formats']: return jsonify( step='error', error='An invalid format was requested and could ' + 'not be processed. Please reload the dialog and try again.' ) if not ( request.form['filename'].strip() and request.form['filedesc'].strip() ): return jsonify( step='error', error='Filename and file description cannot be empty!' ) session['newtasks'][id]['filename'] = \ request.form['filename'].strip() session['newtasks'][id]['format'] = \ request.form['format'].strip() session['newtasks'][id]['filedesc'] = \ request.form['filedesc'].strip() revalidate_filename(id) elif step == 'confirm': pass # nothing to do in confirm screen else: return jsonify( step='error', error='Something weird going on. ' + 'Please notify [[commons:User:Zhuyifei1999]]' ) action = request.form['action'] if step == 'source' and action == 'prev': return jsonify( step='error', error='You cannot go to the previous step of first step.') elif step == 'confirm' and action == 'next': return run_task(id) # Send new data action = {'prev': -1, 'next': 1}[action] steps = ['source', 'target', 'confirm'] step = steps[steps.index(step) + action] if step == 'source': return jsonify( id=id, step=step, url=session['newtasks'][id]['url'], audio=session['newtasks'][id]['audio'], video=session['newtasks'][id]['video'], subtitles=session['newtasks'][id]['subtitles'] ) elif step == 'target': return jsonify( id=id, step=step, filename=session['newtasks'][id]['filename'], formats=session['newtasks'][id]['formats'], format=session['newtasks'][id]['format'], filedesc=session['newtasks'][id]['filedesc'] ) elif step == 'confirm': keep = ", ".join(filter(None, [ 'video' if session['newtasks'][id]['video'] else False, 'audio' if session['newtasks'][id]['audio'] else False, 'subtitles' if session['newtasks'][id]['subtitles'] else False, ])) return jsonify( id=id, step=step, url=session['newtasks'][id]['url'], extractor=session['newtasks'][id]['extractor'], keep=keep, filename=session['newtasks'][id]['filename'], format=session['newtasks'][id]['format'], filedesc=session['newtasks'][id]['filedesc'] ) except Exception, e: session.rollback() return jsonify( step='error', error=format_exception(e), traceback=traceback.format_exc() )