def put(self, request, pk, format=None): customer = self.get_object(pk) serializer = CustomerSerializer(customer, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, customer_id): customer = self.get_object(customer_id) serializer = CustomerSerializer(instance=customer, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response({'error': serializer.errors})
def put(self, request, pk): customer = self.get_object(pk) serializer = CustomerSerializer(instance=customer, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def test_successful_request(self): serializer = CustomerSerializer(data=self.data) self.assertTrue(serializer.is_valid()) token = Token.objects.create(key="test token", user=self.user) self.client.credentials(HTTP_AUTHORIZATION="Token " + token.key) response = self.client.post(self.url, self.data, format="json") self.assertEqual(response.status_code, status.HTTP_200_OK)
def post(self, request, version='v1', format='json'): serialized = CustomerSerializer(data=request.data) errors = None if serialized.is_valid(): serialized.save() return self.get(request) else: errors = serialized.errors return Response(errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = CustomerSerializer(data=request.data) if serializer.is_valid(): customer = serializer.validated_data update_customer_if_is_partner.delay(customer['email']) return Response(status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update_credit_card(request): """ Update the credit card from customer """ logger.debug("Updating credit card") if 'credit_card' in request.data: if not validate_credit_card(request.data.get('credit_card')): logger.error(errors.USR_08.message) return errors.handle(errors.USR_08) try: customer = request.user.customer customer.credit_card = request.data.get('credit_card', None) customer.save() serializer_element = CustomerSerializer(customer) logger.debug("Success") return Response(serializer_element.data) except AttributeError: logger.error(errors.USR_10.message) return errors.handle(errors.USR_10) except Exception as error: errors.COM_02.message = str(error) logger.error(errors.COM_02.message) return errors.handle(errors.COM_02) else: errors.COM_02.field = 'credit_card' logger.error(errors.COM_02.message) return errors.handle(errors.COM_02)
def post(self, request): logger.debug("Login a customer") """Authenticate user through the access_token""" serializer = SocialSerializer(data=request.data) serializer.is_valid(raise_exception=True) access_token = serializer.data.get("access_token") user = FacebookValidation().validate_access_token(access_token) username = user.get("name", None) email = user.get("email", None) try: customer = Customer.objects.get(name=username) except Customer.DoesNotExist: customer = Customer.objects.create_customer(name=username, email=email) refresh = RefreshToken.for_user(customer) serializer_element = CustomerSerializer(customer) response = Response( { "customer": { "schema": serializer_element.data }, "accessToken": "Bearer " + str(refresh.access_token), "expires_in": "24h", }, 200, ) logger.debug("Success") return response
def get_customer(self, order): customer = Customer.objects.filter(id=order.customer_id).first() if customer: serial_customer = CustomerSerializer(customer) return serial_customer.data else: return None
def login(request): serializer = CustomerAuthSerializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.validated_data.get('customer') serializer = CustomerSerializer(user) token, created = Token.objects.get_or_create(user=user) return Response({'token': token.key, 'user': serializer.data})
def list(self, request): fields = ('name', 'email', 'url') customers = Customer.objects.all() serializer = CustomerSerializer(customers, many=True, context={'request': request}, fields=fields) return Response(serializer.data)
def customer_list_by_age(request, age): customers = Customer.objects.filter(age=age) # GET all customers by age if request.method == 'GET': customers_serializer = CustomerSerializer(customers, many=True) return JsonResponse(customers_serializer.data, safe=False)
def customer_details(request, pk): try: customer = Customer.objects.get(pk=pk) except Customer.DoesNotExist: return HttpResponse(status=status.HTTP_404_NOT_FOUND) # GET customer details if request.method == 'GET': customer_serializer = CustomerSerializer(customer) return JsonResponse(customer_serializer.data) # PUT existing customer elif request.method == 'PUT': customer_data = JSONParser().parse(request) customer_serializer = CustomerSerializer(customer, data=customer_data) if customer_serializer.is_valid(): customer_serializer.save() return JsonResponse(customer_serializer.data) return JsonResponse(customer_serializer.errors, status=status.HTTP_400_BAD_REQUEST) # DELETE existing customer elif request.method == 'DELETE': customer.delete() return HttpResponse(status=status.HTTP_204_NO_CONTENT)
def update(self, request, *args, **kwargs): customer_id = self.kwargs['pk'] user = self.request.user first_name = self.request.data['first_name'] last_name = self.request.data['last_name'] email = self.request.data['email'] company = self.request.data['company'] phone = self.request.data['phone'] address = self.request.data['address'] apartment = self.request.data['apartment'] city = self.request.data['city'] country = self.request.data['country'] region = self.request.data['region'] postal_code = self.request.data['postal_code'] image = self.request.data['image'] customer = Customer.objects.filter(pk=customer_id).first() if first_name: customer.first_name = first_name if last_name: customer.last_name = last_name if email: customer.email = email if company: customer.company = company if phone: customer.phone = phone if address: customer.address = address if apartment: customer.apartment = apartment if city: customer.city = city if country: customer.country = country if region: customer.region = region if postal_code: customer.postal_code = postal_code if image: customer.image = image customer.save() customer_serializer = CustomerSerializer(customer) sio.emit('create_change_customer', { 'data': { 'state': 'updated', 'customer': customer_serializer.data, 'user': { 'email': user.email, 'id': user.id } } }, namespace='/test') return Response(customer_serializer.data)
def retrieve(self, request, pk, format=None): fields = ('name', 'email', 'favorites') customer = self.get_object(pk) serializer = CustomerSerializer(customer, context={'request': request}, fields=fields) data_response = self.get_data_response(serializer_data=serializer.data) return Response(data_response)
def put(self, request): customer = request.user for field, value in request.data.items(): setattr(customer, field, value) customer.save() serializer_element = CustomerSerializer(instance=customer) return Response(serializer_element.data, status.HTTP_200_OK)
def create(self, request): product_id = request.data.get('product_id') if product_id: product_id_status = utils.check_product_id( request.data.get('product_id')) # using false to make it explicit if product_id_status is False: return Response({"product_id": "This product does not exist."}, status.HTTP_400_BAD_REQUEST) fields = ('name', 'email', 'url') serializer = CustomerSerializer(data=request.data, context={'request': request}, fields=fields) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def customers_without_orders(request): try: customers = Customer.objects.exclude( order__created_at__gt=datetime.datetime(2016, 1, 1)) except DatabaseError as ex: raise ex serializer = CustomerSerializer(customers, many=True) return Response(data={"data": serializer.data})
def new(self, request): try: q = request.query_params q_d = {k: v[0] if len(v) == 1 else v for k, v in q.lists()} customer = Customer(**q_d) customer.save() return Response(data=CustomerSerializer(customer).data) except: print(traceback.format_exc()) return Response(data={"is": "false"})
def get(self, request): """ Get a customer by ID. The customer is getting by token """ customer_id = decode_token_from_request(request) if isinstance(request.user, AnonymousUser): logger.error(errors.USR_10.message) return errors.handle(errors.USR_10) customer = Customer.objects.get(customer_id=customer_id) serializer_element = CustomerSerializer(customer) return Response(serializer_element.data)
def customer(request): """ Get a customer by ID. The customer is getting by token """ logger.debug("Getting customer") user = request.user if isinstance(user, AnonymousUser): logger.error(errors.USR_10.message) return errors.handle(errors.USR_10) serializer_element = CustomerSerializer(user.customer) logger.debug("Success") return Response(serializer_element.data)
def partial_update(self, request, pk, format=None): favorites = request.data.get('favorites') product_id_statuses = [ utils.check_product_id(product_status.get("product_id")) for product_status in favorites ] if not any(product_id_statuses): return Response({"product_id": "This product does not exist."}, status.HTTP_400_BAD_REQUEST) fields = ('name', 'email', 'favorites') customer = self.get_object(pk) serializer = CustomerSerializer(customer, data=request.data, context={'request': request}, fields=fields) if serializer.is_valid(): serializer.save() data_response = self.get_data_response( serializer_data=serializer.data) return Response(data_response) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): form_data = request.data.dict() user = None if 'type' not in form_data: return Response(data=json.dumps( {'error': 'Login type not specified'}), status=status.HTTP_400_BAD_REQUEST) elif form_data.get('type') not in ['admin', 'biller', 'customer']: return Response(data=json.dumps( {'error': 'Login type inappropriate'}), status=status.HTTP_400_BAD_REQUEST) try: user = Mywallet.objects.filter( (Q(user__email=form_data.get('email', '')) | Q(user__username=form_data.get('username', '')) | Q(contact_number=form_data.get('contact_number', ''))), user__is_active=True, user__is_staff=True if form_data.get('type') is 'admin' else False, ).first() except Exception as e: Response(data=json.dumps({'error': 'DB error'}), status=status.HTTP_404_NOT_FOUND) if user is None: user = User.objects.create_user( form_data.get('username', ''), email=form_data.get('email', ''), password=form_data.get('password', ''), **{ 'first_name': form_data.get('first-name', ''), 'last_name': form_data.get('last-name', ''), }) if form_data.get('type') == 'biller': user.is_active = False user.save() mywallet_user = Mywallet.objects.create( user=user, contact_number=form_data.get('contact_number')) if form_data.get('type') == 'admin': serializer = MywalletSerializer(mywallet_user) elif form_data.get('type') == 'biller': serializer = BillerSerializer( Biller.objects.create(biller=mywallet_user)) elif form_data.get('type') == 'customer': serializer = CustomerSerializer( Customer.objects.create(customer=mywallet_user)) return Response(serializer.data) Response(data=json.dumps( {'error': 'Username / EmailID already in use'}), status=status.HTTP_400_BAD_REQUEST)
def get(self, request): cache_key = 'AllCustomerReport' # needs to be unique data = cache.get(cache_key) # returns None if no key-value pair # print('---->', settings.CACHE_DURATION) # print('---->',data) print('---->',cache.key_prefix) if not data: cust = Customer.objects.all() # cache_time = settings.CACHE_DURATION data = CustomerSerializer(cust, many=True).data cache.set(cache_key, data, settings.CACHE_DURATION) return Response(data)
def put(self, request): customer = request.user shipping_id = request.data.get("shipping_region_id", None) if shipping_id is None: errors.COM_01.message = "The field shipping_region_id is required" return errors.handle(errors.COM_01) if not isinstance(shipping_id, int): return errors.handle(errors.USR_09) for field, value in request.data.items(): setattr(customer, field, value) customer.save() serializer_element = CustomerSerializer(instance=customer) return Response(serializer_element.data, status.HTTP_200_OK)
def get(self, request, user_id=None): customer = None try: if user_id is None: customer = self.get_object() else: customer = self.get_object(user_id) if customer is not None: serializer = CustomerSerializer( customer, many=True if isinstance(customer, QuerySet) else False) return Response(serializer.data) return Response(status=status.HTTP_400_BAD_REQUEST) except Exception as e: return Response(data=json.dumps({'error': 'Unauthorized'}), status=status.HTTP_404_UNAUTHORIZED)
def post(self, request): customer_details = { "name": request.data.get("name", None), "email": request.data.get("email", None), "password": request.data.get("password", None), } customer_instance = Customer.objects.create_customer( **customer_details) serializer = CustomerSerializer(instance=customer_instance) return Response( { "customer": serializer.data, "accessToken": "", "expiresIn": "" }, status=201, )
def get_queryset(self): customer_id = self.kwargs['pk'] user = self.request.user queryset = Customer.objects.filter(pk=customer_id) customer = Customer.objects.filter(pk=customer_id).first() customer_serializer = CustomerSerializer(customer) sio.emit('create_change_customer', { 'data': { 'state': 'deleted', 'customer': customer_serializer.data, 'user': { 'email': user.email, 'id': user.id } } }, namespace='/test') return queryset
def customer_list(request): """ List all code snippets, or create a new customer. """ if request.method == 'GET': customers = Customer.objects.all() serializer = CustomerSerializer(customers, many=True) return JsonResponse(serializer.data, safe=False) elif request.method == 'POST': data = JSONParser().parse(request) serializer = CustomerSerializer(data=data) if serializer.is_valid(): serializer.save() return JsonResponse(serializer.data, status=201) return JsonResponse(serializer.errors, status=400)
def customers(request): try: customers = Customer.objects.all() except Customer.DoesNotExist as e: return Response({'error': str(e)}) if request.method == 'GET': serializer = CustomerSerializer(customers, many=True) return Response(serializer.data) elif request.method == 'PUT': serializer = CustomerSerializer(instance=customers, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response({'error': serializer.errors})