def post(self, request):
"""Create multiple matches."""
try:
data = json.loads(request.body)
except json.JSONDecodeError:
data = request.data
match_ids_list = data.get("matches")
cancel_previous = data.get("cancel_previous", False)
if not match_ids_list:
return failure_response("POST body is misformatted",
status=status.HTTP_400_BAD_REQUEST)
errors = []
for match_ids in match_ids_list:
new_match_response = CreateMatchController(
{
"ids": match_ids,
"cancel_previous": cancel_previous
},
self.serializer_class,
).process()
if new_match_response.status_code not in [
status.HTTP_201_CREATED,
status.HTTP_200_OK,
]:
errors.append(new_match_response)
if errors:
return failure_response(
f"message: {len(errors)} matches failed to be created with the following errors: {errors}",
status=status.HTTP_400_BAD_REQUEST,
)
return success_response(status=status.HTTP_201_CREATED)
def process(self):
"""Returns the current access token or a new one if expired. If the user isn't authenticated yet,
logs an existing user in or registers a new one."""
user = self._request.user
status_code = status.HTTP_200_OK
if self._data.get("username") and self._data.get("password"):
user, status_code = self._authenticate(self._data.get("username"),
self._data.get("password"))
if user is None:
return failure_response("Bad credentials provided.",
status=status_code)
elif not user.is_authenticated:
token = self._data.get("id_token")
token_info = self._get_token_info(token)
if token_info is None:
return failure_response("ID Token is not valid.",
status.HTTP_401_UNAUTHORIZED)
user, status_code = self._login(token_info)
if user is None:
return failure_response("ID Token is not valid.",
status=status_code)
access_token = self._issue_access_token(user)
return success_response(
self._serializer(user, context={
"access_token": access_token
}).data,
status=status_code,
)
def process(self):
message = self._data.get("message")
if not message:
return failure_response("Message is required",
status.HTTP_400_BAD_REQUEST)
receiving_user = User.objects.filter(id=self._receiving_user_id)
if not receiving_user:
return failure_response("Receiving user not found",
status.HTTP_404_NOT_FOUND)
receiving_user = receiving_user[0]
if not receiving_user.person.fcm_registration_token:
# Receiving user does not have notifications enabled, but message will still be delivered through Firebase
return success_response(status=status.HTTP_200_OK)
device = GCMDevice.objects.get(
registration_id=receiving_user.person.fcm_registration_token)
response = device.send_message(
title=f"Chat from {self._user.first_name}",
message=message,
# Give APNS user id as thread id so iOS can collapse notifications
thread_id=str(self._user.id),
# Set the app to have a badge
badge=1,
)
if response.get("failure") == 1:
return failure_response(
f"Failed to send message, FCM Response: {response}",
status.HTTP_502_BAD_GATEWAY,
)
return success_response(status=status.HTTP_201_CREATED)
def post(self, request):
"""Populates the database with the hardcoded data from the filenames in `request.body`."""
body = json.loads(request.body)
filenames = body.get("filenames")
if filenames is None:
return failure_response(
"POST body is misformatted", status.HTTP_400_BAD_REQUEST
)
new_entries = 0
for filename in filenames:
controller = self._filename_switch(filename)
if controller:
new_entries += self._parse_and_create(filename, controller)
else:
return failure_response(
f"Invalid filename {filename}", status.HTTP_406_NOT_ACCEPTABLE
)
if new_entries > 0:
return success_response(
f"Successfully created {new_entries} new entries",
status.HTTP_201_CREATED,
)
else:
return success_response("No new changes", status.HTTP_200_OK)
def post(self, request, id):
"""Unblock user by id."""
if not User.objects.filter(id=id).exists():
return failure_response("User not found.",
status.HTTP_404_NOT_FOUND)
elif id == request.user.id:
return failure_response("You cannot unblock yourself.",
status.HTTP_403_FORBIDDEN)
elif request.user.person.blocked_users.filter(id=id).exists():
request.user.person.blocked_users.remove(id)
return success_response(status=status.HTTP_201_CREATED)
else:
# User is not blocked anyways
return success_response(status=status.HTTP_200_OK)
def process(self):
# Verify that all required fields are provided
name = self._data.get("name")
if name is None:
return failure_response("POST body is misformatted",
status.HTTP_400_BAD_REQUEST)
# Get optional fields
subtitle = self._data.get("subtitle")
img_url = self._data.get("img_url")
# Check if a interest already exists with the given fields and return it if so
interest = Interest.objects.filter(name=name,
subtitle=subtitle,
img_url=img_url)
if interest:
return success_response(
self._serializer(interest[0]).data, status.HTTP_200_OK)
# Create and return a new interest with the given fields
interest = Interest.objects.create(name=name,
subtitle=subtitle,
img_url=img_url)
interest.save()
return success_response(
self._serializer(interest).data, status.HTTP_201_CREATED)
def get(self, request, id):
"""Get group by id."""
group = Group.objects.filter(id=id)
if not group:
return failure_response("Group does not exist",
status.HTTP_404_NOT_FOUND)
return success_response(
self.serializer_class(group[0]).data, status.HTTP_200_OK)
def get(self, request, id):
"""Get purpose by id."""
purpose = Purpose.objects.filter(id=id)
if not purpose:
return failure_response("Purpose does not exist", status.HTTP_404_NOT_FOUND)
return success_response(
self.serializer_class(purpose[0]).data, status.HTTP_200_OK
)
def delete(self, request, id):
"""Delete a match by id."""
match = Match.objects.filter(id=id)
if not match:
return failure_response("Match does not exist",
status.HTTP_404_NOT_FOUND)
match[0].delete()
return success_response()
def get(self, request, id):
"""Get interest by id."""
interest = Interest.objects.filter(id=id)
if not interest:
return failure_response("Interest does not exist",
status.HTTP_404_NOT_FOUND)
return success_response(
self.serializer_class(interest[0]).data, status.HTTP_200_OK)
def get(self, request, id):
"""Get prompt by id."""
prompt = Prompt.objects.filter(id=id)
if not prompt:
return failure_response("Prompt does not exist", status.HTTP_404_NOT_FOUND)
return success_response(
self.serializer_class(prompt[0]).data, status.HTTP_200_OK
)
def get(self, request, id):
"""Get major by id."""
major = Major.objects.filter(id=id)
if not major:
return failure_response("Major does not exist",
status.HTTP_404_NOT_FOUND)
return success_response(
self.serializer_class(major[0]).data, status.HTTP_200_OK)
def delete(self, request, id, match_id):
"""Delete a survey by id."""
survey = Survey.objects.filter(id=id).exists()
if not survey:
return failure_response("Survey does not exist",
status.HTTP_404_NOT_FOUND)
Survey.objects.get(id=id).delete()
return success_response(None, status.HTTP_200_OK)
def get(self, request, id, match_id):
"""Get survey by id."""
survey = Survey.objects.filter(id=id).exists()
if not survey:
return failure_response("Survey does not exist",
status.HTTP_404_NOT_FOUND)
return success_response(
self.serializer_class(Survey.objects.get(id=id)).data,
status.HTTP_200_OK)
def post(self, request, id):
"""Cancel match by id."""
match = Match.objects.filter(id=id)
if not match:
return failure_response("Match does not exist.",
status.HTTP_404_NOT_FOUND)
match[0].status = match_status.CANCELED
match[0].save()
return success_response()
def get(self, request, id):
"""Get user by id."""
if not User.objects.filter(id=id).exists():
return failure_response("User not found.",
status.HTTP_404_NOT_FOUND)
serialized_user = self.serializer_class(
User.objects.get(id=id), context={"request_user": request.user})
# because we pass in the request, must make sure serializer is valid
return success_response(serialized_user.data, status.HTTP_200_OK)
def get(self, request):
"""Get current match by user."""
match = Match.objects.filter(
Q(user_1=request.user)
| Q(user_2=request.user)).order_by("-created_date")
if not match:
return failure_response("Match does not exist",
status.HTTP_404_NOT_FOUND)
return success_response(
MatchSerializer(match[0], user=request.user).data,
status.HTTP_200_OK)
def get(self, request, id):
"""Get all matches for user by user id."""
user = User.objects.filter(id=id).exists()
if not user:
return failure_response("User not found.",
status.HTTP_404_NOT_FOUND)
user = User.objects.get(id=id)
matches = Match.objects.filter(Q(user_1=user) | Q(
user_2=user)).order_by("-created_date")
return success_response(
self.serializer_class(matches, many=True).data, status.HTTP_200_OK)
def post(self, request):
body = json.loads(request.body)
seconds = body.get("seconds")
if seconds:
start_countdown.delay(seconds)
return success_response(
f"Countdown started for {seconds} seconds", status.HTTP_200_OK
)
return failure_response(
"POST body is misformatted", status.HTTP_400_BAD_REQUEST
)
def post(self, request):
"""Cancel current user's current match."""
match = Match.objects.filter(
Q(user_1=request.user)
| Q(user_2=request.user)).order_by("-created_date")
if not match:
return failure_response("Match does not exist",
status.HTTP_404_NOT_FOUND)
match = match[0]
match.status = match_status.CANCELED
match.save()
return success_response()
def process(self):
# Get the model
survey = Survey.objects.filter(id=self._id)
if survey is None:
return failure_response("Survey does not exist", status.HTTP_404_NOT_FOUND)
survey = survey[0]
# Extract attributes
did_meet = self._data.get("did_meet")
explanation = self._data.get("explanation")
rating = self._data.get("rating")
if rating is not None and rating not in RATINGS:
return failure_response(
"The provided rating is invalid", status.HTTP_400_BAD_REQUEST
)
# Modify new fields
modify_attribute(survey, "did_meet", did_meet)
modify_attribute(survey, "explanation", explanation)
modify_attribute(survey, "rating", rating)
survey.save()
return success_response(None, status.HTTP_200_OK)
def post(self, request):
"""Update current match for current user."""
try:
data = json.loads(request.body)
except json.JSONDecodeError:
data = request.data
match = Match.objects.filter(
Q(user_1=request.user)
| Q(user_2=request.user)).order_by("-created_date")
if match:
return UpdateMatchController(match[0].id, request.user, data,
self.serializer_class).process()
return failure_response("Match does not exist",
status.HTTP_404_NOT_FOUND)
def process(self):
# Get the model
purpose = Purpose.objects.filter(id=self._id)
if not purpose:
return failure_response("Purpose does not exist", status.HTTP_404_NOT_FOUND)
purpose = purpose[0]
# Extract attributes
name = self._data.get("name")
# Modify new fields
modify_attribute(purpose, "name", name)
purpose.save()
return success_response(self._serializer(purpose).data, status.HTTP_200_OK)
def process(self):
# Verify that all required fields are provided
name = self._data.get("name")
if name is None:
return failure_response(
"POST body is misformatted", status.HTTP_400_BAD_REQUEST
)
# Check if a major already exists with the given fields and return it if so
major = Major.objects.filter(name=name)
if major:
return success_response(self._serializer(major[0]).data, status.HTTP_200_OK)
# Create and return a new major with the given fields
major = Major.objects.create(name=name)
major.save()
return success_response(self._serializer(major).data, status.HTTP_201_CREATED)
def process(self):
# Get the model
prompt = Prompt.objects.filter(id=self._id)
if not prompt:
return failure_response("Prompt does not exist",
status.HTTP_404_NOT_FOUND)
prompt = prompt[0]
# Extract attributes
name = self._data.get("question_name")
label = self._data.get("question_placeholder")
# Modify new fields
modify_attribute(prompt, "question_name", name)
modify_attribute(prompt, "question_placeholder", label)
prompt.save()
return success_response(
self._serializer(prompt).data, status.HTTP_200_OK)
def process(self):
# Get the model
location = Location.objects.filter(id=self._id)
if not location:
return failure_response("Location does not exist",
status.HTTP_404_NOT_FOUND)
location = location[0]
# Extract attributes
area = self._data.get("area")
name = self._data.get("name")
# Modify new fields
modify_attribute(location, "area", area)
modify_attribute(location, "name", name)
# Save new changes
location.save()
return success_response(
self._serializer(location).data, status.HTTP_200_OK)
def process(self):
# Get the model
group = Group.objects.filter(id=self._id)
if not group:
return failure_response("Group does not exist", status.HTTP_404_NOT_FOUND)
group = group[0]
# Extract attributes
name = self._data.get("name")
subtitle = self._data.get("subtitle")
img_url = self._data.get("img_url")
# Modify new fields
modify_attribute(group, "name", name)
modify_attribute(group, "subtitle", subtitle)
modify_attribute(group, "img_url", img_url)
# Save new changes
group.save()
return success_response(self._serializer(group).data, status.HTTP_200_OK)
def process(self):
# Get the model
interest = Interest.objects.filter(id=self._id)
if not interest:
return failure_response("Interest does not exist",
status.HTTP_404_NOT_FOUND)
interest = interest[0]
# Extract attributes
name = self._data.get("name")
subtitle = self._data.get("subtitle")
img_url = self._data.get("img_url")
# Modify new fields
modify_attribute(interest, "name", name)
modify_attribute(interest, "subtitle", subtitle)
modify_attribute(interest, "img_url", img_url)
interest.save()
return success_response(
self._serializer(interest).data, status.HTTP_200_OK)
def process(self):
users = User.objects.filter(
Q(person__has_onboarded=True) & Q(person__soft_deleted=False))
query = self._request.GET.get("query")
# Check if query was provided and isn't whitespace
if query is not None and query.strip() != "":
# Create processor to ignore query but convert User object into string choice
def user_properties(user):
return [user.first_name.lower(), user.last_name.lower()]
def processor(user):
return user if type(user) is str else " ".join(
user_properties(user))
searched_users = fuzzymatch.extract(query.lower(),
users,
processor=processor)
# Extract the users from the returned tuple list
users = list(
map(lambda searched_user: searched_user[0], searched_users))
page_size = self._request.GET.get("page_size")
page_number = self._request.GET.get("page_number")
if page_size is not None and page_number is not None:
paginator = Paginator(users, page_size)
try:
page = paginator.page(page_number)
users = page.object_list
except:
return failure_response("Page not found",
status.HTTP_404_NOT_FOUND)
return success_response(
self._serializer(users,
context={
"request_user": self._request.user
},
many=True).data,
status.HTTP_200_OK,
)
def process(self):
# Verify that all required fields are provided
name = self._data.get("name")
area = self._data.get("area")
if name is None or area is None:
return failure_response(
"POST body is misformatted", status.HTTP_400_BAD_REQUEST
)
# Check if a location already exists with the given fields and return it if so
location = Location.objects.filter(name=name, area=area)
if location:
return success_response(
self._serializer(location[0]).data, status.HTTP_200_OK
)
# Create and return a new location with the given fields
location = Location.objects.create(name=name, area=area)
location.save()
return success_response(
self._serializer(location).data, status.HTTP_201_CREATED
)
