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 update_note_by_service_id_or_user_id(user_connected_model, user_connected_schema):
"""
@return:
"""
data, error = validate_data(user_stars_schema, request)
if error:
return custom_response(data, 400)
if data.get('service_id'):
stars_to_add_note = Stars.get_stars_by_service_id(data.get('service_id'))
if not stars_to_add_note:
custom_response("Service rate not found", 400)
stars_ = user_stars_schema.dump(stars_to_add_note)
update_note(stars_to_add_note, stars_, data, user_connected_model)
return custom_response("success", 200)
if data.get('user_id'):
artist_to_note = User.get_one_user(data['user_id'])
user_who_set_note = User.get_one_user(auth.user.get('id'))
if not artist_to_note.user_type == user_who_set_note.user_type == USER_AUDITOR_PRO:
stars_to_add_note = Stars.get_stars_by_user_id(data.get('user_id'))
if not stars_to_add_note:
custom_response("Service rate not found", 400)
stars_ = user_stars_schema.dump(stars_to_add_note)
update_note(stars_to_add_note, stars_, data, user_connected_model)
return custom_response("success", 200)
return custom_response("Unauthorized", 400)
return custom_response("I need user_id or service_id", 400)
def facebook_authorized():
"""Authorize facebook login."""
data = request.get_json()
session['facebook_token'] = {"Type": data['token_type'], "access_token": data['accessToken']}
graph = f.GraphAPI(data['accessToken'])
profile = graph.get_object('me', **{'fields': 'id, name, email, picture'})
data.clear()
data = dict(
photo=profile['picture']['data']['url'],
name=profile['name'],
social_id=profile['id'],
social="facebook",
password=None,
email=profile.get('email'),
fileStorage_key=random_string(10),
)
user_in_db = User.get_user_by_social_id(profile['id'])
if user_in_db:
token = Auth.generate_token(user_social.dump(user_in_db)["id"])
return token_return(token, data.get('name'), data.get('email'))
if data['email']:
login_success('LoginSuccess.html', email=data.get('email'), name=data.get('name'))
create_profile(data)
profile_info = profile_schema.dump(Profiles.get_profile(data.get('social_id')))
data['fileStorage_key'], data['profile_id'] = random_string(10), profile_info.get('id')
user = User(data)
user.save()
create_all_default_contract(user.id)
return token_return(Auth.generate_token(user_schema.dump(user)['id']), data.get('name'), data.get('email'))
def send_prestige_email(user_connected_model,
user_connected_schema,
prestige,
beat_id=None,
service_id=None):
"""
Args:
prestige:
beat_id:
service_id:
user_connected_model:
user_connected_schema:
"""
if prestige not in list(PRESTIGE_ALLOWED_TYPE):
return custom_response("prestige type not found", 400)
prestige = PRESTIGE_ALLOWED_TYPE[prestige]
mail_data = dict(template="prestige.html")
if beat_id:
beat = Media.get_song_by_id(beat_id)
if not beat:
return custom_response("beat not found", 400)
recipient = User.get_one_user(beat.user_id)
mail_data.update(dict(beat_title=beat.title))
else:
service = Services.get_by_service_id(service_id)
if not service:
return custom_response("service not found", 400)
recipient = User.get_one_user(service.user_id)
mail_data.update(dict(service_title=service.title))
if user_connected_model.email == recipient.email:
return custom_response('Unauthorized', 400)
data = prestige_data(
sender_id=user_connected_model.id,
recipient_id=recipient.id,
service_id=service_id,
prestige=prestige,
beat_id=beat_id,
)
mail_data.update(
dict(reference=data['key_share'],
sender_name=user_connected_model.name,
sender_email=user_connected_model.email,
recipient_email=recipient.email,
prestige=prestige))
Prestige(data).save()
send_prestige(**mail_data)
return custom_response("success", 200)
def decorated_auth(*args, **kwargs):
""" auth required decoration """
try:
socket.create_connection(
(socket.gethostbyname("www.google.com"), 80), 2)
except OSError:
return custom_response("Connection error", 404)
if RevokedTokenModel.is_jti_blacklisted(
request.headers.get('Isl-Token')):
return custom_response('You Are logout, reconnect you please',
400)
if 'Isl_Token' not in request.headers:
return custom_response(
'Authentication token is not available, please login to get one',
400)
token = request.headers.get('Isl-Token')
data = Auth.decode_token(token)
try:
if data.status_code == 400:
return custom_response('token invalid', 400)
except AttributeError:
user_id = data['data']['user_id']
check_user = User.get_one_user(user_id)
if not check_user:
return custom_response('token invalid', 400)
auth.user = {'id': user_id}
kwargs['user_connected_model'] = check_user
kwargs['user_connected_schema'] = UserSchema().dump(check_user)
return func(*args, **kwargs)
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_artist_condition_global(user_id):
user = User.get_one_user(user_id)
if user and user.condition_globals:
return custom_response(
condition_globals_schema.dump(user.condition_globals[0]), 200)
return custom_response("user or user condition global not found", 400)
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 create_a_new_reservation(user_connected_model, user_connected_schema):
""" """
data, error = validate_data(reservation_schema, request)
if error:
return custom_response(data, 400)
payment_reference = random_string(20)
stripe.api_key = "sk_test_SnQS9gn3p2TRP7lrkjkpM5LN007eNS7Izg"
artist_amount, total_tva, isl_amount = check_price_details(ht_price=data["total_amount"])
total_amount = float(isl_amount + total_tva + artist_amount)
payment_history_obj = {
"paid": False,
"tva": total_tva,
"name": data["name"],
"email": data["email"],
"city": data["city"],
"postal_code": data["postal_code"],
"phone": data["phone"],
'address': data["address"],
'type': KANTOBIZ,
'buyer_id': user_connected_model.id,
'artist_id': data["artist_owner_id"],
'reference': payment_reference,
'isl_amount': isl_amount,
'artist_amount': artist_amount,
'ip_address': None,
'total_amount': total_amount
}
payment_history_to_save = PaymentHistory(payment_history_obj)
payment_history_to_save.save()
artist = User.get_one_user(data["artist_owner_id"])
data["artist_email"] = artist.email
# payment = payment_stripe(total_amount, data['stripe_token']['id'], "Purchase Service KantoBiz")
if data["email"] != user_connected_schema["email"]:
data["auditor_email"] = user_connected_schema["email"]
# if payment.paid:
new_reservation = Reservations({
"event": data["event"],
"status": PENDING,
"address": data["address"],
"total_amount": total_amount,
"event_date": data["event_date"],
"services_id": data["services_id"],
"artist_owner_id": data["artist_owner_id"],
"options_id_list": data["options_id_list"],
"payment_history_id": payment_history_to_save.id,
"auditor_who_reserve_id": user_connected_model.id,
"refund_policy": artist.condition_globals[0].refund_policy
})
new_reservation.save()
payment_success_send_email({"user_data": data}, payment_reference, total_amount, total_tva)
return custom_response(reservation_basic_schema.dump(new_reservation), 200)
def show_profile(user_connected_model, user_connected_schema):
""" Get my Profile """
profile = user_connected_model.profile or Profiles.get_profile(
social_id=user_connected_model.social_id)
user_condition_globals, reservation_booking_list, reservation_list, notes = {}, [], [], 0.00
if user_connected_model.user_type != USER_AUDITOR_PRO:
user_condition_globals = condition_globals_schema.dump(
user_connected_model.condition_globals[0])
user_reservation_list = user_connected_model.reservation_list.all()
if user_reservation_list:
reservation_list = [
check_reservation_info_with_service_info(
reservation_basic_schema, Services, User, r)
for r in user_reservation_list
]
else:
notes = mean(
User.get_one_user(user_connected_model.id).stars[0].note or [0])
user_booking_list = user_connected_model.booking_list.all()
if user_booking_list:
reservation_booking_list = [
check_reservation_info_with_service_info(reservation_basic_schema,
Services, User, r)
for r in user_booking_list
]
user_banking = user_connected_model.banking
if user_banking:
user_banking = banking_schema.dump(user_banking[0])
return custom_response(
{
"notes":
notes,
"role":
user_connected_model.user_type,
"my_followings":
user_connected_model.all_admires.count(),
"my_followers":
user_connected_model.my_admirers.count(),
"my_profile":
profile_schema.dump(profile),
"conditions":
user_condition_globals,
"banking":
user_banking or {},
"reservations_list":
reservation_list,
"reservations_booking_list":
reservation_booking_list,
"payment_history":
check_all_user_payment_history(user_connected_model,
payment_history_schema, User,
Reservations),
}, 200)
def auditor_decline_reservation(reservation_id, user_connected_model, user_connected_schema):
"""
Args:
reservation_id:
user_connected_model:
user_connected_schema:
Returns:
"""
user_reservation = user_connected_model.booking_list.filter_by(id=reservation_id).first()
if user_reservation:
reservation_s = reservation_basic_schema.dump(user_reservation)
if reservation_s["status"] == DECLINED:
return custom_response("already declined", 400)
if reservation_s["status"] == ACCEPTED:
service_s = service_schema.dump(user_reservation.service)
artist = User.get_one_user(service_s["user_id"])
payment_history_0bj = payment_history_schema.dump(user_reservation.payment_history)
reference = payment_history_0bj["reference"]
data = {
"service": service_s,
"refunded": 0.00,
"date": month + " " + day + ", " + year,
"auditor": user_connected_schema,
"reservation": reservation_s,
"artist_name": artist.name,
"artist_email": artist.email,
"invoicing_address": payment_history_0bj
}
# do not forget refund
reservation_s["invoice"] = canceled_by_auditor_after_accept(
"CanceledByAuditorAfterAccept.html", data=data, reference=reference,
user_type="customer", email=payment_history_0bj["email"], user_connected=user_connected_schema)
canceled_by_auditor_after_accept(
"CanceledByAuditorAfterAccept.html", data=data, reference=reference,
user_type="artist", email=artist.email)
reservation_s["status"] = DECLINED
payment_history_0bj["refund"] = True
user_reservation.payment_history.update(payment_history_0bj)
user_reservation.update(reservation_s)
return custom_response_after_update(user_connected_model, user_reservation)
reservation_s["status"] = DECLINED
user_reservation.update(reservation_s)
return custom_response_after_update(user_connected_model, user_reservation)
return custom_response("reservation not found", 404)
def artist_decline_reservation(reservation_id, user_connected_model, user_connected_schema):
"""
Args:
reservation_id:
user_connected_model:
user_connected_schema:
Returns:
"""
user_reservation = user_connected_model.reservation_list.filter_by(id=reservation_id).first()
if user_reservation:
reservation_s = reservation_basic_schema.dump(user_reservation)
if reservation_s["status"] == DECLINED:
return custom_response("already declined", 400)
if reservation_s["status"] == ACCEPTED:
# refund
service_s = service_schema.dump(user_reservation.service)
payment_history_0bj = payment_history_schema.dump(user_reservation.payment_history)
reference = payment_history_0bj["reference"]
data = {
"service": service_s,
"date": month + " " + day + ", " + year,
"auditor": user_schema.dump(User.get_one_user(reservation_s["auditor_who_reserve_id"])),
"reservation": reservation_s,
"artist_name": user_connected_model.name,
"artist_email": user_connected_model.email,
"invoicing_address": payment_history_0bj
}
invoice = canceled_reservation_by_artist(
"PaymentRefundByArtistRefused.html", data=data, reference=reference,
user_type="customer", email=payment_history_0bj["email"], user_connected=user_connected_schema)
canceled_reservation_by_artist(
"PaymentRefundByArtistRefused.html", data=data, reference=reference,
user_type="artist", email=user_connected_model.email)
reservation_s["status"] = DECLINED
reservation_s["invoice"] = invoice
user_reservation.update(reservation_s)
payment_history_0bj["refund"] = True
user_reservation.payment_history.update(payment_history_0bj)
return custom_response_after_update(user_connected_model, user_reservation)
reservation_s["status"] = DECLINED
user_reservation.update(reservation_s)
return custom_response(
check_reservation_info_with_service_info(reservation_basic_schema, Services, User, user_reservation, True
), 200)
return custom_response("reservation not found", 404)
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 search_user_service_by_id(service_id):
service_checked = Services.get_by_service_id(service_id)
if not service_checked:
return custom_response("service not found", 400)
service_checked = service_schema.dump(service_checked)
material_id = service_checked["materials_id"]
service_checked["materials"] = material_schema.dump(
Materials.get_by_materials_id(material_id))
service_checked["artist_name"] = User.get_one_user(
service_checked["user_id"]).name
service_checked["notes"] = check_service_stars(service_checked["id"])
_options = User.get_one_user(service_checked["user_id"]).options.all()
service_checked["options"] = []
for option in _options:
if service_checked["id"] in option.services_id_list:
service_checked["options"].append(option_schema.dump(option))
return custom_response({"service": service_checked}, 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 all_user_admiration(user_id):
""" get all user admiration """
user = User.get_one_user(user_id)
if not user:
return custom_response("user do not exist", 400)
all_users = {"all_admire": [], "my_admirers": []}
all_admiration = user.all_admires.all()
all_admirers = user.my_admirers.all()
for admire in all_admiration:
u_pr = profile_schema.dump(User.get_one_user(admire.admire_id).profile)
all_users['all_admire'].append(
check_dict_keys(u_pr, _keys=profile_keys_to_remove, inverse=True))
for admire in all_admirers:
u_pr = profile_schema.dump(User.get_one_user(admire.admire_id).profile)
all_users['my_admirers'].append(
check_dict_keys(u_pr, _keys=profile_keys_to_remove, inverse=True))
return custom_response(all_users, 200)
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 all_beats_admiration(user_id):
""" get all beats user admiration """
user = User.get_one_user(user_id)
if not user:
return custom_response("user do not exist", 400)
all_beats = []
all_admiration = user.all_admires.filter_by(admire_id=None).all()
for admire in all_admiration:
_beat = media_schema.dump(admire.beat)
all_beats.append(_beat)
return custom_response(all_beats, 200)
def all_new_beat_maker_in_the_six_last_month(listed=False):
""" new beatMaker in the six last month with one or plus beats shared """
all_beat_makers = []
_beat_maker = User.all_beat_maker_in_three_last_month()
for _user in _beat_maker:
beat_maker_profile = profile_schema.dump(_user.profile)
all_beat_makers.append(
check_dict_keys(beat_maker_profile,
_keys=profile_keys_to_remove,
inverse=True))
if listed:
return all_beat_makers
return custom_response({"new_beatMaker": all_beat_makers}, 200)
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)
def add_others_information_to_list_of_service(all_indexed_data):
new_list_of_all_indexed_data = []
for service in all_indexed_data:
material = es.search(
index="materials",
body={
"query": {
"bool": {
"must": [{
"match": {
"id": service["materials_id"]
}
}]
}
}}
)
option = es.search(
index="options",
body={
"query": {
"bool": {
"must": [{
"match": {
"user_id": service["user_id"]
}
}],
"filter": {
"query_string": {
"fields": ["services_id_list"],
"query": service["id"]
}
}}
}
}
)
service["materials"] = material['hits']['hits'][0]["_source"]
service["artist_name"] = User.get_one_user(service["user_id"]).name
service["notes"] = check_service_stars(service["id"])
service["options"] = [d["_source"] for d in option['hits']['hits']]
new_list_of_all_indexed_data.append(service)
return sorted(new_list_of_all_indexed_data, key=itemgetter('price'))
def add_new_admiration_user(artist_to_admire_id, user_connected_model,
user_connected_schema):
""" User add new admiration """
if not User.get_one_user(artist_to_admire_id):
return custom_response("User not found", 400)
if artist_to_admire_id is not user_connected_model.id:
admire_info = user_connected_model.all_admires.filter_by(
admire_id=artist_to_admire_id).first()
if admire_info:
return custom_response("exist", 400)
Admiration(
dict(user_id=user_connected_model.id,
admire_id=artist_to_admire_id)).save()
return custom_response("Added", 200)
return custom_response("Unauthorized", 400)
def validator():
""" check if user data is in request """
data = request.get_json()
if not data.get("stripe_token"):
return custom_response("no token stripe", 400)
if not data.get("MyCarts"):
return custom_response("send me the carts with key 'MyCarts'", 400)
if not data.get("user_data"):
return custom_response(
"send me the user information with key 'user_data'", 400)
if not data["user_data"].get("name"):
return custom_response("i need name in user information", 400)
if not data["user_data"].get("email"):
return custom_response("i need email in user information", 400)
if not data["user_data"].get("address"):
return custom_response("i need address in user information", 400)
if not data["user_data"].get("city"):
return custom_response("i need city in user information", 400)
if not data["user_data"].get("postal_code"):
return custom_response("i need postal_code in user information",
400)
if data['user_data'].get('phone'):
data['user_data']['phone'] = int(data['user_data'].get('phone'))
else:
data['user_data']['phone'] = None
token = request.headers.get('Isl-Token')
if token:
data_ = Auth.decode_token(token)
try:
if data_.status_code == 400:
data["user_data"]["user_id"] = None
except AttributeError:
user_id = data_['data']['user_id']
check_user = User.get_one_user(user_id)
if not check_user:
data["user_data"]["user_id"] = None
return func(data)
def get_top_beat_maker(listed=False):
""" get top beatmakers """
top_beats = get_top_beats(listed=True)
top_beat_maker = []
for beat in top_beats:
user = User.get_one_user(beat['user_id'])
beat_maker_profile = profile_schema.dump(user.profile)
beat_maker_profile = check_dict_keys(beat_maker_profile,
_keys=profile_keys_to_remove,
inverse=True)
beat_maker_profile['number_of_beats'] = user.medias.count()
if beat_maker_profile not in top_beat_maker:
top_beat_maker.append(beat_maker_profile)
if listed:
return top_beat_maker
return custom_response({"top_beatmaker": top_beat_maker}, 200)
def search_beats_and_artist(string_to_search):
""" search matching with text_ in table medias """
beats_and_artist = es.search(
index="beats",
doc_type="songs",
body={
"from": 0,
"size": 10,
"query": {
"query_string": {
"fields":
["title", "artist", "genre", "artist_tag", "description"],
"query":
"*" + string_to_search + "*"
}
},
# "sort": [{"listened": {"order": "asc", "mode": "min"}}]
})
data = {'beats': [], 'artists': []}
for r in beats_and_artist['hits']['hits']:
data['beats'].append(r['_source'])
artist_profile = profile_schema.dump(
User.get_one_user(r['_source']['user_id']).profile)
keys_to_remove = [
'address', 'age', 'city', 'region', 'social_id', 'photo', 'email',
'cover_photo', 'photo'
]
artist_profile = check_dict_keys(artist_profile,
_keys=keys_to_remove,
inverse=True)
if artist_profile not in data['artists']:
data['artists'].append(artist_profile)
return custom_response(data, 200)
def get_user_data_by_token(self, token):
data = Auth.decode_token(token)
self.assertEqual(type(data), dict)
with self._app.app_context():
user = User.get_one_user(data['data']["user_id"])
return user
