def test_is_after_noon(self):
Customize.objects.all().delete()
now = timezone.now()
now = now.time().strftime('%H:%M')
noon = timezone.now().time().replace(hour=12, minute=30, second=0).strftime('%H:%M')
if now >= noon:
self.assertEqual(dateManager.current_vote_day(), datetime.date.today() + datetime.timedelta(days=1))
else:
self.assertEqual(dateManager.current_vote_day(), timezone.now().date())
def delete_all_inactive_absences(self):
logger.debug("delete all absences that are not active / old")
current_vote_day = dateManager.current_vote_day()
absences = self.absence_DAO.get_absences()
for absence in absences:
if absence.absenceTo < current_vote_day:
self.absence_DAO.delete_absence(absence)
def delete_old_and_current_absences_for_user(self, user):
logger.debug("delete absences for user: %s that are old or current active" % user.username)
current_vote_day = dateManager.current_vote_day()
user_absences_for_reason = self.absence_DAO.get_absences_from_user(user)
for absence in user_absences_for_reason.filter(absenceFrom__lte=current_vote_day):
self.absence_DAO.delete_absence(absence)
def get_active_absent_absences_from_team(self, team):
logger.debug("get active absent absences")
current_vote_day = dateManager.current_vote_day()
absences = self.absence_DAO.get_absences_from_team_for_reason(Reasons.ABSENT, team)
active_absences = []
for absence in absences:
if self.check_if_a_absence_is_active_for_date([absence], current_vote_day):
active_absences.append(absence)
return active_absences
def save_new_absence(request):
logger.debug("save absence")
context = get_standard_context()
if request.method == 'POST':
form = AbsenceForm(request.POST)
if form.is_valid():
form.clean()
new_absence = form.save(commit=False)
new_absence.user = request.user
new_absence.reason = Reasons.ABSENT.value
new_absence.save()
absence_logic.delete_vote_absence_for_user(request.user,
new_absence.absenceFrom)
logger.info(
"form is valid, save absence %s for user: %s and delete old one"
% (new_absence, request.user.username))
if new_absence.absenceFrom <= dateManager.current_vote_day():
logger.debug("User voted, we need to delete that votes")
vote_logic.delete_votes_from_user(request.user)
return HttpResponseRedirect(reverse('main:absenceIndex'))
else:
logger.warn("Form was not valid")
context['absence_form'] = form
return render(request, 'templates/absenceIndex.html', context)
def set_vote_absence_for_user(self, user, reason):
logger.info("set (vote) absence for User: %s with reason %s" % (user.username, reason.value))
current_vote_day = dateManager.current_vote_day()
self.delete_old_and_current_absences_for_user(user)
self.absence_DAO.set_absence_for_user(user, current_vote_day, current_vote_day, reason)
class AbsenceLogicTest(TestCase):
absence_logic = AbsenceLogic()
absence_dao = AbsenceDAO()
today = dateManager.today()
tomorrow = dateManager.tomorrow()
yesterday = dateManager.today() + datetime.timedelta(days=-1)
current_vote_date = dateManager.current_vote_day()
def setUp(self):
team = Team.objects.create(team_name="TestTeam")
test_user = User.objects.create(username='******', is_staff=True)
test_user.set_password('12345')
test_user.team = team
test_user.save()
test_user_second = User.objects.create(username='******', is_staff=True)
test_user_second.set_password('12345')
test_user_second.team = team
test_user_second.save()
test_user_third = User.objects.create(username='******', is_staff=True)
test_user_third.set_password('12345')
test_user_third.team = team
test_user_third.save()
Absence.objects.create(user=test_user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.OUT.value)
Absence.objects.create(user=test_user_second,
absenceFrom=self.tomorrow,
absenceTo=self.tomorrow,
reason=Reasons.OUT.value)
Absence.objects.create(user=test_user_third,
absenceFrom=self.yesterday,
absenceTo=self.yesterday,
reason=Reasons.OUT.value)
# other User absence with different team does not effect absences for TestTeam
other_team = Team.objects.create(team_name="other_team")
other_user = User.objects.create(username='******', is_staff=True)
other_user.set_password('12345')
other_user.team = team
Absence.objects.create(user=other_user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.OUT.value)
def test_check_if_a_absence_is_active_for_date(self):
absence = [Absence.objects.get(user__username='******')]
self.assertTrue(self.absence_logic.check_if_a_absence_is_active_for_date(absence, self.today))
self.assertFalse(self.absence_logic.check_if_a_absence_is_active_for_date(absence, self.tomorrow))
def test_delete_old_absence_for_user(self):
absence_first_user = Absence.objects.get(user__username='******')
absence_second_user = Absence.objects.get(user__username='******')
firstUser = User.objects.get(username='******')
secondUser = User.objects.get(username='******')
self.absence_logic.delete_old_and_current_absences_for_user(firstUser)
self.assertNotIn(absence_first_user, self.absence_dao.get_absences_from_user(firstUser))
Absence.objects.create(user=firstUser,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.OUT.value)
self.absence_logic.delete_old_and_current_absences_for_user(firstUser)
self.assertIn(absence_second_user, self.absence_dao.get_absences_from_user(secondUser))
def test_set_todays_absence_for_user(self):
self.refresh_absence_databse()
# User does not have any absence -> is after noon absence for tomorrow else for today / reason does not matter
fresh_user = User.objects.create(username='******', is_staff=True)
fresh_user.set_password('12345')
fresh_user.save()
self.absence_logic.set_vote_absence_for_user(user=fresh_user, reason=Reasons.OUT)
absence_from_fresh_user = Absence.objects.filter(user=fresh_user)
self.assertEqual(absence_from_fresh_user.get().absenceFrom, self.current_vote_date)
self.absence_logic.set_vote_absence_for_user(user=fresh_user, reason=Reasons.OUT)
absence_from_fresh_user = Absence.objects.filter(user=fresh_user)
self.assertEqual(absence_from_fresh_user.filter(user=fresh_user).get().absenceFrom, self.current_vote_date)
# Start with clear database
self.refresh_absence_databse()
self.absence_logic.set_vote_absence_for_user(user=fresh_user, reason=Reasons.OUT)
out_absence = Absence.objects.get(user=fresh_user)
self.absence_logic.set_vote_absence_for_user(user=fresh_user, reason=Reasons.DONOTCARE)
all_absences = Absence.objects.all()
# Old absence should be deleted
self.assertNotIn(out_absence, all_absences)
# New absence should be there
do_not_care_absence = Absence.objects.get(user=fresh_user)
self.assertIn(do_not_care_absence, all_absences)
def test_delete_absences_for_user(self):
absences = Absence.objects.all()
self.assertEqual(len(absences), 4)
for a in absences:
self.absence_logic.delete_absences_for_user(a.user, [a.__str__()])
absences = Absence.objects.all()
self.assertEqual(len(absences), 0)
def test_get_active_absent_absences(self):
team = Team.objects.get(team_name="TestTeam")
user = User.objects.get(username='******')
absent = Absence.objects.create(user=user,
absenceFrom=self.today,
absenceTo=self.tomorrow,
reason=Reasons.ABSENT.value)
active_absences = self.absence_logic.get_active_absent_absences_from_team(team)
self.assertEqual(active_absences, [absent])
def test_delete_all_inactive_absences(self):
first_absence = Absence.objects.get(user__username='******')
second_absence = Absence.objects.get(user__username='******')
third_absence = Absence.objects.get(user__username='******')
other_absence = Absence.objects.get(user__username='******')
self.assertEquals([first_absence, second_absence, third_absence, other_absence], list(Absence.objects.all()))
self.absence_logic.delete_all_inactive_absences()
self.assertIn(second_absence, list(Absence.objects.all()))
def test_get_sorted_absent_absences(self):
team = Team.objects.get(team_name="TestTeam")
user = User.objects.get(username='******')
user_two = User.objects.get(username='******')
absence = Absence.objects.create(user=user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.ABSENT.value)
absence_two = Absence.objects.create(user=user_two,
absenceFrom=self.tomorrow,
absenceTo=self.tomorrow,
reason=Reasons.ABSENT.value)
absences = self.absence_logic.get_sorted_absent_absences_for_team(team)
self.assertEqual(absences, {'test_user': [absence], 'test_user_second': [absence_two]})
def test_delete_vote_absence_for_user(self):
self.refresh_absence_databse()
user = User.objects.get(username='******')
absence = Absence.objects.create(user=user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.OUT.value)
self.absence_logic.delete_vote_absence_for_user(user, self.yesterday)
self.assertEqual(list(Absence.objects.all()), [])
def refresh_absence_databse(self):
for a in Absence.objects.all():
a.delete()