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_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 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_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 _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 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 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 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 _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 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_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 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 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],
)
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_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 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 genera_credenziali(self, richiedente=None):
nuova_password = genera_uuid_casuale()
self.set_password(nuova_password)
self.save()
Messaggio.costruisci_e_invia(
oggetto="Credenziali per accedere a Gaia",
modello="email_credenziali.html",
corpo={
"nuova_password": nuova_password,
"utenza": self,
"persona": self.persona,
"richiedente": richiedente,
},
mittente=None,
destinatari=[self.persona],
)
def autorizzazione_concessa(self, modulo=None, auto=False):
with atomic():
corso = self.corso
partecipazione = PartecipazioneCorsoBase.objects.create(persona=self.persona, corso=self.corso)
partecipazione.autorizzazione_concessa()
Messaggio.costruisci_e_invia(
oggetto="Iscrizione a Corso Base",
modello="email_corso_base_iscritto.html",
corpo={
"persona": self.persona,
"corso": self.corso,
},
mittente=self.invitante,
destinatari=[self.persona]
)
self.delete()
return corso
def supporto(request, me=None):
from base.forms_extra import ModuloRichiestaSupporto
modulo = None
if me:
deleghe = set([d.tipo for d in me.deleghe_attuali()])
tipi = set((UFFICIO_SOCI, UFFICIO_SOCI_TEMPORANEO, UFFICIO_SOCI_UNITA, PRESIDENTE))
if deleghe.intersection(tipi):
modulo = ModuloRichiestaSupportoPersone(request.POST or None)
else:
modulo = ModuloRichiestaSupporto(request.POST or None)
scelte = modulo.fields['tipo'].choices
# Solo i delegati possono contattare SECONDO_LIVELLO e TERZO_LIVELLO
if not me.deleghe_attuali().exists():
scelte = rimuovi_scelte([modulo.TERZO_LIVELLO, modulo.SECONDO_LIVELLO], scelte)
modulo.fields['tipo'].choices = scelte
if modulo and modulo.is_valid():
tipo = modulo.cleaned_data['tipo']
oggetto = modulo.cleaned_data['oggetto']
descrizione = modulo.cleaned_data['descrizione']
persona = modulo.cleaned_data.get('persona', None)
oggetto = "(%s) %s" % (tipo, oggetto)
Messaggio.costruisci_e_invia(
oggetto=oggetto,
modello="email_supporto.html",
mittente=me,
destinatari=[],
corpo={
"testo": descrizione,
"mittente": me,
"persona": persona
},
)
return messaggio_generico(request, me, titolo="Richiesta inoltrata",
messaggio="Grazie per aver contattato il supporto. La tua richiesta con "
"oggetto '%s' è stata correttamente inoltrata. Riceverai a minuti "
"un messaggio di conferma del codice ticket assegnato alla "
"tua richiesta." % (oggetto,))
contesto = {
"modulo": modulo
}
return 'supporto.html', contesto
def test_fallimento_disconnect(self, mock_smtp):
"""
In caso di disconessione del server il messaggio viene rimesso in coda
"""
instance = mock_smtp.return_value
instance.sendmail.side_effect = smtplib.SMTPServerDisconnected({})
self._invia_msg_singolo()
self.assertEqual(Messaggio.in_coda().count(), 1)
self._reset_coda()
def test_flag_utenza_solo_email_di_contatto(self):
self.persona.email_contatto = self.persona.utenza.email
self.persona.save()
self.persona.utenza = None
self.persona.save()
Messaggio.costruisci_e_invia(
destinatari=[self.persona],
oggetto="Email contatto",
modello="email.html",
utenza=True
)
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(email.subject.find('Email contatto') > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(self.persona.email_contatto, email.to)
self.assertEqual(1, len(email.to))
def commenti_nuovo(request, me):
"""
Crea un nuovo commento e ritorna indietro alla pagina dei commenti.
:return:
"""
if not request.method == 'POST':
return redirect(ERRORE_PERMESSI)
next = request.POST['next']
oggetto_app_label = request.POST['oggetto_app_label']
oggetto_model = request.POST['oggetto_model']
commento = request.POST['commento']
oggetto_pk = int(request.POST['oggetto_pk'])
oggetto_m = apps.get_model(oggetto_app_label, oggetto_model)
oggetto = oggetto_m.objects.get(pk=oggetto_pk)
if not hasattr(oggetto, 'commenti'):
return redirect(ERRORE_PERMESSI)
if not commento:
return redirect(next)
c = Commento(
oggetto=oggetto,
autore=me,
commento=commento,
)
c.save()
if oggetto.commento_notifica_destinatari(me).exists():
from posta.models import Messaggio
Messaggio.costruisci_e_accoda(
oggetto="Commento di %s su %s" % (me.nome_completo, oggetto,),
modello="email_commento.html",
corpo={
"commento": c,
},
mittente=me,
destinatari=oggetto.commento_notifica_destinatari(me),
)
return redirect(next)
def _richiesta_conferma_email(request, me, parametri, modulo):
email = modulo.cleaned_data.get(parametri['field'], None)
if email and email != parametri['precedente']:
request.session[parametri['session_code']] = email
corpo = {
'code': request.session[parametri['session_key']],
'code_type': parametri['code_type'],
'vecchia_email': parametri['precedente'],
'nuova_email': email,
'persona': me,
'autore': me,
}
Messaggio.invia_raw(
oggetto=parametri['oggetto'],
corpo_html=get_template(parametri['template']).render(corpo),
email_mittente=None,
lista_email_destinatari=[
email
]
)
def test_fallimento_connect(self, mock_smtp):
"""
In caso di fallimento durante il connect il messaggio viene rimesso in coda
"""
codici = (421,)
for codice in codici:
msg = 'code {}'.format(codice)
instance = mock_smtp.return_value
instance.sendmail.side_effect = smtplib.SMTPConnectError(code=codice, msg=msg)
self._invia_msg_singolo()
self.assertEqual(Messaggio.in_coda().count(), 1)
self._reset_coda()
def test_fallimento_recipient(self, mock_smtp):
"""
In caso di fallimento del recipient il messaggio viene rimesso in coda se entrambi
i recipient sono stati rifiutati, altrimenti viene considerato inviato
"""
codici = (550, 551, 552, 553, 450, 451, 452, 500, 501, 503, 521, 421)
for codice in codici:
msg = 'code {}'.format(codice)
instance = mock_smtp.return_value
for x in range(2):
recipients = {
self.persone[0].persona.email: (codice, msg) if x in (1, 2) else (250, 'ok'),
self.persone[0].email: (codice, msg) if x in (0, 2) else (250, 'ok'),
}
instance.sendmail.side_effect = smtplib.SMTPRecipientsRefused(recipients=recipients)
self._invia_msg_singolo()
if codice == 501 or x in (0, 1):
self.assertEqual(Messaggio.in_coda().count(), 0)
else:
self.assertEqual(Messaggio.in_coda().count(), 1)
self._reset_coda()
def test_fallimento_connect(self, mock_smtp):
"""
In caso di fallimento durante il connect il messaggio viene rimesso in coda
"""
codici = (421, )
for codice in codici:
msg = 'code {}'.format(codice)
instance = mock_smtp.return_value
instance.sendmail.side_effect = smtplib.SMTPConnectError(
code=codice, msg=msg)
self._invia_msg_singolo()
self.assertEqual(Messaggio.in_coda().count(), 1)
self._reset_coda()
def autorizzazione_concessa(self,
modulo=None,
auto=False,
notifiche_attive=True,
data=None):
with atomic():
corso = self.corso
partecipazione = PartecipazioneCorsoBase.objects.create(
persona=self.persona, corso=self.corso)
partecipazione.autorizzazione_concessa()
if notifiche_attive:
Messaggio.costruisci_e_invia(
oggetto="Iscrizione a Corso Base",
modello="email_corso_base_iscritto.html",
corpo={
"persona": self.persona,
"corso": self.corso,
},
mittente=self.invitante,
destinatari=[self.persona])
self.delete()
return corso
def test_fallimento_recipient(self, mock_smtp):
"""
In caso di fallimento del recipient il messaggio viene rimesso in coda se entrambi
i recipient sono stati rifiutati, altrimenti viene considerato inviato
"""
codici = (550, 551, 552, 553, 450, 451, 452, 500, 501, 503, 521, 421)
for codice in codici:
msg = 'code {}'.format(codice)
instance = mock_smtp.return_value
for x in range(2):
recipients = {
self.persone[0].persona.email:
(codice, msg) if x in (1, 2) else (250, 'ok'),
self.persone[0].email: (codice, msg) if x in (0, 2) else
(250, 'ok'),
}
instance.sendmail.side_effect = smtplib.SMTPRecipientsRefused(
recipients=recipients)
self._invia_msg_singolo()
if codice == 501 or x in (0, 1):
self.assertEqual(Messaggio.in_coda().count(), 0)
else:
self.assertEqual(Messaggio.in_coda().count(), 1)
self._reset_coda()
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_invia(oggetto=oggetto,
modello=modello,
corpo=corpo,
destinatari=[persona['persona']])
prima.cerca_e_aggiorna()
pv = prima.provincia_breve
altre = Locazione.objects.filter(provincia=provincia)
num = altre.update(provincia_breve=pv)
print("-- %s\t%d\t%s" % (pv, num, provincia))
if args.email:
print("Installo emails di esempio")
# setup di celery per poter accodare
from jorvik.celery import app
if args.reset:
Messaggio.objects.all().delete()
persone = iter(Persona.objects.all().order_by('?'))
for n in range(args.email):
try:
mittente = next(persone)
destinatari = [next(persone) for _ in range(random.randint(0, 5))]
job = Messaggio.costruisci_e_accoda(
oggetto='Prova email numero {}'.format(n + 1),
modello='test_email.html',
mittente=mittente,
destinatari=destinatari)
except StopIteration:
persone = iter(Persona.objects.all().order_by('?')) # rewind
print("Finita esecuzione.")
def do(self):
sedi = Sede.objects.filter(
attiva=True, tipo=Sede.COMITATO,
estensione__in=[NAZIONALE, REGIONALE,
PROVINCIALE, LOCALE]
).prefetch_related("locazione").order_by('nome')
excel = Excel(oggetto=sedi.first())
foglio = FoglioExcel("Report", [
"Denominazione", "Tipo", "Regione", "Provincia",
"Via", "Città", "CAP", "Telefono", "FAX",
"Email", "Sito web", "Denominazione",
"Referente", "Codice Fiscale", "Partita IVA",
"IBAN", "Extra: Titolo", "Extra: Testo"
])
for sede in sedi:
# Denominazione: Rimuovi termini di troppo
denominazione = sede.nome.replace(" Provinciale", "")
estensione = {
NAZIONALE: "CN",
REGIONALE: "CR",
PROVINCIALE: "CP",
LOCALE: "CL"
}[sede.estensione]
regione = sede.locazione.regione if sede.locazione else ""
provincia = sede.locazione.provincia_breve if sede.locazione else ""
via = "%s, %s" % (sede.locazione.via, sede.locazione.civico) if sede.locazione else ""
citta = sede.locazione.comune if sede.locazione else ""
cap = sede.locazione.cap if sede.locazione else ""
presidente = sede.presidente() or ""
extra_titolo = ""
extra_testo = ""
unita = sede.get_children().filter(estensione=TERRITORIALE)
if unita.exists():
extra_titolo = "<h2>Le nostre unità territoriali</h2>"
extra_testo += "<ul>"
for u in unita:
extra_testo += "<li>Sede CRI di %s%s</li>" % (
u.nome,
(" — e-mail: %s" % u.email) if u.email else ""
)
extra_testo += "</ul>"
foglio.aggiungi_riga(
denominazione,
estensione,
regione,
provincia,
via,
citta,
cap,
sede.telefono,
sede.fax,
sede.email,
sede.sito_web,
"Presidente/Commissario CRI",
presidente,
sede.codice_fiscale,
sede.partita_iva,
sede.iban,
extra_titolo,
extra_testo,
)
excel.aggiungi_foglio(foglio)
tra_una_settimana = poco_fa() + timedelta(days=7)
excel.genera_e_salva(nome="Report.xlsx", scadenza=tra_una_settimana)
data = datetime.today().strftime("%d/%m/%Y")
Messaggio.invia_raw(
oggetto="(SVI) Report Sedi CRI - %s" % data,
corpo_html="In allegato è presente il report excel delle Sedi CRI, "
"aggiornato al %s." % data,
email_mittente="%s <%s>" % (Messaggio.SUPPORTO_NOME, Messaggio.NOREPLY_EMAIL),
lista_email_destinatari=DESTINATARI_REPORT,
allegati=[excel]
)
print("Inviato report sedi ai seguenti indirizzi: %s" % ", ".join(DESTINATARI_REPORT))
def posta_scrivi(request, me):
destinatari = Persona.objects.none()
# Prova a recuperare destinatari dalla sessione.
try:
timestamp = request.session["messaggio_destinatari_timestamp"]
if (timestamp and timestamp >
(now() - timedelta(seconds=settings.POSTA_MASSIVA_TIMEOUT))):
# max POSTA_MASSIVA_TIMEOUT secondi fa
destinatari = request.session["messaggio_destinatari"]
except KeyError:
# Nessun destinatario in sessione.
pass
# Svuota eventuale sessione
request.session["messaggio_destinatari"] = None
request.session["messaggio_destinatari_timestamp"] = None
MAX_VISIBILI = 20
MAX_VISIBILI_STR = "%d destinatari selezionati"
if destinatari: # Ho appena scaricato i destinatari
if destinatari.count() > MAX_VISIBILI:
modulo = ModuloScriviMessaggioConDestinatariNascosti(
initial={
"destinatari": [x.pk for x in destinatari],
"destinatari_selezionati":
MAX_VISIBILI_STR % (destinatari.count(), )
})
else:
modulo = ModuloScriviMessaggioConDestinatariVisibili(initial={
"destinatari": [x.pk for x in destinatari],
})
else: # Normale
if len(request.POST.getlist('destinatari')) > MAX_VISIBILI:
modulo = ModuloScriviMessaggioConDestinatariNascosti(
request.POST or None,
request.FILES or None,
initial={
"destinatari_selezionati":
MAX_VISIBILI_STR % (destinatari.count(), )
})
else:
modulo = ModuloScriviMessaggioConDestinatariVisibili(
request.POST or None, request.FILES or None)
if modulo.is_valid():
allegati = []
for a in modulo.cleaned_data['allegati']:
ai = Allegato(file=a, nome=a.name)
ai.scadenza = datetime.now() + timedelta(days=15)
ai.save()
allegati.append(ai)
messaggio = Messaggio.costruisci(
oggetto=modulo.cleaned_data['oggetto'],
modello='email_utente.html',
corpo={"testo": modulo.cleaned_data['testo']},
allegati=allegati,
mittente=me,
destinatari=[
el if isinstance(el, Persona) else Persona.objects.get(
pk=int(el)) for el in modulo.cleaned_data['destinatari']
],
)
# Invia o accoda il messaggio, a seconda del numero di destinatari.
if len(modulo.cleaned_data['destinatari']) > MAX_VISIBILI:
messaggio.accoda()
azione = "accodato"
else:
messaggio.invia()
azione = "inviato"
# Porta alla schermata del messaggio.
return redirect("/posta/in-uscita/1/%d/?%s" % (
messaggio.pk,
azione,
))
contesto = {
"modulo": modulo,
}
return 'posta_scrivi.html', contesto
def do(self):
sedi = Sede.objects.filter(
attiva=True,
tipo=Sede.COMITATO,
estensione__in=[NAZIONALE, REGIONALE, PROVINCIALE, LOCALE
]).prefetch_related("locazione").order_by('nome')
excel = Excel(oggetto=sedi.first())
foglio = FoglioExcel("Report", [
"Denominazione", "Tipo", "Regione", "Provincia", "Via", "Città",
"CAP", "Telefono", "FAX", "Email", "Sito web", "Denominazione",
"Referente", "Codice Fiscale", "Partita IVA", "IBAN", "PEC",
"Ultima modifica", "Extra: Titolo", "Extra: Testo"
])
for sede in sedi:
# Denominazione: Rimuovi termini di troppo
denominazione = sede.nome.replace(" Provinciale", "")
estensione = {
NAZIONALE: "CN",
REGIONALE: "CR",
PROVINCIALE: "CP",
LOCALE: "CL"
}[sede.estensione]
regione = sede.locazione.regione if sede.locazione else ""
provincia = sede.locazione.provincia_breve if sede.locazione else ""
via = "%s, %s" % (sede.locazione.via,
sede.locazione.civico) if sede.locazione else ""
citta = sede.locazione.comune if sede.locazione else ""
cap = sede.locazione.cap if sede.locazione else ""
presidente = sede.presidente() or ""
extra_titolo = ""
extra_testo = ""
unita = sede.ottieni_figli().filter(estensione=TERRITORIALE)
if unita.exists():
extra_titolo = "<h2>Le nostre unità territoriali</h2>"
extra_testo += "<ul>"
for u in unita:
extra_testo += "<li>Sede CRI di %s%s</li>" % (u.nome, (
" — e-mail: %s" % u.email) if u.email else "")
extra_testo += "</ul>"
foglio.aggiungi_riga(
denominazione,
estensione,
regione,
provincia,
via,
citta,
cap,
sede.telefono,
sede.fax,
sede.email,
sede.sito_web,
"Presidente/Commissario CRI",
presidente,
sede.codice_fiscale,
sede.partita_iva,
sede.iban,
sede.pec,
sede.ultima_modifica,
extra_titolo,
extra_testo,
)
excel.aggiungi_foglio(foglio)
tra_una_settimana = poco_fa() + timedelta(days=7)
excel.genera_e_salva(nome="Report.xlsx", scadenza=tra_una_settimana)
data = datetime.today().strftime("%d/%m/%Y")
Messaggio.invia_raw(
oggetto="(SVI) Report Sedi CRI - %s" % data,
corpo_html="In allegato è presente il report excel delle Sedi CRI, "
"aggiornato al %s." % data,
email_mittente="%s <%s>" %
(Messaggio.SUPPORTO_NOME, Messaggio.NOREPLY_EMAIL),
lista_email_destinatari=DESTINATARI_REPORT,
allegati=[excel])
print("Inviato report sedi ai seguenti indirizzi: %s" %
", ".join(DESTINATARI_REPORT))
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 = PartecipazioneCorsoBase.NON_ISCRITTO
partecipazione = None
if esito in corso.PUOI_ISCRIVERTI or esito in corso.NON_PUOI_ISCRIVERTI_SOLO_SE_IN_AUTONOMIA:
if hasattr(persona, 'aspirante'):
inviti = InvitoCorsoBase.con_esito_ok(
) | InvitoCorsoBase.con_esito_pending()
if inviti.filter(persona=persona, corso=corso).exists():
ok = PartecipazioneCorsoBase.INVITO_INVIATO
partecipazione = InvitoCorsoBase.objects.filter(
persona=persona, corso=corso).first()
else:
partecipazione = InvitoCorsoBase(persona=persona,
corso=corso,
invitante=me)
partecipazione.save()
partecipazione.richiedi()
ok = PartecipazioneCorsoBase.IN_ATTESA_ASPIRANTE
else:
partecipazione = PartecipazioneCorsoBase.objects.create(
persona=persona, corso=corso)
ok = PartecipazioneCorsoBase.ISCRITTO
Messaggio.costruisci_e_invia(
oggetto="Iscrizione a Corso Base",
modello="email_corso_base_iscritto.html",
corpo={
"persona": persona,
"corso": corso,
},
mittente=me,
destinatari=[persona])
Log.crea(me, partecipazione)
risultati += [{
"persona": persona,
"partecipazione": partecipazione,
"esito": esito,
"ok": ok,
}]
contesto = {
"corso": corso,
"puo_modificare": True,
"modulo": modulo,
"risultati": risultati,
}
return 'aspirante_corso_base_scheda_iscritti_aggiungi.html', contesto
def _invia_msg_singolo(self):
Messaggio.costruisci_e_invia(destinatari=[self.persone[0].persona],
oggetto="Email contatto",
modello="email.html",
utenza=True)
def recupera_password(request):
"""
Mostra semplicemente la pagina di recupero password.
"""
def _errore(contesto, modulo, livello=None, delegati=None, email=None, codice_fiscale=None):
contesto.update({
'modulo': ModuloRecuperaPassword(),
})
if livello:
contesto.update({'errore': livello})
if delegati:
contesto.update({'delegati': delegati})
if email:
contesto.update({'email': email})
if codice_fiscale:
contesto.update({'codice_fiscale': codice_fiscale})
return 'base_recupera_password.html', contesto
contesto = {}
if request.method == 'POST':
modulo = ModuloRecuperaPassword(request.POST)
if modulo.is_valid():
codice_fiscale = modulo.cleaned_data['codice_fiscale'].upper()
email = modulo.cleaned_data['email'].lower()
try:
per = Persona.objects.get(codice_fiscale=codice_fiscale)
delegati = per.deleghe_anagrafica()
if not hasattr(per, 'utenza'):
return _errore(contesto, modulo, 2, delegati, email=email, codice_fiscale=codice_fiscale)
if per.utenza.email != email:
return _errore(contesto, modulo, 3, delegati, email=email, codice_fiscale=codice_fiscale)
Messaggio.costruisci_e_invia(
destinatari=[per],
oggetto="Nuova password",
modello="email_recupero_password.html",
corpo={
"persona": per,
"uid": urlsafe_base64_encode(force_bytes(per.utenza.pk)),
"reset_pw_link": default_token_generator.make_token(per.utenza),
"scadenza_token": django_settings.PASSWORD_RESET_TIMEOUT_DAYS * 24
},
utenza=True
)
return messaggio_generico(request, None,
titolo="Controlla la tua casella e-mail",
messaggio="Ti abbiamo inviato le istruzioni per cambiare la "
"tua password tramite e-mail. Controlla la tua "
"casella al più presto. ",
torna_url="/utente/cambia-password/",
torna_titolo="Accedi e cambia la tua password")
except Persona.DoesNotExist:
return _errore(contesto, modulo, 1, email=email, codice_fiscale=codice_fiscale)
else:
modulo = ModuloRecuperaPassword()
contesto.update({
'modulo': modulo,
})
return 'base_recupera_password.html', contesto
def do(self):
Messaggio.smaltisci_coda(dimensione_massima=2200)
