def test_filtro_con_sede(self):
volontario_con_sede, sede, appartenenza = crea_persona_sede_appartenenza()
appartenenza.inizio = now()
appartenenza.save()
altra_sede = crea_sede()
segmento_0 = self._crea_segmento(self.file_1, 'D')
segmento_1 = self._crea_segmento(self.file_1, 'B', sede=altra_sede)
segmento_2 = self._crea_segmento(self.file_2, 'B', sede=sede)
qs = DocumentoSegmento.objects.all()
documenti = qs.filtra_per_segmenti(volontario_con_sede)
self.assertEqual(documenti.count(), 1)
self.assertEqual(set(documenti), set(DocumentoSegmento.objects.filter(pk=segmento_2.pk)))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 1)
self.assertEqual(set(oggetti), set(Documento.objects.filter(pk=self.file_2.pk)))
segmento_3 = self._crea_segmento(self.file_1, 'B')
documenti = qs.filtra_per_segmenti(volontario_con_sede)
self.assertEqual(documenti.count(), 2)
self.assertEqual(set(documenti), set(DocumentoSegmento.objects.filter(pk__in=(segmento_2.pk, segmento_3.pk))))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 2)
self.assertEqual(set(oggetti), set(Documento.objects.filter(pk__in=(self.file_1.pk, self.file_2.pk))))
def test_reclama_ordinario(self):
# Crea oggetti e nomina i delegati US regionali e Locali
us_regionale = crea_persona()
us_locale = crea_persona()
ordinario, regionale, appartenenza = crea_persona_sede_appartenenza(presidente=us_regionale)
appartenenza.membro = Appartenenza.ORDINARIO
appartenenza.save()
regionale.estensione = REGIONALE
regionale.save()
locale = crea_sede(presidente=us_locale, genitore=regionale)
sessione_regionale = self.sessione_utente(persona=us_regionale)
sessione_locale = self.sessione_utente(persona=us_locale)
# Prima di tutto, assicurati che il socio ordinario risulti correttamente
# nell'elenco del regionale.
sessione_regionale.click_link_by_partial_text("Soci")
sessione_regionale.click_link_by_partial_text("Ordinari")
self.assertTrue(self.presente_in_elenco(sessione_regionale, persona=ordinario),
msg="Il socio ordinario è in elenco al regionale")
# Poi, vai alla procedura di reclamo per il locale e completa.
sessione_locale.click_link_by_partial_text("Soci")
sessione_locale.click_link_by_partial_text("Reclama Persona")
sessione_locale.fill('codice_fiscale', ordinario.codice_fiscale)
sessione_locale.find_by_xpath("//button[@type='submit']").first.click()
# Completa dati di inizio appartenenza - data nel passato!
sessione_locale.fill('app-inizio', "1/1/1910")
sessione_locale.select('app-membro', Appartenenza.SOSTENITORE)
sessione_locale.select('quota-registra_quota', ModuloReclamaQuota.NO)
sessione_locale.find_by_xpath("//button[@type='submit']").first.click()
self.assertTrue(sessione_locale.is_text_present("1. Appartenenza al Comitato"),
msg="Non e possibile reclamare ordinario nel passato")
# Compila con la data di oggi.
sessione_locale.fill('app-inizio', timezone.now().strftime("%d/%m/%Y"))
sessione_locale.find_by_xpath("//button[@type='submit']").first.click()
# Controlla elenco dei sostenitori.
sessione_locale.visit("%s/utente/" % self.live_server_url)
sessione_locale.click_link_by_partial_text("Soci")
sessione_locale.click_link_by_partial_text("Sostenitori")
self.assertTrue(
self.presente_in_elenco(sessione_locale, persona=ordinario),
msg="L'ex ordinario è stato reclamato con successo")
# Controlla la rimozione corretta dagli ordinari.
sessione_regionale.click_link_by_partial_text("Ordinari")
self.assertFalse(
self.presente_in_elenco(sessione_regionale, persona=ordinario),
msg="L'ex ordinario non è più in elenco al regionale"
)
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 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_appartenenza(self):
p = crea_persona()
c = crea_sede()
self.assertTrue(
c.appartenenze_attuali().count() == 0,
msg="Non ci devono essere appartenze ancora attuali."
)
a = crea_appartenenza(p, c)
a.richiedi()
self.assertTrue(
c.appartenenze_attuali().count() == 0,
msg="Non ancora."
)
self.assertTrue(
a.autorizzazioni_set(),
msg="Qualche autorizzazione e' stata generata."
)
a.autorizzazioni_set()[0].concedi(p)
self.assertTrue(
c.appartenenze_attuali().count() == 1,
msg="Ora l'appartenenza e' attuale."
)
# Riscarica l'appartenenza
a = Appartenenza.objects.get(pk=a.id)
self.assertTrue(
a.confermata,
msg="L'appartenenza risulta ora confermata."
)
self.assertTrue(
a.attuale(),
msg="L'appartenenza risulta ora attuale ad oggi."
)
self.assertTrue(
c.membri_attuali()[0] == p,
msg="Il membro attuale corrisponde alla persona inserita."
)
self.assertTrue(
c.appartenenze_attuali(membro=Appartenenza.MILITARE).count() == 0,
msg="Ma ancora nessun militare."
)
def setUpTestData(cls):
cls.factory = RequestFactory()
cls.presidente = crea_persona()
cls.presidente.email_contatto = email_fittizzia()
crea_utenza(cls.presidente, email=cls.presidente.email_contatto)
cls.sede = crea_sede(cls.presidente)
for i in range(cls.num_persone):
persona = crea_persona()
crea_appartenenza(persona, cls.sede)
persona.email_contatto = email_fittizzia()
persona.save()
cls.persone.append(crea_utenza(persona, email=email_fittizzia()))
def setUpTestData(cls):
cls.factory = RequestFactory()
cls.presidente = crea_persona()
cls.presidente.email_contatto = email_fittizzia()
crea_utenza(cls.presidente, email=cls.presidente.email_contatto)
cls.sede = crea_sede(cls.presidente)
for i in range(cls.num_persone):
persona = crea_persona()
crea_appartenenza(persona, cls.sede)
persona.email_contatto = email_fittizzia()
persona.save()
cls.persone.append(crea_utenza(persona, email=email_fittizzia()))
def test_presidente_recursetree(self):
"""
Questo test controlla che la pagina /presidente
funzioni correttamente nel caso particolare di due sottoalberi
completamente separati, che causa problemi e non puo essere usata
con {% recursetree %}.
"""
presidente = crea_persona()
# Struttura:
# x
# - y presidenza
# - - a
# - - - b (unita)
# - c presidenza
# - - d (unita)
x = crea_sede()
y = crea_sede(genitore=x)
a = crea_sede(genitore=y, presidente=presidente)
b = crea_sede(genitore=a, estensione=TERRITORIALE)
c = crea_sede(genitore=x, presidente=presidente)
d = crea_sede(genitore=c, estensione=TERRITORIALE)
sessione = self.sessione_utente(persona=presidente)
sessione.click_link_by_partial_text("Sedi")
self.assertTrue(
sessione.is_text_present(c.nome),
msg="Pagina caricata correttamente"
)
def test_controllo_anni_attivita(self):
from anagrafica.costanti import LIMITE_ETA, LIMITE_ANNI_ATTIVITA
ora = now()
data_limite = ora.today()
data_sotto = data_limite.replace(year=data_limite.year -
(LIMITE_ETA - 1))
data_sopra = data_limite.replace(year=data_limite.year -
(LIMITE_ETA + 1))
data_limite = data_limite.replace(year=data_limite.year - LIMITE_ETA)
sede = crea_sede()
persona_sotto_limite = crea_persona()
persona_sotto_limite.data_nascita = data_sotto
persona_sotto_limite.save()
crea_appartenenza(persona_sotto_limite, sede)
persona_sopra_limite = crea_persona()
persona_sopra_limite.data_nascita = data_sopra
persona_sopra_limite.save()
crea_appartenenza(persona_sopra_limite, sede)
persona_al_limite = crea_persona()
persona_al_limite.data_nascita = data_limite
persona_al_limite.save()
crea_appartenenza(persona_al_limite, sede)
area, attivita = crea_area_attivita(sede)
for anni in range(0, LIMITE_ANNI_ATTIVITA + 3):
inizio = ora.replace(year=ora.year - (anni - 1))
fine = ora.replace(year=ora.year -
(anni - 1)) + datetime.timedelta(hours=1)
t1 = crea_turno(attivita, inizio=inizio, fine=fine)
if anni < LIMITE_ANNI_ATTIVITA:
for persona in (persona_sotto_limite, persona_sopra_limite,
persona_al_limite):
crea_partecipazione(persona, t1)
elif anni == LIMITE_ANNI_ATTIVITA:
for persona in (persona_sopra_limite, persona_al_limite):
crea_partecipazione(persona, t1)
else:
crea_partecipazione(persona_sopra_limite, t1)
lista = _calcola_anni_attivita(Persona.objects.all())
self.assertEqual(set(lista), {persona_sotto_limite})
lista = _calcola_anni_attivita(Persona.objects.all(), meno=False)
self.assertEqual(set(lista), {persona_al_limite, persona_sopra_limite})
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_controllo_anni_attivita(self):
from anagrafica.costanti import LIMITE_ETA, LIMITE_ANNI_ATTIVITA
ora = now()
data_limite = ora.today()
data_sotto = data_limite.replace(year=data_limite.year - (LIMITE_ETA - 1))
data_sopra = data_limite.replace(year=data_limite.year - (LIMITE_ETA + 1))
data_limite = data_limite.replace(year=data_limite.year - LIMITE_ETA)
sede = crea_sede()
persona_sotto_limite = crea_persona()
persona_sotto_limite.data_nascita = data_sotto
persona_sotto_limite.save()
crea_appartenenza(persona_sotto_limite, sede)
persona_sopra_limite = crea_persona()
persona_sopra_limite.data_nascita = data_sopra
persona_sopra_limite.save()
crea_appartenenza(persona_sopra_limite, sede)
persona_al_limite = crea_persona()
persona_al_limite.data_nascita = data_limite
persona_al_limite.save()
crea_appartenenza(persona_al_limite, sede)
area, attivita = crea_area_attivita(sede)
for anni in range(0, LIMITE_ANNI_ATTIVITA + 3):
inizio = ora.replace(year=ora.year - (anni - 1))
fine = ora.replace(year=ora.year - (anni - 1)) + datetime.timedelta(hours=1)
t1 = crea_turno(attivita, inizio=inizio, fine=fine)
if anni < LIMITE_ANNI_ATTIVITA:
for persona in (persona_sotto_limite, persona_sopra_limite, persona_al_limite):
crea_partecipazione(persona, t1)
elif anni == LIMITE_ANNI_ATTIVITA:
for persona in (persona_sopra_limite, persona_al_limite):
crea_partecipazione(persona, t1)
else:
crea_partecipazione(persona_sopra_limite, t1)
lista = _calcola_anni_attivita(Persona.objects.all())
self.assertEqual(set(lista), {persona_sotto_limite})
lista = _calcola_anni_attivita(Persona.objects.all(), meno=False)
self.assertEqual(set(lista), {persona_al_limite, persona_sopra_limite})
def test_dimissione_passaggio_sostenitore(self):
c = crea_sede(estensione=PROVINCIALE)
c.save()
p = crea_persona()
p.save()
a = Appartenenza(
persona=p,
sede=c,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
confermata=True
)
a.save()
d = Dimissione(
persona=p,
sede=c,
appartenenza=a
)
d.save()
self.assertTrue(
a.attuale(),
msg="L'appartenenza risulta quella attuale."
)
d.applica(trasforma_in_sostenitore=True)
self.assertFalse(
a.attuale(),
msg="L'appartenenza risulta non più attuale."
)
appartenenze_attuali = p.appartenenze_attuali()
self.assertTrue(
appartenenze_attuali.count() == 1,
msg="Esiste solo una appartenenza attuale come sostenitore."
)
def test_dimissione(self):
c = crea_sede(estensione=PROVINCIALE)
c.save()
p = crea_persona()
p.save()
a = Appartenenza(
persona=p,
sede=c,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
confermata=True
)
a.save()
d = Dimissione(
persona=p,
sede=c,
appartenenza=a
)
d.save()
self.assertTrue(
a.attuale(),
msg="L'appartenenza risulta quella attuale."
)
d.applica()
self.assertFalse(
a.attuale(),
msg="L'appartenenza risulta non più attuale."
)
appartenenze_attuali = p.appartenenze_attuali()
self.assertTrue(
appartenenze_attuali.count() == 0,
msg="Non esiste alcuna appartenenza attuale per dimissioni normali."
)
def test_filtro_con_sede(self):
volontario_con_sede, sede, appartenenza = crea_persona_sede_appartenenza(
)
appartenenza.inizio = now()
appartenenza.save()
altra_sede = crea_sede()
segmento_0 = self._crea_segmento(self.file_1, 'D')
segmento_1 = self._crea_segmento(self.file_1, 'B', sede=altra_sede)
segmento_2 = self._crea_segmento(self.file_2, 'B', sede=sede)
qs = DocumentoSegmento.objects.all()
documenti = qs.filtra_per_segmenti(volontario_con_sede)
self.assertEqual(documenti.count(), 1)
self.assertEqual(
set(documenti),
set(DocumentoSegmento.objects.filter(pk=segmento_2.pk)))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 1)
self.assertEqual(set(oggetti),
set(Documento.objects.filter(pk=self.file_2.pk)))
segmento_3 = self._crea_segmento(self.file_1, 'B')
documenti = qs.filtra_per_segmenti(volontario_con_sede)
self.assertEqual(documenti.count(), 2)
self.assertEqual(
set(documenti),
set(
DocumentoSegmento.objects.filter(pk__in=(segmento_2.pk,
segmento_3.pk))))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 2)
self.assertEqual(
set(oggetti),
set(
Documento.objects.filter(pk__in=(self.file_1.pk,
self.file_2.pk))))
def test_comitato(self):
"""
Controlla che il Comitato venga ottenuto correttamente.
"""
italia = crea_sede(estensione=NAZIONALE)
self.assertTrue(
italia.comitato == italia,
msg="Il Comitato Nazionale e' Comitato di se' stesso"
)
sicilia = crea_sede(estensione=REGIONALE, genitore=italia)
self.assertTrue(
sicilia.comitato == sicilia,
msg="Il Comitato Regionale e' Comitato di se' stesso"
)
catania = crea_sede(estensione=PROVINCIALE, genitore=sicilia)
self.assertTrue(
catania.comitato == catania,
msg="Il Comitato Provinciale e' Comitato di se' stesso"
)
giarre = crea_sede(estensione=LOCALE, genitore=catania)
self.assertTrue(
giarre.comitato == giarre,
msg="Il Comitato Locale e' Comitato di se' stesso"
)
riposto = crea_sede(estensione=TERRITORIALE, genitore=giarre)
self.assertTrue(
riposto.comitato == giarre,
msg="Unita' territoriale di Locale funziona correttamente"
)
maletto = crea_sede(estensione=TERRITORIALE, genitore=catania)
self.assertTrue(
maletto.comitato == catania,
msg="Unita' territoriale di Provinciale funziona corretatmente"
)
self.assertTrue(
maletto.comitato == catania.comitato,
msg="Sede.comitato e' transitiva"
)
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 test_estensione_accettata(self):
presidente1 = crea_persona()
presidente2 = crea_persona()
da_estendere, sede1, app1 = crea_persona_sede_appartenenza(presidente1)
sede2 = crea_sede(presidente2)
self.assertFalse(
da_estendere.estensioni_attuali_e_in_attesa().exists(),
msg="Non esiste estensione alcuna"
)
self.assertFalse(
presidente1.autorizzazioni_in_attesa().exists(),
msg="Il presidente non ha autorizzazioni in attesa"
)
modulo = ModuloCreazioneEstensione()
est = modulo.save(commit=False)
est.richiedente = da_estendere
est.persona = da_estendere
est.destinazione = sede2
est.save()
est.richiedi()
self.assertTrue(
da_estendere.estensioni_attuali_e_in_attesa().exists(),
msg="L'estensione creata correttamente"
)
self.assertFalse(
da_estendere.estensioni_attuali().exists(),
msg="L'estensione creata correttamente (in attesa, non attuale)"
)
self.assertTrue(
presidente1.autorizzazioni_in_attesa().exists(),
msg="Il presidente ha autorizzazioni da processare"
)
self.assertFalse(
presidente2.autorizzazioni_in_attesa().exists(),
msg="Il presidente non ha autorizzazioni in attesa"
)
aut = presidente1.autorizzazioni_in_attesa().first()
self.assertFalse(
est.appartenenza is not None,
msg="l'estensione non ha un'appartenenza"
)
modulo = est.autorizzazione_concedi_modulo()({
"protocollo_numero": 31,
"protocollo_data": datetime.date.today()
})
aut.concedi(presidente1, modulo=modulo)
self.assertFalse(
presidente2.autorizzazioni_in_attesa().exists(),
msg="Il presidente di dest. non ha autorizzazioni in attesa"
)
est.refresh_from_db()
self.assertTrue(
est.appartenenza is not None,
msg="l'estensione ha un'appartenenza"
)
self.assertTrue(
est.appartenenza.persona == da_estendere,
msg="l'appartenenza contiene il volontario esatto"
)
self.assertTrue(
est.appartenenza.sede == sede2,
msg="l'appartenenza contiene la sede esatta"
)
self.assertTrue(
est.appartenenza.membro == Appartenenza.ESTESO,
msg="l'appartenenza e' di tipo esteso"
)
self.assertTrue(
est.appartenenza.esito == Appartenenza.ESITO_OK,
msg="l'appartenenza e' accettata"
)
def test_menu_non_volontario(self):
aspirante = crea_persona()
aspirante.aspirante = Aspirante.objects.create(persona=aspirante)
aspirante.save()
dipendente = crea_persona()
ordinario = crea_persona()
sostenitore = crea_persona()
sede = crea_sede()
Appartenenza.objects.create(persona=dipendente, sede=sede, membro=Appartenenza.DIPENDENTE, inizio=poco_fa())
Appartenenza.objects.create(persona=ordinario, sede=sede, membro=Appartenenza.ORDINARIO, inizio=poco_fa())
Appartenenza.objects.create(persona=sostenitore, sede=sede, membro=Appartenenza.SOSTENITORE, inizio=poco_fa())
sessione_aspirante = self.sessione_utente(persona=aspirante, wait_time=2)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Estensione')), 0)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Trasferimento')), 0)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Riserva')), 0)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Fotografie')), 1)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Patenti CRI')), 0)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Titoli CRI')), 0)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Attività')), 0)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Storico')), 1)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Documenti')), 1)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Utente')), 0)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Volontario')), 0)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Aspirante')), 1)
self.assertEqual(len(sessione_aspirante.find_link_by_partial_text('Cambia password')), 1)
sessione_aspirante.visit("%s/utente/estensione/" % self.live_server_url)
self.assertTrue(sessione_aspirante.is_text_present('Necessaria appartenenza,'))
sessione_aspirante.visit("%s/utente/trasferimento/" % self.live_server_url)
self.assertTrue(sessione_aspirante.is_text_present('Necessaria appartenenza,'))
sessione_aspirante.visit("%s/utente/riserva/" % self.live_server_url)
self.assertTrue(sessione_aspirante.is_text_present('Accesso Volontari'))
sessione_aspirante.visit("%s/utente/fotografia/" % self.live_server_url)
self.assertTrue(sessione_aspirante.is_text_not_present('Fototessera (formale)'))
sessione_aspirante.visit("%s/utente/fotografia/fototessera/" % self.live_server_url)
self.assertTrue(sessione_aspirante.is_text_present('Accesso Volontari'))
for tipo in dict(Titolo.TIPO).keys():
sessione_aspirante.visit("%s/utente/curriculum/%s/" % (self.live_server_url, tipo))
if tipo in (Titolo.PATENTE_CRI, Titolo.TITOLO_CRI):
self.assertTrue(sessione_aspirante.is_text_present('Accesso Volontari'))
else:
self.assertFalse(sessione_aspirante.is_text_present('Accesso Volontari'))
sessione_aspirante.visit("%s/attivita/" % self.live_server_url)
self.assertTrue(sessione_aspirante.is_text_present('Accesso Volontari'))
sessione_aspirante.visit("%s/utente/storico/" % self.live_server_url)
self.assertTrue(sessione_aspirante.is_text_not_present('Accesso Volontari'))
sessione_aspirante.visit("%s/utente/documenti/" % self.live_server_url)
self.assertTrue(sessione_aspirante.is_text_present('Accesso Volontari'))
sessione_dipendente = self.sessione_utente(persona=dipendente, wait_time=2)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Estensione')), 0)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Trasferimento')), 0)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Riserva')), 0)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Fotografie')), 1)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Patenti CRI')), 1)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Titoli CRI')), 1)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Attività')), 0)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Storico')), 1)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Documenti')), 2)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Utente')), 1)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Volontario')), 0)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('dipendente')), 0)
self.assertEqual(len(sessione_dipendente.find_link_by_partial_text('Cambia password')), 1)
sessione_dipendente.visit("%s/utente/estensione/" % self.live_server_url)
self.assertTrue(sessione_dipendente.is_text_present('Accesso Volontari'))
sessione_dipendente.visit("%s/utente/trasferimento/" % self.live_server_url)
self.assertTrue(sessione_dipendente.is_text_present('Accesso Volontari'))
sessione_dipendente.visit("%s/utente/riserva/" % self.live_server_url)
self.assertTrue(sessione_dipendente.is_text_present('Accesso Volontari'))
sessione_dipendente.visit("%s/utente/fotografia/" % self.live_server_url)
self.assertTrue(sessione_dipendente.is_text_not_present('Fototessera (formale)'))
sessione_dipendente.visit("%s/utente/fotografia/fototessera/" % self.live_server_url)
self.assertTrue(sessione_dipendente.is_text_present('Accesso Volontari'))
for tipo in dict(Titolo.TIPO).keys():
sessione_dipendente.visit("%s/utente/curriculum/%s/" % (self.live_server_url, tipo))
self.assertFalse(sessione_dipendente.is_text_present('Accesso Volontari'))
sessione_dipendente.visit("%s/attivita/" % self.live_server_url)
self.assertTrue(sessione_dipendente.is_text_present('Accesso Volontari'))
sessione_dipendente.visit("%s/utente/storico/" % self.live_server_url)
self.assertTrue(sessione_dipendente.is_text_not_present('Accesso Volontari'))
sessione_dipendente.visit("%s/utente/documenti/" % self.live_server_url)
self.assertTrue(sessione_dipendente.is_text_not_present('Accesso Volontari'))
sessione_ordinario = self.sessione_utente(persona=ordinario, wait_time=2)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Estensione')), 0)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Trasferimento')), 0)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Riserva')), 0)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Fotografie')), 1)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Patenti CRI')), 0)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Titoli CRI')), 0)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Attività')), 0)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Storico')), 1)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Documenti')), 1)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Utente')), 1)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Volontario')), 0)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('ordinario')), 0)
self.assertEqual(len(sessione_ordinario.find_link_by_partial_text('Cambia password')), 1)
sessione_ordinario.visit("%s/utente/estensione/" % self.live_server_url)
self.assertTrue(sessione_ordinario.is_text_present('Accesso Volontari'))
sessione_ordinario.visit("%s/utente/trasferimento/" % self.live_server_url)
self.assertTrue(sessione_ordinario.is_text_present('Accesso Volontari'))
sessione_ordinario.visit("%s/utente/riserva/" % self.live_server_url)
self.assertTrue(sessione_ordinario.is_text_present('Accesso Volontari'))
sessione_ordinario.visit("%s/utente/fotografia/" % self.live_server_url)
self.assertTrue(sessione_ordinario.is_text_not_present('Fototessera (formale)'))
sessione_ordinario.visit("%s/utente/fotografia/fototessera/" % self.live_server_url)
self.assertTrue(sessione_ordinario.is_text_present('Accesso Volontari'))
for tipo in dict(Titolo.TIPO).keys():
sessione_ordinario.visit("%s/utente/curriculum/%s/" % (self.live_server_url, tipo))
if tipo in (Titolo.PATENTE_CRI, Titolo.TITOLO_CRI):
self.assertTrue(sessione_ordinario.is_text_present('Accesso Volontari'))
else:
self.assertFalse(sessione_ordinario.is_text_present('Accesso Volontari'))
sessione_ordinario.visit("%s/attivita/" % self.live_server_url)
self.assertTrue(sessione_ordinario.is_text_present('Accesso Volontari'))
sessione_ordinario.visit("%s/utente/storico/" % self.live_server_url)
self.assertTrue(sessione_ordinario.is_text_not_present('Accesso Volontari'))
sessione_ordinario.visit("%s/utente/documenti/" % self.live_server_url)
self.assertTrue(sessione_ordinario.is_text_present('Accesso Volontari'))
sessione_sostenitore = self.sessione_utente(persona=sostenitore, wait_time=2)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Estensione')), 0)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Trasferimento')), 0)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Riserva')), 0)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Fotografie')), 1)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Patenti CRI')), 0)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Titoli CRI')), 0)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Attività')), 0)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Storico')), 1)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Documenti')), 1)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Utente')), 1)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Volontario')), 0)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('sostenitore')), 0)
self.assertEqual(len(sessione_sostenitore.find_link_by_partial_text('Cambia password')), 1)
sessione_sostenitore.visit("%s/utente/estensione/" % self.live_server_url)
self.assertTrue(sessione_sostenitore.is_text_present('Accesso Volontari'))
sessione_sostenitore.visit("%s/utente/trasferimento/" % self.live_server_url)
self.assertTrue(sessione_sostenitore.is_text_present('Accesso Volontari'))
sessione_sostenitore.visit("%s/utente/riserva/" % self.live_server_url)
self.assertTrue(sessione_sostenitore.is_text_present('Accesso Volontari'))
sessione_sostenitore.visit("%s/utente/fotografia/" % self.live_server_url)
self.assertTrue(sessione_sostenitore.is_text_not_present('Fototessera (formale)'))
sessione_sostenitore.visit("%s/utente/fotografia/fototessera/" % self.live_server_url)
self.assertTrue(sessione_sostenitore.is_text_present('Accesso Volontari'))
for tipo in dict(Titolo.TIPO).keys():
sessione_sostenitore.visit("%s/utente/curriculum/%s/" % (self.live_server_url, tipo))
if tipo in (Titolo.PATENTE_CRI, Titolo.TITOLO_CRI):
self.assertTrue(sessione_sostenitore.is_text_present('Accesso Volontari'))
else:
self.assertFalse(sessione_sostenitore.is_text_present('Accesso Volontari'))
sessione_sostenitore.visit("%s/attivita/" % self.live_server_url)
self.assertTrue(sessione_sostenitore.is_text_present('Accesso Volontari'))
sessione_sostenitore.visit("%s/utente/storico/" % self.live_server_url)
self.assertTrue(sessione_sostenitore.is_text_not_present('Accesso Volontari'))
sessione_sostenitore.visit("%s/utente/documenti/" % self.live_server_url)
self.assertTrue(sessione_sostenitore.is_text_present('Accesso Volontari'))
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')
def test_richiedi_tesserino(self, extra_headers={}):
presidente_locale = crea_persona()
presidente_provinciale = crea_persona()
presidente_regionale = crea_persona()
presidente_nazionale = crea_persona()
persona = crea_persona()
locazione = Locazione.objects.create(indirizzo="viale italia 1")
sede_nazionale = crea_sede(presidente=presidente_nazionale, estensione=NAZIONALE)
sede_nazionale.locazione = locazione
sede_nazionale.save()
sede_regionale = crea_sede(presidente=presidente_regionale, estensione=REGIONALE, genitore=sede_nazionale)
sede_regionale.locazione = locazione
sede_regionale.save()
sede_provinciale = crea_sede(presidente=presidente_provinciale, estensione=PROVINCIALE, genitore=sede_regionale)
sede_provinciale.locazione = locazione
sede_provinciale.save()
sede_locale = crea_sede(presidente=presidente_locale, estensione=PROVINCIALE, genitore=sede_provinciale)
sede_locale.locazione = locazione
sede_locale.save()
appartenenza = crea_appartenenza(persona, sede_locale)
sessione_persona = self.sessione_utente(persona=persona)
sessione_persona.visit("%s/utente/fotografia/fototessera/" % self.live_server_url)
file_obj, filename = tempfile.mkstemp('.jpg')
file_obj = django.core.files.File(open(filename, 'rb'))
fototessera = Fototessera.objects.create(
persona=persona,
file=file_obj
)
self.assertTrue(persona.fototessere.all().exists())
self.assertEqual(fototessera, persona.fototessera_attuale())
sessione_persona.reload()
self.assertTrue(sessione_persona.is_text_present('Storico richieste fototessere'))
self.assertTrue(sessione_persona.is_text_present('Confermato'))
self.assertEqual(1, len(sessione_persona.find_by_tag('tbody').find_by_tag('tr')))
sessione_presidente_locale = self.sessione_utente(persona=presidente_locale)
sessione_presidente_locale.click_link_by_partial_text("Soci")
self.assertEqual(1, len(sessione_presidente_locale.find_link_by_href("/us/tesserini/")))
sessione_presidente_locale.visit("%s/us/tesserini/" % self.live_server_url)
self.assertEqual(1, len(sessione_presidente_locale.find_link_by_href("/us/tesserini/da-richiedere/")))
# TODO: richiedere il tesserino cliccando sul link apposito, al momento
# non è possibile agire sugli elementi della pagina causa probabile timeout
#sessione_presidente_locale.visit("%s/us/tesserini/da-richiedere/" % self.live_server_url)
#self.assertTrue(sessione_presidente_locale.is_text_present(persona.nome))
#self.assertTrue(sessione_presidente_locale.is_text_present(persona.cognome))
sessione_presidente_locale.visit("%s/us/tesserini/richiedi/%s/" % (self.live_server_url, persona.pk))
self.assertTrue(sessione_presidente_locale.is_text_present('Richiesta inoltrata'))
self.assertTrue(sessione_presidente_locale.is_text_present('La richiesta di stampa è stata inoltrata correttamente alla Sede di emissione'))
self.assertTrue(sessione_presidente_locale.is_text_present(sede_regionale.nome))
self.assertTrue(sessione_presidente_locale.is_text_present(persona.nome))
self.assertTrue(sessione_presidente_locale.is_text_present(persona.cognome))
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(email.subject.find('Richiesta Tesserino inoltrata') > -1)
self.assertTrue(email.body.find('Il tuo Comitato ha avviato la richiesta di stampa del tuo tesserino.') > -1)
sessione_presidente_regionale = self.sessione_utente(persona=presidente_regionale)
sessione_presidente_regionale.visit("%s/us/tesserini/emissione/" % self.live_server_url)
sessione_presidente_regionale.find_by_xpath('//select[@name="stato_richiesta"]//option[@value="ATT"]').first.click()
sessione_presidente_regionale.find_by_xpath("//button[@type='submit']").first.click()
sessione_presidente_regionale.find_by_id("seleziona-tutti").first.click()
sessione_presidente_regionale.find_by_value("lavora").first.click()
sessione_presidente_regionale.find_by_xpath('//select[@name="stato_richiesta"]//option[@value="OK"]').first.click()
sessione_presidente_regionale.find_by_xpath('//select[@name="stato_emissione"]//option[@value="STAMPAT"]').first.click()
sessione_presidente_regionale.find_by_xpath("//button[@type='submit']").first.click()
tesserini = Tesserino.objects.all()
self.assertEqual(1, tesserini.count())
tesserino = tesserini.first()
codice_tesserino = tesserino.codice
self.assertTrue(tesserino.valido)
self.assertNotEqual(None, codice_tesserino)
sessione_persona.visit("%s/informazioni/verifica-tesserino/" % self.live_server_url)
sessione_persona.fill('numero_tessera', codice_tesserino)
sessione_persona.find_by_xpath("//button[@type='submit']").first.click()
self.assertTrue(sessione_persona.is_text_present('Tesserino valido'))
# Richiedi duplicato
sessione_presidente_locale.visit("%s/us/tesserini/richiedi/%s/" % (self.live_server_url, persona.pk))
self.assertTrue(sessione_presidente_locale.is_text_present('Richiesta inoltrata'))
self.assertTrue(sessione_presidente_locale.is_text_present('La richiesta di stampa è stata inoltrata correttamente alla Sede di emissione'))
self.assertTrue(sessione_presidente_locale.is_text_present(sede_regionale.nome))
self.assertTrue(sessione_presidente_locale.is_text_present(persona.nome))
self.assertTrue(sessione_presidente_locale.is_text_present(persona.cognome))
self.assertEqual(len(mail.outbox), 2)
email = mail.outbox[1]
self.assertTrue(email.subject.find('Richiesta Duplicato Tesserino inoltrata') > -1)
self.assertTrue(email.body.find('Il tuo Comitato ha avviato la richiesta di stampa del duplicato del tuo tesserino.') > -1)
sessione_presidente_regionale = self.sessione_utente(persona=presidente_regionale)
sessione_presidente_regionale.visit("%s/us/tesserini/emissione/" % self.live_server_url)
sessione_presidente_regionale.find_by_xpath('//select[@name="stato_richiesta"]//option[@value="ATT"]').first.click()
sessione_presidente_regionale.find_by_xpath("//button[@type='submit']").first.click()
sessione_presidente_regionale.find_by_id("seleziona-tutti").first.click()
sessione_presidente_regionale.find_by_value("lavora").first.click()
sessione_presidente_regionale.find_by_xpath('//select[@name="stato_richiesta"]//option[@value="OK"]').first.click()
sessione_presidente_regionale.find_by_xpath('//select[@name="stato_emissione"]//option[@value="STAMPAT"]').first.click()
sessione_presidente_regionale.find_by_xpath("//button[@type='submit']").first.click()
tesserino_duplicato = Tesserino.objects.exclude(codice=codice_tesserino).first()
tesserino_vecchio = Tesserino.objects.filter(codice=codice_tesserino).first()
self.assertEqual(Tesserino.DUPLICATO, tesserino_duplicato.tipo_richiesta)
self.assertNotEqual(Tesserino.DUPLICATO, tesserino.tipo_richiesta)
self.assertTrue(tesserino_duplicato.valido)
self.assertFalse(tesserino_vecchio.valido)
sessione_persona.visit("%s/informazioni/verifica-tesserino/" % self.live_server_url)
sessione_persona.fill('numero_tessera', codice_tesserino)
sessione_persona.find_by_xpath("//button[@type='submit']").first.click()
self.assertTrue(sessione_persona.is_text_present('Tesserino non valido'))
sessione_persona.fill('numero_tessera', tesserino_duplicato.codice)
sessione_persona.find_by_xpath("//button[@type='submit']").first.click()
self.assertTrue(sessione_persona.is_text_present('Tesserino valido'))
def test_appartenenza(self):
data_corrente = datetime.date.today()
anno_corrente = data_corrente.year
LIVELLI_DELEGATI = [(DELEGATO_OBIETTIVO_1, 'M'), (DELEGATO_OBIETTIVO_2, 'N'), (DELEGATO_OBIETTIVO_3, 'O'), (DELEGATO_OBIETTIVO_4, 'P'), (DELEGATO_OBIETTIVO_5, 'Q'), (DELEGATO_OBIETTIVO_6, 'R')]
LIVELLI_ATTIVITA = ['S', 'T', 'U', 'V', 'W', 'X']
# Notizie di test
notizia_1 = NotiziaTest.objects.create(testo="Notizia 1: Testo di prova!")
notizia_2 = NotiziaTest.objects.create(testo="Notizia 2: Altro testo di prova!")
# SEGMENTI NOTIZIA_1
# Segmento per filtrare tutti gli utenti
segmento_tutti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='A',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i volontari
segmento_volontari_no_filtri = NotiziaTestSegmento.objects.create(
segmento='B',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i volontari con meno di un anno di attivita
segmento_volontari_meno_uno_no_filtri = NotiziaTestSegmento.objects.create(
segmento='C',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i volontari con più di un anno di attivita
segmento_volontari_piu_uno_no_filtri = NotiziaTestSegmento.objects.create(
segmento='D',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i volontari con meno di 35 anni
segmento_volontari_meno_35_anni_no_filtri = NotiziaTestSegmento.objects.create(
segmento='E',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i volontari con meno di 35 anni
segmento_volontari_35_anni_o_piu_no_filtri = NotiziaTestSegmento.objects.create(
segmento='F',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i sostenitori
segmento_sostenitori_no_filtri = NotiziaTestSegmento.objects.create(
segmento='G',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i sostenitori
segmento_aspiranti_corsisti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='H',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i presidenti con delega attiva
segmento_presidenti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='I',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i presidenti di comitati locali con delega attiva
segmento_presidenti_comitati_locali_no_filtri = NotiziaTestSegmento.objects.create(
segmento='J',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i presidenti di comitati regionali con delega attiva
segmento_presidenti_comitati_regionali_no_filtri = NotiziaTestSegmento.objects.create(
segmento='K',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i delegati Ufficio Soci con delega attiva
segmento_delegati_US_no_filtri = NotiziaTestSegmento.objects.create(
segmento='L',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i delegati Autoparco con delega attiva
segmento_delegati_autoparco_no_filtri = NotiziaTestSegmento.objects.create(
segmento='Y',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i delegati Formazione con delega attiva
segmento_delegati_formazione_no_filtri = NotiziaTestSegmento.objects.create(
segmento='Z',
notiziatest=notizia_1
)
# Segmento per filtrare tutti i volontari con titolo
titolo_patenteCRI = Titolo.objects.create(tipo='PC', nome='Titolo test')
segmento_volontari_con_titolo_no_filtri = NotiziaTestSegmento.objects.create(
segmento='AA',
notiziatest=notizia_1,
titolo=titolo_patenteCRI
)
# Utente gaia generico
persona = crea_persona()
persona.save()
# Test appartenenza
esito = persona.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = persona.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertFalse(esito)
esito = persona.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Volontario
volontario, _, _ = crea_persona_sede_appartenenza()
esito = volontario.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Volontario con meno di un anno di attività
volontario_meno_uno, _, _ = crea_persona_sede_appartenenza()
volontario_meno_uno.creazione = data_corrente - datetime.timedelta(days=5)
volontario_meno_uno.save()
esito = volontario_meno_uno.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_uno.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_uno.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
# TODO: creare dati di test per verificare il segmento
#esito = volontario_meno_uno.appartiene_al_segmento(segmento_volontari_piu_uno_no_filtri)
#self.assertFalse(esito)
#esito = volontario_meno_uno.appartiene_al_segmento(segmento_volontari_meno_uno_no_filtri)
#self.assertTrue(esito)
# Volontario con più di un anno di attività
volontario_piu_uno, _, _ = crea_persona_sede_appartenenza()
volontario_piu_uno.creazione = data_corrente - datetime.timedelta(days=720)
volontario_piu_uno.save()
esito = volontario_piu_uno.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_piu_uno.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_piu_uno.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
# TODO: creare dati di test per verificare il segmento
#esito = volontario_piu_uno.appartiene_al_segmento(segmento_volontari_meno_uno_no_filtri)
#self.assertFalse(esito)
#esito = volontario_piu_uno.appartiene_al_segmento(segmento_volontari_piu_uno_no_filtri)
#self.assertTrue(esito)
# Volontario con meno di 35 anni
volontario_meno_35_anni, _, _ = crea_persona_sede_appartenenza()
esito = volontario_meno_35_anni.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_35_anni.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_35_anni.appartiene_al_segmento(segmento_volontari_meno_35_anni_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_35_anni.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Volontario con 35 anni o più di età
volontario_35_anni_o_piu, _, _ = crea_persona_sede_appartenenza()
volontario_35_anni_o_piu.data_nascita = "1960-2-5"
volontario_35_anni_o_piu.save()
esito = volontario_35_anni_o_piu.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_35_anni_o_piu.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_35_anni_o_piu.appartiene_al_segmento(segmento_volontari_meno_35_anni_no_filtri)
self.assertFalse(esito)
esito = volontario_35_anni_o_piu.appartiene_al_segmento(segmento_volontari_35_anni_o_piu_no_filtri)
self.assertTrue(esito)
esito = volontario_35_anni_o_piu.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Sostenitore
sostenitore, _, appartenenza = crea_persona_sede_appartenenza()
appartenenza.membro = Appartenenza.SOSTENITORE
appartenenza.save()
esito = sostenitore.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = sostenitore.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertFalse(esito)
esito = sostenitore.appartiene_al_segmento(segmento_sostenitori_no_filtri)
self.assertTrue(esito)
esito = sostenitore.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Presidente
presidente = crea_persona()
presidente.save()
presidente, sede, _ = crea_persona_sede_appartenenza(presidente)
delega_presidente_in_corso = Delega(
persona=presidente,
tipo=PRESIDENTE,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_presidente_in_corso.save()
esito = presidente.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = presidente.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = presidente.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertTrue(esito)
# Presidente comitato locale
presidente_comitato_locale = crea_persona()
presidente_comitato_locale, sede, appartenenza = crea_persona_sede_appartenenza(presidente_comitato_locale)
delega_presidente_comitato_locale_in_corso = Delega(
persona=presidente_comitato_locale,
tipo=PRESIDENTE,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_presidente_comitato_locale_in_corso.save()
esito = presidente_comitato_locale.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_locale.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_locale.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_locale.appartiene_al_segmento(segmento_presidenti_comitati_locali_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_locale.appartiene_al_segmento(segmento_presidenti_comitati_regionali_no_filtri)
self.assertFalse(esito)
# Presidente comitato regionale
presidente_comitato_regionale = crea_persona()
presidente_comitato_regionale, sede, appartenenza = crea_persona_sede_appartenenza(presidente_comitato_regionale)
sede.estensione = REGIONALE
sede.save()
delega_presidente_comitato_regionale_in_corso = Delega(
persona=presidente_comitato_regionale,
tipo=PRESIDENTE,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_presidente_comitato_regionale_in_corso.save()
esito = presidente_comitato_regionale.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_regionale.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_regionale.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_regionale.appartiene_al_segmento(segmento_presidenti_comitati_locali_no_filtri)
self.assertFalse(esito)
esito = presidente_comitato_regionale.appartiene_al_segmento(segmento_presidenti_comitati_regionali_no_filtri)
self.assertTrue(esito)
# Delegato Ufficio Soci
delegato_US = crea_persona()
sede_delegato_US = crea_sede()
appartenenza = crea_appartenenza(delegato_US, sede_delegato_US)
delega_ufficio_soci = Delega(
persona=delegato_US,
tipo=UFFICIO_SOCI,
oggetto=sede_delegato_US,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_ufficio_soci.save()
esito = delegato_US.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = delegato_US.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = delegato_US.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = delegato_US.appartiene_al_segmento(segmento_delegati_US_no_filtri)
self.assertTrue(esito)
esito = delegato_US.appartiene_al_segmento(segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
# Delegati Obiettivo
for livello_obiettivo in LIVELLI_DELEGATI:
delegato = crea_persona()
sede_delegato = crea_sede()
appartenenza = crea_appartenenza(delegato, sede_delegato)
segmento = NotiziaTestSegmento.objects.create(
segmento=livello_obiettivo[1],
notiziatest=notizia_1
)
delega_obiettivo = Delega(
persona=delegato,
tipo=livello_obiettivo[0],
oggetto=sede_delegato,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_obiettivo.save()
esito = delegato.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = delegato.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = delegato.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = delegato.appartiene_al_segmento(segmento)
self.assertTrue(esito)
esito = delegato.appartiene_al_segmento(segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
# Referenti attività area
for idx, livello_attivita in enumerate(LIVELLI_ATTIVITA):
referente = crea_persona()
sede_referente = crea_sede()
appartenenza = crea_appartenenza(referente, sede_referente)
segmento = NotiziaTestSegmento.objects.create(
segmento=livello_attivita,
notiziatest=notizia_1
)
delega_referente = Delega(
persona=referente,
tipo=REFERENTE,
oggetto=sede_referente,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_referente.save()
area, attivita = crea_area_attivita(sede=sede_referente)
area.obiettivo = idx + 1
area.save()
attivita.aggiungi_delegato(REFERENTE, referente)
esito = referente.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = referente.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = referente.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = referente.appartiene_al_segmento(segmento)
self.assertTrue(esito)
esito = referente.appartiene_al_segmento(segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
# Delegato Autoparco
delegato_autoparco = crea_persona()
sede_delegato_autoparco = crea_sede()
appartenenza = crea_appartenenza(delegato_autoparco, sede_delegato_autoparco)
delega_autoparco = Delega(
persona=delegato_autoparco,
tipo=RESPONSABILE_AUTOPARCO,
oggetto=sede_delegato_autoparco,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_autoparco.save()
esito = delegato_autoparco.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = delegato_autoparco.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = delegato_autoparco.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = delegato_autoparco.appartiene_al_segmento(segmento_delegati_US_no_filtri)
self.assertFalse(esito)
esito = delegato_autoparco.appartiene_al_segmento(segmento_delegati_autoparco_no_filtri)
self.assertTrue(esito)
# Delegato Formazione
delegato_formazione = crea_persona()
sede_delegato_formazione = crea_sede()
appartenenza = crea_appartenenza(delegato_formazione, sede_delegato_formazione)
delega_formazione = Delega(
persona=delegato_formazione,
tipo=RESPONSABILE_FORMAZIONE,
oggetto=sede_delegato_formazione,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_formazione.save()
esito = delegato_formazione.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = delegato_formazione.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = delegato_formazione.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = delegato_formazione.appartiene_al_segmento(segmento_delegati_US_no_filtri)
self.assertFalse(esito)
esito = delegato_formazione.appartiene_al_segmento(segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
esito = delegato_formazione.appartiene_al_segmento(segmento_delegati_formazione_no_filtri)
self.assertTrue(esito)
# Aspirante volontario iscritto ad un corso
aspirante_corsista = crea_persona()
sede = crea_sede()
aspirante = Aspirante(persona=aspirante_corsista)
aspirante.save()
corso = CorsoBase.objects.create(
stato='A',
sede=sede,
data_inizio=datetime.datetime.now() + datetime.timedelta(days=5),
data_esame=datetime.datetime.now() + datetime.timedelta(days=25),
progressivo=1,
anno=anno_corrente
)
partecipazione = PartecipazioneCorsoBase(
persona=aspirante_corsista,
corso=corso
)
partecipazione.ammissione = 'AM'
partecipazione.save()
esito = aspirante_corsista.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = aspirante_corsista.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(segmento_delegati_US_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(segmento_delegati_formazione_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(segmento_aspiranti_corsisti_no_filtri)
self.assertTrue(esito)
# Volontario con titolo
volontario_con_titolo, _, _ = crea_persona_sede_appartenenza()
titolo_personale = TitoloPersonale.objects.create(titolo=titolo_patenteCRI, persona=volontario_con_titolo)
esito = volontario_con_titolo.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_con_titolo.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_con_titolo.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito =volontario_con_titolo.appartiene_al_segmento(segmento_volontari_con_titolo_no_filtri)
self.assertTrue(esito)
# Volontario con titolo di tipo differente dal filtro
volontario_con_titolo_differente, _, _ = crea_persona_sede_appartenenza()
titolo_patenteCIVILE = Titolo.objects.create(tipo='PP', nome='Titolo test 2')
titolo_personale = TitoloPersonale.objects.create(titolo=titolo_patenteCIVILE, persona=volontario_con_titolo_differente)
esito = volontario_con_titolo_differente.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_con_titolo_differente.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_con_titolo_differente.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = volontario_con_titolo_differente.appartiene_al_segmento(segmento_volontari_con_titolo_no_filtri)
self.assertFalse(esito)
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')
def test_storia_volontario(self):
presidente1 = crea_persona()
presidente2 = crea_persona()
persona = crea_persona()
persona.save()
persona, sede1, app1 = crea_persona_sede_appartenenza(presidente1)
sede2 = crea_sede(presidente2)
sede2.save()
sede3 = crea_sede(presidente2)
sede3.save()
# Appena diventato volontario
a = Appartenenza(
persona=persona,
sede=sede1,
membro=Appartenenza.VOLONTARIO,
inizio=poco_fa(),
confermata=True
)
a.save()
self.assertTrue(persona.volontario_da_meno_di_un_anno)
# data vecchia nel passato
a.inizio = "1980-12-10"
a.save()
self.assertFalse(persona.volontario_da_meno_di_un_anno)
# trasferiscilo ad altro comitato
modulo = ModuloCreazioneEstensione()
est = modulo.save(commit=False)
est.richiedente = persona
est.persona = persona
est.destinazione = sede2
est.save()
est.richiedi()
aut = presidente1.autorizzazioni_in_attesa().first()
modulo = est.autorizzazione_concedi_modulo()({
"protocollo_numero": 31,
"protocollo_data": datetime.date.today()
})
aut.concedi(presidente1, modulo=modulo)
est.refresh_from_db()
# il trasferimento non cambia l'anzianità
self.assertFalse(persona.volontario_da_meno_di_un_anno)
# impostiamo una data recente
a.inizio = datetime.date.today()
a.save()
self.assertTrue(persona.volontario_da_meno_di_un_anno)
# trasferimento fallito ad altro comitato
modulo = ModuloCreazioneEstensione()
est = modulo.save(commit=False)
est.richiedente = persona
est.persona = persona
est.destinazione = sede3
est.save()
est.richiedi()
aut = presidente1.autorizzazioni_in_attesa().first()
modulo = est.autorizzazione_concedi_modulo()({
"protocollo_numero": 32,
"protocollo_data": datetime.date.today()
})
aut.nega(presidente1, modulo=modulo)
est.refresh_from_db()
# lo stato non è cambiato
self.assertTrue(persona.volontario_da_meno_di_un_anno)
# data vecchia nel passato
a.inizio = "1980-12-10"
a.save()
self.assertFalse(persona.volontario_da_meno_di_un_anno)
# un espulso non è più un volontario, quindi deve fallire
a.inizio = datetime.date.today()
a.save()
persona.espelli()
self.assertFalse(persona.volontario_da_meno_di_un_anno)
# reintegriamo l'utente
a = Aspirante(persona=persona)
a.locazione = sede1.locazione
a.save()
# l'aspirante non è volontario
self.assertFalse(persona.volontario_da_meno_di_un_anno)
# promosso a volontario
persona.da_aspirante_a_volontario(sede2)
# è appena tornato volontario
self.assertTrue(persona.volontario_da_meno_di_un_anno)
# dimettiamolo
for app in persona.appartenenze_attuali():
d = Dimissione(
persona=persona,
sede=sede2,
appartenenza=app
)
d.save()
d.applica()
self.assertFalse(persona.volontario_da_meno_di_un_anno)
# reintegriamo l'utente
a = Aspirante(persona=persona)
a.locazione = sede1.locazione
a.save()
# l'aspirante non è volontario
self.assertFalse(persona.volontario_da_meno_di_un_anno)
# promosso a volontario
persona.da_aspirante_a_volontario(sede2)
# è appena tornato volontario
self.assertTrue(persona.volontario_da_meno_di_un_anno)
attuale = persona.appartenenze_attuali().get(membro=Appartenenza.VOLONTARIO)
# data vecchia nel passato
attuale.inizio = "1980-12-10"
attuale.save()
self.assertFalse(persona.volontario_da_meno_di_un_anno)
def test_permessi(self):
c = crea_sede(estensione=PROVINCIALE)
c.save()
c2 = crea_sede(estensione=TERRITORIALE, genitore=c)
c2.save()
p = crea_persona()
p.save()
v = crea_persona()
v.save()
a = Appartenenza(
persona=v,
sede=c,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
confermata=True
)
a.save()
self.assertFalse(
p.permessi_almeno(c, MODIFICA),
msg="Questa persona non ha delega di presidenza"
)
self.assertFalse(
p.permessi_almeno(v, MODIFICA),
msg="Questa persona non ha delega di Ufficio Soci"
)
d1 = Delega(
persona=p,
tipo=UFFICIO_SOCI,
oggetto=c,
inizio="1980-12-10",
fine="1990-12-10",
)
d1.save()
self.assertFalse(
p.permessi_almeno(v, MODIFICA),
msg="La delega e' passata, non vale."
)
d2 = Delega(
persona=p,
tipo=UFFICIO_SOCI,
oggetto=c,
inizio="2020-12-10",
fine="2025-12-10",
)
d2.save()
self.assertFalse(
p.permessi_almeno(v, MODIFICA),
msg="La delega e' futura, non vale."
)
d3 = Delega(
persona=p,
tipo=UFFICIO_SOCI,
oggetto=c,
inizio="2020-12-10",
fine=None,
)
d3.save()
self.assertFalse(
p.permessi_almeno(v, MODIFICA),
msg="La delega e' futura, non vale."
)
self.assertFalse(
p.oggetti_permesso(ELENCHI_SOCI).exists(),
msg="Non ho permesso di Elenchi soci da nessuna parte"
)
d4 = Delega(
persona=p,
tipo=UFFICIO_SOCI,
oggetto=c,
inizio="2000-12-10",
fine="2099-12-10",
)
d4.save()
self.assertTrue(
p.permessi_almeno(v, MODIFICA),
msg="La persona ha diritti di US sulla scheda."
)
d4.delete()
d5 = Delega(
persona=p,
tipo=UFFICIO_SOCI,
oggetto=c,
inizio="2000-12-10",
fine=None,
)
d5.save()
self.assertTrue(
p.permessi_almeno(v, MODIFICA),
msg="La persona ha diritti di US sulla scheda."
)
self.assertTrue(
p.oggetti_permesso(ELENCHI_SOCI).count() == 2,
msg="Ho permesso di elenchi su due comitati"
)
self.assertFalse(
p.permessi_almeno(c, MODIFICA),
msg="Questa persona non ha delega di presidenza"
)
d6 = Delega(
persona=p,
tipo=PRESIDENTE,
oggetto=c,
inizio="2000-12-10",
fine=None,
)
d6.save()
self.assertTrue(
p.permessi_almeno(v, MODIFICA),
msg="La persona ha diritti di US sulla scheda."
)
self.assertTrue(
p.permessi_almeno(c, MODIFICA),
msg="Questa persona ha delega di presidenza"
)
self.assertTrue(
p.permessi_almeno(c2, MODIFICA),
msg="Questa persona ha delega di presidenza, e puo' quindi modificare comitati sottostanti"
)
d5.delete()
self.assertTrue(
p.permessi_almeno(v, MODIFICA),
msg="La persona ha ancora, tramite presidenza, diritti di US sulla scheda."
)
self.assertTrue(
p.permessi_almeno(c, MODIFICA),
msg="Questa persona ha delega di presidenza"
)
d6.fine = "2010-12-10"
d6.save()
self.assertFalse(
p.permessi_almeno(v, MODIFICA),
msg="La persona non ha piu, tramite presidenza, diritti di US sulla scheda."
)
self.assertFalse(
p.permessi_almeno(c, MODIFICA),
msg="Questa persona non ha piu delega di presidenza"
)
d6.delete()
def test_permessi_ufficio_soci(self):
stefano = crea_persona()
catania = crea_sede(presidente=stefano, estensione=LOCALE)
maletto = crea_sede(estensione=TERRITORIALE, genitore=catania)
ufficio_soci_catania_locale = crea_persona()
Delega.objects.create(persona=ufficio_soci_catania_locale, tipo=UFFICIO_SOCI, oggetto=catania, inizio=poco_fa())
ufficio_soci_catania_unita = crea_persona()
Delega.objects.create(persona=ufficio_soci_catania_unita, tipo=UFFICIO_SOCI_UNITA, oggetto=catania, inizio=poco_fa())
ufficio_soci_maletto = crea_persona()
Delega.objects.create(persona=ufficio_soci_maletto, tipo=UFFICIO_SOCI_UNITA, oggetto=maletto, inizio=poco_fa())
self.assertTrue(
ufficio_soci_catania_locale.oggetti_permesso(GESTIONE_SOCI).filter(pk=catania.pk),
msg="US Catania Locale puo' gestire soci Catania"
)
self.assertTrue(
ufficio_soci_catania_locale.oggetti_permesso(GESTIONE_SOCI).filter(pk=maletto.pk),
msg="US Catania Locale puo' gestire soci Maletto"
)
self.assertTrue(
ufficio_soci_catania_unita.oggetti_permesso(GESTIONE_SOCI).filter(pk=catania.pk),
msg="US Catania Unita puo' gestire soci Catania"
)
self.assertFalse(
ufficio_soci_catania_unita.oggetti_permesso(GESTIONE_SOCI).filter(pk=maletto.pk),
msg="US Catania Unita NON puo' gestire soci Maletto"
)
self.assertFalse(
ufficio_soci_maletto.oggetti_permesso(GESTIONE_SOCI).filter(pk=catania.pk),
msg="US Maletto NON puo' gestire soci Catania"
)
self.assertTrue(
ufficio_soci_maletto.oggetti_permesso(GESTIONE_SOCI).filter(pk=maletto.pk),
msg="US Maletto puo' gestire soci Maletto"
)
# Inizialmente nessuno ha autorizzazioni
self.assertFalse(
ufficio_soci_catania_locale.autorizzazioni_in_attesa().exists()
or ufficio_soci_catania_unita.autorizzazioni_in_attesa().exists()
or ufficio_soci_maletto.autorizzazioni_in_attesa().exists()
or stefano.autorizzazioni_in_attesa().exists(),
msg="Inizialmente nessuno ha autorizzzioni in attesa"
)
tizio_nuovo = crea_persona()
app = Appartenenza.objects.create(persona=tizio_nuovo, membro=Appartenenza.VOLONTARIO, inizio=poco_fa(), sede=maletto)
app.richiedi()
self.assertFalse(
ufficio_soci_catania_unita.autorizzazioni_in_attesa().exists(),
msg="Il delegato Catania Unita non vede la richiesta"
)
self.assertTrue(
ufficio_soci_catania_locale.autorizzazioni_in_attesa().exists(),
msg="Il delegato Catania Locale vede la richiesta"
)
self.assertTrue(
ufficio_soci_maletto.autorizzazioni_in_attesa().exists(),
msg="Il delegato Maletto vede la richiesta"
)
# Accettiamo la richiesta.
for x in app.autorizzazioni.all():
x.concedi(stefano, modulo=None)
self.assertFalse(
ufficio_soci_catania_unita.permessi_almeno(tizio_nuovo, MODIFICA),
msg="Il delegato Catania Unita non puo gestire volontario"
)
self.assertFalse(
ufficio_soci_catania_unita.permessi_almeno(tizio_nuovo, LETTURA),
msg="Il delegato Catania Unita non puo gestire volontario"
)
self.assertTrue(
ufficio_soci_catania_locale.permessi_almeno(tizio_nuovo, MODIFICA),
msg="Il delegato Catania Locale puo gestire volontario"
)
self.assertTrue(
ufficio_soci_maletto.permessi_almeno(tizio_nuovo, MODIFICA),
msg="Il delegato Maletto puo gestire volontario"
)
def test_sede_espandi(self):
italia = crea_sede(estensione=NAZIONALE)
_sicilia = crea_sede(estensione=REGIONALE, genitore=italia)
__catania = crea_sede(estensione=PROVINCIALE, genitore=_sicilia)
___maletto = crea_sede(estensione=TERRITORIALE, genitore=__catania)
___giarre = crea_sede(estensione=LOCALE, genitore=__catania)
____riposto = crea_sede(estensione=TERRITORIALE, genitore=___giarre)
____salfio = crea_sede(estensione=TERRITORIALE, genitore=___giarre)
lombardia = crea_sede(estensione=REGIONALE, genitore=italia)
_milano = crea_sede(estensione=PROVINCIALE, genitore=lombardia)
# Ricarica tutte le Sedi dal database
for x in [italia, _sicilia, __catania, ___maletto, ___giarre, ____riposto, ____salfio, lombardia, _milano]:
x.refresh_from_db()
self.assertTrue(
italia.espandi(includi_me=True, pubblici=True).count() == (italia.get_descendants().count() + 1),
msg="Espansione dal Nazionale ritorna tutti i Comitati - inclusa Italia",
)
self.assertTrue(
italia.espandi(includi_me=True, pubblici=False).count() == 1,
msg="Espansione dal Nazionale solo se stessa se pubblici=False",
)
self.assertTrue(
italia.espandi(includi_me=False, pubblici=True).count() == italia.get_descendants().count(),
msg="Espansione dal Nazionale ritorna tutti i Comitati - escludendo Italia",
)
self.assertTrue(
_sicilia.espandi(includi_me=True, pubblici=True).count() == (_sicilia.get_descendants().count() + 1),
msg="Espansione dal Regionale ritrna tutti i Comitati - Inclusa Regione"
)
self.assertTrue(
_sicilia.espandi(includi_me=True, pubblici=False).count() == 1,
msg="Espansione dal Regionale ritrna solo se stessa se pubblici=False"
)
self.assertTrue(
__catania in _sicilia.espandi(pubblici=True),
msg="Espansione Regionale ritorna Provinciale"
)
self.assertTrue(
____salfio in _sicilia.espandi(pubblici=True),
msg="Espansione Regionale ritorna Territoriale"
)
self.assertTrue(
____riposto in ___giarre.espandi(pubblici=True),
msg="Espansione Locale ritorna Territoriale"
)
self.assertTrue(
____riposto in ___giarre.espandi(pubblici=False),
msg="Espansione Locale ritorna Territoriale"
)
self.assertTrue(
____riposto not in __catania.espandi(),
msg="Espansione Provinciale non ritorna territoriale altrui"
)
self.assertTrue(
___maletto in __catania.espandi(),
msg="Espansione Provinciale ritorna territoriale proprio"
)
def test_estensione_negata(self):
presidente1 = crea_persona()
presidente2 = crea_persona()
da_estendere, sede1, app1 = crea_persona_sede_appartenenza(presidente1)
sede2 = crea_sede(presidente2)
self.assertFalse(
da_estendere.estensioni_attuali_e_in_attesa().exists(),
msg="Non esiste estensione alcuna"
)
self.assertFalse(
presidente1.autorizzazioni_in_attesa().exists(),
msg="Il presidente non ha autorizzazioni in attesa"
)
modulo = ModuloCreazioneEstensione()
est = modulo.save(commit=False)
est.richiedente = da_estendere
est.persona = da_estendere
est.destinazione = sede2
est.save()
est.richiedi()
self.assertTrue(
da_estendere.estensioni_attuali_e_in_attesa().filter(pk=est.pk).exists(),
msg="L'estensione creata correttamente"
)
self.assertTrue(
presidente1.autorizzazioni_in_attesa().exists(),
msg="Il presidente ha autorizzazioni da processare"
)
self.assertFalse(
presidente2.autorizzazioni_in_attesa().exists(),
msg="Il presidente non ha autorizzazioni in attesa"
)
aut = presidente1.autorizzazioni_in_attesa().first()
self.assertFalse(
est.appartenenza is not None,
msg="l'estensione non ha un'appartenenza"
)
aut.nega(presidente1, modulo=ModuloNegaEstensione({"motivo": "Un motivo qualsiasi"}))
est.refresh_from_db()
self.assertFalse(
est.appartenenza is not None,
msg="l'estensione non ha un'appartenenza"
)
self.assertTrue(
est.esito == est.ESITO_NO,
msg="Estensione rifiutata"
)
da_estendere.refresh_from_db()
self.assertFalse(
da_estendere.estensioni_attuali().exists(),
msg="Il volontario non ha estensioni in corso"
)
def test_appartenenza(self):
data_corrente = datetime.date.today()
anno_corrente = data_corrente.year
LIVELLI_DELEGATI = [(DELEGATO_OBIETTIVO_1, 'M'),
(DELEGATO_OBIETTIVO_2, 'N'),
(DELEGATO_OBIETTIVO_3, 'O'),
(DELEGATO_OBIETTIVO_4, 'P'),
(DELEGATO_OBIETTIVO_5, 'Q'),
(DELEGATO_OBIETTIVO_6, 'R')]
LIVELLI_ATTIVITA = ['S', 'T', 'U', 'V', 'W', 'X']
# Notizie di test
notizia_1 = NotiziaTest.objects.create(
testo="Notizia 1: Testo di prova!")
notizia_2 = NotiziaTest.objects.create(
testo="Notizia 2: Altro testo di prova!")
# SEGMENTI NOTIZIA_1
# Segmento per filtrare tutti gli utenti
segmento_tutti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='A', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari
segmento_volontari_no_filtri = NotiziaTestSegmento.objects.create(
segmento='B', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con meno di un anno di attivita
segmento_volontari_meno_uno_no_filtri = NotiziaTestSegmento.objects.create(
segmento='C', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con più di un anno di attivita
segmento_volontari_piu_uno_no_filtri = NotiziaTestSegmento.objects.create(
segmento='D', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con meno di 35 anni
segmento_volontari_meno_35_anni_no_filtri = NotiziaTestSegmento.objects.create(
segmento='E', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con meno di 35 anni
segmento_volontari_35_anni_o_piu_no_filtri = NotiziaTestSegmento.objects.create(
segmento='F', notiziatest=notizia_1)
# Segmento per filtrare tutti i sostenitori
segmento_sostenitori_no_filtri = NotiziaTestSegmento.objects.create(
segmento='G', notiziatest=notizia_1)
# Segmento per filtrare tutti i sostenitori
segmento_aspiranti_corsisti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='H', notiziatest=notizia_1)
# Segmento per filtrare tutti i presidenti con delega attiva
segmento_presidenti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='I', notiziatest=notizia_1)
# Segmento per filtrare tutti i presidenti di comitati locali con delega attiva
segmento_presidenti_comitati_locali_no_filtri = NotiziaTestSegmento.objects.create(
segmento='J', notiziatest=notizia_1)
# Segmento per filtrare tutti i presidenti di comitati regionali con delega attiva
segmento_presidenti_comitati_regionali_no_filtri = NotiziaTestSegmento.objects.create(
segmento='K', notiziatest=notizia_1)
# Segmento per filtrare tutti i delegati Ufficio Soci con delega attiva
segmento_delegati_US_no_filtri = NotiziaTestSegmento.objects.create(
segmento='L', notiziatest=notizia_1)
# Segmento per filtrare tutti i delegati Autoparco con delega attiva
segmento_delegati_autoparco_no_filtri = NotiziaTestSegmento.objects.create(
segmento='Y', notiziatest=notizia_1)
# Segmento per filtrare tutti i delegati Formazione con delega attiva
segmento_delegati_formazione_no_filtri = NotiziaTestSegmento.objects.create(
segmento='Z', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con titolo
titolo_patenteCRI = Titolo.objects.create(tipo='PC',
nome='Titolo test')
segmento_volontari_con_titolo_no_filtri = NotiziaTestSegmento.objects.create(
segmento='AA', notiziatest=notizia_1, titolo=titolo_patenteCRI)
# Utente gaia generico
persona = crea_persona()
persona.save()
# Test appartenenza
esito = persona.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = persona.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertFalse(esito)
esito = persona.appartiene_al_segmento(segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Volontario
volontario, _, _ = crea_persona_sede_appartenenza()
esito = volontario.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Volontario con meno di un anno di attività
volontario_meno_uno, _, _ = crea_persona_sede_appartenenza()
volontario_meno_uno.creazione = data_corrente - datetime.timedelta(
days=5)
volontario_meno_uno.save()
esito = volontario_meno_uno.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_uno.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_uno.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
# TODO: creare dati di test per verificare il segmento
#esito = volontario_meno_uno.appartiene_al_segmento(segmento_volontari_piu_uno_no_filtri)
#self.assertFalse(esito)
#esito = volontario_meno_uno.appartiene_al_segmento(segmento_volontari_meno_uno_no_filtri)
#self.assertTrue(esito)
# Volontario con più di un anno di attività
volontario_piu_uno, _, _ = crea_persona_sede_appartenenza()
volontario_piu_uno.creazione = data_corrente - datetime.timedelta(
days=720)
volontario_piu_uno.save()
esito = volontario_piu_uno.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_piu_uno.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_piu_uno.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
# TODO: creare dati di test per verificare il segmento
#esito = volontario_piu_uno.appartiene_al_segmento(segmento_volontari_meno_uno_no_filtri)
#self.assertFalse(esito)
#esito = volontario_piu_uno.appartiene_al_segmento(segmento_volontari_piu_uno_no_filtri)
#self.assertTrue(esito)
# Volontario con meno di 35 anni
volontario_meno_35_anni, _, _ = crea_persona_sede_appartenenza()
esito = volontario_meno_35_anni.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_35_anni.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_35_anni.appartiene_al_segmento(
segmento_volontari_meno_35_anni_no_filtri)
self.assertTrue(esito)
esito = volontario_meno_35_anni.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Volontario con 35 anni o più di età
volontario_35_anni_o_piu, _, _ = crea_persona_sede_appartenenza()
volontario_35_anni_o_piu.data_nascita = "1960-2-5"
volontario_35_anni_o_piu.save()
esito = volontario_35_anni_o_piu.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_35_anni_o_piu.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_35_anni_o_piu.appartiene_al_segmento(
segmento_volontari_meno_35_anni_no_filtri)
self.assertFalse(esito)
esito = volontario_35_anni_o_piu.appartiene_al_segmento(
segmento_volontari_35_anni_o_piu_no_filtri)
self.assertTrue(esito)
esito = volontario_35_anni_o_piu.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Sostenitore
sostenitore, _, appartenenza = crea_persona_sede_appartenenza()
appartenenza.membro = Appartenenza.SOSTENITORE
appartenenza.save()
esito = sostenitore.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = sostenitore.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertFalse(esito)
esito = sostenitore.appartiene_al_segmento(
segmento_sostenitori_no_filtri)
self.assertTrue(esito)
esito = sostenitore.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
# Presidente
presidente = crea_persona()
presidente.save()
presidente, sede, _ = crea_persona_sede_appartenenza(presidente)
delega_presidente_in_corso = Delega(
persona=presidente,
tipo=PRESIDENTE,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_presidente_in_corso.save()
esito = presidente.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = presidente.appartiene_al_segmento(segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = presidente.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertTrue(esito)
# Presidente comitato locale
presidente_comitato_locale = crea_persona()
presidente_comitato_locale, sede, appartenenza = crea_persona_sede_appartenenza(
presidente_comitato_locale)
delega_presidente_comitato_locale_in_corso = Delega(
persona=presidente_comitato_locale,
tipo=PRESIDENTE,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_presidente_comitato_locale_in_corso.save()
esito = presidente_comitato_locale.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_locale.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_locale.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_locale.appartiene_al_segmento(
segmento_presidenti_comitati_locali_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_locale.appartiene_al_segmento(
segmento_presidenti_comitati_regionali_no_filtri)
self.assertFalse(esito)
# Presidente comitato regionale
presidente_comitato_regionale = crea_persona()
presidente_comitato_regionale, sede, appartenenza = crea_persona_sede_appartenenza(
presidente_comitato_regionale)
sede.estensione = REGIONALE
sede.save()
delega_presidente_comitato_regionale_in_corso = Delega(
persona=presidente_comitato_regionale,
tipo=PRESIDENTE,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_presidente_comitato_regionale_in_corso.save()
esito = presidente_comitato_regionale.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_regionale.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_regionale.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertTrue(esito)
esito = presidente_comitato_regionale.appartiene_al_segmento(
segmento_presidenti_comitati_locali_no_filtri)
self.assertFalse(esito)
esito = presidente_comitato_regionale.appartiene_al_segmento(
segmento_presidenti_comitati_regionali_no_filtri)
self.assertTrue(esito)
# Delegato Ufficio Soci
delegato_US = crea_persona()
sede_delegato_US = crea_sede()
appartenenza = crea_appartenenza(delegato_US, sede_delegato_US)
delega_ufficio_soci = Delega(
persona=delegato_US,
tipo=UFFICIO_SOCI,
oggetto=sede_delegato_US,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_ufficio_soci.save()
esito = delegato_US.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = delegato_US.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = delegato_US.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = delegato_US.appartiene_al_segmento(
segmento_delegati_US_no_filtri)
self.assertTrue(esito)
esito = delegato_US.appartiene_al_segmento(
segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
# Delegati Obiettivo
for livello_obiettivo in LIVELLI_DELEGATI:
delegato = crea_persona()
sede_delegato = crea_sede()
appartenenza = crea_appartenenza(delegato, sede_delegato)
segmento = NotiziaTestSegmento.objects.create(
segmento=livello_obiettivo[1], notiziatest=notizia_1)
delega_obiettivo = Delega(
persona=delegato,
tipo=livello_obiettivo[0],
oggetto=sede_delegato,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_obiettivo.save()
esito = delegato.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = delegato.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = delegato.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = delegato.appartiene_al_segmento(segmento)
self.assertTrue(esito)
esito = delegato.appartiene_al_segmento(
segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
# Referenti attività area
for idx, livello_attivita in enumerate(LIVELLI_ATTIVITA):
referente = crea_persona()
sede_referente = crea_sede()
appartenenza = crea_appartenenza(referente, sede_referente)
segmento = NotiziaTestSegmento.objects.create(
segmento=livello_attivita, notiziatest=notizia_1)
delega_referente = Delega(
persona=referente,
tipo=REFERENTE,
oggetto=sede_referente,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_referente.save()
area, attivita = crea_area_attivita(sede=sede_referente)
area.obiettivo = idx + 1
area.save()
attivita.aggiungi_delegato(REFERENTE, referente)
esito = referente.appartiene_al_segmento(segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = referente.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = referente.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = referente.appartiene_al_segmento(segmento)
self.assertTrue(esito)
esito = referente.appartiene_al_segmento(
segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
# Delegato Autoparco
delegato_autoparco = crea_persona()
sede_delegato_autoparco = crea_sede()
appartenenza = crea_appartenenza(delegato_autoparco,
sede_delegato_autoparco)
delega_autoparco = Delega(
persona=delegato_autoparco,
tipo=RESPONSABILE_AUTOPARCO,
oggetto=sede_delegato_autoparco,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_autoparco.save()
esito = delegato_autoparco.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = delegato_autoparco.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = delegato_autoparco.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = delegato_autoparco.appartiene_al_segmento(
segmento_delegati_US_no_filtri)
self.assertFalse(esito)
esito = delegato_autoparco.appartiene_al_segmento(
segmento_delegati_autoparco_no_filtri)
self.assertTrue(esito)
# Delegato Formazione
delegato_formazione = crea_persona()
sede_delegato_formazione = crea_sede()
appartenenza = crea_appartenenza(delegato_formazione,
sede_delegato_formazione)
delega_formazione = Delega(
persona=delegato_formazione,
tipo=RESPONSABILE_FORMAZIONE,
oggetto=sede_delegato_formazione,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_formazione.save()
esito = delegato_formazione.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = delegato_formazione.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = delegato_formazione.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = delegato_formazione.appartiene_al_segmento(
segmento_delegati_US_no_filtri)
self.assertFalse(esito)
esito = delegato_formazione.appartiene_al_segmento(
segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
esito = delegato_formazione.appartiene_al_segmento(
segmento_delegati_formazione_no_filtri)
self.assertTrue(esito)
# Aspirante volontario iscritto ad un corso
aspirante_corsista = crea_persona()
sede = crea_sede()
aspirante = Aspirante(persona=aspirante_corsista)
aspirante.save()
corso = CorsoBase.objects.create(
stato='A',
sede=sede,
data_inizio=datetime.datetime.now() + datetime.timedelta(days=5),
data_esame=datetime.datetime.now() + datetime.timedelta(days=25),
progressivo=1,
anno=anno_corrente)
partecipazione = PartecipazioneCorsoBase(persona=aspirante_corsista,
corso=corso)
partecipazione.ammissione = 'AM'
partecipazione.save()
esito = aspirante_corsista.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = aspirante_corsista.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(
segmento_delegati_US_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(
segmento_delegati_autoparco_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(
segmento_delegati_formazione_no_filtri)
self.assertFalse(esito)
esito = aspirante_corsista.appartiene_al_segmento(
segmento_aspiranti_corsisti_no_filtri)
self.assertTrue(esito)
# Volontario con titolo
volontario_con_titolo, _, _ = crea_persona_sede_appartenenza()
titolo_personale = TitoloPersonale.objects.create(
titolo=titolo_patenteCRI, persona=volontario_con_titolo)
esito = volontario_con_titolo.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_con_titolo.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_con_titolo.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = volontario_con_titolo.appartiene_al_segmento(
segmento_volontari_con_titolo_no_filtri)
self.assertTrue(esito)
# Volontario con titolo di tipo differente dal filtro
volontario_con_titolo_differente, _, _ = crea_persona_sede_appartenenza(
)
titolo_patenteCIVILE = Titolo.objects.create(tipo='PP',
nome='Titolo test 2')
titolo_personale = TitoloPersonale.objects.create(
titolo=titolo_patenteCIVILE,
persona=volontario_con_titolo_differente)
esito = volontario_con_titolo_differente.appartiene_al_segmento(
segmento_tutti_no_filtri)
self.assertTrue(esito)
esito = volontario_con_titolo_differente.appartiene_al_segmento(
segmento_volontari_no_filtri)
self.assertTrue(esito)
esito = volontario_con_titolo_differente.appartiene_al_segmento(
segmento_presidenti_no_filtri)
self.assertFalse(esito)
esito = volontario_con_titolo_differente.appartiene_al_segmento(
segmento_volontari_con_titolo_no_filtri)
self.assertFalse(esito)
