def list_my_events(user_id):
# this page should list all of this user's events
# Option : Open or contribute to any of the events
# Option: Edit an event from the list
# Option: Create a new event... redirects to '/createevent'
# Option: Delete one of their own events... redirects to '/deleteevent'
# Gather important details on user from Stormpath
usr_id = get_pure_id(user.get_id())
usr_first_name = user.given_name
usr_last_name = user.surname
usr_username = user.username
usr_email = user.email
print "\nThe current User is :", usr_id, "\n"
# Gather details on the user's own events
usr_events = session.query(Event).filter_by(org_id=usr_id).all()
# Determine the number of events originated by this user
num_evts = len(usr_events)
response_dict = {'0': 0}
print "\nNumber of events for this user", num_evts
# Determine the number of responses for each of these events
for i in range(0, num_evts):
print "\nQuery for number of committed items for this event"
num_resp = session.query(Committed).\
filter_by(evt_id=(usr_events[i].id)).all()
response_dict.update({ (usr_events[i].id) : len(num_resp) })
return render_template('listmyevents.html',
webuserid = usr_id,
webfname = usr_first_name,
weblname = usr_last_name,
webusername = usr_username,
webevents = usr_events,
webrespdict = response_dict)
def search():
# User has the ability to search for an event based on Originator last name
# and event ID.
# gather details about searching user
usr_id = get_pure_id(user.get_id())
usr_first_name = user.given_name
usr_last_name = user.surname
usr_username = user.username
usr_email = user.email
print "The current User is :", usr_id, "\n"
if request.method == 'POST':
form = SearchForm(formdata = MultiDict(request.form))
if form.validate():
# Gather details about this event
event = session.query(Event).filter_by(id=form.evt_id.data).one()
flash('Event Found!')
return redirect(url_for('contribute',
org_id = event.org_id,
event_id = event.id))
else:
# got to this point since form data was missing
flash('Enter both required fields!')
return render_template('searchevents.html', webform = form)
else:
return render_template('searchevents.html', webform = SearchForm())
def edit_book(book_id):
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
book = Book.query.get(book_id)
if book in app_user.author.books:
if request.method == 'GET':
return render_template('edit_book.html', book=book)
genres = []
for g in request.form.get('genres').split(','):
genre_name = g.strip().title()
if not genre_name.isspace():
genre = Genre.query.filter_by(name=genre_name).first()
if not genre:
genre = Genre(genre_name)
db.session.add(genre)
genres.append(genre)
book.genres = genres
book.title = request.form.get('title')
book.isbn = request.form.get('isbn')
book.publisher = request.form.get('publisher')
book.description = request.form.get('description')
db.session.add(book)
db.session.commit()
return redirect(url_for('author_routes.author_dashboard'))
return redirect(url_for('index'))
def add_book():
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
if app_user.is_author:
if request.method == 'GET':
return render_template('add_book.html', author=app_user.author)
book_file = request.files.get('epub_file', None)
# POST is a epub file upload
if book_file.content_type == 'application/epub+zip' or book_file.content_type == 'application/octet-stream':
book_upload = BookUploader(book_file.filename, book_file)
book_location = book_upload.file_dir[:-1]
# fetch genres too!
book_data = {
'author': app_user.author,
'title': request.form.get('title'),
'publisher': request.form.get('publisher'),
'epub_url': book_location
}
book = Book.book_from_dict(**book_data)
db.session.add(book)
db.session.commit()
print book
return render_template('add_book.html', author=app_user.author)
return redirect(url_for('index'))
def purchase(book_id):
user_href = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_href))
book = Book.query.get(book_id)
app_user.purchase_book(book)
return redirect(url_for('user_routes.library'))
def purchase(book_id):
user_href = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_href))
book = Book.query.get(book_id)
app_user.purchase_book(book)
return redirect(url_for('user_routes.library'))
def showLoggedin():
# 3 options on this page
# 1. Create a new event
# 2. list my events
# 3. Search for an event (that user has been invited to)
usr_email = user.email
usr_first_name = user.given_name
usr_last_name = user.surname
usr_username = user.username
usr_id = get_pure_id(user.get_id())
print "\nCurrent user ID =" , get_pure_id(user.get_id()), user
return render_template('loggedin.html',
webemail = usr_email,
webfname = usr_first_name,
weblname = usr_last_name,
webusername = usr_username,
webuserid = usr_id)
def test_user_can_login(self):
_user = User.from_login(
TestConfig.USER_EMAIL,
TestConfig.USER_PASSWORD,
)
login_user(_user)
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
assert app_user.user_href == user_id
def test_user_can_login(self):
_user = User.from_login(
TestConfig.USER_EMAIL,
TestConfig.USER_PASSWORD,
)
login_user(_user)
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
assert app_user.user_href == user_id
def upload(id):
study = Studies.query.get(id)
if study.owner != user.get_id():
abort(401)
file = request.files['file']
dataset = Datasets.from_file(file, study)
db.session.add(dataset)
db.session.commit()
return jsonify({'success': True})
def upload(id):
study = Studies.query.get(id)
if study.owner != user.get_id():
abort(401)
file = request.files['file']
dataset = Datasets.from_file(file, study)
db.session.add(dataset)
db.session.commit()
return jsonify({
'success': True
})
def new_contact():
form = AddContactForm()
if form.validate_on_submit():
new_contact = Contact(form.name.data, form.email.data, form.phone.data,
form.comment.data, form.lead_source.data,
user.get_id(), user.custom_data['tenant_id'])
db.session.add(new_contact)
db.session.commit()
return redirect(url_for('dashboard.dashboard_home'))
return render_template('dashboard/add_contact.html',
action='Add',
form=form)
def contact_detail(contact_id):
form = AddNoteForm()
contact = Contact.query.filter_by(id=contact_id, tenant_id=user.custom_data["tenant_id"]).first_or_404()
notes = contact.notes
if form.validate_on_submit():
new_note = Note(form.content.data, user.get_id(), user.custom_data["tenant_id"], contact.id)
db.session.add(new_note)
db.session.commit()
return redirect(url_for("dashboard.contact_detail", contact_id=contact.id))
return render_template("dashboard/contact_detail.html", contact=contact, notes=notes, form=form)
def study(id):
study = Studies.query.get(id)
if study.owner != user.get_id():
abort(401)
page = int(request.args.get('page') or 1)
datasets = study.datasets\
.order_by(Datasets.created_at.desc())\
.paginate(page, per_page=15)
return render_template('study.html',
study=study,
datasets=datasets.items,
pagination=datasets)
def point():
json = request.get_json()
point = DataPoints.query.get(json['id'])
if point.dataset.study.owner != user.get_id():
abort(401)
point.selected = json['selected'] == 1
print point
print point.timestamp
db.session.add(point)
db.session.commit()
return jsonify({"success": True})
def study(id):
study = Studies.query.get(id)
if study.owner != user.get_id():
abort(401)
page = int(request.args.get('page') or 1)
datasets = study.datasets\
.order_by(Datasets.created_at.desc())\
.paginate(page, per_page=15)
return render_template('study.html',
study=study,
datasets=datasets.items,
pagination=datasets)
def add_book():
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
if app_user.is_author:
if request.method == 'GET':
return render_template('add_book.html', author=app_user.author)
book_file = request.files.get('epub_file', None)
cover_file = request.files.get('cover_file', None)
# POST is a epub file upload
if book_file.content_type == 'application/epub+zip' or book_file.content_type == 'application/octet-stream':
book_upload = BookUploader(book_file.filename, book_file,
cover_file)
epub_url = S3URL + 'epubs/' + book_upload.epub_key
cover_url = CLOUDFRONTURL + book_upload.cover_key
genres = []
for g in request.form.get('genres').split(','):
genre_name = g.strip().title()
if not genre_name.isspace():
genre = Genre.query.filter_by(name=genre_name).first()
if not genre:
genre = Genre(genre_name)
db.session.add(genre)
genres.append(genre)
book_data = {
'author': app_user.author,
'isbn': request.form.get('isbn'),
'title': request.form.get('title'),
'publisher': request.form.get('publisher'),
'description': request.form.get('description'),
'genres': genres,
'epub_url': epub_url,
'cover_large': cover_url
}
book = Book.book_from_dict(**book_data)
db.session.add(book)
db.session.commit()
return redirect(url_for('author_routes.author_dashboard'))
return redirect(url_for('index'))
def new_contact():
form = AddContactForm()
if form.validate_on_submit():
new_contact = Contact(
form.name.data,
form.email.data,
form.phone.data,
form.comment.data,
form.lead_source.data,
user.get_id(),
user.custom_data["tenant_id"],
)
db.session.add(new_contact)
db.session.commit()
return redirect(url_for("dashboard.dashboard_home"))
return render_template("dashboard/add_contact.html", action="Add", form=form)
def point():
json = request.get_json()
point = DataPoints.query.get(json['id'])
if point.dataset.study.owner != user.get_id():
abort(401)
point.selected = json['selected'] == 1
print point
print point.timestamp
db.session.add(point)
db.session.commit()
return jsonify({
"success": True
})
def contact_detail(contact_id):
form = AddNoteForm()
contact = Contact.query.filter_by(
id=contact_id, tenant_id=user.custom_data['tenant_id']).first_or_404()
notes = contact.notes
if form.validate_on_submit():
new_note = Note(form.content.data, user.get_id(),
user.custom_data['tenant_id'], contact.id)
db.session.add(new_note)
db.session.commit()
return redirect(
url_for('dashboard.contact_detail', contact_id=contact.id))
return render_template('dashboard/contact_detail.html',
contact=contact,
notes=notes,
form=form)
def settings():
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
if request.method == 'GET':
return render_template('author_settings.html', author=app_user.author)
if not app_user.is_author:
author = Author.author_from_dict(**request.form.to_dict())
db.session.add(author)
db.session.commit()
app_user.become_author(author)
## TODO Handle edit author attributes
"""
if app_user.is_author:
author_name = request.form.get('author_name')
if author_name != app_user.author.name:
app_user.author.update_name(author_name)
"""
return render_template('author_settings.html', author=app_user.author)
def dataset(id):
import time
dataset = Datasets.query.get(id)
if dataset.study.owner != user.get_id():
abort(401)
# Grab the list of datasets in this study
# What page is this dataset?
# has_next?
# has_prev?
prev_ds = dataset.prev()
next_ds = dataset.next()
def clean_selected(sel):
if not sel:
return 0
if sel:
return 1
return 0
graph_points = [{
"id": x.id,
"selected": 0,
"temp_c": x.value,
"time": x.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
"selected": clean_selected(x.selected)
} for x in dataset.data_points]
return render_template('dataset.html',
dataset=dataset,
notes=dataset.notes,
points=dataset.data_points,
points_json=json.dumps(graph_points),
next_ds=next_ds,
prev_ds=prev_ds)
def dataset(id):
import time
dataset = Datasets.query.get(id)
if dataset.study.owner != user.get_id():
abort(401)
# Grab the list of datasets in this study
# What page is this dataset?
# has_next?
# has_prev?
prev_ds = dataset.prev()
next_ds = dataset.next()
def clean_selected(sel):
if not sel:
return 0
if sel:
return 1
return 0
graph_points = [{
"id": x.id,
"selected": 0,
"temp_c": x.value,
"time": x.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
"selected": clean_selected(x.selected)
} for x in dataset.data_points]
return render_template('dataset.html',
dataset=dataset,
notes=dataset.notes,
points=dataset.data_points,
points_json=json.dumps(graph_points),
next_ds=next_ds,
prev_ds=prev_ds)
@auth_routes.route('/authorize_ios', methods=['POST'])
def authorize_iOS():
""" User login/auth/session management """
username = request.form.get('username', '')
password = request.form.get('password', '')
user = None
try:
user = User.from_login(username, password)
except StormpathError, err:
pass
if user:
app_user = AppUser.query.get(stormpathUserHash(user.get_id()))
t = make_secure_token(username + password)
if app_user.ios_token != t:
app_user.set_ios_token(t)
return jsonify({
'username': user.username,
'user_id': app_user.user_id,
'authenticated': True,
'ios_token': t
})
else:
return jsonify({
'username': username,
'authenticated': False,
'ios_token': None
})
@auth_routes.route('/authorize_ios', methods=['POST'])
def authorize_iOS():
""" User login/auth/session management """
username = request.form.get('username', '')
password = request.form.get('password', '')
user = None
try:
user = User.from_login(username, password)
except StormpathError, err:
pass
if user:
app_user = AppUser.query.get(stormpathUserHash(user.get_id()))
t = make_secure_token(username + password)
if app_user.ios_token != t:
app_user.set_ios_token(t)
return jsonify({ 'username': user.username,
'user_id': app_user.user_id,
'authenticated': True,
'ios_token': t
})
else:
return jsonify({ 'username': username,
'authenticated': False,
'ios_token': None
})
@auth_routes.route('/logout')
def create_event(user_id):
# User should be able to create a new event & add details about event
# Gather important details on user from Stormpath
usr_id = get_pure_id(user.get_id())
usr_first_name = user.given_name
usr_last_name = user.surname
usr_username = user.username
usr_email = user.email
print "The current User is :", usr_id, "\n"
if request.method == 'POST':
# Gather posted data of details about this event
form = CreateForm(formdata = MultiDict(request.form))
if form.validate():
# Gather details about this event
# prepare items to be posted into event table
date1 = datetime.date(int(form.evt_year.data),
int(form.evt_month.data),
int(form.evt_day.data))
time1 = str(form.evt_hour.data + ":" +\
form.evt_minute.data + form.evt_tz.data)
Event1 = Event(org_id = usr_id,
org_username = usr_username,
org_fname = usr_first_name,
org_lname = usr_last_name,
evt_num = form.evt_num.data,
evt_date = date1,
evt_time = time1,
evt_name = form.evt_name.data,
evt_location = form.evt_location.data,
evt_address = form.evt_address.data,
evt_city = form.evt_city.data,
evt_state = form.evt_state.data,
evt_zip = form.evt_zip.data,
evt_notes = form.evt_notes.data,
evt_image = 'party01.jpg')
session.add(Event1)
session.flush()
session.refresh(Event1) # get the id of the last added event
new_event_id = int(Event1.id)
# prepare items to be posted into Requested table
for x in categories:
# create a reference string for current category
field1 = "req_%s_qty" % x
field2 = "req_%s_note" % x
# use reference string to retrieve form data for QTY & Note
current_req_qty = getattr(form, field1).data
current_req_note = getattr(form, field2).data
# if requested QTY > 0 then persist requested data to db
if int(current_req_qty) > 0:
Req1 = Requested(evt_id = new_event_id,
category = get_real_cat(x),
qty_rqst = current_req_qty,
rqst_note = current_req_note)
session.add(Req1)
session.flush()
session.commit()
# if data persisted correctly redirect to "List my Events"
return redirect(url_for('list_my_events',
user_id = user_id))
else:
# got to this point since form data was missing
print "CreateForm did not validate!"
flash('Enter required fields!')
return render_template('createevent.html',
webform = form,
webevent_org_id = usr_id)
else:
# GET Method
return render_template('createevent.html',
webform = CreateForm(),
webevent_org_id = usr_id,
webuser_email = usr_email,
webuser_fname = usr_first_name,
webuser_lname = usr_last_name,
webuserid = usr_id)
def author_dashboard():
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
if app_user.is_author:
return render_template('author_dashboard.html', author=app_user.author)
def get_user():
url = user.get_id()
return url.split('/')[-1]
def edit_event(user_id, evt_id):
# User has the ability to edit an event that they created.
# Gather important details on user from Stormpath
usr_id = get_pure_id(user.get_id())
usr_first_name = user.given_name
usr_last_name = user.surname
usr_username = user.username
usr_email = user.email
print "\nThe current User is :", usr_id, "\n"
# Gather details on this event to be edited
print "\nQuery for Event"
event = session.query(Event).filter_by(id=evt_id).one()
print "\nQuery for Requested Items for this event"
req = session.query(Requested).filter_by(evt_id=evt_id).all()
# Initialize request qty variables Dictionary to integer
req_qty_dct = {'req_app_qty' : 0, 'req_main_qty' : 0, 'req_side_qty' : 0,
'req_bread_qty' : 0, 'req_dessert_qty' : 0,
'req_bev_qty' : 0, 'req_uten_qty' : 0, 'req_cups_qty' : 0,
'req_misc_qty' :0}
# Initialize request note variables Dictionary
req_note_dct = {'req_app_note' : "", 'req_main_note' : "",
'req_side_note' : "", 'req_bread_note' : "",
'req_dessert_note' : "", 'req_bev_note' : "",
'req_uten_note' : "", 'req_cups_note' : "",
'req_misc_note' : ""}
# iterate thru all categories and store requested items from db into
# local variable dictionaries
for x in categories:
# create a reference string for current category
field1 = "req_%s_qty" % x
field2 = "req_%s_note" % x
# use reference string to store requested items QTY & Note
# storing db values into dictionaries
for item in req:
if item.category == get_real_cat(x):
req_qty_dct[field1] = item.qty_rqst
req_note_dct[field2] = item.rqst_note
# handle Posted Form Data #########################################
if request.method == 'POST':
# create a dict that translates form names to database field names
event_fields = ['evt_num', 'evt_name', 'evt_location', 'evt_address',
'evt_city', 'evt_state', 'evt_zip', 'evt_notes']
# Initialize database changed trigger
db_change = False
# define the form, same as create event form
form = CreateForm(formdata = MultiDict(request.form))
# Note: I did not check for form validation in this case
# since form fields do not require changed data
# ###############################################################
# Determine which Event details need to be updated
# then update the database entry for Event Details that changed.
for aa in event_fields:
# get posted form data for current field
form_data = getattr(form, aa).data
# get db data for current field
db_data = getattr(event,aa)
if form_data != db_data:
# db update will be required in this path
setattr(event, aa, form_data)
db_change = True
session.flush()
# #################################################################
# Next check for any posted changes in Date fields
date_changed = False
if form.evt_month.data != "--":
date_changed = True
if form.evt_day.data != "--":
date_changed = True
if form.evt_year.data != "--":
date_changed = True
if date_changed:
date1 = datetime.date(int(form.evt_year.data),
int(form.evt_month.data),
int(form.evt_day.data))
# persist the date change to database
event.evt_date = date1
db_change = True
session.flush()
# check for any posted changes in Time fields
time_changed = False
if form.evt_hour.data != "--":
time_changed = True
if form.evt_minute.data != "--":
time_changed = True
if form.evt_tz.data != "--":
time_changed = True
if time_changed:
time1 = str(form.evt_hour.data + ":" +
form.evt_minute.data + form.evt_tz.data)
# persist the time change to database
event.evt_time = time1
db_change = True
session.flush()
# ##################################################################
# above are all changes to the Event table so COMMIT any changes
if db_change:
flash('Event Updated!')
session.commit()
db_change = False # reset db change trigger
# ############ 'REQUESTED' table updates ###########################
# Determine which requested amounts or notes need to be updated
# Note: Since all the requested quantity and note fields are optional,
# we CANT assume that the item/category previously existed in db.
# So, we must first check if an item for each requested category
# exists in the database. This will in turn dictate whether any
# detected changes need to be Updated or Inserted. Updates and
# Inserts are handled differently in code. Be AWARE.
# Updated (for database items that existed in database) or
# Inserted (for new form items that didnt exist in database)
#
# iterate thru all categories
for thiscat in categories:
keyq = 'req_%s_qty' % thiscat
keyn = 'req_%s_note' % thiscat
form_qty = getattr(form, keyq).data
form_note = getattr(form, keyn).data
if form_qty or form_note:
# form data was posted path
if int(form_qty) == 0:
# POSTED form qty is 0,
qty_in_db = check_req_db(evt_id, thiscat)
if qty_in_db:
# in this case we want to delete the db row for this
# category in the requested table since now 0 is
# requested.
try:
del_cat_req = session.query(Requested).\
filter_by(evt_id = evt_id,\
category = get_real_cat(thiscat)).one()
session.delete(del_cat_req)
db_change = True
session.flush()
except:
print "error in requested table update"
elif int(form_qty) > 0:
# POSTED form qty is > 0
# check does db qty exist
qty_in_db = check_req_db(evt_id, thiscat)
if qty_in_db:
# db qty exists, then UPDATE db qty & note
# check for change in form data
if int(form_qty) != req_qty_dct[keyq]:
# UPDATE db with form qty
qty_req = session.query(Requested).\
filter_by(evt_id = evt_id,\
category = get_real_cat(thiscat)).one()
setattr(qty_req, 'qty_rqst', form_qty)
db_change = True
session.flush()
if form_note != req_note_dct[keyn]:
# UPDATE db with form note
note_req = session.query(Requested).\
filter_by(evt_id = evt_id,\
category = get_real_cat(thiscat)).one()
setattr(note_req, 'rqst_note', form_note)
db_change = True
session.flush()
else:
# db qty does NOT exist, then INSERT new qty & note
try:
Req1 = Requested(evt_id = evt_id,
category = get_real_cat(thiscat),
qty_rqst = form_qty,
rqst_note = form_note)
session.add(Req1)
db_change = True
session.flush()
except:
print "error: insrt new Req data not complete! "
# all changes to Requested table are complete, so commit
if db_change:
flash('Event Updated!')
session.commit()
db_change = False # reset db_change trigger
return redirect(url_for('list_my_events',
user_id = usr_id))
else:
# Initial GET path, no posted path
return render_template('editevent.html',
webform = CreateForm(),
webuserid = usr_id,
webuser_fname = usr_first_name,
webuser_lname = usr_last_name,
webuser_email =usr_email,
webevent = event,
webreq = req,
web_req_app_qty = req_qty_dct['req_app_qty'],
web_req_app_note = req_note_dct['req_app_note'],
web_req_main_qty = req_qty_dct['req_main_qty'],
web_req_main_note = req_note_dct['req_main_note'],
web_req_side_qty = req_qty_dct['req_side_qty'],
web_req_side_note = req_note_dct['req_side_note'],
web_req_bread_qty = req_qty_dct['req_bread_qty'],
web_req_bread_note = req_note_dct['req_bread_note'],
web_req_dessert_qty = req_qty_dct['req_dessert_qty'],
web_req_dessert_note = req_note_dct['req_dessert_note'],
web_req_bev_qty = req_qty_dct['req_bev_qty'],
web_req_bev_note = req_note_dct['req_bev_note'],
web_req_uten_qty = req_qty_dct['req_uten_qty'],
web_req_uten_note = req_note_dct['req_uten_note'],
web_req_cups_qty = req_qty_dct['req_cups_qty'],
web_req_cups_note = req_note_dct['req_cups_note'],
web_req_misc_qty = req_qty_dct['req_misc_qty'],
web_req_misc_note = req_note_dct['req_misc_note'],
web_evt_id = evt_id)
def contribute(org_id, event_id):
# user has the ability to contribute to an event
# gather details about contributing user
usr_id = get_pure_id(user.get_id())
usr_first_name = user.given_name
usr_last_name = user.surname
usr_username = user.username
usr_email = user.email
print "The current User is :", usr_id, "\n"
# Gather details about this event
print "\nQuery for Event"
event = session.query(Event).filter_by(id=event_id).one()
# Gather details about what has been requested for this event
print "\nQuery for Requested Items"
req = session.query(Requested).filter_by(evt_id=event_id).all()
# Gather details about what is committed for this event
print "\nQuery for Committed Items"
cmttd = session.query(Committed).filter_by(evt_id=event_id).all()
if request.method == 'POST':
form = ContributeForm(formdata = MultiDict(request.form))
if form.validate():
# Form Validated Path
# add posted data to database at this point
Com1 = Committed(evt_id = event_id,
category = form.category.data,
item_name = form.item.data,
usr_lname = usr_last_name,
usr_fname = usr_first_name,
usr_username = usr_username,
usr_email = usr_email,
usr_qty = "1",
usr_note = form.note.data)
session.add(Com1)
session.commit()
flash('New Item committed for this event!')
# once data is posted & persisted to database,
# then reload Contribute page
return redirect(url_for('contribute',
org_id = event.org_id,
event_id = event.id))
else:
# form did NOT validate path
flash('Enter required fields!')
return render_template('contribute.html',
webform = form,
webevent_org_id = event.org_id,
webevent_org_fname = event.org_fname,
webevent_org_lname = event.org_lname,
webevent_name = event.evt_name,
webevent_date = event.evt_date,
webevent_time = event.evt_time,
webevent_location = event.evt_location,
webevent_address = event.evt_address,
webevent_city = event.evt_city,
webevent_state = event.evt_state,
webevent_zip = event.evt_zip,
webevent_notes = event.evt_notes,
webevent_image = event.evt_image,
webevent_id = event_id,
webrequested = req,
webcommitted = cmttd)
else:
# HTTP method is GET
return render_template('contribute.html',
webform = ContributeForm(),
webevent_org_id = event.org_id,
webevent_org_fname = event.org_fname,
webevent_org_lname = event.org_lname,
webevent_name = event.evt_name,
webevent_date = event.evt_date,
webevent_time = event.evt_time,
webevent_location = event.evt_location,
webevent_address = event.evt_address,
webevent_city = event.evt_city,
webevent_state = event.evt_state,
webevent_zip = event.evt_zip,
webevent_notes = event.evt_notes,
webevent_image = event.evt_image,
webevent_id = event_id,
webrequested = req,
webcommitted = cmttd)
def delete(org_id, event_id):
# organizer has ability to delete one of their events
# gather details about contributing user
usr_id = get_pure_id(user.get_id())
usr_first_name = user.given_name
usr_last_name = user.surname
usr_username = user.username
usr_email = user.email
print "The current User is :", usr_id, "\n"
# Gather details about this event
print "\nQuery for Event"
event = session.query(Event).filter_by(id=event_id).one()
# Gather details about what has been requested for this event
print "\nQuery for Requested Items"
req = session.query(Requested).filter_by(evt_id=event_id).all()
# Gather details about what is committed for this event
print "\nQuery for Committed Items"
cmttd = session.query(Committed).filter_by(evt_id=event_id).all()
# verify user Id and org_id match
if usr_id != org_id:
flash('Event Mismatch!')
return redirect(url_for('list_my_events',
user_id = usr_id))
else:
# user Id and org_id match
if request.method == 'POST':
db_change = False
form = DeleteForm(formdata = MultiDict(request.form))
if form.validate() and form.confirm.data:
# Form Validated Path
# delete this event in 3 tables
# 1. Committed table
for each in cmttd:
session.delete(each)
db_change = True
session.flush()
# 2. Requested table
for each in req:
session.delete(each)
db_change = True
session.flush()
# 3. Event Table
session.delete(event)
db_change = True
session.flush()
if db_change:
flash('Event Deleted!')
session.commit()
db_change = False # reset db_change trigger
return redirect(url_for('list_my_events',
user_id = usr_id))
return render_template('deleteevent.html',
webform = DeleteForm(),
webevent_org_id = event.org_id,
webevent_org_fname = event.org_fname,
webevent_org_lname = event.org_lname,
webevent_name = event.evt_name,
webevent_date = event.evt_date,
webevent_time = event.evt_time,
webevent_location = event.evt_location,
webevent_address = event.evt_address,
webevent_city = event.evt_city,
webevent_state = event.evt_state,
webevent_zip = event.evt_zip,
webevent_notes = event.evt_notes,
webevent_image = event.evt_image,
webevent_id = event_id,
webrequested = req,
webcommitted = cmttd)
def on_load(state):
stormpath_manager.init_app(state.app)
@login_required
@user_routes.route('/settings', methods=['GET', 'POST'])
def settings():
if request.method == 'GET':
return render_template('settings.html')
is_author = True if request.form.get('is_author') is not None else False
try:
user.username = request.form.get('username')
user.email = request.form.get('email')
user.given_name = request.form.get('first_name')
user.surname = request.form.get('last_name')
user.save()
except StormpathError, err:
return render_template('settings.html', error=err.message)
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
if app_user.is_author:
author_name = request.form.get('author_name')
if author_name != app_user.author.name:
app_user.author.update_name(author_name)
return render_template('settings.html')
def inject_appuser():
if user.is_authenticated():
user_id = user.get_id()
app_user = AppUser.query.get(stormpathUserHash(user_id))
return dict(app_user=app_user)
return dict(app_user=None)
If the user is valid, we'll log them in, and store their session for later.
"""
if request.method == 'GET':
return render_template('login.html')
try:
_user = User.from_login(
request.form.get('email'),
request.form.get('password'),
)
except StormpathError, err:
return render_template('login.html', error=err.message['message'])
login_user(_user, remember=True)
print stormpath_user.get_id()
user = Users.from_stormpath(stormpath_user)
print user.id
return redirect(request.args.get('next') or url_for('dashboard'))
@app.route('/dashboard', methods=['GET'])
@login_required
def dashboard():
page = int(request.args.get('page') or 1)
user = Users.from_stormpath(stormpath_user)
mystudies = user.studies().filter(StudyUsers.role == "owner").all()
tolabel = user.studies().filter(StudyUsers.role == "labeller").all()
return render_template('dashboard.html',
mystudies=mystudies,
tolabel=tolabel
