def test_get(self):
random_room = Room.objects.order_by('?').first()
pk = random_room.pk
response = client.get(reverse('api:room', args=[pk]))
self.assertEqual(response.status_code, status.HTTP_200_OK)
serializer = RoomSerializer(random_room)
self.assertEqual(response.data, serializer.data)
def perform_destroy(self, instance):
room_id = instance.game.room.pk
super().perform_destroy(instance)
update_room_rate_after_delete_review(review=instance, room_id=room_id)
update_user_reviews_count_after_delete_review(user=instance.game.user)
recombee_client = RecombeeIntegrationClient()
recombee_client.cancel_room_rating_by_user(
room_id=instance.game.room.id, user_id=instance.game.user.id)
recombee_client.update_room_rating(RoomSerializer(instance.game.room))
def get(self, request, format=None):
if request.user.is_anonymous:
queryset = Room.objects.all().order_by(
'-totalRating')[:RECOMMENDATION_SIZE]
else:
already_played = Game.objects.filter(
user__id=request.user.id).values_list('room_id',
flat=True).distinct()
queryset = Room.objects.filter(~Q(id__in=already_played)).order_by(
'-totalRating')[:RECOMMENDATION_SIZE]
serializer = RoomSerializer(queryset,
many=True,
context={'request': request})
return Response(serializer.data)
def test_post(self):
venue = Venue.objects.order_by('?').first()
record = {
'venue_id': venue.id,
'room_number': 'A002',
'room_type': 'Suite',
'room_desc': 'Avengers HQ themed Second Suite'
}
response = client.post(reverse('api:rooms'), data=record)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
pk = response.data['id']
room = Room.objects.get(pk=pk)
serializer = RoomSerializer(room)
self.assertEqual(response.data, serializer.data)
def post(self, request):
try:
player_id = request.session["player_id"]
player = Player.objects.get(uuid=player_id)
except (KeyError, Player.DoesNotExist):
return HttpResponseBadRequest(
"No player ID in session, or invalid")
friendly_name = self._generate_friendly_name(request)
room = Room.objects.create(admin=player, friendly_name=friendly_name)
player.room = room
player.save()
return JsonResponse(RoomSerializer(room).data)
def create(self, request, room_pk):
""" create new review """
try:
room = Room.objects.get(pk=room_pk)
except Room.DoesNotExist:
return Response(data=['לא נמצא חדר'],
status=status.HTTP_404_NOT_FOUND)
user = request.user
game, created = Game.objects.get_or_create(room=room, user=user)
# check if a review for the game already exists
if Review.objects.filter(game=game).exists():
return Response(data=['כבר הגבת על החדר'],
status=status.HTTP_403_FORBIDDEN)
# insert the game to the data
data = request.data.copy()
data['game'] = game.pk
# validate the request.data
review_serializer = self.serializer_class(data=data)
if not review_serializer.is_valid():
return Response(dic_to_list(review_serializer.errors),
status=status.HTTP_400_BAD_REQUEST)
# update all the relevant models and return the new review
review_serializer.save()
if created:
# if a new game was created we need to update the user_room_count
user.rooms_count += 1
recombee_client = RecombeeIntegrationClient()
recombee_client.send_room_done_by_user(room.id, user.id)
user.save()
update_room_rate_after_create_review(request=self.request, room=room)
update_user_reviews_count_after_create_review(user=user)
# send room rating update to recombee
recombee_client = RecombeeIntegrationClient()
recombee_client.send_room_rating_by_user(
room.id, user.id, int(request.data['totalRating']))
roomSerializer = RoomSerializer(room)
recombee_client.update_room_rating(roomSerializer)
return Response(review_serializer.data, status=status.HTTP_201_CREATED)
def update(self, request, *args, **kwargs):
""" update a review """
review_before_update = self.get_object()
data = request.data
data['game'] = review_before_update.game.pk
partial = kwargs.pop('partial', False)
serializer = self.get_serializer(review_before_update,
data=data,
partial=partial)
if not serializer.is_valid():
return Response(dic_to_list(serializer.errors),
status=status.HTTP_400_BAD_REQUEST)
# self.update_room_rate_after_update_review(request, review_before_update)
self.perform_update(serializer)
roomObject = Room.objects.get(pk=kwargs['room_pk'])
self.update_room_rate_after_update_review(roomObject)
recombee_client = RecombeeIntegrationClient()
recombee_client.update_room_rating_by_user(
roomObject.id, review_before_update.game.user.id,
review_before_update.totalRating)
recombee_client.update_room_rating(RoomSerializer(roomObject))
return Response(serializer.data, status=status.HTTP_200_OK)
def test_list(self):
response = client.get(reverse('api:rooms'))
rooms = Room.objects.all()
serializer = RoomSerializer(rooms, many=True)
self.assertEqual(response.data['results'], serializer.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)