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)
