def get(self, request):
token = request.headers.get('Authorization', None)
if token is None or token == "":
connection.close()
return Response({"message": "Authorization credentials missing"},
status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message": payload['message']},
status=status.HTTP_403_FORBIDDEN)
accepts = Accepts.objects.filter(
Q(request_made_by=payload['_id'])
| Q(request_acceptor=payload['_id']))
if len(accepts) == 0:
connection.close()
return Response({"message": "No accpets found"},
status=status.HTTP_204_NO_CONTENT)
else:
serializer = AcceptsSerializer(accepts, many=True)
serializer = serializer.data
key = 1
for item in serializer:
item['key'] = key
key += 1
connection.close()
return Response({
"message": "Accepts found",
"Accepts": serializer
},
status=status.HTTP_200_OK)
def get(self, request, pk):
token = request.headers.get('Authorization', None)
if token is None or token == "":
connection.close()
return Response({"message": "Authorization credentials missing"},
status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message": payload['message']},
status=status.HTTP_403_FORBIDDEN)
try:
org = Organizations.objects.get(id=pk)
serializer = OrganizationsSerializer(org)
serializer = serializer.data
areas = AreasCatered.objects.filter(org_id=pk)
areas_serializer = AreasCateredSerializer(areas, many=True)
serializer['areas_catered'] = areas_serializer.data
connection.close()
return Response(
{
"message": "Organization Found",
"Organization": serializer
},
status=status.HTTP_200_OK)
except Organizations.DoesNotExist:
connection.close()
return Response({"message": "Organization Does Not Exist"},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk):
token = request.headers.get('Authorization', None)
if token is None or token == "":
connection.close()
return Response({"message": "Authorization credentials missing"},
status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message": payload['message']},
status=status.HTTP_403_FORBIDDEN)
try:
item_request = ItemRequest.objects.get(id=pk)
serializer = ItemRequestSerializer(item_request)
serializer = serializer.data
connection.close()
return Response({
'message': "Request Found",
"Request": serializer
},
status=status.HTTP_200_OK)
except ItemRequest.DoesNotExist:
connection.close()
return Response({"maessage": "Request not found"},
status=status.HTTP_204_NO_CONTENT)
def post(self, request):
token = request.headers.get('Authorization', None)
if token is None or token=="":
connection.close()
return Response({"message":"Authorization credentials missing"}, status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message":payload['message']}, status=status.HTTP_403_FORBIDDEN)
item_requests = ItemRequest.objects.filter(request_made_by=payload['_id'])
if len(item_requests) >= 5:
connection.close()
return Response({"message":"User has already made maximum requests"}, status=status.HTTP_400_BAD_REQUEST)
req_data = {}
req_data["item_name"] = request.data.get("item_name", None)
req_data["quantity"] = request.data.get("quantity", None)
req_data["location"] = request.data.get("location", None)
req_data['request_made_by'] = payload['_id']
req_data['description'] = request.data.get('description', None)
if req_data['description']=='':
req_data['description'] = None
serializer = ItemRequestSerializer(data=req_data)
if serializer.is_valid():
serializer.save()
registration_ids = []
userDevices = UserFCMDevice.objects.all()
for userDevice in userDevices:
print(userDevice.user_id)
if userDevice.user_id != payload['_id']:
registration_ids.append(userDevice.registration_id)
else:
print("Not Taking")
message_title = "New Request Arrived"
message_body = req_data['item_name'] + '\nCity: ' + req_data['location']
data = {
"url":"https://akina.dscvit.com/feed",
"click_action":"FLUTTER_NOTIFICATION_CLICK",
"sound":"default",
"status":"done",
"screen":"Requests Page",
"location":req_data['location']
}
result = send_notifs(registration_ids, message_title, message_body, data)
connection.close()
if result:
return Response({"message":"New Request created but, failed to send notifications", "Request":serializer.data}, status=status.HTTP_200_OK)
return Response({"message":"New Request created", "Request":serializer.data}, status=status.HTTP_201_CREATED)
else:
connection.close()
return Response({"message":"Invalid Request"}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
token = request.headers.get('Authorization', None)
if token is None or token == "":
connection.close()
return Response({"message": "Authorization credentials missing"},
status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message": payload['message']},
status=status.HTTP_403_FORBIDDEN)
print(request.data)
org_data = {}
org_data['name'] = request.data.get("name", None)
org_data['city'] = request.data.get("city", None)
org_data['state'] = request.data.get("state", None)
org_data['country'] = request.data.get("country", None)
org_data['description'] = request.data.get("description", None)
org_data['email'] = request.data.get("email", None)
org_data['phone_no'] = request.data.get("phone_no", None)
org_data['address'] = request.data.get("address", None)
org_data['other_contact'] = request.data.get("other_contact", None)
org_data['web_links'] = request.data.get("web_links", None)
areas_catered = request.data.get("areas_catered", None)
if areas_catered == None or len(areas_catered) == 0:
connection.close()
return Response({"message": "Please provide Areas catered"},
status=status.HTTP_400_BAD_REQUEST)
serializer = OrganizationsSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
print(serializer.data['id'])
for area in areas_catered:
area['org_id'] = serializer.data['id']
area_serializer = AreasCateredSerializer(data=area)
if area_serializer.is_valid():
area_serializer.save()
else:
print(area_serializer.errors)
connection.close()
return Response(
{
"message": "Organization Saved",
"organization": serializer.data
},
status=status.HTTP_201_CREATED)
else:
connection.close()
return Response({"message": serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
token = request.headers.get('Authorization', None)
if token is None or token=="":
connection.close()
return Response({"message":"Authorization credentials missing"}, status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message":payload['message']}, status=status.HTTP_403_FORBIDDEN)
location = request.query_params.get('location', None)
if location==None or location=='':
connection.close()
return Response({"message":"Location not provided"}, status=status.HTTP_400_BAD_REQUEST)
item_requests = ItemRequest.objects.filter(location__iexact=location)
if len(item_requests) == 0:
connection.close()
return Response({"message":"No requests found"}, status=status.HTTP_204_NO_CONTENT)
serializer = ItemRequestSerializer(item_requests, many=True)
data = serializer.data
flag = True
while flag:
for item in data:
request_acceptors = item['accepted_by'].split(',')
if item['request_made_by']==payload['_id'] or payload['_id'] in request_acceptors:
data.remove(item)
flag = False
for item in data:
request_acceptors = item['accepted_by'].split(',')
if item['request_made_by']==payload['_id'] or payload['_id'] in request_acceptors:
flag = True
key = 1
for item in data:
item['key'] = key
key += 1
if len(data) == 0:
connection.close()
return Response({"message":"No requests found"}, status=status.HTTP_204_NO_CONTENT)
connection.close()
return Response({"message":"Requests found", "Request":data}, status=status.HTTP_200_OK)
def post(self, request):
req_data = request.data
if req_data.get("user_token", None) == None or req_data.get(
"registration_id", None) == None:
connection.close()
return Response(
{"message": "User token or registration id missing"},
status=status.HTTP_400_BAD_REQUEST)
payload = get_user_id(req_data.get("user_token"))
if payload['_id'] is None:
connection.close()
return Response({"message": payload['message']},
status=status.HTTP_403_FORBIDDEN)
req_data = {}
req_data['user_id'] = payload['_id']
req_data["registration_id"] = request.data.get("registration_id", None)
userDevice = UserFCMDevice.objects.filter(
Q(user_id=req_data['user_id'])
& Q(registration_id=req_data['registration_id']))
if len(userDevice) != 0:
connection.close()
print('device alreay exists')
return Response({"message": "Device details updated"},
status=status.HTTP_200_OK)
else:
data = {
"user_id": req_data['user_id'],
"registration_id": req_data['registration_id']
}
serializer = UserFCMDeviceSerializer(data=data)
if serializer.is_valid():
serializer.save()
connection.close()
print("Registered")
return Response({"message": "Device Registered"},
status=status.HTTP_201_CREATED)
else:
print(serializer.errors)
connection.close()
return Response({"message": "Unable to register device"},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
token = request.headers.get('Authorization', None)
if token is None or token == "":
connection.close()
return Response({"message": "Authorization credentials missing"},
status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message": payload['message']},
status=status.HTTP_403_FORBIDDEN)
orgs = Organizations.objects.all()
if len(orgs) == 0:
connection.close()
return Response({"message": "No Organizations Found"},
status=status.HTTP_204_NO_CONTENT)
serializer = OrganizationsSerializer(orgs, many=True)
serializer = serializer.data
key = 1
for item in serializer:
areas = AreasCatered.objects.filter(id=item['id'])
area_serializer = AreasCateredSerializer(areas, many=True)
item['areas_catered'] = area_serializer.data
item['key'] = key
key += 1
connection.close()
return Response(
{
"message": "Organizations Found",
"Organization": serializer
},
status=status.HTTP_200_OK)
def get(self, request, pk):
token = request.headers.get('Authorization', None)
if token is None or token == "":
connection.close()
return Response({"message": "Authorization credentials missing"},
status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message": payload['message']},
status=status.HTTP_403_FORBIDDEN)
try:
org = Organizations.objects.get(id=pk)
org.is_verified = True
org.save()
connection.close()
return Response({"message": "Organization Verified"},
status=status.HTTP_200_OK)
except Organizations.DoesNotExist:
connection.close()
return Response({"message": "Organization Does Not Exist"},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
token = request.headers.get('Authorization', None)
if token is None or token == "":
connection.close()
return Response({"message": "Authorization credentials missing"},
status=status.HTTP_403_FORBIDDEN)
city = request.query_params.get("city", None)
state = request.query_params.get("state", None)
country = request.query_params.get("country", None)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message": payload['message']},
status=status.HTTP_403_FORBIDDEN)
orgs = Organizations.objects.all()
result = []
for org in orgs:
if org.is_verified:
serializer = OrganizationsSerializer(org)
serializer = serializer.data
areas = AreasCatered.objects.filter(org_id=org.id)
areas_serializer = AreasCateredSerializer(areas, many=True)
serializer['areas_catered'] = areas_serializer.data
result.append(serializer)
field = None
field_value = None
if city != None and city != "":
field = 'city'
field_value = city.lower()
elif state != None and state != "":
field = 'state'
field_value = state.lower()
elif country != None and country != "":
field = 'country'
field_value = country.lower()
to_remove = []
if field != None:
for org in result:
areas = org['areas_catered']
should_remove = True
for area in areas:
if field_value == (area[field].lower()):
should_remove = False
if should_remove:
to_remove.append(org)
for item in to_remove:
result.remove(item)
key = 1
for item in result:
item['key'] = key
key += 1
if len(result) == 0:
connection.close()
return Response({"message": "Organizations not found"},
status=status.HTTP_204_NO_CONTENT)
connection.close()
return Response(
{
"message": "Organizaions found",
"Organization": result
},
status=status.HTTP_200_OK)
def post(self, request):
token = request.headers.get('Authorization', None)
if token is None or token=="":
connection.close()
return Response({"message":"Authorization credentials missing"}, status=status.HTTP_403_FORBIDDEN)
payload = get_user_id(token)
if payload['_id'] is None:
connection.close()
return Response({"message":payload['message']}, status=status.HTTP_403_FORBIDDEN)
if request.data.get('request_id', None)==None or request.data.get("location", None)==None:
connection.close()
return Response({"message":"Invalid accept"}, status=status.HTTP_400_BAD_REQUEST)
try:
item_request = ItemRequest.objects.get(id=int(request.data.get('request_id', None)))
except ItemRequest.DoesNotExist:
connection.close()
return Response({"message":"Request Not Found"}, status=status.HTTP_400_BAD_REQUEST)
if item_request.request_made_by == payload['_id']:
connection.close()
return Response({"message":"User not allowed to accept request"}, status=status.HTTP_400_BAD_REQUEST)
if item_request.location.lower() == request.data.get('location', None).lower():
accepts = Accepts.objects.filter(Q(request_made_by=item_request.request_made_by) & Q(request_acceptor=payload['_id']))
if len(accepts)!=0:
accept = accepts[0]
#################### CHECKING IF USERS BLOCKED EACH OTHER ####################################
resp = check_blocked(accept.request_made_by, accept.request_acceptor)
if resp.status_code==200:
resp = json.loads(resp.text)
connection.close()
return Response({"message":resp['message']}, status=status.HTTP_400_BAD_REQUEST)
items_accepted = accept.request_id
items_accepted = items_accepted.split(',')
if str(item_request.id) in items_accepted:
connection.close()
return Response({'message':"Item Already Accepted"}, status=status.HTTP_400_BAD_REQUEST)
accept.request_id = accept.request_id + "," + str(item_request.id)
accept.item_names = accept.item_names + "," +str(item_request.item_name)
accept.save()
serializer = AcceptsSerializer(accept)
item_request.accepted_by = str(item_request.accepted_by) + "," + str(payload['_id'])
item_request.save()
registration_ids = []
userDevices = UserFCMDevice.objects.filter(user_id = accept.request_made_by)
if len(userDevices) != 0:
registration_ids.append(userDevices[0].registration_id)
message_title = "Request Has been Accepted"
message_body = "Your request for " + item_request.item_name + " has been accepted."
data = {
"url":"https://akina.dscvit.com/mychats",
"click_action":"FLUTTER_NOTIFICATION_CLICK",
"sound":"default",
"status":"done",
"screen":"Chats Page"
}
result = send_notifs(registration_ids, message_title, message_body, data)
else:
result = 1
if result:
connection.close()
return Response({"message":"Request Accepted but, failed to send notifications", "Accepts":serializer.data}, status=status.HTTP_200_OK)
connection.close()
return Response({"message": "Request Accepted", "Accepts":serializer.data}, status=status.HTTP_200_OK)
else:
#################### CHECKING IF USERS BLOCKED EACH OTHER ####################################
resp = check_blocked(item_request.request_made_by, str(payload['_id']))
if resp.status_code==200:
resp = json.loads(resp.text)
connection.close()
return Response({"message":resp['message']}, status=status.HTTP_400_BAD_REQUEST)
accepts = {
"request_made_by": item_request.request_made_by,
"request_acceptor": str(payload['_id']),
"request_id": str(item_request.id),
"item_names": str(item_request.item_name)
}
serializer = AcceptsSerializer(data=accepts)
if serializer.is_valid():
serializer.save()
item_request.accepted_by = payload['_id']
item_request.save()
registration_ids = []
userDevices = UserFCMDevice.objects.filter(user_id = accepts['request_made_by'])
if len(userDevices) != 0:
registration_ids.append(userDevices[0].registration_id)
message_title = "Request Has been Accepted"
message_body = "Your request for " + item_request.item_name + " has been accepted."
data = {
"url":"https://akina.dscvit.com/mychats",
"click_action":"FLUTTER_NOTIFICATION_CLICK",
"sound":"default",
"status":"done",
"screen":"Chats Page"
}
result = send_notifs(registration_ids, message_title, message_body, data)
else:
result = 1
if result:
connection.close()
return Response({"message":"Request Accepted but, failed to send notifications", "Accepts":serializer.data}, status=status.HTTP_200_OK)
connection.close()
return Response({"message": "Request Accepted", "Accepts":serializer.data}, status=status.HTTP_200_OK)
else:
connection.close()
return Response({"message":"Invalid acceptor"}, status=status.HTTP_400_BAD_REQUEST)
else:
connection.close()
return Response({"message":"Locations are not same"}, status=status.HTTP_400_BAD_REQUEST)