def test_get_group_members(self):
user = self._sample_user()
group = self._sample_group(user)
with self.app_context:
Group.remove(group.id)
User.remove(user.id)
user.save()
group.save()
ret = []
for friend_id in group.users:
friend = User.get_by_id(friend_id)
ret.extend([{
'friend_id': friend_id,
'name': friend.email,
'location': friend.location
}])
self.assertGreater(len(ret), 0)
Group.remove(group.id)
User.remove(user.id)
async def update(self, db: AsyncSession, *, db_obj: models.User,
obj_in: Union[UserUpdate, Dict[str, Any]]) -> models.User:
if isinstance(obj_in, dict):
update_data = obj_in
else:
update_data = obj_in.dict(exclude_unset=True)
if update_data.get("password"):
hashed_password = get_password_hash(update_data["password"])
del update_data["password"]
update_data["hashed_password"] = hashed_password
if update_data.get("roles") or len(update_data["roles"]) == 0:
roles = await db.execute(
select(models.Role).filter(models.Role.name.in_(obj_in.roles)))
db_obj.roles = roles.scalars().all()
del update_data["roles"]
if update_data.get("study_areas") or len(
update_data["study_areas"]) == 0:
study_areas = await db.execute(
select(models.StudyArea).filter(
models.StudyArea.id.in_(obj_in.study_areas)))
db_obj.study_areas = study_areas.scalars().all()
del update_data["study_areas"]
return await super().update(db, db_obj=db_obj, obj_in=update_data)
def test_activate_email_invite(self):
inviter = self._sample_user()
invite = Invite.create("*****@*****.**", inviter.id)
with self.app_context:
invite.save()
Invite.activate(invite.token, "pass")
user = User.get_by_email(invite.email)
self.assertIsNotNone(user)
self.assertEqual(user.email, invite.email)
User.remove(user.id)
Group.remove_member(invite.inviter_id, user.id)
def test_register_user(self):
with self.app_context:
user = User.register(email="*****@*****.**", password="******")
user.save()
user_test = User.get_by_id(user.id)
self.assertIsNotNone(user_test.access_token)
self.assertEqual(user.email, "*****@*****.**")
self.assertTrue(check_password_hash(user.password, "paco"))
User.remove(user.id)
def test_update_user_location(self):
user = self._sample_user()
with self.app_context:
user.save()
User.update_location(user.id, 57.062, 13.673)
user_test = User.get_by_id(user.id)
self.assertEqual(user_test.location[0], 57.062)
self.assertEqual(user_test.location[1], 13.673)
User.remove(user.id)
def update_user_location():
log("In update_user_location method")
lat = request.json.get('lat')
lon = request.json.get('lon')
user_id = g.user.id
log("Got user details in update_user_location")
User.update_location(user_id, lat, lon)
log("Updated location")
response_data = create_response_data(
"Updated location",
200
)
return jsonify(response_data), response_data['status_code']
async def set_active_state_of_custom_poi(
self, *, db: AsyncSession, obj_in: schemas.CutomDataUploadState,
current_user: models.User):
"""Set active state of custom poi."""
data_upload_obj = await db.execute(
select(models.DataUpload).filter(
models.DataUpload.id == obj_in.data_upload_id))
data_upload_obj = data_upload_obj.scalars().first()
if data_upload_obj.user_id != current_user.id:
raise HTTPException(status_code=400,
detail="User ID does not match")
data_upload_ids_obj = current_user.active_data_upload_ids
if obj_in.state == False and data_upload_obj.id in data_upload_ids_obj:
try:
data_upload_ids_obj.remove(obj_in.data_upload_id)
except ValueError:
print("Data upload doesn't exist")
elif obj_in.state == True and data_upload_obj.id not in data_upload_ids_obj:
data_upload_ids_obj.append(obj_in.data_upload_id)
else:
return current_user
current_user.active_data_upload_ids = data_upload_ids_obj
flag_modified(current_user, "active_data_upload_ids")
db.add(current_user)
await db.commit()
await db.refresh(current_user)
return current_user
def login_user():
email = request.json.get('email')
password = request.json.get('password')
if not (email or password):
response_data = Utils.create_response_error(
'EmptyEmailOrPassword', 'The email or password is empty', 409)
return jsonify(response_data)
try:
user = User.login(email, password)
except User.IncorrectEmailOrPassword:
response_data = Utils.create_response_error(
'IncorrectEmailOrPassword', 'The email or password is incorrect',
409)
return jsonify(response_data)
except User.UserNotExists:
response_data = Utils.create_response_error(
'UserNotExists', 'The user was not found in the database!', 409)
return jsonify(response_data)
g.user = user
response_data = Utils.create_response_data(user.to_dict(), 200)
return jsonify(response_data)
def add_member_to_group(group_id):
log("Adding member to group...")
user_id = request.json.get('user_id')
user_email = request.json.get('email')
log("Going to check e-mail and user id...")
if user_email != "" and user_email is not None and Utils.email_is_valid(
user_email):
user = User.get_by_email(user_email)
if user is not None:
log("Email: Adding {} to group {}".format(user_email, group_id))
Group.add_member(group_id, user.id)
else:
invite = Invite.create(user_email, g.user.id)
invite.save()
invite.send()
else:
if user_id != "" and user_id is not None:
log("ID: Adding {} to group {}".format(user_id, group_id))
Group.add_member(group_id, user_id)
else:
response_data = Utils.create_response_error(
"InternalServerError",
"The server could not fulfil your request", 500)
return jsonify(response_data), response_data['status_code']
response_data = Utils.create_response_data(
Group.get_by_id(group_id).to_dict(), 200)
return jsonify(response_data), response_data['status_code']
def init_db():
from src.db.models import User
Base.metadata.drop_all(bind=engine)
Base.metadata.create_all(bind=engine)
jake = User(name='jake', password='******', email='*****@*****.**')
db_session.add(jake)
db_session.commit()
def test_add_member_to_group(self):
user = self._sample_user()
group = self._sample_group(user)
with self.app_context:
Group.remove(group.id)
User.remove(user.id)
user.save()
group.save()
Group.add_member(group.id, "1234")
group_test = Group.get_by_id(group.id)
Group.remove(group.id)
User.remove(user.id)
self.assertTrue("1234" in group_test.users)
def login_facebook():
email = request.json.get('email')
password = request.json.get('password')
user = User.create(email, password)
user.save()
response_data = create_response_data(
user.to_dict(),
200
)
return jsonify(response_data), response_data['status_code']
def get_friend_locations(group_id):
group = Group.get_by_id(group_id)
ret = []
for friend_id in group.users:
ret.extend([User.get_by_id(friend_id).to_dict()])
response_data = create_response_data(
{'friends': ret},
200
)
return jsonify(response_data), response_data['status_code']
def post(self):
try:
parser = reqparse.RequestParser()
parser.add_argument('email', type=str)
parser.add_argument('name', type=str)
parser.add_argument('password', type=str)
args = parser.parse_args()
user = User(args['name'], args['password'], args['email'])
db_session.add(user)
db_session.commit()
return str(user)
except Exception as e:
return {'error': str(e)}
def current_user():
"""get current user by token"""
req_token = request.headers.get('Authorization')
_current_user = False
if req_token:
user = User.verify_auth_token(req_token)
if user:
_current_user = user
if web_current_user:
_current_user = web_current_user
with request:
g.current_user = _current_user
g.host = request.headers.get('Host')
def register_user():
email = request.json.get('email')
password = request.json.get('password')
if not email_is_valid(email):
response_data = create_response_error(
'InvalidEmail',
'This email is invalid',
409
)
return jsonify(response_data)
if not password:
response_data = create_response_error(
'InvalidPassword',
'This password is invalid',
409
)
return jsonify(response_data)
try:
user = User.register(email, password)
except User.EmailAlreadyInUse:
response_data = create_response_error(
'UsedEmail',
'This email is already in use',
409
)
return jsonify(response_data)
user.save()
g.user = user
# Create a Friends default group for the user
# This group has the same id as the user id
friends_group = Group.create(group_id=user.id,
name="Friends",
creator=user.id)
friends_group.save()
response_data = create_response_data(
user.to_dict(),
200
)
return jsonify(response_data), response_data['status_code']
def check_authorization(authorization):
if authorization is not None:
try:
prefix, access_key = authorization.split(' ')
except ValueError:
return False
if prefix != '<DEFINE_PREFIX_HERE>':
return False
try:
g.user = User.get_by_access_token(access_key)
except User.DoesNotExist:
return False
return True
def check_authorization(authorization):
if authorization is not None:
try:
ffinder, access_key = authorization.split(' ')
except ValueError:
return False
if ffinder != 'FFINDER':
return False
try:
g.user = User.get_by_access_token(access_key)
except User.DoesNotExist:
return False
return True
def confirm(token):
log("Starting confirmation...")
invite = Invite.get_by_token(token)
log("Inviter ID: {}".format(invite.inviter_id))
inviter = User.get_by_id(invite.inviter_id)
log("Invited by: {}".format(inviter.email))
try:
return render_template('invite.html',
email=invite.email,
token=token,
inviter_email=inviter.email), 200
except jinja2.TemplateNotFound:
response_data = Utils.create_response_error(
"InternalServerError", "The server could not display the template",
500)
return jsonify(response_data), response_data['status_code']
def send_welcome(message):
user = User.query.filter_by(tid=message.from_user.id).first()
if not user:
user = User(tid=message.from_user.id, is_admin=False)
session.add(user)
session.commit()
course_themes = CourseTheme.query.all()
markup = telebot.types.InlineKeyboardMarkup(row_width=6)
for ct in course_themes:
markup.row(
telebot.types.InlineKeyboardButton(text=ct.name,
callback_data=':'.join(
['get_cn',
str(ct.id)])))
tbot.send_message(chat_id=message.from_user.id,
text='\U0001F680 Выберите Ваше направление подготовки',
reply_markup=markup)
def confirm(token):
log("Starting confirmation...")
invite = Invite.get_by_token(token)
log("Inviter ID: {}".format(invite.inviter_id))
inviter = User.get_by_id(invite.inviter_id)
log("Invited by: {}".format(inviter.email))
try:
return render_template('invite.html',
email=invite.email,
token=token,
inviter_email=inviter.email), 200
except Exception:
type, ex, trace = sys.exc_info()
loggerObject.error(path + " | " + os.path.join(path, '../../app/templates/'))
loggerObject.error(type)
loggerObject.error(ex.message)
response_data = create_response_error(
"InternalServerError",
"The server could not display the template",
500
)
return jsonify(response_data), response_data['status_code']
def _sample_user(self):
user = User.create(email="*****@*****.**", password="******")
return user
def test_save_user(self):
user = self._sample_user()
with self.app_context:
user.save()
User.remove(user.id)
