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)