def update_service(services_id, user_connected_model, user_connected_schema):
""" Update one service by artist """
_u_model = user_connected_model
service_to_update = _u_model.services.filter_by(id=services_id).first()
if service_to_update:
data, error = validate_data(service_schema, request, return_dict=False)
if error:
return custom_response(data, 400)
new_galleries = check_galleries_files(request, _u_model)
if len(new_galleries) != 0:
data['galleries'] = list(
set(data.get("galleries", []) + new_galleries))
if data['special_dates']:
data['special_dates'] = func.json_build_object(
*convert_dict_to_sql_json(data['special_dates']))
for link in service_to_update.galleries:
if link not in data['galleries']:
destroy_image(link, CLOUD_IMAGES_SERVICES_TYPE,
_u_model.fileStorage_key, _u_model.id)
service_to_update.update(data)
return custom_response(
return_services(service_schema.dump(service_to_update),
service_to_update), 200)
return custom_response("service not found", 200)
def update_material_by_service_id(service_id, user_connected_model,
user_connected_schema):
"""
Args:
service_id:
user_connected_model:
user_connected_schema:
Returns:
"""
data, error = validate_data(materials_schema, request, return_dict=False)
if error:
return custom_response(data, 400)
user_service_selected = user_connected_model.services.filter_by(
id=service_id).first()
if not user_service_selected:
return custom_response("service not found", 400)
user_material_to_update = user_service_selected.material
if user_material_to_update:
return custom_response(
update_material(user_connected_schema, user_material_to_update,
request, data), 200)
return custom_response("material not found", 404)
def search_services_enable_in_this_date():
""" search matching with text_ in table medias """
country_locate = request.headers.get('Country', None)
if not country_locate:
return custom_response('country may not be null in headers', 400)
data, error = validate_data(search_service_schema, request)
if error:
return custom_response(data, 400)
all_data = []
if not data.get("country"):
data["country"] = country_locate
options = [{"match": {"country": data["country"]}}]
if not data.get("city", None) and not data.get("thematics", None) and not data.get("event", None):
all_data = suggest_service_by_country(data["country"], True)
elif data.get("thematics"):
indexation_with_thematics(data, options, all_data)
else:
if data.get("city"):
all_data = indexed_filter(indexation_with_city(options, data.get("city"), data['event_date']), all_data)
if data.get("event"):
all_data = indexed_filter(indexation_with_event(options, data.get("event"), data['event_date']), all_data)
return custom_response(add_others_information_to_list_of_service(all_data), 200)
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 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 delete_beats(song_id, user_connected_model, user_connected_schema):
""" delete a beats """
user_ = user_connected_model
beat = user_.medias.filter_by(id=song_id).first()
if beat:
params = {'fileStorage_key': user_.fileStorage_key, 'user_id': user_.id}
beat_to_rm = media_schema.dump(beat)
if beat_to_rm['photo']:
destroy_image(beat_to_rm["photo"], CLOUD_IMAGES_BEATS_TYPE, **params)
if beat_to_rm["stems"]:
destroy_beats(beat_to_rm["stems"], **params, stems=True)
if beat_to_rm["mp3"]:
destroy_beats(beat_to_rm["mp3"], **params)
if beat_to_rm["wave"]:
destroy_beats(beat_to_rm["wave"], **params)
document_delete(
index="beats",
doc_type="songs",
first_={"id": song_id},
second_={"created_at": beat_to_rm['created_at']}
)
beat.delete()
return custom_response("deleted", 200)
return custom_response("beat not found or deleted", 400)
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 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 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 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 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 beats_secure(*args, **kwargs):
""" Get a beats type and other verification """
_u_schema = kwargs['user_connected_schema']
if _u_schema['user_type'] == USER_ARTIST_BEATMAKER or _u_schema['right'] != 0:
data, error = validate_data(media_schema, request, False)
if error:
return custom_response(data, 400)
if not (data.get("basic_price") and data.get("silver_price") and data.get("gold_price")):
return custom_response("i need basic, silver and gold price", 400)
if data["genre"] not in allowed_beat_maker_options:
return custom_response("genre not supported", 400)
extracted_file = extract_file(request)
msg = _specific(**extracted_file)
if isinstance(msg, str):
return custom_response(msg, 400)
kwargs.update(extracted_file)
kwargs.update({'data': data})
return func(**kwargs)
return custom_response("Unauthorized", 400)
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 delete_in_my_cart(cart_id, user_connected_model, user_connected_schema):
""" get all song in my cart """
cart = user_connected_model.carts.filter_by(id=cart_id).first()
if not cart:
return custom_response("cart not existing", 400)
cart.delete()
return custom_response("deleted", 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 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 delete_admiration_user(beat_do_not_admire_id, user_connected_model, user_connected_schema):
""" User delete admiration """
admire_info = user_connected_model.all_admires.filter_by(beat_id=beat_do_not_admire_id).first()
if not admire_info:
return custom_response("Not found", 400)
admire_info.delete()
return custom_response("deleted", 200)
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_user_password(user_connected_model, user_connected_schema):
data = request.get_json()
if not data.get("password"):
return custom_response("send me the password", 404)
if not user_connected_model.check_hash(data.get("password")):
return custom_response("not matched", 400)
return custom_response("matched", 200)
def all_artist_types(lang):
""" get all artist types """
if lang and lang not in allowed_lang:
return custom_response("Lang not allowed", 400)
data_of_artist_type = dict(artist_types=type_of_isl_artist,
events=allowed_events)
return custom_response(data_of_artist_type, 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 check_message_id(message_id):
"""
A user create a new message to support
"""
model_message = SupportMessages.get_message_by_id(message_id)
if not model_message:
return custom_response("id not found", 200)
schema_message = support_message.dump(model_message)
return custom_response(schema_message, 200)
def create_user_banking_details(user_connected_model, user_connected_schema):
""" create new banking details """
data, error = validate_data(banking_schema, request)
if error:
return custom_response(data, 400)
data['user_id'] = user_connected_model.id
new_user_banking_details = BankingDetails(data)
new_user_banking_details.save()
return custom_response(banking_schema.dump(new_user_banking_details), 200)
def delete_an_partner(partner_id, user_connected_model, user_connected_schema):
""" delete a partner """
partner = Partner.partner_by_id(partner_id)
if user_connected_model.right == 2 and partner:
_u_model = user_connected_model
destroy_image(partner.logo, CLOUD_IMAGES_PARTNERS_TYPE,
_u_model.fileStorage_key, _u_model.id)
partner.delete()
return custom_response("deleted", 200)
return custom_response("Unauthorized", 400)
def create_new_message():
"""
A user create a new message to support
"""
data, error = validate_data(support_message, request)
if error:
return custom_response(data, 400)
SupportMessages(data).save()
return custom_response("added", 200)
def delete_one_option(option_id, user_connected_model, user_connected_schema):
""" delete one options """
option_selected = user_connected_model.options.filter_by(
id=option_id).first()
if option_selected:
delete_material_technical_sheet(option_selected.material,
user_connected_model)
option_selected.delete()
return custom_response("deleted", 200)
return custom_response("option not found", 404)
def decode_token(token):
""" Decode token method """
my_response = {'data': {}, 'error': {}}
try:
payload = jwt.decode(token, os.getenv('JWT_SECRET_KEY'))
my_response['data'] = {'user_id': payload['sub']}
return my_response
except jwt.ExpiredSignatureError:
return custom_response("token expired, login please", 400)
except jwt.InvalidTokenError:
return custom_response("Invalid token", 400)
def add_new_admiration_user(beat_to_admire_id, user_connected_model, user_connected_schema):
""" User add new admiration """
if not Media.get_song_by_id(beat_to_admire_id):
return custom_response("Beat not found", 400)
admire_info = user_connected_model.all_admires.filter_by(beat_id=beat_to_admire_id).first()
if admire_info:
return custom_response("exist", 400)
Admiration(dict(user_id=user_connected_model.id, beat_id=beat_to_admire_id)).save()
return custom_response("Added", 200)
def delete_user_banking_details(user_connected_model, user_connected_schema):
""" delete banking details """
data, error = validate_data(banking_schema, request)
if error:
return custom_response(data, 400)
user_banking = user_connected_model.banking
if not user_banking:
return custom_response("banking details not found, create one", 404)
user_banking[0].delete()
return custom_response("updated", 200)
def update_contract_silver(user_connected_model, user_connected_schema):
""" Update user silver lease """
data, error = validate_data(contract_schema, request)
if error:
return custom_response(data, 400)
user_silver_lease = user_connected_model.ContractBeat.filter_by(
contract_name="silver_lease").first()
if user_silver_lease:
user_silver_lease.update(data)
return custom_response("Silver lease updated", 200)
return custom_response("contract not found", 400)
