gd/comunicazione/views.py

from django.shortcuts import render
from django.core.mail import send_mail
from django.core.mail import SafeMIMEText

from django.core.mail import EmailMultiAlternatives
from django.template.loader import get_template
from django.template import Context
from django.template import engines, TemplateSyntaxError

from uuid import uuid4,UUID
import json
import re

from django.db.models import Sum
#from .templatetags.commtags import *
from django.shortcuts import render

from .models import *
from .forms import *
import datetime
import sys

from config.views import *
from azienda.views import *

# se serve aiuta a capire quali sono i moduli caricati, ma meglio
# disattivarlo che sono una cifra lunghissima
#print(sys.modules)

def template_from_string(template_string, using=None):

  """
  Convert a string into a template object,
  using a given template engine or using the default backends 
  from settings.TEMPLATES if no engine was specified.
  This function is based on django.template.loader.get_template, 
  but uses Engine.from_string instead of Engine.get_template.
  """

  chain = []
  engine_list = engines.all() if using is None else [engines[using]]
  for engine in engine_list:
    try:
      return engine.from_string(template_string)
    except TemplateSyntaxError as e:
      chain.append(e)
  raise TemplateSyntaxError(template_string, chain=chain)

class ServizioMail:
  def __init__(self,debug=False):
    self._from_ = getConfig('DefaultEmail')
    self._to_ = []
    self._to = {}
    self.debug = debug
    self.soggetto = ""
    self.corpo = ""
    self.corpo_testo = ""
    self.corpo_html = ""
    self.data = dict()
    self.json = None

    if self.debug: print('attivato flag di debug')

  def set_mailfrom(self,mail_from):
    self._from_ = mail_from
    if self.debug: print('mail_from',self._from_)

  def set_listadestinatari(self,lista=[]):
    self._to_ = []
    self.add_listadestinatari(lista)
    if self.debug: print('lista destinatari',self._to_)

  def set_rcptto(self,lista=[]):
    self.set_listadestinatari(lista)

  def add_listadestinatari(self,mail=None):
    if self.debug: print('type mail:',type(mail))
    if mail:
      if type(mail) == list:
        for i in mail:
          self._to_.append(i)
        return
      self._to_.append((mail))
      if self.debug: print('lista destinatari',self._to_)

  def add_to(self,mail=None):
    self.add_listadestinatari(mail)

  def set_soggetto(self,soggetto=""):
    self.soggetto = soggetto
    if self.debug: 
      print("########")
      print('soggetto:',self.soggetto)
      print("########")

  def set_corpo(self,corpo="",html=False):
    self.corpo = corpo
    if self.debug:
      print("########")
      print('corpo:',self.corpo)
      print('set_corpo html:',html)
      print("########")

    self.html = html

  def set_data(self,data={}):
    self.data = data

    if not 'ora_data' in self.data:
      self.data['ora_data'] = datetime.datetime.now().strftime('%H:%M %d/%m/%Y')
    if not 'ora' in self.data:
      self.data['ora'] = datetime.datetime.now().strftime('%H:%m')
    if not 'data' in self.data:
      self.data['data'] = datetime.datetime.now().strftime('%d/%m/%Y')

    if self.debug: print('data',self.data)

  def set_json(self,data={}):
    self.json = json.dumps(data)
    if self.debug:  print('json:',self.json)

  def send(self):
    # normalizza i destinatari (uno solo, non ripetuti)
    if self.debug: print('spedisco a:',self._to_)

    for i in self._to_:
      self._to[i] = i
 
    self._to_complete = [ x for x in self._to.values() ]
    if self.debug: print("destinatari tutti:",self._to_complete)
 
    #rendering del soggetto
    soggetto = template_from_string(self.soggetto)
    soggetto_render = soggetto.render(self.data)
    print('soggetto_render:',soggetto_render)

    if self.debug: print("soggetto",soggetto)

    corpo = template_from_string(self.corpo)
    corpo_render = None
    try:
      corpo_render = corpo.render(self.data)
      print('corpo_render:',corpo_render)
    except TemplateSyntaxError as tse:
      print('Errore nel Template')
      print(tse)

    print('quanti sono',len(self._to_complete))
    for tt in self._to_complete:
      ttl = [tt,]
      print('ttl',ttl,)
      msg = None
      if self.debug: print('richiesta html::',self.html)
      if self.html: 
        msg=EmailMultiAlternatives(soggetto_render, corpo_render, self._from_, ttl)
        msg.attach_alternative(corpo_render, "text/html")
      else: msg=EmailMultiAlternatives(soggetto_render, corpo_render, self._from_, ttl)

      if self.json:
        msg.attach_alternative(self.json,'text/json')

      try:
        msg.send()
        print('messaggio inviato')
      except ConnectionRefusedError as cre:
        print('impossibile inviare mail',cre)

####################
# modulo comunicazioni
####################

def welcome(request):
  '''
  punto di ingresso.
  vengono mostrati tutti i modelli presenti presenti
  '''
  print('__name__',__name__,'welcome')
  data = dict()
  data['HeaderTitle'] = getConfig('HeaderTitle')

  if not 'AziendaId' in request.session:
    print('manca azienda')
    return HttpResponseRedirect(reverse("login:start"))
  else:
    data['AziendaId'] = request.session['AziendaId']
  print("Azienda rilevata",data['AziendaId'])

  if not 'AdminId' in request.session or 'UserId' in request.session:
    print("Non rilevo presensa UserId e AdminId in request.session")
    return HttpResponseRedirect(reverse("login:start"))
  else:
    data['AdminId'] = request.session['AdminId']

  if 'UserId' in request.session:
    data['UserId'] = request.session['UserId']

  sede = None
  SedeId = None

  if 'SedeId' in request.session:
    SedeId = request.session['SedeId']
    data['SedeId']=SedeId
    print('SedeId',SedeId)
    try:
      sede = Sede.objects.get(pk=SedeId)
    except Sede.DoesNotExist as dne:
      print("sede non esistente")
    data['sede'] = sede

  #filtro:
  # selezionare tutti gli utenti per AziendaId
  data['admin'] = Amministratore.objects.get(pk=data['AdminId'])
  data['azienda'] = Azienda.objects.get(pk=data['AziendaId'])
  print('SedeId',SedeId)
  if 'SedeId' in data and data['SedeId'] is not -1:
    data['sede'] = Sede.objects.get(pk=data['SedeId'])

  data['comunicazione'] = data['azienda'].comunicazione_set.all()
  print(data)

  if request.method == "POST":
    print('Richiesta effettuata')
    print(request.POST)

    if 'indietro' in request.POST:
      return HttpResponseRedirect(reverse("azienda:welcome"))

    if 'Nuovo' in request.POST:
      if 'ComId' in request.session:
        del request.session['ComId']
      return HttpResponseRedirect(reverse("comunicazione:edit"))

    if 'edit' in request.POST:
      request.session['ComId'] = request.POST.get('edit')
      print('ComId',request.session.get('ComId'))
      return HttpResponseRedirect(reverse("comunicazione:edit"))
    
  return render(request,'comunicazione.welcome.html',data)

def edit(request):
  print('__name__',__name__,'edit')
  data = dict()
  data['HeaderTitle'] = getConfig('HeaderTitle')

  if not 'AziendaId' in request.session:
    print('manca azienda')
    return HttpResponseRedirect(reverse("login:start"))

  data['AziendaId'] = request.session['AziendaId']
  print("Azienda rilevata",data['AziendaId'])

  data['azienda'] = Azienda.objects.get(pk=data['AziendaId'])

  if not 'AdminId' in request.session or 'UserId' in request.session:
    print("Non rilevo presensa UserId e AdminId in request.session")
    return HttpResponseRedirect(reverse("login:start"))

  data['AdminId'] = request.session['AdminId']
  print(data)

  if 'UserId' in request.session:
    data['UserId'] = request.session['UserId']

  comunicazione = Comunicazione()

  if 'ComId' in request.session:
    ComId = request.session.get('ComId')
    print('trovato ComId',ComId)
    comunicazione = Comunicazione.objects.get(pk=ComId)

  if request.method == 'POST':
    print('richiesta effettuata')
    if 'Ritorna' in request.POST:
      return HttpResponseRedirect(reverse("comunicazione:welcome"))

    fd = formComunicazione(request.POST)
    if fd.is_valid():
      print('comunicazione valido')
      comunicazione.mittente = fd.cleaned_data.get('mittente')
      comunicazione.soggetto = fd.cleaned_data.get('soggetto')
      comunicazione.corpo = fd.cleaned_data.get('corpo')
      comunicazione.azienda = data['azienda']
      comunicazione.save()
    else:
      print('comunicazione non valido')
    data['comunicazione'] = formComunicazione(request.POST)
  else:
    print('post non valido')
    tmp = dict()
    if len(data['azienda'].mail):
      print('azienda contiene email',data['azienda'].mail)
      tmp['mittente'] = data['azienda'].mail
    else:
      print('azienda non contiene email, prendo default',getConfig("DefaultEmail"))
      tmp['mittente'] = getConfig("DefaultEmail")

    tmp['soggetto'] = comunicazione.soggetto
    tmp['corpo'] = comunicazione.corpo
    data['comunicazione'] = formComunicazione(tmp)
    print(data) 
  return render(request,'comunicazione.edit.html',data)