def post(self, *args, **kwargs): data = request.get_json() username = data.get("username", "") roledesc = data.get("roledesc", "") status = data.get("status", "") schema = Kanpai.Object({ "username": (Kanpai.String(error="user name should be string").trim().required( error="user name should required").max( 32, error="should not be more than 32 characters")), "roledesc": (Kanpai.String(error="role desc should be string").trim().required( error="role desc should required").max( 32, error="should not be more than 32 characters")), "status": (Kanpai.String(error="role desc should be string").trim().required( error="role desc should required").max( 32, error="should not be more than 32 characters")) }) validation_results = schema.validate(data) Validations.validate_error(obj=validation_results) check_username_indb = session.query(UserDB).filter_by( username=username).first() check_roledesc_indb = session.query(RoleDB).filter_by( roledesc=roledesc).first() if not check_username_indb: return jsonify({ "status": "error", "errors": f"user {check_username_indb} not present in db" }) if not check_roledesc_indb: return jsonify({ "status": "error", "errors": f"role description {check_roledesc_indb} not present in db" }) if data: userrole = UserRoleDB(userid=check_username_indb.id, roleid=check_roledesc_indb.id, status=status) db.add(userrole) db.commit() return jsonify({ "status": "success", "data": validation_results["data"] })
def add(): name = request.form['name'] price = float(request.form['price']) qty = int(request.form['qty']) product = Product(0, name, price, qty) db.add(db.open_db(db_url), product) return redirect(url_for('index'))
def post(self, *args, **kwargs): data = request.get_json() bankname = data.get("bankname", '') universalbranchcode = data.get("universalbranchcode", "") schema = Kanpai.Object({ "bankname": (Kanpai.String().required().max(32)), "universalbranchcode": (Kanpai.String().required()) }) validation_results = schema.validate(data) Validations.validate_error(validation_results) if data: bankcode = BankCodeDB(bankname=bankname, universalbranchcode=universalbranchcode) db.add(bankcode) db.commit() return jsonify({ "status": "success", "data": validation_results["data"] })
def extract(): global PERFORM_FETCH timestamp = time.time() config = Config() api = Mobileclient() manager = ApiManager(api, config) manager.login() now = datetime.datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0) data_playcounts, data_genres, data_artists = manager.get_plays(now) manager.logout() if data_playcounts is not None: graph_dict = graph_data(data_genres) if PERFORM_FETCH: inserts = len(data_playcounts) inserts += DatabaseInsert.genre_playcount(data_genres, now) inserts += DatabaseInsert.artist_playcount(data_artists, now) else: inserts = 0 app.logger.info("%s inserts have been made into the database." % inserts) timestamp = time.time() - timestamp record = models.Metrics(date=now, query_time=timestamp) db.add(record) db.commit() else: graph_dict = None app.logger.info("Database has already been updated for today, avoiding double entry.") return data_playcounts, graph_dict, data_artists
def post(self, *args, **kwargs): schema = Kanpai.Object({ 'name': (Kanpai.String( error="Description should be string").trim().required( error="Description should required").max( 64, error="Should not be more than 64 characters")), 'idnumber': (Kanpai.String( error="Description should be string").trim().required( error="Description should required").max( 64, error="Should not be more than 64 characters")) }) data = request.get_json() validation_result = schema.validate(data) if validation_result.get('success', False) is False: return jsonify({ "status": "error", "errors": validation_result.get('error') }) if data: idtype = IdTypeDB(name=data['name'], idnumber=data['idnumber']) db.add(idtype) db.commit() return jsonify({ "status": "success", "result": validation_result['data'] })
def add_product(): vendor_code = int(request.form['vendor_code']) product_name = request.form['product_name'] price = int(request.form['price']) quantity = int(request.form['quantity']) product = Products(vendor_code, product_name, price, quantity) db.add(db.open_db(db_url), product) return redirect(url_for('index'))
def register(): form = forms.RegisterForm(request.form) if request.method == 'POST' and form.validate(): user = models.User(form.username.data, form.password.data, role="teacher") db.add(user) flash('Thanks for registering') return redirect(url_for('login')) return render_template('register.html', form=form)
def getAthleteStats(challenges): client = stravalib.client.Client(access_token=config.TOKEN) for c in challenges: athStats=models.AthleteStats(client.get_athlete_stats(c.athId)) if athStats.YTDCount > minNumberRuns: db.add(athId=c.athId,athStats=athStats) db.add(c) db.commit()
def addUser(self, social_id, name, email): # check if user exists with the same name. newUser = User(social_id=social_id, name=name, email=email) session.add(newUser) session.commit() if newUser: return newUser return None
def reject_drift(did): with db.auto_commit(): drift = Drift.query.filter_by(requester_id=current_user.id, id=did).first_or_404() drift.pending = PendingStatus.Redraw current_user.beans += 1 db.add(drift) return redirect(url_for('web.pending')) pass
def properties(): properties = db.query(Property) if request.method == 'GET': return render_template('property.html', properties=properties) elif request.method == 'POST': property_ = Property(property_type=request.form.get('property_type'), owner_id=request.form.get('owner_id')) db.add(property_) db.commit() return render_template('property.html', properties=properties)
def create_user(request:Request, response: Response, user_data: schemas.UserIn): user = models.User(username=user_data.username, email=user_data.email) db.add(user) db.commit() _links = {} _links.update({"self" : request.url_for("read_user", user_id=user.id)}) _links.update({"collection" : request.url_for("read_users")}) _links.update({"department" : request.url_for("read_department", department_id=user.department_id)}) user.__setattr__("_links", _links) response.status_code = status.HTTP_201_CREATED return {'data':user}
def create_department(request:Request, response: Response, department_data: schemas.DepartmentIn): department = models.Department(name=department_data.name) db.add(department) db.commit() _links = {} _links.update({"self" : request.url_for("read_department", department_id=department.id)}) _links.update({"collection" : request.url_for("read_departments")}) _links.update({"users" : request.url_for("read_department_users", department_id=department.id)}) department.__setattr__("_links", _links) response.status_code = status.HTTP_201_CREATED return {'data':department}
def update(): property_ = db.query(Property).filter( Property.id == request.form.get('id')).first() if request.form.get('property_type'): property_.property_type = request.form.get('property_type') if request.form.get('owner_id'): property_.property_type = request.form.get('owner_id') db.add(property_) db.commit() return redirect(url_for('properties'))
def register(): if request.method == 'GET': return render_template('register.html') elif request.method == 'POST': user = User(first_name=request.form.get('first_name'), last_name=request.form.get('last_name'), username=request.form.get('username')) user.set_password(request.form.get('password')) db.add(user) db.commit() return redirect(url_for('login'))
def genre_playcount(data, now): app.logger.info("Inserting Genre PlayCount Data ...") insertions = 0 for record in data: insert = models.Genre( date=now, genre=record[0], playCount=record[1] ) db.add(insert) insertions += 1 db.commit() return insertions
def create_categories(): # Create all unique categories in the db. categories = set() for node in nodes: if node['categories']: categories.update(node['categories']) categories = [category for category in categories if len(category) > 2] for name in categories: category = Category(name) db.add(category) db.commit()
def artist_playcount(data, now): app.logger.info("Inserting Artist PlayCount Data ...") insertions = 0 for record in data: insert = models.Artists( date=now, artist=record[0], playCount=record[1] ) db.add(insert) insertions += 1 db.commit() return insertions
def updateItem(self, old_item_id, updated_item, user): if not (self.isCreator(old_item_id, user)): return False old_item = session.query(Item).filter_by(id=old_item_id).first() if not old_item: return False # delete old item self.deleteItem(old_item_id, user) # add updated item session.add(updated_item) session.commit() return True
def post(self, *args, **kwargs): schema = Kanpai.Object({ "username": (Kanpai.String( error='User first name must be string.').trim().required( error='Please provide user first name.').max( 32, error='Maximum allowed length is 32')), "email": (Kanpai.Email(error='User email must be proper.').trim().required( error='Please provide user email.').max( 32, error='Maximum allowed length is 32')), "phone": (Kanpai.String( error='User phone number must be string.').trim().required( error='Please provide user phone number.').max( 13, error='Maximum allowed length is 13')), "gender": (Kanpai.String().trim()), "firstname": Kanpai.String(error='User phone number must be string.'), "surename": Kanpai.String(error='User phone number must be string.'), "DOB": (Kanpai.String().trim()), "idname": Kanpai.String(error="It's not required") }) data = request.get_json() validation_result = schema.validate(data) if validation_result.get('success', False) is False: return jsonify({ "status": "Error", "errors": validation_result.get("error") }) if data: idtypeid = session.query(IdTypeDB).filter_by( name=data['idname']).first() user = UserDB( username=data['username'], email=data['email'] if data['email'] else '*****@*****.**', phone=data['phone'], gender=data['gender'], firstname=data['firstname'], surename=data['surename'], DOB=data['DOB'], idnumber=idtypeid.id) db.add(user) db.commit() return jsonify({ "statu": "success", "data": validation_result["data"] })
def create_key_people(): # Create all key_people in the db. key_people = set() for node in nodes: if node['key_people']: for kp in node['key_people']: key_people.add(kp['name']) key_people = list(key_people) for person in key_people: key_person = Keyperson(person) db.add(key_person) db.commit()
def addItem(self, item): # check if incoming item is not None if item is None: return False # check if item already exists if self.existingItem(item): return False if item.title == '': return False if item.description == '': return False # After all these checks have passed create the item. session.add(item) session.commit() return True
def post(self, *args, **kwargs): data = request.get_json() accountnumber = data.get('accountnumber', "") accountname = data.get('accountname', "") schema = Kanpai.Object({ "accountnumber": Kanpai.String().required(), "accountname": Kanpai.String().required() }) validation_results = schema.validate(data) Validations.validate_error(obj=validation_results) is_accountnumber = session.query(CorperateAccountDB).filter_by( accountnumber=accountnumber).first() is_accountname = session.query(CorperateAccountDB).filter_by( accountname=accountname).first() if is_accountnumber: return jsonify({ "status": "error", "errors": f"account number {is_accountnumber} already present" }) if is_accountname: return jsonify({ "status": "error", "errors": f"account name {is_accountname} already present" }) if data: corpaccount = CorperateAccountDB(accountnumber=accountnumber, accountname=accountname) db.add(corpaccount) db.commit() return jsonify({ "status": "success", "data": validation_results["data"] })
def facebook_authorized(resp): if resp is None: flash(u'Access denied: reason=%s error=%s' % ( request.args['error_reason'], request.args['error_description']) ) return redirect(url_for('sign_in')) session['facebook_token'] = (resp['access_token'], '') me = facebook.get('/me') # >>> me.data # { # "username": "******", # "id": "581604320", # "email": "*****@*****.**" # "locale": "en_US", # "timezone": -5, # "first_name": "Juan-Pablo", # "last_name": "Scaletti", # "name": "Juan-Pablo Scaletti", # "gender": "male", # "link": "http://www.facebook.com/jpscaletti", # "updated_time": "2013-04-15T06:33:55+0000", # } user = db.query(User).filter(User.facebook_id == me.data['id']).first() if not user: # new user! if g.user: user = g.user else: login = get_unique_login(me.data.get('username')) user = User(login=login) db.add(user) user.facebook_id = me.data['id'] user.last_sign_in = datetime.utcnow() # in any case we update the authentication token in the db # In case the user temporarily revoked access we will have # new tokens here. user.facebook_token = resp['access_token'] # don't forget to commit **before** doing ``auth.login(user)` db.commit() auth.login(user) next = request.args.get('next') or url_for('profile') return redirect(next)
def song_playcount(data, now): app.logger.info("Inserting Song PlayCount Data ...") insertions = 0 for record in data: insert = models.Songs( date=now, google_id=record[0], playCount=record[1], artist=record[2], album=record[3], title=record[4], trackNumber=record[5], genre=record[6] ) db.add(insert) insertions += 1 db.commit() return insertions
def post(self, *args, **kwargs): data = request.get_json() schema = Kanpai.Object({ "rolecode": (Kanpai.Number().integer().between(1, 10)), "roledesc": (Kanpai.String(error="Role desc should be String").trim().required( error="Role code is required")), "status": (Kanpai.String( error="Role desc should be active, deactive").trim().required( error="Role code is required")) }) validation_results = schema.validate(data) if validation_results.get('success', False) is False: return jsonify({ "status": "error", "errors": validation_results.get('error') }) is_role_duplcate = session.query(RoleDB).filter_by( rolecode=data['rolecode']).first() if is_role_duplcate: return jsonify({ "status": "error", "errors": f"role code {is_role_duplcate.rolecode} already present" }) if data: role = RoleDB(rolecode=data['rolecode'], roledesc=data['roledesc'], status=data['status']) db.add(role) db.commit() return jsonify({ "status": "success", "data": validation_results["data"] })
def create_entity(node): entity = Entity(node['name']) entity.nickname = node['nickname'] entity.entitytype = node['type'] entity.influence = node['influence'] if entity.influence: entity.influence = entity.influence.capitalize() entity.employees = node['employees'] entity.url = node['url'] entity.twitter_handle = node['twitter_handle'] entity.followers = node['followers'] categorize(entity, node['categories']) add_finances(entity, node['revenue'], 'revenue') add_finances(entity, node['expenses'], 'expenses') #add_relations(entity, node['relations']) connect_key_people(entity, node['key_people']) db.add(entity) db.flush() add_location(entity, node['location']) old_to_new[node['ID']] = entity.id
def twitter_authorized(resp): if resp is None: flash(u'You denied the request to sign in.') return redirect(url_for('sign_in')) session['twitter_token'] = resp['oauth_token'] # >>> resp # { # "oauth_token_secret": "...", # "oauth_token": "...", # "user_id": "11640332", # "screen_name": "jpscaletti" # } user = db.query(User).filter(User.twitter_id == resp['user_id']).first() if not user: # new user! if g.user: user = g.user else: login = get_unique_login(resp['screen_name']) user = User(login=login) db.add(user) user.twitter_id = resp['user_id'] user.last_sign_in = datetime.utcnow() # in any case we update the authentication token in the db # In case the user temporarily revoked access we will have # new tokens here. user.twitter_username = resp['screen_name'] user.twitter_token = resp['oauth_token'] user.twitter_secret = resp['oauth_token_secret'] # don't forget to commit **before** doing ``auth.login(user)` db.commit() auth.login(user) next = request.args.get('next') or url_for('profile') return redirect(next)
def post(self, *args, **kwargs): data = request.get_json() bankname = data.get("bankname", "") branchname = data.get("branchname", "") branchaddress = data.get("branchaddress", "") schema = Kanpai.Object({ "bankname": (Kanpai.String().required().max(32)), "branchname": (Kanpai.String().required()), "branchaddress": (Kanpai.String().required()) }) validation_results = schema.validate(data) Validations.validate_error(validation_results) bankcode = session.query(BankCodeDB).filter_by( bankname=bankname).first() if not bankcode: return jsonify({ "status": "error", "errors": f"user {bankname} not present in db" }) if data: branchcode = BranchCodeDB(bankcode=bankcode, branchname=branchname, branchaddress=branchaddress) db.add(branchcode) db.commit() return jsonify({ "status": "success", "data": validation_results["data"] })
if g.user: return redirect(url_for('profile')) form = RegisterForm(request.form) if request.method == 'POST' and form.is_valid(): user = form.save() user.add_role('user') db.commit() # commit BEFORE doing auth.login! auth.login(user) return redirect(url_for('profile')) return render_template('index.html', **locals()) @app.route('/user/') @auth.protected() def profile(): return render_template('profile.html', **locals()) if __name__ == '__main__': # Just for this demo db.create_all() if not User.by_login(u'example'): db.add(User(login=u'example', password='******')) db.commit() # port = int(os.getenv("PORT", 5000)) app.run(host='0.0.0.0', port=port)
def create_new_session(username): print "Creating new sitting session" session = Session(username) db.add(session) db.commit() return session
#!./flask/bin/python # -*- coding: utf-8 -*- from app import db from app.models import AuthUser, Equipment, User, Department u = AuthUser("admin", "passad") u.role = 1 db.add(u) db.commit() u = AuthUser("user", "passus") u.role = 0 db.add(u) db.commit() equipment = [ ['Sys block', '123456', '123456'], ['Monitor', '214365', '214365'], ['Faks', '432165', '432165'], ['Scanner', '654321', '654321'], ['Sys block', '1324356', '1324356'] ] users = [ ['Serg', 'Porokh'], ['Vasyl', 'Chereda'], ['Musiy', 'Storoguk'] ] departments = ['jur', 'it']
#!./flask/bin/python # -*- coding: utf-8 -*- from app import db from app.models import AuthUser, Equipment, User, Department u = AuthUser("admin", "passad") u.role = 1 db.add(u) db.commit() u = AuthUser("user", "passus") u.role = 0 db.add(u) db.commit() us_quip = { (u'Порох', u'Сергій'): [ [u'Системиний блок', '123456', '132465'], [u'Монітор', '123457', '132467'], [u'Факс', '123458', '132468'] ], (u'Копайбіда', u'Олег'): [ [u'Системиний блок', '123466', '132475'], [u'Монітор', '123477', '132477'], [u'Факс', '123478', '132478'] ], (u'Череда', u'Василь'): [ [u'Системиний блок', '123436', '132435'], [u'Монітор', '123437', '132437'],
import csv from app import app, create_app, db from app import models hr = models.Department(name='HR') sales = models.Department(name='Sales') legal = models.Department(name='Legal') engineering = models.Department(name='Engineering') db.add(hr) db.add(sales) db.add(legal) db.add(engineering) admin = models.User(username="******", email="*****@*****.**") guest = models.User(username="******", email="*****@*****.**") jan = models.User(username="******", email="*****@*****.**") hein = models.User(username="******", email="*****@*****.**") klaas = models.User(username="******", email="*****@*****.**") pit = models.User(username="******", email="*****@*****.**") db.add(admin) db.add(guest) db.add(jan) db.add(hein) db.add(klaas) db.add(pit) hr.users.append(admin) sales.users.append(jan) legal.users.append(hein) engineering.users.append(klaas)