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)