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