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)