def item_new():
if request.method == 'POST':
# store form data
try:
item = vh.item_from_form(Item(), request.form,
user_id=g.user.id)
except ValueError as e:
# client-side validation should prevent this
current_app.logger.exception(e)
return render_template('err.html',
err_msg="Database validation error")
except SQLAlchemyError as e:
current_app.logger.exception(e)
# todo: reinitialize db connection if necessary
return render_template('err.html',
err_msg="Database error")
# store image file
file_storage_err = vh.store_item_pic(
item, request.files['picture'])
if file_storage_err is not None:
# todo: what if item delete after failed pic storage fails?
# using wtfform in item_add.html would simplify all this
get_db().delete(item)
return render_template(
'err.html', err_msg=file_storage_err), 500
return redirect(url_for('.home'))
else:
categories = get_db().query(Category).all()
return render_template('item_add.html',
categories=categories)
def home():
categories = get_db().query(Category).all()
items = get_db().query(
Item).order_by(desc(Item.last_update)).limit(NUM_RECENT_ITEMS)
return render_template('home.html',
categories=categories,
items=items)
def dashboard_add( id=None ):
application = get_db('db').application()
if request.method == 'GET':
# --- GET ----------------------------------------------------
if id == None:
empty_row = get_db('db').empty_dash()
return render_template( 'dash_edit.html', row=empty_row, application=application )
else:
row = get_db('db').get_dash( id )
return render_template( 'dash_edit.html', row=row, application=application )
else:
# --- POST ---------------------------------------------------
if( request.form['action'] == u'cancel' ):
# Abandon
return redirect(url_for('main'))
# Extract data (ready to save)
# request.form is already in unicode
data = {
'id' : (None if request.form['id'] == '' else int( request.form['id'] ) ),
'label' : ('Indéfini'.decode('utf8') if request.form['label'] == '' else request.form['label'] ),
'color' : (application['color'].decode('utf8') if not('color' in request.form) or (request.form['color']==u'') else request.form['color'] ),
'color_text' : ('black'.decode('utf8') if not('colortext' in request.form) or (request.form['colortext']==u'') else request.form['colortext'] ),
'icon' : (None if not('icon' in request.form) or (request.form['icon']==u'') else request.form['icon'] )
}
app.logger.debug( 'saving dash %s', data )
get_db('db').save_dash( **data )
flash( u'%s modifié' % data['label'] )
return redirect( url_for('main') )
def modify_movie(payload, movie_id):
try:
movie = Movie.query.filter_by(id=movie_id).one_or_none()
if movie is None:
abort(422)
body = request.get_json()
title = body.get('title')
release_date = body.get('release_date')
if title is not None:
movie.title = title
if release_date is not None:
movie.release_date = release_date
movie_formatted = movie.format()
movie.update()
return jsonify({"success": True, "movie": movie_formatted})
except Exception:
print(sys.exc_info())
get_db().session.rollback()
abort(422)
finally:
get_db().session.close()
def modify_actor(payload, actor_id):
try:
actor = Actor.query.filter_by(id=actor_id).one_or_none()
if actor is None:
abort(422)
body = request.get_json()
name = body.get('name')
age = body.get('age')
gender = body.get('gender')
if name is not None:
actor.name = name
if age is not None:
actor.age = age
if gender is not None:
actor.gender = gender
actor_formatted = actor.format()
actor.update()
return jsonify({"success": True, "actor": actor_formatted})
except Exception:
print(sys.exc_info())
get_db().session.rollback()
abort(422)
finally:
get_db().session.close()
def serialize_catalog():
categories = get_db().query(Category).all()
categories_json = [c.serialize for c in categories]
for category_json in categories_json:
items = get_db().query(Item).filter_by(
category_id=category_json['id']).all()
if len(items) > 0:
category_json['Item'] = [
i.serialize for i in items]
return {'Category': categories_json}
def block_add( dash_id, block_id = None ):
db = get_db( 'db' )
application = db.application()
dashboard = db.get_dash( dash_id )
data_sources= get_data_sources() # Source databases (like those made by Push-to-db.py)
if request.method == 'GET':
# --- GET ----------------------------------------------------
# identify the origin of the request (either the DASHBOARD, either the BLOCK-LIST)
origin = 'BLOCK-LIST' if '/block/list' in request.referrer else 'DASHBOARD'
if block_id:
# Modify the existing block
block = db.get_dash_block( block_id = block_id )
dbPythonic = get_db( block['source'] )
topics = dbPythonic.topics()
return render_template( 'block_edit.html', row=block, dashboard=dashboard, application=application, data_sources=data_sources, topics=topics, origin=origin )
else:
# Create a new block
block = db.empty_block( dash_id )
return render_template( 'block_edit.html', row=block, dashboard=dashboard, application=application, data_sources=data_sources, topics=None, origin=origin )
else:
# --- POST --------------------------------------------------
if( request.form['action'] == u'cancel' ):
# -- Abandon --
# Send back to original screen (either the DASHBOARD, either the BLOCK-LIST)
return redirect(
url_for('block_list', dash_id=request.form['dash_id'] )
if request.form['origin']=='BLOCK-LIST'
else url_for('dashboard', id=request.form['dash_id']) )
# Extract data (ready to save)
# request.form is already in unicode
data = {
'id' : (None if request.form['id'] == '' else int( request.form['id'] ) ),
'dash_id' : int( request.form['dash_id'] ),
'title' : request.form['title'] ,
'block_type' : request.form['block_type'],
'block_config': request.form['block_config'],
'color' : ( 'white'.decode('utf8') if not('color' in request.form) or (request.form['color']==u'') else request.form['color'] ),
'color_text' : ( 'black'.decode('utf8') if not('colortext' in request.form) or (request.form['colortext']==u'') else request.form['colortext'] ),
'icon' : (None if not('icon' in request.form) or (request.form['icon']==u'') else request.form['icon'] ),
'source' : request.form['source'],
'topic' : request.form['topic'],
'hist_type' : request.form['hist_type'],
'hist_size' : safe_cast( request.form['hist_size'], int, 50 )
}
app.logger.debug( 'saving dash_block %s', data )
get_db('db').save_dash_block( **data )
flash( u'%s modifié' % data['title'] )
# Send back to original screen (either the DASHBOARD, either the BLOCK-LIST)
return redirect( url_for('block_list', dash_id=data['dash_id']) if request.form['origin']=='BLOCK-LIST' else url_for('dashboard', id=data['dash_id']) )
def item_from_form(item, form, user_id=None,
save=True):
item.title = form['title']
item.description = form['description']
item.category_id = form['category']
if user_id is not None:
item.user_id = user_id
if save:
get_db().add(item)
get_db().commit()
# query in order to have id set
return get_db().query(Item).filter_by(
title=form['title']).one()
def items_list(category_name):
try:
category = get_db().query(Category).filter_by(
name=category_name).one()
except NoResultFound:
err_msg = "category '" + category_name + "' not found"
return render_template(
'err.html', err_msg=err_msg), 404
categories = get_db().query(Category).all()
items = get_db().query(Item).filter_by(
category_id=category.id).all()
return render_template('items.html',
categories=categories,
category=category,
items=items)
def get_token():
'''
Generate and return an token in json format after adding it to
the database
'''
token_string = ''.join([
random.choice(string.ascii_uppercase + string.digits)
for _ in range(32)
])
token = models.Token(token=token_string)
models.get_db().add(token)
models.get_db().commit()
return jsonify({"token": token_string})
def process_nonpremiums():
log_info("Process non-premiums")
database = get_db()
now = datetime.now()
#last_valid_date = datetime.now() - timedelta(hours = 24)
#select = SubscribtionModel.select().join(UserModel).where(UserModel.id == SubscribtionModel.user_id).where(UserModel.activated == True).where(UserModel.last_sent < last_valid_date).where(UserModel.last_hi + timedelta(days=14) < now)
today_4_00 = get_datetime_today_4_00()
if now < today_4_00:
return # not 4 yet ..
compare_against = today_4_00 - timedelta(
hours=22
) # so if user received a kindler at 3.59am? dont send another one 2 hours later..
last_hi_verif = now - timedelta(days=14)
select = SubscribtionModel.select().join(UserModel).where(
UserModel.id == SubscribtionModel.user_id).where(
UserModel.is_recurrent == True).where(
UserModel.activated == True).where(
UserModel.last_sent < compare_against).where(
UserModel.last_hi > last_hi_verif).select()
#print(select)
#print(list(select))
process(select)
def block_delete( dash_id, block_id ):
""" delete a given block from the dashboard """
application = get_db('db').application()
if request.method == 'GET':
# --- GET ----------------------------------------------------
row = get_db('db').get_dash_block( block_id )
return render_template( 'block_del_confirm.html', row=row, application=application)
else:
# --- POST --------------------------------------------------
app.logger.debug( "Deleted block")
if request.form['action'] == u'cancel':
return redirect( url_for('block_list', dash_id=dash_id ) )
else:
flash( u'Bloc %s effacé!' % get_db('db').get_dash_block( block_id )['title'] )
get_db('db').drop_dash_block( block_id )
return redirect( url_for('block_list', dash_id=dash_id ) )
def dashboard_delete( id ):
""" Drop a given Dashboard """
application = get_db('db').application()
if request.method == 'GET':
# --- GET ----------------------------------------------------
row = get_db('db').get_dash( id )
return render_template( 'dash_del_confirm.html', row=row, application=application)
else:
# --- POST --------------------------------------------------
app.logger.debug( "Deleted dash")
if request.form['action'] == u'cancel':
return redirect( url_for('main') )
else:
flash( u'Dashboard %s effacé!' % get_db('db').get_dash( id )['label'] )
get_db('db').drop_dash( id )
return redirect( url_for( 'main') )
def add_unit(institution_uri, department_uri):
args = request.get_json()
dep = get_department_id(institution_uri, department_uri)
inst = get_institution_id(institution_uri)
if DepartmentPermission(dep, inst).can():
unit_code = args["code"]
unit_name = args["name"]
unit_level = args["level"]
department = Department.query.join(Institution).\
filter(Institution.uri == institution_uri).\
filter(Department.uri == department_uri).\
one().id
unit = Unit.query.filter(Unit.code==unit_code).\
filter(Unit.department_id==department).first()
db = get_db()
if not unit:
unit = Unit(code=unit_code, name=unit_name, level=unit_level, department_id=department)
db.session.add(unit)
db.session.commit()
return '1'
return '0'
abort(403)
def save_cycle_to_db(
generated_cycle: DefaultDict[str, DefaultDict[str, List[LiftData]]]):
db = get_db()
cycle = Cycle()
for lift in generated_cycle['test_max']:
cycle_lift = CycleLiftMax(lift=lift,
amount=generated_cycle['test_max'][lift],
cycle=cycle)
db.add(cycle_lift)
for week in range(1, 5):
try:
week_title = 'week_{}'.format(week)
for lift in generated_cycle[week_title]:
for lift_data in generated_cycle[week_title][lift]:
cycle_lift_weekly = CycleLiftWeekly(
week=week,
lift=lift,
amount=lift_data.weight,
reps=lift_data.reps,
percentage=lift_data.percentile,
cycle=cycle)
db.add(cycle_lift_weekly)
except KeyError:
if week != 4:
print(
"something's wrong looks like data for week {} is missing".
format(week))
pass
db.add(cycle)
db.commit()
db.close()
def put():
'''
Handle a put to add data for a particular token
'''
token = request.get_json()["token"]
data = request.get_json()["data"]
try:
existing_token = models.get_db().query(
models.Token).filter(models.Token.token == token).one()
except sqlalchemy.orm.exc.NoResultFound:
return jsonify(), 400
existing_token.data = base64.b64encode(data.encode())
models.get_db().commit()
return jsonify({"did_insert": True})
def block_list( dash_id ): """ produce a list of blocks to allow editing and deletion """ dashdb = get_db( 'db' ) dash = dashdb.get_dash( dash_id ) blocks = dashdb.get_dash_blocks( dash_id ) application = dashdb.application() return render_template( 'block_list.html', block_list=blocks, dash=dash ,application=application )
def delete_actor(payload, actor_id):
try:
actor = Actor.query.filter_by(id=actor_id).one_or_none()
if actor is None:
abort(422)
actor_formatted = actor.format()
actor.delete()
return jsonify({"success": True, "actor": actor_formatted})
except Exception:
print(sys.exc_info())
get_db().session.rollback()
abort(422)
finally:
get_db().session.close()
def delete_movie(payload, movie_id):
try:
movie = Movie.query.filter_by(id=movie_id).one_or_none()
if movie is None:
abort(422)
movie_formatted = movie.format()
movie.delete()
return jsonify({"success": True, "movie": movie_formatted})
except Exception:
print(sys.exc_info())
get_db().session.rollback()
abort(422)
finally:
get_db().session.close()
async def get_photo_of_dog(dog_id: int):
db = next(get_db())
photo = db.query(Photo).filter(Photo.subject_id == dog_id).first()
if photo:
file_like = open(photo.photo_url, mode="rb")
return StreamingResponse(file_like, media_type="image/png")
else:
return ""
async def get_in_location(latitude: float, longitude: float):
db = next(get_db())
dogs = (db.query(Dog,
Sighting).filter(Dog.dog_id == Sighting.dog_id).all())
return_dogs = [dog for dog in dogs if abs(dog[1].latitude - latitude) < 1]
return_dogs_next = [
dog for dog in return_dogs if abs(dog[1].longitude - longitude) < 1
]
return {"dogs": return_dogs_next}
def main(): """ List available Dashboard """ dashdb = get_db( 'db' ) # List of dashboard rows = dashdb.dashes() # Info about application name application = dashdb.application() return render_template( 'dash_list.html', dash_list=rows, application=application )
def setUp(self):
db = models.get_db()
self.addCleanup(db.reset)
transaction = db.connection.begin()
self.addCleanup(transaction.rollback)
self.session = db.session
self.addCleanup(self.session.close)
def before_request():
g.user = None
if 'user_id' in login_session:
try:
g.user = get_db().query(User).filter_by(
id=login_session.get('user_id')).one()
except NoResultFound:
current_app.logger.warning((
"session with non-existant user id"))
login_session.pop('user_id')
def item_edit(item_title):
try:
item = get_db().query(Item).filter_by(
title=item_title).one()
except NoResultFound:
err_msg = "item '" + item_title + "' not found"
return render_template(
'err.html', err_msg=err_msg), 404
if item.user is not None and item.user.id != g.user.id:
err_msg = "user doesn't have edit permissions for this item"
return render_template(
'err.html', err_msg=err_msg), 404
if request.method == 'POST':
form = vh.get_item_form()(request.form, item)
file_storage_err = vh.store_item_pic(
item, request.files['picture'])
if (not form.validate() or file_storage_err is not None):
http_err_code = 500 if file_storage_err is not None else 400
return (render_template('item_edit.html',
form=form,
file_err=file_storage_err),
http_err_code)
form.populate_obj(item)
try:
get_db().add(item)
get_db().commit()
# todo: pic updated w/o updating item record
except ValueError as e:
# client-side validation should prevent this
current_app.logger.exception(e)
return render_template('err.html',
err_msg="Database validation error")
except SQLAlchemyError as e:
current_app.logger.exception(e)
# todo: reinitialize db connection if necessary
return render_template('err.html',
err_msg="Database error")
return redirect(url_for('.home'))
else:
form = vh.get_item_form()(obj=item)
return render_template('item_edit.html',
form=form,
file_err=None)
def source_topics( source_name ):
""" for Ajax request: returns a JSON list of topic names for a given source name (eg: the Pythonic database)"""
db_source = get_db( source_name )
rows = db_source.topics()
data = [ {'topic':row['topic'], 'history':row['tsname'] } for row in rows ]
response = app.response_class(
response=json.dumps(data),
mimetype='application/json'
)
return response
def remove_institution():
if AdminPermission().can():
db = get_db()
inst_id = (request.get_json())['id']
institution = db.session.query(Institution).get(inst_id)
db.session.delete(institution)
db.session.commit()
return ''
abort(403)
def item_detail(category_name, item_title):
try:
category = get_db().query(Category).filter_by(
name=category_name).one()
except NoResultFound:
# return tuples automatically passed flask.make_response
err_msg = "category '" + category_name + "' not found"
return render_template(
'err.html', err_msg=err_msg), 404
item = get_db().query(Item).filter_by(
category_id=category.id).filter_by(
title=item_title).one()
has_img = vh.get_item_image_info(item.id) is not None
can_modify = (g.user is not None and
(item.user is None or item.user.id == g.user.id))
return render_template('item.html',
item=item,
has_img=has_img,
can_modify=can_modify,
rand_q=time.time())
def calculate_new_training_max(
cycle: Cycle,
cycle_lift_increments: Optional[Dict[str, Union[Decimal, str]]] = None
) -> Tuple[Dict[str, Decimal], Dict[str, Decimal]]:
db = get_db()
incremented_values = {}
if cycle_lift_increments:
training_maxes = {}
# get current lift_maxes and figure out what to do next
current_training_maxes = db.query(CycleLiftMax).filter(
CycleLiftMax.cycle == cycle).all()
for current_max in current_training_maxes:
lift = current_max.lift
if lift in cycle_lift_increments:
need_to_roll_back = type(cycle_lift_increments[lift]) is str
if need_to_roll_back:
training_maxes[lift] = get_one_rep_training_max(
current_max.amount)
incremented_values[
lift] = training_maxes[lift] - current_max.amount
else:
training_maxes[lift] = Decimal(
current_max.amount) + cycle_lift_increments[lift]
incremented_values[lift] = cycle_lift_increments[lift]
else:
standard_increment = Decimal(
db.query(LiftIncrement).filter(
LiftIncrement.lift == lift).one().amount)
training_maxes[lift] = Decimal(
current_max.amount) + standard_increment
incremented_values[lift] = standard_increment
else:
new_training_max = db.query(
CycleLiftMax.lift,
CycleLiftMax.amount +
coalesce(CycleLiftIncrement.amount, LiftIncrement.amount),
).outerjoin(CycleLiftIncrement,
CycleLiftMax.lift == CycleLiftIncrement.lift).join(
LiftIncrement,
CycleLiftMax.lift == LiftIncrement.lift).filter(
CycleLiftMax.cycle == cycle).all()
training_maxes = {}
for row in new_training_max:
training_maxes[row[0]] = row[1]
for increment in db.query(LiftIncrement).all():
incremented_values[increment.lift] = increment.amount
return training_maxes, incremented_values
def save_cycle_increments(increments: Dict[str, Decimal]):
db = get_db()
# cant use get_latest_cycle because when you assign object from different session when creating a new one
# it gets upset, I think
cycle = db.query(Cycle).order_by(Cycle.index.desc()).first()
for lift in increments:
increment = CycleLiftIncrement(lift=lift,
amount=increments[lift],
cycle=cycle)
db.add(increment)
db.commit()
def item_delete(item_title):
try:
item = get_db().query(Item).filter_by(
title=item_title).one()
except NoResultFound:
err_msg = "item '" + item_title + "' not found"
return render_template(
'err.html', err_msg=err_msg), 404
if item.user is not None and item.user.id != g.user.id:
return redirect(url_for('.home'))
if request.method == 'POST':
img_filepath = vh.get_item_image_filepath(item.id)
# todo: error-handling, filesystem/db consistency story as w/ C&U
if os.path.isfile(img_filepath):
os.remove(img_filepath)
get_db().delete(item)
get_db().commit()
return redirect(url_for('.home'))
else:
return render_template('item_delete.html',
item=item)
def add_department(institution_uri):
inst = get_institution_id(institution_uri)
if InstitutionPermission(inst).can():
db = get_db()
args = request.get_json()
department = Department(name=args['name'], uri=args['uri'], institution=inst)
db.session.add(department)
db.session.commit()
return '1'
abort(403)
def get_item_form():
return model_form(
Item,
db_session=get_db(),
only=[
'title',
'description',
'category',
],
# ??? duplicate validation ok?
field_args={
'description': {'validators': [NotBlank(), ], },
})
def item_img(item_id):
try:
item = get_db().query(Item).filter_by(
id=item_id).one()
except NoResultFound:
return json.dumps('Image not found'), 401
img_info = vh.get_item_image_info(item.id)
if img_info is None:
current_app.logger.exception("got None for img_info")
return json.dumps("programming or operation error"), 500
# todo: edit out this '..' nonsense after tests for file uploading
return send_file(os.path.join('..', img_info['path']),
mimetype='image/'+img_info['type'])
def remove_department(institution_uri):
inst = get_institution_id(institution_uri)
if InstitutionPermission(inst).can():
db = get_db()
dept_id = (request.get_json())['id']
department = db.session.query(Department).get(dept_id)
db.session.delete(department)
db.session.commit()
return ''
abort(403)
def get(self):
if 'task' in self.request.url:
q = taskqueue.Queue('update-clusters-queue')
task = taskqueue.Task(url='/api/mysql/places', method='GET')
q.add(task)
return
#json list of places
db = get_db()
#clear database table
try:
cursor = db.cursor()
sql = 'DELETE FROM places'
# logging.info("SQL: " + sql)
cursor.execute(sql)
db.commit()
except ValueError as e:
logging.error("Error while deleting data fom places table: " + str(e))
finally:
db.close()
places, status, errcode = logic.place_list_get({}, None)
if places is not None and status == "OK":
for p in places:
db = get_db()
try:
cursor = db.cursor()
sql = 'INSERT INTO places (pkey, lat, lon) VALUES ("%s", %f, %f)' % (p['key'], p['address']['lat'], p['address']['lon'])
# logging.info("SQL: " + sql)
cursor.execute(sql)
db.commit()
except ValueError:
logging.error("Invalid data for place: %s, %f, %f" % (p['key'], p['address']['lat'], p['address']['lon']))
finally:
db.close()
self.response.set_status(200)
self.response.write('{}')
else:
self.response.set_status(errcode)
self.response.write(status)
def topic_history(dash_id, block_id, _from=0, _len=None):
""" Display the history for a given block in the dashboad.
Note:
* _from=0 is equivalent of _from=None.
Remark:
* The block_id allows to retreive the source and topic.
* The source dans topic allows to retreive the topic record.
* The topic record allows to identify the timeserie tablename
"""
dashdb = get_db('db')
dash = dashdb.get_dash(dash_id)
block = dashdb.get_dash_block(block_id)
topic = block['topic']
hist_type = block['hist_type']
hist_size = _len if _len else block['hist_size']
db_source = get_db(block['source'])
values = db_source.get_values([topic])
tsname = values[0]['tsname']
hist_rows = db_source.get_history(tsname=tsname,
topic=topic,
from_id=None if _from <= 1 else _from,
_len=hist_size)
# print( type(hist_rows[0]["rectime"]) )
# print( hist_rows[0]["rectime"] )
if hist_type == 'LIST':
return render_template('history/list.html',
block=block,
dash=dash,
rows=hist_rows,
_from=_from,
_len=hist_size)
else:
flash(('Type d'
'historique %s non supporté' % hist_type).decode('utf-8'),
'error')
return redirect(url_for('dashboard', id=dash_id))
def get_categories(topic):
fetched_categories = fetch_categories(topic.name)
category_names = map(lambda x: x['title'], fetched_categories)
if category_names:
existing_categories = Category.query.filter(Category.name.in_(category_names)).all()
existing_names = map(lambda x: x.name, existing_categories)
new_categories = [Category(name) for name in category_names if name not in existing_names]
map(get_db().session.add, new_categories)
return existing_categories + new_categories
else:
return []
def create_movie(payload):
try:
body = request.get_json()
title = body.get('title')
release_date = body.get('release_date')
if title is None:
abort(422)
if release_date is None:
abort(422)
movie = Movie(title=title, release_date=release_date)
movie.insert()
return jsonify({"success": True, "movie": movie.format()})
except Exception:
print(sys.exc_info())
get_db().session.rollback()
abort(422)
finally:
get_db().session.close()
async def create_owner(owner: OwnerSchema):
db = next(get_db())
length_owner = db.query(Owner).count()
hashed_password = get_password_hash(owner.password)
owner_model = Owner(
owner_id=length_owner + 1,
email=owner.email,
password=hashed_password,
username=owner.username,
)
db.add(owner_model)
db.commit()
db.refresh(owner_model)
return {"owner": owner_model.username}
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
db = next(get_db())
owner = db.query(Owner).filter(
Owner.username == form_data.username).first()
if not owner:
raise HTTPException(status_code=400,
detail="Incorrect username or password")
if not verify_password(form_data.password, owner.password):
raise HTTPException(status_code=400,
detail="Incorrect username or password")
access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
access_token = create_access_token(data={"sub": owner.username},
expires_delta=access_token_expires)
return {"access_token": access_token, "token_type": "bearer"}
def create_actor(payload):
try:
body = request.get_json()
name = body.get('name')
age = body.get('age')
gender = body.get('gender')
if name is None:
abort(422)
if age is None:
abort(422)
if gender is None:
abort(422)
actor = Actor(name=name, age=age, gender=gender)
actor.insert()
return jsonify({"success": True, "actor": actor.format()})
except Exception:
print(sys.exc_info())
get_db().session.rollback()
abort(422)
finally:
get_db().session.close()
def add_user(institution_uri, department_uri):
dep = get_department_id(institution_uri, department_uri)
inst = get_institution_id(institution_uri)
if DepartmentPermission(dep, inst).can():
db = get_db()
args = request.get_json()
user = User(username=args['username'], password=bcrypt.generate_password_hash(args['password']), department=dep)
db.session.add(user)
db.session.commit()
return ''
abort(403)
def mutate(self, info, subsystem, param, value, timestamp):
db_session = get_db()
new_telem = TelemetryModel(subsystem=subsystem,
param=param,
value=value,
timestamp=timestamp)
db_session.add(new_telem)
db_session.commit()
return Telemetry(subsystem=subsystem,
param=param,
value=value,
timestamp=timestamp)
def update_institution():
args = request.get_json()
if AdminPermission().can():
db = get_db()
institution = db.session.query(Institution).get(args['id'])
institution.name = args['name']
institution.uri = args['uri']
db.session.commit()
return ''
abort(403)
def poll():
'''
Handle a poll for data for a particular token
'''
token = request.get_json()["token"]
try:
result = models.get_db().query(
models.Token).filter(models.Token.token == token).one()
except sqlalchemy.orm.exc.NoResultFound:
return jsonify(), 400
if not result.data:
return jsonify()
return jsonify(base64.b64decode(result.data).decode())
def login():
args = request.get_json()
user = get_db().session.query(User).join(Department).join(Institution).\
filter(or_(Institution.uri == i for i in (args["institution"], 'admin'))).\
filter(or_(Department.uri == d for d in (args["department"], 'admin'))).\
filter(User.username == args["user"]).one_or_none()
if user:
if bcrypt.check_password_hash(user.password, args["pass"]):
login_user(user)
identity_changed.send(app, identity=Identity(user.id))
return '1'
return '0'
def special_page(name):
""" Affiche des dashboards spéciaux basé sur un code indiqué entre { } """
name = name.upper()
if name == 'TOPICS':
db = get_db('db')
application = db.application()
sources = get_data_sources()
# Get the first source
if len(sources) == 0:
flash("Pas de sources renseignée dans le fichier de configuration",
'error')
return redirect(url_for('main'))
source_db = get_db(sources[0])
topic_rows = source_db.get_values(topic_list=None)
return render_template('special/topic_list.html',
application=application,
source=sources[0],
rows=topic_rows)
elif name == 'DEMO':
return render_template('demo/demo.html')
flash("Pas de page speciale pour {%s}" % name)
return redirect(url_for('main'))
def update_department(institution_uri):
inst = get_institution_id(institution_uri)
args = request.get_json()
if InstitutionPermission(inst).can():
db = get_db()
department = db.session.query(Department).get(args['id'])
department.name = args['name']
department.uri = args['uri']
db.session.commit()
return ''
abort(403)
def remove_syllabus_item(institution_uri, department_uri):
db = get_db()
dep = get_department_id(institution_uri, department_uri)
inst = get_institution_id(institution_uri)
if DepartmentPermission(dep, inst):
unit_topic_id = (request.get_json())['unit_topic_id']
unit_topic = db.session.query(UnitTopic).get(unit_topic_id)
db.session.delete(unit_topic)
db.session.commit()
return ''
abort(403)
def remove_unit(institution_uri, department_uri):
db = get_db()
dep = get_department_id(institution_uri, department_uri)
inst = get_institution_id(institution_uri)
if DepartmentPermission(dep, inst).can():
unit_id = (request.get_json())['id']
unit = db.session.query(Unit).get(unit_id)
db.session.delete(unit)
db.session.commit()
return ''
abort(403)
def create_db():
Model.metadata.create_all(get_engine(), checkfirst=True)
print('Created DB')
db = get_db()
for lift in ['Press', 'Deadlift', 'Bench press', 'Squat']:
db.add(Lift(name=lift))
db.commit()
print('Added 4 main Lifts')
for lift in ['Press', 'Deadlift', 'Bench press', 'Squat']:
increment_amount = 2.5 if 'press' in lift.lower() else 5
db.add(LiftIncrement(lift=lift, amount=increment_amount))
db.commit()
print('...and their default increments')
def dump_cycles():
from datetime import datetime
import json
db = get_db()
dump_file_name = 'cycles_dump_{}.json'.format(str(datetime.now().date()))
data = []
with open(dump_file_name, 'w') as f:
for cycle in db.query(Cycle).order_by(Cycle.index):
cycle_data = {}
for lift_data in db.query(CycleLiftMax).filter(
CycleLiftMax.cycle == cycle):
# because Decimal is not json serializable by default
cycle_data[lift_data.lift] = float(lift_data.amount)
cycle_data['index'] = cycle.index
data.append(cycle_data)
json.dump(data, f)
def bulk_add_units(institution_uri, department_uri):
dep = get_department_id(institution_uri, department_uri)
inst = get_institution_id(institution_uri)
if DepartmentPermission(dep, inst).can():
args = request.get_json()
newunits = []
for unit in args['units']:
newunits.append(Unit(code=unit['code'], name=unit['name'], level=unit['level'], department_id=dep))
db = get_db()
db.session.bulk_save_objects(newunits)
db.session.commit()
return str(len(newunits))
abort(403)
def main():
import sys
import webapp
webapp.check_config()
global db
db = get_db()
if "--add-admin" in sys.argv:
index = sys.argv.index("--add-admin")
email = sys.argv[index+1]
state = Place.find(key=webapp.get_state())
# Hack to fix the error at account.get_current_user() when adding volunteer
web.ctx.current_user = None
state.add_volunteer("Fix Your Name", email, "0000000000", role="admin")
return
if "--polling-centers" in sys.argv:
index = sys.argv.index("--polling-centers")
state_code = sys.argv[index+1]
filename = sys.argv[index+2]
state = Place.find(state_code)
print "add_polling_centers", state, filename
add_polling_centers(state, filename)
return
if "--wards" in sys.argv:
index = sys.argv.index("--wards")
state_code = sys.argv[index+1]
filename = sys.argv[index+2]
state = Place.find(state_code)
print "add_wards", state, filename
add_wards(state, filename)
return
dir = sys.argv[1]
code = sys.argv[2]
name = sys.argv[3]
state = add_state(code, name)
add_pcs(state, dir)
add_acs(state, dir)
#add_wards(state, dir)
add_polling_booths(state, dir)
def update_unit(institution_uri, department_uri):
args = request.get_json()
db = get_db()
dep = get_department_id(institution_uri, department_uri)
inst = get_institution_id(institution_uri)
if DepartmentPermission(dep, inst).can():
unit = db.session.query(Unit).get(args['id'])
unit.level = args['level']
unit.code = args['code']
unit.name = args['name']
db.session.commit()
return ''
abort(403)
def add_invites(place_key, filename, batch):
from webapp import import_people
place = Place.find(place_key)
if not place:
raise ValueError("Invalid place {0}".format(place_key))
rows = [line.strip("\n").split("\t") for line in open(filename) if line.strip()]
re_badchars = re.compile("[^A-Za-z0-9 \.-]+")
count = 0
with get_db().transaction():
for row in rows:
name, phone, email = row
name = re_badchars.sub("", name).strip()
d = web.storage(name=name, phone=phone, email=email, place=None, role=None)
if import_people().add_volunteer(d, place, batch=batch, as_invite=True):
count += 1
logger.info("imported %s people", count)
async def get_current_owner(token: str = Depends(oauth2_scheme)):
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = jwt.decode(token, SECRET, algorithms=[ALGORITHM])
username: str = payload.get("sub")
if username is None:
raise credentials_exception
except JWTError:
raise credentials_exception
db = next(get_db())
owner = db.query(Owner).filter(Owner.username == username).first()
if owner is None:
raise credentials_exception
return owner
def get_create_user(name, email):
""" get or create user record """
try:
user = get_db().query(User).filter_by(
email=email).one()
except NoResultFound:
new_user = User(name=name,
email=email)
get_db().add(new_user)
get_db().commit()
user = get_db().query(User).filter_by(
email=email).one()
return user.id
def add_institution():
if AdminPermission().can():
db = get_db()
args = request.get_json()
institution = Institution(name=args['name'], uri=args['uri'])
db.session.add(institution)
db.session.commit()
department = Department(name="admin", uri="admin", institution=institution.id)
db.session.add(department)
db.session.commit()
admin = User(username=args['username'], password=bcrypt.generate_password_hash(args['password']), department=department.id)
db.session.add(admin)
db.session.commit()
return '1'
abort(403)
