dashboard4/comunicazioni/views.py

from django.shortcuts import render
from django.core.mail import send_mail
from django.core.mail import SafeMIMEText
from configurazione.views import getConfigurazione
#from domini.views import Aggiorna_Dominio_Da_Causale

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 datetime import date,datetime
from uuid import uuid4,UUID
import json
from mqtt import views as m
from mqtt.views  import mqtt

from .models import *
import re
from django.db.models import Sum
from .templatetags.commtags import *


class ServizioMail:
  def __init__(self,debug=False):
    self._from_ = getConfigurazione('mail_from')
    self._to_ = []
    self._to = {}
    self.debug = debug
    self.soggetto = ""
    self.corpo_testo = ""
    self.corpo_html = ""
    self.set_data()
    self.json = None
  def template_from_string(self,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)

  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

  def set_oggetto(self,oggetto="",html=False):
    self.oggetto = oggetto
    if self.debug: print('set_oggetto html:',html)
    self.html = html

  def set_data(self,data={}):
    self.data = data
    #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('self._to_',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:",self._to_complete)
 
    #rendering del soggetto
    soggetto = self.template_from_string(self.soggetto)
    soggetto_render = soggetto.render(self.data)
    if self.debug: print("soggetto",soggetto)

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

    if oggetto_render:
      if self.debug: print('oggetto render',oggetto_render)

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

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

        msg.send()

  def send_mail(self):
    ''' 
    wrapper per aggiornare il nome della funzione che spedisce le mail
    '''
    print('Sto usando ancora send_mail')
    self.send()

def ControlloScadenzeRegistrar(request,demo=0,dominio=0):
  '''
  questa funzione effettua la scansione dei domini per verificare che non ci siano scadenze imminenti.
  il flag: demo se 1 non effettua l'invio

  dovrebbero venir inviate le seguenti mail:
  scadenza in arrivo: al destinatario
  lista prossime scadenze notificate all'amministrazione e al server

  demo = 1: nessuna operazione
  demo = 0: modalita' demo, non invia le email

  dominio = 0: operazioni normali
  dominio = id: predispone invio mail per il dominio <id>

  causale = 0: operazioni normali
  causale = id: invia email con la causale <id>

  '''

  if demo==1: demo=True
  else: demo=False

  listalog=[]

  listalog.append(("demo: ",demo))

  domini = None
  if dominio:
    # richiesta di singolo dominio.
    try:
      domini = Domini.objects.all().filter(id=dominio)
      listalog.append(("dominio richiesto:",domini[0].nome))
    except Domini.DoesNotExists as dne:
      print('dominio non trovato')
      domini = None

  if not domini:
    # estrae tutti i domini ordinati per scadenza contratto
    domini = Domini.objects.all().filter(enabled=True).order_by('date_expire_contract')


  listadomini=[]
  for d in domini:
    if d.registrar.registrazione: # la gestione del registrar e' nostra.
      #l'avviso viene avviato quando viene raggiunto il limite di registrazione indicato
      #smette di essere inviato dopo x giorni successivi alla scadenza
      print("sc contratto: ",d.nome)
      if int((d.date_expire_registrar - date.today()).days) < int(getConfigurazione('registrar-giorni-preavviso')) and  int((d.date_expire_registrar - date.today()).days) > -int(getConfigurazione('registrar-giorni-posticipati')):
        print("sc contratto: ",d.nome,d.date_expire_registrar,(d.date_expire_registrar - date.today()).days)
        # verifica eventuali causali gia'  registrate e presenti
        listadomini.append(d)
        listalog.append(('scadenza registrazione',d.nome,d.date_expire_registrar,(d.date_expire_registrar - date.today()).days))

  data={}
  data['demo']=demo
  data['domini']=listadomini
  print('domini',listadomini)

  for i in data['domini']:
    print(i.registrar.nome)

  # invia la mail
  for i in listadomini:
    sm = ServizioMail()
    print('dominio in corso di comunicazione',i.nome)
    # servono alcune cose:
    #1: template
    idtemplate = getConfigurazione('template-registrar-in-scadenza')

    template = Template.objects.get(pk=idtemplate)
    #2: lista dei destinatari a cui mandare l'avviso
    #3: lista da inviare in amministrazione
    print(template.nome)

    listadestinatari=[]
    listadestinatari.append(getConfigurazione('mail_notification'))

    dictdict={} 
    dictdict['domini'] = i.__dict__
    dictdict['dominio'] = i
    dictdict['registrar'] = i.registrar.nome
    dictdict['registrar.id'] = i.registrar
    dictdict['totaledomini'] = len(listadomini)

    print(dictdict)
    #nota ... la funzione dict, non mantiene gli agganci alle altre cartele tramite chiave
    
    sm.set_rcptto(listadestinatari)
    sm.set_soggetto(template.soggetto)
    sm.set_oggetto(template.oggetto)
    sm.set_data(dictdict)

    if not demo:  sm.send_mail()
      
      # ignoro la verifica dei contatti, tanto stiamo andando solo con la voce nel dominio

  return render(request,"Controllo.Scadenze.Registrar.html",data)

def ControlloScadenzeContratto(request,demo=0,dominio=None,causale=None):
  '''
  questa funzione effettua la scansione dei domini per verificare che non ci siano scadenze imminenti.
  il flag: demo se 1 non effettua l'invio

  dovrebbero venir inviate le seguenti mail:
  scadenza in arrivo: al destinatario
  lista prossime scadenze notificate all'amministrazione e al server

  demo = 1: nessuna operazione
  demo = 0: modalita' demo, non invia le email

  dominio = 0: operazioni normali
  dominio = id: predispone invio mail per il dominio <id>

  causale = 0: operazioni normali
  causale = id: invia email con la causale <id>

  '''

  if demo==1: demo=True
  else: demo=False

  listalog=[]

  listalog.append(("demo: ",demo))

  domini = None
  if dominio:
    # richiesta di singolo dominio.
    try:
      domini = Domini.objects.all().filter(id=dominio)
      listalog.append(("dominio richiesto:",domini[0].nome))
    except Domini.DoesNotExists as dne:
      print('dominio non trovato')
      domini = None

  if not domini:
    # estrae tutti i domini ordinati per scadenza contratto
    domini = Domini.objects.all().filter(enabled=True).order_by('nome')

  # estrae l'elenco delle causali
  causaleFlag=False
  causali = None

  if causale:
    print('causale richiesta:',causale)
    listalog.append(('causale richiesta:',causale))

    causali = Causale.objects.filter(id=causale)
  else:
     causali=Causale.objects.all()

  listadomini=[]

  for d in domini:
    for c in causali:
      if c.enabled: #se la causale e' abilitata
        if c.renew_request: #riguarda proprio la scadenza del contratto
          print("sc contratto: ",d.nome,c.nome,d.date_expire_contract,(d.date_expire_contract - date.today()).days,c.valore)
          listalog.append(("scadenza: ",d.nome,c.nome,d.date_expire_contract,(d.date_expire_contract - date.today()).days,c.valore))
          if int((d.date_expire_contract - date.today()).days) == int(c.valore): #raggiunta di avviso raggiunta
            print("sc contratto trovata: ",d.nome,c.nome,d.date_expire_contract,(d.date_expire_contract - date.today()).days,c.valore)
            listalog.append(("scadenza trovata: ",d.nome,c.nome,d.date_expire_contract,(d.date_expire_contract - date.today()).days,c.valore))
            # verifica eventuali causali gia'  registrate e presenti
            try:
              print('ordine:',c.id,c.nome,c.ordine,"ultima causale",d.last_causale.id,d.last_causale.nome,d.last_causale.ordine)
              listalog.append(("Causale trovata",c.id,c.nome,c.ordine,"ultima causale",d.last_causale.id,d.last_causale.nome,d.last_causale.ordine))
            except Domini.last_causale.RelatedObjectDoesNotExist as rodne:
              print("errore:",rodne)
              listalog.append(("Errore:",rodne))
              d.last_causale_id = getConfigurazione('causale:default')
              print('d.last_causale_id',d.last_causale_id,d.last_causale.nome)
              listalog.append(('d.last_causale_id',d.last_causale_id,d.last_causale.nome))
              d.save()

            try:
              # se la posizione da richiedere e' piu' alta di quella precedentemente inviata:
              # correzione del 06/09/21a
              print("ordine causale trovata",c.ordine,"ultima causale assegnata",d.last_causale.ordine)

              if c.ordine > d.last_causale.ordine:
                print('ordine confermato: ',c.ordine,d.last_causale.ordine,d.last_causale.nome)
                listalog.append(('ordine confermato: ',c.ordine,d.last_causale.ordine,d.last_causale.nome))
                d.last_causale = c
                listadomini.append(d)
              else:
                print('ordine NON confermato: ',c.ordine,d.last_causale.ordine,d.last_causale.nome)
                listalog.append(('ordine NON confermato: ',c.ordine,d.last_causale.ordine,d.last_causale.nome))
            except Causale.DoesNotExist as dne:
              print('ordine forzato: ',c.ordine,d.last_causale.ordine)
              listalog.append(('ordine forzato: ',c.ordine,d.last_causale.ordine))
              d.last_causale = c
              listadomini.append(d) 

            if not d.renew_code:
              d.renew_code = uuid4()

            if d.rinnovo_automatico:
                Aggiorna_Dominio_Da_Causale(d,getConfigurazione('Rinnovo:Automatico'))

            if not demo: 
              d.save()
            else: 
              print("Non salvo - modalita' demo")
              listalog.append(("Non salvo - modalità demo"))


  data={}

  #if demo:
  #  data['data']=True

  data['demo']=demo
  data['totaledomini'] = len(domini)

  data['domini']=listadomini
  print('domini',listadomini,len(listadomini))
  listalog.append(('domini',listadomini,len(listadomini)))

  # invia la mail ai destinatari
  for i in listadomini:
    sm = ServizioMail()
    print('dominio in corso di comunicazione',i.nome)
    # servono alcune cose:
    #1: template
    template = i.last_causale.template
    #2: lista dei destinatari a cui mandare l'avviso
    #3: lista da inviare in amministrazione
    print(template.nome)

    listadestinatari=[]
    print(i.contatti)
    PresenteContattoDestinatari=False

    if len(i.contatti)>0:
      PresenteContattoDestinatari=True
      tmpdestinatari =  re.split(',| ',i.contatti)
      for td in tmpdestinatari:
        # dovremmo validare ogni elemento
        listadestinatari.append(td)
        print("mail to  ",td)
        listalog.append(("mail to  ",td))
    listadestinatari.append(i.last_causale.from_email)

    dictdict={} 
    dictdict['dominio'] = i.__dict__
    dictdict['causale'] = i.last_causale.__dict__
    dictdict['totaledomini'] = len(listadomini)

    if not demo: dictdict['uuid'] = i.renew_code
    else: dictdict['uuid'] = uuid4()
    if not demo: dictdict['renew_code'] = i.renew_code
    else: dictdict['renew_code'] = uuid4()

    print('!!presenza flag PresenteContattoDestinatari:',PresenteContattoDestinatari)
    listalog.append(('!!presenza flag PresenteContattoDestinatari:',PresenteContattoDestinatari))

    if PresenteContattoDestinatari: 
      dictdict['PresenteContattoDestinatari']=True

    sm.set_rcptto(listadestinatari)
    sm.set_soggetto(template.soggetto)
    sm.set_oggetto(template.oggetto)
    sm.set_data(dictdict)
    if not demo:
      sm.send()

    #************************************
    # invia la mail alla contabilita'
    lista_destinatari = []
    if i.last_causale.send_email_account:
      if len(i.last_causale.to_account):
        tmplista =  re.split(',| ',i.last_causale.to_account)
        for t in tmplista:
          listadestinatari.append(t)
      accountdft = getConfigurazione('mail:accounting')
      if accountdft and len(accountdft):
        accountdft = re.split(',| ',accountdft)
        for t in accountdft:
          listadestinatari.append(t)
 
      co = getConfigurazione("mail:accounting:domain:expire")
      template = None
      flag = False
      try:
        template = Template.objects.get(pk=co) 
        flag = True
      except Template.DoesNotExists as dne:
        print('template errato',co)
        listalog.append(('template errato',co))

      sm.set_rcptto(listadestinatari)
      sm.set_soggetto(template.soggetto)
      sm.set_oggetto(template.oggetto)
      sm.set_data(dictdict)
      if flag and not demo:
        sm.send()
      else:
        print("Modalita' Demo, non spedisco")
        listalog.append("Modalita' demo, nessuna spedizione")

      # ignoro la verifica dei contatti, tanto stiamo andando solo con la voce nel dominio
  
  if not demo:
    data['listalog'] = listalog

  return render(request,"Controllo.Scadenze.Contratto.html",data)

def ControlloScadenzaDefinitiva(request,demo=0,dominio=None):
  '''
  questa funzione effettua la scansione dei domini per verificare che non ci siano scadenze imminenti.
  il flag: demo se 1 non effettua l'invio

  dovrebbero venir inviate le seguenti mail:
  scadenza in arrivo: al destinatario
  lista prossime scadenze notificate all'amministrazione e al server

  demo = 1: nessuna operazione
  demo = 0: modalita' demo, non invia le email

  dominio = 0: operazioni normali
  dominio = id: predispone invio mail per il dominio <id>

  causale = 0: operazioni normali
  causale = id: invia email con la causale <id>

  '''

  domini = Domini.objects.all().filter(enabled=True).order_by('date_expire_contract')

  if dominio:
    print('dominio richiesto:',dominio)
    domini = Domini.objects.filter(id=dominio).filter(enabled=True).order_by('date_expire_contract')

  print('dominio trovato:',domini)

  causali = Causale.objects.get(pk=getConfigurazione('dominio-scaduto'))
  print('causale trovata:',causali)

  listadomini=[]
  for d in domini:
    if causali.enabled: #se la causale e' abilitata
      if causali.domain_expired: #riguarda proprio la scadenza del contratt
        print('scaduto',d.nome,int((d.date_expire_contract - date.today()).days),int(causali.valore))

        # se oggi  - data_scadenza (25-20> 3...) allora e' scaduto.
        if int((date.today() - d.date_expire_contract).days) > int(causali.valore): #raggiunta di avviso raggiunta
          print("scadenze raggiunte: ",d.nome,causali.nome,d.date_expire_contract,(d.date_expire_contract - date.today()).days,causali.valore)
          # verifica eventuali causali gia'  registrate e presenti
          d.last_causale = causali
          print('assegnata causale:',d.last_causale.nome)
          d.enabled = False
          d.save()
          listadomini.append(d)

  data={}
  data['domini']=listadomini
  print('domini',listadomini)


  # invia la mail
  sm = ServizioMail()

  for i in listadomini:
    print(i.nome)
    # servono alcune cose:
    #1: template
    template = causali.template
    #2: lista dei destinatari a cui mandare l'avviso
    #3: lista da inviare in amministrazione
    print(template.nome)

    listadestinatari=[]
    print(i.contatti)
    PresenteContattoDestinatari=False

    #if len(i.contatti)>0:
    #  PresenteContattoDestinatari=True
    #  tmpdestinatari =  re.split(',| ',i.contatti)
    #  for d in tmpdestinatari:
    #    # dovremmo validare ogni elemento
    #    listadestinatari.append(d)
    #    print("mail to  ",d)

    listadestinatari.append(causali.from_email)

    dictdict={} 
    dictdict['dominio'] = i.__dict__
    dictdict['causale'] = causali.__dict__
    dictdict['data'] = date.today()

    print('!!presenza flag PresenteContattoDestinatari:',PresenteContattoDestinatari)

    if PresenteContattoDestinatari: dictdict['PresenteContattoDestinatari']=True

    
    sm.set_rcptto(listadestinatari)
    sm.set_soggetto(template.soggetto)
    sm.set_oggetto(template.oggetto)
    sm.set_data(dictdict)

    if demo==1:  
      sm.mail()
  return render(request,"Controllo.Scadenze.html",data)


def ControlloScadenzaVicina(request,demo=0,dominio=None):
  '''
  questa funzione ha il solo scopo di comunicare periodicamente le scadenze vicine (il range puo' essere desunto dalla configurazione)
  il flag: demo se 1 non effettua l'invio
  '''
  if demo==1: demo=True
  else: demo=False

  domini_scadenza_contract = Domini.objects.all().filter(enabled=True).order_by('date_expire_contract')
  domini_scadenza_registrar = Domini.objects.all().filter(enabled=True).order_by('date_expire_registrar')

  if dominio:
    print('dominio richiesto:',dominio)
    domini = Domini.objects.filter(id=dominio).filter(enabled=True).order_by('date_expire_contract')
    domini_scadenza_contract = Domini.objects.filter(id=dominio).filter(enabled=True).order_by('date_expire_contract')
    domini_scadenza_registrar = Domini.objects.filter(id=dominio).filter(enabled=True).order_by('date_expire_registrar')

  print('domini la cui registrazione e in scadenza:',domini_scadenza_registrar)
  print('domini il cui contratto e in scadenza:    ',domini_scadenza_contract)

  limiteAvviso = int(getConfigurazione("scadenza:limite:avviso"))

  listascadenzaregistrar = []
  listascadenzacontract = []

  for d in domini_scadenza_registrar:
    if int((d.date_expire_registrar - date.today()).days) < limiteAvviso:
        print(int((d.date_expire_registrar - date.today()).days))
        listascadenzaregistrar.append(d)
  for d in domini_scadenza_contract:
    if int((d.date_expire_contract - date.today()).days) < limiteAvviso:
        print(int((d.date_expire_contract - date.today()).days))
        listascadenzacontract.append(d)

  data={}
  data['limiteAvviso'] = limiteAvviso
  data['listascadenzaregistrar'] = listascadenzaregistrar
  data['listascadenzacontract'] = listascadenzacontract

  # invia la mail
  sm = ServizioMail()
  print(dir(sm))

  template  = Template.objects.get(pk=getConfigurazione("scadenza:limite:template"))

  listadestinatari = []
  listadestinatari.append(getConfigurazione("mail:notifica"))

  dictdict={} 
  dictdict['listascadenzaregistrar'] = listascadenzaregistrar
  dictdict['listascadenzacontract'] = listascadenzacontract
  dictdict['data'] = date.today()
  dictdict['limiteavviso'] = limiteAvviso

  print(template.soggetto)
  print(template.oggetto)

  sm.set_rcptto(listadestinatari)
  sm.set_soggetto(template.soggetto)
  sm.set_oggetto(template.oggetto)
  sm.set_data(dictdict)

  if not demo:  
    sm.send()

  return render(request,"Controllo.Vicino.html",data)


  
def ConfermaScadenza(request,uuid=None):
  # primo step, verifichiamo uuid

  print("uuid =",uuid)
  print(type(uuid))

  dom = Domini.objects.all().filter(enabled=True)
  for d in dom:
    print("compare:",uuid,d.renew_code)

    if d.renew_code and uuid == UUID(d.renew_code):
      print(d.nome,uuid)
      '''
      passaggi da fare:
      chiedere conferma
      dare conferma al cliente della registrazione
      avvisare l'amministrazione
      aggiornare il db
      '''
      value = {}
      value['dominio'] = d

      if request.method == 'POST':
        invia_risposta = False
        causale = None

        if "Renew" in request.POST:
          rinnova = request.POST.get('Renew')
          print('dominio da rinnovare',rinnova)
          d = Domini.objects.get(pk=rinnova)
          if d:
            # carica causale di autorizzato al rinnovo
            causale  = Causale.objects.get(pk=getConfigurazione("causale:rinnovo_autorizzato"))
            print("causale: ",causale.nome)

            d.last_causale = causale
            d.renew_code = None
            d.save()
            invia_risposta = True
            value['risposta'] = True

        if "Loose" in request.POST:
          perdi = request.POST.get('Loose')
          print('dominio da NON rinnovare',perdi)
          d = Domini.objects.get(pk=perdi)
          if d:
            # carica causale di autorizzato al rinnovo
            causale  = Causale.objects.get(pk=getConfigurazione("causale:rinnovo_non_autorizzato"))
            print("causale: ",causale.nome)

            d.last_causale = causale
            d.renew_code = None
            d.save()
            invia_risposta = True
            value['risposta']=False

        if invia_risposta:
          sm = ServizioMail()

          listadestinatari=[]
          print(d.contatti)
          if len(d.contatti)>0:
            tmpdestinatari =  re.split(',| ',d.contatti)
            for t in tmpdestinatari:
              # dovremmo validare ogni elemento
              listadestinatari.append(t)
              print("email to: ",t)
              listadestinatari.append(causale.from_email)
          dictdict={} 
          dictdict['dominio'] = d.__dict__
          dictdict['causale'] = causale.__dict__
          dictdict['data'] = date.today()

          sm.set_rcptto(listadestinatari)
          sm.set_soggetto(causale.template.soggetto)
          sm.set_oggetto(causale.template.oggetto)
          sm.set_data(dictdict)
          sm.send()

          if causale.send_email_account:
            ac = getConfigurazione("mail:accounting")
            sm.set_rcptto([ac,])
            te = getConfigurazione("mail:accounting_template")
            template = Template.objects.get(pk=te)
            sm.set_soggetto(template.soggetto)
            sm.set_oggetto(template.oggetto)
            sm.set_data(dictdict)
            sm.send()

        value['causale'] = causale
        print("value:",value)

        return render(request,"conferma.scelta.rinnovo.html",value)

      return render(request,'richiesta.conferma.html',value)

  return render(request,"notfound.html")

def ConfermaScadenza(request,uuid=None):
  # primo step, verifichiamo uuid

  print("uuid =",uuid)
  print(type(uuid))

  dom = Domini.objects.all().filter(enabled=True)
  for d in dom:
    print("compare:",uuid,d.renew_code)

    if d.renew_code and uuid == UUID(d.renew_code):
      print(d.nome,uuid)
      '''
      passaggi da fare:
      chiedere conferma
      dare conferma al cliente della registrazione
      avvisare l'amministrazione
      aggiornare il db
      '''
      value = {}
      value['dominio'] = d

      if request.method == 'POST':
        invia_risposta = False
        causale = None

        if "Renew" in request.POST:
          rinnova = request.POST.get('Renew')
          print('dominio da rinnovare',rinnova)
          d = Domini.objects.get(pk=rinnova)
          if d:
            # carica causale di autorizzato al rinnovo
            causale  = Causale.objects.get(pk=getConfigurazione("causale:rinnovo_autorizzato"))
            print("causale: ",causale.nome)

            d.last_causale = causale
            d.renew_code = None
            d.save()
            invia_risposta = True
            value['risposta'] = True

        if "Loose" in request.POST:
          perdi = request.POST.get('Loose')
          print('dominio da NON rinnovare',perdi)
          d = Domini.objects.get(pk=perdi)
          if d:
            # carica causale di autorizzato al rinnovo
            causale  = Causale.objects.get(pk=getConfigurazione("causale:rinnovo_non_autorizzato"))
            print("causale: ",causale.nome)

            d.last_causale = causale
            d.renew_code = None
            d.save()
            invia_risposta = True
            value['risposta']=False

        if invia_risposta:
          sm = ServizioMail()

          listadestinatari=[]
          print(d.contatti)
          if len(d.contatti)>0:
            tmpdestinatari =  re.split(',| ',d.contatti)
            for t in tmpdestinatari:
              # dovremmo validare ogni elemento
              listadestinatari.append(t)
              print("email to: ",t)
              listadestinatari.append(causale.from_email)
          dictdict={} 
          dictdict['dominio'] = d.__dict__
          dictdict['causale'] = causale.__dict__
          dictdict['data'] = date.today()

          sm.set_rcptto(listadestinatari)
          sm.set_soggetto(causale.template.soggetto)
          sm.set_oggetto(causale.template.oggetto)
          sm.set_data(dictdict)
          sm.send()

          if causale.send_email_account:
            ac = getConfigurazione("mail:accounting")
            sm.set_rcptto([ac,])
            te = getConfigurazione("mail:accounting_template")
            template = Template.objects.get(pk=te)
            sm.set_soggetto(template.soggetto)
            sm.set_oggetto(template.oggetto)
            sm.set_data(dictdict)
            sm.send()

        value['causale'] = causale
        print("value:",value)

        return render(request,"conferma.scelta.rinnovo.html",value)

      return render(request,'richiesta.conferma.html',value)

  return render(request,"notfound.html")
       
# misurazioni e occupazioni

def CheckQuotaMail(request,dominio=None,mail=None,quota=None):
  value = {}

  if dominio:
    d = Domini.objecs.filter(nome=dominio.lower())

    if len(d) == 1:
      d = d[0]

      if mail:
        print(mail)
        u = User.objects.filter(nome=d).filter(mail=mail.lower(),tobedeleted=False)
    
        if len(u) == 1:
          print('len',len(u))
          u = u[0]
          print('Trovato',d.nome,u.id,int(quota))
          u.mail_quota = int(quota)
          u.save()

      result = d.user_set.all().aggregate(Sum('mail_quota'))
      if not d.mail_quota: 
        d.mail_quota = 0

      d.last_mail_quota = d.mail_quota
      d.date_mail_quota = date.today()
      d.last_mail_check = True

      if result['mail_quota__sum']:
        d.mail_quota = result['mail_quota__sum']
      #else: 
      #  d.mail_quota = 0

      d.last_mail_quota_check = True
      print('Quota mail',d.mail_quota)
      d.save()

  return render(request,'Controllo.Quota.html',value)

      
def CheckQuotaHttp(request,dominio=None,quota=None):
  value = {}

  if dominio:
    d = Domini.objects.filter(nome=dominio.lower(),tobedeleted=False)
    print(d)
    if len(d) == 1:
      d = d[0]
      print('dominio Trovato',d.nome,int(quota))
      d.http_quota = int(quota)
      d.save()

      # caselle ftp/httpd
      result = d.ftpuser_set.filter(ftpgroup__section='http').aggregate(Sum('quota'))
      d.last_http_quota = d.http_quota
      d.date_http_quota = date.today()

      if result['quota__sum']:
        d.http_quota = result['quota__sum']
      #else: 
      #  d.http_quota = 0

      if not d.http_quota: 
        d.http_quota = 0

      d.last_http_quota_check = True
      print('Quota http',d.http_quota)
      d.save()

  return render(request,'Controllo.Quota.html',value)

def CheckQuotaSql(request,database=None,quota=None):
  value = {}
  dominio_di_riferimento = None

  if database:
    d = SqlDatabase.objects.filter(nome=database.lower(),tobedeleted=False)
    print(d)
    if len(d) == 1:
      d = d[0]
      dominio_di_riferimento = d.dominio_id

      print('database Trovato',d.nome,int(quota))
      d.quota = int(quota)
      d.save()
      # sql
      #registriamo i dati nel dominio

      dd = d.dominio

      result = dd.sqldatabase_set.all().aggregate(Sum('quota'))
      dd.last_sql_quota = dd.sql_quota
      dd.date_sql_quota = date.today()

      if result['quota__sum']:
        dd.sql_quota = result['quota__sum']
      #else:
      #  dd.sql_quota = 0

      if not dd.sql_quota: 
        dd.sql_quota = 0

      dd.last_sql_quota_check = True
      dd.save()
      print('Quota sql ',dd.sql_quota)

  return render(request,'Controllo.Quota.html',value)

def CheckQuotaFtp(request,dominio=None,ftp=None,quota=None):
  value = {}
  dominio_di_riferimento = None

  if dominio:
    d = Domini.objects.filter(domain=dominio.lower(),tobedeleted=False)

    if len(d) == 1:
      d = d[0]
      dominio_di_riferimento = d.id
      print('dominio Trovato',d.domain)

      f = FTPUser.objects.filter(dominio=d.id,utente=ftp,tobedeleted=False)
      if len(f) == 1:
        f = f[0]
        f.ftp_quota = int(quota)
        f.save()
      result = d.ftpuser_set.filter().filter(ftpgroup__section='ftp').aggregate(Sum('ftp_quota'))
      d.last_ftp_quota = d.ftp_quota
      d.date_ftp_quota = date.today()

      if result['quota__sum']:
        d.ftp_quota = result['quota__sum']
      else: 
        d.ftp_quota = 0
      if not d.ftp_quota: 
        d.ftp_quota = 0
      d.last_ftp_quota_check = True
      d.save()
      print('Quota ftp ',d.ftp_quota)

  return render(request,'Controllo.Quota.html',value)

def ComunicazioneControlloQuota(request,demo=False,dominio=0):
  value = {}

  try:
    dominio = int(dominio)
    print('dominio indicato:',dominio)
  except ValueError as ve:
    print("dominio non valido:", dominio)
    print(ve)
    dominio = None

  lista_quota = {}
  d = Domini.objects.filter(pk=dominio)
  print("dominio trovato",d)

  if not d:
    d = Domini.objects.all().order_by('nome')
    print('lista domini',d)

  value['domini'] = d

  sm = ServizioMail()
  quota_notifica = getConfigurazione('quota:notifica')
  quota_notifica = re.findall("[ |,]",quota_notifica)
  print(quota_notifica)
  sm.set_listadestinatari(quota_notifica)

  template = Template.objects.get(pk=getConfigurazione('quota:template:notifica'))
  sm.set_soggetto(template.soggetto)
  print('richiesta html',template.html)
  sm.set_oggetto(template.oggetto,template.html)

  template_dati = {}
  template_dati['domini'] = d
  sm.set_data(template_dati)
  if not demo:
    print('richiesta demo:1')
    sm.send()

  quota_accounting = getConfigurazione('quota:notifica:accounting')
  quota_accounting = re.split(',| ',quota_accounting)
  sm.set_listadestinatari(quota_accounting)
  print('Quota_Account',quota_accounting)

  if not demo:
    print('richiesta demo:1')
    sm.send()
  value['demo'] = demo

  return render(request,'Controllo.Quota.html',value)

def ComunicazioneFinale(request,mailfinale=None):
  #invia una comunicazione a una specifica email
  '''
  deve inviare specificatamente:
    elenco email e occupazione finale mail
    elenco ftp e occupazione finale ftp
    elenco sql e occupazione finale sql
    elenco nextcloud e occupazione nextcloud
    occupazione totale
    differenze rispetto al passato
  '''

def OccupazioneControlloQuota(request,dominio=None):
  value = dict()
  c = m.start()

  domini = None

  dtask = datetime.now().timestamp()
  dc = 0

  if not dominio:
    domini = Domini.objects.all().filter(tobedeleted=False)
  else:
    print('dominio richiesto:',dominio)

    domini = Domini.objects.filter(pk=dominio)

  mq = mqtt()
  mq.build('topic','messaggio/quota')
  mq.build('richiesta','quota')
  mq.build('stampa',True)

  tmp = dict()
  tmp['dtask'] = dtask
  tmpdom = list()
  for d in domini:
    tmpdom.append({'id':d.id,'nome':d.nome})
  tmp['domini'] = tmpdom
  mq.build('data',tmp)
  mq.pubblica()
  tmp=None
  tmpdom=None

  listadomini = list() #contiene la lista dei domini da pubblicare

  #cazz - inizio operazioni
  for dominio in domini:
    listadomini.append(dominio)
    ftpdict = dict()
    ftpdict['op'] = 'Quota'
    ftpdict['id'] = dominio.id
    ftpdict['do'] = dominio.nome
    ftpdict['stampa'] = True

    # ottiene la lista degli spazio assegnati via ftp
    listaftp = dominio.ftpuser_set.all()
    print('Numero di elementi',len(listaftp))

    for lf in listaftp:
      # le sezioni si possono dividere in tre, due accorpabili
      # http e stor, enb (enb: enbass, da verificare) 01.12.22
      ftpdict['ftpid'] = lf.id
      ftpdict['ftpuser']= lf.utente
      dc = dc +1
      ftpdict['dc'] = dc
      ftpdict['dtask'] = dtask
      ftpdict['stampa']=True
      print('ftp id',lf.id,'counter',dc,'dtask',dtask)
      try:
        #print('ftpgroup',lf.ftpgroup.id)
        #construisce la stringa che deve essere inviata via mqtt
        ftpdict['ftphome'] = lf.ftpgroup.directory % {'site':dominio.nome,'ftp':lf.utente}
        ftpdict['ftpclass'] = lf.ftpgroup.section
      except FTPGroup.DoesNotExist as dne:
        print('Errore: dato non valido: ',ftpdict)

      print('stringa da inviare per ftp: ',ftpdict)
      try:
        print('richiesta su server specifico',lf.id)
        m.publish(c,"Richiesta/Quota/Http/{}".format(lf.ftpgroup.server),json.dumps(ftpdict))
      except FTPGroup.DoesNotExist as dne:
        print('richiesta diretta a tutti i server',lf.id)
        m.publish(c,"Richiesta/Quota/Http",json.dumps(ftpdict))

    #ottiene la lista degli utenti mail (locali)
    listamail = dominio.user_set.all()
    print('Numero di elementi',len(listamail))

    for lm in listamail:
      maildict = dict()
      maildict['op'] = 'Quota'
      maildict['id'] = dominio.id
      maildict['do'] = dominio.nome
      maildict['mailid'] = lm.id
      maildict['mailuser'] = lm.mail
      maildict['mailserver'] = dominio.mail_server.fisico
      maildict['stampa'] = True
      dc = dc +1
      maildict['dc'] = dc
      maildict['dtask'] = dtask
      try:
        maildict['mailserver'] = lm.mail_server.fisico
      except MailServer.DoesNotExist as dne:
        print('mail server non indicato nel record mail')
   
      print('stringa da inviare per la mail: ',maildict)

      try:
        print('richiesta su server specifico',lm.id)
        m.publish(c,"Richiesta/Quota/Mail/{}".format(dominio.mail_server.nome),json.dumps(maildict))
      except MailServer.DoesNotExist as dne:
        print('richiesta diretta a tutti i server',lf.id)
        m.publish(c,"Richiesta/Quota/Mail",json.dumps(maildict))
      print("json json",json.dumps(maildict))
       
      u = User.objects.get(pk=lm.id)
      u.mail_quota=0
      u.save()

    dominio.mail_quota=0
    dominio.save()
    
  value['domini'] = listadomini
  print('value',value)

  return render(request,'Controllo.Quota.html',value)