def signup_many(request): if request.method == 'POST': profiles = request.data.get('profiles', None) for profile in profiles: username = profile.get('username', None) password = profile.get('password', None) age = profile.get('age', None) occupation = profile.get('occupation', None) gender = profile.get('gender', None) create_profile(username=username, password=password, age=age, occupation=occupation, gender=gender) return Response(status=status.HTTP_201_CREATED) if request.method == 'GET': movieid = request.GET.get('movieid', None) userid = request.GET.get('userid', None) if movieid: profiles = Profile.objects.raw('select api_profile.id, api_profile.user_id,api_profile.gender,api_profile.age,api_profile.occupation,api_rating.rating from api_movie,api_rating,api_profile where api_movie.id = api_rating.movieid_id and api_rating.userid_id = api_profile.user_id and api_movie.id = '+movieid) serializer = ProfileSerializer(profiles, many=True) elif userid: movies = Movie.objects.raw('select api_movie.id, api_movie.title,api_movie.genres, api_rating.rating as rating from api_profile,api_rating,api_movie where api_profile.user_id = api_rating.userid_id and api_movie.id = api_rating.movieid_id and api_profile.user_id = '+userid+' group by api_movie.id') serializer = UserMovieSerializer(movies, many=True) else: profiles = Profile.objects.all() serializer = ProfileSerializer(profiles, many=True) return Response(data=serializer.data, status=status.HTTP_200_OK)
def post(self, request): serializer = ProfileSerializer try: user1 = Profile.objects.get(user=request.user) useremail = bleach.clean(request.data.get('email')) user2 = Profile.objects.get(EmailAddress=useremail) #Can only add a friend if they are not already part of your friends list and not a part of theirs. success = 'fail' if user1 not in user2.Friends.all(): user2.Friends.add(user1) success = 'success' if user2 not in user1.Friends.all(): user1.Friends.add(user2) success = 'success' user1.save() user2.save() serializer = ProfileSerializer(user2) print('success', success) return Response({'profile': serializer.data, 'success': success}) except Exception as e: print('exception: ', e) #error case serializer = ProfileSerializer(user1) return Response({'profile': serializer.data, 'success': 'fail'})
def fetch_profile(request, pk): profile = Profile.objects.filter(uuid=pk) if not profile.exists(): return Response({'error': 'Profile doesn\'t exist.'}, status=status.HTTP_200_OK) if request.method == 'GET': serializer = ProfileSerializer(profile.first(), many=False, context={'request': request}) return Response({'profile': serializer.data}, status=status.HTTP_200_OK) elif request.method == 'PATCH': serializer = ProfileSerializer(profile.first(), data=request.data, partial=True, context={'request': request}) try: serializer.is_valid(raise_exception=True) except: return Response({'error': str(serializer.errors)}, status=status.HTTP_400_BAD_REQUEST) serializer.save() return Response({'profile': serializer.data}, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs): """ profile情報を表示する endpoint: /api/profiles/ name: - """ """テスト項目 済 keyを使ってこのエンドポイントにアクセスするとProfileデータを受け取る 済 test_Tokenオブジェクトに存在しないkeyを使った場合rauthentication_failedの値が返る """ # print(self.request.META) # print(self.request.META['HTTP_AUTHORIZATION']) # HTTPリクエストヘッダーのトークン情報からユーザーを特定する # token = self.request.META['HTTP_AUTHORIZATION'].split(" ")[1] token = getTokenFromHeader(self) # print(token) # Userオブジェクトの取得 # user_obj = Token.objects.get(key=token).user user_obj = getUserByToken(token) if user_obj is None: return Response({"result": "fail"}) profile_obj = Profile.objects.get(user=user_obj) # print(profile_obj) print(Response(ProfileSerializer(profile_obj).data)) return Response(ProfileSerializer(profile_obj).data)
def put(self, request, pk=None): profile = self.get_object(pk) serializer = ProfileSerializer(instance=profile, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors)
def put(self, request, format=None): access_key_check(request) token = Token.objects.get( token=request.META.get('HTTP_AUTHORIZATION')[6:]) profile = Profile.objects.filter(token=token) if 'first_name' in request.data: new_first_name = request.data['first_name'] profile.update(first_name=new_first_name) if 'last_name' in request.data: new_last_name = request.data['last_name'] profile.update(last_name=new_last_name) if 'email' in request.data: new_email = request.data['email'] profile.update(email=new_email) if 'photo' in request.data: new_photo = request.data['photo'] if new_photo: profile.update(photo=upload_photo(new_photo, profile.last().phone)) profile = Profile.objects.get(token=token) serializer = ProfileSerializer(profile) return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, format=None): access_key_check(request) token = Token.objects.get( token=request.META.get('HTTP_AUTHORIZATION')[6:]) profile = Profile.objects.get(token=token) serializer = ProfileSerializer(profile) return Response(serializer.data, status=status.HTTP_200_OK)
def put(self, request): profile = Profile.objects.get(user=self.request.user) serializer = ProfileSerializer(instance=profile, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors)
def getUsers(request): if request.method == 'GET': age = request.GET.get('age', None) gender = request.GET.get('gender', None) occupation = request.GET.get('occupation', None) page = request.GET.get('page', 1) profiles = Profile.objects.all() if age: profiles = profiles.filter(age=age) if gender: profiles = profiles.filter(gender=gender) if occupation: profiles = profiles.filter(occupation=occupation) if page: page = int(page) if page <= len(profiles) // 50 + 1: start = 50 * (page - 1) end = start + 50 if len(profiles[start:]) < 50: profiles = profiles[start:] profiles = profiles[start:end] serializer = ProfileSerializer(profiles, many=True) return JsonResponse({ 'result': serializer.data, 'status': status.HTTP_200_OK }) return JsonResponse({ 'status': status.HTTP_400_BAD_REQUEST, 'msg': 'Invalid Request Method' })
def patch(self, request, provider_id=None, identity_id=None): """ Authentication Required, Update the users profile. Returns: 203 - Success, no body. 400 - Bad key/value on update, errors in body. """ user = request.user profile = user.get_profile() mutable_data = request.DATA.copy() if mutable_data.has_key('selected_identity'): user_data = { 'selected_identity': mutable_data.pop('selected_identity') } serializer = AtmoUserSerializer(user, data=user_data, partial=True) if serializer.is_valid(): serializer.save() serializer = ProfileSerializer(profile, data=mutable_data, partial=True) if serializer.is_valid(): serializer.save() response = Response(serializer.data) return response else: return Response(serializer.errors)
def fetch_payment(request, pk): payment = Payment.objects.filter(uuid=pk) if not payment.exists(): return Response({'error': 'Payment doesn\'t exist.'}, status=status.HTTP_200_OK) stripe.api_key = settings.STRIPE_KEY payment = payment.first() pi = stripe.PaymentIntent.retrieve(payment.stripe_id, ) serializer = ProfileSerializer(payment.entertainer, many=False, context={'request': request}) if pi.status == 'succeeded': return Response( { 'success': True, 'entertainer': serializer.data, 'value': pi.amount_received / 100 }, status=status.HTTP_200_OK) else: return Response( { 'error': 'Payment was never completed', 'entertainer': serializer.data, 'code': 1 }, status=status.HTTP_200_OK)
def patch(self, request, provider_id=None, identity_id=None): """ Update a users profile If VALID save the profile else raise ValidationError """ user = request.user profile = user.get_profile() mutable_data = request.DATA.copy() if mutable_data.has_key('selected_identity'): user_data = { 'selected_identity': mutable_data.pop('selected_identity') } serializer = AtmoUserSerializer(user, data=user_data, partial=True) if serializer.is_valid(): serializer.save() serializer = ProfileSerializer(profile, data=mutable_data, partial=True) if serializer.is_valid(): serializer.save() response = Response(serializer.data) return response else: return Response(serializer.errors)
def profiles(request): if request.method == 'GET': user = request.GET.get('user', request.GET.get('user', None)) title = request.GET.get('title', None) profiles = Profile.objects.all() serializer = ProfileSerializer(profiles, many=True) return Response(data=serializer.data, status=status.HTTP_200_OK) if request.method == 'DELETE': Profile.objects.all() profile.delete() return Response(status=status.HTTP_200_OK) if request.method == 'POST': profiles = request.data.get('profiles', None) for profile in profiles: user = profile.get('user', None) gender = profile.get('gender', None) age = profile.get('age', None) occupation = profile.get('occupation', None) if not (user and gender and age): continue Profile(user=user, gender=gender, age=age, occupation=occupation).save() return Response(status=status.HTTP_200_OK)
class WithdrawRequestSerializer(serializers.HyperlinkedModelSerializer): profile = ProfileSerializer() class Meta: model = WithdrawRequest fields = ('id', 'profile', 'amount', 'request_date', 'status', 'reviewed_time')
def post(self, request): try: username = bleach.clean(request.data.get('username')) password = bleach.clean(request.data.get('password')) firstname = bleach.clean(request.data.get('firstname')) lastname = bleach.clean(request.data.get('lastname')) email = bleach.clean(request.data.get('email')) location = bleach.clean(request.data.get('location')) #GetCoordinates returns the coordinates based on the users input location - provided by gooogle api coordinates = getCoordinates(location) user = User.objects.create_user(username=username, password=password) user.save() profile = Profile(user=user, FirstName=firstname, LastName=lastname, EmailAddress=email, Location=location, coordinates=coordinates) profile.save() serializer = ProfileSerializer(profile) return Response({ 'user': serializer.data, "token": AuthToken.objects.create(user) }) except: return HttpResponseBadRequest()
def getsimilar(request): if request.method == 'GET': movieid = request.GET.get('movieid', None) userid = request.GET.get('userid', None) if movieid: num = MovieCluster.objects.values('clusternum').get( movieid=movieid) moviecluster = MovieCluster.objects.filter( clusternum=num['clusternum']) movienum = [] for use in moviecluster: movienum.append(use.movieid.id) rand = random.sample(movienum, 10) movies = Movie.objects.filter(pk__in=rand).annotate( view_cnt=Count('rating')).annotate( average_rating=Avg('rating__rating')) serializer = MovieSerializer(movies, many=True) elif userid: num = UserCluster.objects.values('clusternum').get( userid_id=userid) usercluster = UserCluster.objects.values('userid_id').filter( clusternum=num['clusternum']) users = Profile.objects.filter(user_id__in=usercluster) serializer = ProfileSerializer(users, many=True) return Response(data=serializer.data, status=status.HTTP_200_OK)
def get_update_user_profile(request, pk): try: user = User.objects.get(pk=pk) profile = user.profile except Profile.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': serializer = ProfileSerializer(profile) return Response(serializer.data, status=status.HTTP_200_OK) elif request.method == 'PUT': serializer = ProfileSerializer(instance=profile, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors)
def post(self, request): """ User Class: Create a new user in the database Returns success 200 OK - NO BODY on creation """ params = request.DATA user = request.user if user.username is not 'admin' or not user.is_superuser: return Response('Only admin and superusers can create accounts', status=status.HTTP_401_UNAUTHORIZED) username = params['username'] #STEP1 Create the account on the provider provider = Provider.objects.get(location='EUCALYPTUS') driver = AccountDriver(provider) user = driver.add_user(username) #STEP2 Retrieve the identity from the provider if user: user_keys = driver.get_key(username) driver.create_key(user_keys) #STEP3 Return the new users serialized profile serialized_data = ProfileSerializer(user.get_profile()).data response = Response(serialized_data) return response
def login(request): if request.method == 'POST': request_data = request.data.get('params', None) if request_data: try: username = request_data.get('username', None) password = request_data.get('password', None) user = User.objects.get(username=username) except User.DoesNotExist: err = "아이디 또는 비밀번호가 틀렸습니다." return Response(data=err, status=status.HTTP_401_UNAUTHORIZED) if not check_password(password, user.password): err = "아이디 또는 비밀번호가 틀렸습니다." return Response(data=err, status=status.HTTP_401_UNAUTHORIZED) else: request.session['user'] = user.username profile = Profile.objects.get(user=user) serializer = ProfileSerializer(profile) return Response(data=serializer.data, status=status.HTTP_200_OK)
def put(self, request, username, format=None): profile = self.get_object(username) serializer = ProfileSerializer(profile, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def profileSearch(request): if request.method == 'GET': username = request.GET.get('username') user = get_object_or_404(User, username=username) profile = get_object_or_404(Profile, id=user.id) serializer = ProfileSerializer(profile) return Response(data=serializer.data, status=status.HTTP_200_OK)
class VendedorSerializer(serializers.ModelSerializer): profile = ProfileSerializer() class Meta: # Especificar el model con el que se va a trabajar model = Vendedor # Especificar los atributos que se desea serializar fields = ('__all__')
def account(request): try: profile = Profile.objects.get(username=request.user.username) serializer = ProfileSerializer(profile) return Response(serializer.data) except Profile.DoesNotExist as e: return Response({'message': str(e)}, status=400)
def register(request): serializer = UserSerializer(data=request.data) serializer_profile = ProfileSerializer(data=request.data.get("profile")) if serializer.is_valid() and serializer_profile.is_valid(): serializer.save() serializer_profile.save() return Response(serializer_profile.data) return Response(serializer.errors)
def save(self, profile, data=None): profile = ProfileSerializer(profile, data=data) if profile.is_valid(): profile.save() response, status = profile.data, STATUS_200 else: response, status = profile.errors, STATUS_400 return response, status
def delete_avatar(self, request, pk=None): userext = UserExt.objects.filter(user=request.user.id).get() userext.avatar = None userext.avatar_mini = None userext.save() serializer = ProfileSerializer(instance=userext, context={'request': request}) return Response({})
def profile(request, user_id): if request.method == 'GET': profile = get_object_or_404(Profile, id=user_id) # profile = Profile.objects.get(id=user_id) serializer = ProfileSerializer(profile) return Response(data=serializer.data, status=status.HTTP_200_OK) if request.method == 'PATCH': profile = get_object_or_404(Profile, pk=user_id) # serializer = ProfileSerializer(profile) serializer = ProfileSerializer(profile, data=request.data, partial=True) if serializer.is_valid(): profile = serializer.save() return Response(ProfileSerializer(profile).data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def ranking(self, request): profiles = None # filtering on existing property if 'time' in request.query_params: time = request.query_params['time'] if time == 'lastTfh': profiles = sorted(Profile.objects.all(), key=lambda m: m.last_tfh_points, reverse=True) elif time == 'currentMonth': profiles = sorted(Profile.objects.all(), key=lambda m: m.current_month_points, reverse=True) else: return Response( { 'error': '{0} is not a acceptable time parameter'.format(time) }, status=status.HTTP_406_NOT_ACCEPTABLE) # filtering on parameter elif 'month' in request.query_params: month = int(request.query_params['month']) if 1 < month > 12: return Response( { 'error': 'Month should be in range 1-12 (included)'.format( month) }, status=status.HTTP_406_NOT_ACCEPTABLE) profiles = sorted(Profile.objects.all(), key=lambda m: m.month_points(month), reverse=True) # no filtering else: profiles = Profile.objects.all().order_by('-global_points') # Returned set limitation if 'limit' in request.query_params: profiles = profiles[:int(request.query_params['limit'])] # serialization serializer = ProfileSerializer(profiles, many=True) if 'userId' in request.query_params: for index, profile in enumerate(profiles): if profile.id == int(request.query_params['userId']): return Response( { 'ranking': serializer.data, 'specified_user_rank': index + 1 }, status=status.HTTP_200_OK) return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, pk): try: user = self.user_repository.get_user_by_id(pk) except UserRepositoryError: response, status = None, STATUS_400 else: profile = ProfileSerializer(user.profile) response, status = profile.data, STATUS_200 return response, status
def get_user_info(request): print(request.GET.get("userId")) user_id = request.GET.get("userId") print("django", user_id) user = get_object_or_404(User, pk=user_id) user_info = Profile.objects.get(user=user) serializer = ProfileSerializer(user_info, many=False) return Response(data=serializer.data, status=status.HTTP_201_CREATED)