def login():
"""Log in a registered user by adding the user id to the session."""
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
error = None
user_password = get_db()[2].get(username, None)
print(username)
print(get_db()[2])
if user_password is None:
error = "Incorrect username."
elif not check_password_hash(user_password, password):
error = "Incorrect password."
if error is None:
# store the user id in a new session and return to the index
session.clear()
session["user_id"] = username
return redirect(url_for("index"))
flash(error)
return render_template("auth/login.html")
def get_by_name(name):
db = get_db()
result = db.companies.find_one({'name': name}, {'_id': False})
if result is None:
raise NotFound('Company', name)
else:
return result
def index():
"""Home view"""
"""Show all upcoming deadlines and list courses."""
coursedb = get_db()[0]
# Get current user's course IDs
courses = g.user.get_courses()
# Get courses from course DB
deadlines = []
for id in courses:
act_course = coursedb.get(id)
deadlines += act_course.get_assignments()
# Pick only the ones that are due
deadlines = [x for x in deadlines if not x.has_passed()]
# Sort by due date
deadlines = sorted(deadlines, key=lambda x: x.due_date)
days_left = get_timer_content([x.due_date for x in deadlines])
due_today = [((x.due_date - datetime.now()).days == 0) for x in deadlines]
# Get them ready with tags, sort by due date
today = 1 + (datetime.today().weekday() + 1) % 7
return render_template("home/index.html",
deadlines=deadlines,
courses=courses,
badges=days_left,
due_today=due_today,
calendar_link=g.user.calendar_link,
today=today)
def index():
db = get_db()
requests = db.execute(
'SELECT created, product, location FROM request JOIN device ON device_id = device.id ORDER BY created DESC;'
).fetchall()
return render_template('monitor.html', requests=requests)
def register():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
password_confirm = request.form['password-confirm']
db = get_db()
error = None
if not username:
error = 'Username is required.'
elif not password:
error = 'Password is required.'
elif not password_confirm or not password_confirm == password:
error = 'Passwords must match.'
elif db.execute('SELECT id FROM user WHERE username = ?',
(username, )).fetchone() is not None:
error = 'User {} is already registered.'.format(username)
if error is None:
db.execute('INSERT INTO user (username, password) VALUES (?, ?)',
(username, generate_password_hash(password)))
db.commit()
return redirect(url_for('auth.login'))
flash(error)
return render_template('auth/register.html')
def get_by_guid_with_friends(guid, friend_eye_color = None, friend_has_died = None):
cond = []
if friend_eye_color is not None:
cond.append({ '$eq': ["$$this.eye_color", friend_eye_color]})
if friend_has_died is not None:
cond.append({ '$eq': ["$$this.has_died", friend_has_died ]})
db = get_db()
people = list(db.people.aggregate([
{'$match': { 'guid': guid}},
{
'$project': {
'_id': False,
'name': True,
'age': True,
'address': True,
'phone': True,
'friends': {
'$filter': {
'input': '$friends',
'cond': { '$and': cond }
}
}
}
}
]))
if len(people) == 0:
raise NotFound('Person', guid)
return people[0]
def create_recipe():
if request.method == 'POST':
print('form just submitted!')
print(request.form.__dict__)
title = request.form.get('title', "default title")
notes = request.form.get('notes', "default notes")
db = get_db()
err = None
if not (notes and title):
error = "cannot create a recipe without fields"
if err is None:
query = """
INSERT INTO recipe
(author_id, title, author_notes)
VALUES (?, ?, ?)
"""
query_args = (g.user['id'], title, notes)
db.execute(query, query_args)
db.commit()
return redirect(url_for('recipes.list_recipes'))
else:
print(err)
return render_template('recipes/create.html')
def register():
db = get_db()
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
error = None
if not username:
error = 'Username is required.'
elif not password:
error = 'Password is required.'
elif db.execute('SELECT id FROM user WHERE username = ?',
(username, )).fetchone() is not None:
error = 'User {} is already registered.'.format(username)
if error is None:
db.execute('INSERT INTO user (username, password) VALUES (?, ?)',
(username, generate_password_hash(password)))
db.commit()
flash('User successfully added !')
else:
flash(error)
users = db.execute(
'SELECT username FROM user ORDER BY username DESC').fetchall()
users = [u['username'] for u in users]
return render_template('auth/register.html', users=users)
def get_by_guid(guid, projection={'_id': False}):
db = get_db()
result = db.people.find_one({ 'guid': guid }, projection)
if result is None:
raise NotFound('Person', guid)
else:
return result
def load_logged_in_user():
user_id = session.get('user_id')
if user_id is None:
g.user = None
else:
g.user = get_db().execute('SELECT * FROM user WHERE id = ?',
(user_id, )).fetchone()
def post(self):
db = get_db()
data = request.json
cur = db.cursor()
cur.execute("INSERT INTO form (content) VALUES (?)",
(json.dumps(data['content']), ))
db.commit()
cur.close()
return {'payload': {'id': cur.lastrowid}}
def load_logged_in_user():
"""If a user id is stored in the session, load the user object from
the database into ``g.user``."""
user_id = session.get("user_id")
if user_id is None:
g.user = None
else:
g.user = get_db()[1].get(user_id, None)
def restock():
if request.method == 'POST':
device_id = request.form['device_id']
device = get_db().execute(
'SELECT * FROM device WHERE id = ?;', (device_id,)
).fetchone()
get_db().execute(
'INSERT INTO request (device_id) VALUES (?);', (device_id,)
)
get_db().commit()
msg = Message("New Restock Request!")
msg.recipients = [current_app.config['NOTIFICATION_RECIPIENT']]
msg.body = 'A new restock request was received.\n\n\nProduct: {}\nLocation: {}\n\n\nThis message was sent automatically by a prototype "smart button"'.format(device['product'], device['location'])
mail.send(msg)
return "All good!"
def get(self, id=None):
if id is None:
abort(400)
db = get_db()
cur = db.cursor()
cur.execute("SELECT content FROM form WHERE id=?", (str(id), ))
rows = cur.fetchall()
if len(rows) == 0:
return abort(404)
return {'payload': json.loads(rows[0][0])}
def list_recipes():
db = get_db()
query = """
SELECT title, author_notes, username FROM recipe r
INNER JOIN user u
ON r.author_id = u.id
"""
recipes = db.execute(query)
return render_template('recipes/recipes.html', recipes=recipes)
def get_recipe(recipe_id):
db = get_db()
query = """
SELECT *
FROM recipe r
WHERE r.id = ?
"""
query_args = (recipe_id, )
res = db.execute(query, query_args).fetchone()
if res is None:
return "oops! recipe not found :("
return get_json(res)
def get_user_recipes(user_id):
db = get_db()
query = """
SELECT *
FROM recipe r
WHERE r.author_id = ?
"""
query_args = (user_id, )
res = db.execute(query, query_args).fetchall()
if res is None:
return "no recipes found for specified user :("
return get_json(res)
def plantes():
db = get_db()
if request.method == 'POST':
deleteid = request.form.get('delete')
buyid = request.form.get('buy')
if deleteid is not None:
if db.execute('SELECT id FROM courses WHERE id = ?',
(deleteid, )).fetchone() is None:
flash('L\'article n\'existe pas.')
else:
db.execute('DELETE FROM courses WHERE id = ?', (deleteid, ))
db.commit()
elif buyid is not None:
if db.execute('SELECT id FROM courses WHERE id = ?',
(buyid, )).fetchone() is None:
flash('L\'article n\'existe pas.')
else:
db.execute(
'UPDATE courses SET needed = 1 - needed WHERE id = ?',
(buyid, ))
db.commit()
else:
name = request.form.get('name')
desc = request.form.get('description')
error = None
if not name:
error = 'Indiquer un nom d\'article.'
elif not desc:
error = 'Indiquer une description d\'article.'
elif db.execute('SELECT id FROM courses WHERE name = ?',
(name, )).fetchone() is not None:
error = u'L\'article {} existe déjà.'.format(name)
if error is None:
db.execute('INSERT INTO courses (name, desc) VALUES (?, ?)',
(name, desc))
db.commit()
flash(u'Nouvel article ajouté !')
else:
flash(error)
articles = db.execute(
'SELECT id, name, desc, needed FROM courses ORDER BY needed DESC, name'
).fetchall()
return render_template('plantes.html', articles=articles)
def setUp(self):
self.app = create_app({
'mongodb': {
'host': 'localhost',
'port': 27017,
'database': 'hivery_integration_test'
}
})
self.client = self.app.test_client()
with self.app.app_context():
self.db = get_db()
# erase all existing data to ensure tests are independant
self.db.people.drop()
self.db.companies.drop()
def put(self, id=None):
if id is None:
abort(400)
db = get_db()
data = request.json
cur = db.cursor()
cur.execute("SELECT content FROM form WHERE id=?", (str(id), ))
rows = cur.fetchall()
if len(rows) == 0:
return abort(404)
cur.execute("UPDATE form SET content = ? WHERE ID = ?;",
(json.dumps(data), id))
db.commit()
cur.close()
return {'payload': data}
def index():
db = get_db()
users = db.execute(
'SELECT * FROM user'
)
# get random recipe from database
random_query = """
SELECT *
FROM recipe
WHERE id IN
(SELECT id
FROM recipe
ORDER BY RANDOM()
LIMIT 1)
"""
recipe = db.execute(random_query).fetchone()
if recipe is None:
print('uh oh')
return render_template('index.html', users=users, recipe=dict(recipe))
def login():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
db = get_db()
error = None
user = db.execute('SELECT * FROM user WHERE username = ?',
(username, )).fetchone()
if user is None:
error = 'Incorrect username.'
elif not check_password_hash(user['password'], password):
error = 'Incorrect password.'
if error is None:
session.clear()
session['user_id'] = user['id']
return redirect(url_for('index'))
flash(error)
return render_template('auth/login.html')
def setting():
if request.method == 'POST':
config_id = request.form['config_id']
db = get_db()
error = None
if not config_id:
error = 'Username is required.'
elif db.execute(
'SELECT config_id FROM configuration WHERE config_id = ?',
(config_id, )).fetchone() is not None:
error = 'User {} is already registered.'.format(config_id)
if error is None:
# set new configuration
db.execute('INSERT INTO configuration (config_id) VALUES (?)',
config_id)
db.commit()
return redirect(url_for('hello'))
flash(error)
return render_template('config/setting.html')
from backend.schemas.issues import Label, Severity, Status
from backend.db import Base, engine, get_db
from backend.models import projects, users, issues
from backend.schemas.users import UserType
from config import settings
# init database
Base.metadata.create_all(bind=engine)
session = next(get_db())
session.add(
users.User.create_user(
settings.admin_email,
settings.admin_user,
settings.admin_pass,
"Admin",
"Admin",
int(UserType.admin),
))
session.add(projects.Project.create("Bug tracker", 1))
session.add_all([
issues.Issue(
title="Set authentication",
description="Create login/register forms",
severity=Severity.high,
status=Status.opened,
label=Label.enhancement,
reporter=1,
project_id=1,
),
def get_person_favourite_food(guid):
db = get_db()
return get_by_guid(guid, {'_id': False, 'favourite_food': True, 'name': True, 'age': True})
def __init__(self):
self.db_name = 'nvd'
self.c = get_db()
def get_people_by_company_name(name):
db = get_db()
# We are pulling the whole result into memory cause we generally have a reasonable number of employees
# per company. If the volume becomes to large, plan to handle pagination in the service
return list(db.people.find({ 'company.name': name }, DEFAULT_PERSON_PROJECTION))
from backend.db import get_db, Sample, Connection, Url, ASN
from backend.additionalinfo import get_ip_info, get_url_info, get_asn_info
db = get_db()
sess = db.sess
asn_cache = {}
urls = sess.query(Url).all()
for url in urls:
if url.asn_id and not url.asn and not url.asn_id in asn_cache:
asn_info = get_asn_info(url.asn_id)
if asn_info:
asn_obj = ASN(asn=url.asn_id,
name=asn_info['name'],
reg=asn_info['reg'],
country=asn_info['country'])
sess.add(asn_obj)
print "Adding ASN " + str(url.asn_id) + " " + asn_info['name']
asn_cache[url.asn_id] = True
conns = sess.query(Connection).all()
for conn in conns:
if conn.asn_id and not conn.asn and not conn.asn_id in asn_cache:
asn_info = get_asn_info(conn.asn_id)
if asn_info:
asn_obj = ASN(asn=conn.asn_id,
name=asn_info['name'],
