def commit_to_session(self, session=session):
"""Commit this problem to the database as a new problem."""
session.add(self)
session.flush()
session.commit()
session.refresh(self)
return self.pid
def create_competition():
data = request.form
if current_user.admin == 0:
return serve_error('Only admins can create competitions', 401)
try:
competition = Competition(
name=data['name'],
start=int(data['start_time']),
stop=(int(data['start_time']) + int(data['length'])),
closed=1 if bool(data['closed']) else 0
)
competition.commit_to_session()
comp_problems = loads(data['problems'])
except KeyError as err:
return serve_error('You must specify name, startTime, length, and'
' problem attributes. ' + err[0] + ' not found.',
response_code=400)
except ValueError:
return serve_error('JSON data for \'problems\' not properly formatted',
response_code=400)
for problem in comp_problems:
session.add(CompProblem(
label=problem['label'][:2],
cid=competition.cid,
pid=problem['pid']
))
session.flush()
session.commit()
return serve_response(competition.to_dict())
def unregister_for_competition(cid):
""" Called when a user wants to unregister for a competition.
All the user has to do is submit a post to this url with no form data.
From their logged-in status, we'll go ahead and remove them from the
competiton.
Similar to the <code>/register</code> endpoint, an admin can post a list of
users to unregister from the competition.
"""
if session.query(Competition).filter(Competition.cid == cid).first() \
is None:
return serve_error('Competition does not exist', response_code=404)
if current_user.admin == 1 and 'users' in request.data:
try:
registrants = loads(request.data['users'])
except ValueError:
return serve_error('JSON data for \'users\' not properly formatted',
response_code=400)
else:
registrants = [current_user.username]
for user in registrants:
(session.query(CompUser)
.filter(CompUser.username == user, CompUser.cid == cid)
.delete())
session.flush()
session.commit()
return serve_response({})
def mutate(self, info, input, **kwargs):
MainType = ScheduleType
SubType = None
if input.get("schd_id") is None or input.get("schd_id") == '':
input["schd_id"] = str(uuid4())
schd_type = input.get("schd_type", None)
sub_data = dict(kwargs.get(schd_type, None))
sub_data["schd_id"] = input["schd_id"]
sub_data["mst_id"] = input["schd_id"]
model = MainType._meta.model(**input)
if schd_type == 'date':
model.date.append(DateScheduleType._meta.model(**sub_data))
elif schd_type == 'interval':
model.interval.append(IntervalScheduleType._meta.model(**sub_data))
elif schd_type == 'crontab':
model.crontab.append(CrontabScheduleType._meta.model(**sub_data))
else:
return CreateSchedule(schedule=None, success=False)
# model = MainModel(**dict([
# (col, data.get(col)) for col in MainModel.__table__.columns.keys()
# ]))
session.add(model)
session.commit()
success = True
return CreateSchedule(schedule=model, success=success)
def delete_folder(id=None):
deletefolderform = DeleteAssetFolderForm(prefix="deletefolderform")
folder = AssetFolder.query.get(id)
if not folder.owner == current_user.profile:
logger.debug("Not deleting folder for other person")
abort(403)
if folder.parent is None:
logger.debug("Can't delete top folder")
abort(403)
if deletefolderform.validate_on_submit():
logger.debug("Delete an empty folder")
parent_id = folder.parent.id
if str(folder.id) != deletefolderform.id.data:
logger.debug(f"Wrong ids specified {folder.id} "
f"and {deletefolderform.id.data}")
abort(403)
if folder.files:
logger.debug("Folder contains files")
abort(403)
session.delete(folder)
session.commit()
return redirect(url_for('userassets.index', folder_id=parent_id))
return redirect(url_for('userassets.index', folder_id=id))
def main():
# grab the last timestamp file, get the timestamp
# ask RRSMS_URL for some fresh data
username='******'
pwd='pickabetterpassword'
client_id='1'
resp = requests.get("{}/get_update".format(RRSMS_URL), timeout=60, params={"client_id":client_id}, auth=HTTPBasicAuth(username, pwd))
# unpickle the data
data = resp.json()
timefile_n = ".timestamps/client{}timestamp".format(client_id)
new_file = not os.path.isfile(timefile_n)
mode = 'w+' if new_file else 'r+'
timefile = open(timefile_n, mode)
max_time = 0
if new_file:
last_time = 0
else:
last_time = float(timefile.read())
for update in data:
(rrid, field, newval, timestamp) = (update[0], update[1], update[2], update[3])
if timestamp > max_time:
max_time = timestamp
if timestamp < last_time:
continue
patient = session.query(Patient).filter(Patient.id == rrid).first()
update_patient(patient, field, newval)
session.commit()
timefile.seek(0)
timefile.write(str(max_time))
timefile.truncate()
timefile.close()
requests.get("{}/update_ack".format(RRSMS_URL), timeout=60, params={"client_id":client_id, "timestamp":str(max_time)},
auth=HTTPBasicAuth(username, pwd))
def update(id: int):
character = get_character(id, check_author=True)
if request.method == "POST":
update = request.get_json()
for setting in update:
character.set_attribute(setting)
field = setting['field']
subfield = setting.get('subfield', '')
value = setting['value']
type = setting.get('type', 'value')
if type == 'portrait' and value is not None:
value = "[image]"
log_subfield = ''
if subfield is not None and subfield != 'None':
log_subfield = ' ' + subfield
log_message = (f"set {type} on {field}{log_subfield}: {value}")
logentry = LogEntry(character,
log_message,
user_id=current_user.id)
session.add(logentry)
character.store_data()
session.commit()
return "OK"
def npc_visibility(npcid: int, campaignid: int):
if not current_user.is_authenticated:
abort(403)
npc = NPC.query.get(npcid)
if npc is None:
abort(404)
if npc.campaign.id != campaignid:
abort(404)
if current_user.profile != npc.campaign.user:
abort(403)
if request.method == 'POST':
data = request.get_json()
logger.debug(data)
if data['visibility']:
logger.debug(f"Showing NPC {npc.character.title}")
npc.visible = True
else:
logger.debug(f"Hiding NPC {npc.character.title}")
npc.visible = False
session.commit()
logger.debug(data)
response = {
'npc': npcid, 'campaign': campaignid, 'visibility': npc.visible
}
return jsonify(response)
def editjson(id: int):
"""Lets the user edit the raw json of the character."""
c = get_character(id, check_author=True)
form = ImportForm(obj=c)
if form.validate_on_submit():
c.title = form.title.data
c.body = form.body.data
if form.migration.data:
logger.debug("Trying to migrate data")
data = form.body.data
c.body = migrate(data, latest, migrations=migrations)
elif form.conversion.data:
logger.debug("Conversion is checked")
data = form.body.data
c.body = coc7e.convert_from_dholes(data)
logentry = LogEntry(c, "JSON edited", user_id=current_user.id)
session.add(logentry)
session.commit()
return redirect(url_for('character.view', id=c.id))
form.submit.label.text = 'Save'
validation_errors = c.validate()
return render_template('character/import.html.jinja',
title="Edit JSON",
validation_errors=validation_errors,
form=form,
type=None)
def commit_to_session(self, session=session):
"""Commit this blog post to the database"""
session.add(self)
session.flush()
session.commit()
session.refresh(self)
return self.id
def put_competition_teams(cid):
""" Update the teams for a competition
If a user is an admin, they can update the competition's users, doing a PUT.
This will take the JSON data in the 'teams' part of the request form and
store it to the database. Any teams or users not included in the JSON data
will not be a part of the competition and will have to re-register; however
it should not be used for the solely purpose of de-registering participants.
"""
try:
teams = loads(request.form['teams'])
except KeyError as err:
return serve_error('You must include the parameter \'teams\'.',
response_code=400)
except ValueError:
return serve_error('JSON data for \'teams\' not properly formatted',
response_code=400)
# Delete all of the old CompUser rows for this competition
session.query(CompUser).filter(CompUser.cid == cid).delete()
for team in teams:
for user in teams[team]:
session.add(CompUser(
cid=cid,
username=user,
team=team
))
session.flush()
session.commit()
return serve_response({})
def mutate(self, info, input):
code = CodeType._meta.model(**dict(input))
session.add(code)
session.commit()
success = True
return CreateParentCode(code=code, success=success)
def api_invite_delete(id):
invite = Invite.query.get(id)
if current_user.profile.id != invite.owner_id:
abort(403)
session.delete(invite)
session.commit()
return jsonify({'html': 'Deleted'})
def setUp(self):
"""Instantiate dummy test details."""
self.username = fake.user_name()
self.password = fake.password()
password_hash = generate_password_hash(self.password)
self.user = User(username=self.username, password_hash=password_hash)
session.add(self.user)
session.commit()
def mutate(self, info, input):
code_type_id = input.get("code_type_id")
deleted = ParentCodeType.get_query(info).filter_by(
code_type_id=code_type_id).delete(synchronize_session=False)
session.commit()
return DeleteParentCode(delete_count=deleted, success=True)
def create():
form = CreateForm()
if form.validate_on_submit():
c = Campaign(title=form.title.data, user_id=current_user.profile.id)
session.add(c)
session.commit()
return redirect(url_for('campaign.view', id=c.id))
return render_template('campaign/create.html.jinja', form=form)
def insert_products(datas): products = Products() products.title = datas['title'] products.director = datas['director'] products.overview = datas['overview'] products.image_path = datas['image_path'] products.category_id = datas['category_id'] session.add(products) session.commit()
def delete_course(category_id, course_id):
try:
course = session.query(Course).filter_by(
id=course_id, category_id=category_id).one()
except:
return error_message(404, "Cannot delete: Course not found.")
session.delete(course)
session.commit()
return data_message(200, None, "Course was successfully deleted.")
def mutate(self, info, input):
code_type_id = input.get("code_type_id")
use_yn = input.get("use_yn")
updated = ParentCodeType.get_query(info).filter_by(
code_type_id=code_type_id).update({"use_yn": use_yn})
session.commit()
return UpdateParentCodeUseYn(update_count=updated, success=True)
def create_folder(folder_id=None):
folderform = NewFolderForm(prefix="newfolderform")
if folderform.validate_on_submit():
logger.debug("Create a new folder")
folder = AssetFolder(parent_id=folderform.parent_id.data,
title=folderform.title.data,
owner=current_user.profile)
session.add(folder)
session.commit()
return redirect(url_for('userassets.index', folder_id=folder_id))
def save(self, commit=True):
if self.db_obj is None:
self.db_obj = models.Block()
self.db_obj.x = self.x
self.db_obj.y = self.y
for param in BLOCK_ENV_PARAMS:
setattr(self.db_obj, param, getattr(self, param))
session.add(self.db_obj)
if commit:
session.commit()
def drop_tables():
Student.metadata.drop_all()
from sqlalchemy.exc import ProgrammingError
from .logger import console_logger
try:
session.execute('DROP TABLE "alembic_version";')
session.commit()
except ProgrammingError as error:
console_logger.critical(error)
def delete_category(category_id):
try:
category = session.query(Category).filter_by(id=category_id).one()
except:
return error_message(404, "Cannot delete: Category not found.")
session.query(Course).filter_by(category_id=category_id).delete()
session.delete(category)
session.commit()
return data_message(200, None,
"Category and sub-courses was successfully deleted.")
def add_category():
name = request.form.get('name')
if name:
category = Category(name=name)
session.add(category)
session.commit()
else:
return error_message(400, "Course name is required.")
return data_message(200, {"Category": category.serialize},
"Successfully added a category.")
def mutate(self, info, input):
Model = DateScheduleType._meta.model
data = input_to_dictionary(input)
date_schedule = Model(**data)
session.add(date_schedule)
session.commit()
success = True
return CreateDateSchedule(date_schedule=date_schedule, success=success)
def folder(id: int):
c = get_character(id, check_author=True)
form = ChooseFolderForm()
if form.validate_on_submit():
c.folder = form.folder_id.data
session.commit()
return render_template('character/move_to_folder.html.jinja',
form=form,
character=c)
def commit_to_session(self):
"""Commit this CompUser to the database.
This is useful for adding a newly-created CompUser to the database.
"""
session.add(self)
session.flush()
session.commit()
session.refresh(self)
self._problem = None
def update_status(self, status):
'''Updates status in the database.
:param status: the status of the submission
:return: None
'''
self.result = status
dblock.acquire()
session.flush()
session.commit()
dblock.release()
def commit_to_session(self, session=session):
"""Commit this Competition to the database.
This is useful for adding a newly-created Competition to the database.
"""
session.add(self)
session.flush()
session.commit()
session.refresh(self)
self._problem = None
return self.cid
def insert_real_life_location(datas): rll = Real_life_location() rll.name = datas['name'] rll.scene = datas['scene'] rll.overview = datas['overview'] rll.image_path = datas['image_path'] rll.latitude = datas['latitude'] rll.longitude = datas['longitude'] rll.products_id = datas['products_id'] session.add(rll) session.commit()
def change_password():
oldPassword = request.form['oldPassword']
newPassword = request.form['newPassword']
if bcrypt.check_password_hash(current_user.passw, oldPassword):
hashed = bcrypt.generate_password_hash(newPassword)
current_user.passw = hashed
session.add(current_user)
session.flush()
session.commit()
return serve_response({})
return serve_error('old password does not match', 401)
def commit_to_session(self):
'''Commit this Submission to the database.
This is useful for adding a newly-created Submission to the database.
'''
dblock.acquire()
session.add(self)
session.flush()
session.commit()
session.refresh(self)
dblock.release()
self._problem = None
def delete(fileid, filename):
logger.debug("Delete asset")
asset = Asset.query.get(fileid)
form = DeleteAssetForm(prefix="deleteasset")
if form.validate_on_submit():
if asset.owner != current_user.profile:
abort(403)
flash("You just deleted an asset")
session.delete(asset)
session.commit()
return redirect(url_for('userassets.index', folder_id=asset.folder_id))
def mutate(self, info, input, **kwargs):
Type = ScheduleType
Model = Type._meta.model
schd_ids = input.get("schd_ids", [])
deleted = ScheduleType.get_query(info).filter(
Model.schd_id.in_(schd_ids)).delete(
synchronize_session=False) # fetch, evaluate
session.commit()
return DeleteSchedule(deleted=0, success=True)
def reset_password(token: str):
if current_user.is_authenticated:
return redirect(url_for('main.index'))
user = User.verify_reset_password_token(token)
form = ResetPasswordForm()
if form.validate_on_submit():
user.set_password(form.password.data)
session.commit()
flash('Your password has been reset.')
return redirect(url_for('auth.login'))
return render_template('auth/reset_password.html.jinja', form=form)
def test_bucketlist_search_by_name(self):
"""Test that a user can search for a bucketlist by its name."""
list_name = 'Ins Kino gehen'
bucketlist = BucketList(list_name=list_name,
creator=self.user.user_id)
session.add(bucketlist)
session.commit()
response = self.client.get('/bucketlists/?q=Kino',
headers={'token': self.token})
self.assertIn('Kino', response.data)
self.assertEqual(response.status_code, 200)
def gconnect():
code = request.data
try:
# Upgrade the authorization code into a credentials object
oauth_flow = flow_from_clientsecrets('client_secrets.json', scope='')
oauth_flow.redirect_uri = 'postmessage'
credentials = oauth_flow.step2_exchange(code)
except FlowExchangeError:
return error_message(401, "Failed to upgrade the authorization code.")
# Check if the access token is valid
access_token = credentials.access_token
url = ('https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=%s' %
access_token)
h = httplib2.Http()
result = json.loads(h.request(url, 'GET')[1])
# If there was an error in the access token info, abort
if result.get('error') is not None:
return error_message(500, result.get('error'))
# Verify that the access token is used for the intended user.
gplus_id = credentials.id_token['sub']
if result['user_id'] != gplus_id:
return error_message(401,
"Token's user ID doesn't match give user ID.")
# Verify that the access token is valid for this app.
if result['issued_to'] != CLIENT_ID:
return error_message(401, "Token's client ID does not match app's.")
# Get user info
userinfo_url = "https://www.googleapis.com/oauth2/v1/userinfo"
params = {'access_token': credentials.access_token, 'alt': 'json'}
answer = requests.get(userinfo_url, params=params)
data = answer.json()
name = data["name"]
picture = data["picture"]
email = data["email"]
user = session.query(User).filter_by(email=email).first()
if not user:
user = User(username=name, picture=picture, email=email)
session.add(user)
session.commit()
# Make token
token = user.generate_auth_token(600)
return data_message(200, {'token': token.decode('ascii')},
"Successfully generated token."), 200
def register_for_competition(cid):
""" Called when a user wants to register for a competition.
All the user has to do is submit a post to this url with no form data.
From their logged-in status, we'll go ahead and add them to the competiton
as an individual (team name is default their display name). A 400 error will
be returned if the user is already registered for the competition.
If the user that is submitting this is an admin, they can optionally
supply a json array of usernames to register for the competition. Specifying
this will not register the admin, but it will register all users that are
listed. A 400 error will be returned if any of the users are already
registered for the competition.
"""
if session.query(Competition).filter(Competition.cid == cid).first() \
is None:
return serve_error('Competition does not exist', response_code=404)
if current_user.admin == 1 and 'users' in request.data:
try:
registrants = loads(request.data['users'])
except ValueError:
return serve_error('JSON data for \'users\' not properly formatted',
response_code=400)
else:
registrants = [current_user.username]
for user in registrants:
if session.query(CompUser).filter(CompUser.cid == cid,
CompUser.username == user).first() is not None:
return serve_error('User ' + user + ' already registered for '
'competition', response_code=400)
for username in registrants:
user = session.query(User).filter(User.username == user).first()
session.add(CompUser(
cid=cid,
username=user.username,
team=user.display
))
socketio.emit('new_user', {
'cid': cid,
'user': {
'display': user.display,
'username': user.username
}
},
namespace='/register')
session.flush()
session.commit()
return serve_response({})
def save(self):
if self.db_obj is None:
self.db_obj = models.Chunk()
self.db_obj.x = self.x
self.db_obj.y = self.y
self.db_obj.name = self.name
for block in self.blocks:
block.save(commit=False)
block.db_obj.chunk_id = self.db_obj.id
session.add(self.db_obj)
session.commit()
def register():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
session.add(user)
session.commit()
flash('Congratulations, you are now a registered user!')
return redirect(url_for('auth.login'))
return render_template('auth/register.html.jinja',
title='Register',
form=form)
def edit_category(category_id):
try:
category = session.query(Category).filter_by(id=category_id).one()
except:
return error_message(404, "Cannot update: Category not found.")
name = request.form.get('name')
if name:
category.name = name
session.add(category)
session.commit()
else:
return error_message(400, "Course name is required.")
return data_message(200, {"Category": category.serialize},
"Successfully updated the category.")
def update_competition_data(cid):
""" Adds problems to a competition
Doing a POST request adds that problem to the competition whereas
a PUT request will remove all problems that were previously associated
with that competition and add all of the ones in the form body.
TODO: form validation to make sure that no duplicates are added.
"""
if current_user.admin == 0:
# admins only
return serve_error('Only admins can modify competitions', 401)
data = request.form
try:
competition = session.query(Competition).filter(Competition.cid == cid)\
.first()
competition.name = data['name']
competition.start=int(data['start_time'])
competition.stop=(int(data['start_time']) + int(data['length']))
competition.closed = 0 if bool(data['closed']) else 0
competition.commit_to_session()
# If the client sends a PUT request, we need to delete all of the old
# problems associated with this competition
session.query(CompProblem).filter(CompProblem.cid == cid).delete()
comp_problems = loads(data['problems'])
except KeyError as err:
return serve_error('You must specify name, startTime, length, and'
' and problem attributes. ' + err[0] + ' not found.',
response_code=400)
except ValueError:
return serve_error('JSON data for \'problems\' not properly formatted',
response_code=400)
for problem in comp_problems:
session.add(CompProblem(
label=problem['label'],
cid=competition.cid,
pid=problem['pid']
))
session.flush()
session.commit()
return serve_response(competition.to_dict())
def add_user():
name = raw_input("Name: ")
email = raw_input("Email: ")
if session.query(User).filter_by(email=email).first():
print "User with that email already exists"
return
password = ""
password_2 = ""
while not (password and password_2) or password != password_2:
password = getpass("Password: "******"Re-enter password: ")
user = User(name=name, email=email,
password=generate_password_hash(password))
session.add(user)
session.commit()
def remove_player(id: int, playerid: int):
form = RemovePlayerForm()
c = Campaign.query.get(id)
player = UserProfile.query.get(playerid)
if form.validate_on_submit():
c.players.remove(player)
session.commit()
return redirect(url_for('campaign.view', id=c.id))
form.id.data = c.id
form.player.data = player.id
return render_template('campaign/removeplayer.html.jinja',
player=player,
campaign=c,
form=form)
def create_blog_post():
if not current_user.admin == 1:
return serve_error('You must be an admin to submit blog posts', response_code=401)
if not request.form['title'] or not request.form['subtitle'] or not request.form['body']:
return serve_error('Must include title, subtitle, and body with request',
response_code=400)
post = BlogPost(title=request.form['title'],
subtitle=request.form['subtitle'],
post_time=int(time()),
body=request.form['body'],
username=current_user.username)
session.add(post)
session.flush()
session.commit()
session.refresh(post)
return serve_response(create_blog_object(post))
def on_revert(request, page_name):
"""Revert an old revision."""
rev_id = request.args.get('rev', type=int)
old_revision = page = None
error = 'No such revision'
if request.method == 'POST' and request.form.get('cancel'):
return redirect(href(page_name))
if rev_id:
old_revision = Revision.query.filter(
(Revision.revision_id == rev_id) &
(Revision.page_id == Page.page_id) &
(Page.name == page_name)
).first()
if old_revision:
new_revision = Revision.query.filter(
(Revision.page_id == Page.page_id) &
(Page.name == page_name)
).order_by(Revision.revision_id.desc()).first()
if old_revision == new_revision:
error = 'You tried to revert the current active ' \
'revision.'
elif old_revision.text == new_revision.text:
error = 'There are no changes between the current ' \
'revision and the revision you want to ' \
'restore.'
else:
error = ''
page = old_revision.page
if request.method == 'POST':
change_note = request.form.get('change_note', '')
change_note = 'revert' + (change_note and ': ' +
change_note or '')
session.add(Revision(page, old_revision.text,
change_note))
session.commit()
return redirect(href(page_name))
return Response(generate_template('action_revert.html',
error=error,
old_revision=old_revision,
page=page
))
def update_status(self, status):
'''Updates status in the database.
:param status: the status of the submission
:return: None
'''
self.result = status
dblock.acquire()
# Add to problem_solved if solved for first time
if status == 'good' and not (session.query(ProblemSolved)
.filter(ProblemSolved.pid == self.pid)
.filter(ProblemSolved.username == self.username).all()):
session.add(ProblemSolved(username=self.username, pid=self.pid,
submit_time=self.submit_time))
session.flush()
session.commit()
dblock.release()
def post(self):
"""Allow a user to register."""
parser.add_argument('username')
parser.add_argument('password')
args = parser.parse_args()
username = args['username']
password = args['password']
exists = session.query(User).filter_by(username=username).first()
if username and password:
if exists and exists.username == username:
return {'message': 'User already exists!'}, 400
user = User(username=username)
user.hash_password(password)
session.add(user)
session.commit()
return {'message': 'User {} has been successfully registered'
.format(username)}, 201
return {'message': 'Missing fields!'}, 400
def create_user():
# Verify that the poster is an admin
if current_user.admin == 0:
return server_error('Must be admin to create users', 401)
# Get form contents
username = request.form['username']
password = request.form['password']
display = request.form['display']
# Create the user if doesn't already exist
user = load_user(username)
if user is None:
hashed = bcrypt.generate_password_hash(password)
user = User(username=username, passw=hashed, display=display, admin=0)
session.add(user)
session.flush()
session.commit()
return serve_response({})
return serve_error('username already exists', 401)
def insert_into_db(session, model, args_list):
"""
Insert a number of ORM objects into the session for testing. The number
of objects inserted is equal to the length of the args_list parameter.
:param session: the database session to insert into
:param model: the model class of the objects to be added
:param args: a list of the arguments to pass to the model constructor
:param num: the number of ORM objects to create and insert
:returns: the list of new ORM objects
"""
results = list()
for args in args_list:
model_object = model(**args)
session.add(model_object)
session.flush()
session.commit(self)
session.refresh(model_object)
results.append(model_object)
return results
def setUp(self):
"""Instantiate dummy bucketlist details for testing."""
# create a dummy user
self.username = fake.user_name()
self.password = fake.password()
password_hash = generate_password_hash(self.password)
self.user = User(username=self.username, password_hash=password_hash)
session.add(self.user)
session.commit()
# create a dummy bucketlist
self.list_name = 'Ein Schatz finden'
self.bucketlist = BucketList(list_name=self.list_name,
creator=self.user.user_id)
session.add(self.bucketlist)
session.commit()
# create a dummy bucketlistitem
self.item_name = 'Ein bisschen Bier trinken'
self.bucketlistitem = BucketListItems(item_name=self.item_name,
bucket_id=self.bucketlist
.list_id)
session.add(self.bucketlistitem)
session.commit()
# log in a user to retrieve token
self.response = self.client.post(url_for('login'),
data=json.dumps({
'username': self.username,
'password': self.password}),
content_type='application/json')
self.token = json.loads(self.response.data)['token']
def on_edit(request, page_name):
"""Edit the current revision of a page."""
change_note = error = ''
revision = Revision.query.filter(
(Page.name == page_name) &
(Page.page_id == Revision.page_id)
).order_by(Revision.revision_id.desc()).first()
if revision is None:
page = None
else:
page = revision.page
if request.method == 'POST':
text = request.form.get('text')
if request.form.get('cancel') or \
revision and revision.text == text:
return redirect(href(page.name))
elif not text:
error = 'You cannot save empty revisions.'
else:
change_note = request.form.get('change_note', '')
if page is None:
page = Page(page_name)
session.add(page)
session.add(Revision(page, text, change_note))
session.commit()
return redirect(href(page.name))
return Response(generate_template('action_edit.html',
revision=revision,
page=page,
new=page is None,
page_name=page_name,
change_note=change_note,
error=error
))
def commit_to_session(self, session=session):
"""Commit this sample case to the database."""
session.add(self)
session.flush()
session.commit()
session.refresh(self)
def re_seed():
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
lacma = POI(name="LACMA",
category="arts",
address="5905 Wilshire Blvd, Los Angeles, CA 90036",
latitude=34.0629,
longitude= -118.3578,
desc="Largest art museum in the western United States. Check out the incredible Latin-American collection.")
venice = POI(name="Venice Beach Boardwalk",
category="active",
address="1800 Ocean Front Walk, Los Angeles, CA 90291",
latitude=33.986,
longitude= -118.473,
desc="Best people watching in the entire city. Wander around, and get your fortune read by one of the palm readers.")
barber = POI(name="The Blind Barber",
category="drink",
address="10797 Washington Blvd, Culver City, CA 90232",
latitude=34.0153,
longitude= -118.4073,
desc="Hidden behind an actual barber shop, no sign. Just walk straight through to the back, and delicious cocktails.")
baco = POI(name="Baco Mercat",
category="food",
address="408 S Main St, Los Angeles, CA 90013",
latitude=34.0479,
longitude= -118.2474,
desc="Try one of the amazing flatbread sandwiches!")
dailypint = POI(name="The Daily Pint",
category="drink",
address="2310 Pico Blvd, Santa Monica, CA 90405",
latitude=34.021084,
longitude= -118.466116,
desc="Hole in the wall, casual and fun. Start with the scotch.")
brennans = POI(name="Brennan's Pub",
category="drink",
address="4089 Lincoln Blvd, Marina del Rey, CA 90292",
latitude=33.988296,
longitude= -118.446087,
desc="Turtle Racing. Yes, seriously!")
perch = POI(name="Perch",
category="drink",
address="448 S Hill St, Los Angeles, CA 90013",
latitude=34.048858,
longitude= -118.251316,
desc="Rooftop bar with some amazing downtown views. Great Happy Hour!")
griffith = POI(name="Griffith Park",
category="active",
address="2800 E Observatory Rd, Los Angeles, CA 90027",
latitude=34.118375,
longitude= -118.300354,
desc="Great hiking. Go with The Sierra Club on a night hike for some amazing views of the city, all lit up!")
barnsdall = POI(name="Barnsdall Art Park",
category="active",
address="4800 Hollywood Blvd, Los Angeles, CA 90027",
latitude=34.101528,
longitude= -118.294334,
desc="Great place for a picnic, or just a lazy Sunday afternoon.")
firstfriday = POI(name="Abbot Kinney: First Friday",
category="other",
address="1121 Abbot Kinney Blvd, Venice, CA 90291",
latitude=33.991867,
longitude= -118.469779,
desc="Shops and galleries open late in Abbot Kinney on the first Friday of each month. Also, an amazing collection of food trucks!")
cinespia = POI(name="Cinespia at Hollywood Forever",
category="other",
address="6000 Santa Monica Blvd, Los Angeles, CA 90038",
latitude=34.090522,
longitude= -118.319727,
desc="Scary movies playing outdoors at Hollywood Forever Cemetery around Halloween. Bring a picnic!")
timetravel = POI(name="Echo Park Time Travel Mart",
category="other",
address="1714 Sunset Blvd, Los Angeles, CA 90026",
latitude=34.077282,
longitude= -118.259066,
desc="Quirky store for 'time travelers' in Echo Park. Profits fund the work of 826 Valencia, a nonprofit that focuses on writing education.")
elmatador = POI(name="El Matador State Beach",
category="active",
address="32350 Pacific Coast Hwy, Malibu, CA 90265",
latitude=34.039051,
longitude= -118.875141,
desc="Fewer services means fewer people. Head North toward Malibu to get away from the bustle near Santa Monica and contemplate the waves...")
flower = POI(name="LA Flower Market",
category="other",
address="754 Wall St Los Angeles, CA 90014",
latitude=34.040473,
longitude= -118.24961,
desc="Come early and see an incredible collection of flowers. Avoid the crowds/bustle on Wednesdays and Fridays if you can.")
largo = POI(name="Largo at the Coronet",
category="arts",
address="366 N La Cienega Blvd, Los Angeles, CA 90048",
latitude=34.077871,
longitude= -118.376322,
desc="Both amazing live music and comedy. Check out ongoing show 'The Thrilling Adventure Hour' for a good laugh!")
hotelcafe = POI(name="The Hotel Cafe",
category="arts",
address="1623 N Cahuenga Blvd, Los Angeles, CA 90028",
latitude=34.100437,
longitude= -118.329829,
desc="Tiny venue in Hollywood hosts some incredible bands that'll probably be famous in a couple years. For now, you can see them for $10!")
noise = POI(name="A Noise Within",
category="arts",
address="3352 E Foothill Boulevard, Pasadena, CA 91107",
latitude=34.149594,
longitude= -118.081141,
desc="Smaller Pasadena theater sticks to the classics. And does an amazing job with them.")
tsujita = POI(name="Tsujita",
category="food",
address="2057 Sawtelle Blvd, Los Angeles, CA 90025",
latitude=34.039604,
longitude= -118.442753,
desc="World's. Best. Noodles. Omnomnomnom.")
saffron = POI(name="Saffron & Rose",
category="food",
address="1387 Westwood Blvd, Los Angeles, CA 90024",
latitude=34.055425,
longitude= -118.4422,
desc="Ice cream with amazing, unique flavors. Try the Cucumber, seriously!")
kang = POI(name="Kang Ho-Dong Baekjeong",
category="food",
address="3465 W 6th St, Los Angeles, CA 90020",
latitude=34.063733,
longitude= -118.297282,
desc="Amazing Korean BBQ in (of course) Koreatown. Knock back a Hite and order everything on the menu.")
places_list = [lacma, venice, barber, baco, dailypint, brennans,
perch, griffith, barnsdall, firstfriday, cinespia, timetravel,
elmatador, flower, largo, hotelcafe, noise, tsujita, saffron, kang]
session.add_all(places_list)
session.commit()
user1 = User(username="******",
email="*****@*****.**",
password=generate_password_hash("test")
)
session.add(user1)
session.commit()
for place in places_list:
user1.poi_assocs.append(UserPOI(poi=place, upvote=1))
session.commit()
#Create sample users and upvotes
for i in range(1, 20):
username = "******" + str(i)
email = "test" + str(i) + "@gmail.com"
password = "******" + str(i)
tempuser = User(username=username,
email=email,
password=generate_password_hash(password)
)
session.add(tempuser)
session.commit()
sampsize = random.randint(6, 12)
sample_likes = random.sample(places_list, sampsize)
for like in sample_likes:
tempuser.poi_assocs.append(UserPOI(poi=like, upvote=1))
session.commit()
def commit_to_session(self):
session.add(self)
session.flush()
session.commit()
session.refresh(self)
def commit_to_session(self):
"""Commit this problem to the database as a new template."""
session.add(self)
session.flush()
session.commit()
session.refresh(self)
def commit_to_session(self, session=session):
"""Commit this problem data object to the database."""
session.add(self)
session.flush()
session.commit()
session.refresh(self)
