def charge(request): """ This method receive a front-end payment and create a charge. """ user = request.user if isinstance(user, AnonymousUser): logger.error(errors.USR_10.message) return errors.handle(errors.USR_10) data = request.data order_id = data.get('order_id', '') amount = data.get('amount', '') currency = data.get('currency', '') description = data.get('description', '') try: Orders.objects.get(pk=order_id) except Orders.DoesNotExist: return errors.handle(errors.ORD_01) response = payments.create(amount=amount, order_id=order_id, currency=currency, description=description) if response.status != 'succeeded': err_data = response.__dict__ return Response(data={ 'message': err_data['message'], 'status': err_data['status'] }, status=err_data['status']) response['message'] = 'Payment made successfully!' return Response(data=response, status=200)
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 put(self, request, item_id): try: cart_item = ShoppingCart.objects.get(item_id=item_id) quantity = request.data.get("quantity", None) if not quantity: return errors.handle(errors.COM_02) cart_item.quantity = request.data.get("quantity", None) cart_item.save() serializer_element = ShoppingcartSerializer(instance=cart_item) cart_id_field = {"cart_id": int(cart_item.cart_id)} new_dict = serializer_element.data new_dict.update(cart_id_field) return Response(new_dict, 201) except ShoppingCart.DoesNotExist: return errors.handle(errors.CRT_03)
def order(request, order_id): """ Get Info about Order """ user = request.user if isinstance(user, AnonymousUser): logger.error(errors.USR_10.message) return errors.handle(errors.USR_10) try: order = Orders.objects.get(pk=order_id) except Orders.DoesNotExist: return errors.handle(errors.ORD_01) serializer = OrdersSerializer() data = serializer.to_representation(order) return Response(data=data, status=status.HTTP_200_OK)
def get(self, request, attribute_id): try: queryset = AttributeValue.objects.filter(attribute_id=attribute_id) serializer = AttributeValueSerializer(queryset, many=True) return Response(serializer.data) except AttributeValue.DoesNotExist: return errors.handle(errors.ATR_02)
def get(self, request, attribute_id): try: attribute = Attribute.objects.get(attribute_id=attribute_id) serializer_element = AttributeSerializer(instance=attribute) return Response(serializer_element.data) except Attribute.DoesNotExist: return errors.handle(errors.ATR_01)
def delete(self, request, item_id): try: item = ShoppingCart.objects.get(item_id=item_id) item.delete() return Response({"message": "Item successfully removed from cart!"}) except ShoppingCart.DoesNotExist: return errors.handle(errors.CRT_03)
def delete(self, request, cart_id): cart = ShoppingCart.objects.filter(cart_id=cart_id) if not cart: return errors.handle(errors.CRT_01) for item in cart: item.delete() return Response([], 200)
def update_quantity(request, item_id): """ Update the cart by item """ logger.debug("Updating quantity") error = None quantity = request.data.get('quantity', '') error = errors.handle( errors.Error(code="COM_10", message="Quantity must be a number not less than 1", _status=400)) if not isinstance( quantity, int) or quantity < 1 else error invalid_qty = validate_field_required(request.data, 'quantity', 'COM_01') invalid_id = validate_cart_ids(item_id, 'item_id') error = invalid_qty if invalid_qty else error error = invalid_id if invalid_id else error if error: return error cart = ShoppingCart.objects.get(item_id=item_id) serializer_class = UpdateShoppingcartSerializer( cart, data=request.data, partial=True, ) serializer_class.is_valid(raise_exception=True) serializer_class.update(cart, request.data) import pdb pdb.set_trace() return Response(serializer_class.data, status=status.HTTP_200_OK)
def create_order(request): """ Create a Order """ user = request.user data = request.data if isinstance(user, AnonymousUser): logger.error(errors.USR_10.message) return errors.handle(errors.USR_10) error = validate_order_input(request.data) if error: return error data['customer_id'] = user.customer_id data['created_on'] = timezone.now() data['status'] = 0 total = 0 for item in ShoppingCart.objects.filter(cart_id=data['cart_id']).all(): product = Product.objects.get(product_id=item.product_id) total += product.price * item.quantity if \ float(product.discounted_price) == 0 else \ product.discounted_price * item.quantity data['total_amount'] = total serializer = OrdersSerializer(data=data) serializer.is_valid(raise_exception=True) return Response(data={'order_id': serializer.save().pk}, status=status.HTTP_201_CREATED)
def get(self, request, shipping_region_id): shipping = Shipping.objects.filter( shipping_region_id=shipping_region_id) if not shipping: return errors.handle(errors.SHP_02) serializer = ShippingSerializer(shipping, many=True) return Response(serializer.data)
def get(self, request, tax_id): try: tax = Tax.objects.get(tax_id=tax_id) serializer = TaxSerializer(instance=tax) return Response(serializer.data) except Tax.DoesNotExist: return errors.handle(errors.TAX_01)
def get(self, request, department_id): try: department = Department.objects.get(department_id=department_id) serializer_element = DepartmentSerializer(instance=department) return Response(serializer_element.data) except Department.DoesNotExist: return errors.handle(errors.DEP_02)
def get(self, request, category_id): try: category = Category.objects.get(category_id=category_id) serializer_element = CategorySerializer(instance=category) return Response(serializer_element.data) except Category.DoesNotExist: return errors.handle(errors.CAT_01)
def get(self, request, order_id): try: order = Orders.objects.get(order_id=order_id) cart_items = ShoppingCart.objects.filter(cart_id=order.reference) details_list = list() for item in cart_items: product = Product.objects.get(product_id=item.product_id) details_dict = { "order_id": order.order_id, "total_amount": str(order.total_amount), "created_on": order.created_on, "shipped_on": order.shipped_on if order.shipped_on is not None else "", "status": order.status, "name": product.name, } details_list.append(details_dict) return Response(details_list) except Orders.DoesNotExist: return errors.handle(errors.ORD_01)
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 create_customer(self, *args, **kwargs): email = kwargs.get("email", None) normalized_email = self.normalize_email(email) if not re.match(r"[^@]+@[^@]+\.[^@]+", normalized_email): errors.handle(errors.USR_03) try: customer = self.model.objects.get(email=normalized_email) if customer: errors.handle(errors.USR_04) except self.model.DoesNotExist: kwargs.pop("email", None) password = kwargs.pop("password", None) customer = self.model(email=normalized_email, **kwargs) if password is not None: customer.set_password(password) customer.save() return customer
def get(self, request, product_id): try: prod_category = ProductCategory.objects.get(product_id=product_id) category = Category.objects.get(category_id=prod_category.category_id) serializer_element = ProductCategorySerializer(instance=category) return Response(serializer_element.data) except ProductCategory.DoesNotExist: return errors.handle(errors.PRO_02)
def get(self, request, product_id): try: product = Product.objects.get(product_id=product_id) serializer_element = SingleProductSerializer(instance=product) data = self.truncate_description(request, serializer_element.data) return Response(data) except Product.DoesNotExist: return errors.handle(errors.PRO_01)
def get(self, request, department_id): _categories = Category.objects.filter(department_id=department_id) if not _categories: errors.handle(errors.DEP_02) _products_list = list() for category in _categories: prod_category = ProductCategory.objects.filter( category_id=category.category_id) for item in prod_category: product = Product.objects.get(product_id=item.product_id) _products_list.append(product) paginated_data = self.paginate_queryset(_products_list) products_list = list() for product in paginated_data: serializer_element = ProductSerializer(instance=product) products_list.append(serializer_element.data) return self.get_paginated_response(products_list)
def webhooks(request): """ Endpoint that provide a synchronization """ user = request.user if isinstance(user, AnonymousUser): logger.error(errors.USR_10.message) return errors.handle(errors.USR_10) response = payments.create_webhook() return Response(data=response, status=201)
def details(self, request, pk): """ Get details of a Product """ product = Product.objects.get(product_id=pk) if not product: return errors.handle(errors.PRO_01) return Response(self.serializer_class(product).data, status=status.HTTP_200_OK)
def get(self, request, product_id): try: product = Product.objects.get(product_id=product_id) review = Review.objects.get(product_id=product_id) serializer_element = ReviewSerializer(instance=review) holding_dict = serializer_element.data return_dict = {"name": product.name, **holding_dict} return Response(return_dict, 201) except Product.DoesNotExist: return errors.handle(errors.PRO_01)
def post(self, request): try: product_id = request.data.get("product_id", None) product = Product.objects.get(product_id=product_id) customer_id = request.user.customer_id review = Review() for field, value in request.data.items(): setattr(review, field, value) customer_review = Review.objects.filter(customer_id=customer_id, product_id=product_id) if customer_review: return errors.handle(errors.USR_11) review.customer_id = customer_id review.save() serializer_element = ReviewSerializer(instance=review) holding_dict = serializer_element.data return_dict = {"name": product.name, **holding_dict} return Response(return_dict, 201) except Product.DoesNotExist: return errors.handle(errors.PRO_01)
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 put(self, request): if "credit_card" in request.data: credit_card = request.data.get("credit_card") if not validate_credit_card(credit_card): return errors.handle(errors.USR_08) customer = request.user customer.credit_card = credit_card customer.save() last_digits = credit_card.split("-")[-1] serializer_element = CustomerSerializer(customer) credit_field = {"credit_card": "xxxxxxxxxxxx" + str(last_digits)} return_dict = dict() return_dict.update(serializer_element.data) return_dict.update(credit_field) return Response(return_dict) else: errors.COM_01.message = "The field credit_card is required" return errors.handle(errors.COM_01)
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 get_values_from_attribute(self, request, *args, **kwargs): """ Get Values Attribute from Attribute ID """ serializer_class = AttributeValueSerializer attribute_id = kwargs.get('attribute_id', '') if not Attribute.objects.filter(attribute_id=attribute_id): return errors.handle(errors.ATT_01) attribute_value = AttributeValue.objects.filter( attribute_id=attribute_id).all() data = serializer_class(attribute_value, many=True).data return Response(data, status=200)
def get(self, request): user = request.user if isinstance(user, AnonymousUser): logger.error(errors.USR_10.message) return errors.handle(errors.USR_10) try: customer = request.user except Customer.DoesNotExist: raise exceptions.APIException(detail='Customer does not exist', code=404) serializer = self.serializer_class(customer) return Response(serializer.data, status=status.HTTP_200_OK)
def reviews(self, request, pk): """Return a list of reviews Args: request (obj): request onject pk (int): product id Returns: list of the product's reviews """ serializer_class = ReviewSerializer if not Product.objects.filter(product_id=pk): return errors.handle(errors.PRO_01) return Response(serializer_class( Review.objects.filter(product_id=pk).all(), many=True).data, status=status.HTTP_200_OK)