def oauthCallback():
"""Handle the data send back by facebook."""
# Check if login alwaydy, if yes, redirect to home page
if not current_user.is_anonymous():
return redirect("/")
oauth=FacebookSignUp()
social_id, email=oauth.callback()
# If face book send nothing back, redirect to home page
if social_id is None:
flash("Authentication failed.")
return redirect("/")
# Check if the user already signup in our database
try:
user = session.query(FUser).filter_by(social_id=str(social_id)).one()
except:
user = None
# If user is not in database, put it in
if not user:
user = FUser(social_id=str(social_id), email=email)
session.add(user)
session.commit()
# Get the user login
login_user(user, True)
return redirect("/")
def editItem(item):
"""This page will be for editing the selected item"""
error=None
login_already=current_user.is_authenticated()
if login_already:
i = session.query(Item).filter_by(id=item).one()
if request.method == "POST":
"""Update the infomation of the item. Item's id is used for index the url.
And it won't change."""
error=vacant_input("photo")
# Check if there is any empty input except photo.
if not error:
# go on input database if no empty imput. If there any,
# reload and labels of the empty form will turn red.
i.name= request.form['name']
i.discription= request.form['discription']
i.category= request.form['category']
if request.files['photo']:
i.photo=upload_image(i.id)
# the photo file will not be change if no file upload.
session.add(i)
session.commit()
return redirect("/item/%s" %item)
c = session.query(Category).all()
return render_template("add.html", c=c, login_already=login_already, error=error)
i=session.query(Item).filter_by(id=item).one()
c=session.query(Category).all()
return render_template("edit.html", c=c, item=i, login_already=login_already, error=error)
else:
return redirect("/")
def tweet(star_id):
session = db.create_scoped_session()
try:
query = session.query(Star)
star = query.get(star_id)
if star.owner.twitterUser:
status = '#GoldStar: @' + star.owner.twitterUser + ' for ' + star.description + ' #' + star.hashtag + ' www.Goldstars.me/star/' + str(star_id)
else:
fullName = star.owner.firstName + ' ' + star.owner.lastName
status = '#GoldStar: ' + fullName + ' for ' + star.description + ' #' + star.hashtag + ' www.Goldstars.me/star/' + str(star_id)
if len(status) > 140:
cutDescriptionBy = len(status) - 135
cutDescriptionBy = len(star.description) - cutDescriptionBy
if star.owner.twitterUser:
status = '#GoldStar: @' + star.owner.twitterUser + ' for ' + star.description[0:cutDescriptionBy] + ' #' + star.hashtag + ' www.Goldstars.me/star/' + str(star_id)
else:
status = '#GoldStar: ' + fullName + ' for ' + star.description[0:cutDescriptionBy] + ' #' + star.hashtag + ' www.Goldstars.me/star/' + str(star_id)
resp = twitter.post('statuses/update.json', data = {'status': status})
return True
except Exception as ex:
userQuery = session.query(User)
user = userQuery.get(star.owner.id)
user.twitterUser = None
user.oauth_secret = None
user.oauth_token = None
session.commit()
finally:
session.close()
def teardown_request(exception):
session = meta.scoped_session()
if exception:
session.rollback()
else:
session.commit()
meta.scoped_session.remove()
def toggle_complete(task_id):
session = Session()
if request.method == 'POST':
task = session.query(Task).filter_by(id=task_id).all()[0]
task.is_complete = not task.is_complete
session.commit()
return redirect('/')
def create_case(self, user, case_name, conf_builder, project_name, flow_name, properties=None, start=True):
case = Case(
owner_id=user.id,
name=case_name,
project_name=project_name,
flow_name=flow_name,
conf=conf_builder.get_conf(),
properties=Data.element(properties))
session = db.Session()
session.add(case)
session.commit()
engine_case_name = "{}-{}".format(user.nick, case_name)
#while self.engine.exists_case(engine_case_name):
# engine_case_name = "{}-{}".format(user.nick, uuid4().hex[-6:])
engine_case = self.engine.create_case(engine_case_name, conf_builder, project_name, flow_name, engine_case_name)
case.created = engine_case.created
case.engine_name = engine_case_name
session.commit()
if start:
engine_case.start()
return case
def set_garbage():
j = sanitize_set_garbage(request.get_json(force=True,silent=True))
if not j:
example = json.dumps({ "id":"123",
"price_bonus":12.34 })
return json.dumps({ 'error': ('provide a valid json body! example: %s' % (example,)) }), 400
session = db.Session()
print "bla"
tid = j['id']
try:
task = session.query(db.OpenTask).filter(db.OpenTask.id == tid).one()
except NoResultFound:
session.close()
return json.dumps({ 'error': 'id does not exists' }), 400
except MultipleResultsFound:
session.close()
return json.dumps({ 'error': 'more than one result found' }), 400
print(task.id)
session.delete(task)
session.commit()
result = { 'error': None, 'success': True }, 200
return json.dumps(result)
def set_bonus():
j = sanitize_set_bonus(request.get_json(force=True,silent=True))
if not j:
example = json.dumps({ "id":"123",
"price_bonus":12.34 })
return json.dumps({ 'error': ('provide a valid json body! example: %s' % (example,)) }), 400
session = db.Session()
tid = j['id']
if session.query(db.OpenTask).filter(db.OpenTask.id == tid).count() == 0:
session.close()
return json.dumps({ 'error': 'id does not exists' }), 400
else:
session.close()
session = db.Session()
tasks = session.query(db.OpenTask).filter(db.OpenTask.id == tid)
for task in tasks:
task.price_bonus = j['price_bonus']
session.commit()
result = { 'error': None, 'success': True }, 200
return json.dumps(result)
session.commit()
def init_db():
session=Session()
Blog.objects.sync_table()
SiteConfig.objects.sync_table()
if not list(SiteConfig.objects.all()):
SiteConfig.objects.create(user_name=u'admin',password=touni(hash_passwd('123456')),site_name=u'DEMO Blog')
session.commit()
def apaga_contato(id):
try:
contato = session.query(Contatos).filter_by(id=id).first()
session.delete(contato)
session.commit()
finally:
pass
def delete_event():
id = request.args.get("id") # event ID
user_id = request.args.get("user_id")
e = session.query(Event).get(id)
session.delete(e)
session.commit()
return redirect("/student-life?id=" + user_id)
def edit_item(category_name, item_name):
# Allowes logged user to edit an item they own
item = get_item_with_name(item_name)
category = item.category
if request.method == "GET":
return render_template("edit_item.html", category = category, item = item)
# Processing Post Request
name = request.form.get("name")
description = request.form.get("description")
validation_result = validate_edit("Item", item, name)
valid = validation_result[0]
message = validation_result[1]
flash(message)
if valid:
item.name = name if name else item.name
item.description = description if description else item.description
session.add(item)
session.commit()
return redirect("/catalog/{0}".format(category.name))
else:
return render_template("edit_item.html", category = category, item = item)
def load_locations(session):
"""
populates locations table from seed file.
seed file is using these fields:
Region|Country|State or Province|County|Beach Name|MSW_ID used|msw id exists for this location?|
Beach Name of closest MSW data|lat|lon|
"""
with open("db_seed_data/seed_locations") as f:
reader = csv.reader(f, delimiter="|")
for row in reader:
id, region, country, state_or_prov, county, beach_name, msw_id, msw_unique_id_exists, msw_beach_name, lat, long = row
# convert string to Boolean:
if msw_unique_id_exists == "T":
msw_unique_id_exists = True
else:
msw_unique_id_exists = False
m = model.Location(
id=id, region=region, country=country, state_or_prov=state_or_prov,
county=county, beach_name = beach_name,
msw_id=msw_id, msw_unique_id_exists=msw_unique_id_exists, msw_beach_name=msw_beach_name,
lat=lat, long=long
)
session.add(m)
session.commit()
print "locations table seeded."
def receiveloop(name,radio):
radio.startListening()
data = []
x_old = 0
t_old = 0
global power, kwh, timestamp
timestamp = datetime.datetime.utcnow()
while True:
if (radio.available()):
t_new = time.time()
timestamp = datetime.datetime.utcnow()
radio.read(data)
text = u''
try:
for i in data:
text += unichr(i)
x_new = int(text[:11])
except:
print("Some error has occurred, waiting for next pulse.")
else:
power = int(7200*(x_new-x_old)/(t_new-t_old))
kwh = x_new/500
x_old = x_new
t_old = t_new
new_power = Power(timestamp, x_new, power, kwh)
session.add(new_power)
session.commit()
print("New counter value received: "+str(x_new))
def task():
j = sanitize_post_task(request.get_json(force=True,silent=True))
if not j:
example = { "id":"123",
"task_description":"Is company mentioned positive/neutral/negative in the following paragraph?",
"task_text":"lorem ipsum ...",
"answer_possibilities":["yes","no","neutral"],
"callback_link":"http://localhost:5000/webook",
"price":12.34 }
return json.dumps({ 'error': 'provide a valid json body!', 'example': example }), 400
with db.session_scope() as session:
tid = j['id']
if session.query(db.OpenTask).filter(db.OpenTask.id == tid).count() != 0:
return json.dumps({ 'error': 'id already exists' }), 400
answers = j['answer_possibilities']
answer = None
if type(answers) is type([]):
answer = "|".join(answers)
elif answers == 'text':
answer = "text"
else:
return json.dumps({ 'error': 'answer_possibilities must either be of type list ["yes","no",...] or "text"' }), 400
open_task = db.OpenTask(j['id'], j['task_description'], j['task_text'], answer, j['callback_link'], j['price'])
session.add(open_task)
session.commit()
result = { 'error': None, 'success': True }
return json.dumps(result)
def set_garbage():
j = sanitize_set_garbage(request.get_json(force=True,silent=True))
if not j:
example = json.dumps({ "id":"123",
"price_bonus":12.34 })
return json.dumps({ 'error': ('provide a valid json body! example: %s' % (example,)) }), 400
with db.session_scope() as session:
tid = j['id']
try:
task = session.query(db.OpenTask).filter(db.OpenTask.id == tid).one()
except NoResultFound:
return json.dumps({ 'error': 'id does not exists' }), 400
except MultipleResultsFound:
return json.dumps({ 'error': 'more than one result found' }), 400
logger.info("set garbage called with task id %d", task.id)
session.delete(task)
session.commit()
result = { 'error': None, 'success': True }, 200
return json.dumps(result)
def createUser(login_session):
newUser = User(name=login_session['username'], email=login_session[
'email'], picture=login_session['picture'])
session.add(newUser)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
return user.id
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 newItem():
"""This page will be for adding a new item."""
error=None
login_already=current_user.is_authenticated()
# This function will return to homepage if it found user is not login.
# There are same setting in pages below which are able to edit the database.
if login_already:
if request.method == "POST":
error = vacant_input()
if not error:
"""go on input database if no empty imput. If there any,
reload and labels of the empty form will turn red."""
time_now=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
""" Get currunt time and insert to create_time.
This will use for index items display order"""
i = Item(create_time=time_now,
name=request.form['name'],
discription=request.form['discription'],
category=request.form['category'])
session.add(i)
session.flush()
i.photo=upload_image(i.id)
session.commit()
return redirect("/")
c = session.query(Category).all()
return render_template("add.html", c=c, login_already=login_already, error=error)
c = session.query(Category).all()
return render_template("add.html", c=c, login_already=login_already, error=error)
else:
return redirect("/")
def settings():
form = SettingsForm(request.form,
username=current_user.username,
email=current_user.mail,
show_def_name=current_user.get_setting(code='show_def_name'),
show_def_desc=current_user.get_setting(code='show_def_desc'),
show_def_tags=current_user.get_setting(code='show_def_tags'),
show_def_logo=current_user.get_setting(code='show_def_logo'),
use_icy=current_user.get_setting(code='use_icy'))
if request.method == "POST" and form.validate():
if current_user.check_password(password=form.old_password.data):
if form.new_password.data:
current_user.password = User.make_password(form.new_password.data)
current_user.mail = form.email.data
current_user.set_setting(code='show_def_name', value=form.show_def_name.data)
current_user.set_setting(code='show_def_desc', value=form.show_def_desc.data)
current_user.set_setting(code='show_def_tags', value=form.show_def_tags.data)
current_user.set_setting(code='show_def_logo', value=form.show_def_logo.data)
current_user.set_setting(code='use_icy', value=form.use_icy.data)
session.commit()
flash('Settings successfully updated.')
return redirect(url_for('settings'))
else:
form.old_password.errors.append('Wrong password.')
return render_template('settings.html', form=form, username=current_user.username, TITLE='Settings')
def new_item(category_name):
# Allows a logged in user to add a new item, with him as its owner
categories = session.query(Category).all()
category = get_category_with_name(category_name)
if request.method == "GET":
return render_template("add_item.html", category = category)
# Processing Post Request
name = request.form.get("name")
description = request.form.get("description")
validation_result = validate_creation("Item", name, category.id)
valid = validation_result[0]
message = validation_result[1]
flash(message)
if valid:
item = Item(name = name, description = description, category_id = category.id, \
user_id = login_session["user_id"])
session.add(item)
session.commit()
return redirect("/catalog/{0}".format(category.name))
else:
return render_template("add_item.html", category = category)
def _case_removed(self, engine_case): session = db.Session() case = session.query(Case).filter(Case.engine_name == engine_case.name).first() if case is not None: self.case_removed.send(case, server=self, logger=self.logger) session.delete(case) session.commit()
def clear_complete():
session = Session()
if request.method == 'POST':
for task in session.query(Task).filter_by(is_complete=True).all():
if (task.is_complete):
session.delete(task)
session.commit()
return redirect('/')
def _case_finished(self, engine_case): session = db.Session() case = session.query(Case).filter(Case.engine_name == engine_case.name).first() if case is not None: case.state = engine_case.state case.finished = engine_case.finished self.case_finished.send(case, server=self, logger=self.logger) session.commit()
def load_entries(session):
"""
populates entries table from seed file.
seed file is using these fields:
user_id|datetime start|loc_id|spot_name|go_out|
swell1_ht|swell1_per|swell1_dir_deg|swell1_arrow_deg|swell1_dir_comp|
wind_speed|wind_gusts|wind_dir_deg|wind_arrow_deg|
board_id|board_pref|board_notes|buddy|gen_notes
rate_wave_challenge|rate_wave_fun|rate_crowd_den|rate_crowd_vibe|rate_overall_fun
(using msw api data collected for past dates from another app, only rounded degress available)
"""
with open("db_seed_data/seed_entries") as f:
reader = csv.reader(f, delimiter="|")
for row in reader:
print row
(user_id, datetime_start, loc_id, spot_name, go_out,
swell1_ht, swell1_per, swell1_dir_deg_global, swell1_arrow_deg, swell1_dir_comp,
wind_speed, wind_gust, wind_dir_deg, wind_arrow_deg,
board_id, board_pref, board_notes, buddy_name, gen_notes,
rate_wave_challenge, rate_wave_fun, rate_crowd_den, rate_crowd_vibe,
rate_overall_fun) = row
## convert string to datetime
date_time_start = datetime.strptime(datetime_start, "%Y-%m-%d %H:%M")
## temp using same start and end time.
date_time_end = date_time_start
swell1_dir_deg_global = float(swell1_dir_deg_global)
## convert from global deg back to deg as msw would provide
swell1_dir_deg_msw = (swell1_dir_deg_global - 180)%360
print "swell1_dir_deg_global: ", swell1_dir_deg_global
print "swell1_dir_deg_msw: ", swell1_dir_deg_msw
u = model.Entry(user_id=user_id, date_time_start=date_time_start, date_time_end=date_time_end,
loc_id=loc_id, spot_name=spot_name, go_out=go_out,
swell1_ht=swell1_ht, swell1_per=swell1_per, swell1_dir_deg_global=swell1_dir_deg_global,
swell1_dir_deg_msw=swell1_dir_deg_msw, swell1_arrow_deg=swell1_arrow_deg, swell1_dir_comp=swell1_dir_comp,
wind_speed=wind_speed, wind_gust=wind_gust,
wind_dir_deg = wind_dir_deg, wind_arrow_deg=wind_arrow_deg,
board_id=board_id, board_pref=board_pref, board_notes=board_notes,
buddy_name=buddy_name, gen_notes=gen_notes,
rate_wave_challenge=rate_wave_challenge, rate_wave_fun=rate_wave_fun,
rate_crowd_den=rate_crowd_den, rate_crowd_vibe=rate_crowd_vibe,
rate_overall_fun=rate_overall_fun)
session.add(u)
session.commit()
print "entries table seeded."
def edit_view(rid):
#debug
if(request.form.has_key('subbtn')):
subbtn = request.form['subbtn']
app.logger.debug("subbtn = %s" % subbtn)
else:
app.logger.debug("no subbtn key")
subbtn=None
rec = session.query(Records).filter(Records.id == rid).first()
form = EditForm(request.form, obj=rec)
# set choices
l = Records.getValuesFromField('phase')
form.phase.choices = listToChoices(l)
form.final_action.choices = listToChoices(Records.getValuesFromField('final_action'))
if form.validate_on_submit():
val = True
else:
val = False
if subbtn:
if subbtn == form.cancel:
app.logger.debug("cancel")
flash("Changes canceled")
return redirect('/select/')
else:
app.logger.debug("saving record")
#form.populate_obj(rec) # f***s up boolean nulls
data = form.data
for d in data:
print "ghetto populate: %s -> %s" % (d, data[d])
setattr(rec,d,data[d])
if val and not subbtn==form.saveselect:
rec.status ="%s-done" % session.query(User).filter(id=uid).first().initials
session.add(rec)
session.commit()
if subbtn == form.savenext:
rec.checkin(current_user.id)
n = getNextRecord()
msg = record.checkout(current_user.id)
flash(msg)
return redirect('/edit/%d' % n.id)
elif subbtn==form.saveselect:
flash("Record saved but not checked in")
return redirect('/select/')
if form.errors:
app.logger.debug("oh shit:")
app.logger.debug(form.errors)
flash("error")
app.logger.debug("edit form validation failed")
return render_template('records/edit.html', form=form, rec=rec, idx=AutoIncrement() )
def test_read_committee_attribute(self):
session.add(committee(name="AttrTest", chamber="House"))
session.commit()
query = session.query(committee).filter(committee.name == "AttrTest").first()
assert query is not None
assert query.chamber == "House"
def test_read_bill_attribute2(self):
session.add(bill(name="AttrTest2", house_status="Failed"))
session.commit()
query = session.query(bill).filter_by(name="AttrTest2").first()
assert query is not None
assert query.house_status == "Failed"
def test_read_legislator_attribute(self):
session.add(legislator(last_name="TESTATTR", party="Republican"))
session.commit()
query = session.query(legislator).filter(legislator.last_name == "TESTATTR").first()
assert query is not None
assert query.party == "Republican"
def add_new_med():
meds = get_medicines()
form = medication_form()
med = entities.User_med(user=current_user.id,
medication=[
Medication(
med_brand_name=form.brand.data,
med_drug=form.drug.data,
med_dosis=form.dosis.data,
med_prescribed_by=form.prescribed_by.data,
med_diagnosis=form.diagnosis.data,
med_quantity=form.quantity.data)
])
session = db.getSession(engine) #med = current_user
session.add(med)
session.commit()
return redirect('/success')
def test_read_legislator_attribute_multiple(self):
session.add(legislator(last_name="TESTATTR1", party="Republican"))
session.add(legislator(last_name="TESTATTR1", party="Democrat"))
session.commit()
queries = session.query(legislator).filter(
legislator.last_name == "TESTATTR1").all()
assert (queries is not None)
assert (len(queries) == 2)
party = []
for x in queries:
party.append(x.party)
assert (party[0] != party[1])
def scan_code():
if check(session) == False:
return jsonify({'flag': 'error', 'reason': 'time_out'})
session = request.headers.get('session')
openid = get_openid_from_session_key(session)
code = request.form.get('code')
member = session.query(Member).filter(
and_(Member.code == code, Member.activity_id == activity_id,
Member.openid == openid)).all()
if member != None:
session.delete(member)
session.commit()
os.remove('qrcode/' + str(code) + '.jpg')
os.remove('barcode/' + str(code) + '.jpg')
return jsonify({'flag': 'success'})
else:
return jsonify({'flag': 'error'})
def settings_user():
form = RegisterForm()
session = db_session.create_session()
form.account_type.render_kw['disabled'] = 'disabled'
form.password.render_kw = {
**form.about_me.render_kw, 'disabled': 'disabled',
'hidden': 'hidden'
}
form.password_repeat.render_kw = {
**form.about_me.render_kw, 'disabled': 'disabled',
'hidden': 'hidden'
}
form.photo.render_kw = {
**form.about_me.render_kw, 'disabled': 'disabled',
'hidden': 'hidden'
}
form.account_type.choices = [[
current_user.account_type,
session.query(AccountType).get(current_user.account_type).name
]]
if form.is_submitted() is False:
form.user_name.data = current_user.user_name
form.name.data = current_user.name
form.surname.data = current_user.surname
form.email.data = current_user.email
form.birthday.data = str(current_user.birthday).split()[0]
form.about_me.data = current_user.about_me
if form.is_submitted():
current_user.user_name = form.user_name.data
current_user.name = form.name.data
current_user.surname = form.surname.data
current_user.email = form.email.data
current_user.birthday = datetime.datetime.strptime(
form.birthday.data, '%Y-%m-%d')
current_user.about_me = form.about_me.data
session.merge(current_user)
session.commit()
return render_template('register.html',
action_title="Редактирование",
form=form)
def voite(work_id):
session = db_session.create_session()
work = session.query(Work).filter(Work.id == work_id).first()
if work:
if work and work.user_id == g.user.id:
result = "Нельзя голосовать за свои работы"
elif session.query(Voite).filter((Voite.work_id == work_id) & (
Voite.user_id == g.user.id)).count() != 0:
result = "Вы уже голосовали за эту работу"
else:
voite = Voite(user_id=g.user.id, work_id=work_id)
session.add(voite)
session.commit()
result = "Спасибо за ваш голос"
else:
result = "Работа не найдена"
return render_template('voite.html', title=result)
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 agregarEmpleado(nombre, apellido, puesto):
engine = create_engine('sqlite:///adminObjetosDB.db')
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
elEmpleado = Empleado(nombre=nombre,
apellido=apellido,
puesto=puesto,
activo="1")
print(elEmpleado.nombre)
print(elEmpleado.apellido)
print(elEmpleado.puesto)
print(elEmpleado.activo)
session.add(elEmpleado)
session.commit()
session.close()
engine.dispose()
def deleteBook(author_id, book_id):
if 'username' not in login_session:
return redirect('/login')
author = session.query(Author).filter_by(id=author_id).one()
bookToDelete = session.query(Book).filter_by(id=book_id).one()
if bookToDelete.user_id != login_session['user_id']:
flash('User not authorized to delete book.')
return redirect(url_for('showBooks', author_id=author.id))
if request.method == 'POST':
session.delete(bookToDelete)
session.commit()
flash('Book Successfully deleted')
return redirect(url_for('showBooks',
author_id=author_id))
else:
flash('Book not deleted')
return redirect(url_for('showBooks'))
def deleteAuthor(author_id):
if 'username' not in login_session:
return redirect('/login')
authorToDelete = session.query(Author).filter_by(id=author_id).one()
booksToDelete = session.query(Book).filter_by(idAuthor=author_id).all()
if authorToDelete.user_id != login_session['user_id']:
flash('User not authorized to delete author.')
return redirect(url_for('showAuthors'))
if request.method == 'POST':
for book in booksToDelete:
session.delete(book)
session.delete(authorToDelete)
session.commit()
flash("Author successfully deleted.")
return redirect(request.referrer)
else:
return render_template('deleteAuthor.html', author_id=author_id)
def create_club():
if request.mimetype != 'application/json':
raise Exception('Content-Type is not "application/json".')
j = request.get_json()
Session, engine = dbconnect(db_options)
session = Session()
club = Club(name=j.get('name'),
school_id=j.get('school_id'),
description=j.get('description'),
category=j.get('category'),
location=j.get('location'),
usualTime=j.get('usualTime'),
img_type=j.get('img_type', None))
session.add(club)
session.commit()
return jsonify({'id': club.id})
def subscribe():
if request.mimetype != 'application/json':
raise Exception('Content-Type is not "application/json".')
j = request.get_json()
Session, engine = dbconnect(db_options)
session = Session()
link = UserClubPositionMapping(user_id=j.get('user_id'),
club_id=j.get('club_id'),
position_id=j.get('position_id'))
session.add(link)
session.commit()
return jsonify({
'user_id': link.user_id,
'club_id': link.club_id,
'position_id': link.position_id
})
def follow(username):
user = User.query.filter_by(
username=username).first() # @UndefinedVariable
if user == None:
flash('User ' + username + ' not found.')
return redirect(url_for('index'))
if user == g.user:
flash('You can\'t follow yourself!')
return redirect(url_for('user', username=username))
u = g.user.follow(user)
if u is None:
flash('Cannot follow ' + username + '.')
return redirect(url_for('user', username=username))
session.add(u)
session.commit()
flash('You are now following ' + username + '!')
return redirect(url_for('user', username=username))
def create_user():
#create user object
#c = json.loads(request.data)
c = json.loads(request.form['values'])
user = entities.User(username=c['username'],
name=c['name'],
fullname=c['fullname'],
password=c['password'])
#send user to persistence layer
session = db.getSession(engine)
session.add(user)
session.commit()
session.close()
#Response client
r_msg = {'msg': 'UserCreated'}
json_msg = json.dumps(r_msg)
return Response(json_msg, status=201)
def edit_work(work_id):
session = db_session.create_session()
work = session.query(Work).filter(Work.id == work_id).first()
# проверяем, существует ли работа и принадлежит ли она пользователю
if work and work.user_id == g.user.id:
form = AddWorkForm(obj=work)
if request.method == 'POST' and form.validate_on_submit():
work.title = form.title.data
work.description = form.description.data
work.registered_only = form.registered_only.data
session.commit()
return redirect('/user/work/' + str(work_id))
return render_template('edit_work.html',
title='Редактирование информации о работе',
form=form)
else:
return render_template('edit_work.html', title='Работа не найдена')
def create_message():
c = json.loads(request.form['values'])
# format = '%d/%m/%Y' # The format
# datetime_str = datetime.datetime.strptime(c['sent_on'], format)
# print(datetime_str)
message = entities.Message(
content=c['content'],
# sent_on=datetime_str,
user_from_id=c['user_from_id']['username']['id'],
user_to_id=c['user_to_id']['username']['id'])
session = db.getSession(engine)
session.add(message)
session.commit()
session.close()
r_msg = {'msg': 'Message Created!'}
json_msg = json.dumps(r_msg)
return Response(json_msg, status=201)
def addJob():
addform = AddJobForm()
if addform.validate_on_submit():
session = db_session.create_session()
jobs = Jobs(
job=addform.job.data,
team_leader=addform.team_leader.data,
work_size=addform.work_size.data,
collaborators=addform.collaborators.data,
is_finished=addform.is_finished.data
)
session.add(jobs)
session.commit()
return redirect('/')
return render_template('add_job.html', title='Добавление работы', form=addform)
def no(n_click):
session = get_session()
if n_click is not None:
if session.query(dc.Current_State).all():
curr_state = session.query(dc.Current_State).all()[0]
else:
curr_state = None
id = flask.request.cookies.get('watcher_id')
if curr_state and curr_state.opened == 1:
voted = session.query(dc.Votes).filter(dc.Votes.uuid == id).filter(dc.Votes.state == curr_state.state).all()
if len(voted) == 0:
vote = dc.Votes(uuid=id, state=curr_state.state, vote='no')
session.add(vote)
session.commit()
session.close()
def index():
reg_form = RegistrationForm()
# updates database on successful registration
if reg_form.validate_on_submit():
hashed_password = generate_password_hash(reg_form.password.data, method='sha256')
username = reg_form.username.data
password = hashed_password
email = reg_form.email.data
#adding user to DB
user = User(username=username, password=password, email=email)
session.add(user)
session.commit()
return redirect(url_for('login'))
return render_template('login.html', form=reg_form)
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegisterForm()
if form.validate_on_submit():
print "Validated"
user = User(username=form.username.data,
password=form.password.data,
email=form.email.data)
session.add(user)
session.commit()
flash('Congratulations, you are now a registered user!')
print "Registered"
login_user(user, remember=form.remember_me.data)
print "Logged in"
return redirect(url_for('home'))
return render_template('register.html', title='Register', form=form)
def eliminar(id, curso, variable):
session = db.getSession(engine)
user = session.query(entities.User).filter_by(id=id).first()
curso1 = session.query(entities.Curso).filter(
entities.Curso.name == curso, entities.Curso.user_id == id).first()
nota = session.query(entities.Nota).filter(
entities.Nota.curso_id == curso1.id,
entities.Nota.variable == variable).first()
session.delete(nota)
session.commit()
resultado = 0
for nota in curso1.notas:
resultado += nota.nota * nota.porcentaje / 100
return render_template("Notas.html",
user=user,
curso=curso1,
resultado="{0:.2f}".format(resultado))
def see_all_ratings(movie_title, rating_MPAA, rating_Rotten, rating_IMDB_R,
rating_IMDB_V):
if movie.query.filter_by(title=movie_title).first():
themovie = Rating.query.filter_by(
moname=movie_title, Rotten_Tomatoes=rating_Rotten).first()
themovie.MPAA_Rating = rating_MPAA
themovie.Rotten_Tomatoes = rating_Rotten
themovie.IMDB_Rating = rating_IMDB_R
themovie.IMDB_Votes = rating_IMDB_V
# rating = Rating(moname = movie_title, MPAA_Rating = rating_MPAA, Rotten_Tomatoes = rating_Rotten, IMDB_Rating = rating_IMDB_R,IMDB_Votes = rating_IMDB_V)
session.add(themovie)
session.commit()
return "That movie {} has ratings! MPAA_Rating:{}. Rotten_Tomatoes:{}. IMDB_Rating:{}. IMDB_Votes:{}.".format(
movie_title, themovie.MPAA_Rating, themovie.Rotten_Tomatoes,
themovie.IMDB_Rating, themovie.IMDB_Votes)
else:
return "That movie doesn't have record. Please input the information and then to check."
def editName(dbid, newName):
session = loopDB.Session()
part = session.query(Part).filter(Part.dbid == dbid).first()
if part:
part.name = newName
retMessage = ["OK", partToJson(part)]
else:
retMessage = ["Error", "Part not found."]
try:
session.commit()
except:
retMessage = ["Error", "Bad name. Try again."]
session.close()
return retMessage
def populate_teams():
with open('overall_ranks.csv', 'r', encoding='utf8') as csv_file:
team_lines = csv.reader(csv_file, delimiter=',')
header = next(team_lines, None)
for t in team_lines:
q_conf = Conference.query.filter_by(ConfName=t[2]).first()
a_conf_id = q_conf.id
team_inst = Team(school_name=t[1],
conf_name=t[2],
conf_id=a_conf_id,
W=t[4],
L=t[5],
Pct=t[6],
Rk=t[0])
session.add(team_inst)
session.commit()
def buy():
session = db_session.create_session()
products = session.query(Products)
basket_ = [int(i) for i in current_user.basket.split()]
price = 0
for i in basket_:
price += float(
session.query(Products).filter(Products.id == i).first().price)
if current_user.is_vip:
price *= 0.8
if price > current_user.money:
return redirect('/not_enough')
current_user.money -= price
current_user.basket = ''
session.merge(current_user)
session.commit()
return render_template("buy.html", products=products, basket=basket_)
def spell_check():
global user_logged_in
global logged_in
# If not logged in, send to login page and stop
if not logged_in:
return redirect(url_for('login'))
form = SpellCheckForm()
textout = []
misspelled = []
uname = session.get('user_ID')
# See if text is validated
if form.validate_on_submit():
spell = SpellChecker()
inputtext = form.inputtext.data
# Parse text
words = inputtext.split()
# Find out if words are misspelled
for word in words:
if word in spell:
textout.append(word)
else:
misspelled.append(word)
# Create log record of query
query_record = Query_Record(username=uname,
querytext=inputtext,
queryresults=misspelled)
# Add query record to DB
session.add(query_record)
session.commit()
return render_template("spell_check.html",
title="Spell Check",
form=form,
spell_check=True,
textout=textout,
misspelled=misspelled,
logged_in=logged_in,
user_logged_in=user_logged_in)
def newUser():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
if username is None or password is None:
flash("Invalid Password or Username")
if session.query(User).filter_by(name=username).first() is not None:
flash("Username already exists! Try something different")
user = User(name=username)
user.hash_password(password)
session.add(user)
session.commit()
flash("Succesfully signed up")
return render_template('newlogin.html')
else:
print "hello"
return render_template('signup.html')
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 set_up_database(userid, csv_file_name):
userid_data = UserId.query.filter_by(IdNum=userid).first()
if userid_data:
pass
else:
userid_data = UserId(IdNum=userid)
session.add(userid_data)
row_lst = []
with open(csv_file_name, "r") as csvdata:
reader = csv.reader(csvdata)
for row in reader:
row_lst.append(row)
csvdata.close()
for i in row_lst[1:]:
type_data = Type.query.filter_by(TypeName=i[-1]).first()
if type_data:
pass
else:
type_data = Type(TypeName=i[-1])
session.add(type_data)
session.commit()
for i in row_lst[1:]:
type_data = Type.query.filter_by(TypeName=i[-1]).first()
userid_data = UserId.query.filter_by(IdNum=userid).first()
fan_data = Fans(
User_id=i[1],
Name=i[0],
# Rank = i[2],
Self_intro=i[2],
# Other_intro = i[4],
Fans_count=i[3],
Following_count=i[4],
# Posts_count = i[8],
Userid_id=userid_data.Id,
Type_id=type_data.Id)
session.add(fan_data)
session.commit()
def reply():
r_content = request.form['val_textarea']
q_id = request.form['question_id']
generated_id = id_generator("Replies")
session = db_session.create_session()
r = Replies(text=r_content,
question_id=q_id,
generated_id=generated_id,
user_id=current_user.id)
q_rep_num = session.query(Questions).filter(
Questions.generated_id == q_id).first()
q_rep_num.rep_num += 1
rep_num = q_rep_num.rep_num
session.add(r)
session.commit()
print(r_content, q_id, generated_id)
return jsonify({"generated_id": generated_id, "rep_num": rep_num})
def register():
"""
Method for register. Is in charge of displaying the template for the register page. Once the user is succesfully
registered, it redirects to the new home page of the user. Accept two methods: GET and POST.
If the method is POST:
-Get the necesary data sent by the user to the server (first name, last name, email and passsword).
-Check if some of the fields are empty.
-Check if the email has the standard format.
-Check if the email entered is already on the database.
-If some of the previous condition is false, it tells the user, and redirect to the register page.
-If all went fine, extract the username from the email, and create a new instance of Usuario. Fills
the fields with the corresponding variables sent, and set the status of the user to available on the server.
If the method is GET:
-Send the template corresonding to the register page.
"""
if request.method == 'POST':
name = request.form['name']
lastname = request.form['LastName']
email = request.form['email']
pwd = request.form['password']
if not name or not lastname or not email or not pwd:
flash("Missing field")
return render_template("register.html")
#Check for validity of email
r = regexp.match(email)
if r == None:
flash("Incorrect email format")
return render_template("register.html")
#Check if user not already exists
q = session.query(exists().where(Usuario.email == email)).scalar()
if q:
flash("User already register")
return render_template("register.html")
index = email.find('@')
username = email[0:index]
newUser = Usuario(nombre = name, apellido = lastname, email = email, contrasena = pwd, username = username, \
conectado = True, disponibilidad = True)
session.add(newUser)
session.commit()
return redirect(url_for("home", username=username))
else:
return render_template("register.html")
