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 get(self, request, *args, **kwargs):
# Controllo che l'utente sia un segretario
permissions = get_permission(request.user.email)
if not permissions["is_segretario"]: # Non è un segretario
return redirect('home')
self.object_list = events.objects.all().order_by('id')
context = self.get_context_data(object_list=self.object_list)
permissions = get_permission(request.user.email)
context.update(permissions)
return self.render_to_response(context)
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 list_racconti_segreteria(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')
# Controllo che il pk_event corrisponda all'id di un evento esistente
concorso = get_object_or_404(events, pk=pk_event)
#controllo se il concorso sia quello attivo
#non si possonon cancellare racconti per concorsi non attivi
if id_active_event() is not None and concorso.pk == id_active_event():
is_active = True
else:
is_active = False
racconti_consegnati = get_racconti_consegnati_concorso(concorso)
context = {'racconti_consegnati': racconti_consegnati, 'titolo_concorso': concorso.eventName,
'categorieeta': CATEGORIE_ETA, 'limite_data': concorso.birthDateLimit, 'pk_event': pk_event,
'is_active' : is_active}
context.update(permissions)
return render(request, 'list_consegne_racconti_concorso.html', context)
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 list_valutatori_selezioni(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)
valutatori_concorso = concorso.valutatoriconcorso.all()
for valutatore in valutatori_concorso:
# Numero totale di racconti selezionati
valutatore.numero_racconti_selezionati = get_numero_racconti_selezionati(valutatore)
# Numero totale di racconti selezionati Junior
valutatore.numero_racconti_selezionati_junior = get_numero_racconti_selezionati_junior(valutatore)
# Numero totale di racconti selezionati Senior
valutatore.numero_racconti_selezionati_senior = get_numero_racconti_selezionati_senior(valutatore)
valutatori_concorso = sorted(valutatori_concorso, key=operator.attrgetter('idUser'), reverse=False)
# print(valutatori_concorso)
context = {'valutatori_concorso': valutatori_concorso, 'titolo_concorso': concorso.eventName,
'pk_event': pk_event, 'inizio_periodo_selezioni': concorso.selectionDateStart,
'scadenza_periodo_selezioni': concorso.selectionDateEnd, 'categorieeta': CATEGORIE_ETA, }
context.update(permissions)
context['max_num_racconti_selezionabili'] = concorso.maxSelections
return render(request, 'list_valutatori_selezioni.html', context)
def list_valutatori_classificazioni(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)
# Valutatori del concorso
valutatori_concorso = concorso.valutatoriconcorso.all().order_by("idUser")
# valutatori_concorso = sorted(valutatori_concorso, key=operator.attrgetter('idUser'), reverse=False)
for valutatore in valutatori_concorso:
valutatore.valutazioni = get_classifiche_valutatore(valutatore)
valutatori_concorso = sorted(valutatori_concorso, key=operator.attrgetter('idUser'), reverse=False)
# print(type(valutatori_concorso))
# print(valutatori_concorso)
context = {'valutatori_concorso': valutatori_concorso, 'titolo_concorso': concorso.eventName,
'pk_event': pk_event, 'categorieeta': CATEGORIE_ETA,
'inizio_periodo_classificazioni': concorso.classificationDateStart,
'scadenza_periodo_classificazioni': concorso.classificationDateEnd}
context.update(permissions)
return render(request, 'list_valutatori_classificazioni.html', context)
def homepage(request):
idEvent = id_active_event()
permissions = get_permission(request.user.email)
if idEvent is not None:
evento_attivo = events.objects.all().get(pk=idEvent)
# Numero di giorni rimasti alla scadenza del periodo valido per l'invio dei racconti
delta = evento_attivo.submissionDateEnd - timezone.now()
context = {
'idEvent':
idEvent,
'titolo_concorso':
evento_attivo.eventName,
'is_submittable':
is_active_event_submittible(),
'numero_racconti_inviati':
racconti.objects.filter(idEvent=evento_attivo).count(),
'numero_racconti_inviabili':
evento_attivo.maxSubmissions,
'posti_disponibili':
evento_attivo.maxSubmissions -
racconti.objects.filter(idEvent=evento_attivo).count(),
'delta':
delta.days,
}
context.update(permissions)
return render(request, "home.html", context=context)
return render(request, "home.html", context=permissions)
def login(request):
context = {}
if hasattr(request.user, 'email'):
permissions = get_permission(request.user.email)
context.update(permissions)
return render(request, "home_not_logged.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 get(self, request, *args, **kwargs):
# 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')
self.object_list = events.objects.all().order_by('id')
context = self.get_context_data(object_list=self.object_list)
permissions = get_permission(request.user.email)
context.update(permissions)
return self.render_to_response(context)
def list_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')
segretari_evento = segretario.objects.all().order_by('idUser')
context = {'segretari': segretari_evento, }
context.update(permissions)
return render(request, 'list_segretario.html', context)
def list_racconti_junior_senior(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)
racconti_junior_senior = get_racconti_junior_senior_classificati_concorso(concorso)
context = {'racconti_junior_senior': racconti_junior_senior, 'titolo_concorso': concorso.eventName,
'categorieeta': CATEGORIE_ETA, 'limite_data': concorso.birthDateLimit, 'pk_event': pk_event}
context.update(permissions)
return render(request, 'list_classifica_junior_senior_concorso.html', context)
def list_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')
permissions = get_permission(request.user.email)
valutatori_evento = valutatore.objects.filter(
idEvent=pk_event).order_by('idUser')
context = {
'valutatori': valutatori_evento,
'pk_event': pk_event,
'is_gestore': True
}
context.update(permissions)
return render(request, 'list_valutatore.html', context)
def list_selezioni_segreteria(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')
# Controllo che il pk_event corrisponda all'id di un evento esistente
concorso = get_object_or_404(events, pk=pk_event)
racconti_selezionati = get_racconti_selezionati_concorso(concorso)
context = {'racconti_selezionati': racconti_selezionati, 'titolo_concorso': concorso.eventName,
'categorieeta': CATEGORIE_ETA, 'limite_data': concorso.birthDateLimit, 'pk_event': pk_event}
context.update(permissions)
return render(request, 'list_selezioni_racconti_concorso.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 selezione_racconti(request, page_number=1, categoriaeta=CATEGORIE_ETA[0]):
idEvent = id_active_event()
permissions = get_permission(request.user.email)
# Controllo che il parametro categoriaeta sia valido
if categoriaeta not in CATEGORIE_ETA:
return redirect('home')
# Controlla se l'evento è attivo
if idEvent is None:
return render(request, "selezioni.html", context={'is_active': False})
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 è attivo più mostra il messaggio
if not is_selectable():
context = {
'is_selectable': False,
'is_active': True,
'categoriaeta': categoriaeta
}
context.update(permissions)
return render(request, "selezioni.html", context=context)
# Ricavo la lista dei racconti per l'evento con relative selezioni da parte del valutatore.
# e classificazione in categoria Junior o Senior
if categoriaeta == CATEGORIE_ETA[0]:
racconti_evento = racconti.objects.all().filter(
idEvent=idEvent, authorBirthDate__gte=concorso.birthDateLimit)
else:
racconti_evento = racconti.objects.all().filter(
idEvent=idEvent, authorBirthDate__lt=concorso.birthDateLimit)
lista_record_racconto = []
record_racconto = []
for racconto in racconti_evento:
# Cerco se il racconto sia già stato selezionato dall'autore
valutazione_racconto = \
valutazione.objects.all().filter(idRacconto=racconto, idValutatore=valutatore_concorso)[:1]
# Il racconto non è mai stato selezionato da questo valutatore
if valutazione_racconto.count() == 0:
record_racconto.append(False)
else:
# print(valutazione_racconto[0].pk, valutazione_racconto[0].selected)
record_racconto.append(valutazione_racconto[0].selected)
record_racconto.append(racconto.counter) # Counter racconto
# Calcolo categoria età
if racconto.authorBirthDate < concorso.birthDateLimit:
record_racconto.append(CATEGORIE_ETA[1]) # Status età
else:
record_racconto.append(CATEGORIE_ETA[0]) # Status età
record_racconto.append(racconto.title) # Titolo racconto
record_racconto.append(racconto.pk) # Id racconto
# Vedo se il racconto è stato marcato come letto dal valutatore loggato
raccontoletto = letturaracconto.objects.all().filter(
idRacconto=racconto, idValutatore=valutatore_concorso[0])[:1]
# Il racconto non è stato letto da questo valutatore
if raccontoletto.count() == 0:
record_racconto.append(False)
else:
record_racconto.append(True)
# print(raccontoletto)
# print("racconto",racconto)
# print("valutatore", valutatore_concorso)
lista_record_racconto.append(record_racconto)
record_racconto = []
# Numero dei racconti selezionati dall'utente
# numero_racconti_selezionati = valutazione.objects.all().filter(selected=True,
# idValutatore=valutatore_concorso,
# idValutatore__idEvent_id=concorso)
numero_racconti_selezionati = valutatore_concorso[
0].valutatorevalutazione.all().filter(selected=1).count()
# print(numero_racconti_selezionati)
# Paginazione risultati
paginator = Paginator(lista_record_racconto, NUM_PAGE)
# if request.GET.get('page') is None:
# page_number = 1
# else:
# page_number = request.GET.get('page')
# page_number = request.GET.get('page')
# print('page_number:', page_number)
page_obj = paginator.get_page(page_number)
# Non si possonopiù selezionare racconti
if numero_racconti_selezionati >= concorso.maxSelections:
is_possible_select = False
else:
is_possible_select = True
_is_only_readable = is_only_readable()
context = {
'record_set': page_obj,
'numero_racconti_selezionabili': concorso.maxSelections,
'numero_racconti_selezionati': numero_racconti_selezionati,
'is_only_readable': _is_only_readable,
'is_possible_select': is_possible_select,
'is_selectable': True,
'is_active': True,
'page_number': page_number,
'categoriaeta': categoriaeta,
}
context.update(permissions)
# return render(request, "selezioni.html", context={'record_set': lista_record_racconto})
return render(request, "selezioni.html", context=context)
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)
def votazione_racconti(request, categoriaeta):
idEvent = id_active_event()
permissions = get_permission(request.user.email)
# Controlla se l'evento è attivo
if idEvent is None:
context = {'is_active': False}
context.update(permissions)
return render(request, "votazioni.html", context=context)
# Controllo che il parametro categoriaeta sia valido
if categoriaeta not in CATEGORIE_ETA:
return redirect('home')
# Controllo che l'utente sia un valutatore
if not permissions['is_valutatore']:
return redirect('home')
# Se il periodo di classificazione non è ancora attivo o non lo è più mostra il messaggio
if not is_classifiable():
context = {'is_classifiable': False, 'is_active': True}
context.update(permissions)
return render(request, "votazioni.html", context=context)
concorso = events.objects.all().get(pk=idEvent)
if categoriaeta == CATEGORIE_ETA[0]:
# racconti categoria senior scelti dai valutatori del concorso
racconti_evento = racconti.objects.all(
).filter( # raccontovalutazione__idValutatore=valutatore_concorso[0],
raccontovalutazione__selected=True,
authorBirthDate__gte=concorso.birthDateLimit,
idEvent=concorso).only('counter', 'title', 'authorBirthDate',
'pk').distinct().order_by("counter")
else:
# racconti categoria junior scelti dai valutatori del concorso
racconti_evento = racconti.objects.all(
).filter( # raccontovalutazione__idValutatore=valutatore_concorso[0],
raccontovalutazione__selected=True,
authorBirthDate__lt=concorso.birthDateLimit,
idEvent=concorso).only('counter', 'title', 'authorBirthDate',
'pk').distinct().order_by("counter")
# print("racconti_evento", racconti_evento)
lista_record_racconto = []
record_racconto = []
for racconto in racconti_evento:
record_racconto.append(racconto.counter) # Counter racconto
# Calcolo categoria età
if racconto.authorBirthDate < concorso.birthDateLimit:
record_racconto.append(CATEGORIE_ETA[1]) # Status età
else:
record_racconto.append(CATEGORIE_ETA[0]) # Status età
record_racconto.append(racconto.title) # Titolo racconto
record_racconto.append(racconto.pk) # Id racconto
lista_record_racconto.append(record_racconto)
record_racconto = []
valutatore_concorso = valutatore.objects.all().filter(
idUser=request.user.email, idEvent=concorso)
classifica = get_classifiche_valutatore(valutatore_concorso[0])
context = {
'record_set': lista_record_racconto,
'numero_racconti_selezionabili': concorso.maxSelections,
'is_classifiable': True,
'is_active': True
}
context.update(permissions)
context.update(classifica)
return render(request, "votazioni.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_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)
