def delete_racconto(request, pk_racconto):
# Controllo che l'utente sia un gestore
permissions = get_permission(request.user.email)
if not permissions["is_segretario"]: # Non è un segretario
return redirect('home')
# Cancellazione racconto
_racconto = get_object_or_404(racconti, pk=pk_racconto)
racconto_id = _racconto.pk
racconto_event = _racconto.idEvent.eventName
pk_event = _racconto.idEvent.pk
racconto_title = _racconto.title
_racconto.delete()
# LOG operazione
insert_log(username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Eliminazione racconto",
description = "Eliminazione racconto {racconto_title} id=[{racconto_id}] per l'evento {racconto_event}".format(
racconto_title=racconto_title, racconto_event=racconto_event, racconto_id=racconto_id)
)
return redirect('list_racconti_segreteria', pk_event)
def create_event(request):
# Controllo che l'utente sia un gestore
utente_gestore = gestore.objects.filter(username=request.user.email)[:1]
if utente_gestore.count() == 0: # Non è un gestore
return redirect('home')
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = eventsModelForm(request.POST)
# check whether it's valid:
if form.is_valid():
form.save()
# LOG operazione
insert_log(username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Creazione concorso",
description="Creazione concorso \"{titolo}\"".format(
titolo=form.cleaned_data['eventName'], ))
return HttpResponseRedirect(reverse('list_event'))
# if a GET (or any other method) we'll create a blank form
else:
form = eventsModelForm()
context = {'form': form}
permissions = get_permission(request.user.email)
context.update(permissions)
return render(request, 'create_event.html', context)
def delete_valutatore(request, pk_valutatore):
# Controllo che l'utente sia un gestore
utente_gestore = gestore.objects.filter(username=request.user.email)[:1]
if utente_gestore.count() == 0: # Non è un gestore
return redirect('home')
# Cancellazione valutatore
permissions = get_permission(request.user.email)
_valutatore = valutatore.objects.get(pk=pk_valutatore)
# Controllo che il valutatore non abbia nessuna selezione attiva e non abbia nessuna
# classificazione per qualche racconto
# Possibili selezioni del valutatore
numero_selezioni_attive = valutazione.objects.filter(
idValutatore=_valutatore, selected=True).count()
# Possibili valutazioni del valutatore
numero_valutazioni = valutazione.objects.filter(
idValutatore=_valutatore,
ranking__in=[RANKING_POINT[0], RANKING_POINT[1],
RANKING_POINT[2]]).count()
if (numero_valutazioni + numero_selezioni_attive) > 0:
# LOG operazione
insert_log(
username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Eliminazione valutatore",
description=
"Eliminazione valutatore \"{utente_valutatore}\" per il concorso "
"con id = {id} non riuscita in quanto ha dati associati".format(
id=id_active_event(),
utente_valutatore=_valutatore.idUser,
))
else:
# LOG operazione
insert_log(
username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Eliminazione valutatore",
description=
"Eliminazione valutatore \"{utente_valutatore}\" per il concorso con id = {id}"
.format(
id=id_active_event(),
utente_valutatore=_valutatore.idUser,
))
_valutatore.delete()
_id_evento = _valutatore.idEvent.pk
# context = {'valutatori': valutatore.objects.filter(idEvent=_id_evento).order_by("idUser"), 'pk_event': _id_evento,
# 'is_gestore': True}
#
# context.update(permissions)
# return render(request, 'list_valutatore.html', context)
return redirect('list_valutatore', _id_evento)
def deseleziona_racconto(request, pk_racconto, page_number, categoriaeta):
idEvent = id_active_event()
# Controlla se l'evento è attivo
if idEvent is None:
return redirect('home')
concorso = events.objects.all().get(pk=idEvent)
valutatore_concorso = valutatore.objects.all().filter(
idEvent=concorso, idUser=request.user.email)[:1]
if valutatore_concorso.count(
) == 0: # L'utente non ' un valutatore per questo concorso
return redirect('home')
# Se il periodo di selezione non è ancora attivo o non lo è l'operazione non è valida
if not is_selectable():
return redirect('home')
racconto_da_valutare = racconti.objects.all().get(pk=pk_racconto)
racconti_concorso_attivo = racconti.objects.all().filter(
idEvent=id_active_event())
if racconto_da_valutare not in racconti_concorso_attivo: # Il racconto non può essere valutato in questo concorso
return redirect('home')
valutazione_racconto = valutazione.objects.all().filter(
idValutatore=valutatore_concorso[0],
idRacconto=racconto_da_valutare)[:1]
if valutazione_racconto.count(
) == 0: # Non esiste nessuna valutazione, si crea quindi il record
valutazione_racconto = valutazione(idRacconto=racconto_da_valutare,
idValutatore=valutatore_concorso[0],
ranking=0,
selected=0)
else: # La valutazione esiste, si modifica quindi il record esistente
valutazione_racconto = valutazione.objects.all().get(
pk=valutazione_racconto[0].pk)
valutazione_racconto.selected = 0
# valutazione_racconto.ranking = 0
valutazione_racconto.save()
# LOG operazione
insert_log(
username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Deselezione racconto",
description=
"Deselezione racconto con id = {idRacconto} per il concorso con id = {id}"
.format(id=id_active_event(), idRacconto=pk_racconto),
)
return redirect('selezione_racconti',
page_number=page_number,
categoriaeta=categoriaeta)
def create_segretario(request):
# Controllo che l'utente sia un gestore
permissions = get_permission(request.user.email)
if not permissions["is_gestore"]: # Non è un gestore
return redirect('home')
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = segretarioModelForm(request.POST)
# check whether it's valid:
if form.is_valid():
email = form.cleaned_data['idUser']
# Controllo che non sia già stato inserito
# Se si invalido il form e lo restituisco
count = segretario.objects.filter(idUser=email).count()
# print(count)
if count > 0:
form.add_error("idUser", "Utente già inserito come segretario")
context = {'form': form, }
permissions = get_permission(request.user.email)
context.update(permissions)
return render(request, 'create_segretario.html', context)
# Controllo che sia un dipendente o uno studente e ne ricavo i dati
res = dipendente_email(email)
if res is None:
res = studente_email(email)
forename = res["nome"]
surname = res["cognome"]
segretario.objects.create(idUser=email, forename=forename, surname=surname)
# LOG operazione
insert_log(username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Creazione segretario",
description="Inserimento segretario {segretario}".format(segretario=email, )
)
return HttpResponseRedirect(reverse('list_segretario', ))
# if a GET (or any other method) we'll create a blank form
else:
form = segretarioModelForm()
context = {'form': form}
context.update(permissions)
return render(request, 'create_segretario.html', context)
def delete_segretario(request, pk_segretario):
# Controllo che l'utente sia un gestore
permissions = get_permission(request.user.email)
if not permissions["is_gestore"]: # Non è un gestore
return redirect('home')
# Cancellazione segretario
_segretario = get_object_or_404(segretario, pk=pk_segretario)
email = _segretario.idUser
_segretario.delete()
# LOG operazione
insert_log(username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Eliminazione segretario",
description="Eliminazione segretario {segretario}".format(segretario=email, )
)
return redirect('list_segretario')
def send_email(request, pk_event):
# Controllo che l'utente sia un segretario
permissions = get_permission(request.user.email)
if not permissions["is_segretario"]: # Non è un segretario
return redirect('home')
concorso = get_object_or_404(events, pk=pk_event)
messaggio_inviato = {'messaggio_inviato': False}
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = MailForm(request.POST)
# check whether it's valid:
if form.is_valid():
from html import unescape, escape
subject = form.cleaned_data["subject"]
body = form.cleaned_data["body"]
destinatari = form.cleaned_data["destinatari"]
# Modifica testo sostituendo i caratteri speciali in entities html
body = da_carattere_speciale_ad_entity(body)
body = body.replace('\n', '<br>')
# Ricavo la lista dei destinatari
if destinatari == "Tutti": # Tutti i valutatori per il concorso
lista_destinatari = valutatore.objects.filter(idEvent=concorso).values_list('idUser', flat=True)
descrizione_destinatari = "Tutti i membri della commissione"
elif destinatari == "Selezioni": # Tutti i valutatori per il concorso che non hanno selezionato tutti i racconti consentiti
destinatari = valutatore.objects.filter(idEvent=concorso) # .values_list('idUser', flat=True)
descrizione_destinatari = "Solo i membri della commissione che non hanno selezionato il numero massimo di racconti."
lista_destinatari = []
# Ricavo i valutatori che non hanno selezionato il numero massimo di racconti
for dest in destinatari:
if (get_numero_racconti_selezionati(dest) < concorso.maxSelections):
lista_destinatari.append(dest.idUser)
elif destinatari == "Valutazioni":
destinatari = valutatore.objects.filter(idEvent=concorso)
descrizione_destinatari = "Solo i membri della commissione che non hanno effettuato tutte le valutazioni per i racconti della categoria Junior e/o Senior"
lista_destinatari = []
# Ricavo i valutatori che non hanno valutazioni complete
for dest in destinatari:
classifiche = get_classifiche_valutatore(dest)
if None in list(classifiche.values()):
lista_destinatari.append(dest.idUser)
else: # Opzione non valida
return redirect('send_email', pk_event)
# for i in lista_destinatari:
# print(i)
# gmail = Gmail()
# message = gmail.send_message(sender="*****@*****.**", to="*****@*****.**",
# subject='Test', message="<p>Test messaggio</p>")
# Invio email
for i in lista_destinatari:
emailsender(subject, body, [i], [], [])
# LOG operazione
insert_log(username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Invio comunicazione",
description="Invio comunicazione a \"{descrizione_destinatari}\" per il concorso con id = {id}".format(
descrizione_destinatari=descrizione_destinatari, id=id_active_event()),
)
messaggio_inviato = {'messaggio_inviato': True}
# return redirect('send_email', pk_event)
# if a GET (or any other method) we'll create a blank form
else:
form = MailForm()
context = {'form': form, 'titolo_concorso': concorso.eventName,
'pk_event': pk_event, 'categorieeta': CATEGORIE_ETA, 'id_event': id_active_event(), }
context.update(permissions)
context.update(messaggio_inviato)
return render(request, 'send_email.html', context)
def create_racconto(request):
# Controllo se c'è un concorso attivo
idEvent = id_active_event()
permissions = get_permission(request.user.email)
if idEvent is not None:
# Calcolo informazioni del concorso da passare alla template
is_submittable = is_active_event_submittible(
) # Controllo se è possibile fare invio racconto
titolo_concorso = events.objects.all().get(pk=idEvent).eventName
# Controllo se l'autore ha già sottomesso il racconto
# in questo caso mostrerà il form solo in lettura
# CASO RACCONTO INVIATO
if is_submitted_in_active_event(request.user.email):
# print("RACCONTO INVIATO")
racconto_inviato = racconti.objects.filter(
idEvent=id_active_event(), idUser=request.user.email)[0]
# Costruisco il form da inviare per mostrare i dati del racconto
form = raccontiModelForm()
form.fields["title"] = forms.CharField(
label="Titolo del racconto",
max_length=128,
initial=racconto_inviato.title,
disabled=True)
form.fields["content"] = forms.CharField(
widget=forms.Textarea(attrs={
'rows': 20,
'maxlength': MAX_NUM_CHAR
}),
label="Testo del racconto ANONIMO (massimo " +
str(MAX_NUM_CHAR) + " caratteri)",
initial=racconto_inviato.content,
disabled=True)
form.fields["coAuthors"] = forms.CharField(
widget=forms.Textarea(attrs={
'rows': 10,
'maxlength': 8000
}),
label="Coautori in caso di testo collettivo (nome, cognome"
" e indirizzo email istituzionale)",
required=False,
initial=racconto_inviato.coAuthors,
disabled=True)
form.fields["contacts"] = forms.CharField(
label="Recapito telefonico",
max_length=128,
initial=racconto_inviato.contacts,
disabled=True)
form.fields["publishingPermission"] = forms.ChoiceField(
widget=forms.CheckboxInput(), # .RadioSelect(),
initial=racconto_inviato.publishingPermission,
choices=[(True, 'Si'), (False, 'No')],
label=
'Autorizzo la Biblioteca di Ateneo alla pubblicazione del mio racconto',
required=False,
disabled=True)
# form.fields["visioneregolamento"] = forms.ChoiceField(widget=forms.RadioSelect(),
# initial=True, choices=[(True, 'Si'), (False, 'No')],
# label='Dichiaro di aver preso visione del regolamento del concorso e di accettare le condizioni <a href="https://www.biblio.unimib.it/it/terza-missione/concorso-letterario" target="_blank">LINK</a>',
# required=False, disabled=True)
# form.fields["visioneinformativa"] = forms.ChoiceField(widget=forms.RadioSelect(),
# initial=True, choices=[(True, 'Si'), (False, 'No')],
# label="Dichiaro di aver preso visione dell'informativa privacy all'indirizzo <a href = 'https://www.unimib.it/sites/default/files/allegati/informativa_eventi_e_iniziative.pdf' target = '_blank' >LINK</a>",
# required=False, disabled=True)
context = {
'form': form,
'idEvent': idEvent,
'titolo_concorso': titolo_concorso,
'is_submitted_in_active_event': True,
'is_submittable': is_submittable,
'MAX_NUM_CHAR': None,
'is_not_valid_user': False
}
context.update(permissions)
return render(request, 'create_racconto.html', context)
# Controllo se il periodo delle sottomissioni è attivo
# (l'autore non ha inviato nessun racconto)
# CASO RACCONTO INVIABILE
elif is_submittable:
# print("RACCONTO INVIABILE")
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = raccontiModelForm(request.POST)
# check whether it's valid:
if form.is_valid():
# Estrazione dati da Esse3
user = studente_email(request.user.email)
if user is not None: # l'utente è di tipo @campus.unimib.it
authorSurname = user["cognome"]
authorForename = user["nome"]
authorBirthDate = codicefiscale.decode(
user["codFis"])["birthdate"]
authorStatus = "Studente"
authorDetail = user["tipoCorsoDes"] + " " + user[
"cdsDes"] + " " + user["cdsCod"]
else: # l'utente è di tipo @unimib.it
user = dipendente_email(request.user.email)
if user is None: # Si tratta ad esempio di una casella di struttura
print("is_not_valid_user")
return render(
request, 'create_racconto.html', {
'idEvent': idEvent,
'is_not_valid_user': True,
'titolo_concorso': titolo_concorso,
})
authorSurname = user["cognome"]
authorForename = user["nome"]
authorBirthDate = codicefiscale.decode(
user["codFis"])["birthdate"]
# print(authorBirthDate, type(authorBirthDate))
authorStatus = user["dsTipoRuolo"]
authorDetail = user["dsTipoRuolo"]
# Racconto da salvare
racconto = racconti(
counter=get_counter(),
idUser=request.user.email,
idEvent=events.objects.get(pk=id_active_event()),
title=form.cleaned_data["title"],
content=form.cleaned_data["content"],
submissionDate=datetime.now(),
publishingPermission=eval(
form.cleaned_data["publishingPermission"]),
contacts=form.cleaned_data["contacts"],
coAuthors=form.cleaned_data["coAuthors"],
authorSurname=authorSurname,
authorForename=authorForename,
authorBirthDate=authorBirthDate,
authorStatus=authorStatus,
authorDetail=authorDetail)
racconto.save()
# LOG operazione
insert_log(
username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Inserimento racconto",
description=
"Inserimento racconto con id = {idRacconto} per il concorso con id = {id}"
.format(id=id_active_event(), idRacconto=racconto.pk),
)
#Invio email di notifica all'utente
subject = "[Notifica invio racconto concorso - {concorso}]".format(
concorso=events.objects.all().get(
pk=idEvent).eventName)
body = "Il racconto da te inviato è stato memorizzato.<br><br><br><br>Questo messaggio è una notifica automatica, qualunque risposta verrà ignorata."
subject = subject.encode("utf8").decode()
body = body.encode("utf8").decode()
emailsender(subject, body, [request.user.email], [], [])
return HttpResponseRedirect(reverse('create_racconto'))
# if a GET (or any other method) we'll create a blank form
else:
form = raccontiModelForm()
# Controllo che il racconto non sia più inviabile
# in questo caso mostro il form vuoto in sola lettura
# (l'autore non ha inviato nessun racconto)
# CASO RACCONTO NON INVIATO E NON INVIABILE #
elif not is_submittable:
# print("RACCONTO NON INVIABILE")
form = raccontiModelForm()
form.fields["title"] = forms.CharField(label="Titolo del racconto",
max_length=128,
disabled=True)
form.fields["content"] = forms.CharField(
widget=forms.Textarea(attrs={
'rows': 20,
'maxlength': MAX_NUM_CHAR
}),
label="Testo del racconto ANONIMO (massimo " +
str(MAX_NUM_CHAR) + " caratteri)",
disabled=True)
form.fields["coAuthors"] = forms.CharField(
widget=forms.Textarea(attrs={
'rows': 10,
'maxlength': 8000
}),
label="Coautori in caso di testo collettivo (nome, cognome"
" e indirizzo email istituzionale)",
required=False,
disabled=True)
form.fields["contacts"] = forms.CharField(
label="Recapito telefonico", max_length=128, disabled=True)
form.fields["publishingPermission"] = forms.ChoiceField(
widget=forms.CheckboxInput(), # .RadioSelect(),
choices=[(True, 'Si'), (False, 'No')],
label=
'Autorizzo la Biblioteca di Ateneo alla pubblicazione del mio racconto',
required=False,
disabled=True)
# form.fields["visioneregolamento"] = forms.ChoiceField(widget=forms.RadioSelect(),
# initial=True, choices=[(True, 'Si'), (False, 'No')],
# label='Dichiaro di aver preso visione del regolamento del concorso e di accettare le condizioni <a href="https://www.biblio.unimib.it/it/terza-missione/concorso-letterario" target="_blank">LINK</a>',
# required=False, disabled=True)
# form.fields["visioneinformativa"] = forms.ChoiceField(widget=forms.RadioSelect(),
# initial=True, choices=[(True, 'Si'), (False, 'No')],
# label="Dichiaro di aver preso visione dell'informativa privacy all'indirizzo <a href = 'https://www.unimib.it/sites/default/files/allegati/informativa_eventi_e_iniziative.pdf' target = '_blank' >LINK</a>",
# required=False, disabled=True)
context = {
'form': form,
'idEvent': idEvent,
'titolo_concorso': titolo_concorso,
'is_submitted_in_active_event': False,
'is_submittable': is_submittable,
'MAX_NUM_CHAR': None,
'is_not_valid_user': False
}
context.update(permissions)
return render(request, 'create_racconto.html', context)
else:
form = raccontiModelForm()
context = {
'form': form,
'idEvent': idEvent,
'titolo_concorso': titolo_concorso,
'is_submitted_in_active_event': False,
'is_submittable': is_submittable,
'MAX_NUM_CHAR': MAX_NUM_CHAR,
'is_not_valid_user': False
}
context.update(permissions)
return render(request, 'create_racconto.html', context)
else:
context = {'idEvent': idEvent, 'is_not_valid_user': False}
context.update(permissions)
return render(request, 'create_racconto.html', context)
def votazione_racconto(request, counter_id_racconto, categoriaeta, classifica):
permission = get_permission(request.user.email)
# Controllo che l'utente sia un valutatore
if not permission['is_valutatore']:
return redirect('home')
# Controllo che il parametro classifica sia valido
try:
RANKING_POINT[classifica]
except:
return redirect('home')
# Controllo che il parametro categoriaeta sia valido
if categoriaeta not in CATEGORIE_ETA:
return redirect('home')
# Estraggo l'entry, se esiste, che associa la valutazione del racconto al valutatore
concorso = events.objects.all().get(pk=id_active_event())
valutatore_concorso = valutatore.objects.all().filter(
idEvent=concorso, idUser=request.user.email)[:1]
racconto = racconti.objects.all().filter(counter=counter_id_racconto,
idEvent=concorso)[:1]
# Controllo che il racconto esista
if racconto.count() == 0:
return redirect('home')
valutazione_racconto = valutazione.objects.all().filter(
idRacconto=racconto[0], idValutatore=valutatore_concorso[0])
if valutazione_racconto.count() == 0: # Non esiste entry, quindi la creo
valutazione_racconto = valutazione(idRacconto=racconto[0],
idValutatore=valutatore_concorso[0],
selected=0,
ranking=RANKING_POINT[classifica])
else: # L'entry esiste quindi la modifico
valutazione_racconto = valutazione.objects.get(
pk=valutazione_racconto[0].pk)
valutazione_racconto.ranking = RANKING_POINT[classifica]
valutazione_racconto.save()
# LOG operazione
insert_log(
username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Valutazione racconto",
description=
"Valutazione racconto con id = {id_racconto} con punteggio assegnato {ranking} per il concorso con id = {id}"
.format(id_racconto=valutazione_racconto.idRacconto.pk,
ranking=valutazione_racconto.ranking,
id=id_active_event()),
)
# Bisogna porre a 0 il ranking di tutte le valutazioni del valutatore che avevano
# valutazione_racconto.ranking = RANKING_POINT[classifica]
if categoriaeta == CATEGORIE_ETA[0]: # Valutazione per racconto Junior
valutazioni_da_aggiornare = valutazione.objects.filter(
idValutatore=valutatore_concorso,
idRacconto__authorBirthDate__gte=concorso.birthDateLimit,
ranking=RANKING_POINT[classifica]).exclude(
idRacconto=racconto[0],
idValutatore=valutatore_concorso[0]).update(ranking=0)
else: # Categoria senior
valutazioni_da_aggiornare = valutazione.objects.filter(
idValutatore=valutatore_concorso,
idRacconto__authorBirthDate__lt=concorso.birthDateLimit,
ranking=RANKING_POINT[classifica]).exclude(
idRacconto=racconto[0],
idValutatore=valutatore_concorso[0]).update(ranking=0)
print(valutazioni_da_aggiornare)
return redirect('votazione_racconti', categoriaeta=categoriaeta)
def create_valutatore(request, pk_event):
# Controllo che l'utente sia un gestore
utente_gestore = gestore.objects.filter(username=request.user.email)[:1]
if utente_gestore.count() == 0: # Non è un gestore
return redirect('home')
# print(pk_event)
# if this is a POST request we need to process the form data
permissions = get_permission(request.user.email)
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = valutatoreModelForm(request.POST)
# check whether it's valid:
if form.is_valid():
id_event = pk_event # id_active_event()
email = form.cleaned_data['idUser']
# Controllo che non sia già stato inserito per questo evento
# Se si invalido il form e lo restituisco
count = valutatore.objects.filter(idUser=email,
idEvent=id_event).count()
# print(count)
if count > 0:
form.add_error(
"idUser",
"Utente già inserito come valutatore per questo concorso")
context = {
'form': form,
'pk_event': pk_event,
'is_gestore': True
}
permissions = get_permission(request.user.email)
context.update(permissions)
return render(request, 'create_valutatore.html', context)
# Controllo che sia un dipendente o uno studente e ne ricavo i dati
res = dipendente_email(email)
if res is None:
res = studente_email(email)
forename = res["nome"]
surname = res["cognome"]
utente_valutatore = valutatore.objects.create(
idUser=email,
forename=forename,
surname=surname,
idEvent=events.objects.get(pk=id_event))
# LOG operazione
insert_log(
username=request.user.email,
operationDate=datetime.now(),
roleUser="******",
type="Inserimento valutatore",
description=
"Inserimento valutatore \"{utente_valutatore}\" per il concorso con id = {id}"
.format(
id=id_active_event(),
utente_valutatore=utente_valutatore.idUser,
))
return HttpResponseRedirect(
reverse('list_valutatore', kwargs={'pk_event': pk_event}))
# if a GET (or any other method) we'll create a blank form
else:
form = valutatoreModelForm()
context = {'form': form, 'pk_event': pk_event, 'is_gestore': True}
context.update(permissions)
return render(request, 'create_valutatore.html', context)