def check_special_profile(profile_id):
""" Get Special Profile """
user_profile = Profiles.get_profile(profile_id=profile_id)
if not user_profile:
return custom_response("Profile not found", 400)
user_profile, user_ = profile_schema.dump(user_profile), None
if user_profile.get('email'):
user_ = User.get_user_by_email(user_profile.get('email'))
else:
user_ = User.get_user_by_email(user_profile.get('social_id'))
user_data_needed = {
**check_user_options_and_services(user_), "user_id": user_.id,
"role": user_.user_type,
"beats_shared": user_.medias.filter_by(genre_musical='beats').count(),
"followings": user_.user.count(),
"followers": user_.admire.count()
}
user_beats = user_.medias.filter_by(genre_musical='beats').all()
return custom_response(
{
"profile_checked": user_profile,
"user_data": user_data_needed,
# "user_beats": [media_schema.dump(beat) for beat in user_beats]
},
200)
def get_mail():
""" Get Email """
data, error = validate_data(user_email, request)
if error:
return custom_response(data, 400)
user = User.get_user_by_email(data.get('email'))
if user:
keys = random_int()
reset_pass = user.reset_password_key
user_id = user_schema.dump(User.get_user_by_email(data.get('email')))['id']
if reset_password('RequestPassword.html', keys, email=data.get('email'), name=user.name):
if reset_pass:
data_user = reset_pass_schema.dump(reset_pass[0])
data_user.update({'keys': keys, 'password_reset': 1})
reset_pass[0].update(data_user)
else:
KeyResetPassword(dict(keys=keys, user_id=user_id, password_reset=1)).save()
return custom_response('Email send', 200)
return custom_response("Connexion Failed", 400)
return custom_response("Email not Found", 400)
def register():
""" Create User Function """
data, error = validate_data(user_schema, request, return_dict=False)
if error:
return custom_response(data, 400)
if User.get_user_by_email(data.get('email')):
return custom_response("Email already exist", 400)
data.update({'fileStorage_key': random_string(10), 'profile_id': create_profile(data)})
new_user = User(data)
new_user.save()
keys = random_int()
KeyResetPassword(dict(keys=keys, user_id=new_user.id)).save()
generate_basic_stars(user_id=new_user.id)
if data.get('services'):
generate_condition_globals(new_user.id)
if data.get('user_type') == USER_ARTIST_BEATMAKER:
create_all_default_contract(new_user.id)
data['services']['user_id'] = new_user.id
data['services']['galleries'] = check_galleries_files(request, new_user)
data['services']['materials_id'] = create_new_materials_for_new_services()
new_service = Services(data['services'])
new_service.save()
generate_basic_stars(service_id=new_service.id)
first_service('FirstService.html', data["email"], data["name"], data['services']["title"])
login_success('LoginSuccess.html', data["email"], data["name"], keys)
return token_return(Auth.generate_token(new_user.id), data.get('name'), data.get('email'))
def login():
""" function for login in api """
data, error = validate_data(user_password, request)
if error:
return custom_response(data, 400)
user = User.get_user_by_email(data['email'])
try:
if user.reset_password_key:
return custom_response("Active your account", 400)
except AttributeError:
pass
try:
response = 'invalid email' if not user else 'invalid password' if not user.check_hash(data['password']) else 0
if response:
return custom_response(response, 400)
except TypeError:
pass
ser_user = user_schema.dump(user)
token = Auth.generate_token(ser_user.get('id'))
if ser_user['email']:
user_profile = profile_schema.dump(Profiles.get_profile(ser_user.get('email')))
if user_profile.get('photo'):
return token_return(token, ser_user['name'], data['email'], user_profile['photo'])
return custom_response({'token': token, 'name': ser_user['name'], 'email': data['email']}, 200)
def callback():
""" My Callback function for google login and register """
google = OAuth2Session(Production.CLIENT_ID, token=request.get_json())
resp = google.get(Production.USER_INFO)
if resp.status_code == 200:
user_data, data = resp.json(), {}
user_in_db = User.get_user_by_social_id(user_data['id'])
if user_in_db:
token = Auth.generate_token(user_in_db.id)
_user_profile = Profiles.get_profile(social_id=user_data['id'])
return token_return(token, user_in_db.name, user_in_db.email, _user_profile.photo)
if User.get_user_by_email(user_data['email']):
return custom_response("Email already exist", 400)
data.update({
'social': "google",
'name': user_data['family_name'],
'social_id': user_data['id'],
'fileStorage_key': random_string(10),
'email': user_data['email'],
'photo': user_data['picture']
})
user = User(data)
create_profile(data)
user.save()
create_all_default_contract(user.id)
token = Auth.generate_token(user.id)
generate_basic_stars(user_id=user.id)
login_success('LoginSuccess.html', email=data['email'], name=data["name"])
return token_return(token, data.get('name'), data.get('email'), data.get('photo'))
return custom_response("Unauthorized, Could not fetch your information.", 400)
def check_beatMaker_token(self):
""" """
self.service_test['thematics'] = [AFROBEAT_ALLOWED]
data = {
"name": self.name,
"email": self.email,
"password": self.password,
"user_type": USER_ARTIST_BEATMAKER,
"services": json.dumps(self.service_test),
}
data_form_type = MultipartEncoder(fields=data)
resp = self.app.post('api/users/register',
data=data_form_type,
content_type=data_form_type.content_type)
token = json.loads(resp.get_data(as_text=True))['token']
self.assertEqual(resp.status_code, 200)
# Check my key in data
with self._app.app_context():
user = User.get_user_by_email(self.email)
self.assertTrue(user)
keys_obj = KeyResetPassword.get_by_user_id(user.id)
self.assertTrue(keys_obj)
new_data = {'email': self.email, 'keys': keys_obj.keys}
response = self.app.post('api/users/get_if_keys_validate',
data=json.dumps(new_data),
content_type='application/json')
self.assertEqual(response.status_code, 200)
return token
def createTestAccount(self, email=None):
""" """
data_form_type = MultipartEncoder(
fields={
"name": self.name,
"email": email or self.email,
"password": self.password
})
response = self.app.post('api/users/register',
data=data_form_type,
content_type=data_form_type.content_type)
self.assertEqual(response.status_code, 200)
# Check my key in data
with self._app.app_context():
user = User.get_user_by_email(email=email or self.email)
self.assertTrue(user)
keys_obj = KeyResetPassword.get_by_user_id(user.id)
self.assertTrue(keys_obj)
new_data = {"keys": keys_obj.keys, "email": email or self.email}
response = self.app.post('api/users/get_if_keys_validate',
data=json.dumps(new_data),
content_type='application/json')
self.assertEqual(response.status_code, 200)
def check_keys_validate(self):
# Check my key in data
with self._app.app_context():
user = User.get_user_by_email(self.email)
self.assertTrue(user)
keys_obj = KeyResetPassword.get_by_user_id(user.id)
self.assertTrue(keys_obj)
# If my key is not valid
# Check if keys is out of data and return error for keys
new_data = {"email": self.email}
response = self.app.post('api/users/get_if_keys_validate',
data=json.dumps(new_data),
content_type='application/json')
self.assertEqual(response.status_code, 400)
json_returned = json.loads(response.get_data(as_text=True))
self.assertEqual(json_returned,
'keys: Missing data for required field.')
# Check if email is out of data and return error for email
new_data = {"keys": keys_obj.keys}
response = self.app.post('api/users/get_if_keys_validate',
data=json.dumps(new_data),
content_type='application/json')
self.assertEqual(response.status_code, 400)
json_returned = json.loads(response.get_data(as_text=True))
self.assertEqual(json_returned,
'email: Missing data for required field.')
# Check if key no validate
new_data = {"keys": 00000, "email": self.email}
response = self.app.post('api/users/get_if_keys_validate',
data=json.dumps(new_data),
content_type='application/json')
self.assertEqual(response.status_code, 400)
json_returned = json.loads(response.get_data(as_text=True))
self.assertTrue(json_returned, "Keys invalid")
# Check if key validate
new_data['keys'] = keys_obj.keys
response = self.app.post('api/users/get_if_keys_validate',
data=json.dumps(new_data),
content_type='application/json')
self.assertEqual(response.status_code, 200)
json_returned = json.loads(response.get_data(as_text=True))
self.assertTrue(json_returned, "validate")
# Check if key already used
response = self.app.post('api/users/get_if_keys_validate',
data=json.dumps(new_data),
content_type='application/json')
self.assertEqual(response.status_code, 400)
json_returned = json.loads(response.get_data(as_text=True))
self.assertTrue(json_returned, "already used")
def validation_keys():
""" get if user keys is validate for reset password """
data, error = validate_data(keys_validator_schema, request)
if error:
return custom_response(data, 400)
reset_pass = User.get_user_by_email(data.get('email')).reset_password_key
try:
if reset_pass_schema.dump(reset_pass[0])["keys"] == int(data["keys"]):
reset_pass[0].delete()
return custom_response("validate", 200)
return custom_response("Keys invalid", 400)
except IndexError:
return custom_response("already used", 400)
def reset_password_after_validate_keys():
""" Reset Password """
data, error = validate_data(user_password, request)
if error:
return custom_response(data, 400)
if not data.get('password'):
return custom_response("Password could not be null", 400)
user_in_db = User.get_user_by_email(data.get('email'))
if user_in_db:
user_in_db.update_password(data.get('password'))
password_updated('PasswordUpdated.html', email=data.get('email'), name=user_in_db.name)
return custom_response("password changed", 200)
return custom_response("Unauthorized", 400)
def update_profile(user_connected_model, user_connected_schema):
""" Update my profile """
data, error = validate_data(profile_schema, request, False)
if error:
return custom_response(data, 400)
if not data.get("email") or not data.get("name"):
return custom_response("email and name is required", 400)
if data['email'] != user_connected_model.email and User.get_user_by_email(
data['email']):
return custom_response("email exist", 400)
user_profile = user_connected_model.profile or Profiles.get_profile(
social_id=user_connected_model.social_id)
p_dumped = profile_schema.dump(user_profile)
data.update(p_dumped)
_u_model = user_connected_model
p_photo = request.files.get('photo')
if p_photo:
if p_dumped["photo"]:
destroy_image(p_dumped["photo"], CLOUD_IMAGES_PROFILES_TYPE,
_u_model.fileStorage_key, _u_model.id)
data['photo'] = upload_image(p_photo, CLOUD_IMAGES_PROFILES_TYPE,
_u_model.fileStorage_key, _u_model.id)
c_photo = request.files.get('cover_photo')
if c_photo:
if p_dumped["cover_photo"]:
destroy_image(p_dumped["cover_photo"], CLOUD_IMAGES_PROFILES_TYPE,
_u_model.fileStorage_key, _u_model.id)
data['cover_photo'] = upload_image(c_photo, CLOUD_IMAGES_PROFILES_TYPE,
_u_model.fileStorage_key,
_u_model.id)
user_connected_schema["name"], user_connected_schema["email"] = data[
'name'], data['email']
user_connected_model.update(user_connected_schema)
user_profile.update(data)
new_user_profile = user_connected_model.profile or Profiles.get_profile(
social_id=user_connected_model.social_id)
return custom_response(profile_schema.dump(new_user_profile), 200)
