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 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)
