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 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 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 teardown_request(exception):
session = meta.scoped_session()
if exception:
session.rollback()
else:
session.commit()
meta.scoped_session.remove()
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()
)
