def crea_tesseramento(anno=None):
anno = anno or poco_fa().year
inizio_anno = poco_fa()
inizio_anno = inizio_anno.replace(day=1,
month=1,
hour=0,
minute=0,
second=0)
if anno:
inizio_anno = inizio_anno.replace(year=anno)
fine_soci = inizio_anno.replace(day=31,
month=3,
hour=23,
minute=59,
second=59)
t = Tesseramento.objects.create(stato=Tesseramento.APERTO,
inizio=inizio_anno,
fine_soci=fine_soci,
anno=anno,
quota_attivo=8,
quota_ordinario=8,
quota_benemerito=8,
quota_aspirante=8,
quota_sostenitore=8)
return t
def permessi_persona(persona):
"""
Permessi di ogni persona (nessuna delega).
:param persona: La persona.
:return: Lista di permessi.
"""
from anagrafica.models import Sede
from attivita.models import Attivita, Partecipazione
from base.utils import poco_fa
# Limiti di tempo per la centrale operativa
quindici_minuti_fa = poco_fa() - timedelta(
minutes=Attivita.MINUTI_CENTRALE_OPERATIVA)
tra_quindici_minuti = poco_fa() + timedelta(
minutes=Attivita.MINUTI_CENTRALE_OPERATIVA)
# Sedi per le quali sto effettuando un servizio di centrale operativa
sede_centrale_operativa = Sede.objects.filter(
Partecipazione.con_esito(
Partecipazione.ESITO_OK,
persona=persona,
).via("attivita__turni__partecipazioni"),
Q(
Q(attivita__centrale_operativa=Attivita.CO_AUTO)
| Q(attivita__centrale_operativa=Attivita.CO_MANUALE,
attivita__turni__partecipazioni__centrale_operativa=True)),
attivita__turni__inizio__lte=tra_quindici_minuti,
attivita__turni__fine__gte=quindici_minuti_fa,
)
return [(GESTIONE_CENTRALE_OPERATIVA_SEDE, sede_centrale_operativa)]
def permessi_persona(persona):
"""
Permessi di ogni persona (nessuna delega).
:param persona: La persona.
:return: Lista di permessi.
"""
from anagrafica.models import Sede
from attivita.models import Attivita, Partecipazione
from base.utils import poco_fa
# Limiti di tempo per la centrale operativa
quindici_minuti_fa = poco_fa() - timedelta(minutes=Attivita.MINUTI_CENTRALE_OPERATIVA)
tra_quindici_minuti = poco_fa() + timedelta(minutes=Attivita.MINUTI_CENTRALE_OPERATIVA)
# Sedi per le quali sto effettuando un servizio di centrale operativa
sede_centrale_operativa = Sede.objects.filter(
Partecipazione.con_esito(Partecipazione.ESITO_OK,
persona=persona,
).via("attivita__turni__partecipazioni"),
Q(
Q(attivita__centrale_operativa=Attivita.CO_AUTO)
| Q(attivita__centrale_operativa=Attivita.CO_MANUALE,
attivita__turni__partecipazioni__centrale_operativa=True)
),
attivita__turni__inizio__lte=tra_quindici_minuti,
attivita__turni__fine__gte=quindici_minuti_fa,
)
return [
(GESTIONE_CENTRALE_OPERATIVA_SEDE, sede_centrale_operativa)
]
def prossimo(self):
"""
Ritorna True il corso e' prossimo (inizia tra meno di due settimane).
"""
return (
poco_fa() <= self.data_inizio <= (poco_fa() + datetime.timedelta(15))
)
def crea_tesseramento(anno=None):
anno = anno or poco_fa().year
inizio_anno = poco_fa()
inizio_anno = inizio_anno.replace(day=1, month=1, hour=0, minute=0, second=0)
if anno:
inizio_anno = inizio_anno.replace(year=anno)
fine_soci = inizio_anno.replace(day=31, month=3, hour=23, minute=59, second=59)
t = Tesseramento.objects.create(
stato=Tesseramento.APERTO, inizio=inizio_anno, fine_soci=fine_soci,
anno=anno, quota_attivo=8, quota_ordinario=8, quota_benemerito=8,
quota_aspirante=8, quota_sostenitore=8
)
return t
def co_turni(request, me):
sedi = me.oggetti_permesso(GESTIONE_CENTRALE_OPERATIVA_SEDE)
tra_qualche_ora = poco_fa() + timedelta(hours=2)
qualche_ora_fa = poco_fa() - timedelta(hours=2)
partecipazioni = Partecipazione.con_esito_ok().filter(
Q(turno__attivita__sede__in=sedi), # Nelle mie sedi di competenza
Q(turno__inizio__lte=tra_qualche_ora, turno__fine__gte=qualche_ora_fa) # a) In corso, oppure
| Q(turno__coturni__montato_da__isnull=False,
turno__coturni__smontato_da__isnull=True) # d) Da smontare
).select_related('turno', 'turno__attivita', 'turno__attivita__sede')\
.order_by('turno__inizio', 'turno__fine', 'turno__id', 'persona__id')\
.distinct('turno__inizio', 'turno__fine', 'turno__id', 'persona__id')
contesto = {
"partecipazioni": partecipazioni,
}
return "centrale_operativa_turni.html", contesto
def test_registrazione_quota_socio_senza_fine_chiuso(self):
# Crea oggetti e nomina il delegato US
delegato = crea_persona()
utente = crea_utenza(delegato, email="*****@*****.**", password="******")
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
oggi = poco_fa()
inizio_anno = oggi.replace(month=1, day=1)
Tesseramento.objects.create(
stato=Tesseramento.CHIUSO, inizio=inizio_anno,
anno=inizio_anno.year, quota_attivo=8, quota_ordinario=8,
quota_benemerito=8, quota_aspirante=8, quota_sostenitore=8
)
sede.telefono = '+3902020202'
sede.email = '*****@*****.**'
sede.codice_fiscale = '01234567891'
sede.partita_iva = '01234567891'
sede.locazione = crea_locazione()
sede.save()
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': (oggi - datetime.timedelta(days=60)).strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
# tesseramento chiuso, quota non registrata
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'tesseramento {} è chiuso'.format(oggi.year))
def test_corso_pubblico(self):
"""
Un corso è visibile fino a FORMAZIONE_FINESTRA_CORSI_INIZIATI giorni dal suo inizio
"""
presidente = crea_persona()
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertTrue(CorsoBase.pubblici().exists())
self.assertFalse(corso.iniziato)
self.assertFalse(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
corso.data_inizio = oggi - timedelta(days=(settings.FORMAZIONE_FINESTRA_CORSI_INIZIATI - 1))
corso.save()
self.assertTrue(corso.iniziato)
self.assertFalse(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
self.assertTrue(CorsoBase.pubblici().exists())
corso.data_inizio = oggi - timedelta(days=settings.FORMAZIONE_FINESTRA_CORSI_INIZIATI)
corso.save()
self.assertTrue(corso.iniziato)
self.assertTrue(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
self.assertFalse(CorsoBase.pubblici().exists())
def crea_turno(attivita, inizio=None, fine=None, prenotazione=None,
minimo=1, massimo=10):
inizio = inizio or poco_fa()
fine = fine or poco_fa() + timedelta(hours=2)
prenotazione = prenotazione or inizio - timedelta(hours=1)
turno = Turno(
attivita=attivita,
inizio=inizio,
fine=fine,
prenotazione=prenotazione,
minimo=minimo,
massimo=massimo,
nome="Turno di test",
)
turno.save()
return turno
def aggiungi_delegato(self, tipo, persona, firmatario=None, inizio=None, fine=None):
"""
Aggiunge un delegato per l'oggetto. Nel caso in cui una nuova delega (attuale)
viene inserita, contemporaneamente ad una delega attuale per la stessa persona,
sempre attuale, questa ultima viene estesa. Assicura quindi l'assenza di duplicati.
:param tipo: Tipologia di delega.
:param persona: La Persona da delegare al trattamento dell'oggetto.
:param firmatario: Persona che inserisce la delega, opzionale.
:param inizio: Inizio della delega. Se non specificato, inizio immediato.
:param fine: Fine della delega. Se non specificato o None, fine indeterminata.
:return: Oggetto delegato inserito.
"""
if inizio is None:
inizio = poco_fa()
# Se il nuovo inserimento e' attuale
if inizio <= timezone.now() and (fine is None or fine >= timezone.now()):
# Cerca eventuali deleghe pari gia' esistenti.
delega_pari = self.deleghe_attuali().filter(persona=persona, tipo=tipo)
# Se esiste, estende se necessario, e ritorna la delega passata
if delega_pari.exists():
delega_pari = delega_pari[0]
delega_pari.inizio = min(delega_pari.inizio, inizio)
delega_pari.fine = None if fine is None or delega_pari.fine is None else max(delega_pari.fine, fine)
delega_pari.save()
return delega_pari
# Aggiungi la nuova delega.
Delega = apps.get_model(app_label='anagrafica', model_name='Delega')
d = Delega(oggetto=self, persona=persona, inizio=inizio, fine=fine, tipo=tipo, firmatario=firmatario)
d.save()
return d
def attivita_organizza(request, me):
aree = me.oggetti_permesso(GESTIONE_ATTIVITA_AREA)
sedi = Sede.objects.filter(aree__in=aree)
if not aree:
return messaggio_generico(request, me, titolo="Crea un'area di intervento, prima!",
messaggio="Le aree di intervento fungono da 'contenitori' per le "
"attività. Per organizzare un'attività, è necessario creare "
"almeno un'area di intervento. ",
torna_titolo="Gestisci le Aree di intervento",
torna_url="/attivita/aree/")
modulo_referente = ModuloOrganizzaAttivitaReferente(request.POST or None)
modulo = ModuloOrganizzaAttivita(request.POST or None)
modulo.fields['area'].queryset = aree
if modulo_referente.is_valid() and modulo.is_valid():
attivita = modulo.save(commit=False)
attivita.sede = attivita.area.sede
attivita.estensione = attivita.sede.comitato
attivita.save()
if modulo_referente.cleaned_data['scelta'] == modulo_referente.SONO_IO:
# Io sono il referente.
attivita.aggiungi_delegato(REFERENTE, me, firmatario=me, inizio=poco_fa())
return redirect(attivita.url_modifica)
else: # Il referente e' qualcun altro.
return redirect("/attivita/organizza/%d/referenti/" % (attivita.pk,))
contesto = {
"modulo": modulo,
"modulo_referente": modulo_referente,
}
return 'attivita_organizza.html', contesto
def test_corso_pubblico(self):
"""
Un corso è visibile fino a FORMAZIONE_FINESTRA_CORSI_INIZIATI giorni dal suo inizio
"""
presidente = crea_persona()
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertTrue(CorsoBase.pubblici().exists())
self.assertFalse(corso.iniziato)
self.assertFalse(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
corso.data_inizio = oggi - timedelta(days=(settings.FORMAZIONE_FINESTRA_CORSI_INIZIATI - 1))
corso.save()
self.assertTrue(corso.iniziato)
self.assertFalse(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
self.assertTrue(CorsoBase.pubblici().exists())
corso.data_inizio = oggi - timedelta(days=settings.FORMAZIONE_FINESTRA_CORSI_INIZIATI)
corso.save()
self.assertTrue(corso.iniziato)
self.assertTrue(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
self.assertFalse(CorsoBase.pubblici().exists())
def import_import_volontari(risultato):
i = 0
for p in risultato:
if _ha_errore(p):
continue
dati = _ottieni_dati(p)
dati_persona = {
x: y
for x, y in dati.items() if x in [
"nome", "cognome", "codice_fiscale", "data_nascita",
"comune_nascita", "provincia_nascita", "stato_nascita",
"stato_residenza", "cap_residenza", "indirizzo_residenza",
"comune_residenza", "email_contatto"
]
}
try:
persona = Persona.objects.get(
codice_fiscale__iexact=dati_persona['codice_fiscale'])
except Persona.DoesNotExist:
persona = Persona(**dati_persona)
persona.save()
if dati['telefono']:
persona.aggiungi_numero_telefono(dati['telefono'], servizio=False)
if dati['telefono_servizio']:
persona.aggiungi_numero_telefono(dati['telefono_servizio'],
servizio=True)
for app in persona.appartenenze_attuali():
app.fine = poco_fa()
app.save()
# Cancella aspirante associato
Aspirante.objects.filter(persona=persona).delete()
app = Appartenenza(
persona=persona,
sede=dati['sede'],
inizio=dati['data_ingresso'],
membro=Appartenenza.VOLONTARIO,
)
app.save()
if dati['email'] and not Utenza.objects.filter(
persona=persona).exists():
# Non ha utenza
if not Utenza.objects.filter(email__iexact=dati['email']):
# Non esiste, prova a creare
u = Utenza(persona=persona, email=dati['email'])
u.save()
u.genera_credenziali()
i += 1
return i
def test_localizzatore_solo_italia(self):
presidente = crea_persona()
sede = crea_sede(presidente)
area = Area.objects.create(
nome="6",
obiettivo=6,
sede=sede,
)
attivita = Attivita.objects.create(
stato=Attivita.VISIBILE,
nome="Att 1",
apertura=Attivita.APERTA,
area=area,
descrizione="1",
sede=sede,
estensione=sede,
)
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=poco_fa() + datetime.timedelta(days=7),
data_esame=poco_fa()+ datetime.timedelta(days=14),
progressivo=1,
anno=poco_fa().year,
descrizione='Un corso',
)
sessione = self.sessione_utente(persona=presidente, wait_time=2)
sessione.visit("%s/presidente/sedi/%s/" % (self.live_server_url, sede.pk))
with sessione.get_iframe(0) as iframe:
self.assertEqual(len(iframe.find_by_xpath('//select[@name="stato"]/option[@value="EC"]')), 0)
self.assertEqual(len(iframe.find_by_xpath('//select[@name="stato"]/option[@value="IT"]')), 1)
sessione.visit("%s/attivita/scheda/%s/modifica/" % (self.live_server_url, attivita.pk))
with sessione.get_iframe(0) as iframe:
self.assertEqual(len(iframe.find_by_xpath('//select[@name="stato"]/option[@value="IT"]')), 1)
self.assertEqual(len(iframe.find_by_xpath('//select[@name="stato"]/option[@value="EC"]')), 1)
sessione.visit("%s/aspirante/corso-base/%s/modifica/" % (self.live_server_url, corso.pk))
with sessione.get_iframe(0) as iframe:
self.assertEqual(len(iframe.find_by_xpath('//select[@name="stato"]/option[@value="EC"]')), 0)
self.assertEqual(len(iframe.find_by_xpath('//select[@name="stato"]/option[@value="IT"]')), 1)
def test_segmento_anzianita(self):
meno_di_tre_anni_fa = poco_fa() - timedelta(days=360*3)
meno_di_due_anni_fa = poco_fa() - timedelta(days=360*2)
meno_di_un_anno_fa = poco_fa() - timedelta(days=360)
presidente = crea_persona()
persona_1 = crea_persona()
persona_2 = crea_persona()
persona_3 = crea_persona()
presidente, sede, _ = crea_persona_sede_appartenenza(presidente)
Appartenenza.objects.create(
persona=persona_1,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=meno_di_tre_anni_fa,
confermata=True
)
Appartenenza.objects.create(
persona=persona_2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=meno_di_due_anni_fa,
confermata=True
)
Appartenenza.objects.create(
persona=persona_3,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=meno_di_un_anno_fa,
confermata=True
)
meno_di_un_anno = volontari_meno_un_anno(Persona.objects.all())
self.assertEqual(meno_di_un_anno.count(), 1)
self.assertEqual(meno_di_un_anno.get(), persona_3)
meno_di_due_anni = volontari_piu_un_anno(Persona.objects.all())
self.assertEqual(meno_di_due_anni.count(), 3)
self.assertTrue(presidente in meno_di_due_anni)
self.assertTrue(persona_1 in meno_di_due_anni)
self.assertTrue(persona_2 in meno_di_due_anni)
def aspirante_corso_base_attiva(request, me, pk):
corso = get_object_or_404(CorsoBase, pk=pk)
if not me.permessi_almeno(corso, MODIFICA):
return redirect(ERRORE_PERMESSI)
if corso.stato != corso.PREPARAZIONE:
return messaggio_generico(
request,
me,
titolo="Il corso è già attivo",
messaggio="Non puoi attivare un corso già attivo",
torna_titolo="Torna al Corso",
torna_url=corso.url)
if not corso.attivabile():
return errore_generico(
request,
me,
titolo="Impossibile attivare questo corso",
messaggio="Non sono soddisfatti tutti i criteri di attivazione. "
"Torna alla pagina del corso e verifica che tutti i "
"criteri siano stati soddisfatti prima di attivare un "
"nuovo corso.",
torna_titolo="Torna al Corso",
torna_url=corso.url)
if corso.data_inizio < poco_fa():
return errore_generico(
request,
me,
titolo="Impossibile attivare un corso già iniziato",
messaggio=
"Siamo spiacenti, ma non possiamo attivare il corso e inviare "
"le e-mail a tutti gli aspiranti nella zona se il corso è "
"già iniziato. Ti inviato a verificare i dati del corso.",
torna_titolo="Torna al Corso",
torna_url=corso.url)
corpo = {"corso": corso, "persona": me}
testo = get_template("email_aspirante_corso_inc_testo.html").render(corpo)
if request.POST:
corso.attiva(rispondi_a=me)
return messaggio_generico(
request,
me,
titolo="Corso attivato con successo",
messaggio=
"A breve tutti gli aspiranti nelle vicinanze verranno informati "
"dell'attivazione di questo corso base.",
torna_titolo="Torna al Corso",
torna_url=corso.url)
contesto = {
"corso": corso,
"puo_modificare": True,
"testo": testo,
}
return 'aspirante_corso_base_scheda_attiva.html', contesto
def test_registrazione_quota_socio_inizio_anno(self):
# Crea oggetti e nomina il delegato US
delegato = crea_persona()
utente = crea_utenza(delegato, email="*****@*****.**", password="******")
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
oggi = poco_fa()
inizio_anno = oggi.replace(month=1, day=1)
fine_soci = inizio_anno.replace(month=3) - datetime.timedelta(days=1)
post_fine_soci = fine_soci + datetime.timedelta(days=2)
Tesseramento.objects.create(
stato=Tesseramento.APERTO, inizio=inizio_anno, fine_soci=fine_soci,
anno=inizio_anno.year, quota_attivo=8, quota_ordinario=8, quota_benemerito=8,
quota_aspirante=8, quota_sostenitore=8
)
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': post_fine_soci.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'non può essere nel futuro')
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Necessario impostare indirizzo del Comitato')
sede.telefono = '+3902020202'
sede.email = '*****@*****.**'
sede.codice_fiscale = '01234567891'
sede.partita_iva = '01234567891'
sede.locazione = crea_locazione()
sede.save()
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
def test_invito_aspirante(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
p = InvitoCorsoBase(persona=aspirante1, corso=corso, invitante=presidente)
p.save()
p.richiedi()
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
self.assertEqual(aspirante1.autorizzazioni_in_attesa().count(), 1)
aspirante1.autorizzazioni_in_attesa()[0].concedi()
self.assertEqual(len(mail.outbox), 3)
email_aspirante = False
email_presidente = False
for email in mail.outbox[1:]:
if aspirante1.email_contatto in email.to:
email_aspirante = True
self.assertTrue(email.subject.find('Iscrizione a Corso Base') > -1)
elif presidente.email_contatto in email.to:
email_presidente = True
self.assertTrue(email.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
else:
raise AssertionError('Email a destinatario sconosciuto {}'.format(email.to))
self.assertTrue(email_aspirante)
self.assertTrue(email_presidente)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
self.assertFalse(corso.inviti.exists())
self.assertEqual(corso.partecipazioni.count(), 1)
def test_invito_aspirante(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
p = InvitoCorsoBase(persona=aspirante1, corso=corso, invitante=presidente)
p.save()
p.richiedi()
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
self.assertEqual(aspirante1.autorizzazioni_in_attesa().count(), 1)
aspirante1.autorizzazioni_in_attesa()[0].concedi()
self.assertEqual(len(mail.outbox), 3)
email_aspirante = False
email_presidente = False
for email in mail.outbox[1:]:
if aspirante1.email_contatto in email.to:
email_aspirante = True
self.assertTrue(email.subject.find('Iscrizione a Corso Base') > -1)
elif presidente.email_contatto in email.to:
email_presidente = True
self.assertTrue(email.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
else:
raise AssertionError('Email a destinatario sconosciuto {}'.format(email.to))
self.assertTrue(email_aspirante)
self.assertTrue(email_presidente)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
self.assertFalse(corso.inviti.exists())
self.assertEqual(corso.partecipazioni.count(), 1)
def co_reperibilita(request, me):
sedi = me.oggetti_permesso(GESTIONE_CENTRALE_OPERATIVA_SEDE)
ora = poco_fa()
reperibilita = Reperibilita.query_attuale(Appartenenza.query_attuale(sede__in=sedi).via("persona__appartenenze"),
al_giorno=ora).order_by('attivazione', '-creazione')
contesto = {
"reperibilita": reperibilita,
"ora": ora,
}
return "centrale_operativa_reperibilita.html", contesto
def test_aspirante_confermato(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
sede = crea_sede(presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso)
partecipazione1.richiedi()
for autorizzazione in partecipazione1.autorizzazioni:
autorizzazione.concedi(firmatario=presidente, modulo=None)
partecipazione1.refresh_from_db()
dati = {
'ammissione': PartecipazioneCorsoBase.AMMESSO,
'motivo_non_ammissione': None,
'esito_parte_1': PartecipazioneCorsoBase.POSITIVO,
'argomento_parte_1': 'blah',
'esito_parte_2': PartecipazioneCorsoBase.POSITIVO,
'argomento_parte_2': 'bla',
'extra_1': False,
'extra_2': False,
'destinazione': sede.pk,
}
modulo = FormVerbaleCorso(
data=dati, generazione_verbale=True, instance=partecipazione1,
)
modulo.fields['destinazione'].queryset = corso.possibili_destinazioni()
modulo.fields['destinazione'].initial = corso.sede
self.assertTrue(modulo.is_valid())
modulo.save()
corso.termina(presidente)
self.assertFalse(Aspirante.objects.all().exists())
aspirante1 = Persona.objects.get(pk=aspirante1.pk)
with self.assertRaises(ObjectDoesNotExist):
self.assertFalse(aspirante1.aspirante)
def test_aspirante_confermato(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
sede = crea_sede(presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso)
partecipazione1.richiedi()
for autorizzazione in partecipazione1.autorizzazioni:
autorizzazione.concedi(firmatario=presidente, modulo=None)
partecipazione1.refresh_from_db()
dati = {
'ammissione': PartecipazioneCorsoBase.AMMESSO,
'motivo_non_ammissione': None,
'esito_parte_1': PartecipazioneCorsoBase.POSITIVO,
'argomento_parte_1': 'blah',
'esito_parte_2': PartecipazioneCorsoBase.POSITIVO,
'argomento_parte_2': 'bla',
'extra_1': False,
'extra_2': False,
'destinazione': sede.pk,
}
modulo = ModuloVerbaleAspiranteCorsoBase(
data=dati, generazione_verbale=True, instance=partecipazione1,
)
modulo.fields['destinazione'].queryset = corso.possibili_destinazioni()
modulo.fields['destinazione'].initial = corso.sede
self.assertTrue(modulo.is_valid())
modulo.save()
corso.termina(presidente)
self.assertFalse(Aspirante.objects.all().exists())
aspirante1 = Persona.objects.get(pk=aspirante1.pk)
with self.assertRaises(ObjectDoesNotExist):
self.assertFalse(aspirante1.aspirante)
def attivita_reperibilita(request, me):
reperibilita = me.reperibilita.all()[:50]
modulo = ModuloNuovaReperibilita(request.POST or None, initial={
"inizio": poco_fa() + timedelta(hours=1),
"fine": poco_fa() + timedelta(hours=2),
})
if modulo.is_valid():
r = modulo.save(commit=False)
r.persona = me
r.save()
return redirect("/attivita/reperibilita/")
contesto = {
"reperibilita": reperibilita,
"modulo": modulo,
}
return "attivita_reperibilita.html", contesto
def test_autocomplete_sostentitore_aspirante(self):
direttore, sede, appartenenza = crea_persona_sede_appartenenza()
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante1.save()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.nome_completo))
self.assertNotContains(response, aspirante1.nome_completo)
# Creiamo aspirante
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
aspirante2.save()
# Se è solo aspirante viene selezionato
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
# Con un appartenenza come volontario non è più selezionabile
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
# Dimettiamolo
aspirante2.espelli()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertContains(response, aspirante2.nome_completo)
# Reintegriamolo
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=poco_fa(),
)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
def co_turni_monta(request, me, partecipazione_pk=None):
p = get_object_or_404(Partecipazione, pk=partecipazione_pk)
if p.turno.attivita.sede not in me.oggetti_permesso(GESTIONE_CENTRALE_OPERATIVA_SEDE):
return redirect(ERRORE_PERMESSI)
coturno = p.coturno()
if coturno is not None:
return redirect("/centrale-operativa/turni/")
coturno = Turno(turno=p.turno, persona=p.persona, montato_da=me, montato_data=poco_fa())
coturno.save()
return redirect("/centrale-operativa/turni/")
def import_import_volontari(risultato):
i = 0
for p in risultato:
if _ha_errore(p):
continue
dati = _ottieni_dati(p)
dati_persona = {x: y for x, y in dati.items() if x in [
"nome", "cognome", "codice_fiscale", "data_nascita", "comune_nascita",
"provincia_nascita", "stato_nascita", "stato_residenza",
"cap_residenza", "indirizzo_residenza", "comune_residenza",
"email_contatto"
]}
try:
persona = Persona.objects.get(codice_fiscale__iexact=dati_persona['codice_fiscale'])
except Persona.DoesNotExist:
persona = Persona(**dati_persona)
persona.save()
if dati['telefono']:
persona.aggiungi_numero_telefono(dati['telefono'], servizio=False)
if dati['telefono_servizio']:
persona.aggiungi_numero_telefono(dati['telefono_servizio'], servizio=True)
for app in persona.appartenenze_attuali():
app.fine = poco_fa()
app.save()
# Cancella aspirante associato
Aspirante.objects.filter(persona=persona).delete()
app = Appartenenza(
persona=persona,
sede=dati['sede'],
inizio=dati['data_ingresso'],
membro=Appartenenza.VOLONTARIO,
)
app.save()
if dati['email'] and not Utenza.objects.filter(persona=persona).exists():
# Non ha utenza
if not Utenza.objects.filter(email__iexact=dati['email']):
# Non esiste, prova a creare
u = Utenza(persona=persona, email=dati['email'])
u.save()
u.genera_credenziali()
i += 1
return i
def test_autocomplete_sostentitore_aspirante(self):
direttore, sede, appartenenza = crea_persona_sede_appartenenza()
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante1.save()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.nome_completo))
self.assertNotContains(response, aspirante1.nome_completo)
# Creiamo aspirante
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
aspirante2.save()
# Se è solo aspirante viene selezionato
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
# Con un appartenenza come volontario non è più selezionabile
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
# Dimettiamolo
aspirante2.espelli()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertContains(response, aspirante2.nome_completo)
# Reintegriamolo
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=poco_fa(),
)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
def crea_turno(attivita,
inizio=None,
fine=None,
prenotazione=None,
minimo=1,
massimo=10):
inizio = inizio or poco_fa()
fine = fine or poco_fa() + timedelta(hours=2)
prenotazione = prenotazione or inizio - timedelta(hours=1)
turno = Turno(
attivita=attivita,
inizio=inizio,
fine=fine,
prenotazione=prenotazione,
minimo=minimo,
massimo=massimo,
nome="Turno di test",
)
turno.save()
return turno
def pagamento_quota_nuovo_volontario(self):
"""
Testa che un nuovo volontario sia in grado di registarare
la quota nell'anno in cui è diventato volontario
"""
delegato = crea_persona()
utente = crea_utenza(delegato, email="*****@*****.**", password="******")
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
sede.telefono = '+3902020202'
sede.email = '*****@*****.**'
sede.codice_fiscale = '01234567891'
sede.partita_iva = '01234567891'
sede.locazione = crea_locazione()
sede.save()
appartenenza.inizio = poco_fa().replace(month=8)
appartenenza.save()
oggi = poco_fa().replace(month=9)
inizio_anno = oggi.replace(month=1, day=1)
fine_soci = inizio_anno.replace(month=3) - datetime.timedelta(days=1)
fine_anno = inizio_anno.replace(month=12) - datetime.timedelta(days=31)
Tesseramento.objects.create(
stato=Tesseramento.APERTO, inizio=inizio_anno, fine_soci=fine_soci,
anno=inizio_anno.year, quota_attivo=8, quota_ordinario=8, quota_benemerito=8,
quota_aspirante=8, quota_sostenitore=8, fine_soci_nv=fine_anno
)
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
def attivita_gruppi_gruppo_espelli(request, me, pk, persona_pk):
"""
Abbandona un gruppo.
"""
gruppo = get_object_or_404(Gruppo, pk=pk)
if not me.permessi_almeno(gruppo, MODIFICA):
return redirect(ERRORE_PERMESSI)
persona = get_object_or_404(Persona, pk=persona_pk)
Appartenenza.query_attuale().filter(gruppo=gruppo,
persona=persona).update(fine=poco_fa())
return redirect("/attivita/gruppi/%d/?espulso=%d" %
(gruppo.pk, persona.pk))
def attivita_organizza(request, me):
aree = me.oggetti_permesso(GESTIONE_ATTIVITA_AREA)
sedi = Sede.objects.filter(aree__in=aree)
if not aree:
return messaggio_generico(
request,
me,
titolo="Crea un'area di intervento, prima!",
messaggio="Le aree di intervento fungono da 'contenitori' per le "
"attività. Per organizzare un'attività, è necessario creare "
"almeno un'area di intervento. ",
torna_titolo="Gestisci le Aree di intervento",
torna_url="/attivita/aree/")
modulo_referente = ModuloOrganizzaAttivitaReferente(request.POST or None)
modulo = ModuloOrganizzaAttivita(request.POST or None)
modulo.fields['area'].queryset = aree
if modulo_referente.is_valid() and modulo.is_valid():
attivita = modulo.save(commit=False)
attivita.sede = attivita.area.sede
attivita.estensione = attivita.sede.comitato
attivita.save()
# Crea gruppo per questa specifica attività se la casella viene selezionata.
crea_gruppo = modulo.cleaned_data['gruppo']
if crea_gruppo:
area = attivita.area
gruppo = Gruppo.objects.create(
nome=attivita.nome,
sede=attivita.sede,
obiettivo=area.obiettivo,
attivita=attivita,
estensione=attivita.estensione.estensione,
area=area)
gruppo.aggiungi_delegato(REFERENTE_GRUPPO, me)
if modulo_referente.cleaned_data['scelta'] == modulo_referente.SONO_IO:
# Io sono il referente.
attivita.aggiungi_delegato(REFERENTE,
me,
firmatario=me,
inizio=poco_fa())
return redirect(attivita.url_modifica)
else: # Il referente e' qualcun altro.
return redirect("/attivita/organizza/%d/referenti/" %
(attivita.pk, ))
contesto = {
"modulo": modulo,
"modulo_referente": modulo_referente,
}
return 'attivita_organizza.html', contesto
def test_aggiungi_aspirante_multiplo(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.client.login(username=presidente.email_contatto, password='******')
# Iscrizione aspirante
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.partecipazioni.count(), 0)
self.assertEqual(corso.inviti.count(), 1)
self.assertContains(response, aspirante1.nome_completo)
self.assertContains(response, 'In attesa')
# Correttezza email di invito
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(
email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertContains(response, 'Già invitato')
def test_aggiungi_aspirante_multiplo(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.client.login(username=presidente.email_contatto, password='******')
# Iscrizione aspirante
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.partecipazioni.count(), 0)
self.assertEqual(corso.inviti.count(), 1)
self.assertContains(response, aspirante1.nome_completo)
self.assertContains(response, 'In attesa')
# Correttezza email di invito
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(
email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertContains(response, 'Già invitato')
def attivita_gruppi_gruppo_abbandona(request, me, pk):
"""
Abbandona un gruppo.
"""
gruppo = get_object_or_404(Gruppo, pk=pk)
Appartenenza.query_attuale().filter(
gruppo=gruppo, persona=me
).update(fine=poco_fa())
return messaggio_generico(request, me, titolo="Hai abbandonato il gruppo",
messaggio="Non fai più parte del gruppo '%s'. <br />"
"Sei stato disiscritto con successo." % (
gruppo.nome,
), torna_titolo="Torna all'elenco dei gruppi",
torna_url="/attivita/gruppi/")
def attivita_gruppi_gruppo_espelli(request, me, pk, persona_pk):
"""
Abbandona un gruppo.
"""
gruppo = get_object_or_404(Gruppo, pk=pk)
if not me.permessi_almeno(gruppo, MODIFICA):
return redirect(ERRORE_PERMESSI)
persona = get_object_or_404(Persona, pk=persona_pk)
Appartenenza.query_attuale().filter(
gruppo=gruppo, persona=persona
).update(fine=poco_fa())
return redirect("/attivita/gruppi/%d/?espulso=%d" % (
gruppo.pk, persona.pk
))
def test_pulizia_aspiranti(self):
presidente = crea_persona()
sede = crea_sede(presidente)
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=poco_fa() + timedelta(days=7),
data_esame=poco_fa() + timedelta(days=14),
progressivo=1,
anno=poco_fa().year,
descrizione='Un corso',
)
for x in range(30):
persona = crea_persona()
Aspirante.objects.create(persona=persona, locazione = sede.locazione)
PartecipazioneCorsoBase.objects.create(persona=persona, corso=corso, confermata=True)
if x % 4 == 1:
crea_appartenenza(persona, sede)
elif x % 4 == 2:
app = crea_appartenenza(persona, sede)
app.fine = poco_fa()
app.save()
elif x % 4 == 3:
app = crea_appartenenza(persona, sede)
app.membro = Appartenenza.SOSTENITORE
app.save()
vol = Aspirante._anche_volontari()
persone = Persona.objects.filter(pk__in=vol.values_list('persona', flat=True))
self.assertEqual(len(vol), 8)
Aspirante.pulisci_volontari()
for persona in persone:
self.assertFalse(hasattr(persona, 'aspirante'))
self.assertTrue(persona.partecipazioni_corsi.esito_esame, PartecipazioneCorsoBase.IDONEO)
def test_pulizia_aspiranti(self):
presidente = crea_persona()
sede = crea_sede(presidente)
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=poco_fa() + timedelta(days=7),
data_esame=poco_fa() + timedelta(days=14),
progressivo=1,
anno=poco_fa().year,
descrizione='Un corso',
)
for x in range(30):
persona = crea_persona()
Aspirante.objects.create(persona=persona, locazione = sede.locazione)
PartecipazioneCorsoBase.objects.create(persona=persona, corso=corso, confermata=True)
if x % 4 == 1:
crea_appartenenza(persona, sede)
elif x % 4 == 2:
app = crea_appartenenza(persona, sede)
app.fine = poco_fa()
app.save()
elif x % 4 == 3:
app = crea_appartenenza(persona, sede)
app.membro = Appartenenza.SOSTENITORE
app.save()
vol = Aspirante._anche_volontari()
persone = Persona.objects.filter(pk__in=vol.values_list('persona', flat=True))
self.assertEqual(len(vol), 8)
Aspirante.pulisci_volontari()
for persona in persone:
self.assertFalse(hasattr(persona, 'aspirante'))
self.assertTrue(persona.partecipazioni_corsi.esito_esame, PartecipazioneCorsoBase.IDONEO)
def attivita_gruppi_gruppo_abbandona(request, me, pk):
"""
Abbandona un gruppo.
"""
gruppo = get_object_or_404(Gruppo, pk=pk)
Appartenenza.query_attuale().filter(gruppo=gruppo,
persona=me).update(fine=poco_fa())
return messaggio_generico(
request,
me,
titolo="Hai abbandonato il gruppo",
messaggio="Non fai più parte del gruppo '%s'. <br />"
"Sei stato disiscritto con successo." % (gruppo.nome, ),
torna_titolo="Torna all'elenco dei gruppi",
torna_url="/attivita/gruppi/")
def aggiungi_delegato(self,
tipo,
persona,
firmatario=None,
inizio=None,
fine=None):
"""
Aggiunge un delegato per l'oggetto. Nel caso in cui una nuova delega (attuale)
viene inserita, contemporaneamente ad una delega attuale per la stessa persona,
sempre attuale, questa ultima viene estesa. Assicura quindi l'assenza di duplicati.
:param tipo: Tipologia di delega.
:param persona: La Persona da delegare al trattamento dell'oggetto.
:param firmatario: Persona che inserisce la delega, opzionale.
:param inizio: Inizio della delega. Se non specificato, inizio immediato.
:param fine: Fine della delega. Se non specificato o None, fine indeterminata.
:return: Oggetto delegato inserito.
"""
if inizio is None:
inizio = poco_fa()
# Se il nuovo inserimento e' attuale
if inizio <= timezone.now() and (fine is None
or fine >= timezone.now()):
# Cerca eventuali deleghe pari gia' esistenti.
delega_pari = self.deleghe_attuali().filter(persona=persona,
tipo=tipo)
# Se esiste, estende se necessario, e ritorna la delega passata
if delega_pari.exists():
delega_pari = delega_pari[0]
delega_pari.inizio = min(delega_pari.inizio, inizio)
delega_pari.fine = None if fine is None or delega_pari.fine is None else max(
delega_pari.fine, fine)
delega_pari.save()
return delega_pari
# Aggiungi la nuova delega.
Delega = apps.get_model(app_label='anagrafica', model_name='Delega')
d = Delega(oggetto=self,
persona=persona,
inizio=inizio,
fine=fine,
tipo=tipo,
firmatario=firmatario)
d.save()
return d
def co_turni_smonta(request, me, partecipazione_pk=None):
p = get_object_or_404(Partecipazione, pk=partecipazione_pk)
if p.turno.attivita.sede not in me.oggetti_permesso(GESTIONE_CENTRALE_OPERATIVA_SEDE):
return redirect(ERRORE_PERMESSI)
coturno = p.coturno()
if coturno is None:
return redirect("/centrale-operativa/turni/")
if not coturno.smontabile:
return errore_generico(request, me, titolo="Questa persona non può essere smontata",
messaggio="Per qualche motivo la persona non è smontabile. Forse è già "
"stata smontata da qualcun altro?", torna_titolo="Torna indietro",
torna_url="/centrale-operativa/turni/")
coturno.smontato_data = poco_fa()
coturno.smontato_da = me
coturno.save()
return redirect("/centrale-operativa/turni/")
def test_invito_aspirante_automatico(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
partecipazione = InvitoCorsoBase(persona=aspirante1, corso=corso, invitante=presidente)
partecipazione.save()
partecipazione.richiedi()
self.assertFalse(InvitoCorsoBase.con_esito_no().exists())
autorizzazione = presidente.autorizzazioni_richieste.first()
autorizzazione.scadenza = timezone.now() - timedelta(days=10)
autorizzazione.save()
self.assertFalse(autorizzazione.concessa)
Autorizzazione.gestisci_automatiche()
self.assertEqual(len(mail.outbox), 2)
messaggio = mail.outbox[1]
self.assertTrue(messaggio.subject.find('Richiesta di iscrizione a Corso Base RESPINTA') > -1)
self.assertFalse(messaggio.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
self.assertTrue(messaggio.body.find('una tua richiesta è rimasta in attesa per 30 giorni e come da policy') == -1)
self.assertEqual(autorizzazione.concessa, None)
self.assertTrue(InvitoCorsoBase.con_esito_no().exists())
def test_invito_aspirante_automatico(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
partecipazione = InvitoCorsoBase(persona=aspirante1, corso=corso, invitante=presidente)
partecipazione.save()
partecipazione.richiedi()
self.assertFalse(InvitoCorsoBase.con_esito_no().exists())
autorizzazione = presidente.autorizzazioni_richieste.first()
autorizzazione.scadenza = timezone.now() - timedelta(days=10)
autorizzazione.save()
self.assertFalse(autorizzazione.concessa)
Autorizzazione.gestisci_automatiche()
self.assertEqual(len(mail.outbox), 2)
messaggio = mail.outbox[1]
self.assertTrue(messaggio.subject.find('Richiesta di iscrizione a Corso Base RESPINTA') > -1)
self.assertFalse(messaggio.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
self.assertTrue(messaggio.body.find('una tua richiesta è rimasta in attesa per 30 giorni e come da policy') == -1)
self.assertEqual(autorizzazione.concessa, None)
self.assertTrue(InvitoCorsoBase.con_esito_no().exists())
def aspirante_corso_base_attiva(request, me, pk):
corso = get_object_or_404(CorsoBase, pk=pk)
if not me.permessi_almeno(corso, MODIFICA):
return redirect(ERRORE_PERMESSI)
if corso.stato != corso.PREPARAZIONE:
return messaggio_generico(request, me, titolo="Il corso è già attivo",
messaggio="Non puoi attivare un corso già attivo",
torna_titolo="Torna al Corso",
torna_url=corso.url)
if not corso.attivabile():
return errore_generico(request, me, titolo="Impossibile attivare questo corso",
messaggio="Non sono soddisfatti tutti i criteri di attivazione. "
"Torna alla pagina del corso e verifica che tutti i "
"criteri siano stati soddisfatti prima di attivare un "
"nuovo corso.",
torna_titolo="Torna al Corso",
torna_url=corso.url)
if corso.data_inizio < poco_fa():
return errore_generico(request, me, titolo="Impossibile attivare un corso già iniziato",
messaggio="Siamo spiacenti, ma non possiamo attivare il corso e inviare "
"le e-mail a tutti gli aspiranti nella zona se il corso è "
"già iniziato. Ti inviato a verificare i dati del corso.",
torna_titolo="Torna al Corso",
torna_url=corso.url)
corpo = {"corso": corso, "persona": me}
testo = get_template("email_aspirante_corso_inc_testo.html").render(corpo)
if request.POST:
corso.attiva(rispondi_a=me)
return messaggio_generico(request, me, titolo="Corso attivato con successo",
messaggio="A breve tutti gli aspiranti nelle vicinanze verranno informati "
"dell'attivazione di questo corso base.",
torna_titolo="Torna al Corso",
torna_url=corso.url)
contesto = {
"corso": corso,
"puo_modificare": True,
"testo": testo,
}
return 'aspirante_corso_base_scheda_attiva.html', contesto
def chiudi(self, autore=None, invia_notifiche=True, azione_automatica=False):
"""
Chiude questa attivita. Imposta il nuovo stato, sospende
le deleghe e, se specificato, invia la notifica ai referenti.
:param invia_notifiche: True per inviare le notifiche ai refernti di attivita, le cui
deleghe verranno sospese.
:param azione_automatica: Se l'azione e' stata svolta in modo automatico (i.e. via cron) o meno.
Viene usato per modificare la notifica.
:return:
"""
self.apertura = self.CHIUSA
self.save()
if invia_notifiche:
self._invia_notifica_chiusura(autore=autore, azione_automatica=azione_automatica)
if azione_automatica:
self.chiusa_automaticamente = poco_fa()
self.sospendi_deleghe()
def veicoli_collocazioni(request, me, veicolo):
veicolo = get_object_or_404(Veicolo, pk=veicolo)
collocazioni = veicolo.collocazioni.all().order_by("-inizio")
modulo = ModuloCreazioneCollocazione(request.POST or None)
sedi = me.oggetti_permesso(GESTIONE_AUTOPARCHI_SEDE)
autoparchi = Autoparco.objects.filter(sede__in=sedi)
modulo.fields['autoparco'].queryset = autoparchi
if not me.permessi_almeno(veicolo, MODIFICA):
return redirect(ERRORE_PERMESSI)
if modulo.is_valid():
veicolo.collocazione().termina()
c = modulo.save(commit=False)
c.inizio = poco_fa()
c.veicolo = veicolo
c.creato_da = me
c.save()
contesto = {
"veicolo": veicolo,
"collocazioni":collocazioni,
"modulo": modulo,
}
return "veicoli_collocazione.html", contesto
def veicoli_collocazioni(request, me, veicolo):
veicolo = get_object_or_404(Veicolo, pk=veicolo)
collocazioni = veicolo.collocazioni.all().order_by("-inizio")
modulo = ModuloCreazioneCollocazione(request.POST or None)
sedi = me.oggetti_permesso(GESTIONE_AUTOPARCHI_SEDE)
autoparchi = Autoparco.objects.filter(sede__in=sedi)
modulo.fields['autoparco'].queryset = autoparchi
if not me.permessi_almeno(veicolo, MODIFICA):
return redirect(ERRORE_PERMESSI)
if modulo.is_valid():
veicolo.collocazione().termina()
c = modulo.save(commit=False)
c.inizio = poco_fa()
c.veicolo = veicolo
c.creato_da = me
c.save()
contesto = {
"veicolo": veicolo,
"collocazioni": collocazioni,
"modulo": modulo,
}
return "veicoli_collocazione.html", contesto
def attivita_gruppi_gruppo_iscriviti(request, me, pk):
"""
Abbandona un gruppo.
"""
gruppo = get_object_or_404(Gruppo, pk=pk)
if Appartenenza.query_attuale().filter(
gruppo=gruppo, persona=me
).exists(): # Gia membro
return redirect("/attivita/gruppi/?gia_membro")
a = Appartenenza(
gruppo=gruppo,
persona=me,
inizio=poco_fa()
)
a.save()
return messaggio_generico(request, me, titolo="Iscrizione effettuata",
messaggio="Sei ora iscritt%s al gruppo di lavoro '%s'. <br />"
"Riceverai per e-mail tutte le comunicazioni "
"relative a questo gruppo" % (
me.genere_o_a, gruppo.nome,
), torna_titolo="Torna all'elenco dei gruppi",
torna_url="/attivita/gruppi/")
def attivita_gruppi_gruppo_iscriviti(request, me, pk):
"""
Abbandona un gruppo.
"""
gruppo = get_object_or_404(Gruppo, pk=pk)
if Appartenenza.query_attuale().filter(gruppo=gruppo,
persona=me).exists(): # Gia membro
return redirect("/attivita/gruppi/?gia_membro")
a = Appartenenza(gruppo=gruppo, persona=me, inizio=poco_fa())
a.save()
return messaggio_generico(
request,
me,
titolo="Iscrizione effettuata",
messaggio="Sei ora iscritt%s al gruppo di lavoro '%s'. <br />"
"Riceverai per e-mail tutte le comunicazioni "
"relative a questo gruppo" % (
me.genere_o_a,
gruppo.nome,
),
torna_titolo="Torna all'elenco dei gruppi",
torna_url="/attivita/gruppi/")
def chiudi(self,
autore=None,
invia_notifiche=True,
azione_automatica=False):
"""
Chiude questa attivita. Imposta il nuovo stato, sospende
le deleghe e, se specificato, invia la notifica ai referenti.
:param invia_notifiche: True per inviare le notifiche ai refernti di attivita, le cui
deleghe verranno sospese.
:param azione_automatica: Se l'azione e' stata svolta in modo automatico (i.e. via cron) o meno.
Viene usato per modificare la notifica.
:return:
"""
self.apertura = self.CHIUSA
self.save()
if invia_notifiche:
self._invia_notifica_chiusura(autore=autore,
azione_automatica=azione_automatica)
if azione_automatica:
self.chiusa_automaticamente = poco_fa()
self.sospendi_deleghe()
def test_registrazione_aspirante(self):
"""
Effettua la registrazione come aspirante, il presidente
del Comitato organizza un corso, avvisa tutti, l'aspirante trova
un corso e vi ci si iscrive.
"""
presidente = crea_persona()
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sessione_iniziale = self.sessione_anonimo()
sessione_iniziale.click_link_by_partial_text("Iscriviti al prossimo corso base")
sessione_iniziale.fill('codice_fiscale', 'MRARSS42A01C351F')
sessione_iniziale.find_by_xpath('//button[@type="submit"]').first.click()
email = email_fittizzia()
sessione_iniziale.fill('email', email)
sessione_iniziale.fill('password', 'ciao12345')
sessione_iniziale.fill('ripeti_password', 'ciao12345')
sessione_iniziale.find_by_xpath('//button[@type="submit"]').first.click()
self.assertTrue(sessione_iniziale.is_text_present('è necessario cliccare sul link'),
msg="Invio email attivazione")
self.sessione_termina(sessione_iniziale)
# Estrazione della chiave di conferma
self.assertEqual(len(mail.outbox), 1)
body = mail.outbox[0].alternatives[0][0]
url_conferma = re.findall('/registrati/aspirante/anagrafica/\?code=\w+®istration=\w+', body)[0]
sessione_aspirante = self.sessione_anonimo()
sessione_aspirante.visit("%s%s" % (self.live_server_url, url_conferma))
self.assertEqual(len(mail.outbox), 1)
sessione_aspirante.fill('nome', 'Mario')
sessione_aspirante.fill('cognome', 'Rossi Accènto')
sessione_aspirante.fill('data_nascita', '1/1/1942')
sessione_aspirante.fill('comune_nascita', 'Catania')
sessione_aspirante.fill('provincia_nascita', 'CT')
sessione_aspirante.fill('indirizzo_residenza', 'Via Etnea 353')
sessione_aspirante.fill('comune_residenza', 'Catania')
sessione_aspirante.fill('provincia_residenza', 'CT')
sessione_aspirante.fill('cap_residenza', '95128')
sessione_aspirante.find_by_xpath('//button[@type="submit"]').first.click()
self.assertTrue(sessione_aspirante.is_text_present("acconsenti al trattamento "
"dei tuoi dati personali"),
msg="Presente clausola di accettazione trattamento dei dati personali")
sessione_aspirante.find_by_xpath('//button[@type="submit"]').first.click()
self.assertTrue(sessione_aspirante.is_text_present("Ciao, Mario"),
msg="Login effettuato automaticamente")
self.assertTrue(sessione_aspirante.is_text_present(email),
msg="Indirizzo e-mail visibile e mostrato correttamente")
sede.locazione = Locazione.objects.filter(comune="Catania").first()
sede.save()
sessione_presidente = self.sessione_utente(persona=presidente)
sessione_presidente.click_link_by_partial_text("Formazione")
sessione_presidente.click_link_by_partial_text("Domanda formativa")
self.assertTrue(sessione_presidente.is_text_present("1 aspiranti"),
msg="Aspirante correttamente considerato in domanda formativa")
sessione_presidente.click_link_by_partial_text("Elenco Corsi Base")
sessione_presidente.click_link_by_partial_text("Pianifica nuovo")
sessione_presidente.select('sede', sede.pk)
sessione_presidente.find_by_xpath('//button[@type="submit"]').first.click()
self.sessione_conferma(sessione_presidente, accetta=True)
self.seleziona_delegato(sessione_presidente, direttore)
self.assertTrue(sessione_presidente.is_text_present("Corso Base pianificato"),
msg="Conferma che il corso base e' stato creato")
self.assertTrue(sessione_presidente.is_text_present(direttore.nome_completo),
msg="Il nome completo del direttore viene mostrato")
self.sessione_termina(sessione_presidente) # Non abbiamo piu' bisogno del presidente
sessione_direttore = self.sessione_utente(persona=direttore)
sessione_direttore.click_link_by_partial_text("Formazione")
sessione_direttore.click_link_by_partial_text("Elenco Corsi Base")
self.assertTrue(sessione_direttore.is_text_present("Corso Base"),
msg="Corso base in lista")
self.assertTrue(sessione_direttore.is_text_present("In preparazione"),
msg="Il corso appare con lo stato corretto")
sessione_direttore.click_link_by_partial_text("Corso Base")
self.assertTrue(sessione_direttore.is_text_present("Non c'è tempo da perdere"),
msg="Visibile promemoria corso che sta per iniziare a breve")
self.assertTrue(sessione_direttore.is_text_present("1 aspiranti"),
msg="Visibile numero di aspiranti nelle vicinanze")
sessione_direttore.click_link_by_partial_text("Gestione corso")
self.scrivi_tinymce(sessione_direttore, "descrizione", "Sarà un corso bellissimo")
sessione_direttore.find_by_xpath('//button[@type="submit"]').first.click()
sessione_direttore.click_link_by_partial_text("Attiva il corso e informa gli aspiranti")
self.assertTrue(sessione_direttore.is_text_present("Anteprima messaggio"),
msg="Anteprima del messaggio visibile")
self.assertTrue(sessione_direttore.is_text_present("Sarà un corso bellissimo"),
msg="La descrizione del corso e' nell'anteprima del messaggio")
sessione_direttore.find_by_xpath('//button[@type="submit"]').first.click()
self.sessione_conferma(sessione_direttore, accetta=True)
self.assertTrue(sessione_direttore.is_text_present("Corso attivato con successo"),
msg="Messaggio di conferma attivazione corso")
if os.environ.get('TRAVIS', 'false') == 'true':
self.skipTest('Questo test fallisce su travis senza motivo apparente')
sessione_aspirante.click_link_by_partial_text("Posta")
self.assertTrue(sessione_aspirante.is_text_present("Nuovo Corso per Volontari CRI"),
msg="E-mail di attivazione corso ricevuta")
sessione_aspirante.click_link_by_partial_text("Nuovo Corso per Volontari CRI")
self.assertTrue(sessione_aspirante.is_text_present("Sarà un corso bellissimo"),
msg="La descrizione del corso è stata comunicata per e-mail")
sessione_aspirante.visit("%s/utente/" % self.live_server_url)
sessione_aspirante.click_link_by_partial_text("Aspirante")
sessione_aspirante.click_link_by_partial_text("Elenco dei corsi nelle vicinanze")
self.assertTrue(sessione_aspirante.is_text_present(direttore.nome_completo),
msg="Il nome completo del Direttore e' visibile in elenco")
sessione_aspirante.click_link_by_partial_text("Corso Base")
sessione_aspirante.click_link_by_partial_text("Voglio iscrivermi a questo corso")
self.assertTrue(sessione_aspirante.is_text_present("Abbiamo inoltrato la tua richiesta"),
msg="Conferma data all'aspirante")
sessione_direttore.visit("%s/utente/" % self.live_server_url)
sessione_direttore.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_direttore.is_text_present("chiede di essere contattato"),
msg="Esplicitare che l'aspirante vuole essere contattato")
self.assertTrue(sessione_direttore.is_text_present("Corso non ancora iniziato, impossibile processare la richiesta."),
msg="Corso non ancora iniziato, impossibile processare la richiesta.")
for corso in sede.corsobase_set.all():
corso.data_inizio = poco_fa()
corso.save()
sessione_direttore.click_link_by_partial_text("Richieste")
sessione_direttore.click_link_by_partial_text("Conferma")
sessione_direttore.check('conferma_1')
sessione_direttore.check('conferma_2')
sessione_direttore.find_by_xpath('//button[@type="submit"]').first.click()
sessione_aspirante.visit("%s/utente/" % self.live_server_url)
sessione_aspirante.click_link_by_partial_text("Aspirante")
self.assertTrue(sessione_aspirante.is_text_present("Sei iscritt"),
msg="Conferma di iscrizione")
sessione_aspirante.click_link_by_partial_text("Vai alla pagina del Corso Base")
self.assertTrue(sessione_aspirante.is_text_present("Presentati alle lezioni del corso"),
msg="Invita l'aspirante a presentarsi alle lezioni del corso")
def attivita_organizza(request, me):
aree = me.oggetti_permesso(GESTIONE_ATTIVITA_AREA)
sedi = Sede.objects.filter(aree__in=aree)
deleghe = me.deleghe_attuali()
from anagrafica.permessi.applicazioni import DELEGATI_NON_SONO_UN_BERSAGLIO
deleghe_bersaglio = deleghe.filter(tipo__in=DELEGATI_NON_SONO_UN_BERSAGLIO)
if deleghe_bersaglio:
if not aree.filter(obiettivo=4,
nome__icontains='non sono un bersaglio'):
for delega in deleghe.filter(
tipo__in=DELEGATI_NON_SONO_UN_BERSAGLIO):
area = Area(nome='Non sono un bersaglio',
obiettivo=4,
sede=delega.oggetto)
area.save()
if not aree:
return messaggio_generico(
request,
me,
titolo="Crea un'area di intervento, prima!",
messaggio="Le aree di intervento fungono da 'contenitori' per le "
"attività. Per organizzare un'attività, è necessario creare "
"almeno un'area di intervento. ",
torna_titolo="Gestisci le Aree di intervento",
torna_url="/attivita/aree/")
modulo_referente = ModuloOrganizzaAttivitaReferente(request.POST or None)
modulo = ModuloOrganizzaAttivita(request.POST or None)
modulo.fields['area'].queryset = me.oggetti_permesso(
GESTIONE_ATTIVITA_AREA)
if deleghe_bersaglio:
modulo_referente.fields[
'scelta'].choices = ModuloOrganizzaAttivitaReferente.popola_scelta(
)
if modulo_referente.is_valid() and modulo.is_valid():
attivita = modulo.save(commit=False)
attivita.sede = attivita.area.sede
attivita.estensione = attivita.sede.comitato
attivita.save()
# Crea gruppo per questa specifica attività se la casella viene selezionata.
crea_gruppo = modulo.cleaned_data['gruppo']
if crea_gruppo:
area = attivita.area
gruppo = Gruppo.objects.create(
nome=attivita.nome,
sede=attivita.sede,
obiettivo=area.obiettivo,
attivita=attivita,
estensione=attivita.estensione.estensione,
area=area)
gruppo.aggiungi_delegato(REFERENTE_GRUPPO, me)
if modulo_referente.cleaned_data['scelta'] == modulo_referente.SONO_IO:
# Io sono il referente.
attivita.aggiungi_delegato(REFERENTE,
me,
firmatario=me,
inizio=poco_fa())
return redirect(attivita.url_modifica)
elif modulo_referente.cleaned_data[
'scelta'] == modulo_referente.SCEGLI_REFERENTI: # Il referente e' qualcun altro.
return redirect("/attivita/organizza/%d/referenti/" %
(attivita.pk, ))
else:
from anagrafica.models import Persona
persona = Persona.objects.get(
pk=modulo_referente.cleaned_data['scelta'])
attivita.aggiungi_delegato(REFERENTE,
persona,
firmatario=me,
inizio=poco_fa())
return redirect(attivita.url_modifica)
contesto = {
"modulo": modulo,
"modulo_referente": modulo_referente,
}
return 'attivita_organizza.html', contesto
def test_gestione_inviti(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sostenitore = crea_persona()
sostenitore.email_contatto = email_fittizzia()
sostenitore.codice_fiscale = codice_fiscale()
sostenitore.save()
Appartenenza.objects.create(
persona=sostenitore,
sede=sede,
membro=Appartenenza.SOSTENITORE,
inizio="1980-12-10",
)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
crea_utenza(aspirante1, aspirante1.email_contatto)
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
aspirante2.save()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
crea_utenza(aspirante2, aspirante2.email_contatto)
# Attività degli aspiranti
sessione_aspirante1 = self.sessione_utente(persona=aspirante1)
sessione_aspirante2 = self.sessione_utente(persona=aspirante2)
sessione_aspirante1.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante1.is_text_present("Non ci sono richieste in attesa."), msg="Nessun invito")
# setup dei dati
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.client.login(username=presidente.email_contatto, password='******')
iscritti = {
'persone': [aspirante1.pk]
}
self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritti)
iscritti = {
'persone': [aspirante2.pk]
}
self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritti)
self.assertEqual(corso.inviti.count(), 2)
sessione_aspirante1.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante1.is_text_present(corso.nome), msg="Invito disponibile")
sessione_aspirante1.click_link_by_partial_text("Conferma")
self.assertTrue(sessione_aspirante1.is_text_present("Richiesta autorizzata."), msg="Richiesta autorizzata")
self.assertEqual(corso.inviti.count(), 1)
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertEqual(aspirante2.inviti_corsi.count(), 1)
sessione_aspirante2.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante2.is_text_present(corso.nome), msg="Invito disponibile")
sessione_aspirante2.click_link_by_partial_text("Nega")
sessione_aspirante2.fill('motivo', 'Test')
sessione_aspirante2.find_by_css(".btn-danger").first.click()
self.assertTrue(sessione_aspirante2.is_text_present("Richiesta negata."), msg="Richiesta negata")
self.assertEqual(corso.inviti.count(), 0)
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertEqual(aspirante2.inviti_corsi.count(), 0)
def test_richieste_processabili(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
sede = crea_sede(presidente)
crea_appartenenza(sede=sede, persona=presidente)
sede2 = crea_sede(presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
est = Estensione.objects.create(
destinazione=sede2,
persona=presidente,
richiedente=presidente,
motivo='test'
)
est.richiedi()
oggi = poco_fa()
corso1 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso1)
partecipazione1.richiedi()
corso2 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi - timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione2 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso2)
partecipazione2.richiedi()
corso3 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi - timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione3 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso3)
partecipazione3.richiedi()
ctype = ContentType.objects.get_for_model(CorsoBase)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso1.pk, oggetto_tipo=ctype
)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso2.pk, oggetto_tipo=ctype
)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso3.pk, oggetto_tipo=ctype
)
url_presenti = []
url_assenti = []
richieste_non_processabili = partecipazione1.autorizzazioni.all()
for richiesta in richieste_non_processabili:
self.assertFalse(PartecipazioneCorsoBase.controlla_richiesta_processabile(richiesta))
url_assenti.append(reverse('autorizzazioni:concedi', args=(richiesta.pk,)))
url_assenti.append(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
non_processabili = PartecipazioneCorsoBase.richieste_non_processabili(Autorizzazione.objects.all())
self.assertEqual(list(non_processabili), [richiesta.pk for richiesta in richieste_non_processabili])
richieste_processabili = partecipazione2.autorizzazioni.all() | partecipazione3.autorizzazioni.all()
for richiesta in richieste_processabili:
self.assertTrue(PartecipazioneCorsoBase.controlla_richiesta_processabile(richiesta))
url_presenti.append(reverse('autorizzazioni:concedi', args=(richiesta.pk,)))
url_presenti.append(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
# Mettendo nel mezzo anche autorizzazioni diverse si verifica che il meccanismo non interferisca
richieste_estensioni = est.autorizzazioni.all()
for richiesta in richieste_estensioni:
pass
url_presenti.append(reverse('autorizzazioni:concedi', args=(richiesta.pk,)))
url_presenti.append(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
self.client.login(email=presidente.email_contatto, password='******')
response = self.client.get(reverse('autorizzazioni-aperte'))
for url in url_presenti:
self.assertContains(response, url)
for url in url_assenti:
self.assertNotContains(response, url)
self.assertContains(response, 'Corso non ancora iniziato, impossibile processare la richiesta.')
for url in url_assenti:
response = self.client.get(url)
self.assertContains(response, 'Richiesta non processabile')
for richiesta in partecipazione2.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni:concedi', args=(richiesta.pk,)))
self.assertContains(response, 'Per dare consenso a questa richiesta')
for richiesta in partecipazione3.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
self.assertContains(response, 'Per negare questa richiesta')
for richiesta in est.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
self.assertContains(response, 'Per negare questa richiesta')
]
else:
tipi = [Appartenenza.VOLONTARIO, Appartenenza.SOSTENITORE]
for membro in tipi:
for i in range(0, 25): # Creo 20 volontari
p = crea_persona()
p.comune_nascita = random.sample(COMUNI.keys(), 1)[0]
p.genere = random.choice((p.MASCHIO, p.FEMMINA))
p.indirizzo_residenza = 'Via prova 34'
p.comune_residenza = random.sample(COMUNI.keys(), 1)[0]
p.provincia_residenza = 'ZZ'
p.cap_residenza = '00100'
p.codice_fiscale = codice_fiscale_persona(p)
p.save()
nuove.append(p)
data = poco_fa() - timedelta(days=random.randint(10, 5000))
a = Appartenenza.objects.create(persona=p,
sede=sede,
inizio=data,
membro=membro)
if membro == Appartenenza.VOLONTARIO:
if i % 5 == 0:
# Dimesso e riammesso
data_precedente = data - timedelta(
days=random.randint(10, 500))
altra = random.sample(sedi, 1)[0]
a = Appartenenza.objects.create(
persona=p,
sede=altra,
inizio=data_precedente,
fine=data,
