AD/main/views.py

from datetime import date

from django.shortcuts import render, redirect, get_object_or_404
from .forms import MultipleShiftForm, ShiftForm, EventForm, HelperForm, ReinigungForm
from .models import Shift, Employee, Location, Event, Helper, Reinigung
from django.utils.timezone import datetime, timedelta
from django.utils import timezone
from django.contrib.auth.decorators import user_passes_test
import calendar


def ma_month(request, mitarbeiter_id, monat, jahr):
    start_date = date(jahr, monat, 1)
    end_date = date(jahr, monat, calendar.monthrange(jahr, monat)[1])

    schichten = Shift.objects.filter(employee=mitarbeiter_id , date__range=(start_date, end_date)).order_by('date')
    mitarbeiter = Employee.objects.get(id=mitarbeiter_id)
    print (mitarbeiter)

    for schicht in schichten:
        print(schicht)

    context = {
        'schichten': schichten,
        'monat': monat,
        'jahr': jahr,
        'mitarbeiter_id': mitarbeiter_id,
        'mitarbeiter': mitarbeiter,
    }

    return render(request, 'main/ma_month.html', context)

def create_multiple_shifts(request):
    date_str = request.GET.get('date')
    initial_data = {}
    if date_str:
        initial_data['date'] = date_str

    if request.method == 'POST':
        form = MultipleShiftForm(request.POST)
        if form.is_valid():
            employees = form.cleaned_data['employees']
            date = form.cleaned_data['date']
            start = form.cleaned_data['start']
            end = form.cleaned_data['end']
            shifttype = form.cleaned_data['shifttype']
            info = form.cleaned_data['info']


            for employee in employees:
                Shift.objects.create(
                    employee=employee,
                    date=date,
                    start=start,
                    end=end,
                    shifttype=shifttype,
                    info=info
                )
            return redirect('public')  # Annahme, dass Sie eine Erfolgsmeldung anzeigen möchten
    else:
        form = MultipleShiftForm(initial=initial_data)

    return render(request, 'main/create_multiple_shifts.html', {'form': form})


def create_event(request):
    date_str = request.GET.get('date')
    initial_data = {}
    if date_str:
        initial_data['date'] = date_str

    if request.method == 'POST':
        form = EventForm(request.POST)
        if form.is_valid():
            name = form.cleaned_data['name']
            date = form.cleaned_data['date']
            event_type = form.cleaned_data['event_type']
            location = form.cleaned_data['location']
            cvd = form.cleaned_data['cvd']
            cvt = form.cleaned_data['cvt']
            Event.objects.create(
                name=name,
                date=date,
                event_type=event_type,
                location=location,
                cvd=cvd,
                cvt=cvt
                )
            return redirect('public')  # Annahme, dass Sie eine Erfolgsmeldung anzeigen möchten
    else:
        form = EventForm(initial=initial_data)

    return render(request, 'main/create_event.html', {'form': form})


# Test function to check if the user is an admin
def is_admin(user):
    return user.is_authenticated and user.is_staff


def public(request):
    # Standardmäßig die aktuelle Woche anzeigen
    today = timezone.now().date()

    # Überprüfen, ob ein Startdatum in der URL angegeben ist
    start_date_str = request.GET.get('start_date')
    if start_date_str:
        try:
            start_of_week = datetime.strptime(start_date_str, '%Y-%m-%d').date()
        except ValueError:
            start_of_week = today - timedelta(days=today.weekday())  # Fallback auf die aktuelle Woche bei Fehler
    else:
        start_of_week = today - timedelta(days=today.weekday())  # Montag der aktuellen Woche

    end_of_week = start_of_week + timedelta(days=6)  # Sonntag der aktuellen Woche

    # Berechnung für die nächste und vorherige Woche
    previous_week = start_of_week - timedelta(days=7)
    next_week = start_of_week + timedelta(days=7)

    # Berechnung der Kalenderwoche
    calendar_week = start_of_week.isocalendar()[1]

    # Initialisiere ein Dictionary für die Schichten der Mitarbeiter
    shifts_by_employee = {}
    events_by_location = {}
    helpers_by_date = {}
    employees = Employee.objects.all()
    locations = Location.objects.all()
    helpers = Helper.objects.all()

    for employee in employees:
        shifts_by_employee[employee] = {day: None for day in range(7)}

    for location in locations:
        events_by_location[location] = {day: None for day in range(7)}

    for helper in helpers:
        helpers_by_date = {day: None for day in range(7)}

        # Hole alle Schichten für die aktuelle Woche
    shifts = Shift.objects.filter(date__range=[start_of_week, end_of_week])

    events = Event.objects.filter(date__range=[start_of_week, end_of_week])

    helpers = Helper.objects.filter(date__range=[start_of_week, end_of_week])


    # Fülle das Dictionary mit den Schichtdaten
    for shift in shifts:
        employee = shift.employee
        day_of_week = (shift.date - start_of_week).days
        shifts_by_employee[employee][day_of_week] = shift

    for event in events:
        location = event.location
        day_of_week = (event.date - start_of_week).days
        events_by_location[location][day_of_week] = event

    for helper in helpers:
        day_of_week = (helper.date - start_of_week).days
        helpers_by_date[day_of_week] = helper

    # Bereite die Daten der Woche für das Template vor
    week_dates = [(start_of_week + timedelta(days=i)).strftime("%d.%m.%Y") for i in range(7)]
    days_of_week = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So']
    days_with_dates = list(zip(days_of_week, week_dates))

    context = {
        'shifts_by_employee': shifts_by_employee,
        'events_by_location': events_by_location,
        'helpers_by_date': helpers_by_date,
        'start_of_week': start_of_week,
        'end_of_week': end_of_week,
        'days_with_dates': days_with_dates,
        'range_days': range(7),
        'previous_week': previous_week.strftime('%Y-%m-%d'),
        'next_week': next_week.strftime('%Y-%m-%d'),
        'calendar_week': calendar_week,
    }
    return render(request, 'main/public.html', context)

def create_reinigung(request):
    date_str = request.GET.get('date')
    initial_data = {}
    if date_str:
        initial_data['date'] = date_str

    if request.method == 'POST':
        form = ReinigungForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('public')  # Redirect to a relevant page after saving
    else:
        form = ReinigungForm()
    return render(request, 'main/create_reinigung.html', {'form': form})

def create_helper(request):
    date_str = request.GET.get('date')
    initial_data = {}
    if date_str:
        initial_data['date'] = date_str

    if request.method == 'POST':
        form = HelperForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('public')  # Redirect to a relevant page after saving
    else:
        form = HelperForm()
    return render(request, 'main/create_helper.html', {'form': form})


def edit_reinigung(request, pk):
    reinigung = get_object_or_404(Reinigung, pk=pk)
    if request.method == 'POST':
        form = ReinigungForm(request.POST, instance=reinigung)
        if form.is_valid():
            form.save()
            return redirect('public')
    else:
        form = ReinigungForm(instance=reinigung)
    return render(request, 'main/edit_reinigung.html', {'form': form, 'reinigung': reinigung})

def edit_helper(request, pk):
    helper = get_object_or_404(Helper, pk=pk)
    if request.method == 'POST':
        form = HelperForm(request.POST, instance=helper)
        if form.is_valid():
            form.save()
            return redirect('public')
    else:
        form = HelperForm(instance=helper)
    return render(request, 'main/edit_helper.html', {'form': form, 'helper': helper})


def edit_shift(request, pk):
    shift = get_object_or_404(Shift, pk=pk)
    if request.method == 'POST':
        form = ShiftForm(request.POST, instance=shift)
        if form.is_valid():
            form.save()
            return redirect('public')
    else:
        form = ShiftForm(instance=shift)
    return render(request, 'main/edit_shift.html', {'form': form, 'shift': shift})


def edit_event(request, pk):
    event = get_object_or_404(Event, pk=pk)
    if request.method == 'POST':
        form = EventForm(request.POST, instance=event)
        if form.is_valid():
            form.save()
            return redirect('public')
    else:
        form = EventForm(instance=event)
    return render(request, 'main/edit_event.html', {'form': form, 'event': event})


def delete_shift(request, pk):
    shift = get_object_or_404(Shift, pk=pk)
    if request.method == 'POST':
        shift.delete()
        return redirect('public')
    return render(request, 'main/delete_shift.html', {'shift': shift})

def delete_reinigung(request, pk):
    reinigung = get_object_or_404(Reinigung, pk=pk)
    if request.method == 'POST':
        reinigung.delete()
        return redirect('public')
    return render(request, 'main/delete_reinigung.html', {'reinigung': reinigung})

def delete_helper(request, pk):
    helper = get_object_or_404(Helper, pk=pk)
    if request.method == 'POST':
        helper.delete()
        return redirect('public')
    return render(request, 'main/delete_helper.html', {'helper': helper})


def delete_event(request, pk):
    event = get_object_or_404(Event, pk=pk)
    if request.method == 'POST':
        event.delete()
        return redirect('public')
    return render(request, 'main/delete_event.html', {'event': event})