def test_campo_centrale_operativa_disabilitata(self):
presidente = crea_persona()
referente = crea_persona()
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
delega = Delega(
oggetto=sede,
persona=presidente,
tipo=PRESIDENTE,
inizio="2005-11-15",
)
delega.save()
delega_2 = Delega(
oggetto=sede,
persona=referente,
tipo=DELEGATO_CO,
inizio="2005-11-15",
)
delega_2.save()
area, attivita = crea_area_attivita(sede=sede)
inizio = timezone.now() + timedelta(hours=12)
fine = inizio + timedelta(hours=2)
turno = crea_turno(attivita, inizio=inizio, fine=fine)
attivita.aggiungi_delegato(REFERENTE, volontario)
attivita.aggiungi_delegato(REFERENTE, referente)
# Crea le sessioni
sessione_referente = self.sessione_utente(persona=referente)
sessione_volontario = self.sessione_utente(persona=volontario)
sessione_presidente = self.sessione_utente(persona=presidente)
# Volontario: Apri la pagina dell'attivita'
sessione_volontario.visit("%s%smodifica/" %
(self.live_server_url, attivita.url))
self.assertIn(
'disabled',
sessione_volontario.find_by_id('id_centrale_operativa')
[0].outer_html)
sessione_presidente.visit("%s%smodifica/" %
(self.live_server_url, attivita.url))
self.assertNotIn(
'disabled',
sessione_presidente.find_by_id('id_centrale_operativa')
[0].outer_html)
sessione_referente.visit("%s%smodifica/" %
(self.live_server_url, attivita.url))
self.assertNotIn(
'disabled',
sessione_referente.find_by_id('id_centrale_operativa')
[0].outer_html)
def test_dettaglio_articoli_protected(self):
articolo = Articolo.objects.create(
titolo='Titolo 1981',
corpo='Testo random',
estratto='qualcosa',
data_inizio_pubblicazione='1981-12-10',
stato=Articolo.PUBBLICATO)
segmento_presidenti_no_filtri = ArticoloSegmento.objects.create(
segmento='I',
articolo=articolo,
)
normale = crea_persona()
normale.save()
normale, sede, _ = crea_persona_sede_appartenenza(normale)
delega_us = Delega(
persona=normale,
tipo=UFFICIO_SOCI,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_us.save()
sessione_persona = self.sessione_utente(persona=normale)
sessione_persona.visit(
"%s%s" % (self.live_server_url,
reverse('dettaglio_articolo',
kwargs={'articolo_slug': articolo.slug})))
self.assertTrue(
sessione_persona.is_text_present(
'Accesso Negato, siamo spiacenti'))
def test_dettaglio_articoli_privati(self):
articolo = Articolo.objects.create(
titolo='Titolo 1981',
corpo='Testo random',
estratto='qualcosa',
data_inizio_pubblicazione='1981-12-10',
stato=Articolo.PUBBLICATO
)
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()
sessione_persona = self.sessione_utente(persona=presidente)
sessione_persona.visit("%s%s" % (
self.live_server_url, reverse('articoli:dettaglio', kwargs={
'articolo_slug': articolo.slug
})
))
self.assertTrue(sessione_persona.is_text_present(articolo.titolo))
def crea_sede(presidente=None, estensione=LOCALE, genitore=None):
ESTENSIONE_DICT = dict(ESTENSIONE)
s = Sede(
nome="Com. " + ESTENSIONE_DICT[estensione] + " " +
names.get_last_name(),
tipo=Sede.COMITATO,
estensione=estensione,
genitore=genitore,
)
s.save()
if presidente is not None:
d = Delega(inizio="1980-12-10",
persona=presidente,
tipo=PRESIDENTE,
oggetto=s)
d.save()
return s
def crea_delega(sede=None, **kwargs):
if not sede:
sede = crea_sede()
print('[sede] <sede> argument was not passed. Created a sede %s' %
sede)
params = {
'creazione': kwargs.get('creazione', "1980-12-01"),
'inizio': kwargs.get('inizio', "1980-12-10"),
'persona': crea_persona(),
'tipo': kwargs.get('tipo', UFFICIO_SOCI),
'stato': kwargs.get('stato', 'a'),
'oggetto': sede,
}
delega = Delega(**params)
delega.save()
print('[delega] Created %s' % delega)
return delega
def crea_sede(presidente=None,
estensione=LOCALE,
genitore=None,
locazione=None):
ESTENSIONE_DICT = dict(ESTENSIONE)
locazione = locazione or crea_locazione()
s = Sede(nome="Com. " + ESTENSIONE_DICT[estensione] + " " +
names.get_last_name(),
tipo=Sede.COMITATO,
estensione=estensione,
genitore=genitore,
telefono='+3902020202',
email='*****@*****.**',
codice_fiscale='01234567891',
partita_iva='01234567891',
locazione=locazione)
s.save()
if presidente is not None:
d = Delega(inizio="1980-12-10",
persona=presidente,
tipo=PRESIDENTE,
oggetto=s)
d.save()
return s
def test_permessi_attivita(self):
fiumefreddo = Sede(
nome="Comitato Locale di Fiumefreddo di Sicilia",
tipo=Sede.COMITATO,
estensione=LOCALE,
)
fiumefreddo.save()
mascali = Sede(
nome="Comitato Locale di Mascali",
tipo=Sede.COMITATO,
estensione=LOCALE,
)
mascali.save()
area = Area(
nome="6",
obiettivo=6,
sede=fiumefreddo,
)
area.save()
a = Attivita(
stato=Attivita.VISIBILE,
nome="Att 1",
apertura=Attivita.APERTA,
area=area,
descrizione="1",
sede=mascali,
)
a.save()
p = Persona(nome="Mario",
cognome="Rossi",
codice_fiscale="FRSSAKJNOKAJMI",
data_nascita="1994-2-5")
p.save()
app = Appartenenza(
persona=p,
sede=fiumefreddo,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
app.save()
t = Turno(
attivita=a,
prenotazione=datetime.datetime(2015, 11, 10),
inizio=datetime.datetime(2015, 11, 10),
fine=datetime.datetime(2015, 11, 30),
minimo=1,
massimo=6,
)
t.save()
delega = Delega(
oggetto=a,
persona=p,
tipo=REFERENTE,
inizio="2015-11-15",
)
delega.save()
self.assertTrue(
p.calendario_turni(datetime.date(2015, 11, 1),
datetime.date(2015, 11,
30)).filter(pk=t.pk).exists(),
msg=
"Il turno viene trovato nel calendario - attivita' creata dalla sede del volontario"
)
def test_articolo(self):
CONTENUTO_1 = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n"
NOME_1 = 'Test1.txt'
CONTENUTO_2 = "Donec tempus nisi eu enim consequat, non scelerisque nisi accumsan.\n"
NOME_2 = 'Test/Test2.txt'
volontario, _, _ = crea_persona_sede_appartenenza()
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()
articolo = Articolo.objects.create(
titolo='Titolo 1',
corpo=parola_casuale(3000),
data_inizio_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=5),
)
self.assertEqual(articolo.corpo[:Articolo.DIMENSIONE_ESTRATTO],
articolo.estratto)
self.assertFalse(articolo.termina)
articolo2 = Articolo.objects.create(
titolo='Titolo 2',
corpo='Testo random',
estratto='estratto qualsiasi',
data_inizio_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=5),
data_fine_pubblicazione=datetime.datetime.now() +
datetime.timedelta(days=5),
stato=Articolo.PUBBLICATO)
segmento_presidenti_no_filtri = ArticoloSegmento.objects.create(
segmento='I',
articolo=articolo2,
)
self.assertNotEqual(articolo2.corpo, articolo2.estratto)
self.assertEqual(articolo2.estratto, 'estratto qualsiasi')
self.assertTrue(articolo2.termina)
articolo3 = Articolo.objects.create(
titolo='Titolo 3',
corpo='Testo qualsiasi',
estratto='estratto random',
data_inizio_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=5),
stato=Articolo.PUBBLICATO)
segmento_volontari_no_filtri = ArticoloSegmento.objects.create(
segmento='B', articolo=articolo3)
z = Zip(oggetto=articolo3)
f1 = NamedTemporaryFile(delete=False, mode='wt')
f1.write(CONTENUTO_1)
f1.close()
z.aggiungi_file(f1.name, NOME_1)
z.comprimi_e_salva(nome='TestZip.zip')
self.assertEqual(1, articolo3.allegati.all().count())
self.assertIn(z, articolo3.allegati.all())
articolo4 = Articolo.objects.create(
titolo='Titolo 4',
corpo='Testo qualsiasi 2',
estratto='estratto random 2',
data_inizio_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=5),
data_fine_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=2),
stato=Articolo.PUBBLICATO)
pubblicati = Articolo.objects.pubblicati()
bozze = Articolo.objects.bozze()
self.assertEqual(pubblicati.count(), 2)
self.assertEqual(bozze.count(), 1)
self.assertIn(articolo, bozze)
self.assertNotIn(articolo, pubblicati)
self.assertNotIn(articolo2, bozze)
self.assertIn(articolo2, pubblicati)
self.assertNotIn(articolo3, bozze)
self.assertIn(articolo3, pubblicati)
self.assertNotIn(articolo4, bozze)
self.assertNotIn(articolo4, pubblicati)
segmenti_volontario = ArticoloSegmento.objects.all(
).filtra_per_segmenti(volontario)
articoli_volontario = segmenti_volontario.oggetti_collegati()
self.assertNotIn(articolo2, articoli_volontario)
self.assertIn(articolo3, articoli_volontario)
segmenti_presidente = ArticoloSegmento.objects.all(
).filtra_per_segmenti(presidente)
articoli_presidente = segmenti_presidente.oggetti_collegati()
self.assertIn(articolo2, articoli_presidente)
self.assertIn(articolo3, articoli_presidente)
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)