def test_default_competition_date(self):
forever = PartySeries.objects.get(name="Forever")
forever_longparty = forever.parties.create(
name="Forever Longparty 2020",
start_date_date=datetime.date(2020, 5, 14),
start_date_precision='d',
end_date_date=datetime.date(2020, 5, 20),
end_date_precision='d',
)
self.assertEqual(forever_longparty.default_competition_date(),
FuzzyDate(datetime.date(2020, 5, 15), 'd'))
forever_futureparty = forever.parties.create(
name="Forever Futureparty 2020",
start_date_date=datetime.date(2020, 5, 17),
start_date_precision='d',
end_date_date=datetime.date(2020, 5, 20),
end_date_precision='d',
)
self.assertEqual(forever_futureparty.default_competition_date(),
FuzzyDate(datetime.date(2020, 5, 17), 'd'))
forever_fuzzyparty = forever.parties.create(
name="Forever Fuzzyparty 2020",
start_date_date=datetime.date(2020, 3, 1),
start_date_precision='m',
end_date_date=datetime.date(2020, 3, 1),
end_date_precision='m',
)
self.assertEqual(forever_fuzzyparty.default_competition_date(),
FuzzyDate(datetime.date(2020, 3, 1), 'm'))
def test_str(self):
self.assertEqual(
str(FuzzyDate(datetime.date(2020, 8, 1), 'd')).strip(),
"1 August 2020")
self.assertEqual(str(FuzzyDate(datetime.date(2020, 8, 1), 'm')),
"August 2020")
self.assertEqual(str(FuzzyDate(datetime.date(2020, 8, 1), 'y')),
"2020")
def test_numeric_format(self):
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 1), 'd').numeric_format(),
"2020-08-01")
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 1), 'm').numeric_format(),
"2020-08")
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 1), 'y').numeric_format(), "2020")
def test_short_format(self):
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 1), 'd').short_format(),
"Aug 2020")
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 1), 'm').short_format(),
"Aug 2020")
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 1), 'y').short_format(), "2020")
def test_date_range_end(self):
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 15), 'd').date_range_end(),
datetime.date(2020, 8, 15))
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 15), 'm').date_range_end(),
datetime.date(2020, 8, 31))
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 15), 'y').date_range_end(),
datetime.date(2020, 12, 31))
def test_date_range_start(self):
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 15), 'd').date_range_start(),
datetime.date(2020, 8, 15))
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 15), 'm').date_range_start(),
datetime.date(2020, 8, 1))
self.assertEqual(
FuzzyDate(datetime.date(2020, 8, 15), 'y').date_range_start(),
datetime.date(2020, 1, 1))
def test_agrees_with(self):
d1 = FuzzyDate(datetime.date(2020, 8, 1), 'd')
d2 = FuzzyDate(datetime.date(2020, 8, 1), 'd')
d3 = FuzzyDate(datetime.date(2020, 8, 2), 'd')
self.assertTrue(d1.agrees_with(None))
self.assertTrue(d1.agrees_with(d2))
self.assertFalse(d1.agrees_with(d3))
m3 = FuzzyDate(datetime.date(2020, 8, 2), 'm')
self.assertTrue(d1.agrees_with(m3))
y1 = FuzzyDate(datetime.date(2020, 1, 1), 'y')
self.assertTrue(y1.agrees_with(d1))
def prods_without_release_date_with_placement(request):
report_name = 'prods_without_release_date_with_placement'
productions = Production.objects.raw('''
SELECT DISTINCT ON (productions_production.id)
productions_production.*,
parties_party.end_date_date AS suggested_release_date_date,
parties_party.end_date_precision AS suggested_release_date_precision,
parties_party.name AS release_detail
FROM
productions_production
INNER JOIN parties_competitionplacing ON (productions_production.id = parties_competitionplacing.production_id)
INNER JOIN parties_competition ON (parties_competitionplacing.competition_id = parties_competition.id AND parties_competition.name <> 'Invitation')
INNER JOIN parties_party ON (parties_competition.party_id = parties_party.id)
WHERE
productions_production.release_date_date IS NULL
AND productions_production.id NOT IN (SELECT record_id FROM maintenance_exclusion WHERE report_name = %s)
ORDER BY productions_production.id, parties_party.end_date_date
''', [report_name])
productions = list(productions)
for production in productions:
production.suggested_release_date = FuzzyDate(production.suggested_release_date_date, production.suggested_release_date_precision)
return render(request, 'maintenance/production_release_date_report.html', {
'title': 'Productions without a release date but with a party placement attached',
'productions': productions,
'report_name': report_name,
'return_to': reverse('maintenance_prods_without_release_date_with_placement'),
})
def prod_soundtracks_without_release_date(request):
report_name = 'prod_soundtracks_without_release_date'
productions = Production.objects.raw('''
SELECT DISTINCT ON (soundtrack.id)
soundtrack.*,
production.release_date_date AS suggested_release_date_date,
production.release_date_precision AS suggested_release_date_precision,
production.title AS release_detail
FROM
productions_production AS soundtrack
INNER JOIN productions_soundtracklink ON (soundtrack.id = productions_soundtracklink.soundtrack_id)
INNER JOIN productions_production AS production ON (productions_soundtracklink.production_id = production.id)
WHERE
soundtrack.release_date_date IS NULL
AND soundtrack.id NOT IN (SELECT record_id FROM maintenance_exclusion WHERE report_name = %s)
ORDER BY
soundtrack.id, production.release_date_date
''', [report_name])
productions = list(productions)
for production in productions:
if production.suggested_release_date_date != None:
production.suggested_release_date = FuzzyDate(production.suggested_release_date_date, production.suggested_release_date_precision)
return render(request, 'maintenance/production_release_date_report.html', {
'title': 'Music with productions attached but no release date',
'productions': productions,
'report_name': report_name,
'return_to': reverse('maintenance_prod_soundtracks_without_release_date'),
})
def prods_with_release_date_outside_party(request):
report_name = 'prods_with_release_date_outside_party'
productions = Production.objects.raw(
'''
SELECT * FROM (
SELECT DISTINCT ON (productions_production.id)
productions_production.*,
parties_party.start_date_date AS party_start_date,
parties_party.end_date_date AS party_end_date,
parties_party.end_date_date AS suggested_release_date_date,
parties_party.end_date_precision AS suggested_release_date_precision,
parties_party.name AS release_detail,
parties_party.end_date_precision AS party_end_date_precision
FROM
productions_production
INNER JOIN parties_competitionplacing ON (productions_production.id = parties_competitionplacing.production_id)
INNER JOIN parties_competition ON (parties_competitionplacing.competition_id = parties_competition.id AND parties_competition.name <> 'Invitation')
INNER JOIN parties_party ON (parties_competition.party_id = parties_party.id)
WHERE
productions_production.release_date_date IS NOT NULL
AND productions_production.release_date_precision = 'd'
ORDER BY productions_production.id, parties_party.end_date_date
) AS releases
WHERE
releases.party_end_date_precision = 'd'
AND (
releases.release_date_date < releases.party_start_date - INTERVAL '14 days'
OR releases.release_date_date > releases.party_end_date + INTERVAL '14 days'
)
AND releases.id NOT IN (SELECT record_id FROM maintenance_exclusion WHERE report_name = %s)
''', [report_name])
productions = list(productions)
for production in productions:
production.suggested_release_date = FuzzyDate(
production.suggested_release_date_date,
production.suggested_release_date_precision)
return render(
request, 'maintenance/production_release_date_report.html', {
'title':
'Productions with a release date more than 14 days away from their release party',
'productions':
productions,
'report_name':
report_name,
'return_to':
reverse('maintenance_prods_with_release_date_outside_party'),
})
def default_competition_date(self):
if self.end_date and self.end_date.precision == 'd':
# assume that competitions were held on the penultimate day of the party
competition_day = self.end_date.date - datetime.timedelta(days=1)
# ...but if that's in the future, use today instead
if competition_day > datetime.date.today():
competition_day = datetime.date.today()
# ...and if that's before the (known exact) start date of the party, use that instead
if self.start_date and self.start_date.precision == 'd' and self.start_date.date > competition_day:
competition_day = self.start_date.date
return FuzzyDate(competition_day, 'd')
else:
# we don't know this party's exact end date, so just use whatever precision of end date
# we know (if indeed we have one at all)
return self.end_date
def test_eq(self):
d1 = FuzzyDate(datetime.date(2020, 8, 1), 'd')
d2 = FuzzyDate(datetime.date(2020, 8, 1), 'd')
m1 = FuzzyDate(datetime.date(2020, 8, 1), 'm')
m2 = FuzzyDate(datetime.date(2020, 8, 2), 'm')
y1 = FuzzyDate(datetime.date(2020, 8, 1), 'y')
y2 = FuzzyDate(datetime.date(2020, 1, 2), 'y')
self.assertTrue(d1 == d2)
self.assertFalse(d1 == m1)
self.assertTrue(m1 == m2)
self.assertTrue(y1 == y2)
def _get_shown_date(self):
if self.shown_date_date and self.shown_date_precision:
return FuzzyDate(self.shown_date_date, self.shown_date_precision)
else:
return None
def _get_end_date(self):
return FuzzyDate(self.end_date_date, self.end_date_precision)
def _get_start_date(self):
return FuzzyDate(self.start_date_date, self.start_date_precision)
def test_passing_fuzzy_date(self):
form = FuzzyDateForm(
{'date': FuzzyDate(datetime.date(2000, 3, 15), 'd')})
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data['date'],
FuzzyDate(datetime.date(2000, 3, 15), 'd'))
def _get_release_date(self):
if self.release_date_date and self.release_date_precision:
return FuzzyDate(self.release_date_date,
self.release_date_precision)
else:
return None
def test_valid(self):
form = FuzzyDateForm({'date': '15 march 2000'})
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data['date'],
FuzzyDate(datetime.date(2000, 3, 15), 'd'))
def test_invalid_precision(self):
with self.assertRaises(KeyError):
FuzzyDate(datetime.date(2020, 8, 1), 'x')
