def handle(self, *args, **options): try: self.game = models.Game.nearest_game() except models.Game.DoesNotExist: self.stderr.write("No currently-running game found.") Game.objects.create(start_date=settings.NOW()) self.game = models.Game.nearest_game() self.schools = list(models.School.objects.all()) self.dorms = list(models.Building.dorms()) if len(self.schools) == 0 or len(self.dorms) == 0: call_command( 'loaddata', os.path.join('hvz', 'main', 'fixtures', 'campus.json'), stdout=self.stdout, stderr=self.stderr, ) self.schools = list(models.School.objects.all()) self.dorms = list(models.Building.dorms().all()) num_players = options.get('players') or NUM_PLAYERS num_ozs = options.get('ozs') or NUM_OZS self.password = options.get('password') or PASSWORD self.year = settings.NOW().year players = self.make_players(num_players) models.Player.objects.bulk_create(players) self.pick_ozs(num_ozs)
def get_current_mod(cls): sched = cls.objects.filter( start_time__lte=settings.NOW(), end_time__gte=settings.NOW(), ) if sched.exists(): return sched[0].mod return None
def filter_date(self, qs, name, value): season = int(self.form.cleaned_data['season']) date = (settings.NOW() - datetime.timedelta(days=1)).date() date = date.replace(year=season if date.month <= 8 else season - 1) end = datetime.date(season, 12, 31) if value or end >= settings.NOW().date(): qs = qs.filter(date__lte=date) else: date = end self.date = date return qs
def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) occupancy = [] range_qs = self.object_list.filter(end__gte=settings.NOW()) range_qs = range_qs.aggregate(begin=Min('begin'), end=Max('end')) if range_qs['begin'] and range_qs['end']: begin = max(range_qs['begin'], settings.NOW().date()) end = range_qs['end'] for i in range((end - begin).days + 1): day = begin + timedelta(days=i) occupancy.append((day, ) + self.occupancy_for(day, 2) + self.occupancy_for(day, 1)) context['occupancy'] = occupancy return context
def clean(self, *args, **kwargs): cleaned_data = super(MealForm, self).clean(*args, **kwargs) g = Game.imminent_game() # Check that day and time exist if not 'day' in cleaned_data: raise forms.ValidationError("Somehow you didn't specify the day.") if not 'time' in cleaned_data: raise forms.ValidationError("Somehow you didn't select a time.") feed_date = g.start_date + datetime.timedelta( days=int(cleaned_data['day'])) if feed_date < g.start_date: raise forms.ValidationError("Can't have eaten before the game!") if feed_date > g.end_date: raise forms.ValidationError( "Can't have eaten after the game ended!") feed_time = datetime.datetime.combine(feed_date, cleaned_data['time']) if feed_time > settings.NOW(): raise forms.ValidationError("You can't eat in the future, bro.") cleaned_data['time'] = feed_time return cleaned_data
def games(cls, **flags): """Return a list of games satisfying the given arguments. @started: True iff you want a game that began in the past. @finished: True iff you want a game that has not completed yet. @ordered: True iff you want the list of games to be ordered by ascending starting date. """ kwargs = {} today = settings.NOW().date() if 'started' in flags: if flags['started']: kwargs['start_date__lte'] = today else: kwargs['start_date__gt'] = today if 'finished' in flags: if flags['finished']: kwargs['end_date__lt'] = today else: kwargs['end_date__gte'] = today qset = cls.objects.filter(**kwargs) if flags.get('ordered'): return qset.order_by('start_date') return qset
def handle(self, *args, **options): now = settings.NOW() start_date = now.date() # The game starts or started on a Tuesday of this week if start_date.weekday() in (SUNDAY, MONDAY, TUESDAY): start_date -= datetime.timedelta((TUESDAY - start_date.weekday()) % 7) else: start_date += datetime.timedelta((start_date.weekday() - TUESDAY) % 7) end_date = start_date + datetime.timedelta(SATURDAY - TUESDAY) if Game.objects.filter(start_date=start_date, end_date=end_date).exists(): self.stderr.write("You don't need to create a game!") return game = Game(start_date=start_date, end_date=end_date) game.full_clean() game.save() self.stderr.write( "Game created from {:%A %d} to {:%A %d}, {:%B %Y}".format( start_date, end_date, start_date, ) )
def raw_serialization(self, context): game = Game.nearest_game() t0, tf = time_endpoints(game) meals_vs_hours = meals_per_hour(Game.nearest_game(), self.get_queryset()) histogram = [] for hour in xrange(len(meals_vs_hours)): t = t0 + timedelta(hours=hour) # Stop at the current time if t > settings.NOW(): break histogram.append([json_format_time(t), meals_vs_hours[hour]]) # Pre-game case if not histogram: histogram = [[json_format_time(t0), 0]] return [{ "data": histogram, "color": "rgb(0, 128, 0)", }]
def get_offset(): """Return the number of days since game start.""" try: g = Game.imminent_game() except Game.DoesNotExist: return 0 return (settings.NOW().date() - g.start_date).days
def json_tag_histogram(request): context = models.Meal.objects.filter( eater__game=models.Game.nearest_game(), time__isnull=False, ) game = models.Game.nearest_game() t0, tf = time_endpoints(game) meals_vs_hours = meals_per_hour( models.Game.nearest_game(), context, ) histogram = [] for hour in range(len(meals_vs_hours)): t = t0 + dt.timedelta(hours=hour) # Stop at the current time if t > settings.NOW(): break histogram.append([json_format_time(t), meals_vs_hours[hour]]) # Pre-game case if not histogram: histogram = [[json_format_time(t0), 0]] return mixins.json_response([{ "data": histogram, "color": "rgb(0, 128, 0)", }])
def serie(self, season, GET): self.today = (settings.NOW() - timedelta(days=1)).date() start = date(season - 1, 9, 1) end = min(date(season, 8, 31), self.today) qs = Adhesion.objects.filter(season=season) if GET['sector'] == '1': qs = qs.exclude(structure__number__in=SVN_NUMBERS + CPN_NUMBERS) elif GET['sector'] == '2': qs = qs.filter(structure__number__in=SVN_NUMBERS) elif GET['sector'] == '3': qs = qs.filter(structure__number__in=CPN_NUMBERS) if GET['units'] == '99': qs = qs.exclude(structure__type__in=(1, 2, 7, 13)) elif GET['units']: qs = qs.filter(structure__type=GET['units']) if GET['function']: qs = qs.filter(nomination__function__category=GET['function'], nomination__main=True) if GET['rate']: qs = qs.filter(rate__category=GET['rate']) qs = qs.order_by('-date').values('date').annotate( headcount=Count('id')) qs = list(qs) data = OrderedDict() dates = [ start + timedelta(days=n) for n in range((end - start).days + 1) ] acc = 0 for d in dates: if qs and qs[-1]['date'] == d: acc += qs.pop()['headcount'] if d.month == 2 and d.day == 29: continue data[d] = acc return data
def save(self, commit=False): def grab(s): return self.cleaned_data[s] game = Game.nearest_game() player = Player.user_to_player(self.user, game) self.thread = Thread( game=game, team=grab('team'), title=grab('title'), slug=slugify(grab('title')), ) self.thread.save() post = Post( author=player, thread=self.thread, body=grab('post_body'), created=settings.NOW(), ) if commit: post.save() return self.thread
def get_nearest_hour(): now = settings.NOW() return datetime.datetime( now.year, now.month, now.day, now.hour, )
def get_visible(cls, game, team): """Returns all plots visible to the given team during the given game.""" return cls.objects.filter( Q(visible=True) | Q(visible__isnull=True, reveal_time__lt=settings.NOW()), team=team, mission__game=game, ).exclude(before_story='').exclude(before_story__isnull=True)
def __init__(self, data, *args, **kwargs): data = data.copy() data.setdefault('season', current_season()) if kwargs.pop('ref', False): data['season'] = int(data['season']) - 1 super(AdhesionFilter, self).__init__(data, *args, **kwargs) date = (settings.NOW() - datetime.timedelta(days=1)).date() self.filters['date2date'].label = "Au {}".format( date.strftime('%d/%m'))
def save(self): if not self.time: self.time = settings.NOW() self.eaten.team = "Z" self.eater.brains += 1 with transaction.atomic(): self.eaten.save() self.eater.save() return super(Meal, self).save()
def save(self, commit=False): post = Post( author=self.player, thread=self.thread, body=self.cleaned_data['body'], created=settings.NOW(), ) if commit: post.save() return post
def adhesion(self): today = settings.NOW() if today.month < 9: seasons = (today.year, ) elif today.month == 9: seasons = (today.year, today.year + 1) else: seasons = (today.year + 1, ) try: return self.adhesions.filter(season__in=seasons).latest('season') except Adhesion.DoesNotExist: return None
def save(self): self.eaten.team = "Z" if not self.time: self.time = settings.NOW() self.eaten.clan = self.eater.clan self.eaten.save() self.eater.brains += 1 self.eater.save() return super(Meal, self).save()
def create_new_game(game_start=None): """Create a Game starting today and lasting a week.""" if game_start is None: game_start = settings.NOW().date() g = models.Game( start_date=game_start, end_date=game_start + timedelta(6), ) g.full_clean() g.save() return g
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.fields['year'].initial = settings.NOW().year self.helper = FormHelper() self.helper.form_class = 'form-inline' self.helper.field_template = 'bootstrap3/layout/inline_field_with_label.html' self.helper.form_method = 'get' self.helper.layout = Layout( 'structure', 'year', 'org_type', InlineCheckboxes('state'), )
def test_visibility_override(self): """A false visibility should prevent us from seeing a mission.""" c = Client() human_plot = Plot.objects.get(team='H') human_plot.visible = False human_plot.reveal_time = settings.NOW() - timedelta(hours=1) human_plot.save() # We should not see any missions. c.post(reverse('login'), HUGH_MANN) response = c.get(reverse('plot_list')) self.assertFalse(response.context_data['plot_list'])
def get_context_data(self): season = current_season() date = (settings.NOW() - timedelta(days=1)).date() leap_year = date.month == 2 and date.day == 29 ref_date = date.replace(year=date.year - 1, day=28 if leap_year else date.day) nb_groups = self.get_nb_groups(season, date) ref_nb_groups = self.get_nb_groups(season - 1, ref_date) return { 'nb_groups': nb_groups, 'nb_groups_diff': (100 * (nb_groups - ref_nb_groups) / ref_nb_groups) if ref_nb_groups else 0, }
def raw_serialization(self, context): game = Game.nearest_game() t0, tf = time_endpoints(game) players = Player.current_players().all() meals = Meal.objects.select_related('eaten').all() eaten_zombies = set([m.eaten for m in meals]) ozs = [p for p in players if p.team == 'Z' and p not in eaten_zombies] num_zombies = len(ozs) num_humans = len(players) - num_zombies human_tally = [] zombie_tally = [] meals_vs_hours = meals_per_hour(game, self.get_queryset()) for hour in xrange(len(meals_vs_hours)): t = t0 + timedelta(hours=hour) # Stop the graph at the current time if t > settings.NOW(): break meal_count = meals_vs_hours[hour] num_humans -= meal_count num_zombies += meal_count human_tally.append([json_format_time(t), num_humans]) zombie_tally.append([json_format_time(t), num_zombies]) if not human_tally: human_tally = [[json_format_time(t0), num_humans]] if not zombie_tally: zombie_tally = [[json_format_time(t0), num_zombies]] return [ { 'label': 'humans', 'data': human_tally, 'color': 'rgb(128, 0, 0)' }, { 'label': 'zombies', 'data': zombie_tally, 'color': 'rgb(0, 128, 0)' }, ]
def weekday_choices(): """Returns a list of offsets from the start of the current game.""" try: g = Game.imminent_game() except Game.DoesNotExist: return [(i, CAL.formatweekday(i, 3)) for i in xrange(7)] # Bounds on when the meal can have occurred start = g.start_date end = min(settings.NOW().date(), g.end_date) return ((i, CAL.formatweekday((start + datetime.timedelta(days=i)).weekday(), 3)) for i in range((end - start).days + 1))
def test_visibility_restriction(self): """We should be able to see a mission with a reveal time in the past.""" c = Client() # Set a revealed mission human_plot = Plot.objects.get(team='H') human_plot.visible = None human_plot.reveal_time = settings.NOW() - timedelta(hours=1) human_plot.save() # Check for visibility c.post(reverse('login'), HUGH_MANN) response = c.get(reverse('plot_list')) self.assertTrue(response.context_data['plot_list'])
def test_future_reveal_times(self): """We shouldn't see a mission if its reveal time is in the future.""" c = Client() # Set a revealed mission human_plot = Plot.objects.get(team='H') human_plot.visible = None human_plot.reveal_time = settings.NOW() + timedelta(hours=1) human_plot.save() # Check for visibility c.post(reverse('login'), HUGH_MANN) response = c.get(reverse('plot_list')) self.assertFalse(response.context_data['plot_list'])
def setUpClass(cls): """Create an initial game and tabler.""" # Create a current Game. cls._game_start = settings.NOW().date() cls.create_new_game(cls._game_start) tabler = auth_models.User.objects.create_user( username="******", password="******", ) ts = auth_models.Group.objects.create(name="Tablers") ts.permissions.add( auth_models.Permission.objects.filter(codename="add_player").get()) ts.user_set.add(tabler) ts.save()
def get_context_data(self): season = current_season() date = (settings.NOW() - timedelta(days=1)).date() leap_year = date.month == 2 and date.day == 29 ref_date = date.replace(year=date.year - 1, day=28 if leap_year else date.day) qs = Adhesion.objects.filter(season=season, date__lte=date) qs = qs.aggregate(revenue=Sum('rate__rate')) ref_qs = Adhesion.objects.filter(season=season - 1, date__lte=ref_date) ref_qs = ref_qs.aggregate(revenue=Sum('rate__rate')) return { 'revenue': (qs['revenue'] or 0) / 1000, 'revenue_diff': (100 * (qs['revenue'] - ref_qs['revenue']) / ref_qs['revenue']) if (qs['revenue'] and ref_qs['revenue']) else 0, }
def clean(self): if self.eaten.team != "H": raise ValidationError("Victim is not a human.") if self.eater.game != self.eaten.game: raise ValidationError( "Eater's game is {}, victim's game is {}.".format( self.eater.game, self.eaten.game)) if self.time: validators.validate_past(self.time) validators.DateValidator(self.eater.game)(self.time.date()) else: self.time = settings.NOW() return super(Meal, self).clean()