Python models.Appartenenza类代码示例

 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]

        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]
        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 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 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 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 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