def login():
schema = UserSchema()
req = request.form or request.get_json()
response = dict(errors=dict(), logged_in=False, results=dict())
# Valid data or return errors
try:
data = schema.load(req).data
except ValidationError as err:
response['errors'] = err.messages
return jsonify(response)
users = mongo_mgr.db.users
login_user = users.find_one({'username': data['username']})
if login_user:
if check_password_hash(login_user['password'],
data['password'].encode('utf-8')):
session['username'] = data['username']
response['results'] = schema.dump(login_user)
response['logged_in'] = True
return json.dumps(response)
def get_distances():
"""
Each user has a lat/lon associated with them. Determine the distance
between each user pair, and provide the min/max/average/std as a json response.
This should be GET only.
You can use numpy or whatever suits you
"""
response = dict(
errors=dict(),
results=dict(min=0, max=0, avg=0, std=0),
)
db = mongo_mgr.db.users
users = db.find()
user_schema = UserSchema()
results = user_schema.dump(users, many=True)
coordinates = []
for item in results.data:
if 'coordinates' in item.get('location', dict()):
coordinates.append(tuple(item['location']['coordinates']))
response['results'] = calculate_distances(coordinates)
return jsonify(response)
def get(self):
user_info = UserSchema(only=("username", "id", "email", "role",
"avatarURL"))
_id = get_jwt_identity()
user = UserModule(id=_id)
current_user = UserModule(**user.find_by_id())
reponse_user = user_info.dump(current_user)
return make_response(reponse_user)
def get(cls, user_id: int):
user = UserModel.find_by_id(user_id)
user_schema = UserSchema()
if not user:
return max_err(USER_NOT_FOUND, 404)
return max_res(user_schema.dump(user))
def get_user(user_id):
schema = UserSchema()
response = dict(errors=dict(), results=dict())
users = mongo_mgr.db.users
login_user = users.find_one({'_id': ObjectId(user_id)})
results = schema.dump(login_user)
response['results'] = results.data
return jsonify(response)
def get_users():
"""
Update this to return a json stream defining a listing of the users
Note: Always return the appropriate response for the action requested.
"""
schema = UserSchema()
response = dict(errors=dict(), results=dict())
users = mongo_mgr.db.users
login_user = users.find()
results = schema.dump(login_user, many=True)
response['results'] = results.data
return jsonify(response)
def new_user(req):
schema = UserSchema()
response = dict(errors=dict(), logged_in=False, results=dict())
# Valid data or return errors
try:
data = schema.load(req).data
except ValidationError as err:
response['errors'] = err.messages
return jsonify(response)
users = mongo_mgr.db.users
existing_user = users.find_one({'username': data['username']})
if existing_user is None:
hash_pass = generate_password_hash(data['password'])
user = dict(
username=data['username'],
password=hash_pass,
first_name=None,
last_name=None,
coordinates=dict(
lat=None,
lng=None,
),
)
add_user = users.insert_one(user)
session['username'] = data['username']
response['logged_in'] = True
response['results']['username'] = session['username']
response['results']['id'] = str(add_user.inserted_id)
return response
# User exists
response['errors']['user_exists'] = 'This account already exists.'
response['results'] = schema.dump(existing_user)
return response
def update_user(user_id):
"""
Update user specified with user ID and return updated user contents
Note: Always return the appropriate response for the action requested.
"""
schema = UserSchema()
req = request.form or request.get_json()
response = dict(errors=dict(), results=dict(), updated=False)
data = schema.load(req)
users = mongo_mgr.db.users
update = users.update_one(
{'_id': ObjectId(user_id)},
{'$set': data.data},
)
if update.matched_count and update.modified_count:
response['updated'] = True
updated_user = users.find_one({'_id': ObjectId(user_id)})
results = schema.dump(updated_user)
response['results'] = results.data
return jsonify(response)