def _test_fix_times(self, game_data): game = Game.objects.get(id=self.game_id) self.assertFalse(GameSerializer(game, data=game_data).is_valid()) s = GameSerializer(game, data=game_data, context={"fix_times": True}) self.assertTrue(s.is_valid()) self.assertTrue(GameSerializer(game, data=s.validated_data).is_valid()) update_game(game, s.validated_data)
def create(self, request): serializer = GameSerializer(data=request.data) if serializer.is_valid(): user = request.user player = user.player player.hosted_count += 1 player.game_count += 1 if request.data['nickname'] != "": player.nickname = request.data['nickname'] elif player.nickname == "": player.nickname = player.user.username player.save() new_game = Game() new_game.host = player new_game.name = request.data['name'] new_game.motto = request.data['motto'] new_game.passcode = request.data['passcode'] new_game.save() new_game_player_detail = GamePlayerDetail() new_game_player_detail.game = new_game new_game_player_detail.player = player new_game_player_detail.save() return Response({'status': 'game set', 'game_id': new_game.id}) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def game_detail(request, pk): try: game = Game.objects.get(pk=pk) except Game.DoesNotExist: # return HttpResponse(status=status.HTTP_404_NOT_FOUND) return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': game_serialized = GameSerializer(game) # return JsonResponse(game_serialized.data) return Response(game_serialized.data) elif request.method == 'PUT': # game_data = JSONParser().parse(request) game_serializer = GameSerializer(game, data=request.data) if game_serializer.is_valid: game_serializer.save() # return JsonResponse(game_serializer.data) return Response(game_serializer.data) else: # return JsonResponse(game_serializer.errors, # status=status.HTTP_400_BAD_REQUEST) return Response(game_serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': game.delete() # return HttpResponse(status=status.HTTP_204_NO_CONTENT) return Response(status=status.HTTP_204_NO_CONTENT)
def get(self, request): games = Game.objects.all() category = self.request.query_params.get('category_id', 0) if category is 0: serializer = GameSerializer(games, many=True) else: serializer = GameSerializer(games.filter(category=category), many=True) return Response(serializer.data)
def game_list(request): if request.method == 'GET': games = Game.objects.all() games_serializer = GameSerializer(games, many=True) return Response(games_serializer.data) elif request.method == 'POST': games_serializer = GameSerializer(data=request.data) cont = Game.objects.all().count() validador_de_entradas(games_serializer, cont) return Response(games_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def game_list(request): if request.method == 'GET': games = Game.objects.all() games_serializer = GameSerializer(games, many=True) return JSONResponse(games_serializer.data) elif request.method == 'POST': game_data = JSONParser().parse(request) game_serializer = GameSerializer(data=game_data) if game_serializer.is_valid(): game_serializer.save() return JSONResponse(game_serializer.data, status=status.HTTP_201_CREATED) return JSONResponse(game_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def game_detail(request, pk): try: game = Game.objects.get(pk=pk) except Game.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) games = Game.objects.all() games_serializer = GameSerializer(games, many=True) tam = len(games_serializer.data) nomes = [] i = tam - 1 for nome in games_serializer.data: nome = games_serializer.data[i]['name'] nomes.append(nome) i = i - 1 if request.method == 'GET': game_serializer = GameSerializer(game) return Response(game_serializer.data) elif request.method == 'PUT': game_serializer = GameSerializer(game, data=request.data) if game_serializer.is_valid(): if (game_serializer.validated_data['name'] in nomes): return Response("Já existe jogo com esse nome!") game_serializer.save() return Response(game_serializer.data) return Response(game_serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': if game.played == True: return Response("O jogo não pode ser excluído!") game.delete() return Response(status=status.HTTP_204_NO_CONTENT)
def confirm_payment(self,request,identifier=None): source = get_object_or_404(User,pk=request.data['source_id']) amount = request.data['amount'] target = get_object_or_404(User,pk=request.data['target_id']) if source == target: #TODO:should be error return #TODO: also check if amount bigger than result amount bet = get_object_or_404(Bet,game__identifier=identifier,player=target) payment, created = Payment.objects.get_or_create( source=source, bet=bet, defaults={'amount':amount} ) #overrides amount if not equal if not created: payment.amount = amount payment.save() serializer = GameSerializer(context={'request': request}, instance=bet.game) pusher_client.trigger(bet.game.identifier, 'game-update', {'game': serializer.data}); return Response(serializer.data)
class DossierRoleSerializer(serializers.ModelSerializer): guild = GuildSerializer(read_only=True) guild_id = serializers.PrimaryKeyRelatedField(source='guild', queryset=Guild.objects.all()) game = GameSerializer(read_only=True) game_id = serializers.PrimaryKeyRelatedField(source='game', queryset=Game.objects.all()) class Meta: model = DossierRole fields = ( 'id', 'role', 'created', 'duration', 'guild', 'guild_id', 'game', 'game_id', ) read_only_fields = ( 'id', 'created', 'duration', 'guild', 'game', )
def games_list(request): """ List all code snippets, or create a new snippet. """ if request.method == 'GET': games = Game.objects.all() serializer = GameSerializer(games, many=True) return JSONResponse(serializer.data) elif request.method == 'POST': data = JSONParser().parse(request) serializer = GameSerializer(data=data) if serializer.is_valid(): serializer.save() return JSONResponse(serializer.data, status=201) return JSONResponse(serializer.errors, status=400)
def get_detailed_info(request, id): game = Game.objects.filter(id=id).first() if game is not None: serializer = GameSerializer(game) return Response(serializer.data, status=200) else: return Response({'error': "Given game doesn't exist"}, status=404)
def join_game(self,request,identifier=None): #TODO: check if user already in the game if request.data['player_id']: player = get_object_or_404(User,pk=request.data['player_id']) else: player = request.user game = Game.objects.get(identifier=identifier) bet, created = Bet.objects.get_or_create( game=game, player=player, ) if created: #created, set bet to game's bet #TODO: allow for special cases? bet.amount = game.min_bet bet.save() #TODO: this is an example of how it works. this should be used in the payView when ready #send push notifications: # for b in bet.game.bets.exclude(player__push_token__isnull=True) # notifications.send_push_message(b.player.push_token, str(player) + " joined your game",{game_identifier:identifier}) serializer = GameSerializer(context={'request': request},instance=game) pusher_client.trigger(game.identifier, 'game-update', {'game': serializer.data}); return Response(serializer.data)
def handle(self, *args, **kwargs): file_name = kwargs['file'] file_path = os.path.join(getattr(settings, "GAMES_CSV_PATH"), file_name) cnt = 0 with open(file_path, 'r') as file: for row in csv.DictReader(file): if not row['genre'].strip(): row['genre'] = 'null' serialized_data = GameSerializer(data=row) if serialized_data.is_valid(): # save if the data has no errors serialized_data.save() cnt += 1 else: raise ValueError("File contains invalid record.") self.stdout.write(f"Successfully uploaded {cnt} records from {file_name}.")
async def send_game_update(self): game = await self.game await self.channel_layer.group_send( self.game_group, { 'type': 'game_update', 'data': GameSerializer().to_representation(game) })
def player_games(request): if request.method == 'GET': player = Player.objects.get(user=request.user) games = Game.objects.filter( game_score__player__user__pk=player.user.pk) serializer = GameSerializer(games, many=True) return Response(serializer.data)
class BetSerializer(serializers.ModelSerializer): game = GameSerializer(read_only=True) class Meta: model = Bet fields = ('id', 'game', 'player', 'creation_date', 'type', 'status', 'sum', 'cf')
def get(self, request, pk, format=None): game = self.get_object(pk) serializer = GameSerializer(game) zip_file = open(serializer.data["build"], 'rb') response = FileResponse(zip_file, content_type='application/orce-download') response['Content-Disposition'] = 'attachment; filename=name.zip' return response
def handle(self, *args, **options): data = json.load(options["file"]) game, created = Game.objects.get_or_create( id=data["id"], defaults={"start_datetime": None}) s = GameSerializer(game, data=data, context={"fix_times": options["fix_times"]}) if not s.is_valid(): raise CommandError(s.errors) update_game(game, s.validated_data) if created: print(f"Created game with id {data['id']}") else: print(f"Updated game with id {data['id']}")
def game_detail(request, pk): try: # Read, Update, Delete 객체를 선택한다 game = Game.objects.get(pk=pk) except Game.DoseNotExist: # DB에 객체가 없는 경우 # return HttpResponse(status=status.HTTP_404_NOT_FOUND) return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': # Get 방식은 DB를 읽는다 games_serializer = GameSerializer(game) # game 모든 객체를 직렬화 # return JSONResponse(games_serializer.data) # 직렬화 객체를 JSON으로 출력 return Response(games_serializer.data) elif request.method == 'PUT': # game_data = JSONParser().parse(request) # games_serializer = GameSerializer(game, data=game_data) games_serializer = GameSerializer(game, data=request.data) # 위 2줄을 1줄로 대체 if games_serializer.is_valid(): games_serializer.save() # return JSONResponse(games_serializer.data) return Response(games_serializer.data) # return JSONResponse(games_serializer.errors, status=status.HTTP_400_BAD_REQUEST) return Response(games_serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': game.delete() # return HttpResponse(status=status.HTTP_204_NO_CONTENT) return Response(status=status.HTTP_204_NO_CONTENT)
def game_detail(request,pk): try: game = Game.objects.get(pk = pk) except Game.DoesNotExist: return HttpResponse(status = status.HTTP_404_NOT_FOUND) if request.method == 'GET': game_serializer = GameSerializer(game) return JSONResponse(game_serializer.data) elif request.method == 'POST': game_data = JSONParser().parse(game) game_serializer = GameSerializer(game, data = game_data) if game_serializer.is_valid(): game_serializer.save() return JSONResponse(game_serializer.data) return JSONResponse(game_serializer.errors, status= status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': game.delete() return HttpResponse(status = status.HTTP_204_NO_CONTENT)
def test_retrieving_one_game(self): """Test retrieving a specific game""" res = self.client.get(get_game_detail_url(1)) game = Game.objects.get(pk=1) serializer = GameSerializer(game) self.assertEqual(res.status_code, status.HTTP_200_OK) self.assertEqual(res.data, serializer.data)
def post(self, request, *args, **kwargs): game = self.get_object(kwargs['pk']) serializer = GameSerializer(game) if self.request.data['approved']: game.hasBeenApproved = True game.save() else: game.delete() return Response(serializer.data)
def test_retreive_games(self): """Test retrieving all the games""" res = self.client.get(GAMES_URL) games = Game.objects.all().order_by('-name') serializer = GameSerializer(games, many=True) self.assertEqual(res.status_code, status.HTTP_200_OK) self.assertEqual(res.data, serializer.data)
class FullAwardSummarySerializer(serializers.ModelSerializer): award_categories = AwardCategorySummarySerializer(many=True) game = GameSerializer(read_only=True) class Meta: model = Chapter fields = ( 'id', 'game', 'award_categories', )
def game_list(request): games = Game.objects.all() games_serializer = GameSerializer(games, many=True) tam = len(games_serializer.data) nomes = [] i = tam - 1 for nome in games_serializer.data: nome = games_serializer.data[i]['name'] nomes.append(nome) i = i - 1 if request.method == 'GET': return Response(games_serializer.data) elif request.method == 'POST': game_serializer = GameSerializer(data=request.data) if game_serializer.is_valid(): if (game_serializer.validated_data['name'] in nomes): return Response("O Jogo já existe!") game_serializer.save() return Response(game_serializer.validated_data, status=status.HTTP_201_CREATED) return Response(game_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def game_list(request): if request.method == 'GET': games = Game.objects.all() game_serializer = GameSerializer(games, many=True) return Response(game_serializer.data) elif request.method == 'POST': game_serializer = GameSerializer(data=request.data) if game_serializer.is_valid(): game_serializer.save() return Response(game_serializer.data, status=status.HTTP_201_CREATED) return Response(game_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def game_detail(request, id): try: game = Game.objects.get(id=id) except Game.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': game_serializer = GameSerializer(game) return Response(game_serializer.data) elif request.method == 'PUT': game_serializer = GameSerializer(game, data=request.data) validador_de_entradas(game_serializer, id) return Response(game_serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': if game.release_date > timezone.now(): game.delete() return Response(status=status.HTTP_204_NO_CONTENT) return Response( 'O jogo em questão já foi lançado, por isso não pode ser excluído!', status=status.HTTP_400_BAD_REQUEST)
class BundleSerializer(serializers.ModelSerializer): """Serializer for Games""" games = GameSerializer(many=True) class Meta: """Model and field definitions""" model = Bundle fields = ( 'id', 'name', 'slug', 'created_at', 'games', )
def game_list(request): if request.method == 'GET': games = Game.objects.all() games_serializer = GameSerializer(games, many=True) return JSONResponse(games_serializer.data) elif request.method == 'POST': game_data = JSONParser().parse(request) games_serializer = GameSerializer(data=game_data) if games_serializer.is_valid(): games_serializer.save() return JSONResponse(games_serializer.data, status=status.HTTP_201_CREATED)
def game_detail(request, pk): """ Retrieve, update or delete a code snippet. """ try: game = Game.objects.get(pk=pk) except Game.DoesNotExist: return HttpResponse(status=404) if request.method == 'GET': serializer = GameSerializer(game) return JSONResponse(serializer.data) elif request.method == 'PUT': data = JSONParser().parse(request) serializer = GameSerializer(game, data=data) if serializer.is_valid(): serializer.save() return JSONResponse(serializer.data) return JSONResponse(serializer.errors, status=400) elif request.method == 'DELETE': game.delete() return HttpResponse(status=204)
def confirm_payment_receipt(self,request,identifier=None): payment_id = request.data['payment_id'] payment = get_object_or_404(Payment,pk=payment_id) payment.is_confirmed = True payment.save() game = payment.bet.game serializer = GameSerializer(context={'request': request}, instance=game) pusher_client.trigger(game.identifier, 'game-update', {'game': serializer.data}); return Response(serializer.data)
def leave_game(self,request,identifier=None): if request.data['player_id']: player = get_object_or_404(User,pk=request.data['player_id']) else: player = request.user bet = Bet.objects.get(player=player,game__identifier=identifier) bet.result = request.data['result'] bet.save() serializer = GameSerializer(context={'request': request}, instance=bet.game) pusher_client.trigger(bet.game.identifier, 'game-update', {'game': serializer.data}); return Response(serializer.data)
def game_detail(request, pk): try: game = Game.objects.get(id=pk) except: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == "GET": game_serializer = GameSerializer(game) return Response(game_serializer.data, status=status.HTTP_200_OK) elif request.method == "PUT": game_serializer = GameSerializer(game, data=request.data) if game_serializer.is_valid(): try: games = Game.objects.filter(name=request.data['name']) if not game in games: return Response( {"name": "game already exists in the database"}, status=status.HTTP_400_BAD_REQUEST) else: game_serializer.save() return Response(game_serializer.data) except: game_serializer.save() return Response(game_serializer.data) return Response(game_serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == "DELETE": utc = pytz.UTC date2 = utc.localize(datetime.now()) print(date2) # date1 = utc.localize(game.release_date) # print(date1) if game.release_date > date2: game.delete() return Response(status=status.HTTP_204_NO_CONTENT) return Response({"date_release": "Game has been released"}, status=status.HTTP_401_UNAUTHORIZED)
def approve_game(self,request,identifier=None): game = get_object_or_404(Game,identifier=identifier) is_approved = request.data['is_approved'] #make sure input val is boolean if not isinstance(is_approved, bool): #TODO: should be error return game.is_approved = is_approved game.save() serializer = GameSerializer(context={'request': request}, instance=game) pusher_client.trigger(game.identifier, 'game-update', {'game': serializer.data}); return Response(serializer.data)