def register():
form = RegisterForm()
if form.validate_on_submit():
print("Valid")
user_id = User.objects.count() # >=0
user_id += 1
email = form.email.data
password = form.password.data
first_name = form.first_name.data
last_name = form.last_name.data
user = User(user_id=user_id,
email=email,
first_name=first_name,
last_name=last_name)
user.set_password(password)
user.save()
flash("You are successfully registered!", "success")
return redirect(url_for('index'))
return render_template("register.html",
title="Register",
form=form,
register=True)
def register():
if session.get('username'):
return redirect(url_for("index"))
registerform = RegisterForm()
if registerform.validate_on_submit():
user_id = User.objects.count()
user_id += 1
first_name = registerform.first_name.data
last_name = registerform.last_name.data
email = registerform.email.data
password = registerform.password.data
new_user = User(userid=user_id,
email=email,
first_name=first_name,
last_name=last_name)
new_user.set_password(password)
new_user.save()
# flash("You Are Successfully Registered","success")
return redirect(url_for("index"))
return render_template("register.html",
registerformtitle="New User Registration",
registerform=registerform,
register=True)
def user_loader(email):
validate = Users.query.filter_by(email=email).first()
if not validate:
return
user = User()
user.id = email
return user
def register():
if session.get('username'):
return redirect(url_for('index'))
form = RegisterForm()
if form.validate_on_submit() == True:
user_id = User.objects.count()
user_id += 1
email = form.email.data
password = form.password.data
first_name = form.first_name.data
last_name = form.last_name.data
user = User(user_id=user_id,
password=password,
email=email,
first_name=first_name,
last_name=last_name)
user.save()
flash("You are successfully registered!", "success")
return redirect(url_for('index'))
return render_template("register.html",
title="Register",
form=form,
register=True)
def register(email, password, first_name, last_name, birthday, gender, address,
suburb, postcode):
if db.users.find({email: email}):
return {'status': "Email is already in use."}
user_id = User.objects.count()
user_id += 1
user = User(user_id=user_id,
email=email,
first_name=first_name,
last_name=last_name,
birthday=birthday,
gender=gender,
address=address,
suburb=suburb,
postcode=postcode,
available=True,
confirmed=False)
user.set_password(password)
confirm_email(email)
id = db.Users.insertOne(user).get("insertedId")
token = user.assign_token(id)
return {'status': "success", 'token': token, "id": id}
def create_dummy_account(pg):
"""Create dummy account with liked and bookmarked recipes"""
from application.models import User
from passlib.hash import pbkdf2_sha512
import datetime
# If user entry already exists, do nothing, otherwise create it
user = User.query.filter_by(username=pg.dummy_name).first()
if not user:
user = User(
username=pg.dummy_name,
password=pbkdf2_sha512.hash(pg.dummy_password),
email=pg.dummy_email,
confirmed=False,
created_on=datetime.datetime.utcnow(),
optin_news=True,
)
pg.session.add(user)
pg.session.commit()
user = User.query.filter_by(username=pg.dummy_name).first()
# Add item to cookbook
pg.add_to_cookbook(user.userID, pg.url)
# Like a recipe
pg.rate_recipe(user.userID, pg.url, 5)
user = User.query.filter_by(username=pg.dummy_name).first()
assert user.email == pg.dummy_email
def new_user():
user = User(username='******',
password='******',
email='*****@*****.**',
account_created_on=datetime.utcnow().strftime('%Y-%m-%d'))
return user
def register():
# Check if user is already logged in
if current_user.is_authenticated:
return redirect(url_for('account'))
form = RegistrationForm()
# Check if a request is both a POST request and a valid request
if form.validate_on_submit():
username = form.username.data
email = form.email.data
first_name = form.first_name.data
last_name = form.last_name.data
password = form.password.data
gdpr_check = form.gdpr_check.data
# Create new instance of user
user = User(username = username, email = email, first_name = first_name, last_name = last_name, gdpr_check = gdpr_check)
# Hash password
user.set_password(password)
# Insert record to the DB
user.save()
flash(f'Welcome, we\'re glad to have you here {form.first_name.data}! Please login with your e-mail and password.', 'success')
return redirect("/login")
# Getting latest 5 recipes for footer
footer_recipes = Recipe.objects[:5].order_by('-recipe_id')
# Render html, giving its title, passing in the form and footer recipes
return render_template("register.html", title = "Register", form = form, footer_recipes = footer_recipes)
async def on_post(self, req: Request, resp: Response):
id_token = req.media.get('id_token')
if not id_token:
raise falcon.HTTPForbidden('Missing Token')
# Download the cert and verify the token
try:
decoded_token = auth.verify_id_token(id_token)
uid = decoded_token['uid']
except (ValueError, exceptions.InvalidIdTokenError):
raise falcon.HTTPForbidden('Invalid Token')
except exceptions.RevokedIdTokenError:
raise falcon.HTTPForbidden('Token Revoked')
except exceptions.CertificateFetchError:
raise falcon.HTTPForbidden('Missing Certificate')
# Create our session cookie
try:
expires_in = datetime.timedelta(days=7)
session_cookie = auth.create_session_cookie(id_token,
expires_in=expires_in)
resp.set_cookie('session',
session_cookie,
expires=datetime.datetime.now() + expires_in)
except exceptions.FirebaseError:
raise falcon.HTTPForbidden('Session Cookie Failure')
# Grab our local user object
session = req.context.session
user = session.query(User).filter(User.firebase_uid == uid).first()
# Create our user, if this is their first sign-in
if not user:
user = User(firebase_uid=uid)
session.add(user)
session.commit()
resp.status = falcon.HTTP_CREATED
def new_game():
global user_data
req_data = request.get_json()
logging.error(req_data)
id = req_data['id']
user = User.query.filter_by(sber_id=id).first()
res = {}
if user is None:
db.session.add(User(id, 0, -1))
db.session.commit()
res = {'level': 0, 'diff': -1}
else:
res = {'level': user.level, 'diff': user.difficulty}
user_data[id] = {
'word_list':
list(
map(
lambda word: (word.rus, word.eng),
Word.query.filter_by(level=res['level'],
difficulty=res['diff']).limit(5))),
'cur_word':
0,
'testing_phase':
False,
}
logging.error(user_data)
response = app.response_class(response=json.dumps(res),
status=200,
mimetype='application/json')
return response
def register():
if session.get('first_name'):
return redirect(url_for('index'))
form = RegisterForm()
if form.validate_on_submit():
user_id = User.objects.count()
user_id += 1
email = form.email.data
password = form.password.data
first_name = form.first_name.data
last_name = form.last_name.data
user = User(user_id=user_id,
email=email,
first_name=first_name,
last_name=last_name)
user.set_password(password)
user.save()
flash("You're registered now!", "success")
return redirect(url_for('index'))
return render_template('register.html', register=True, form=form)
def post(self):
data = api.payload
user = User(user_id=data['user_id'], email=data['email'],
first_name=data['first_name'], last_name=data['last_name'])
user.set_password(data['password'])
user.save()
return jsonify(User.objects(user_id=data['user_id']))
def add_user():
id = request.form.get("id")
first = request.form.get("firstname")
last = request.form.get("lastname")
role = request.form.get("role")
gender = request.form.get("gender")
nationality = request.form.get("nationality")
email = request.form.get("email")
mobile = request.form.get("mobile")
password = request.form.get("password")
if id and first and last and role and gender and nationality and email and mobile and password:
hashed_password = bcrypt.generate_password_hash(password).decode('utf-8')
check_user = User.query.filter_by(user_id=id).first()
if check_user:
flash('The User is already registered in the system!', 'danger')
return redirect(url_for('add_user'))
else:
user = User(user_id=id, firstname=first, lastname=last, role=role, gender=gender, nationality=nationality, email=email, mobile=mobile, password=hashed_password)
db.session.add(user)
db.session.commit()
flash('The new user has been added successfully', 'success')
return redirect(url_for('add_user'))
return render_template('/admin/add_user.html')
def register():
if session.get('username'):
return redirect(url_for('index'))
form = RegisterForm()
print("hello")
if form.validate_on_submit():
print("on submit")
user_id = User.objects.count()
user_id += 1
email = form.email.data
password = form.password.data
name = form.name.data
role_id = form.role_id.data
user = User(ws_user_id=user_id,
ws_email=email,
ws_name=name,
ws_role_id=role_id)
user.set_password(password)
user.save()
flash("You are registered", "success")
return redirect('/index')
return render_template("register.html", title="Register", form=form)
def file_upload():
if 'file' not in request.files:
return jsonify('false'), 403
res = {'code': 0, 'msg': '禁止'}
user_id = session.get('user_id')
image = request.files['file']
header_type = request.headers.get('Type')
key_res = False
if image and allowed_file(image.filename):
img_path = './upload/' + user_id + '.png'
if header_type == '1':
img_path = './upload/' + user_id + '.old.png'
# 生成key
key_res = gen_user_key(user_id)
if header_type == '2':
img_path = './upload/' + user_id + '.new.png'
try:
image.save(os.path.join(img_path))
except Exception as e:
print(e)
res['msg'] = '系统错误0'
return jsonify(res), 200
# 人脸有无判断
try:
result = load_and_detect_data([img_path], 1.0)
except Exception as e:
print(e)
res['msg'] = '系统错误1'
return jsonify(res), 200
if result == 0:
os.remove(img_path)
res['msg'] = '未识别到人脸'
return jsonify(res), 200
if header_type == '1' and not key_res:
res = {'code': 0, 'msg': '密钥生成失败'}
return jsonify(res), 200
# 数据入库
db_res = User.query.filter(User.user_id == user_id).first()
if db_res is None:
user = User(user_status=1,
user_id=user_id,
user_upload=1,
create_time=time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime()))
db.session.add(user)
db.session.commit()
elif header_type == '1':
user = User.query.filter(User.user_id == user_id).first()
user.user_upload += 1
user.user_status = 1
db.session.add(user)
db.session.commit()
res['code'] = 1
res['msg'] = '上传成功'
res['user_id'] = user_id
return jsonify(res), 200
else:
return jsonify(res), 200
def signup():
"""
User sign-up using API
POST to /api/signup using JSON with
{name: , email: , password: , college: , major: }
Checks if data is valid and email unique.
Responds with authentication token in JSON {token: }
Checks for valid data is done before posting but there are
some defaults and checks:
email must be unique to succeed.
college and major will defualt to 'None','Undecided' if
erroneous text is passed for either category
"""
# Get posted JSON data
signup_data = request.get_json()
name = signup_data['name']
email = signup_data['email']
password = signup_data['password']
college = signup_data['college']
major = signup_data['major']
# Check if user already exists and valid unc charlotte email
existing_user = User.query.filter_by(email=email).first()
if existing_user is None and str(email).endswith('@uncc.edu'):
# Create and add user to database
user = User(username=name,
email=email,
password=password,
college=college,
major=major)
db.session.add(user)
db.session.commit()
user = User.query.filter_by(email=email).first()
for item in [college, major]:
add_room(item)
room = Chatroom.query.filter_by(name=item).first()
add_member(user=user, room=room)
# generate auth token
token = encode_token(user.id)
# Respond with success message and token
response = {
'status': 'success',
'message': 'successfully registered.',
'token': token.decode()
}
return make_response(jsonify(response)), 201
# failure, user exists or invalid info
else:
response = {
'status': 'failure',
'message': 'could not be registered.',
}
return make_response(jsonify(response)), 400
def test_timestamps(self):
u = User(password='******')
db.session.add(u)
db.session.commit()
self.assertTrue(
(datetime.utcnow() - u.member_since).total_seconds() < 3)
self.assertTrue(
(datetime.utcnow() - u.last_seen).total_seconds() < 3)
def signin():
if request.method == "POST":
req = request.form
new_user = User(username=req.get("username"),
password=req.get("password"))
db.session.add(new_user)
db.session.commit()
return render_template("login.html")
def test__user_can_instantiate(self, db):
user = User(username="******", email="*****@*****.**")
db.session.add(user)
db.session.commit()
getuser = User.query.filter_by(username=user.username).first()
assert getuser is user
def createUser(login_session):
newUser = User(name=login_session['username'],
email=login_session['email'],
urlfoto=login_session['picture'])
db.session.add(newUser)
session.commit()
user = User.query.filter_by(email=login_session['email']).one()
return user.id
def index():
if session.get('userId'):
user = User.objects(ws_user_id=session.get('userId')).first()
return render_template("index.html",
name=session.get('username'),
email=user.ws_email)
user_id = User.objects.count()
if user_id == 0:
user_id += 1
email = "*****@*****.**"
password = "******"
name = "Customer Executive"
role_id = "1111"
user = User(ws_user_id=user_id,
ws_email=email,
ws_name=name,
ws_role_id=role_id)
user.set_password(password)
user.save()
user_id += 1
email = "*****@*****.**"
password = "******"
name = "Cashier/Teller"
role_id = "2222"
user = User(ws_user_id=user_id,
ws_email=email,
ws_name=name,
ws_role_id=role_id)
user.set_password(password)
user.save()
role_id = Role.objects.count()
if role_id == 0:
role_id = "1111"
name = "CAE"
Role(roleId=role_id, name=name).save()
role_id = "2222"
name = "C/T"
Role(roleId=role_id, name=name).save()
return redirect("/login")
def test_ping(self):
u = User(password='******')
db.session.add(u)
db.session.commit()
time.sleep(2)
last_seen_before = u.last_seen
u.ping()
self.assertTrue(u.last_seen > last_seen_before)
def test_user_attributes(self):
user = User("Maddy")
user.device = "testid"
user.tutor = True
user.tutor = False
db.session.add(user)
db.session.commit()
assert user in db.session
def setUp(self):
for x in models.CELL_BLACK_LIST[:]:
models.CELL_BLACK_LIST.pop()
app.config['TESTING'] = True
self.login('*****@*****.**', 'testuser')
self.app = app.test_client()
self.user = User(user=users.get_current_user())
self.user.put()
def get_person(name):
person = User.query.filter(User.name.like(name)).first()
if not person:
person = User(name)
db.session.add(person)
db.session.commit()
write_to_events("created", "user", person.id, person)
return person
def test_invalid_token(app_, db_):
detail = deepcopy(USER_DETAIL)
user = User(id=detail['individualId'], unit=detail['homeUnitNbr'])
db_.session.add(user)
token = generate_auth_token(user)
change = b'1' if token[0] != b'1' else b'0' # change token to invalidate
invalid_token = change + token[1:]
assert verify_auth_token(invalid_token) is None
def test_reuse_user_on_later_login(_mock_sync, mock_tenant, mock_login, app_,
db_):
detail = deepcopy(USER_DETAIL)
mock_login.return_value = (mock.MagicMock(), detail)
db_.session.add(User(id=detail['individualId'],
unit=detail['homeUnitNbr']))
user_login('u', 'p')
assert db_.session.query(User).count() == 1
def create(self):
data = json.loads(request.data)
if 'mail' not in data:
abort(400)
u = users.User(data['mail'])
a = User(role='editor', user=u)
a.save()
return Response(a.as_json(), mimetype='application/json')
def post(self):
data = api.payload
user = User(user_id=data["user_id"],
email=data["email"],
first_name=data["first_name"],
last_name=data["last_name"])
user.set_password(data["password"])
user.save()
return jsonify(User.objects(user_id=data["user_id"]))
def signup():
params = request.authorization
try:
user = User(**params)
db.session.add(user)
db.session.commit()
except IntegrityError:
return {"Status": "Error", "result": "User already exists"}, 400
return {"Status": "Success", "result": "User created"}
