def post(self):
id = request.form.get('id')
pw = request.form.get('pw')
if User.objects(id=id):
return '', 204
else:
User(id=id, pw=pw).save()
return '', 201
def post(self):
id = str(current_identity)
title = request.form.get('title')
content = request.form.get('content')
PostCol(title=title,
content=content,
author=User(id,
User.objects(id=id).first().pw)).save()
return '', 201
async def get_all_user_by_lang(self, lang_id: int) -> List[User]:
sql = f"""
{User.__select__} where "lang_id" = $1
"""
return [
User(**acc) for acc in await self.connection.fetch(
sql,
lang_id,
)
]
def post(self):
try:
body = request.get_json()
user = User(**body)
user.hash_password()
user.save()
id = user.id
return {'id': str(id)}, 201
except FieldDoesNotExist:
raise SchemaValidationError
except NotUniqueError:
raise EmailAlreadyExistsError
except Exception:
raise InternalServerError
def test_create_user(self):
""" Create user in db
Should: return save user in db """
user = User(username='******',
email="*****@*****.**",
password="******",
provider="Tutubo")
user.save()
fresh_user = User.objects().first()
assert fresh_user.username == 'oli'
assert fresh_user.email == '*****@*****.**'
assert fresh_user.password == '123'
assert fresh_user.provider == 'Tutubo'
def user(*args, **kwargs):
args = current_app.config['args']
headers = current_app.config['headers']
response = Response()
route_params = request.view_args
get_params = request.args.to_dict(flat=False)
if request.method in ['POST', 'PUT', 'DELETE']:
body = request.json
message = []
data = None
error = None
try:
if request.method == 'POST':
data = User(**body)
data.save()
data = data.to_mongo()
elif request.method == 'GET':
data = [obj.to_mongo() for obj in User.objects]
elif request.method == 'PUT':
_id = route_params['user_id']
data = User.objects(id=bson.ObjectId(_id))
for attr in [
'first_name', 'last_name', 'email', 'password',
'authorization'
]:
if body.get(attr) is not None:
setattr(data, attr, body[attr])
data.save()
data = data.to_mongo()
elif request.method == 'DELETE':
_id = route_params['user_id']
data = User.objects(id=bson.ObjectId(_id))
data.delete()
elif request.method == 'OPTIONS':
pass
else:
pass
except Exception as e:
error = AugmentedException(e).to_dict()
LOGGER.error('', exc_info=True)
response = jsonify(message=message, data=data, error=error)
response = add_headers(response, headers=headers)
LOGGER.warning(vars(response))
return response
def user_oauth_login():
body = request.get_json()
if (not body or not OAUTH_FIELD in body.keys()):
return error_response(400, 'Cant verify login credentials')
try:
idinfo = id_token.verify_oauth2_token(
body['idToken'],
requests.Request()) if not app.config['TESTING'] else {
'email': body['idToken']
}
email = idinfo['email']
user = User.objects(email=email)
if not user:
username = email.split('@')[0]
username = "******" + username
photo = body['photoURL'] if 'photoURL' in body else None
user = User(email=email,
profile_pic=photo,
username=username,
provider="Google").save()
else:
user = user[0]
if user.is_blocked:
return error_response(401, "User is blocked")
token = jwt.encode(
{
'email': user.email,
'exp':
datetime.datetime.utcnow() + datetime.timedelta(days=7)
},
app.config['SECRET_KEY'],
algorithm=ENCODING_ALGORITHM)
return jsonify({
'token': token.decode('UTF-8'),
"user": user.serialize()
})
except ValueError as err:
return error_response(401,
'Cant verify Google credentials ' + str(err))
def register():
print(request)
email, password, fullname = dict(request.get_json(force=True)).values()
print(email, password, fullname)
if email == "" or password == "" or fullname == "":
abort(400, msg="이메일, 패스워드, 이름은 NULL일 수 없습니다.")
elif not email_pattern.match(email):
abort(400, msg="이메일 형식이 올바르지 않습니다.")
elif not password_pattern.match(password):
abort(400, msg="비밀번호 형식이 올바르지 않습니다.")
elif name_pattern.match(fullname):
abort(400, msg="이름에 특수문자나 숫자가 포함될 수 없습니다.")
elif User.query.filter_by(email=email).first():
return jsonify(status="fail", msg=f"{email}는 이미 등록된 계정입니다."), 400
user = User(email, password, fullname)
db.session.add(user)
db.session.commit()
profile = Profile(user.id, user.fullname)
db.session.add(profile)
db.session.commit()
education = Education(user.id)
db.session.add(education)
db.session.commit()
awards = Awards(user.id)
db.session.add(awards)
db.session.commit()
project = Project(user.id)
db.session.add(project)
db.session.commit()
certificate = Certificate(user.id)
db.session.add(certificate)
db.session.commit()
return jsonify(status="success",
message=f"Successfully Registered: {email}")
def createUser():
try:
data = request.form
for key in getModelKeys(User):
if not key in data:
raise AssertionError(f'Property {key} is missing')
user = User(email=data['email'])
user.setPassword(data['password'])
session.add(user)
session.commit()
session.refresh(user)
return jsonify(user=JSONEncoder(user)), 201
except AssertionError as err:
return jsonify({"message": str(err)}), 400
except Exception as err:
print(err)
return jsonify({"message": str(err)}), 500
def post(self):
"""
Add a new user
"""
body = request.get_json()
if User.find_by_username(body['username']):
return custom_response(
401, 'User {} already exists'.format(body['username']))
if (body['username'] == '' or body['password'] == ''
or body['password'] != body['confirm_password']
or body['full_name'] == '' or body['gender'] > 1
or body['date_of_birth'] == ''):
return custom_response(400, "Invalid parameters")
user = User(
username=body['username'],
password=User.generate_hash(body['password']),
role=USER_ROLE['user'],
full_name=body['full_name'],
gender=body['gender'],
date_of_birth=body['date_of_birth'],
)
try:
user.save()
access_token = create_access_token(identity=create_identity(user))
refresh_token = create_refresh_token(
identity=create_identity(user))
return custom_response(200,
'User {} was created'.format(user.username),
{
'access_token': access_token,
'refresh_token': refresh_token
})
except:
return custom_response(500, 'Something went wrong')
def register_user():
body = request.get_json()
if (not body or not Counter(REGISTER_FIELDS) == Counter(body.keys())
or len(body['password']) == 0):
app.logger.debug(
" Registration || FAILURE || Bad Request --> %s %s", body,
request.content_length, request.content_type)
return error_response(400, 'Cant verify register')
hashed_password = generate_password_hash(body['password'],
method='sha256')
try:
user = User(email=body['email'],
password=hashed_password,
username=body['username'],
provider="Tutubo").save()
id = user.id
response = jsonify({'id': id})
response.status_code = 200
return response
except NotUniqueError:
return error_response(409, 'User already registered')
except ValidationError:
return error_response(400, 'Invalid email address')
def extract_data(result):
return User(id=result['id'],
username=result['username'],
password=result['password'])
def login():
connection = ConnectionManager().get_db_connection()
user_id = UserDAO(connection).read(
User(username=request.args.get('username', None),
password=request.args.get('password', None)))
return json.dumps({'user_id': user_id})
def register():
connection = ConnectionManager().get_db_connection()
user_id = UserDAO(connection).create_or_update(
User(username=request.form['username'],
password=request.form['password']))
return json.dumps({'user_id': user_id})
async def get_user(self, user_id: int) -> Optional[User]:
sql = f'{User.__select__} where "id" = $1'
raw = await self.connection.fetchrow(sql, user_id,)
if (raw):
return User(**raw)
