def get(self, request): game = most_recent_game() return self.mobile_or_desktop( request, { 'game': game, 'participant': request.user.participant(game) })
def handle(self, *args, **options): game = most_recent_game() unclaimed_codes = SupplyCode.objects.filter(game=game, claimed_by__isnull=True) for code in unclaimed_codes: code.active = False code.save()
def post(self, request): game = most_recent_game() participant = request.user.participant(game) message_players_form = MessagePlayersForm(request.POST, player=participant) if not message_players_form.is_valid(): return self.get(request, message_players_form=message_players_form) cd = message_players_form.cleaned_data recipients = [] if cd['recipients'] == "All": recipients = Player.objects \ .filter(game=game, active=True) \ .values_list('user__email', flat=True) elif cd['recipients'] == "Zombies": if not participant.is_zombie: messages.error(request, "Only zombies can email only zombies.") return redirect('message_players') recipients = Player.objects \ .filter(game=game, active=True, role=PlayerRole.ZOMBIE) \ .values_list('user__email', flat=True) EmailMultiAlternatives( subject=f"Message from {request.user.get_full_name()}", body=cd['message'], from_email=settings.DEFAULT_FROM_EMAIL, to=[], bcc=recipients).send() if cd['recipients'] == "All": messages.success(request, "You've sent an email to all players.") elif cd['recipients'] == "Zombies": messages.success(request, "You've sent an email to all zombies.") return redirect('message_players')
def post(self, request, signup_invite): game = most_recent_game() invite = SignupInvite.objects.get(pk=signup_invite) forced_role = invite.participant_role in_oz_pool = request.POST.get('is_oz', 'off') == 'on' has_signed_waiver = request.POST.get('accept_waiver', 'off') == 'on' if not has_signed_waiver: messages.warning(request, "Please sign the waiver.") return self.get(request) if request.user.participant(game): messages.warning(request, f"You're already signed up for the {game} game.") return redirect('dashboard') if forced_role: if forced_role == ParticipantRole.MODERATOR: Moderator.objects.create_moderator(request.user, game) elif forced_role == ParticipantRole.SPECTATOR: Spectator.objects.create_spectator(request.user, game) else: equivalent_role = PlayerRole.HUMAN if forced_role == ParticipantRole.HUMAN else PlayerRole.ZOMBIE Player.objects.create_player(request.user, game, equivalent_role) else: Player.objects.create_player(request.user, game, PlayerRole.HUMAN, in_oz_pool=in_oz_pool) messages.success( request, f"You've successfully signed up for the {game} game.") return redirect('dashboard')
def get(self, request): game = most_recent_game() participants = get_game_participants(game) spectators = Spectator.objects.filter(game=game) moderators = Moderator.objects.filter(game=game) humans = Player.objects.filter(game=game, active=True, role=PlayerRole.HUMAN) zombies = Player.objects.filter(game=game, active=True, role=PlayerRole.ZOMBIE) all_emails = [p.user.email for p in participants] spectator_emails = [s.user.email for s in spectators] moderator_emails = [m.user.email for m in moderators] human_emails = [h.user.email for h in humans] + spectator_emails + moderator_emails zombie_emails = [z.user.email for z in zombies ] + spectator_emails + moderator_emails return render( request, self.template_name, { 'game': game, 'participant': request.user.participant(game), 'all_emails': all_emails, 'human_emails': human_emails, 'zombie_emails': zombie_emails, })
def get_context(self, request, *args, **kwargs): context = super(AnnouncementPage, self).get_context(request) game = most_recent_game() participant = request.user.participant(game) context['participant'] = participant context['game'] = game return context
def post(self, request): report_tag_form = ReportTagForm(request.POST) if not report_tag_form.is_valid(): return render_player_info(request, report_tag_form=report_tag_form) game = most_recent_game() initiating_player = request.user.participant(game) cleaned_data = report_tag_form.cleaned_data receiver_code = cleaned_data['player_code'].upper() try: receiving_player = Player.objects.get(code=receiver_code, active=True) except ObjectDoesNotExist: report_tag_form.add_error('player_code', "No player with that code exists.") return render_player_info(request, report_tag_form=report_tag_form) tag_modifier_amount = 0 try: tag_modifier = Modifier.objects.get( faction=initiating_player.faction, modifier_type=ModifierType.TAG) tag_modifier_amount = tag_modifier.modifier_amount except ObjectDoesNotExist: pass if Tag.objects.filter( initiator=initiating_player, receiver=receiving_player, tagged_at=cleaned_data['datetime'], location=cleaned_data['location'], description=cleaned_data['description']).exists(): return redirect('player_info') try: tag = Tag.objects.create_tag(initiating_player, receiving_player, cleaned_data['datetime'], cleaned_data['location'], cleaned_data['description'], tag_modifier_amount) except ValueError as err: messages.error(request, err) return redirect('player_info') if initiating_player.is_human: send_stun_email(request, tag) messages.success( request, f"You've successfully submitted a stun on {receiving_player.user.get_full_name()}." ) else: send_tag_email(request, tag) messages.success( request, f"You've successfully submitted a tag on {receiving_player.user.get_full_name()}." ) return redirect('player_info')
def get(self, request): # While it would be nice to use running_game_required and player_required # due to the fact that we redirect here from login for all users we must # account for spectators/moderators and when the game isn't running as well. game = most_recent_game() if not game.is_running or not request.user.participant( game) or not request.user.participant(game).is_player: return redirect('dashboard') return render_player_info(request)
def get(self, request): game = most_recent_game() supply_codes = SupplyCode.objects.filter(game=game, active=True) return render( request, self.template_name, { 'game': game, 'participant': request.user.participant(game), 'supply_codes': supply_codes })
def get(self, request): game = most_recent_game() players = Player.objects.filter( game=game, in_oz_pool=True).order_by('user__first_name') return render( request, self.template_name, { 'game': game, 'participant': request.user.participant(game), 'players': players })
def get(self, request): game = most_recent_game() participant = request.user.participant(game) participants = get_game_participants(game).order_by('user__first_name') return render(request, self.template_name, { 'game': game, 'participant': participant, 'participants': participants })
def get(self, request, **kwargs): game = most_recent_game() participant = request.user.participant(game) message_players_form = kwargs.get( 'message_players_form', MessagePlayersForm(player=participant)) return render( request, self.template_name, { 'game': game, 'participant': participant, 'message_players_form': message_players_form })
def post(self, request): minimum_score_threshold = 5 game = most_recent_game() human_players = Player.objects.filter(game=game, role=PlayerRole.HUMAN, active=True) for human in human_players: if human.score() < minimum_score_threshold: human.kill() return redirect('manage_game')
def get(self, request): game = most_recent_game() participant = request.user.participant(game) if not participant: return redirect('dashboard') if not request.user.is_staff and participant.is_player and participant.is_human: raise PermissionDenied player_codes = {} nodes = [] edges = [] ozs = set() all_zombies = Player.objects.filter(game=game, role=PlayerRole.ZOMBIE, active=True) for zombie in all_zombies: # We mutate the OZs' role rather than setting inactive, so an OZ won't have # an inactive human player. if not Player.objects.filter(game=game, code=zombie.code, role=PlayerRole.HUMAN).exists(): ozs.add(zombie) nodes.append({'id': 'NECROMANCER', 'label': "Necromancer"}) for oz in ozs: edges.append({'from': 'NECROMANCER', 'to': oz.code}) player_codes[oz.code] = oz.user.get_full_name() tags = Tag.objects.filter(initiator__game=game, receiver__game=game, initiator__role=PlayerRole.ZOMBIE, receiver__role=PlayerRole.HUMAN, active=True) for tag in tags: edges.append({'from': tag.initiator.code, 'to': tag.receiver.code}) player_codes[ tag.initiator.code] = tag.initiator.user.get_full_name() player_codes[tag.receiver.code] = tag.receiver.user.get_full_name() for code, name in player_codes.items(): nodes.append({'id': code, 'label': name}) return render( request, self.template_name, { 'game': game, 'participant': participant, 'nodes': json.dumps(nodes), 'edges': json.dumps(edges), })
def render_signup_players( self, request, volunteer_signup_player_form=VolunteerSignupPlayerForm()): game = most_recent_game() locations = SignupLocation.objects.filter(game=game) return render( request, self.template_name, { 'game': game, 'participant': request.user.participant(game), 'signup_locations': locations, 'volunteer_signup_player_form': volunteer_signup_player_form })
def render_manage_players( self, request, mod_signup_player_form=ModeratorSignupPlayerForm()): game = most_recent_game() participants = get_game_participants(game).order_by('user__first_name') locations = SignupLocation.objects.filter(game=game) return render( request, self.template_name, { 'game': game, 'participant': request.user.participant(game), 'participants': participants, 'signup_locations': locations, 'mod_signup_player_form': mod_signup_player_form })
def is_viewable_by(self, participant) -> bool: game = most_recent_game() if self.game != game or not participant: return False if self.viewable_by == ViewableBy.ALL.value: return True if self.viewable_by == ViewableBy.HUMANS.value and participant.is_player and participant.is_human: return True if self.viewable_by == ViewableBy.ZOMBIES.value and participant.is_player and participant.is_zombie: return True if participant.is_spectator or participant.is_moderator or participant.user.is_staff: return True return False
def get_context(self, request, *args, **kwargs): context = super(GameInfoPage, self).get_context(request) game = most_recent_game() participant = request.user.participant(game) context['is_mobile'] = request.user_agent.is_mobile context['participant'] = participant context['game'] = game announcements = self.get_children().type(AnnouncementPage).live().order_by('-first_published_at') viewable_announcements = [a for a in announcements if a.specific.is_viewable_by(participant)] context['announcements'] = viewable_announcements missions = self.get_children().type(MissionPage).live().order_by('-first_published_at') viewable_missions = [m for m in missions if m.specific.is_viewable_by(participant)] context['missions'] = viewable_missions return context
def post(self, request): volunteer_signup_player_form = VolunteerSignupPlayerForm(request.POST) if not volunteer_signup_player_form.is_valid(): return self.render_signup_players( request, volunteer_signup_player_form=volunteer_signup_player_form) game = most_recent_game() cleaned_data = volunteer_signup_player_form.cleaned_data location, email = cleaned_data['location'], cleaned_data['email'] signup_invite = SignupInvite.objects.create_signup_invite( game, location, email) send_signup_email(request, signup_invite, game) messages.success(request, f"Sent a signup email to {email}.") return redirect('signup_players')
def post(self, request): mod_signup_player_form = ModeratorSignupPlayerForm(request.POST) if not mod_signup_player_form.is_valid(): return self.render_manage_players( request, mod_signup_player_form=mod_signup_player_form) game = most_recent_game() cleaned_data = mod_signup_player_form.cleaned_data location, email, participant_role = cleaned_data[ 'location'], cleaned_data['email'], cleaned_data[ 'participant_role'] signup_invite = SignupInvite.objects.create_signup_invite( game, location, email, participant_role) send_signup_email(request, signup_invite, game) messages.success(request, f"Sent a signup email to {email}.") return redirect('manage_players')
def post(self, request): game = most_recent_game() in_oz_pool = request.POST.get('is_oz', 'off') == 'on' has_signed_waiver = request.POST.get('accept_waiver', 'off') == 'on' if not has_signed_waiver: messages.warning(request, "Please sign the waiver.") return self.get(request) if request.user.participant(game): messages.warning(request, f"You're already signed up for the {game} game.") return redirect('dashboard') Player.objects.create_player(request.user, game, PlayerRole.HUMAN, in_oz_pool=in_oz_pool) return redirect('dashboard')
def get(self, request): game = most_recent_game() if request.user.participant(game): return redirect('dashboard') if game.is_running: messages.warning( request, "The game has already started please contact a mod.") return redirect('dashboard') if game.is_finished: messages.warning(request, "The game is over.") return redirect('dashboard') return render(request, "registration/game_signup.html", { 'game': game, 'participant_role': None })
def render_player_info(request, report_tag_form=ReportTagForm(), claim_supply_code_form=ClaimSupplyCodeForm()): template_name = "mobile/dashboard/player.html" if request.user_agent.is_mobile else "dashboard/player.html" game = most_recent_game() participant = request.user.participant(game) team_score = sum([ p.score() for p in Player.objects.filter(game=game, role=participant.role) ]) return render( request, template_name, { 'game': game, 'participant': participant, 'team_score': team_score, 'report_tag_form': report_tag_form, 'claim_supply_code_form': claim_supply_code_form, })
def get(self, request, signup_invite): game = most_recent_game() invite = SignupInvite.objects.get(pk=signup_invite) forced_role = invite.participant_role if request.user.participant(game): messages.warning(request, "You're already signed up for the game.") return redirect('dashboard') if game.is_running and not forced_role: messages.warning( request, "The game has already started please contact a mod.") return redirect('dashboard') if game.is_finished: messages.warning(request, "The game is over.") return redirect('dashboard') return render(request, "registration/game_signup.html", { 'game': game, 'participant_role': forced_role })
def post(self, request): claim_supply_code_form = ClaimSupplyCodeForm(request.POST) if not claim_supply_code_form.is_valid(): return render_player_info( request, claim_supply_code_form=claim_supply_code_form) game = most_recent_game() player = request.user.participant(game) cleaned_data = claim_supply_code_form.cleaned_data cleaned_supply_code = cleaned_data['code'].upper() try: supply_code = SupplyCode.objects.get(game=game, code=cleaned_supply_code, claimed_by__isnull=True, active=True) except ObjectDoesNotExist: claim_supply_code_form.add_error( 'code', "That supply code does not exist or has already been redeemed." ) return render_player_info( request, claim_supply_code_form=claim_supply_code_form) if not player.is_human: messages.error(request, "Only humans can redeem supply codes.") return redirect('player_info') supply_code_modifier_amount = 0 try: supply_code_modifier = Modifier.objects.get( faction=player.faction, modifier_type=ModifierType.SUPPLY_CODE) supply_code_modifier_amount = supply_code_modifier.modifier_amount except ObjectDoesNotExist: pass supply_code.claim(player, supply_code_modifier_amount) messages.success(request, "The code has been redeemed successfully.") return redirect('player_info')
def get(self, request): game = most_recent_game() return self.mobile_or_desktop(request, {'game': game})
def get_signup_locations(): return ((x.id, x) for x in SignupLocation.objects.filter(game=most_recent_game()))
def post(self, request): game = most_recent_game() supply_code = SupplyCode.objects.create_supply_code(game) messages.success(request, f"Generated new supply code \"{supply_code}\".") return redirect('generate_supply_codes')