def retrieve(self, request, pk=None):
"""
detail cartItem for other user
:param request:
:param pk:
:return:
"""
try:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
# this is for select is_pay = False object, that means thay that dont payment
cart_obj = obj.get(is_pay=False)
cart_items = cacheCartItem(request,
f'cartItem-{cart_obj.user.email}',
CartItem, cart_obj)
# this is for select CartItem object that is in user cart that is_pay = False
queryset = cart_items.get(pk=pk)
serializer = CartItemDetailSerializers(
queryset, context={'request': request})
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def destroy(self, request, pk=None):
try:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
cart = obj.filter(is_pay=False, user=request.user, pk=pk).first()
cart.delete()
return response.SuccessResponse(message='Delete object').send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def update(self, request, pk=None):
try:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
cart = obj.get(is_pay=False, user=request.user, pk=pk)
serializer = CartInputSerializers(cart, data=request.data)
if serializer.is_valid():
serializer.save(user=request.user)
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def destroy(self, request, pk=None):
try:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
# this is for select is_pay = False object, that means thay that dont payment
cart = obj.get(is_pay=False)
cart_items = cacheCartItem(request, f'cartItem-{cart.user.email}',
CartItem, cart)
# this is for select CartItem objects that are in user cart that is_pay = False
queryset = cart_items.get(pk=pk)
queryset.delete()
return response.SuccessResponse(message='Delete object').send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def retrieve(self, request, pk=None):
"""
detail cart
:param request:
:param pk:
:return:
"""
try:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
cart = obj.get(is_pay=False, user=request.user, pk=pk)
serializer = CartDetailSerializers(cart,
context={'request': request})
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def list(self, request):
"""
other user can show list carts that is_pay=False
show user just one cart that is_pay = False
Indeed, user cant create more than one cart
:param request:
:return:
"""
try:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
queryset = obj.filter(is_pay=False)
serializer = CartListSerializers(queryset,
context={'request': request},
many=True)
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def create(self, request):
"""
when create owner user is request.user and is_pay=False
create CartItem object for your cart that is_pay = False
:param request:
:return:
"""
try:
serializer = CartItemInputSerializers(data=request.data)
# get user cart for add created object to your cart
obj_cart = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
cart = obj_cart.get(is_pay=False)
if serializer.is_valid():
serializer.save(cart=cart)
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def retrieve(self, request, pk=None):
"""
just for user that is_pay=True
and superuser can show all carts that is_pay=True
:param request:
:param pk:
:return: detail carts that is_pay=True
"""
try:
if request.user.is_superuser:
cart_obj = Cart.objects.get(pk=pk, is_pay=True)
else:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
cart_obj = obj.get(is_pay=True, pk=pk)
serializer = FactorDetailSerializers(cart_obj)
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def list(self, request):
"""
just for user
and superuser can show all carts that is_pay=True
:param request:
:return: list carts that is_pay=True
"""
try:
if request.user.is_superuser:
cart_obj = Cart.objects.filter(is_pay=True)
else:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
cart_obj = obj.filter(is_pay=True)
serializer = FactorListSerializers(cart_obj,
context={'request': request},
many=True)
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def update(self, request, pk=None):
"""
user cant change cart in update
:param request:
:param pk:
:return:
"""
try:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
cart = obj.get(is_pay=False)
cart_items = cacheCartItem(request, f'cartItem-{cart.user.email}',
CartItem, cart)
queryset = cart_items.get(pk=pk)
serializer = CartItemInputSerializers(queryset, data=request.data)
if serializer.is_valid():
serializer.save(cart=cart)
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def create(self, request):
"""
when create object user=request.user and is_pay=False
:param request:
:return:
"""
try:
cart = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
len_cart = cart.filter(is_pay=False).count()
serializer = CartInputSerializers(data=request.data)
if serializer.is_valid():
if len_cart == 0:
serializer.save(is_pay=False, user=request.user)
return response.SuccessResponse(serializer.data).send()
else:
return response.ErrorResponse(
message='cart object is_pay == False exist.',
status=403).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def list(self, request):
"""
other user can just see self cartItems object
show user CartItem list for your cart
:param request:
:return:
"""
try:
obj = cacheCart(request, f'cart-{request.user.email}', Cart,
request.user)
# this is for select is_pay = False object, that means thay that dont payment
cart_obj = obj.filter(is_pay=False).first()
# this is for select CartItem objects that are in user cart that is_pay = False
query = cacheCartItem(request, f'cartItem-{cart_obj.user.email}',
CartItem, cart_obj)
serializer = CartItemListSerializers(query,
context={'request': request},
many=True)
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
