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