def update(self, request, slug=None):
"""
superuser can change all objects
but other user if is_seller=True and be seller object just can change owner object
if other user update object status=False,choice='d' for dont show site
:param request:
:param slug:
:return:
"""
try:
obj = productCacheDatabase(request, 'products', Product)
product = obj.filter(slug=slug)
serializer = ProductDetailSerializer(product, data=request.data)
if serializer.is_valid(raise_exception=True):
if request.user.is_superuser:
serializer.save()
else:
serializer.save(choice='d',
status=False,
seller=request.user)
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):
"""
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 create(self, request):
try:
serializer = TicketCreateSerializer(data=request.data)
if serializer.is_valid():
serializer.save(status='de', 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 retrieve(self, request, pk=None):
try:
obj = cacheCategoryOrFigur(request, 'figure', FigureField)
queryset = obj.get(pk=pk)
serializer = FigureFieldDetailSerializer(queryset)
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def create(request):
try:
serializer = CategoryInputSerializer(data=request.data)
if serializer.is_valid() and request.user.is_superuser:
serializer.save()
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):
try:
serializer = FigureFieldDetailSerializer(data=request.data)
if serializer.is_valid() and request.user.is_superuser:
serializer.save()
return response.SuccessResponse(serializer.data).send()
except CustomException as e:
print("===============")
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def list(self, request):
try:
obj = cacheCategoryOrFigur(request, 'figure', FigureField)
serializer = FigureFieldSerializer(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 list(self, request):
try:
answer = QuestionAndAnswer.objects.filter(user=request.user)
serializer = AnswerListSerializer(answer,
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 list(self, request):
try:
obj = User.objects.all()
serializer = UserListSerializers(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 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 = cacheCategoryOrFigur(request, 'figure', FigureField)
figure = obj.get(pk=pk)
serializer = FigureFieldDetailSerializer(figure, data=request.data)
if serializer.is_valid() and request.user.is_superuser:
serializer.save()
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, username=None):
try:
obj = User.objects.all()
queryset = obj.filter(username=username)
serializer = UserDetailSerializers(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 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):
"""
just super user can delete it
:param request:
:param pk:
:return: delete object with pk=pk and is_pay=True
"""
try:
Cart.objects.get(pk=pk, is_pay=True).delete()
return response.SuccessResponse(message='Deleted object').send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def retrieve(self, request, pk=None):
try:
if request.user.is_superuser:
queryset = Ticket.objects.filter(pk=pk)
else:
queryset = Ticket.objects.filter(pk=pk, user=request.user)
serializer = TicketDetailSerializer(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 list(self, request):
try:
if request.user.is_superuser:
ticket = Ticket.objects.all()
else:
ticket = Ticket.objects.filter(user=request.user)
serializer = TicketListSerializer(ticket,
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 destroy(self, request, pk=None):
"""
superuser can delete notices object
:param request:
:param pk:
:return:
"""
try:
notice = Notice.objects.get(pk=pk)
notice.delete()
return response.SuccessResponse(message='Deleted object').send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def create(self, request):
"""
create notice object by all user
when superuser has not approved (status == False) ==> dont send email for user
:param request:
:return:
"""
try:
serializer = NoticeCreateSerializer(data=request.data)
if serializer.is_valid():
serializer.save(status=False)
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):
"""
show list all notices object for superuser
:param request:
:return:
"""
try:
notice = Notice.objects.all()
serializer = NoticeListSerializer(notice,
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):
try:
serializer = AnswerCreateSerializer(data=request.data)
tick_pk = request.data['question']
ticket = Ticket.objects.get(pk=tick_pk)
if serializer.is_valid():
if ticket.status != 'cl':
serializer.save(user=request.user)
return response.SuccessResponse(serializer.data).send()
else:
return response.ErrorResponse(message='ticket is closed',
status=403).send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def destroy(self, request, pk=None):
"""
delete figure field
:param request:
:param pk:
:return:
"""
try:
obj = cacheCategoryOrFigur(request, 'figure', FigureField)
figure = obj.get(pk=pk)
figure.delete()
return response.SuccessResponse(message='Deleted object').send()
except CustomException as e:
return response.ErrorResponse(message=e.detail,
status=e.status_code).send()
def update(self, request, pk=None):
"""
superuser can update all object notices
:param request:
:param pk:
:return:
"""
try:
notice = Notice.objects.get(pk=pk)
serializer = NoticeDetailSerializer(notice, data=request.data)
if serializer.is_valid():
serializer.save()
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):
"""
detail object for superuser
:param request:
:param pk:
:return:
"""
try:
queryset = Notice.objects.filter(pk=pk)
serializer = NoticeDetailSerializer(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 update(self, request, pk=None):
"""
just superuser can update list carts that is_pay=True
:param request:
:param pk:
:return: update object with pk=pk
"""
try:
cart = Cart.objects.get(pk=pk, is_pay=True)
serializer = CartDetailSerializers(cart, data=request.data)
if serializer.is_valid():
serializer.save()
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, slug=None):
"""
superuser can delete all objects
but other user if is_seller=True and be seller object just can delete owner object
:param request:
:param slug:
:return:
"""
try:
obj = productCacheDatabase(request, 'products', Product)
product = obj.filter(slug=slug)
product.delete()
return response.SuccessResponse(message='Delete object').send()
except CustomException as e:
return response.ErrorResponse(message='Instance does not exist.',
status=404).send()
def create(self, request):
"""
create object and put choice='d',status=False,seller=request.user
and superuser must ok object ====> status=True,choice='p' for shows site
:param request:
:return:
"""
try:
serializer = InputProductSerializers(data=request.data)
if serializer.is_valid(raise_exception=True):
# when superuser has approved it, dont show to user ==> choice = 'd' and status = False
serializer.save(choice='d', status=False, seller=request.user)
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):
"""
list all category for all user
:param request:
:return:
"""
try:
obj = cacheCategoryOrFigur(request, 'category', Category)
category = obj.filter(status=True)
serializer = CategoryListSerializer(category,
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 destroy(self, request, slug=None):
"""
delete object
:param request:
:param slug:
:return:
"""
try:
obj = cacheCategoryOrFigur(request, 'category', Category)
category = obj.filter(slug=slug).first()
print(category)
category.delete()
return response.SuccessResponse(message='Delete object').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()
