def db_write_user(data):
summary = Users(**data)
session.add(summary)
# pushing data to db
session.commit()
session.close()
def recipes_list():
username = current_user.get_id()
recipes_filter = recipes
recipes_ordered = recipes
pred_rating = pd.Series([None]*recipes_ordered.shape[0], index = recipes_ordered.index)
allergies = []
if username != None:
user = Users().getUser(username)
allergiesAux = user['allergies']
if isinstance(allergiesAux, list):
allergies = allergiesAux
else:
allergies = allergiesAux.split(',')
if request.method == 'POST':
time = request.form['time']
ingredients = request.form['ingredients']
search = request.form['search']
recipes_filter = recipeClass.getFilteredRecipes(search, time, ingredients,0, allergies)
#filter
if (len(search) > 0 and username!=None):
recipes_ordered,pred_rating = recipeClass.getRecipesRecommender(recipes_filter,username,a)
else:
recipes_ordered = recipes_filter
pred_rating = pd.Series([None]*recipes_ordered.shape[0], index = recipes_ordered.index)
rating = 3
#return render_template('recipes/index.html', recipes=recipes_filter.head(100), rating=rating)
return render_template('recipes/index.html', recipes=recipes_ordered.head(100), rating=rating, pred_rating=pred_rating.head(100))
def process_registration():
"""Register new user if email not already in db."""
f_name = request.form.get('first_name')
l_name = request.form.get('last_name')
email = request.form.get('email')
cell = request.form.get('cell')
password_hash = request.form.get('password')
cell_number = cell_verify(cell) #verify cell number using Twilio API.
#if cell verify returns error- then number is invalid.
if cell_number == False: #exception made for error to return false.
flash("That is not a valid phone number, please try again!")
return redirect('/register')
# if user cell already exists, ask user to login.
if Users.query.filter(Users.cell_number == cell_number).first():
flash("That cell number already exists, please login.")
return redirect('/login')
else: # if user cell does not exist, add to db
user = Users(f_name=f_name,
l_name=l_name,
email=email,
cell_number=cell_number)
user.set_password(password_hash)
db.session.add(user)
db.session.commit()
#place user in session.
session['user_name'] = user.f_name
session['user_id'] = user.user_id
# flash("Successfully logged in!"). #need to fix formating for flash messages
return redirect('/user-page')
def signup():
form = SignupForm()
session['mssg'] = ""
if form.validate_on_submit():
user = Users.query.filter_by(email=form.email.data).first()
if user is None:
hashed_pass = generate_password_hash(form.password.data,
method='sha256')
new_user = Users(username=form.username.data,
email=form.email.data,
password=hashed_pass)
# user_table = UserTableCreator(form.email.data)
# Base.metadata.create_all(engine)
db.session.add(new_user)
db.session.commit()
db.session.close()
return redirect(url_for('login'))
else:
session['mssg'] = "Email ID already in use. Please login"
return render_template('register.html',
form=form,
subtitle="Signup",
mssg=session['mssg'])
return render_template('register.html',
subtitle="Signup",
form=form,
mssg=session['mssg']), 200
def set_users(self, users):
for person_id, display_name in users.items():
self.session.merge(
Users(person_id=person_id,
display_name=display_name,
collections=0))
self.session.commit()
def registration():
if request.method == 'POST':
reg_data = json.loads(request.data)
try:
user = Users(**reg_data)
user.save()
return json.dumps({'success': True, 'user': user.id}), 200
except:
return json.dumps({'success': False}), 400
def register():
form = Register_Form()
if form.validate_on_submit():
user = Users(username=form.name.data, password=form.pwd.data)
db.session.add(user)
db.session.commit()
flash('注册成功')
return redirect(url_for('eNote.index'))
return render_template('register.html', form=form)
def add_users():
try:
data = request.get_json()
u = Users()
for key in data.keys():
setattr(u,key,data[key])
u.save()
return jsonify({"message":"Usuario cadastrado com sucesso!"})
except Exception as e:
return jsonify({"message":"Falhou ao cadastrar: {}".format(e)})
def index():
if request.method == 'POST':
if not request.form['first_name'] or not request.form['last_name']:
return input_not_found()
else:
User = Users(request.form['first_name'], request.form['last_name'])
db.session.add(User)
db.session.commit()
return redirect(url_for('index'))
return render_template('home.html', Users=Users.query.all())
def edit_function_user():
if user_actif[0][-1] == 1:
user = Users(value_name.get(), value_Firstname.get(),
value_poste.get(), value_username.get(),
value_password.get(), value_date_debut.get(),
value_date_fin.get(), value_role.get())
update_user(conn, c, user, user_id)
affiche_table_users(frame3_1)
print("Fonction de modification")
else:
box.showerror("Erreur", "Connectez vous en tant que admin")
def add_function_user():
# pass
if user_actif[0][-1] == 1:
user = Users(value_name.get(), value_Firstname.get(),
value_poste.get(), value_username.get(),
value_password.get(), value_date_debut.get(),
value_date_fin.get(), value_role.get())
add_user(conn, c, user)
print("Fonction d'ajout")
affiche_table_users(frame3_1)
else:
box.showerror("Erreur", "Connectez vous en tant que admin")
def signup():
form = SignupForm()
if form.validate_on_submit():
user = Users(first_name=form.first_name.data,
last_name=form.last_name.data,
email=form.email.data,
password=form.password.data,
is_active=True)
db.session.add(user)
db.session.commit()
return redirect(url_for('root.home'))
return render_template("account/signup.html", form=form)
def user(username):
form = UserForm(request.form)
error = None
if request.method == 'POST':
a = 0
username = form.username.data.lower().strip()
name = form.name.data.lower().strip()
allergies = form.allergies.data.lower().strip()
user = Users().setUser(username,name,allergies,'')
#validation of registration and post to mongo
usero = Users().getUser(username)
if(usero['username'] == ""):
error = "User not found"
return error, 404
else:
form.username=usero['username']
form.name=usero['name']
form.allergies=usero['allergies']
return render_template('user/user.html', form=form, error=error)
def post(self):
errors = {}
# Get all values from signup form
username = self.request.get("username")
password = self.request.get("password")
verify = self.request.get("verify")
email = self.request.get("email")
# Validate form data and return errors if invalid
if not util.valid_username(username):
errors["userError"] = "That isn't a valid username."
if not util.valid_password(password):
errors["passwordError"] = "That isn't a valid password."
if not verify == password:
errors["verifyError"] = "Your passwords don't match."
if not util.valid_email(email):
errors["emailError"] = "That isn't a valid email."
# If errors exist render the page with the errors
# If no errors exist redirect to welcome page
if errors:
errors["userValue"] = username
errors["emailValue"] = email
self.render('signup.html', **errors)
else:
# Create the user entity with validated data
if email:
user = Users(name = username, password = password, email = email)
else:
user = Users(name = username, password = password)
user.put()
# Generate a cookie storing user_id
self.response.headers.add_header('Set-Cookie', 'user_id=%s; Path=/' % str(user.key().id()))
#self.render('/wikihome.html', home="active", logged_in=True)
self.redirect('/')
def test():
yield from orm.create_pool(loop=loop,
user='******',
password='******',
db='awesome')
# u=Users(name='Test', email='*****@*****.**', passwd='1234567890', image='about:blank')
u = Users(name='dflhuang',
email='*****@*****.**',
passwd='0123',
image='about:blank',
id='110')
yield from u.save()
def registration():
if current_user.is_authenticated:
print("Loguejat")
return redirect(url_for('products_list'))
form = RegistrationForm(request.form)
error = None
if request.method == 'POST' and form.validate():
print("post")
a = 0
username = form.username.data.lower().strip()
password = form.password.data.lower().strip()
user = Users().addUser(username, password,'','','')
#validation of registration and post to mongo
return render_template('user/registration.html', form=form, error=error)
def createdb(init=True):
"""creer la base de donnee
a partir de la liste des tables presentent dans le module
models
"""
import model
from sqlobject import SQLObject, sqlhub
from model import Users, Groupe, Role
constraints = []
for (name, table) in vars(model).iteritems():
if (inspect.isclass(table)) and (issubclass(
table, SQLObject)) & (table != SQLObject):
if context.conf["sgbd"] == "postgresql":
constraints.extend(
table.createTable(applyConstraints=False, ifNotExists=True)
) # True pour ne pas creer la table si elle existe deja
else:
table.createTable(ifNotExists=True)
print "Creation de la table `" + name + '` OK'
# Les contraintes ne sont ajoute qu'a la fin (pour postgresql)
if context.conf["sgbd"] == "postgresql":
if constraints:
for constraint in constraints:
if constraint:
sqlhub.processConnection.query(constraint)
if not init:
return
#ajout d'un groupe par default, role et association (ne rien faire si il existe deja)
if not list(Groupe.select(Groupe.q.nom == 'visiteur')): #.
groupe = Groupe(nom="visiteur")
if not list(Role.select(Role.q.name == 'visiteur')): #.
role = Role(name="visiteur")
groupe.addRole(role)
#Ajout d'un groupe admin et d'un admin (ne rien faire si il existe deja)
if not list(Users.select(Users.q.pseudo == 'admin')): #.
user = Users(nom="", prenom="", pseudo="admin", password="******")
print "\n--> Creation d'un compte `admin` mot de passe : `nimda`"
groupe = Groupe(nom="admin")
role = Role(name="admin")
groupe.addRole(role)
user.addGroupe(groupe)
print "Tables crees avec succes\n"
def register():
if not all(k in request.args for k in ("username", "password", "email",
"phone", "zip_code", "name")):
return make_response(
jsonify({
'error':
'Invalid usage. Must include username, password, email, phone, zip_code and name.'
}), 400)
else:
def validate(input):
return len(input) >= 8 and len(input) <= 16
if validate(request.args['username']) and validate(
request.args['password']):
user = Users.query.filter_by(
username=request.args['username']).first()
if not user:
user = Users(request.args['username'],
request.args['password'], request.args['email'],
request.args['phone'], request.args['zip_code'],
request.args['name'])
db.session.add(user)
db.session.commit()
return make_response(
jsonify({
'success': {
'username': user.username,
'email': user.email,
'phone': user.phone,
'zip_code': user.zip_code,
'user_token': user.user_token,
'name': user.name
}
}), 200)
else:
return make_response(
jsonify({'error': 'Username already exists!'}), 400)
else:
return make_response(
jsonify({
'error':
'Username or Password not between 8 and 16 characters.'
}), 400)
def create_user():
if request.method == 'POST':
user_data = request.get_json()
email = user_data.get('email')
password = user_data.get('password')
name = user_data.get('name')
hash_password = bcrypt.generate_password_hash(password)
try:
UserSchema().load(user_data)
except ValidationError:
abort(400, description="Error validation")
new_user = Users(email, hash_password, name)
db.session.add(new_user)
db.session.commit()
return jsonify(UserSchema().dump(new_user))
