def choices_for_request(self):
self.choices = self.choices.filter(
Q(Appartenenza.query_attuale(membro=Appartenenza.SOSTENITORE).via("appartenenze")) |
Q(aspirante__isnull=False)
).exclude(
Q(Appartenenza.query_attuale(membro=Appartenenza.VOLONTARIO).via("appartenenze"))
).order_by('nome', 'cognome', 'codice_fiscale').distinct('nome', 'cognome', 'codice_fiscale')
return super(PersonaAutocompletamento, self).choices_for_request()
def crea_appartenenza(persona, sede):
app = Appartenenza(
persona=persona,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
app.save()
return app
def _calcola_anni_attivita(queryset, meno=True):
limite = now().replace(year=now().year - LIMITE_ANNI_ATTIVITA)
if meno:
appartenenze_filtrate = Appartenenza.query_attuale().filter(inizio__gte=limite)
else:
appartenenze_filtrate = Appartenenza.query_attuale().filter(inizio__lt=limite)
return queryset.filter(appartenenze__in=appartenenze_filtrate)
def risultati(self):
qs_sedi = self.args[0]
oggi = self.modulo_riempito.cleaned_data['al_giorno']
nascita_minima = date(oggi.year - 18, oggi.month, oggi.day)
if self.modulo_riempito.cleaned_data['elettorato'] == ModuloElencoElettorato.ELETTORATO_ATTIVO:
anzianita_minima = datetime(
oggi.year - Appartenenza.MEMBRO_ANZIANITA_ELETTORATO_ATTIVO, oggi.month, oggi.day, 23, 59, 59
)
else:
anzianita_minima = datetime(
oggi.year - Appartenenza.MEMBRO_ANZIANITA_ANNI, oggi.month, oggi.day, 23, 59, 59
)
aggiuntivi = {
# Anzianita' minima
"pk__in": Persona.objects.filter(
Appartenenza.con_esito_ok(
membro__in=Appartenenza.MEMBRO_ANZIANITA,
inizio__lte=anzianita_minima
).via("appartenenze")
).only("id")
}
if self.modulo_riempito.cleaned_data['elettorato'] == ModuloElencoElettorato.ELETTORATO_PASSIVO:
# Elettorato passivo,
aggiuntivi.update({
# Eta' minima
"data_nascita__lte": nascita_minima,
})
r = Persona.objects.filter(
Appartenenza.query_attuale(
al_giorno=oggi,
sede__in=qs_sedi, membro=Appartenenza.VOLONTARIO,
).via("appartenenze"),
Q(**aggiuntivi),
).exclude( # Escludi quelli con dimissione negli anni di anzianita'
appartenenze__terminazione__in=[Appartenenza.DIMISSIONE, Appartenenza.ESPULSIONE],
appartenenze__fine__gte=anzianita_minima,
).exclude( # Escludi quelli con provvedimento di sospensione non terminato
pk__in=ProvvedimentoDisciplinare.objects.filter(
Q(fine__gte=oggi) | Q(fine__isnull=True), inizio__lte=oggi, tipo=ProvvedimentoDisciplinare.SOSPENSIONE
).values_list('persona_id', flat=True)
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
return r
def import_import_volontari(risultato):
i = 0
for p in risultato:
if _ha_errore(p):
continue
dati = _ottieni_dati(p)
dati_persona = {x: y for x, y in dati.items() if x in [
"nome", "cognome", "codice_fiscale", "data_nascita", "comune_nascita",
"provincia_nascita", "stato_nascita", "stato_residenza",
"cap_residenza", "indirizzo_residenza", "comune_residenza",
"email_contatto"
]}
try:
persona = Persona.objects.get(codice_fiscale__iexact=dati_persona['codice_fiscale'])
except Persona.DoesNotExist:
persona = Persona(**dati_persona)
persona.save()
if dati['telefono']:
persona.aggiungi_numero_telefono(dati['telefono'], servizio=False)
if dati['telefono_servizio']:
persona.aggiungi_numero_telefono(dati['telefono_servizio'], servizio=True)
for app in persona.appartenenze_attuali():
app.fine = poco_fa()
app.save()
# Cancella aspirante associato
Aspirante.objects.filter(persona=persona).delete()
app = Appartenenza(
persona=persona,
sede=dati['sede'],
inizio=dati['data_ingresso'],
membro=Appartenenza.VOLONTARIO,
)
app.save()
if dati['email'] and not Utenza.objects.filter(persona=persona).exists():
# Non ha utenza
if not Utenza.objects.filter(email__iexact=dati['email']):
# Non esiste, prova a creare
u = Utenza(persona=persona, email=dati['email'])
u.save()
u.genera_credenziali()
i += 1
return i
def espandi_gestione_soci(qs_sedi, al_giorno=None):
from anagrafica.models import Persona, Appartenenza, Trasferimento, Estensione, Riserva
from ufficio_soci.models import Quota, Tesserino
return [
(MODIFICA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_DIRETTO).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_ESTESO).via("appartenenze"))),
(MODIFICA, Trasferimento.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_DIRETTO).via("persona__appartenenze"))),
##(LETTURA, Trasferimento.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_DIRETTO).via("persona__appartenenze__precedente")))
(MODIFICA, Estensione.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_DIRETTO).via("persona__appartenenze"))),
(LETTURA, Estensione.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_ESTESO).via("persona__appartenenze"))),
(MODIFICA, Quota.objects.filter(sede__in=qs_sedi)),
(LETTURA, Riserva.objects.filter(appartenenza__sede__in=qs_sedi)),
]
def test_elettorato_passivo_trasferimento_anzianita_soddisfatta(self):
x = Appartenenza(
persona=self.p,
sede=self.s,
inizio=self.due_anni_e_mezo_fa,
fine=self.un_anno_fa,
terminazione=Appartenenza.TRASFERIMENTO,
)
x.save()
self.a.inizio = self.un_anno_fa
self.a.fine = None
self.a.precedente = x
self.a.save()
self.assertTrue(
self._elettorato_contiene(tipo="passivo", persona=self.p),
"Elettorato passivo contiene volontari con doppia appartenenza valida (trasf.)"
)
x.inizio = self.un_anno_e_mezzo_fa
x.save()
self.assertFalse(
self._elettorato_contiene(tipo="passivo", persona=self.p),
"Elettorato attivo non contiene volontari con doppia appartenenza invalida (trasf.)"
)
self.a.precedente = None
self.a.save()
x.delete()
def test_elettorato_attivo_dimissione_anzianita_soddisfatta(self):
x = Appartenenza(
persona=self.p,
sede=self.s,
inizio=self.due_anni_e_mezo_fa,
fine=self.un_anno_fa,
terminazione=Appartenenza.DIMISSIONE,
)
x.save()
self.a.inizio = self.sei_mesi_fa
self.a.fine = None
self.a.precedente = x
self.a.save()
self.assertFalse(
self._elettorato_contiene(tipo="attivo", persona=self.p),
"Elettorato attivo NON contiene volontari con doppia appartenenza valida (DIMISSIONE)"
)
x.inizio = self.un_anno_e_mezzo_fa
x.save()
self.assertFalse(
self._elettorato_contiene(tipo="attivo", persona=self.p),
"Elettorato attivo non contiene volontari con doppia appartenenza invalida (DIMISSIONE)"
)
self.a.precedente = None
self.a.save()
x.delete()
def choices_for_request(self):
# Le mie sedi di competenza:
# 1. La mia Sede attuale
# 2. Il mio Comitato
# 3. Le mie Sedi di competenza
sedi = self.request.user.persona.sedi_attuali() \
| self.request.user.persona.sedi_attuali().ottieni_comitati().espandi() \
| self.request.user.persona.sedi_deleghe_attuali(espandi=True, pubblici=True)
self.choices = self.choices.filter(
# 1. Appartenente a una delle sedi
Q(Appartenenza.query_attuale(sede__in=sedi).via("appartenenze"),)
# 2. Iscritto confermato a un corso base presso una mia sede
| Q(PartecipazioneCorsoBase.con_esito(
PartecipazioneCorsoBase.ESITO_OK,
corso__sede__in=sedi
).via("partecipazioni_corsi"))
# 3. Iscritto in attesa a un corso base presso una mia sede
| Q(PartecipazioneCorsoBase.con_esito(
PartecipazioneCorsoBase.ESITO_PENDING,
corso__sede__in=sedi
).via("partecipazioni_corsi"))
)\
.order_by('nome', 'cognome', 'codice_fiscale')\
.distinct('nome', 'cognome', 'codice_fiscale')
return super(PersonaAutocompletamento, self).choices_for_request()
def risultati(self):
qs_sedi = self.args[0]
modulo = self.modulo_riempito
membri = modulo.cleaned_data['membri']
attivi = membri == modulo.MEMBRI_VOLONTARI
ordinari = membri == modulo.MEMBRI_ORDINARI
try:
tesseramento = Tesseramento.objects.get(anno=modulo.cleaned_data.get('anno'))
except Tesseramento.DoesNotExist: # Errore tesseramento anno non esistente
raise ValueError("Anno di tesseramento non valido o gestito da Gaia.")
if modulo.cleaned_data['tipo'] == modulo.VERSATE:
origine = tesseramento.paganti(attivi=attivi, ordinari=ordinari) # Persone con quote pagate
else:
origine = tesseramento.non_paganti(attivi=attivi, ordinari=ordinari) # Persone con quote NON pagate
# Ora filtra per Sede
q = Appartenenza.query_attuale_in_anno(modulo.cleaned_data.get('anno'))
app = Appartenenza.objects.filter(pk__in=q).filter(sede__in=qs_sedi, membro=Appartenenza.VOLONTARIO)
return origine.filter(appartenenze__in=app).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related('quote').distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
cd = self.modulo_riempito.cleaned_data
metodo = cd['metodo']
titoli = cd['titoli']
base = Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_SOCIO,
).via("appartenenze")
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
)
if metodo == self.modulo_riempito.METODO_OR:
# Almeno un titolo
return base.filter(titoli_personali__in=TitoloPersonale.con_esito_ok().filter(
titolo__in=titoli,
)).distinct('cognome', 'nome', 'codice_fiscale')
else:
# Tutti i titoli
base = base.filter(titoli_personali__in=TitoloPersonale.con_esito_ok())
for titolo in titoli:
base = base.filter(titoli_personali__titolo=titolo)
return base.distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
tesserini_richiesti = super(ElencoTesseriniDaRichiedere, self).risultati()
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_TESSERINO,
).via("appartenenze"),
# Con fototessera confermata
Fototessera.con_esito_ok().via("fototessere"),
# Escludi tesserini rifiutati
~Q(tesserini__stato_richiesta=Tesserino.RIFIUTATO),
).exclude( # Escludi quelli richiesti da genitore
pk__in=tesserini_richiesti.values_list('id', flat=True)
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def espandi_gestione_gruppo(qs_gruppi, al_giorno=None):
from anagrafica.models import Persona
from gruppi.models import Appartenenza
return [
(MODIFICA, qs_gruppi),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno).via("appartenenze_gruppi"),
appartenenze_gruppi__gruppo__in=qs_gruppi)),
]
def risultati(self):
qs_sedi = self.args[0]
gruppo = self.args[1]
return Persona.objects.filter(
Appartenenza.query_attuale().via("appartenenze_gruppi"),
App.query_attuale(sede__in=qs_sedi).via("appartenenze"),
appartenenze_gruppi__gruppo=gruppo
).distinct('cognome', 'nome', 'codice_fiscale')
def clean_membro(self):
membro = self.cleaned_data['membro']
sede = self.cleaned_data['sede']
if not Appartenenza.membro_permesso(sede.estensione, membro):
raise ValidationError("La Sede selezionata non può avere questo "
"tipo di membri.")
return membro
def clean_membro(self):
membro = self.cleaned_data['membro']
sede = self.cleaned_data['sede']
if not Appartenenza.membro_permesso(sede.estensione, membro):
raise ValidationError("La Sede selezionata non può avere questo "
"tipo di membri.")
return membro
def risultati(self):
qs_sedi = self.args[0]
gruppo = self.args[1]
return Persona.objects.filter(
Appartenenza.query_attuale().via("appartenenze_gruppi"),
App.query_attuale(sede__in=qs_sedi).via("appartenenze"),
appartenenze_gruppi__gruppo=gruppo).distinct(
'cognome', 'nome', 'codice_fiscale')
def espandi_elenchi_soci(qs_sedi, al_giorno=None):
from anagrafica.models import Persona, Appartenenza, Sede, Riserva
from ufficio_soci.models import Quota, Tesserino
return [
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_DIRETTO).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_ESTESO).via("appartenenze"))),
(LETTURA, Quota.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_ESTESO).via("persona__appartenenze"))),
(LETTURA, Quota.objects.filter(Q(Q(sede__in=qs_sedi) | Q(appartenenza__sede__in=qs_sedi)))),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, confermata=True, ritirata=False).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.con_esito_pending(sede__in=qs_sedi).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.con_esito_no(sede__in=qs_sedi).via("appartenenze"))),
(LETTURA, Riserva.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, confermata=True, ritirata=False).via("persona__appartenenze"))),
(LETTURA, Tesserino.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, confermata=True, ritirata=False).via("persona__appartenenze"))),
]
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro=Appartenenza.SOSTENITORE,
).via("appartenenze")
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
)
def choices_for_request(self):
sedi = [
d.oggetto for d in self.request.user.persona.deleghe_attuali(
tipo__in=(UFFICIO_SOCI, UFFICIO_SOCI_UNITA))
]
self.choices = self.choices.filter(
Appartenenza.query_attuale(membro=Appartenenza.VOLONTARIO,
sede__in=sedi).via("appartenenze"))
return super(VolontarioSedeAutocompletamento,
self).choices_for_request()
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro=Appartenenza.SOSTENITORE,
).via("appartenenze")
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
)
def co_reperibilita(request, me):
sedi = me.oggetti_permesso(GESTIONE_CENTRALE_OPERATIVA_SEDE)
ora = poco_fa()
reperibilita = Reperibilita.query_attuale(Appartenenza.query_attuale(sede__in=sedi).via("persona__appartenenze"),
al_giorno=ora).order_by('attivazione', '-creazione')
contesto = {
"reperibilita": reperibilita,
"ora": ora,
}
return "centrale_operativa_reperibilita.html", contesto
def espandi_gestione_gruppo(qs_gruppi, al_giorno=None):
from anagrafica.models import Persona
from gruppi.models import Appartenenza
try:
return [
(MODIFICA, qs_gruppi),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno).via("appartenenze_gruppi"),
appartenenze_gruppi__gruppo__in=qs_gruppi)),
]
except (AttributeError, ValueError, KeyError, TypeError):
return []
def test_dimissione_passaggio_sostenitore(self):
c = crea_sede(estensione=PROVINCIALE)
c.save()
p = crea_persona()
p.save()
a = Appartenenza(
persona=p,
sede=c,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
confermata=True
)
a.save()
d = Dimissione(
persona=p,
sede=c,
appartenenza=a
)
d.save()
self.assertTrue(
a.attuale(),
msg="L'appartenenza risulta quella attuale."
)
d.applica(trasforma_in_sostenitore=True)
self.assertFalse(
a.attuale(),
msg="L'appartenenza risulta non più attuale."
)
appartenenze_attuali = p.appartenenze_attuali()
self.assertTrue(
appartenenze_attuali.count() == 1,
msg="Esiste solo una appartenenza attuale come sostenitore."
)
def test_dimissione(self):
c = crea_sede(estensione=PROVINCIALE)
c.save()
p = crea_persona()
p.save()
a = Appartenenza(
persona=p,
sede=c,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
confermata=True
)
a.save()
d = Dimissione(
persona=p,
sede=c,
appartenenza=a
)
d.save()
self.assertTrue(
a.attuale(),
msg="L'appartenenza risulta quella attuale."
)
d.applica()
self.assertFalse(
a.attuale(),
msg="L'appartenenza risulta non più attuale."
)
appartenenze_attuali = p.appartenenze_attuali()
self.assertTrue(
appartenenze_attuali.count() == 0,
msg="Non esiste alcuna appartenenza attuale per dimissioni normali."
)
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
~Appartenenza.query_attuale(
sede__in=qs_sedi,
).via("appartenenze"),
appartenenze__sede__in=qs_sedi,
appartenenze__terminazione__in=[Appartenenza.DIMISSIONE, Appartenenza.ESPULSIONE],
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
~Appartenenza.query_attuale(
sede__in=qs_sedi,
).via("appartenenze"),
appartenenze__sede__in=qs_sedi,
appartenenze__terminazione__in=[Appartenenza.DIMISSIONE, Appartenenza.ESPULSIONE],
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Riserva.query_attuale(
Riserva.con_esito_ok().q,
Appartenenza.query_attuale(sede__in=qs_sedi).via(
"appartenenza")).via("riserve")).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
).prefetch_related('appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono').distinct(
'cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
from django.db.models import BooleanField, Value
if self.modulo_riempito.cleaned_data['estesi'] == self.modulo_riempito.ESTESI_INGRESSO:
# Estesi in ingresso
risultati = Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro=Appartenenza.ESTESO,
).via("appartenenze")
).annotate(is_ingresso=Value(value=True, output_field=BooleanField()))
else:
# Estesi in uscita
estesi_da_qualche_parte = Persona.objects.filter(
Appartenenza.query_attuale(
membro=Appartenenza.ESTESO
).via("appartenenze")
).values_list('pk', flat=True)
volontari_da_me = Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro=Appartenenza.VOLONTARIO,
).via("appartenenze")
).values_list('pk', flat=True)
risultati = Persona.objects.filter(
pk__in=volontari_da_me
).filter(
pk__in=estesi_da_qualche_parte
).annotate(is_ingresso=Value(value=False, output_field=BooleanField()))
return risultati.annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
from django.db.models import BooleanField, Value
if self.modulo_riempito.cleaned_data['estesi'] == self.modulo_riempito.ESTESI_INGRESSO:
# Estesi in ingresso
risultati = Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro=Appartenenza.ESTESO,
).via("appartenenze")
).annotate(is_ingresso=Value(value=True, output_field=BooleanField()))
else:
# Estesi in uscita
estesi_da_qualche_parte = Persona.objects.filter(
Appartenenza.query_attuale(
membro=Appartenenza.ESTESO
).via("appartenenze")
).values_list('pk', flat=True)
volontari_da_me = Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro=Appartenenza.VOLONTARIO,
).via("appartenenze")
).values_list('pk', flat=True)
risultati = Persona.objects.filter(
pk__in=volontari_da_me
).filter(
pk__in=estesi_da_qualche_parte
).annotate(is_ingresso=Value(value=False, output_field=BooleanField()))
return risultati.annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def espandi_elenchi_soci(qs_sedi, al_giorno=None):
from anagrafica.models import Persona, Appartenenza, Sede, Riserva
from ufficio_soci.models import Quota, Tesserino
try:
return [
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_DIRETTO).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_ESTESO).via("appartenenze"))),
(LETTURA, Quota.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_ESTESO).via("persona__appartenenze"))),
(LETTURA, Quota.objects.filter(Q(Q(sede__in=qs_sedi) | Q(appartenenza__sede__in=qs_sedi)))),
(LETTURA, Persona.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, confermata=True, ritirata=False).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.con_esito_pending(sede__in=qs_sedi).via("appartenenze"))),
(LETTURA, Persona.objects.filter(Appartenenza.con_esito_no(sede__in=qs_sedi).via("appartenenze"))),
(LETTURA, Riserva.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, confermata=True, ritirata=False).via("persona__appartenenze"))),
(LETTURA, Tesserino.objects.filter(Appartenenza.query_attuale(al_giorno=al_giorno, sede__in=qs_sedi, confermata=True, ritirata=False).via("persona__appartenenze"))),
]
except (AttributeError, ValueError, KeyError):
return []
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi,
membro=Appartenenza.ORDINARIO,
).via("appartenenze")).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related('appartenenze', 'appartenenze__sede', 'utenza',
'numeri_telefono').distinct(
'cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro=Appartenenza.ORDINARIO,
).via("appartenenze")
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Appartenenza.query_attuale(
al_giorno=self.modulo_riempito.cleaned_data['al_giorno'],
sede__in=qs_sedi,
membro__in=Appartenenza.MEMBRO_SOCIO,
).via("appartenenze")).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related('appartenenze', 'appartenenze__sede', 'utenza',
'numeri_telefono').distinct(
'cognome', 'nome', 'codice_fiscale')
def passibili_pagamento(self, membri=Appartenenza.MEMBRO_SOCIO):
"""
Ritorna un elenco di tutti i passibili di pagamento di quota
associativa per il tesseramento in essere.
:param membri: Lista o tupla di appartenenze da considerare
:return: QuerySet<Persona>
"""
# Soci che hanno almeno una appartenenza confermata
# durante l'anno presso un Comitato CRI
return Persona.objects.filter(
Appartenenza.query_attuale_in_anno(self.anno).via("appartenenze"), # Membri nell'anno
appartenenze__membro__in=membri, # ...di un socio cri
appartenenze__sede__tipo=Sede.COMITATO, # ...presso un Comitato
)
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Appartenenza.query_attuale(
al_giorno=self.modulo_riempito.cleaned_data['al_giorno'],
sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_SOCIO,
).via("appartenenze")
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
sostenitori = Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi,
membro=Appartenenza.SOSTENITORE,
).via("appartenenze")).values_list('pk', flat=True)
ex = Persona.objects.filter(
appartenenze__in=Appartenenza.objects.filter(
sede__in=qs_sedi,
membro=Appartenenza.SOSTENITORE,
fine__isnull=False)).exclude(pk__in=sostenitori)
return ex.prefetch_related('appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono')
def passibili_pagamento(self, membri=Appartenenza.MEMBRO_SOCIO):
"""
Ritorna un elenco di tutti i passibili di pagamento di quota
associativa per il tesseramento in essere.
:param membri: Lista o tupla di appartenenze da considerare
:return: QuerySet<Persona>
"""
# Soci che hanno almeno una appartenenza confermata
# durante l'anno presso un Comitato CRI
return Persona.objects.filter(
Appartenenza.query_attuale_in_anno(self.anno).via("appartenenze"), # Membri nell'anno
appartenenze__membro__in=membri, # ...di un socio cri
appartenenze__sede__tipo=Sede.COMITATO, # ...presso un Comitato
)
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
appartenenze__sede__in=qs_sedi,
appartenenze__terminazione__in=[
Appartenenza.TRASFERIMENTO,
],
).exclude( # Escludi tutti i membri attuali delle mie sedi (es. trasf. interni)
pk__in=Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi).via("appartenenze")).values_list(
'id', flat=True)).prefetch_related(
'appartenenze', 'appartenenze__sede', 'utenza',
'numeri_telefono').distinct(
'cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Riserva.query_attuale(
Riserva.con_esito_ok().q,
Appartenenza.query_attuale(
sede__in=qs_sedi
).via("appartenenza"),
).via("riserve")
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_TESSERINO,
).via("appartenenze"),
tesserini__stato_richiesta__in=(Tesserino.ACCETTATO, Tesserino.RICHIESTO),
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
tesserino_codice=F('tesserini__codice'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def attivita_gruppi_gruppo(request, me, pk):
"""
Mostra i membri del gruppo
"""
gruppo = get_object_or_404(Gruppo, pk=pk)
if not me.permessi_almeno(gruppo, MODIFICA):
return redirect(ERRORE_PERMESSI)
sedi = Sede.objects.filter(App.query_attuale().via("appartenenze"),
appartenenze__persona__appartenenze_gruppi__in=gruppo.appartenenze.all())
elenco = ElencoMembriGruppo(sedi, gruppo, gruppo=gruppo)
contesto = {
"elenco": elenco,
"gruppo": gruppo,
}
return 'attivita_gruppi_gruppo.html', contesto
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
appartenenze__sede__in=qs_sedi,
appartenenze__terminazione__in=[Appartenenza.TRASFERIMENTO,],
).exclude( # Escludi tutti i membri attuali delle mie sedi (es. trasf. interni)
pk__in=Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi
).via("appartenenze")
).values_list('id', flat=True)
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_TESSERINO,
).via("appartenenze"),
tesserini__stato_richiesta__in=(Tesserino.ACCETTATO, Tesserino.RICHIESTO, Tesserino.DUPLICATO),
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
tesserino_pk=F('tesserini__pk'),
tesserino_codice=F('tesserini__codice'),
tesserino_tipo_richiesta=F('tesserini__tipo_richiesta'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
sostenitori = Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro=Appartenenza.SOSTENITORE,
).via("appartenenze")
).values_list('pk', flat=True)
ex = Persona.objects.filter(
appartenenze__in=Appartenenza.objects.filter(
sede__in=qs_sedi, membro=Appartenenza.SOSTENITORE,
fine__isnull=False
)
).exclude(pk__in=sostenitori)
return ex.prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
)
def risultati(self):
qs_sedi = self.args[0]
modulo = self.modulo_riempito
membri = modulo.cleaned_data['membri']
attivi = membri == modulo.MEMBRI_VOLONTARI
ordinari = membri == modulo.MEMBRI_ORDINARI
anno = modulo.cleaned_data['anno']
try:
tesseramento = Tesseramento.objects.get(anno=anno)
except Tesseramento.DoesNotExist: # Errore tesseramento anno non esistente
raise ValueError(
"Anno di tesseramento non valido o gestito da Gaia.")
# Dobbiamo ridurre il set a tutti i volontari che sono, al giorno attuale, appartenenti a questa sede
# Nel caso di un anno passato, generiamo l'elenco al 31 dicembre. Nel caso dell'anno in corso,
# generiamo l'elenco al giorno attuale. Questo e' equivalente a:
# giorno = min(31/dicembre/<anno selezionato>, oggi)
giorno_appartenenza = min(date(day=31, month=12, year=anno), oggi())
if modulo.cleaned_data['tipo'] == modulo.VERSATE:
origine = tesseramento.paganti(
attivi=attivi, ordinari=ordinari) # Persone con quote pagate
else:
origine = tesseramento.non_paganti(
attivi=attivi,
ordinari=ordinari) # Persone con quote NON pagate
# Ora filtra per Sede
q = Appartenenza.query_attuale(
al_giorno=giorno_appartenenza,
membro=Appartenenza.VOLONTARIO).filter(sede__in=qs_sedi).defer(
'membro', 'inizio', 'sede')
return origine.filter(appartenenze__in=q).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related('quote').distinct('cognome', 'nome',
'codice_fiscale')
def attivita_gruppi_gruppo(request, me, pk):
"""
Mostra i membri del gruppo
"""
gruppo = get_object_or_404(Gruppo, pk=pk)
if not me.permessi_almeno(gruppo, MODIFICA):
return redirect(ERRORE_PERMESSI)
sedi = Sede.objects.filter(
App.query_attuale().via("appartenenze"),
appartenenze__persona__appartenenze_gruppi__in=gruppo.appartenenze.all(
))
elenco = ElencoMembriGruppo(sedi, gruppo, gruppo=gruppo)
contesto = {
"elenco": elenco,
"gruppo": gruppo,
}
return 'attivita_gruppi_gruppo.html', contesto
def risultati(self):
qs_sedi = self.args[0]
tesserini_richiesti = super(ElencoTesseriniRifiutati, self).risultati()
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi,
membro__in=Appartenenza.MEMBRO_TESSERINO,
).via("appartenenze"),
# Escludi tesserini non rifiutati
Q(tesserini__stato_richiesta=Tesserino.RIFIUTATO),
).exclude( # Escludi quelli richiesti da genitore
pk__in=tesserini_richiesti.values_list('id', flat=True)).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related('appartenenze', 'appartenenze__sede', 'utenza',
'numeri_telefono').distinct(
'cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
modulo = self.modulo_riempito
query = Q()
if modulo.IV == modulo.cleaned_data['includi']:
query &= Q(iv=True)
if modulo.CM == modulo.cleaned_data['includi']:
query &= Q(cm=True)
return Persona.objects.filter(
query,
Appartenenza.query_attuale(
sede__in=qs_sedi,
membro__in=Appartenenza.MEMBRO_DIRETTO,
).via("appartenenze")).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related('appartenenze', 'appartenenze__sede', 'utenza',
'numeri_telefono').distinct(
'cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
modulo = self.modulo_riempito
attivi = Partecipazione.objects.filter(
turno__fine__gte=modulo.cleaned_data['inizio'], turno__inizio__lte=modulo.cleaned_data['fine'],
turno__attivita__sede__in=qs_sedi,
confermata=True,
).values_list('persona_id', flat=True)
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro__in=Appartenenza.MEMBRO_ATTIVITA,
).via("appartenenze")
).exclude(pk__in=attivi).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
modulo = self.modulo_riempito
if modulo and modulo.cleaned_data['includi_estesi'] == modulo.SI:
appartenenze = [Appartenenza.VOLONTARIO, Appartenenza.ESTESO]
else:
appartenenze = [Appartenenza.VOLONTARIO,]
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi, membro__in=appartenenze,
).via("appartenenze")
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def risultati(self):
qs_sedi = self.args[0]
tesserini_da_richiedere = super(ElencoTesseriniSenzaFototessera,
self).risultati()
tesserini_richiesti = super(ElencoTesseriniDaRichiedere,
self).risultati()
return Persona.objects.filter(
Appartenenza.query_attuale(
sede__in=qs_sedi,
membro__in=Appartenenza.MEMBRO_TESSERINO,
).via("appartenenze"),
).exclude( # Escludi quelli che posso richiedere
pk__in=tesserini_da_richiedere.values_list(
'id', flat=True)).exclude( # Escludi quelli gia richiesti
pk__in=tesserini_richiesti.values_list('id', flat=True),
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related('appartenenze', 'appartenenze__sede',
'utenza', 'numeri_telefono').distinct(
'cognome', 'nome', 'codice_fiscale')
def choices_for_request(self, filtra_per_sede=True):
persona = self.request.user.persona
# Le mie sedi di competenza:
# 1. La mia Sede attuale
# 2. Il mio Comitato
# 3. Le mie Sedi di competenza
sedi_attuali = persona.sedi_attuali()
sedi_comitato = sedi_attuali.ottieni_comitati().espandi()
sedi_competenza = persona.sedi_deleghe_attuali(espandi=True,
pubblici=True)
sedi = sedi_attuali | sedi_comitato | sedi_competenza
# 1. Appartenente a una delle sedi
q_appartenenza_sede = Q(
Appartenenza.query_attuale(sede__in=sedi).via("appartenenze"), )
# 2. Iscritto confermato a un corso base presso una mia sede
q_iscritto_corso_base_mia_sede = Q(
PartecipazioneCorsoBase.con_esito(
PartecipazioneCorsoBase.ESITO_OK,
corso__sede__in=sedi).via("partecipazioni_corsi"))
# 3. Iscritto in attesa a un corso base presso una mia sede
q_iscritto_in_attesa_corso_base_mia_sede = Q(
PartecipazioneCorsoBase.con_esito(
PartecipazioneCorsoBase.ESITO_PENDING,
corso__sede__in=sedi).via("partecipazioni_corsi"))
self.choices = self.choices.filter(
q_appartenenza_sede |
q_iscritto_corso_base_mia_sede |
q_iscritto_in_attesa_corso_base_mia_sede
).order_by('nome', 'cognome', 'codice_fiscale')\
.distinct('nome', 'cognome', 'codice_fiscale')
return super(PersonaAutocompletamento, self).choices_for_request()
def test_attivita_estesa(self):
sicilia = Sede(
nome="Comitato Regionale di Sicilia",
tipo=Sede.COMITATO,
estensione=LOCALE,
)
sicilia.save()
fiumefreddo = Sede(
nome="Comitato Locale di Fiumefreddo di Sicilia",
tipo=Sede.COMITATO,
estensione=LOCALE,
genitore=sicilia,
)
fiumefreddo.save()
mascali = Sede(
nome="Comitato Locale di Mascali",
tipo=Sede.COMITATO,
estensione=LOCALE,
genitore=sicilia,
)
mascali.save()
calabria = Sede(
nome="Comitato Regionale di Calabria",
tipo=Sede.COMITATO,
estensione=LOCALE,
)
calabria.save()
area = Area(
nome="6",
obiettivo=6,
sede=sicilia,
)
area.save()
a = Attivita(
stato=Attivita.VISIBILE,
nome="Att 1",
apertura=Attivita.APERTA,
area=area,
descrizione="1",
sede=sicilia,
estensione=sicilia,
)
a.save()
a1 = Attivita(
stato=Attivita.VISIBILE,
nome="Att 1",
apertura=Attivita.APERTA,
area=area,
descrizione="1",
sede=fiumefreddo,
estensione=sicilia,
)
a1.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()
t1 = Turno(attivita=a,
prenotazione=datetime.datetime(2015, 11, 10),
inizio=datetime.datetime(2015, 10, 10),
fine=datetime.datetime(2015, 10, 30))
t1.save()
t2 = Turno(attivita=a1,
prenotazione=datetime.datetime(2015, 11, 10),
inizio=datetime.datetime(2015, 11, 10),
fine=datetime.datetime(2015, 11, 30))
t2.save()
p = Persona(nome="Mario",
cognome="Rossi",
codice_fiscale="FRSSAKJSIKAJDO",
data_nascita="1994-2-5")
p.save()
p1 = Persona(nome="Mario",
cognome="Rossi",
codice_fiscale="FRSSAKJSIRAJDO",
data_nascita="1994-2-5")
p1.save()
p2 = Persona(nome="Mario",
cognome="Rossi",
codice_fiscale="FRSSAKJNOKAJDO",
data_nascita="1994-2-5")
p2.save()
p3 = Persona(nome="Mario",
cognome="Rossi",
codice_fiscale="FRSSAKJNOKAJMI",
data_nascita="1994-2-5")
p3.save()
app = Appartenenza(
persona=p,
sede=sicilia,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
app.save()
app1 = Appartenenza(
persona=p1,
sede=fiumefreddo,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
app1.save()
app2 = Appartenenza(
persona=p2,
sede=mascali,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
app2.save()
app3 = Appartenenza(
persona=p3,
sede=calabria,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
app3.save()
self.assertTrue(
p2.calendario_turni(datetime.date(2015, 11, 1),
datetime.date(2015, 11,
30)).filter(pk=t2.pk).exists(),
msg=
"Il turno viene trovato nel calendario - attivita' estesa al volontario"
)
self.assertFalse(
p3.calendario_turni(datetime.date(2015, 11, 1),
datetime.date(2015, 11,
30)).filter(pk=t2.pk).exists(),
msg=
"Il turno non viene trovato nel calendario - attivita' estesa al volontario"
)
def risultati(self):
from datetime import datetime
qs_sedi = self.args[0]
form = self.modulo_riempito
cd = form.cleaned_data
oggi = cd['al_giorno'] # date
elettorato = cd['elettorato']
# Impostazione Anzianità
oggi = datetime.combine(oggi, datetime.min.time()) # date -> datetime
delta_months = oggi - relativedelta(months=Appartenenza.MEMBRO_ANZIANITA_MESI)
anzianita_minima = delta_months.replace(hour=23, minute=59, second=59)
aggiuntivi = {
# Anzianita' minima
"pk__in": Persona.objects.filter(
Appartenenza.con_esito_ok(
membro__in=[Appartenenza.VOLONTARIO, ],
inizio__lte=anzianita_minima,
terminazione__isnull=True,
).via("appartenenze")
).only("id")
}
# Impostazione età minima
ETA_MINIMA_ANNI = 18 if elettorato == ModuloElencoElettorato.ELETTORATO_PASSIVO else 14
nascita_minima = date(oggi.year - ETA_MINIMA_ANNI, oggi.month, oggi.day)
# Update criteri query
aggiuntivi.update({
# Registrazione versamento della quota associativa annuale (da commentare)
# 'quota__stato': Quota.REGISTRATA,
# 'quota__tipo': Quota.QUOTA_SOCIO,
"data_nascita__lte": nascita_minima, # Età minima
})
# Cerca dipendenti da escludere
dipendenti = Persona.objects.filter(
Q(Appartenenza.query_attuale(
membro=Appartenenza.DIPENDENTE,
sede__in=qs_sedi,
al_giorno=oggi,
).via("appartenenze")))
# print("dipendenti", dipendenti.values_list('pk', flat=True) )
# Query finale
persone = Persona.objects.filter(Appartenenza.query_attuale(
membro=Appartenenza.VOLONTARIO,
sede__in=qs_sedi,
al_giorno=oggi,
).via("appartenenze"), Q(**aggiuntivi))
r = persone.exclude(
# Escludi quelli con provvedimento di sospensione non terminato
pk__in=ProvvedimentoDisciplinare.objects.filter(
Q(fine__lte=oggi) | Q(fine__isnull=True),
inizio__gte=oggi - relativedelta(months=24),
tipo__in=[ProvvedimentoDisciplinare.SOSPENSIONE,
ProvvedimentoDisciplinare.ESPULSIONE,
ProvvedimentoDisciplinare.RADIAZIONE, ]
).values_list('persona__id', flat=True)
).exclude(
pk__in=dipendenti.values_list('pk', flat=True)
)
# Escludi nelle liste elettorali di dove è volontario, essendo dipendente,
# anche se in un altro comitato, non DEVE essere nella lista ne attiva e ne passiva
qs_sedi_pk_list = qs_sedi if isinstance(qs_sedi, list) else qs_sedi.values_list('pk', flat=True)
return r.exclude(
pk__in=Appartenenza.query_attuale(
membro=Appartenenza.DIPENDENTE,
al_giorno=oggi,
sede__pk__in=set(qs_sedi_pk_list) ^
set(Persona.objects.filter(pk__in=r.values_list('pk', flat=True)).values_list('appartenenze__sede__pk', flat=True)),
).values_list('persona__pk', flat=True)
).annotate(
appartenenza_tipo=F('appartenenze__membro'),
appartenenza_inizio=F('appartenenze__inizio'),
appartenenza_sede=F('appartenenze__sede'),
).prefetch_related(
'appartenenze', 'appartenenze__sede', 'utenza', 'numeri_telefono'
).distinct('cognome', 'nome', 'codice_fiscale')
def _q_ordinari(self, solo_paganti=True):
return Q( # Ordinario che ha pagato almeno quota ordinario
Appartenenza.query_attuale_in_anno(self.anno).via("appartenenze"),
self._q_pagante() if solo_paganti else Q(),
appartenenze__membro=Appartenenza.ORDINARIO,
)
def _q_volontari(self, solo_paganti=True):
return Q( # Oppure volontario che ha pagato almeno quota volontario
Appartenenza.query_attuale_in_anno(self.anno).via("appartenenze"),
self._q_pagante() if solo_paganti else Q(),
appartenenze__membro=Appartenenza.VOLONTARIO,
)
def _appartenenze_attive(queryset):
return queryset.filter(
appartenenze__in=Appartenenza.query_attuale().values_list('pk', flat='True')
)
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"
)
