def disiscrivi(self, mittente=None):
     """
     Disiscrive partecipante dal corso base.
     """
     self.autorizzazioni_ritira()
     Messaggio.costruisci_e_invia(
         oggetto="Disiscrizione dal Corso Base: %s" % self.corso,
         modello="email_aspirante_corso_deiscrizione.html",
         corpo={
             "partecipazione": self,
             "corso": self.corso,
             "persona": self.persona,
             "mittente": mittente,
         },
         mittente=mittente,
         destinatari=[self.persona],
     )
     Messaggio.costruisci_e_invia(
         oggetto="Disiscrizione dal Corso Base: %s" % self.corso,
         modello="email_aspirante_corso_deiscrizione_mittente.html",
         corpo={
             "partecipazione": self,
             "corso": self.corso,
             "persona": self.persona,
             "richiedente": mittente,
         },
         mittente=None,
         destinatari=[mittente],
     )

    def test_flag_utenza_e_contatti_uguali(self):
        self.persona.email_contatto = self.persona.utenza.email
        self.persona.save()

        Messaggio.costruisci_e_invia(
            destinatari=[self.persona],
            oggetto="Stessa email",
            modello="email.html",
            utenza=True
        )
        self.assertEqual(len(mail.outbox), 1)
        email = mail.outbox[0]
        self.assertTrue(email.subject.find('Stessa email') > -1)
        self.assertEqual(len(email.to), 1)
        self.assertIn(self.persona.email_contatto, email.to)
        self.assertIn(self.persona.utenza.email, email.to)

        # Nessuna email di contatto
        self.persona.email_contatto = ''
        self.persona.save()

        Messaggio.costruisci_e_invia(
            destinatari=[self.persona],
            oggetto="Stessa email",
            modello="email.html",
            utenza=True
        )
        # c'è anche quella precedente
        self.assertEqual(len(mail.outbox), 2)
        email = mail.outbox[1]
        self.assertTrue(email.subject.find('Stessa email') > -1)
        self.assertEqual(len(email.to), 1)
        self.assertNotIn(self.persona.email_contatto, email.to)
        self.assertIn(self.persona.utenza.email, email.to)

    def _invia_notifica(self, modello, oggetto, auto, destinatari=None, aggiunte_corpo=None):
        from posta.models import Messaggio

        if not destinatari:
            if auto:
                destinatari = [self.richiedente]
                if self.firmatario:
                    destinatari.append(self.firmatario)
                self.oggetto.automatica = True
                self.oggetto.save()
            else:
                destinatari = [self.richiedente]
        corpo = {
            "richiesta": self,
            "firmatario": self.firmatario,
            "giorni": self.giorni_automatici
        }
        if aggiunte_corpo:
            corpo.update(aggiunte_corpo)

        Messaggio.costruisci_e_accoda(
            oggetto=oggetto,
            modello=modello,
            corpo=corpo,
            mittente=self.firmatario,
            destinatari=destinatari
        )

 def _invia_msg_singolo(self):
     Messaggio.costruisci_e_invia(
         destinatari=[self.persone[0].persona],
         oggetto="Email contatto",
         modello="email.html",
         utenza=True
     )

 def test_messaggio_senza_destinatari(self, mock_smtp):
     messaggio = Messaggio.costruisci_e_accoda(
         destinatari=[],
         oggetto="Email contatto",
         modello="email.html",
     )
     messaggio.smaltisci_coda()
     self.assertEqual(Messaggio.in_coda().count(), 0)

 def _invia_notifica_registrazione(self):
     Messaggio.costruisci_e_invia(
         oggetto="Ricevuta %d del %d: %s" % (
             self.progressivo, self.anno, self.causale
         ),
         modello="email_ricevuta_nuova_notifica.html",
         corpo={"ricevuta": self},
         mittente=self.registrato_da,
         destinatari=[self.persona],
     )

 def test_messaggio_con_destinatario_vuoto(self, mock_smtp):
     persona, sede, appartenenza = crea_persona_sede_appartenenza()
     persona.save()
     messaggio = Messaggio.costruisci_e_accoda(
         destinatari=[persona],
         oggetto="Email contatto",
         modello="email.html",
     )
     messaggio.smaltisci_coda()
     self.assertEqual(Messaggio.in_coda().count(), 0)

    def test_fallimento_autenticazione(self, mock_smtp):
        """
        In caso di fallimento autenticazione il messaggio viene rimesso in coda
        """
        self.assertEqual(Messaggio.in_coda().count(), 0)
        instance = mock_smtp.return_value
        instance.sendmail.side_effect = smtplib.SMTPAuthenticationError(code=530, msg='authentication error')

        self._invia_msg_singolo()
        self.assertEqual(Messaggio.in_coda().count(), 1)

 def _invia_notifica_annullamento(self):
     Messaggio.costruisci_e_invia(
         oggetto="ANNULLATA Ricevuta %d del %d" % (
             self.progressivo, self.anno
         ),
         modello="email_ricevuta_annullata_notifica.html",
         corpo={"ricevuta": self},
         mittente=self.registrato_da,
         destinatari=[self.persona],
     )

    def notifiche_richieste_in_attesa(cls):
        from anagrafica.models import Estensione,  Trasferimento
        from posta.models import Messaggio

        oggetto = "Richieste in attesa di approvazione"
        modello = "email_richieste_pending.html"

        in_attesa = cls.objects.filter(
            concessa__isnull=True
        )
        trasferimenti = in_attesa.filter(oggetto_tipo=ContentType.objects.get_for_model(Trasferimento))
        estensioni = in_attesa.filter(oggetto_tipo=ContentType.objects.get_for_model(Estensione))
        trasferimenti_manuali = trasferimenti.filter(scadenza__isnull=True, tipo_gestione=Autorizzazione.MANUALE)
        trasferimenti_automatici = trasferimenti.filter(
            scadenza__isnull=False, scadenza__gt=now()
        ).exclude(tipo_gestione=Autorizzazione.MANUALE)

        autorizzazioni = list(estensioni) + list(trasferimenti_manuali) + list(trasferimenti_automatici)

        persone = dict()
        for autorizzazione in autorizzazioni:
            if not autorizzazione.oggetto:
                print('autorizzazione {} non ha oggetto collegato'.format(autorizzazione.pk))
                continue
            if autorizzazione.oggetto and not autorizzazione.oggetto.ritirata and not autorizzazione.oggetto.confermata:
                destinatari = cls.espandi_notifiche(autorizzazione.destinatario_oggetto, [], True, True)
                for destinatario in destinatari:
                    if destinatario.pk not in persone:
                        persone[destinatario.pk] = {
                            'persona': None,
                            'estensioni': [],
                            'trasferimenti_manuali': [],
                            'trasferimenti_automatici': [],
                        }
                    persone[destinatario.pk]['persona'] = destinatario
                    if autorizzazione in estensioni:
                        persone[destinatario.pk]['estensioni'].append(autorizzazione.oggetto)
                    elif autorizzazione in trasferimenti_manuali:
                        persone[destinatario.pk]['trasferimenti_manuali'].append(autorizzazione.oggetto)
                    elif autorizzazione in trasferimenti_automatici:
                        persone[destinatario.pk]['trasferimenti_automatici'].append(autorizzazione.oggetto)

        for persona in persone.values():
            corpo = {
                "persona": persona,
                "DATA_AVVIO_TRASFERIMENTI_AUTO": settings.DATA_AVVIO_TRASFERIMENTI_AUTO
            }

            Messaggio.costruisci_e_accoda(
                oggetto=oggetto,
                modello=modello,
                corpo=corpo,
                destinatari=[persona['persona']]
            )

 def notifica_negata(self):
     from posta.models import Messaggio
     Messaggio.costruisci_e_invia(
         oggetto="Richiesta di %s RESPINTA" % (self.oggetto.RICHIESTA_NOME,),
         modello="email_autorizzazione_negata.html",
         corpo={
             "richiesta": self,
         },
         mittente=self.firmatario,
         destinatari=[self.richiedente]
     )

 def _invia_email_agli_aspiranti(self, rispondi_a=None):
     for aspirante in self.aspiranti_nelle_vicinanze():
         persona = aspirante.persona
         Messaggio.costruisci_e_accoda(
             oggetto="Nuovo Corso per Volontari CRI",
             modello="email_aspirante_corso.html",
             corpo={
                 "persona": persona,
                 "corso": self,
             },
             destinatari=[persona],
             rispondi_a=rispondi_a
         )

 def test_flag_utenza(self):
     Messaggio.costruisci_e_invia(
         destinatari=[self.persona],
         oggetto="Entrambe le email",
         modello="email.html",
         utenza=True
     )
     self.assertEqual(len(mail.outbox), 1)
     email = mail.outbox[0]
     self.assertTrue(email.subject.find('Entrambe le email') > -1)
     self.assertEqual(len(email.to), 2)
     self.assertIn(self.persona.email_contatto, email.to)
     self.assertIn(self.persona.utenza.email, email.to)

    def test_flag_no_utenza(self):

        Messaggio.costruisci_e_invia(
            destinatari=[self.persona],
            oggetto="Solo email di contatto",
            modello="email.html"
        )
        self.assertEqual(len(mail.outbox), 1)
        email = mail.outbox[0]
        self.assertTrue(email.subject.find('Solo email di contatto') > -1)
        self.assertEqual(len(email.to), 1)
        self.assertIn(self.persona.email_contatto, email.to)
        self.assertNotIn(self.persona.utenza.email, email.to)

 def _invia_notifica_chiusura(self, autore, azione_automatica):
     """
     Invia una e-mail di notifica ai delegati della chiusura automatica di questa attivita'.
     :param azione_automatica: Se l'azione e' stata svolta in modo automatico (i.e. via cron) o meno.
                               Viene usato per modificare la notifica.
     """
     Messaggio.costruisci_e_accoda(oggetto="Chiusura automatica: %s" % self.nome,
                                   mittente=(None if azione_automatica else autore),
                                   destinatari=self.delegati_attuali(solo_deleghe_attive=True),
                                   modello="email_attivita_chiusa.html",
                                   corpo={"azione_automatica": azione_automatica,
                                          "autore": autore,
                                          "attivita": self})

def aspirante_corso_base_iscritti_aggiungi(request, me, pk):
    corso = get_object_or_404(CorsoBase, pk=pk)
    if not me.permessi_almeno(corso, MODIFICA):
        return redirect(ERRORE_PERMESSI)

    if not corso.possibile_aggiungere_iscritti:
        return errore_generico(request, me, titolo="Impossibile aggiungere iscritti",
                               messaggio="Non si possono aggiungere altri iscritti a questo "
                                         "stadio della vita del corso base.",
                               torna_titolo="Torna al corso base", torna_url=corso.url_iscritti)

    modulo = ModuloIscrittiCorsoBaseAggiungi(request.POST or None)
    risultati = []
    if modulo.is_valid():

        for persona in modulo.cleaned_data['persone']:
            esito = corso.persona(persona)
            ok = False

            if esito in corso.PUOI_ISCRIVERTI or \
                            esito in corso.NON_PUOI_ISCRIVERTI_SOLO_SE_IN_AUTONOMIA:
                ok = True
                p = PartecipazioneCorsoBase(persona=persona, corso=corso)
                p.save()
                Log.crea(me, p)
                Messaggio.costruisci_e_invia(
                    oggetto="Iscrizione a Corso Base",
                    modello="email_corso_base_iscritto.html",
                    corpo={
                        "persona": persona,
                        "corso": corso,
                    },
                    mittente=me,
                    destinatari=[persona]
                )

            risultati += [{
                "persona": persona,
                "esito": esito,
                "ok": ok,
            }]

    contesto = {
        "corso": corso,
        "puo_modificare": True,
        "modulo": modulo,
        "risultati": risultati,
    }
    return 'aspirante_corso_base_scheda_iscritti_aggiungi.html', contesto

 def test_fallimento_data(self, mock_smtp):
     """
     In caso di fallimento durante il comando data  il messaggio viene rimesso in coda,
     tranne che in caso di errore 501 che è permanente
     """
     codici = (451, 554, 500, 501, 503, 421, 552, 451, 452)
     for codice in codici:
         msg = 'code {}'.format(codice)
         instance = mock_smtp.return_value
         instance.sendmail.side_effect = smtplib.SMTPDataError(code=codice, msg=msg)
         self._invia_msg_singolo()
         if codice == 501:
             self.assertEqual(Messaggio.in_coda().count(), 0)
         else:
             self.assertEqual(Messaggio.in_coda().count(), 1)
         self._reset_coda()

    def notifica_richiesta(self, persona):
        from anagrafica.models import Delega, Persona
        from posta.models import Messaggio

        if not persona:
            return  # Nessun destinatario, nessuna e-mail.

        Messaggio.costruisci_e_accoda(
            oggetto="Richiesta di %s da %s" % (self.oggetto.RICHIESTA_NOME, self.richiedente.nome_completo,),
            modello="email_autorizzazione_richiesta.html",
            corpo={
                "richiesta": self,
            },
            mittente=self.richiedente,
            destinatari=[persona],
        )

 def test_fallimento_sender(self, mock_smtp):
     """
     In caso di fallimento del sender il messaggio viene rimesso in coda,
     tranne che in caso di errore 501 che è permanente
     """
     codici = (451, 452, 500, 501, 421)
     for codice in codici:
         msg = 'code {}'.format(codice)
         instance = mock_smtp.return_value
         instance.sendmail.side_effect = smtplib.SMTPSenderRefused(code=codice, msg=msg, sender=Messaggio.SUPPORTO_EMAIL)
         self._invia_msg_singolo()
         if codice == 501:
             self.assertEqual(Messaggio.in_coda().count(), 0)
         else:
             self.assertEqual(Messaggio.in_coda().count(), 1)
         self._reset_coda()

 def notifica_esito_esame(self, mittente=None):
     """
     Invia una e-mail al partecipante con l'esito del proprio esame.
     """
     Messaggio.costruisci_e_accoda(
         oggetto="Esito del Corso Base: %s" % self.corso,
         modello="email_aspirante_corso_esito.html",
         corpo={
             "partecipazione": self,
             "corso": self.corso,
             "persona": self.persona,
             "mittente": mittente,
         },
         mittente=mittente,
         destinatari=[self.persona],
     )