def post(self, request): """ Add location to customer locations :param request: :return: """ user = request.user try: customer = Customer.objects.get(user=user) except: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) data = request.data serializer = self.serializer_class( data={ "long": data['long'], "lat": data['lat'], "address": data['address'], "customerID": customer.customer_id }) if not serializer.is_valid(): return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) location = serializer.create(serializer.validated_data) return Response(status=status.HTTP_200_OK)
def post(self, request): user = request.user try: barber = Barber.objects.filter(user=user).first() except: return Response(get_error_obj('access_denied'), status=status.HTTP_404_NOT_FOUND) if not barber.is_verified: return Response(get_error_obj('access_denied'), status=status.HTTP_401_UNAUTHORIZED) action = 1 if 'action' in request.data: action = request.data['action'] try: service_id = request.data['service_id'] except: return Response(get_error_obj('wrong_parameters', 'no service id was sent'), status=status.HTTP_400_BAD_REQUEST) if action == 1: return self.create_or_update(request, service_id, barber) elif action == 2: return self.delete(service_id, barber) else: return Response(get_error_obj('wrong_parameters', 'this action is not in action list'), status=status.HTTP_400_BAD_REQUEST)
def post(self, request, action): if action not in self.ACTIONS: return Response(get_error_obj('wrong_parameters', 'this action is not in action list'), status=status.HTTP_400_BAD_REQUEST) try: project_id = request.data['reserved_service_id'] except: return Response(get_error_obj('wrong_parameters', 'no reserved service id sent'), status=status.HTTP_400_BAD_REQUEST) user = request.user i_barber = Barber.objects.filter(user=user).first() project = self.queryset.filter(project_id=project_id).first() if not project: return Response(get_error_obj( 'no_data_found', 'no reserved service found for this id'), status=status.HTTP_400_BAD_REQUEST) if project.barber.barber_id != i_barber.barber_id: return Response(get_error_obj( 'access_denied', 'you are not the owner of this reserved service'), status=status.HTTP_401_UNAUTHORIZED) res = 0 if action == self.ACTIONS[0]: res = self.verify(project) elif action == self.ACTIONS[1]: res = self.reject(project) else: res = self.end(project) project.save() if res != 0: return Response(get_error_obj('not_allowed_action'), status=status.HTTP_400_BAD_REQUEST) return Response({"status": 200})
def score(request): point_limit = 10 user = request.user if user is None: return Response("user not found ", status=status.HTTP_400_BAD_REQUEST) customer = Customer.objects.filter(user=user).first() if customer is None: return Response(status=status.HTTP_404_NOT_FOUND) if customer.isCompleted is False: return Response(get_error_obj('access_denied'), status=status.HTTP_405_METHOD_NOT_ALLOWED) try: barber_id = request.data['barber_id'] point = request.data['point'] except: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) if point > point_limit: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) if point < 0: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) barber = Barber.objects.filter(barber_id=barber_id).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) barber_point = barber.point point_counter = barber.point_counter barber_point = (float)(point + barber_point * point_counter) / (point_counter + 1) barber.point_counter = point_counter + 1 barber.point = barber_point barber.save() return Response({"status": 200}, status=status.HTTP_200_OK)
def customer_likes(request): limit = 10 user = request.user offset = request.GET.get('offset') if not offset: offset = 0 offset = limit * int(offset) if user is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) customer = Customer.objects.filter(user=user).first() if customer is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) if customer.isCompleted is False: return Response(get_error_obj('access_denied'), status=status.HTTP_401_UNAUTHORIZED) queryset = customer.like.all() size = queryset.count() if offset > size: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) elif offset + limit < size: barbers = queryset[offset: offset + limit] else: barbers = queryset[offset:] serializer = BarberSerializer_out(barbers, many=True) return Response(serializer.data, status=status.HTTP_200_OK)
def customer_profile(request): user = request.user if user is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) customer = Customer.objects.filter(user=request.user).first() if customer is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) if customer.isCompleted is False: return Response(get_error_obj('access_denied'), status=status.HTTP_405_METHOD_NOT_ALLOWED) serializer = CustomerSerializer_out(customer) return Response(serializer.data)
def logout(request): try: user = request.user if user is AnonymousUser: return Response(get_error_obj('access_denied'), status.HTTP_404_NOT_FOUND) user.auth_token.delete() return Response({"status": 200}, status=status.HTTP_200_OK) except: return Response(get_error_obj('server_error'), status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_profile(request): user = request.user if user is AnonymousUser or None: return Response(get_error_obj('access_denied'), status=status.HTTP_400_BAD_REQUEST) barber = Barber.objects.filter(user=user).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) serializer = BarberSerializer_out(barber) # serializer = bar_BarberSerializer(barber) return Response(serializer.data)
def get_locations(request): try: user = request.user customer = Customer.objects.filter(user=user).first() if not customer: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) locations = LocationSerializer(customer.location.all(), many=True) return Response(locations.data) except: return Response(get_error_obj('server_error'), status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def barber_comment(request, barber_id): limit = 5 offset = request.GET.get('offset') if not offset: offset = 0 offset = limit * int(offset) if offset < 0: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) user = request.user if user is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) customer = Customer.objects.filter(user=user).first() if customer is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) if customer.isCompleted is False: return Response(get_error_obj('access_denied'), status=status.HTTP_405_METHOD_NOT_ALLOWED) if barber_id is None: Response(get_error_obj('wrong_parameters'), status.HTTP_400_BAD_REQUEST) # barber id does not send barber = Barber.objects.filter(barber_id=barber_id).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) # barber not exists:status 400 try: queryset = Comment.objects.filter(barber=barber).order_by('created_time') except: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) size = queryset.count() if offset > size: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) elif offset + limit < size: comment = queryset[offset: offset + limit] else: comment = queryset[offset:] serializer = CommentSerializer(comment, many=True) return Response(serializer.data, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs): try: if any(d not in request.data for d in ['phone', 'code', 'name', 'gender']): return Response(get_error_obj( 'wrong_parameters', 'name, gender, phone & code must be sent in body'), status=status.HTTP_400_BAD_REQUEST) phone = request.data['phone'] code = request.data['code'] name = request.data['name'] gender = request.data['gender'] login_user = LoginUser.objects.filter(phone=phone).first() if login_user is None: return Response( get_error_obj('auth_no_code_found'), status=status.HTTP_400_BAD_REQUEST ) # or we can redirect to a get with a phone number maincode = login_user.code if maincode == code: user = User.objects.filter(username=phone).first() if not user: user = User.objects.create(username=phone, password='******') id = Customer.objects.count() + 1 customer = Customer(user=user, phone=phone, customer_id='customer_{}'.format(id)) customer.gender = gender customer.name = name customer.save() else: customer = Customer.objects.filter(user=user).first() customer.gender = gender customer.name = name customer.save() token, create = Token.objects.get_or_create(user=user) serializer = CustomerSerializer_out(customer) data = serializer.data # data['name'] = customer.name data['phone'] = customer.phone # data['id'] = customer.customer_id data['token'] = token.key return Response(data) else: return Response(get_error_obj('auth_wrong_code'), status=status.HTTP_400_BAD_REQUEST) except: return Response(get_error_obj('auth_failure'), status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def change_profile(request): user = request.user if user is AnonymousUser or None: return Response(get_error_obj('access_denied'), status=status.HTTP_400_BAD_REQUEST) barber = Barber.objects.filter(user=user).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) serializer = BarberSerializer(data=request.data) if not serializer.is_valid(): return Response(get_error_obj('access_denied'), status=status.HTTP_400_BAD_REQUEST) temp = serializer.update(barber, serializer.validated_data) if temp is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) return Response({'status': 200}, status=status.HTTP_200_OK)
def get(self, request): stat = PresentedService.STATUS length = len(stat) # offset = [0 for i in range(length)] queryset = [[] for i in range(length)] serializer = [[] for i in range(length)] final = {} # final = json.dumps(final) try: user = request.user if user is AnonymousUser or None: return Response(get_error_obj('access_denied'), status=status.HTTP_400_BAD_REQUEST) barber = Barber.objects.filter(user=user).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) if barber.is_verified is False: return Response(get_error_obj('access_denied'), status=status.HTTP_405_METHOD_NOT_ALLOWED) for i in range(length): queryset[i] = PresentedService.objects.filter(status=stat[i][0]) # for i in range(length): # offset[i] = request.GET.get('offset{}'.format(i + 1)) # # for i in range(length): # queryset[i] = self.manage_set(offset[i], queryset[i]) if queryset[i] is None: queryset[i] = [] # return Response({"status": 804}, status=status.HTTP_400_BAD_REQUEST) for i in range(length): serializer[i] = PresentedServiceSerializer_home(queryset[i], many=True) cnt = 0 # extrat_data = {'barber': barber.barberName, 'name': barber.firstName + ' ' + barber.lastName} for i in serializer: final[stat[cnt][1]] = i.data # temp = {} # temp[stat[cnt][1]] = i.data # json = JSONRenderer().render(temp) # stream = io.BytesIO(json) # data = JSONParser().parse(stream) # final.append(data) cnt += 1 except Exception as error: return Response(get_error_obj('server_error'), status=status.HTTP_400_BAD_REQUEST) return Response(final)
def get_home_page(request): user = request.user try: customer = Customer.objects.get(user=user) except: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) long, lat = request.GET.get('long'), request.GET.get('lat') user_location = SampleLocation(long, lat) if not long or not lat: user_location = customer.location.filter(chosen=True).first() closest_data, err = ClosestBarbers.closest(0, ClosestBarbers.LIMIT, Barber.objects.all(), user_location, BarberRecordSerializer, customer) if err == 1: return Response(closest_data, status=status.HTTP_400_BAD_REQUEST) best_data, err = BestBarbers.best(0, BestBarbers.LIMIT, Barber.objects.all().order_by('-point'), user_location, BarberRecordSerializer, customer) if err == 1: return Response(best_data, status=status.HTTP_400_BAD_REQUEST) return Response({ "best_barbers": best_data.data, "closest_barbers": closest_data.data })
def login_verify(request): # try: if any(d not in request.data for d in ['phone', 'code', 'name', 'gender']): return Response(get_error_obj( 'wrong_parameters', 'name, gender, phone & code must be sent in body'), status=status.HTTP_400_BAD_REQUEST) phone = request.data['phone'] code = request.data['code'] name = request.data['name'] gender = request.data['gender'] login_user = LoginUser.objects.filter(phone=phone).first() if login_user is None: return Response(get_error_obj('auth_no_code_found'), status=status.HTTP_400_BAD_REQUEST) else: if login_user.code == code: user = User.objects.filter(username=phone).first() if user is None: user = User.objects.create(username=phone, password='******') id = Barber.objects.count() + 1 barber = Barber(user=user, barber_id='barber_{}'.format(id), phone=phone) barber.gender = gender barber.name = name barber.save() else: barber = Barber.objects.filter(user=user).first() if not barber: return Response(get_error_obj('wrong_user_type'), status=status.HTTP_400_BAD_REQUEST) barber.gender = gender barber.name = name barber.save() token, create = Token.objects.get_or_create(user=user) serializer = BarberSerializer_out(barber) data = serializer.data # data['name'] = barber.name data['phone'] = barber.phone # data['id'] = barber.barber_id data['token'] = token.key return Response(data) else: return Response(get_error_obj('auth_wrong_code'), status=status.HTTP_400_BAD_REQUEST)
def delete(self, service_id, barber): service = Service.objects.filter(schema__service_schema_id=service_id, barber=barber).first() if not service: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) service.delete() return Response({"status": 200})
def post(self, request): """ Filter barbers based on price range and services :param request: :return: """ user = request.user try: customer = Customer.objects.get(user=user) except: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) long, lat = request.GET.get('long'), request.GET.get('lat') user_location = SampleLocation(long, lat) if not long or not lat: user_location = customer.location.filter(chosen=True).first() if not user_location: return Response(get_error_obj('no_location_found'), status=status.HTTP_400_BAD_REQUEST) data = request.data try: serviceID, price_lower_limit, price_upper_limit = data[ 'serviceID'], data['price_lower_limit'], data[ 'price_upper_limit'] except: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) barbers = [] for barber in self.queryset.all(): services = barber.services.filter(service_id__in=serviceID) if not services: continue price = services.aggregate(Sum('cost'))['cost__sum'] if price_lower_limit <= price <= price_upper_limit: barbers.append(barber) queryset = sorted(barbers, key=lambda barber: ClosestBarbers.cal_dist( user_location, [barber.long, barber.lat])) barbers = self.serializer_class(queryset, many=True, context={ "user_location": user_location, 'customer': customer }) return Response(barbers.data)
def change_customer_chose_location(self, customer, request): lid = request.GET.get('id') if not lid: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) lid = lid location = self.queryset.filter(customer=customer, chosen=True) if location: for l in location: l.chosen = False l.save() location = self.queryset.filter(customer=customer, ID=lid).first() if not location: return Response(get_error_obj('no_location_found'), status=status.HTTP_400_BAD_REQUEST) location.chosen = True location.save() return Response()
def get(self, request): try: schemas = ServiceSchema.objects.all() schemas = ServiceSchemaSerializer(schemas, many=True) return Response(schemas.data) except Exception as e: return Response(get_error_obj('server_error', str(e)), status=status.HTTP_500_INTERNAL_SERVER_ERROR ) # general problem
def shift_handler(request): user = request.user if user is AnonymousUser or None: return Response(get_error_obj('access_denied'), status=status.HTTP_400_BAD_REQUEST) barber = Barber.objects.filter(user=user).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) if barber.is_verified is False: return Response(get_error_obj('access_denied'), status=status.HTTP_400_BAD_REQUEST) data = request.data data['barber_id'] = barber.barber_id serializer = ShiftSerializer(data=data) if serializer.is_valid() is False: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) shift = serializer.create(serializer.validated_data) if shift is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) return Response({"status": 200}, status=status.HTTP_200_OK)
def add_samples(request): user = request.user if user is AnonymousUser or None: return Response(get_error_obj('access_denied'), status=status.HTTP_400_BAD_REQUEST) barber = Barber.objects.filter(user=user).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) if barber.is_verified is False: return Response(get_error_obj('access_denied'), status=status.HTTP_405_METHOD_NOT_ALLOWED) data = request.data data['barber_id'] = barber.barber_id serializer = SampleWorkSerializer_in(data=data) if serializer.is_valid() is False: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) sample = serializer.create(serializer.validated_data) if sample is None: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) return Response({'status': 200}, status=status.HTTP_200_OK)
def create_or_update(self, request, service_id, barber): try: cost = request.data['cost'] except: return Response(get_error_obj('wrong_parameters', 'no parameter cost sent'), status=status.HTTP_400_BAD_REQUEST) schema = ServiceSchema.objects.filter( service_schema_id=service_id).first() if not schema: return Response(get_error_obj('no_data_found', 'service schema was not found'), status=status.HTTP_404_NOT_FOUND) if schema.lower_limit != 0 and schema.lower_limit > cost: return Response(get_error_obj('wrong_parameters', 'cost is out of range'), status=status.HTTP_409_CONFLICT) if schema.upper_limit != -1 and schema.upper_limit < cost: return Response(get_error_obj('wrong_parameters', 'cost is out of range'), status=status.HTTP_409_CONFLICT) service = Service.objects.filter(schema__service_schema_id=service_id, barber=barber).first() if not service: try: service = Service.objects.create( barber=barber, schema=schema, cost=0, service_id="service_{}".format(Service.objects.count() + 1)) except: service = Service.objects.create( barber=barber, schema=schema, cost=0, service_id="service_{}".format( Service.objects.all().last().pk + 2)) service.cost = cost service.save() return Response({"status": 200})
def barber_profile(request): user = request.user if user is None: return Response("user not found ", status=status.HTTP_400_BAD_REQUEST) customer = Customer.objects.filter(user=request.user).first() # if customer is None: # return Response(status=status.HTTP_404_NOT_FOUND) # if customer.isCompleted is False : # return Response({"status":401},status=status.HTTP_401_UNAUTHORIZED) try: barber_id = request.data['barber'] except: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) if barber_id is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) barber = Barber.objects.filter(barber_id=barber_id).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) serializer = BarberSerializer_out(barber, context={'customer': customer}) return Response(serializer.data)
def post(self, request): user = request.user try: barber = Barber.objects.filter(user=user).first() except: return Response(get_error_obj('access_denied'), status=status.HTTP_404_NOT_FOUND) if not barber.is_verified: return Response(get_error_obj('access_denied'), status=status.HTTP_401_UNAUTHORIZED) try: date = request.data['date'] year, month, day = date.split('-') projects = self.queryset.filter(reserveTime__year=year, reserveTime__month=month, reserveTime__day=day) projects = ProjectSerializer(projects, many=True) return Response(projects.data) except: return Response(get_error_obj('server_error'), status=status.HTTP_400_BAD_REQUEST)
def get(self, request): """ Search barbers with parameter search field :param request: :return: """ user = request.user try: customer = Customer.objects.get(user=user) except: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) long, lat = request.GET.get('long'), request.GET.get('lat') user_location = SampleLocation(long, lat) if not long or not lat: user_location = customer.location.filter(chosen=True).first() if not user_location: return Response(get_error_obj('no_location_found'), status=status.HTTP_400_BAD_REQUEST) barber_name = request.GET.get('barber_name') if not barber_name: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) barbers = self.queryset.filter( Q(barberName__icontains=barber_name) | Q(firstName__icontains=barber_name) | Q(lastName__icontains=barber_name) | Q(name__icontains=barber_name)) barbers = sorted(barbers, key=lambda barber: ClosestBarbers.cal_dist( user_location, [barber.long, barber.lat])) barbers = self.serializer_class(barbers, many=True, context={ "user_location": user_location, 'customer': customer }) return Response(barbers.data)
def customer_change_profile(request): # how make a field optional? set a default value or set required = false user = request.user customer = Customer.objects.filter(user=user).first() # customer.image = request.data['image'] if customer is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) try: serializer = CustomerSerializer(data=request.data) if serializer.is_valid(): customer = serializer.update(customer, serializer.validated_data) # customer.image = request.FILES['image'] customer.isCompleted = True customer.save() return Response({"status": 200}, status=status.HTTP_200_OK) else: # return Response({str(serializer.errors)}) return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) except Exception as e: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST)
def add_like(request): user = request.user try: barber_id = request.data['barber'] except: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) barber = Barber.objects.filter(barber_id=barber_id).first() if barber is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) if user is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) customer = Customer.objects.filter(user=user).first() if customer is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) if customer.isCompleted is False: return Response(get_error_obj('access_denied'), status=status.HTTP_405_METHOD_NOT_ALLOWED) if barber in customer.like.all(): customer.like.remove(barber) else: customer.like.add(barber) return Response({"status": 200}, status=status.HTTP_200_OK)
def login(request, phone=None): try: login_user = LoginUser.objects.filter(phone=phone) maincode = str(random.randrange(1000, 10000, 1)) if len(login_user) == 0: LoginUser.objects.create(phone=phone, code=maincode) else: login_user = login_user.first() login_user.code = maincode login_user.save() return Response({maincode}) except: return Response(get_error_obj('server_error'), status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request): user = request.user try: barber = Barber.objects.filter(user=user).first() except: return Response(get_error_obj('access_denied'), status=status.HTTP_404_NOT_FOUND) if not barber.is_verified: return Response(get_error_obj('access_denied'), status=status.HTTP_401_UNAUTHORIZED) project_status = request.GET.get('status') offset = int(request.GET.get('offset')) if not offset: offset = 0 if not project_status: # return Response(get_error_obj('wrong_parameters', 'no project status declared'), # status=status.HTTP_400_BAD_REQUEST) queryset = self.queryset elif project_status == 'unverified': queryset = self.queryset.filter( status=PresentedService.STATUS[0][0]) elif project_status == 'in_progress': queryset = self.queryset.filter( status=PresentedService.STATUS[2][0]) else: queryset = self.queryset.filter( status=PresentedService.STATUS[3][0]) size = queryset.count() if offset > size: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) elif offset + self.LIMIT < size: projects = queryset[offset:offset + self.LIMIT] else: projects = queryset[offset:] projects = ProjectSerializer(projects, many=True) return Response(projects.data)
def send_comment(request): user = request.user if user is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) customer = Customer.objects.filter(user=request.user).first() if customer is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) if customer.isCompleted is False: return Response(get_error_obj('access_denied'), status=status.HTTP_405_METHOD_NOT_ALLOWED) data = request.data data['customer'] = {'customer_id': customer.customer_id} serializer = CommentSerializer(data=data) if serializer.is_valid(): # barber_id = serializer.validated_data['barber']['barber_id'] # barber = Barber.objects.filter(barber_id=barber_id) # if barber is None: # return Response(get_error_obj('no_data_found'), status=status.HTTP_404_NOT_FOUND) comment = serializer.create(serializer.validated_data) if comment is None: return Response(get_error_obj('no_data_found'), status=status.HTTP_400_BAD_REQUEST) else: return Response(get_error_obj('wrong_parameters'), status=status.HTTP_400_BAD_REQUEST) return Response({"status": 200}, status=status.HTTP_200_OK)