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 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 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)
