728 lines
24 KiB
Python
728 lines
24 KiB
Python
from django.shortcuts import render, redirect
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.http import JsonResponse
|
|
from .models import Workday, Breaks, FreeDays, AbsenceReason, Absence
|
|
from django.utils import timezone
|
|
import requests, csv, os
|
|
from django.templatetags.static import static
|
|
from django.conf import settings
|
|
from datetime import date
|
|
from django.contrib.auth.models import User
|
|
from calendar import monthrange
|
|
import datetime
|
|
import calendar
|
|
from .forms import AddAbsence, ConfirmAbsenceForm, UpdateAbsence
|
|
from django.contrib import messages
|
|
from users.models import UserFullName, UserYearAbsenceInfo
|
|
from users.models import UserTime
|
|
from datetime import timedelta
|
|
from django.db.models.signals import post_save
|
|
from users.signals import save_newabsence
|
|
|
|
# Load freedays
|
|
def loadingFreeDays(plz):
|
|
# Getting land
|
|
|
|
file_path = os.path.join(settings.STATIC_ROOT, 'users/extra/plz_short.csv')
|
|
|
|
land = False
|
|
|
|
with open(file_path, 'rt') as csvfile:
|
|
filecsv = csv.reader(csvfile, delimiter=';')
|
|
for row in filecsv:
|
|
if row[1] == plz:
|
|
land = row[6]
|
|
break;
|
|
|
|
if(land != False):
|
|
# CALCULATE FREEDAYS AS JSON
|
|
year = today = date.today().year
|
|
|
|
|
|
URL = "https://feiertage-api.de/api/"
|
|
PARAMS = {'jahr':year,'nur_land':land}
|
|
r = requests.get(url = URL, params = PARAMS)
|
|
return r.json()
|
|
else:
|
|
return False
|
|
|
|
def get_datetime_range(year, month):
|
|
nb_days = monthrange(year, month)[1]
|
|
return [datetime.date(year, month, day) for day in range(1, nb_days+1)]
|
|
|
|
@login_required
|
|
def AbsenceUpdate(request, pk):
|
|
|
|
if request.method == "GET":
|
|
absence = Absence.objects.get(pk=pk)
|
|
timeinfo_thisyear = list(UserYearAbsenceInfo.objects.filter(year=absence.start.year, user=absence.user))[0]
|
|
try:
|
|
timeinfo_nextyear = list(UserYearAbsenceInfo.objects.filter(year=absence.start.year+1, user=absence.user))[0]
|
|
except:
|
|
timeinfo_nextyear = False
|
|
|
|
context = {
|
|
"active_link" : "abscence",
|
|
"form" : UpdateAbsence(instance=request.user),
|
|
"absence" : absence,
|
|
"timeinfo_thisyear" : timeinfo_thisyear,
|
|
"timeinfo_nextyear" : timeinfo_nextyear,
|
|
"start" : absence.start.strftime("%d.%m.%Y"),
|
|
"end" : absence.end.strftime("%d.%m.%Y"),
|
|
}
|
|
return render(request, 'timemanagement/tm_ab_update.html', context)
|
|
elif request.method == "POST":
|
|
absence = Absence.objects.get(pk=pk)
|
|
formtocheck = UpdateAbsence(request.POST, instance=request.user)
|
|
if(formtocheck.is_valid()):
|
|
|
|
abinfo = list(UserYearAbsenceInfo.objects.filter(user=absence.user, year=absence.start.year))[0]
|
|
abinfo_lastyear = ""
|
|
abinfo_nextyear = ""
|
|
|
|
is_lastyear = False
|
|
|
|
abinfo_lastyear = list(UserYearAbsenceInfo.objects.filter(user=absence.user, year=absence.start.year-1))
|
|
if(len(abinfo_lastyear) > 0):
|
|
is_lastyear = True
|
|
abinfo_lastyear = abinfo_lastyear[0]
|
|
|
|
is_nextyear = False
|
|
abinfo_nextyear = list(UserYearAbsenceInfo.objects.filter(user=absence.user, year=absence.start.year+1))
|
|
if(len(abinfo_nextyear) > 0):
|
|
is_nextyear = True
|
|
abinfo_nextyear = abinfo_nextyear[0]
|
|
|
|
|
|
print(formtocheck.cleaned_data["holidays_normal"])
|
|
print(formtocheck.cleaned_data["holidays_rest"])
|
|
|
|
print(formtocheck.cleaned_data["startday_info"])
|
|
print(formtocheck.cleaned_data["endday_info"])
|
|
|
|
abinfo.days_inuse -= formtocheck.cleaned_data["holidays_normal"]
|
|
abinfo.restdays -= formtocheck.cleaned_data["holidays_rest"]
|
|
abinfo.save()
|
|
|
|
abinfo_nextyear.days_inuse -= formtocheck.cleaned_data["holidays_normal_next"]
|
|
abinfo_nextyear.restdays -= formtocheck.cleaned_data["holidays_rest_next"]
|
|
abinfo_nextyear.save()
|
|
|
|
absence.start = formtocheck.cleaned_data["start"]
|
|
absence.end = formtocheck.cleaned_data["end"]
|
|
absence.startday_info = str(formtocheck.cleaned_data["startday_info"])
|
|
absence.endday_info = str(formtocheck.cleaned_data["endday_info"])
|
|
absence.reason = formtocheck.cleaned_data["reason"]
|
|
|
|
rep = None
|
|
if(formtocheck.cleaned_data["representator"] != None):
|
|
rep = User.objects.get(pk=formtocheck.cleaned_data["representator"].pk)
|
|
absence.representator = rep
|
|
absence.info = formtocheck.cleaned_data["info"]
|
|
|
|
absence.holidays_normal = 0.0
|
|
absence.holidays_rest = 0.0
|
|
absence.holidays_normal_next = 0.0
|
|
absence.holidays_rest_next = 0.0
|
|
|
|
absence.save()
|
|
|
|
messages.success(request, f'Abwesenheit aktualisiert!')
|
|
else:
|
|
messages.success(request, f'Fehler bei Abwesenheitsaktualisierung!')
|
|
context = {
|
|
"active_link" : "abscence",
|
|
}
|
|
return redirect("tma-management")
|
|
|
|
@login_required
|
|
def AbsenceManagmenet(request, activemonth=False, activeyear=False):
|
|
|
|
# NEW ABSENCE
|
|
if(request.method == "POST"):
|
|
'''
|
|
|
|
Nachdem eine neue Abwesenheit gespeichert wurde, geht es zur normalen Seite zurück, jedoch mit den Daten des
|
|
aktuell angezeigten Monate/Jahr
|
|
|
|
'''
|
|
if(request.POST.get("form_type") == "absenceform"):
|
|
formtocheck = AddAbsence(request.POST, instance=request.user)
|
|
if(formtocheck.is_valid()):
|
|
|
|
try:
|
|
workinguser = UserFullName.objects.get(pk=formtocheck.cleaned_data["userid"])
|
|
|
|
# DIFFERENT USER AGENCY
|
|
if(workinguser.profile.agency != request.user.profile.agency):
|
|
messages.success(request, f'Das dürfen Sie nicht!')
|
|
return redirect('tma-management', formtocheck.cleaned_data['activemonth'], formtocheck.cleaned_data['activeyear'])
|
|
# ALL OK - START SAVING ABSENCE
|
|
else:
|
|
confirmstat = 0
|
|
if(request.user.has_perm("users.absencemanager") == False):
|
|
confirmstat = 1
|
|
messages.success(request, f'Abwesenheit beantragt')
|
|
# SEND NOTIFICATION
|
|
else:
|
|
messages.success(request, f'Abwesenheit eingetragen')
|
|
|
|
rep = None
|
|
if(formtocheck.cleaned_data["representator"] != None):
|
|
rep = User.objects.get(pk=formtocheck.cleaned_data["representator"].pk)
|
|
|
|
#newab = Absence(agency=request.user.profile.agency, user=workinguser, start=formtocheck.cleaned_data["start"],end=formtocheck.cleaned_data["end"], representator=rep, confirm_status=confirmstat, info=formtocheck.cleaned_data["info"], reason=formtocheck.cleaned_data["reason"], start_ishalf=formtocheck.cleaned_data["start_ishalf"], end_ishalf=formtocheck.cleaned_data["end_ishalf"]).save()
|
|
newab = Absence(agency=request.user.profile.agency, user=workinguser, start=formtocheck.cleaned_data["start"],end=formtocheck.cleaned_data["end"], representator=rep, confirm_status=confirmstat, info=formtocheck.cleaned_data["info"], reason=formtocheck.cleaned_data["reason"], startday_info=formtocheck.cleaned_data["startday_info"], endday_info=formtocheck.cleaned_data["endday_info"]).save()
|
|
# USER NOT FOUND
|
|
except:
|
|
messages.success(request, f'Fehler bei Benutzerzuweisung!')
|
|
return redirect('tma-management', formtocheck.cleaned_data['activemonth'], formtocheck.cleaned_data['activeyear'])
|
|
|
|
return redirect('tma-management', formtocheck.cleaned_data['activemonth'], formtocheck.cleaned_data['activeyear'])
|
|
else:
|
|
messages.success(request, f'Fehler beim eintragen der neuen Abwesenheit!')
|
|
return redirect('tma-management', formtocheck.cleaned_data['activemonth'], formtocheck.cleaned_data['activeyear'])
|
|
else:
|
|
return redirect('tma-management')
|
|
# NORMAL VIEW
|
|
else:
|
|
prevmonth = ""
|
|
nextmonth = ""
|
|
#MONTH
|
|
if(not activemonth or activemonth > 12 or activemonth < 1):
|
|
activemonth = int(activemonth)
|
|
#Active month
|
|
activemonth=date.today().month
|
|
|
|
if(activemonth == 1):
|
|
prevmonth = 12
|
|
else:
|
|
prevmonth = activemonth-1
|
|
|
|
if(activemonth == 12):
|
|
nextmonth = 1
|
|
else:
|
|
nextmonth = activemonth + 1
|
|
else:
|
|
|
|
if(activemonth == 1):
|
|
prevmonth = 12
|
|
else:
|
|
prevmonth = activemonth-1
|
|
|
|
if(activemonth == 12):
|
|
nextmonth = 1
|
|
else:
|
|
nextmonth = activemonth + 1
|
|
|
|
#YEAR
|
|
nextyear = date.today().year
|
|
prevyear = date.today().year
|
|
|
|
if(not activeyear):
|
|
activeyear = date.today().year
|
|
else:
|
|
if(nextmonth == 1):
|
|
nextyear = activeyear + 1
|
|
else:
|
|
nextyear = activeyear
|
|
if(prevmonth == 12):
|
|
prevyear = activeyear - 1
|
|
else:
|
|
prevyear = activeyear
|
|
|
|
missinguserdata = []
|
|
#CHECK, ob alle nötigen Infos zur Urlaubsberechnung vorliegen
|
|
for user in User.objects.filter(profile__agency=request.user.profile.agency):
|
|
tempTime = UserTime.objects.get(user=user)
|
|
|
|
if(tempTime.startdate == None):
|
|
missinguserdata.append(user)
|
|
|
|
kontingent = 0
|
|
inuse = 0
|
|
yearinfo = False
|
|
try:
|
|
yearinfo = list(UserYearAbsenceInfo.objects.filter(year=activeyear, user=request.user))[0]
|
|
inuse = yearinfo.days_inuse
|
|
kontingent = yearinfo.days - inuse
|
|
except:
|
|
pass
|
|
|
|
|
|
# ABSENCE AUFLISTUNG NACH GRUND
|
|
|
|
allreasons = AbsenceReason.objects.filter(agency=request.user.profile.agency).order_by("name")
|
|
final_reasons = []
|
|
for ar in allreasons:
|
|
tempabsece = Absence.objects.filter(reason=ar, user=request.user, start__year=activeyear)
|
|
temp_sum = 0.0
|
|
for t in tempabsece:
|
|
temp_sum += calculatingHolidaysByAbsence(request, t)
|
|
final_reasons.append([ar, temp_sum])
|
|
|
|
context = {
|
|
"active_link" : "abscence",
|
|
"usersofagency" : User.objects.filter(profile__agency=request.user.profile.agency).order_by("-last_name"),
|
|
"days_this_month" : get_datetime_range(activeyear,activemonth),
|
|
"nextmonth" : nextmonth,
|
|
"missinguserdata" : missinguserdata,
|
|
"prevmonth" : prevmonth,
|
|
"nextyear" : nextyear,
|
|
"prevyear" : prevyear,
|
|
"activemonth" : activemonth,
|
|
"activeyear" : activeyear,
|
|
"inuse" : inuse,
|
|
"final_reasons" : final_reasons,
|
|
"yearinfo" : yearinfo,
|
|
"kontingent" : kontingent,
|
|
"abscenceform" : AddAbsence(instance=request.user),
|
|
"userown" : Absence.objects.filter(agency=request.user.profile.agency, user=request.user).order_by("-start")
|
|
}
|
|
|
|
if(request.user.has_perm("users.absencemanager")):
|
|
context.update({
|
|
"needtoconfirm" : Absence.objects.filter(agency=request.user.profile.agency, confirm_status=1).order_by("-start"),
|
|
"allabsences" : Absence.objects.filter(agency=request.user.profile.agency).order_by("-start")
|
|
})
|
|
|
|
return render(request, 'timemanagement/tm_ab_management.html', context)
|
|
|
|
|
|
@login_required
|
|
def TimeManagement(request):
|
|
context = {
|
|
"active_link" : "timemanagement",
|
|
"workdays" : Workday.objects.filter(agency=request.user.profile.agency, user=request.user).order_by("-start")
|
|
}
|
|
return render(request, 'timemanagement/timemanagement_management.html', context)
|
|
|
|
@login_required
|
|
def TimeAjax(request):
|
|
data = {}
|
|
if request.method == "GET":
|
|
# START WORKDAY
|
|
if request.GET["action"] == "start_day":
|
|
wd = Workday(user=request.user, agency=request.user.profile.agency, start=timezone.now())
|
|
wd.save()
|
|
data = {
|
|
"success" : True,
|
|
"wd_starttime" : wd.start.strftime("%H:%M:%S"),
|
|
"wd_starttime_complete" : wd.start
|
|
}
|
|
# END DAY
|
|
elif request.GET["action"] == "end_day":
|
|
wd = list(Workday.objects.filter(user=request.user, agency=request.user.profile.agency, end=None))[0]
|
|
# END ALL BREAKS
|
|
for b in wd.breaks.all():
|
|
if b.end == None:
|
|
b.end = timezone.now()
|
|
b.save()
|
|
wd.end = timezone.now()
|
|
wd.save()
|
|
|
|
breaksum = 0
|
|
for b in wd.breaks.all():
|
|
if(b.end != None):
|
|
breaksum += (b.end - b.start).seconds
|
|
|
|
data = {
|
|
"success" : True,
|
|
"wd_endtime" : wd.end.strftime("%H:%M:%S"),
|
|
"actualbreaktime" : breaksum*1000
|
|
}
|
|
# START A BREAK
|
|
elif request.GET["action"] == "start_break":
|
|
wd = list(Workday.objects.filter(user=request.user, agency=request.user.profile.agency, end=None))[0]
|
|
newbreak = Breaks(workday=wd, user=request.user, agency=request.user.profile.agency, start=timezone.now())
|
|
newbreak.save()
|
|
wd.breaks.add(newbreak)
|
|
data = {
|
|
"success" : True,
|
|
"break_starttime" : newbreak.start,
|
|
}
|
|
# END BREAK
|
|
elif request.GET["action"] == "end_break":
|
|
wd = list(Workday.objects.filter(user=request.user, agency=request.user.profile.agency, end=None))[0]
|
|
toendbreak = list(wd.breaks.filter(end=None))[0]
|
|
toendbreak.end = timezone.now()
|
|
toendbreak.save()
|
|
|
|
wd = list(Workday.objects.filter(user=request.user, agency=request.user.profile.agency, end=None))[0]
|
|
breaksum = 0
|
|
for b in wd.breaks.all():
|
|
if(b.end != None):
|
|
breaksum += (b.end - b.start).seconds
|
|
|
|
data = {
|
|
"success" : True,
|
|
"actualbreaktime" : breaksum*1000
|
|
}
|
|
# REMOVE WORKDAY
|
|
elif request.GET["action"] == "remove_workday":
|
|
wd = Workday.objects.get(pk=request.GET.get("workday"))
|
|
if(wd.user == request.user and wd.agency == request.user.profile.agency):
|
|
wd.delete()
|
|
data = {
|
|
"success" : True
|
|
}
|
|
else:
|
|
data = { "success" : False}
|
|
# Get Rendered Table
|
|
elif request.GET["action"] == "getrenderedtable":
|
|
prevmonth = ""
|
|
nextmonth = ""
|
|
activemonth = int(request.GET["activemonth"])
|
|
activeyear = int(request.GET["activeyear"])
|
|
|
|
#MONTH
|
|
if(not activemonth or activemonth > 12 or activemonth < 1):
|
|
activemonth = int(activemonth)
|
|
#Active month
|
|
activemonth=date.today().month
|
|
|
|
if(activemonth == 1):
|
|
prevmonth = 12
|
|
else:
|
|
prevmonth = activemonth-1
|
|
|
|
if(activemonth == 12):
|
|
nextmonth = 1
|
|
else:
|
|
nextmonth = activemonth + 1
|
|
else:
|
|
|
|
if(activemonth == 1):
|
|
prevmonth = 12
|
|
else:
|
|
prevmonth = activemonth-1
|
|
|
|
if(activemonth == 12):
|
|
nextmonth = 1
|
|
else:
|
|
nextmonth = activemonth + 1
|
|
|
|
#YEAR
|
|
nextyear = date.today().year
|
|
prevyear = date.today().year
|
|
|
|
if(not activeyear):
|
|
activeyear = date.today().year
|
|
else:
|
|
if(nextmonth == 1):
|
|
nextyear = activeyear + 1
|
|
else:
|
|
nextyear = activeyear
|
|
if(prevmonth == 12):
|
|
prevyear = activeyear - 1
|
|
else:
|
|
prevyear = activeyear
|
|
missinguserdata = []
|
|
#CHECK, ob alle nötigen Infos zur Urlaubsberechnung vorliegen
|
|
for user in User.objects.filter(profile__agency=request.user.profile.agency):
|
|
tempTime = UserTime.objects.get(user=user)
|
|
|
|
if(tempTime.startdate == None):
|
|
missinguserdata.append(user)
|
|
|
|
|
|
context = {
|
|
"active_link" : "abscence",
|
|
"usersofagency" : User.objects.filter(profile__agency=request.user.profile.agency).order_by("-last_name"),
|
|
"days_this_month" : get_datetime_range(activeyear,activemonth),
|
|
"activemonth" : activemonth,
|
|
"missinguserdata" : missinguserdata,
|
|
"activeyear" : activeyear,
|
|
"nextmonth" : nextmonth,
|
|
"prevmonth" : prevmonth,
|
|
"nextyear" : nextyear,
|
|
"prevyear" : prevyear
|
|
}
|
|
return render(request, "timemanagement/rendered_table.html", context)
|
|
|
|
# Get Rendered Table
|
|
elif request.GET["action"] == "checkrequired":
|
|
reason = AbsenceReason.objects.get(pk=request.GET["rid"])
|
|
if(reason.agency == request.user.profile.agency):
|
|
data = {
|
|
"success" : True,
|
|
"isreq" : reason.need_rep,
|
|
"isholiday" : reason.is_holiday
|
|
}
|
|
else:
|
|
data = {
|
|
"success" : False
|
|
}
|
|
# DELETE ABSENCE
|
|
elif request.GET["action"] == "remove_absence":
|
|
absence = Absence.objects.get(pk=request.GET["ab"])
|
|
|
|
if(request.user.has_perm("users.absencemanager") and absence.agency == request.user.profile.agency):
|
|
absence.delete()
|
|
data = {
|
|
"success" : True
|
|
}
|
|
# GET FORM FOR CONFIRM ABSENCE
|
|
elif request.GET["action"] == "getrenderedform":
|
|
|
|
absence = Absence.objects.get(pk=request.GET["abscenceid"])
|
|
timeinfo_thisyear = list(UserYearAbsenceInfo.objects.filter(year=absence.start.year, user=absence.user))[0]
|
|
try:
|
|
timeinfo_nextyear = list(UserYearAbsenceInfo.objects.filter(year=absence.start.year+1, user=absence.user))[0]
|
|
except:
|
|
timeinfo_nextyear = False
|
|
|
|
|
|
# POrüfen, ob es in diesem Zeitraum noch andere Abwesenheiten gibt
|
|
other_absences = Absence.objects.filter(start__lte=absence.start, end__gte=absence.end, agency=request.user.profile.agency).exclude(user=absence.user)
|
|
|
|
other_absences_string = False
|
|
if (len(other_absences) > 0):
|
|
other_absences_string = []
|
|
for a in other_absences:
|
|
other_absences_string.append(a.user.first_name + " " + a.user.last_name + " - Vom " + a.start.strftime("%d.%m.%Y") + " bis " + a.end.strftime("%d.%m.%Y"))
|
|
|
|
|
|
context = {
|
|
"confirmform" : ConfirmAbsenceForm(instance=request.user),
|
|
"absence" : absence,
|
|
"other_absences_string" : other_absences_string,
|
|
"timeinfo_thisyear" : timeinfo_thisyear,
|
|
"timeinfo_nextyear" : timeinfo_nextyear
|
|
}
|
|
|
|
return render(request, "timemanagement/rendered_confirmform.html", context)
|
|
elif request.GET["action"] == "confirmornotabscence":
|
|
absence = Absence.objects.get(pk=request.GET["absencetowork"])
|
|
new_stat = request.GET["newconfstat"]
|
|
|
|
info = request.GET["info"]
|
|
|
|
if(absence.user.profile.agency == request.user.profile.agency and request.user.has_perm("users.absencemanager")):
|
|
absence.confirm_status = new_stat
|
|
absence.confirm_info = info
|
|
post_save.disconnect(save_newabsence, sender=Absence)
|
|
absence.save()
|
|
post_save.connect(save_newabsence, sender=Absence)
|
|
messages.success(request, f'Abwesenheit gespeichert!')
|
|
else:
|
|
messages.success(request, f'Das dürfen Sie nicht!')
|
|
|
|
data = {
|
|
"success" : True,
|
|
"activemonth" : request.GET["activemonth"],
|
|
"activeyear" : request.GET["activeyear"]
|
|
}
|
|
elif request.GET["action"] == "getrestholidays":
|
|
user = User.objects.get(pk=request.GET["userid"])
|
|
usertimedata = UserTime.objects.get(user=user)
|
|
today = date.today()
|
|
if(user.profile.agency == request.user.profile.agency):
|
|
|
|
start_day = request.GET["startdate"].split("__")
|
|
start_day_obj = datetime.date(int(start_day[0]), int(start_day[1]), int(start_day[2]))
|
|
|
|
end_day = request.GET["enddate"].split("__")
|
|
end_day_obj = datetime.date(int(end_day[0]), int(end_day[1]), int(end_day[2]))
|
|
|
|
try:
|
|
holidayloose_date = datetime.date(start_day_obj.year, int(usertimedata.loose_holidedate.split(".")[1]), int(usertimedata.loose_holidedate.split(".")[0]))
|
|
except:
|
|
holidayloose_date = datetime.date(2020, int(usertimedata.loose_holidedate.split(".")[1]), int(usertimedata.loose_holidedate.split(".")[0]))
|
|
|
|
|
|
# GET INFO IF DAY IS HALF OR NOT, EQUAL PRE-POST-DAY
|
|
start_half = False
|
|
if request.GET["startday_info"] == "1" or request.GET["startday_info"] == "2":
|
|
start_half = True
|
|
|
|
end_half = False
|
|
if request.GET["endday_info"] == "1" or request.GET["endday_info"] == "2":
|
|
end_half = True
|
|
|
|
choosenyear = int(start_day[0])
|
|
|
|
yeardata = list(UserYearAbsenceInfo.objects.filter(user=user, agency=user.profile.agency, year=choosenyear))[0]
|
|
|
|
holiday_thisyear = 0
|
|
holiday_lastyear = yeardata.restdays
|
|
holiday_nextyear = 0
|
|
holiday_nextyear_rest = 0
|
|
two_years = False
|
|
need_days_next = 0
|
|
need_days_this = 0
|
|
|
|
try:
|
|
holiday_nextyear = list(UserYearAbsenceInfo.objects.filter(user=user, agency=user.profile.agency,
|
|
year=choosenyear+1))[0].days - list(UserYearAbsenceInfo.objects.filter(user=user, agency=user.profile.agency,
|
|
year=choosenyear+1))[0].days_inuse
|
|
holiday_nextyear_rest = list(UserYearAbsenceInfo.objects.filter(user=user, agency=user.profile.agency,
|
|
year=choosenyear+1))[0].restdays
|
|
except:
|
|
holiday_nextyear = yeardata.days
|
|
|
|
# Urlaub innerhalb eines Jahres inkl. Prüfung auf Resturlaubsanspruch
|
|
if(end_day_obj.year == start_day_obj.year):
|
|
# Startt des Urlaubs NACH Verfallsdatum - nur aktuelles JAhr und die Zahl interessiert
|
|
if(start_day_obj > holidayloose_date):
|
|
need_days = (calculateHolidays(request, start_day_obj, end_day_obj, start_half, end_half))*(-1)
|
|
holiday_thisyear = yeardata.days - yeardata.days_inuse - need_days
|
|
else:
|
|
need_days = (calculateHolidays(request, start_day_obj, end_day_obj, start_half, end_half))*(-1)
|
|
# Kein Resturlaub
|
|
if(yeardata.restdays == 0.0):
|
|
holiday_thisyear = yeardata.days - yeardata.days_inuse - need_days
|
|
# Resturlaub vorhanden, berechne mit Resturlaub
|
|
else:
|
|
holiday_lastyear = yeardata.restdays
|
|
holiday_thisyear = yeardata.days - yeardata.days_inuse
|
|
temp_holiday = holiday_lastyear - need_days
|
|
if(temp_holiday < 0):
|
|
holiday_lastyear = 0
|
|
holiday_thisyear = yeardata.days - yeardata.days_inuse + temp_holiday
|
|
else:
|
|
holiday_lastyear = yeardata.restdays - need_days
|
|
# Urlaub geht über das nächstes Jahr hinweg
|
|
else:
|
|
two_years = True
|
|
holiday_lastyear = yeardata.restdays
|
|
date_splitter = datetime.date(end_day_obj.year, 1, 1)
|
|
|
|
need_days_this = (calculateHolidays(request, start_day_obj, date_splitter, start_half, False))*(-1)
|
|
|
|
need_days_next = (calculateHolidays(request, date_splitter, end_day_obj, False, end_half))*(-1)
|
|
|
|
need_days = (calculateHolidays(request, start_day_obj, date_splitter, start_half, False))*(-1) + (calculateHolidays(request, date_splitter, end_day_obj, False, end_half))*(-1)
|
|
holiday_thisyear = yeardata.days - yeardata.days_inuse - need_days_this
|
|
days_nextyear_normal = 0
|
|
days_nextyear_rest = 0
|
|
# Urlaub nächstes Jahr MIT und OHNE Rest
|
|
if(holiday_nextyear_rest == 0.0):
|
|
holiday_nextyear = holiday_nextyear - (calculateHolidays(request, date_splitter, end_day_obj, False, end_half))*(-1)
|
|
else:
|
|
temprest = holiday_nextyear_rest - need_days_next
|
|
# Rest reicht!
|
|
if(temprest >= 0):
|
|
holiday_nextyear_rest = temprest
|
|
days_nextyear_normal = 0
|
|
days_nextyear_rest = need_days_next
|
|
# Rest reicht nicht
|
|
else:
|
|
holiday_nextyear_rest = 0
|
|
holiday_nextyear += temprest
|
|
days_nextyear_rest = need_days_next + temprest
|
|
days_nextyear_normal = temprest * -1
|
|
|
|
# POrüfen, ob es in diesem Zeitraum noch andere Abwesenheiten gibt
|
|
other_absences = Absence.objects.filter(start__lte=start_day_obj, end__gte=end_day_obj, agency=request.user.profile.agency).exclude(user=user)
|
|
|
|
other_absences_string = False
|
|
if (len(other_absences) > 0):
|
|
other_absences_string = ""
|
|
for a in other_absences:
|
|
other_absences_string += a.user.first_name + " " + a.user.last_name + " - Vom " + a.start.strftime("%d.%m.%Y") + " bis " + a.end.strftime("%d.%m.%Y") + "<br />"
|
|
|
|
data = {
|
|
"restholiday_thisyear" : holiday_thisyear,
|
|
"restholiday_lastyear" : holiday_lastyear,
|
|
"restholiday_nextyear" : holiday_nextyear,
|
|
"restholiday_nextyear_rest" : holiday_nextyear_rest,
|
|
"two_years" : two_years,
|
|
"need_days" : need_days,
|
|
"need_days_next" : need_days_next,
|
|
"need_days_this" : need_days_this,
|
|
"other_absences" : other_absences_string
|
|
}
|
|
# REQUEST USER NO RIGHTS
|
|
else:
|
|
data = {
|
|
"success" : False
|
|
}
|
|
# GET REQUEST ACTION UNKNOWN
|
|
else:
|
|
data = {
|
|
"success" : False
|
|
}
|
|
|
|
return JsonResponse(data)
|
|
|
|
|
|
'''
|
|
|
|
Gibt einen Integer zurück, welcher die Urlaubstage von Start zu Enddatum auf der Grundlage von Freitagen berechnet.
|
|
Berücksichtigt sowohl Wochenende als auch in der Agentur hinterlegte Freitage/Schließtage
|
|
|
|
'''
|
|
@login_required
|
|
def calculateHolidays(request, start, end, start_half, end_half):
|
|
restdays = 0
|
|
allfreedays = FreeDays.objects.filter(agency=request.user.profile.agency)
|
|
if(end == start):
|
|
if(start_half):
|
|
return restdays - 0.5
|
|
else:
|
|
return restdays - 1
|
|
else:
|
|
if(end < start):
|
|
return False
|
|
else:
|
|
counter = 0
|
|
if(start_half):
|
|
counter -= 0.5
|
|
if(end_half):
|
|
counter -= 0.5
|
|
|
|
weekdays = [6,7]
|
|
freedaycounter = 0
|
|
for dt in daterange(start, end):
|
|
|
|
if dt.isoweekday() not in weekdays:
|
|
counter += 1
|
|
for freeday in allfreedays.all():
|
|
if(dt == freeday.day):
|
|
freedaycounter += 1
|
|
|
|
|
|
return restdays - counter + freedaycounter
|
|
|
|
@login_required
|
|
def calculatingHolidaysByAbsence(request, absence):
|
|
# Freitage laden, die innerhalb der gewünschten Abwesenheit liegen
|
|
allfreedays = FreeDays.objects.filter(agency=request.user.profile.agency, day__gt=absence.start, day__lt=absence.end)
|
|
finalholidayinabsence = 0
|
|
|
|
# Start und Ende gleich, nur ein Tag. Checken, ob Halber Tag
|
|
|
|
if(absence.start == absence.end):
|
|
if absence.startday_info == "1" or absence.startday_info == "2":
|
|
finalholidayinabsence = 0.5
|
|
else:
|
|
finalholidayinabsence = 1
|
|
return finalholidayinabsence
|
|
|
|
else:
|
|
if absence.startday_info == "1" or absence.startday_info == "2":
|
|
finalholidayinabsence -= 0.5
|
|
if absence.endday_info == "1" or absence.endday_info == "2":
|
|
finalholidayinabsence -= 0.5
|
|
|
|
weekdays = [6,7]
|
|
freedaycounter = 0
|
|
for dt in daterange(absence.start, absence.end):
|
|
|
|
if dt.isoweekday() not in weekdays:
|
|
finalholidayinabsence += 1
|
|
for freeday in allfreedays.all():
|
|
# FREEDAY FOUND
|
|
if(dt == freeday.day):
|
|
freedaycounter += 1
|
|
|
|
return finalholidayinabsence - freedaycounter
|
|
|
|
# Gibt die Woche als Wochentage zurück
|
|
def daterange(date1, date2):
|
|
for n in range(int ((date2 - date1).days)+1):
|
|
yield date1 + timedelta(n)
|
|
|
|
|