def test_users():
for d in UNIQUE_USERS:
user = User()
user.first_name = d[0]
user.last_name = d[1]
user.email = d[2]
user.access = d[3]
user.salcie = d[4]
user.incie = d[5]
user.mucie = d[6]
user.is_active = True
user.set_password(user.first_name)
db.session.add(user)
db.session.commit()
for i, d in enumerate(USERS):
user = User()
user.first_name = f"{d[0]}{i}"
user.last_name = d[1]
user.email = f"{user.first_name}{d[2]}"
user.access = d[3]
user.salcie = d[4]
user.incie = d[5]
user.mucie = d[6]
user.is_active = True
user.set_password(user.first_name)
db.session.add(user)
db.session.commit()
def normal_register():
request_json = request.get_json()
print(request_json)
if request_json.get('isSnap'):
user = User(email="*****@*****.**",
password="******",
name=request_json['name'],
isSnap=True,
snapPic=request_json['snapPic'])
db.session.add(user)
db.session.commit()
return json.dumps({'id': user.id, 'status': 0})
if User.query.filter_by(email=request_json['email']).first():
return json.dumps({
'status':
1,
'output':
User.query.filter_by(email=request_json['email']).first().email,
'error':
"User Already Exists"
})
email = request_json['email']
hashed_pwd = bcrypt.generate_password_hash(
request_json['password']).decode('utf-8')
name = request_json['name']
# noinspection PyArgumentList
user = User(email=email, password=hashed_pwd, name=name)
db.session.add(user)
db.session.commit()
return json.dumps({'id': user.id, 'status': 0})
def testdb(request):
test1 = User(name='runoob')
test1.save()
test2 = User(name='测试')
test2.save()
test3 = User(name='成功')
test3.save()
return HttpResponse("<p>数据添加成功！</p>")
def index(request, template_name='webpage/index.html'):
if is_party_assigned(request):
return redirect('webparty:index')
join_party_form = JoinPartyForm(request.POST or None)
join_party_form.fields['admin_password'].widget = forms.HiddenInput()
set_passwd_form = SetPasswordForm(request.POST or None)
if join_party_form.is_valid():
party_tag = join_party_form.cleaned_data['party_tag']
try:
party = Party.objects.get(tag=party_tag)
except:
party = None
user = get_user(request)
if not user:
user = User(session=Session.objects.get(
session_key=request.session.session_key),
party=party)
else:
user.party = party
user.save()
return redirect('webparty:index')
if set_passwd_form.is_valid():
party = Party()
party.init_party()
user = get_user(request)
if not user:
user = User(session=Session.objects.get(
session_key=request.session.session_key),
party=party)
else:
user.party = party
user.save()
party.admins.add(user)
party.password = set_passwd_form.cleaned_data['password']
party.save()
return redirect('player')
context = {
'join_form': join_party_form,
'host_form': set_passwd_form,
}
return render(request, template_name, context)
def authorized():
resp = rc.authorized_response()
if resp is None:
raise AuthorizationFailed('Error: {} ({})'.format(
request.args['error'], request.args['error_description']))
session['rc_token'] = {
'access_token': resp['access_token'],
'refresh_token': resp['refresh_token'],
'expires_at': resp['expires_in'] + time() - 600
}
me = rc.get('profiles/me').data
user = User.query.get(me['id'])
if user is None:
user = User(
id=me['id'],
name=util.name_from_rc_person(me),
avatar_url=me['image_path'],
is_faculty=util.profile_is_faculty(me),
)
db.session.add(user)
db.session.commit()
elif user.faculty != util.profile_is_faculty(me):
user.faculty = util.profile_is_faculty(me)
db.session.commit()
session['user_id'] = user.id
return redirect(url_for('home'))
def sign_up():
username = request.json.get('username', None)
email = request.json.get('email', None)
password = request.json.get('password', None)
if not username or not password or not email:
return jsonify({'login': False}), 401
hashed_pass = generate_password_hash(password, method='sha256')
default_skill = json.dumps({'learning':0})
new_user = User(username=username, email=email, hashed_password=hashed_pass, user_skills=default_skill, focus='', theme='galaxy')
db.session.add(new_user)
db.session.commit()
# Create the tokens we will be sending back to the user
access_token = create_access_token(identity=username)
refresh_token = create_refresh_token(identity=username)
user = new_user.to_dict()
print('---------------------------------------')
print(user)
# Set the JWT cookies in the response
resp = jsonify({'login': True, **user})
print('--------------------')
print(resp)
set_access_cookies(resp, access_token)
set_refresh_cookies(resp, refresh_token)
return resp, 200
def register(request):
if request.method == 'POST':
user_id = request.POST['user_id']
client_id = Client(client_id = request.POST['companyTypeSelect']) #ForeignKey
prefix = request.POST['appellationTypeSelect']
first_name = request.POST['first_name']
middle_name = request.POST['middle_name']
last_name = request.POST['last_name']
job_title = request.POST['job_title']
email = request.POST['email']
office_phone = request.POST['office_phone']
cell_phone = request.POST['cell_phone']
if User.objects.filter(user_id = user_id).exists():
messages.info(request, 'User already exists. Please try different User name')
return redirect('register')
else:
user = User(user_id = user_id, client_id=client_id, prefix=prefix, first_name=first_name, middle_name=middle_name,
last_name=last_name, job_title=job_title, email=email, office_phone=office_phone, cell_phone=cell_phone)
user.save()
#messages.info(request, 'User Created. Please login now.')
return redirect('/')
else:
client_list = Client.objects.order_by('client_id') #all client records
context = {'client_list' : client_list}
return render(request, 'register.html', context)
def register():
if current_user.is_authenticated:
abort(400)
data = request.get_json()
if not data or not 'password' in data or not 'username' in data or not 'first_name' in data \
or not 'last_name' in data or not 'gender' in data or not 'birth_date' in data or not 'email' in data:
abort(400)
check_user = User.query.filter_by(email=data['email']).first()
if check_user:
return 'Email Taken'
check_user = User.query.filter_by(username=data['username']).first()
if check_user:
return 'Username Taken'
hashed_password = bcrypt.generate_password_hash(
data['password']).decode('utf-8')
user = User(username=data['username'],
first_name=data['first_name'],
last_name=data['last_name'],
gender=data['gender'],
birth_date=datetime.datetime.now(),
email=data['email'],
password=hashed_password)
db.session.add(user)
db.session.commit()
return 'Created'
def join_party(request):
if is_party_assigned(request):
return redirect('player')
if request.method == 'POST':
form = JoinPartyForm(request.POST)
if form.is_valid():
party_tag = form.cleaned_data['party_tag']
party = Party.objects.get(tag=party_tag)
password = form.cleaned_data['admin_password']
user = get_user(request)
if not user:
user = User(session=Session.objects.get(session_key=request.session.session_key), party=party)
else:
user.party = party
user.save()
if password != '' and password == party.password:
party.admins.add(user)
party.save()
return redirect('player')
else:
form = JoinPartyForm()
return render(request, 'party/join_party.html', {'join_party_form': form})
def register():
if current_user.is_authenticated:
abort(403)
data = request.form['user']
data = json.loads(data)
if not data or not 'password' in data or not 'username' in data or not 'firstname' in data \
or not 'lastname' in data or not 'email' in data or not 'bio' in data:
abort(400)
check_user = User.query.filter_by(email=data['email']).first()
if check_user:
return make_response((jsonify({'error': 'email taken'})), 400)
check_user = User.query.filter_by(username=data['username']).first()
if check_user:
return make_response((jsonify({'error': 'username taken'})), 400)
if 'file' in request.files:
file = request.files['file']
picture_saved_name = save_picture(file)
else:
picture_saved_name = ""
hashed_password = bcrypt.generate_password_hash(
data['password']).decode('utf-8')
user = User(username=data['username'],
first_name=data['firstname'],
last_name=data['lastname'],
email=data['email'],
password=hashed_password,
bio=data['bio'],
image_file=picture_saved_name)
db.session.add(user)
db.session.commit()
return make_response((jsonify({'ok': 'account created'})), 200)
def authorized(access_token):
existing_user = None
oauth_user = None
meta = None
if oauth_user is None:
oauth_user = User(github_access_token=access_token)
g.user = oauth_user
github_user = github.get("/user")
github_emails = github.get("/user/emails")
existing_user = User.query.filter_by(github_id=github_user["id"]).first()
if existing_user:
oauth_user = existing_user
meta = oauth_user.meta
else:
meta = Meta(roles="Student")
db.session.add(meta)
db.session.commit()
oauth_user = create_user(github_user, github_emails, access_token, meta.id)
student = Student(meta_id=meta.id)
db.session.add(student)
db.session.add(oauth_user)
db.session.commit()
session["profile"] = MetaSerializer(meta).data
g.user = oauth_user
# return session["profile"]
return redirect("https://camp.bitproject.org", 200)
def update(cnx, id, username, password):
user = User.User(cnx)
user.update((
username,
password,
id,
))
def admin_user(db):
user = User(email="*****@*****.**", password="******")
db.session.add(user)
db.session.commit()
return user
def register():
if not request.is_json:
return jsonify({"msg": "Error mala consulta"}), 400
email = request.json.get('email', None)
password = request.json.get('password', None)
firstName = request.json.get('firstName', None)
lastName = request.json.get('lastName', None)
if not email:
return jsonify({"msg": "El correo electrónico es requerido"}), 400
if not password:
return jsonify({"msg": "La contraseña es requerida"}), 400
if not firstName:
return jsonify({"msg": "El nombre del usuario es requerido"}), 400
if not lastName:
return jsonify({"msg": "Los apellido del usuario es requerido"}), 400
if User.objects(email=email).first():
return jsonify({"msg": "El correo electrónico ya esta registrado"}), 400
user = User(email=email, first_name=firstName, last_name=lastName)
user.set_password(password)
user.save()
return jsonify({ "msg": "Creado con éxito" }), 200
def auth():
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
email = request.json.get('email', None)
password = request.json.get('password', None)
if not email:
return {"msg": "Please enter an email"}, 400
if not password:
return {"msg": "Please enter a password"}, 400
user = User.query.filter(User.email == email).first()
if request.method == 'PUT': # login
if not user or not user.check_password(password):
return {"msg": "Invalid email or password"}, 401
elif request.method == 'POST': # signup
if user:
return {"msg": "A user with the given email already exists"}, 401
if len(password) < 4:
return {"msg": "Password must be 4 characters or longer"}, 401
user = User(email=email)
user.password = password
db.session.add(user)
db.session.commit()
access_token = create_access_token(identity=user.to_dict())
return access_token, 200
def test_model_repr(db):
u = User(username="******", email="*****@*****.**")
db.session.add(u)
db.session.commit()
u = User.query.one()
assert repr(u) == "<User 1>"
def testid_register(testid):
"""
Given the user's personal info, return a token representing the user.
This token should be stored in a session cookie on the frontend side.
"""
form = request.form
# Create the user and add data
testid = TestID.query.filter_by(testid=testid).first()
if not testid:
return "Test ID Not Found", 400
try:
user = User()
user.token = str(uuid.uuid4())
user.testid = testid
user.reuse = False
user.first_name = form["firstname"]
user.last_name = form["lastname"]
user.email = form["email"]
user.date_of_birth = form["date-year"] + "-" + form[
"date-month"] + "-" + form["date-day"]
user.testing_location = form["testing-location"]
db.session.add(user)
db.session.commit()
except KeyError as e:
print(form)
print(e)
return "Missing field", 400
# Send back le token
return user.token
def register():
if request.mimetype != 'application/json':
abort(415)
data = register_schema(request.json)
user = User.query.filter_by(email=data['email']).first()
if user:
if user.is_invite:
user.password = data['password']
user.first_name = data['first_name']
user.last_name = data['last_name']
user.registered_at = datetime.datetime.now()
user.is_invite = False
db.session.commit()
return jsonify({'success': 'User created'})
else:
return jsonify({'errors': {'email': 'Email already in use'}}), 400
user = User(email=data['email'].lower(),
password=data['password'],
first_name=data['first_name'],
last_name=data['last_name'],
registered_at=datetime.datetime.now(),
is_invite=False)
db.session.add(user)
db.session.commit()
return jsonify({'success': 'User created'})
def add_data(self):
logging.basicConfig(level=logging.INFO)
logging.info('testing add data...')
try:
for i in range(0, 10):
user = User(id=i + 1,
student_id=f"{i+1}",
username=f"ct{i+1}",
password=encrypt_helper("123"),
email=f"bz{i}@163.com",
phone=f"123{i}")
db.session.add(user)
db.session.flush()
except Exception as e:
logging.error(f'error when adding users: {e}')
try:
for i in range(0, 10):
task = Task(id=i + 1,
title='cbbmjm哈哈',
creator_id=f"{i%2+1}",
task_type=f"{i%3+1}",
reward=100,
description="pptmjj",
due_time="2019-07-02 18:00",
max_participate=i % 3 + 1)
db.session.add(task)
db.session.flush()
except Exception as e:
logging.error(f'error when adding tasks: {e}')
try:
for i in range(0, 10):
comment = Comment(user_id=i + 1,
task_id=i + 1,
content="Nice!")
db.session.add(comment)
db.session.flush()
except Exception as e:
logging.error(f'error when adding comments: {e}')
try:
for i in range(0, 10):
collect = Collect(user_id=i + 1, task_id=i + 1)
db.session.add(collect)
db.session.flush()
except Exception as e:
logging.error(f'error when adding collects: {e}')
try:
for i in range(0, 10):
participate = Participate(user_id=i + 1,
task_id=i % 2 + 1,
status=1)
db.session.add(participate)
db.session.flush()
except Exception as e:
logging.error(f'error when adding participates: {e}')
db.session.commit()
logging.info('testing add data succeed')
def addUser():
if request.method == "POST":
try:
account = request.form["account"]
username = request.form["username"]
password = request.form["password"]
level = request.form["level"]
if level == "MANAGE_LOW":
user = User()
user.createUser(
account=account,
password=generate_password_hash(password),
role=level,
username=username,
)
db.session.add(user)
db.session.commit()
sha = hashlib.md5()
sha.update(account.encode("utf-8"))
loveworker = LoveWorker()
loveworker.id = sha.hexdigest()
loveworker.level = 8
loveworker.manId = g.user.manLink.first().id
loveworker.userAc = account
db.session.add(loveworker)
db.session.commit()
except Exception as e:
flash("用户已存在")
return redirect(url_for("manage.index"))
else:
user = g.user
return render_template("manage/user/add.html", user=user)
def normal_register():
request_json = request.get_json()
if User.query.filter_by(email=request_json['email']).first():
return json.dumps({
'status':
0,
'output':
User.query.filter_by(email=request_json['email']).first().email,
'error':
"User Already Exists"
})
elif User.query.filter_by(gt_id=request_json['gt_id']).first():
return json.dumps({
'status':
0,
'error':
"The provided GeorgiaTech ID is already registered."
})
email = request_json['email']
hashed_pwd = bcrypt.generate_password_hash(
request_json['password']).decode('utf-8')
name = request_json['name']
gt_id = request_json['gt_id']
# noinspection PyArgumentList
user = User(email=email,
password=hashed_pwd,
name=name,
gt_id=gt_id,
isAdmin=False)
db.session.add(user)
db.session.commit()
return json.dumps({'id': user.id, 'status': 1})
def register():
if request.method == "POST":
try:
account = request.form["account"]
username = request.form["username"]
password = request.form["password"]
user = User()
user.createUser(
account=account,
password=generate_password_hash(password),
role="USER_LOW",
username=username,
)
db.session.add(user)
db.session.commit()
baseLink = BaseUser()
baseLink.createInfo(level=1, userAc=account)
db.session.add(baseLink)
db.session.commit()
except Exception as e:
print(e)
flash("注册失败")
return redirect(url_for("auth.register"))
return redirect(url_for("auth.login"))
else:
return render_template("auth/register.html")
def setUp(self):
User.objects.bulk_create([
User(username=f"admin{i}",
email=f"admin{i}@mpt.vn",
password=make_password('123456'),
is_active=True) for i in range(0, 3)
])
def register():
print("inside register")
data = request.get_json()
if not data:
return jsonify(error='Fill all the fields!!')
print(data)
name = data.get('name')
username = data.get('username')
user = User.query.filter_by(username=username).first()
print (user)
if user is not None:
return jsonify(error='Username already taken', success=False)
password = data.get('password')
email = data.get('email')
user = User.query.filter_by(email=email).first()
if user is not None:
return jsonify(error='Email is already registered', success=False)
tags = data.get('tags')
major = data.get('major')
user = User(name, username, password, email, tags, major)
db.session.add(user)
db.session.commit()
return jsonify(success=True)
def signup():
data = request.get_json()
username = data['username']
email = data['email']
profile_pic = data['profile_pic']
if not username:
return jsonify(message="Username required"), 400
elif not email:
return jsonify(message='Email required'), 400
elif not (data['password'] == data['rePassword']):
return jsonify(message="Passwords must match"), 400
if not profile_pic:
return jsonify(message="error in profile pic upload")
try:
hashed_password = set_password(data['password'])
except Exception:
return jsonify(message='Password required'), 400
user = User(username=username,
email=email,
hashed_password=hashed_password,
profile_pic=profile_pic)
db.session.add(user)
db.session.commit()
auth_token = create_access_token(identity={"username": user.username})
return jsonify(auth_token=auth_token), 200
def registered_user(new_user, app, _db):
new_user = User(**new_user)
with app.app_context():
db = _db
db.session.add(new_user)
db.session.commit()
return new_user
def post(self):
try:
args = self.parser.parse_args()
email = args['email']
password = sha256_crypt.hash(args['password'])
username = args['username']
firstname = args['firstname']
lastname = args['lastname']
language = args['language']
user = User(email=email,
username=username,
password=password,
firstname=firstname,
lastname=lastname,
language=language)
try:
db.session.add(user)
db.session.commit()
except Exception as e:
print(e)
return jsonify(status="error",
message="app.auth.register_error")
return jsonify(status="success")
except Exception as e:
print(e)
return jsonify(status="error", message="app.auth.register_error")
def post(self):
args = parser.parse_args()
user = User()
for key, value in args.items():
setattr(user, key, value)
db.session.add(user)
db.session.commit()
return user_schema.dump(user).data
def test_create_new_user(new_user):
"""Test user model."""
new_user = User(username=new_user["username"],
password=new_user["password"])
assert new_user.username == "TestName"
assert new_user.check_password("TestPassword")
def test_create_new_user(new_user):
"""Test user model."""
new_user = User(username=new_user['username'],
password=new_user['password'])
assert new_user.username == 'TestName'
assert new_user.check_password('TestPassword')
