Zitap/zitap/views.py

import datetime
import json
from django.db import IntegrityError
from django.http import HttpResponseNotFound, HttpResponseRedirect, JsonResponse, HttpResponseNotAllowed
from django.shortcuts import render
from django.contrib.auth import authenticate, login as auth_login, logout as auth_logout
from django.views.decorators.csrf import csrf_exempt
from django.utils.translation import gettext as _
from django.contrib.auth.models import User

from .forms import CreateEventForm, LoginForm, UpdateSlotsForm
from .models import Event, Participant, Date
from .helpers import slots2string, string2slots, get_slot_count, slots2grid

def index(request):
    return render(request, 'zitap/index.html')

def my_events(request):
    if not request.user.is_authenticated:
        return HttpResponseRedirect('/my-events/login')
    events = Event.objects.filter(participant__user=request.user).prefetch_related('date_set', 'participant_set', 'participant_set__user')
    return render(request, 'zitap/my-events.html', {
        'events': events,
    })

def about(request):
    return render(request, 'zitap/about.html')

def create_event(request):
    if request.method == 'POST':
        form = CreateEventForm(request.POST)
        if form.is_valid():
            data = form.cleaned_data
            # Try to create the event. If the url is already taken, try again.
            n = 0
            while n<10:
                try:
                    event = Event.objects.create(
                        name=data['event_name'], 
                        start_time=datetime.time(int(data['start_time']), 0), 
                        end_time=datetime.time(int(data['end_time']), 0),
                        slot_interval=datetime.timedelta(minutes=int(data['slot_interval'])),
                    )
                    for date in data['event_date']:
                        event.date_set.create(date=date)
                    event.save()
                    return HttpResponseRedirect(f'/{event.url}')
                except IntegrityError:
                    n += 1
            form.add_error(None, _('Could not create event. Please try again.'))
    else:
        form = CreateEventForm()
    return render(request, 'zitap/create-event.html', {'form': form})

def event(request, url):
    try:
        event = Event.objects.prefetch_related('date_set', 'participant_set', 'participant_set__user').get(url=url)
    except Event.DoesNotExist:
        return render(request, 'zitap/event-not-found.html')
    
    # Check if the user is logged in
    if 'user_id' in request.session:
        participant = event.participant_set.filter(user_id=request.session['user_id']).first()
        if participant is None:
            participant, created = Participant.objects.get_or_create(user_id=request.session['user_id'], event=event)
        login_form = None
        update_form = UpdateSlotsForm(initial={'slots': slots2string(participant, get_slot_count(event))}, participant=participant)
    else:
        login_form = LoginForm()
        update_form = None
    return render(
        request, 
        'zitap/event.html', 
        {'event': event, 'grid': slots2grid(event, list(event.participant_set.all()), False), 'login_form': login_form, 'update_form': update_form}
    )

def login(request, url):
    if url == 'my-events':
        text = _('Login to My Events')
    elif Event.objects.filter(url=url).exists():
        text = _('Login to Update Slots')
    else:
        return render(request, 'zitap/event-not-found.html')

    if request.method == 'POST':
        form = LoginForm(request.POST)
    elif request.user.is_authenticated:
        return HttpResponseRedirect(f'/{url}')
    else:
        form = LoginForm()
    if form.is_valid():
        data = form.cleaned_data
        user = authenticate(request, username=data['username'], password=data.get('password'))
        if user is None:
            try:
                user = User.objects.create_user(data['username'], password=data.get('password'))
            except IntegrityError:
                form.add_error('username', _('Username already exists'))
                return render(request, 'zitap/login.html', {'form': form, 'url': url, 'text': text})

        auth_login(request, user)
        request.session['user_id'] = user.id
        return HttpResponseRedirect(f'/{url}')
    return render(request, 'zitap/login.html', {'form': form, 'url': url, 'text': text})

def logout(request, url):
    auth_logout(request)
    if url == 'my-events':
        return HttpResponseRedirect(f'/{url}')
    elif Event.objects.filter(url=url).exists():
        return HttpResponseRedirect(f'/{url}')
    else:
        return render(request, 'zitap/event-not-found.html')


def update_slots(request, url):
    try:
        event = Event.objects.get(url=url)
    except Event.DoesNotExist:
        return render(request, 'zitap/event-not-found.html')

    if request.method != 'POST':
        return HttpResponseNotAllowed(['POST'])

    participant = Participant.objects.get(user_id=request.session['user_id'], event=event)
    form = UpdateSlotsForm(request.POST, participant=participant)
    if form.is_valid():
        data = form.cleaned_data
        participant.slots = string2slots(data['slots'], get_slot_count(event))
        participant.save()
        return HttpResponseRedirect(f'/{event.url}')

def event_api(request, url):
    """
    REST JSON API for an event
    """
    try:
        event = Event.objects.get(url=url)
    except Event.DoesNotExist:
        return JsonResponse({'error': 'Event not found'}, status=404)
    if request.method == 'GET':
        return JsonResponse({
            'name': event.name,
            'url': event.url,
            'start_time': event.start_time.strftime('%H:%M'),
            'end_time': event.end_time.strftime('%H:%M'),
            'slot_interval': event.slot_interval.seconds // 60,
            'dates': [date.date.strftime('%Y-%m-%d') for date in event.date_set.all()],
        })
    else:
        return HttpResponseNotAllowed(['GET'])

@csrf_exempt
def slots_api(request, url):
    """
    REST JSON API for slots of all participants of an event
    Slots are represented as a string of 0s and 1s where 0 means the slot is available and 1 means the slot is taken.
    The string begins with the first slot of the first day of the event and ends with the last slot of the last day of the event.
    """
    try:
        event = Event.objects.get(url=url)
        slot_count = get_slot_count(event)

        # Check if the user is logged in and wants to update their slots
        if 'user_id' in request.session and request.method == 'POST':
            participant = Participant.objects.get(user_id=request.session['user_id'], event=event)
            form = UpdateSlotsForm(request.POST, participant=participant)
            if form.is_valid():
                data = form.cleaned_data
                participant.slots = string2slots(data['slots'], slot_count)
                participant.save()

        # Get the slots of each participant
        data = {}
        participants = event.participant_set.all()
        for participant in participants:
            data[participant.user.username] = slots2string(participant, slot_count)
        
        return JsonResponse(data)

    except Event.DoesNotExist:
        return HttpResponseNotFound()