def test_crea_area(self):
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
if not presidente.volontario:
crea_appartenenza(presidente, sede)
sessione_presidente = self.sessione_utente(persona=presidente)
#sessione_persona = self.sessione_utente(persona=persona)
# Crea area di intervento
sessione_presidente.click_link_by_partial_href("/attivita/")
sessione_presidente.click_link_by_partial_text("Aree di intervento")
sessione_presidente.click_link_by_partial_text(sede.nome)
sessione_presidente.fill('nome', "Area 42")
sessione_presidente.fill('obiettivo', '6')
sessione_presidente.find_by_xpath("//button[@type='submit']").first.click()
# Nomina la persona come responsabile
self.seleziona_delegato(sessione_presidente, persona)
self.assertTrue(
sessione_presidente.is_text_present("Area 42"),
"La nuova area è stata creata con successo",
)
self.assertTrue(
sessione_presidente.is_text_present(persona.nome_completo),
"La nuova area ha il responsabile assegnato",
)
self.assertTrue(
sessione_presidente.is_text_present("0 attività"),
"La nuova area non ha alcuna attività",
)
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_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 test_recupero_password_corretto(self, mocked):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
persona_in_sede = crea_persona()
utenza_persona_in_sede = crea_utenza(persona_in_sede)
appartenenza_persona_in_sede = crea_appartenenza(persona, sede)
sessione = self.sessione_anonimo()
sessione.visit("%s%s" % (self.live_server_url, reverse('recupera_password')))
sessione.fill('codice_fiscale', persona_in_sede.codice_fiscale)
sessione.fill('email', utenza_persona_in_sede.email)
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(sessione.is_text_present('Ti abbiamo inviato le istruzioni per cambiare la tua password tramite e-mail'))
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_crea_area(self):
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(
presidente=presidente)
if not presidente.volontario:
crea_appartenenza(presidente, sede)
sessione_presidente = self.sessione_utente(persona=presidente)
#sessione_persona = self.sessione_utente(persona=persona)
# Crea area di intervento
sessione_presidente.click_link_by_partial_href("/attivita/")
sessione_presidente.click_link_by_partial_text("Aree di intervento")
sessione_presidente.click_link_by_partial_text(sede.nome)
sessione_presidente.fill('nome', "Area 42")
sessione_presidente.fill('obiettivo', '6')
sessione_presidente.find_by_xpath(
"//button[@type='submit']").first.click()
# Nomina la persona come responsabile
self.seleziona_delegato(sessione_presidente, persona)
self.assertTrue(
sessione_presidente.is_text_present("Area 42"),
"La nuova area è stata creata con successo",
)
self.assertTrue(
sessione_presidente.is_text_present(persona.nome_completo),
"La nuova area ha il responsabile assegnato",
)
self.assertTrue(
sessione_presidente.is_text_present("0 attività"),
"La nuova area non ha alcuna attività",
)
def test_recupero_password_email_errata(self, mocked):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
persona_in_sede = crea_persona()
utenza_persona_in_sede = crea_utenza(persona_in_sede)
appartenenza_persona_in_sede = crea_appartenenza(persona, sede)
sessione = self.sessione_anonimo()
sessione.visit("%s%s" % (self.live_server_url, reverse('recupera_password')))
sessione.fill('codice_fiscale', persona_in_sede.codice_fiscale)
sessione.fill('email', '*****@*****.**')
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(sessione.is_text_present('ma NON con questo indirizzo e-mail ([email protected])'))
self.assertTrue(sessione.is_text_present('Supporto di Gaia'))
def test_recupero_password_link_valido(self):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
persona_in_sede = crea_persona()
utenza_persona_in_sede = crea_utenza(persona_in_sede)
appartenenza_persona_in_sede = crea_appartenenza(persona, sede)
uid = urlsafe_base64_encode(force_bytes(utenza_persona_in_sede.pk))
reset_pw_link = default_token_generator.make_token(utenza_persona_in_sede)
sessione = self.sessione_anonimo()
sessione.visit("%s%s" % (self.live_server_url, reverse('recupera_password_conferma', kwargs={ 'uidb64': uid, 'token': reset_pw_link})))
sessione.fill('new_password1', 'new_password')
sessione.fill('new_password2', 'new_password')
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(sessione.is_text_present('La tua nuova password è stata impostata'))
sessione.visit("%s%s" % (self.live_server_url, '/login/'))
sessione.fill('auth-username', utenza_persona_in_sede.email)
sessione.fill('auth-password', 'new_password')
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
testo_personalizzato = 'Ciao, {0}'.format(persona_in_sede.nome)
self.assertTrue(sessione.is_text_present(testo_personalizzato))
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_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_registrazione_quota_socio_iv(self):
# Crea oggetti e nomina il delegato US
delegato = crea_persona()
utente = crea_utenza(delegato, email="*****@*****.**", password="******")
volontario, sede, __ = crea_persona_sede_appartenenza()
volontario_iv_1 = crea_persona()
crea_appartenenza(volontario_iv_1, sede)
volontario_iv_1.iv = True
volontario_iv_1.save()
volontario_iv_2 = crea_persona()
crea_appartenenza(volontario_iv_2, sede)
volontario_iv_2.iv = True
volontario_iv_2.save()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
sede.telefono = '+3902020202'
sede.email = '*****@*****.**'
sede.codice_fiscale = '01234567891'
sede.partita_iva = '01234567891'
sede.locazione = crea_locazione()
sede.save()
oggi = poco_fa()
inizio_anno = oggi.replace(month=1, day=1)
fine_soci = oggi - datetime.timedelta(days=60)
fine_soci_iv = oggi - datetime.timedelta(days=30)
data_1 = fine_soci_iv - datetime.timedelta(days=10)
data_2 = fine_soci - datetime.timedelta(days=10)
Tesseramento.objects.create(
stato=Tesseramento.APERTO, inizio=inizio_anno, fine_soci=fine_soci,
fine_soci_iv=fine_soci_iv, anno=inizio_anno.year, quota_attivo=8, quota_ordinario=8,
quota_benemerito=8, quota_aspirante=8, quota_sostenitore=8
)
# registrazione con data odierna bloccata per entrambi
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'successiva al {}'.format(fine_soci.strftime('%Y-%m-%d')))
data = {
'volontario': volontario_iv_1.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'successiva al {}'.format(fine_soci_iv.strftime('%Y-%m-%d')))
# registrazione con data di un mese fa bloccata solo per soci normali
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': data_1.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'successiva al {}'.format(fine_soci.strftime('%Y-%m-%d')))
data = {
'volontario': volontario_iv_1.pk,
'importo': 8,
'data_versamento': data_1.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
# registrazione con data di due mesi fa bloccata solo per soci normali
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': data_2.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
data = {
'volontario': volontario_iv_2.pk,
'importo': 8,
'data_versamento': data_2.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
data = {
'volontario': volontario_iv_1.pk,
'importo': 8,
'data_versamento': data_1.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Questo volontario ha già pagato la Quota associativa '
'per l'anno {}'.format(oggi.year))
def test_crea_attivita(self):
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(
presidente=presidente)
if not presidente.volontario:
crea_appartenenza(presidente, sede)
area = Area(sede=sede, nome="Area 42", obiettivo=6)
area.save()
# Crea le sessioni
sessione_presidente = self.sessione_utente(persona=presidente)
sessione_persona = self.sessione_utente(persona=persona)
# Presidente: Vai a organizza attivita
sessione_presidente.click_link_by_partial_href("/attivita/")
sessione_presidente.click_link_by_partial_text("Organizza attività")
# Presidente: Riempi dettagli attivita
sessione_presidente.fill('nome', "Fine del mondo")
sessione_presidente.select('area', area.pk)
sessione_presidente.select('scelta',
ModuloOrganizzaAttivitaReferente.SONO_IO)
# Presidente: Invia il modulo
sessione_presidente.find_by_xpath(
"//button[@type='submit']").first.click()
# Presidente: Torna all'elenco attività, naviga fino a nuovo turno.
sessione_presidente.click_link_by_partial_text("Gestione turni")
sessione_presidente.click_link_by_partial_text("Crea nuovo turno")
inizio = (timezone.now()).strftime("%d/%m/%Y %H:%m")
fine = (timezone.now() +
timedelta(hours=30)).strftime("%d/%m/%Y %H:%m")
# Presidente: Riempi i dettagli del nuovo turno
sessione_presidente.fill('nome', "Vedetta")
sessione_presidente.fill('inizio', inizio)
sessione_presidente.fill('fine', fine)
sessione_presidente.fill('minimo', 1)
sessione_presidente.fill('massimo', 5)
sessione_presidente.fill('prenotazione', inizio)
sessione_presidente.execute_script(
'window.scrollTo(0, document.body.scrollHeight)')
# Presidente: Invia il modulo
sessione_presidente.find_by_css("button.btn-primary").first.click()
# Volontario: Vai in attività
sessione_persona.click_link_by_partial_text("Attività")
self.assertFalse(sessione_persona.is_text_present("Vedetta"),
msg="L'attività non è visibile.")
# Presidente: Modifica attività
sessione_presidente.click_link_by_partial_text("Elenco attività")
sessione_presidente.click_link_by_partial_text("modifica info")
sessione_presidente.click_link_by_partial_text("Gestione attività")
# Presidente: Imposta stato come VISIBILE
sessione_presidente.select('stato', Attivita.VISIBILE)
# Presidente: Invia il modulo
sessione_presidente.find_by_xpath(
"//button[@type='submit']").first.click()
# Volontario: Vai in attività
sessione_persona.click_link_by_partial_text("Attività")
self.assertTrue(sessione_persona.is_text_present("Vedetta"),
msg="L'attività è ora visibile.")
# Volontario: Clicca sul turno
sessione_persona.click_link_by_partial_text("Vedetta")
self.assertTrue(sessione_persona.is_text_present("Scoperto!"),
msg="Viene mostrata correttamente come scoperta.")
def test_richiesta_supporto(self):
presidente = crea_persona()
persona_normale, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
persona_us = crea_persona()
persona_us_territoriale = crea_persona()
crea_appartenenza(persona_us, sede)
crea_appartenenza(persona_us_territoriale, sede)
crea_utenza(presidente, email=email_fittizzia())
crea_utenza(persona_normale, email=email_fittizzia())
crea_utenza(persona_us, email=email_fittizzia())
crea_utenza(persona_us_territoriale, email=email_fittizzia())
Delega.objects.create(
inizio="1980-12-10",
persona=persona_us,
tipo=UFFICIO_SOCI,
oggetto=sede
)
Delega.objects.create(
inizio="1980-12-10",
persona=persona_us_territoriale,
tipo=UFFICIO_SOCI_UNITA,
oggetto=sede
)
# Utente normale senza persone
sessione_normale = self.sessione_utente(persona=persona_normale)
sessione_normale.visit("%s/supporto/" % self.live_server_url)
sessione_normale.is_text_not_present('Seleziona le persone per cui si richiede assistenza.')
sessione_normale.find_option_by_value(ModuloRichiestaSupporto.SANGUE).first.click()
sessione_normale.fill('oggetto', 'Oggetto')
sessione_normale.fill('descrizione', 'Descrizione')
sessione_normale.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertEqual(email.subject, '(%s) Oggetto' % ModuloRichiestaSupporto.SANGUE)
self.assertTrue('Descrizione' in email.body)
mail.outbox = []
# Utente US con persone
sessione = self.sessione_utente(persona=persona_us)
sessione.visit("%s/supporto/" % self.live_server_url)
sessione.is_text_present('Seleziona le persone per cui si richiede assistenza.')
# Utente US con persone
sessione = self.sessione_utente(persona=persona_us_territoriale)
sessione.visit("%s/supporto/" % self.live_server_url)
sessione.is_text_present('Seleziona le persone per cui si richiede assistenza.')
# Presidente con persone
sessione = self.sessione_utente(persona=presidente)
sessione.visit("%s/supporto/" % self.live_server_url)
sessione.is_text_present('Seleziona le persone per cui si richiede assistenza.')
# Invio form persona normale
self.client.login(username=presidente.utenza.email, password='******')
dati = {
'oggetto': 'Oggetto',
'descrizione': 'Descrizione',
'tipo': ModuloRichiestaSupporto.TERZO_LIVELLO,
}
self.client.post('/supporto/', data=dati)
self.assertTrue(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertEqual(email.subject, '(%s) Oggetto' % ModuloRichiestaSupporto.TERZO_LIVELLO)
self.assertTrue('Descrizione' in email.body)
mail.outbox = []
# Invio form con selezione persone
dati = {
'persona': persona_normale.pk,
'oggetto': 'Oggetto',
'descrizione': 'Descrizione',
'tipo': ModuloRichiestaSupporto.TERZO_LIVELLO,
}
self.client.post('/supporto/', data=dati)
self.assertTrue(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertEqual(email.subject, '(%s) Oggetto' % ModuloRichiestaSupporto.TERZO_LIVELLO)
self.assertTrue('Descrizione' in email.body)
self.assertTrue(force_text(persona_normale) in email.body)
mail.outbox = []
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_crea_attivita(self):
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
if not presidente.volontario:
crea_appartenenza(presidente, sede)
area = Area(sede=sede, nome="Area 42", obiettivo=6)
area.save()
# Crea le sessioni
sessione_presidente = self.sessione_utente(persona=presidente)
sessione_persona = self.sessione_utente(persona=persona)
# Presidente: Vai a organizza attivita
sessione_presidente.click_link_by_partial_href("/attivita/")
sessione_presidente.click_link_by_partial_text("Organizza attività")
# Presidente: Riempi dettagli attivita
sessione_presidente.fill('nome', "Fine del mondo")
sessione_presidente.select('area', area.pk)
sessione_presidente.select('scelta', ModuloOrganizzaAttivitaReferente.SONO_IO)
# Presidente: Invia il modulo
sessione_presidente.find_by_xpath("//button[@type='submit']").first.click()
# Presidente: Torna all'elenco attività, naviga fino a nuovo turno.
sessione_presidente.click_link_by_partial_text("Gestione turni")
sessione_presidente.click_link_by_partial_text("Crea nuovo turno")
inizio = (timezone.now()).strftime("%d/%m/%Y %H:%m")
fine = (timezone.now() + timedelta(hours=30)).strftime("%d/%m/%Y %H:%m")
# Presidente: Riempi i dettagli del nuovo turno
sessione_presidente.fill('nome', "Vedetta")
sessione_presidente.fill('inizio', inizio)
sessione_presidente.fill('fine', fine)
sessione_presidente.fill('minimo', 1)
sessione_presidente.fill('massimo', 5)
sessione_presidente.fill('prenotazione', inizio)
# Presidente: Invia il modulo
sessione_presidente.find_by_xpath("//button[@type='submit']").first.click()
# Volontario: Vai in attività
sessione_persona.click_link_by_partial_text("Attività")
self.assertFalse(sessione_persona.is_text_present("Vedetta"),
msg="L'attività non è visibile.")
# Presidente: Modifica attività
sessione_presidente.click_link_by_partial_text("Elenco attività")
sessione_presidente.click_link_by_partial_text("modifica info")
sessione_presidente.click_link_by_partial_text("Gestione attività")
# Presidente: Imposta stato come VISIBILE
sessione_presidente.select('stato', Attivita.VISIBILE)
# Presidente: Invia il modulo
sessione_presidente.find_by_xpath("//button[@type='submit']").first.click()
# Volontario: Vai in attività
sessione_persona.click_link_by_partial_text("Attività")
self.assertTrue(sessione_persona.is_text_present("Vedetta"),
msg="L'attività è ora visibile.")
# Volontario: Clicca sul turno
sessione_persona.click_link_by_partial_text("Vedetta")
self.assertTrue(sessione_persona.is_text_present("Scoperto!"),
msg="Viene mostrata correttamente come scoperta.")
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_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_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_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)