dashboard5/domini/views.py

from django.shortcuts import render
from django.http import HttpResponseRedirect,HttpResponseNotFound,JsonResponse
from django.urls import reverse
from django import template
import time

from datetime import datetime,timedelta
from uuid import uuid4,UUID

import re

# Create your views here.
from .models import *
from .forms import *
from sicurezza.views import *
from comunicazioni.views import *

def Aggiorna_Dominio_Da_Causale(d,c,sm=None):


  dominio = d
  print('dominio nome',dominio.nome)
  causale = c
  print('causale nome',causale.nome)

  if causale.date_expire_contract:
    print("Stato contratto prima:",dominio.id,dominio.date_expire_contract)
    dominio.date_expire_contract = dominio.date_expire_contract + timedelta(int(causale.valore))
    print("Stato contratto dopo:",dominio.id,dominio.date_expire_contract)

  if causale.date_expire_registrar:
    print("Stato registrar prima:",dominio.id,dominio.date_expire_registrar)
    dominio.date_expire_registrar = dominio.date_expire_registrar+timedelta(int(causale.valore))
    print("Stato registrar dopo:",dominio.id,dominio.date_expire_registrar)
 
  if causale.renew_code:
    dominio.renew_code = uuid4()
    print('dominio.renew_code',dominio.renew_code)

  if causale.domain_closed:
    dominio.enabled = False

  if causale.domain_suspended:
    dominio.enabled = False

  if causale.domain_enabled:
    dominio.enabled = True
    dominio.tobedeleted = False

  if causale.domain_tobedeleted:
    print('richiesta cancellazione')
    dominio.enabled = False
    dominio.tobedeled = True

  if causale.domain_expired:
    dominio.enabled = False

  dominio.last_causale = causale
  dominio.save()

  if not sm:
    return

  #imposta i destinatari
  listadestinatari=[]
  PresenteContattoDestinatari=False

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

  if causale.send_email_admin and len(causale.to_admin):
    tmplista = re.split(',| ',causale.to_admin)
    for i in tmplista:
      listadestinatari.append(i)

  if causale.send_email_account:
    if len(causale.to_account):
      tmplista =  re.split(',| ',causale.to_account)
      for i in tmplista:
        listadestinatari.append(i)
    else:
      accountdft = getConfigurazione('mail:accounting')
      if accountdft and len(accountdft):
        accountdft = re.split(',| ',accountdft)
        for i in accountdft:
          listadestinatari.append(i)

  templatetrovato=False
  try:
    template = causale.template
    templatetrovato=True
  except Template.DoesNotExist as dne:
    print("Template inesistente")
    print(dne)

  if templatetrovato:
    print('template valido')
    data = {}
    data['dominio'] = dominio.__dict__
    print("dominio.renew_code",dominio.__dict__['renew_code'])
    if PresenteContattoDestinatari: data['PresenteContattoDestinatari']=True

    print("spedisco mail a",listadestinatari)
    sm.add_listadestinatari(listadestinatari)
    sm.set_oggetto(template.oggetto)
    sm.set_soggetto(template.soggetto)
    sm.set_data(data)
    sm.send()
    sm = None
  else:
    print("Template Non valido.... non invio comunicazioni")
  return 

def AggiornaStoriaCausali(dominio=None,utente=None,causale=None,nota=None):
  print("Salvo dati Storia")
  storia = Storia()
  storia.dominio_id = dominio.id
  storia.utente_id = utente.id
  storia.causale_id = causale.id
  print(int(time.time()))
  storia.data = int(time.time())
  storia.nota = nota
  storia.save()

def UltimaStoriaCausali(dominio=None,count=1):

  if count == 1:
    print("Ritorna l'utlimo record della causale per il dominio:",dominio.id)
    tmp = Storia.objects.filter(dominio=dominio).latest('data')
    return tmp
  else:
    print("ritorna gli ultimi reecord memorizzati per il dominio:",count,": ",dominio.id)
    tmp = Storia.objects.filter(dominio=dominio)[:5]
    print(len(tmp))
    return tmp

def DomainList(request):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  user2edit = session['_user2edit_']
  domain2edit = session['_domain2edit_']
  domain_order = session['_domain_order']
  print('domain_order',domain_order)

  request.session['_from_']="Utenti:UserList"

  #print(next)
  if not user2edit:
    user2edit = userauth

  try:
    utenteautorizzato = User.objects.get(pk=userauth)
  except User.DoesNotExist as dne:
    return  HttpResponseRedirect(reverse('Login:login',args={}))

  if not domain2edit:
    domain2edit = utenteautorizzato.domain.id

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['user'] = None
  value['navbar'] = True

  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel_id)
  securityrow = getSecurityRow(utenteautorizzato.securitylevel_id)
  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)

  Nascondi_Scaduti = getConfigurazione("NascondiScaduti")
  print("Nascondi_Scaduti",Nascondi_Scaduti)

  dominiolist = Domini.objects.all().order_by('nome')

  if Nascondi_Scaduti== "1":
    #dominiolist = dominiolist.filter(enabled=1)
    value['Nascondi_Scaduti'] = "Visualizza"
  else:
    value['Nascondi_Scaduti'] = "Nascondi"

  value['domainlist'] = dominiolist
  value['causali'] = Causale.objects.all().filter(enabled=True).order_by('nome')

  if request.method=="POST":
    print('request ok',request.POST)

    #memorizza la posizione.... cosi' l'arnese sa dove tornare
    request.session['_position_'] = 'DomainList'

    if 'Nuovo Dominio' in request.POST:
      request.session['_domain2edit_'] = -1
      return HttpResponseRedirect(reverse('Domini:DomainEdit',args={}))

    if 'Ritorno' in request.POST:
      return HttpResponseRedirect(reverse('Login:welcome',args={}))

    if 'Nascondi_Scaduti' in request.POST:
      print("Il tasto Nascondi_Scaduti èstato preumto")

      if Nascondi_Scaduti == "0":
        value['Nascondi_Scaduti'] = "Nascondi"
        setConfigurazione("NascondiScaduti","1")
      else:
        value['Nascondi_Scaduti'] = "Visualizza"
        setConfigurazione("NascondiScaduti","0")

    if 'Ordine_Alfabetico' in request.POST:
      request.session['_domain_order']='oa'
      value['domainlist'] = Domini.objects.all().order_by('nome')
      if Nascondi_Scaduti == "1" : value['domainlist'] = value['domainlist'].filter(enabled=1)
      return render(request,"gestione.domain.list.html",value)

    if 'Ordine_Scadenza_Contratto' in request.POST:
      request.session['_domain_order']='oc'
      value['domainlist'] = Domini.objects.all().order_by('date_expire_contract')
      if Nascondi_Scaduti == "1": value['domainlist'] = value['domainlist'].filter(enabled=1)
      return render(request,"gestione.domain.list.html",value)

    if 'Ordine_Scadenza_Registrar' in request.POST:
      request.session['_domain_order'] = 'or'
      value['domainlist'] = Domini.objects.all().order_by('date_expire_registrar')
      if Nascondi_Scaduti == "1": value['domainlist'] = value['domainlist'].filter(enabled=1)
      return render(request,"gestione.domain.list.html",value)

    if "Servizi" in request.POST:
      print('id da editare',request.POST['Servizi'])
      request.session['_domain2edit_'] = request.POST['Servizi']
      print("request.session['_domain2edit_']",request.session['_domain2edit_'])
      return HttpResponseRedirect(reverse('Domini:DomainServizi',args={}))

    if "Editing" in request.POST:
      print("Editing")
      print('id da editare',request.POST['Editing'])
      request.session['_domain2edit_'] = request.POST['Editing']
      return HttpResponseRedirect(reverse('Domini:DomainEdit',args={}))

    if "Info" in request.POST:
      print('id da mostrare',request.POST['Info'])
      request.session['_domain2edit_'] = request.POST['Info']
      return HttpResponseRedirect(reverse('Domini:DomainShow'))

    if "disable" in request.POST:
      print('id da disattivare',request.POST['disable'])
      idpost = request.POST.get('disable')
      u = Domini.objects.get(pk=idpost)
      u.enabled=False
      u.save()

    if "enable" in request.POST:
      print('id da attivare',request.POST['enable'])
      idpost = request.POST['enable']
      u = Domini.objects.get(pk=idpost)
      u.enabled=True
      u.save()

    if "ExecSpazio" in request.POST:
      idpost = request.POST['ExecSpazio']
      print('Richiesto calcolo spazio per',idpost)
      print('url richiesto',reverse('Comunicazioni:OccupazioneControlloQuota',args=(idpost,)))
      #return HttpResponseRedirect(reverse('Domini:DomainList'))
      return HttpResponseRedirect(reverse('Comunicazioni:OccupazioneControlloQuota',args=(idpost,)))


    if "AggiornaCausale" in request.POST:
      print("Aggiornamento causale",request.POST['AggiornaCausale'])
      idpost = request.POST['AggiornaCausale']
      d = Domini.objects.get(pk=idpost)
      print('dominio richiesto',idpost)
      print('causale richiesta',request.POST['ValoreCausale'])
      c = Causale.objects.get(pk=request.POST['ValoreCausale'])
      d.last_causale = c

      Aggiorna_Dominio_Da_Causale(d,c)
      AggiornaStoriaCausali(d,utenteautorizzato,c,"")
      print(UltimaStoriaCausali(d))
      d.save()

  if domain_order == 'oa':
    value['domainlist'] = Domini.objects.all().order_by('nome')
    if Nascondi_Scaduti == "1": value['domainlist'] = Domini.objects.all().order_by('nome').filter(enabled=1)
  if domain_order == 'oc':
    value['domainlist'] = Domini.objects.all().order_by('date_expire_contract')
    if Nascondi_Scaduti == "1": value['domainlist'] = Domini.objects.all().order_by('date_expire_contract').filter(enabled=1)
  if domain_order == 'or':
    value['domainlist'] = Domini.objects.all().order_by('date_expire_registrar')
    if Nascondi_Scaduti == "1": value['domainlist'] = Domini.objects.all().order_by('date_expire_registrar').filter(enabled=1)

  return render(request,"gestione.domain.list.html",value)


def DomainEdit(request):

  '''
  gestione delle info sul domini
  e contabilita'
  '''
  # verifica utente passato nella session
  session = getSessionParms(request)
  userauth = session['_userauth_']

  try:
    utenteautorizzato = User.objects.get(pk=userauth)
  except User.DoesNotExist as dne:
    return  HttpResponseRedirect(reverse('Login:login',args={}))


  domain2edit = session['_domain2edit_']
  if not domain2edit:
    domain2edit = utenteautorizzato.domain

  # se e' a 0: associa il dominio dell'utente autorizzato
  # se e' a -1: nuovo dominio

  dominio = None
  value = {}

  # se non e' indicato un dominio, usa il dominio dell'utente.
  if not domain2edit:
    domain2edit = utenteautorizzato.domain.id
  
  # il dominio e' nuovo. 
  if domain2edit == -1:
    dominio = Domini();
    # possiamo assegnare i default.
    dominio.max_account = getConfigurazione('domini.default_maxaccount')
    dominio.max_alias = getConfigurazione('domini.default.max_alias')
    dominio.max_list = getConfigurazione('domini.default.list')
    dominio.public_email = getConfigurazione('domini:public_email')
    dominio.target = Target.objects.get(id=getConfigurazione('domini.default.target'))
    dominio.maildir = getConfigurazione('domini.default.maildir')
    dominio.edit = True; #fondamentale per consentire la prima compilazione
    dominio.tobedeleted = False
    dominio.rinnovo_automatico = False

    #gestione delle date
    datadioggi = datetime.now()
    datatraunanno = datetime.now() + timedelta(days=365)
    dominio.date_start_contract = datadioggi
    dominio.date_expire_contract = datatraunanno
    dominio.date_expire_registrar = datatraunanno

  else:
    dominio = Domini.objects.get(pk=domain2edit)

  value['dominio'] = dominio
  print("domain2Edit: ",domain2edit,dominio.nome)

  value['utenteautorizzato'] = utenteautorizzato
  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel.id)
  securityrow = getSecurityRow(securitylevel.id)
  securitylist = getSecurityList(securityrow)
  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['securitylist'] = securitylist
  value['navbar']=True

  print(f'request.method: {request.method}')
  value['causali'] = Causale.objects.all().filter(enabled=True).order_by('nome')
  value['mailserver'] = MailServer.objects.all().filter(enabled=True).order_by('nome')
  value['target'] = Target.objects.all().filter(enabled=True).order_by('nome')

  value['registrar'] = Registrar.objects.all().filter(enabled=True)

  dsa = None
  try:
    dsa = DominiServiziAssegnati.objects.get(dominio=dominio.id)
  except DominiServiziAssegnati.DoesNotExist as dne:
    print(dne)

  value['dsf'] = dsa
  #value['dsf'] = dominio.dominiserviziassegnati_set.all()

  #value['list_mail_server'] = MailServer.objects.all().filter(enabled=True)
  #value['list_target'] = Target.objects.all().filter(enabled=True)

  if request.method == 'POST':

    if 'Ritorna' in request.POST:
      print('Premuto tasto Ritorna da Editing Domini')
      return HttpResponseRedirect(reverse('Domini:DomainList'))

    domainedit = FormDomainEdit(request.POST)
    domainedit.update()

    domaincausale = FormDomainCausale(request.POST)

    if domaincausale.is_valid(): #verificare che non si tratti di prima registrazione
      print("conferma causale trovata");
      print("domaincausalet.causale",domaincausale.cleaned_data.get('causale'))
      try:
        print("domain.ultima causale usata",dominio.last_causale.nome)
      except Causale.DoesNotExist as dne:
        print("causale non registrata")

      causaleindicata = domaincausale.cleaned_data.get('causale')

      causale = None
      try:
        causale = Causale.objects.get(pk=causaleindicata)
      except Causale.DoesNotExist as dne:
        print("Causale inesistente: ",causaleindicata)
      except ValueError as ve:
        print("Cazzo, valore vuote") 
      print("ci:",causaleindicata)

      if causale:
        print("cc:",causale.id,causale.nome)
      else:
        print("cc: sbagliato")

      ''' a questo punto devi, in base a quanto riportato nella causale, effettuare le diverse operazioni
      '''

      Aggiorna_Dominio_Da_Causale(dominio,causale)
      AggiornaStoriaCausali(dominio,utenteautorizzato,causale,"")
      print(UltimaStoriaCausali(dominio))

      sm = ServizioMail()
      #imposta i destinatari
      listadestinatari=[]
      PresenteContattoDestinatari=False

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

      if causale.send_email_admin and len(causale.to_admin):
        tmplista = re.split(',| ',causale.to_admin)
        for i in tmplista:
          listadestinatari.append(i)

      if causale.send_email_account:
        if len(causale.to_account):
          tmplista =  re.split(',| ',causale.to_account)
          for i in tmplista:
            listadestinatari.append(i)
        else:
          accountdft = getConfigurazione('mail:accounting')
          if accountdft and len(accountdft):
            accountdft = re.split(',| ',accountdft)
            for i in accountdft:
              listadestinatari.append(i)

      if causale.domain_tobedeleted:
        dominio.tobedeleted = True

      dominio.last_causale = causale
      dominio.save()

      print("salvo gli aggiornamenti:")

      AggiornaStoriaCausali(dominio,utenteautorizzato,causale,"")
      print(UltimaStoriaCausali(dominio))

      templatetrovato=False
      try:
        template = causale.template
        templatetrovato=True
      except Template.DoesNotExist as dne:
        print("Template inesistente")
        print(dne)

      if templatetrovato:
        print('template valido')
        data = {}
        data['dominio'] = dominio.__dict__
        print("dominio.renew_code",dominio.__dict__['renew_code'])
        if PresenteContattoDestinatari: data['PresenteContattoDestinatari']=True

        print("spedisco mail a",listadestinatari)
        sm.add_listadestinatari(listadestinatari)
        sm.set_oggetto(template.oggetto)
        sm.set_soggetto(template.soggetto)
        sm.set_data(data)
        sm.send()
        sm = None
      else:
        print("Template Non valido.... non invio comunicazioni")

    elif domainedit.is_valid():
      print(f'domainedit.is_valid {domainedit.is_valid()}')
      dominio.nome = domainedit.cleaned_data.get('dominio')
      if not 'home' in domainedit.cleaned_data:
        dominio.home = domainedit.cleaned_data.get('home')
      if not 'public_email' in domainedit.cleaned_data:
        dominio.public_email.getConfigurazione('default-public-email')
      else:
         dominio.public_email = domainedit.cleaned_data.get('public_email')

      dominio.contatti = domainedit.cleaned_data.get('contatti')
      dominio.proprietario = domainedit.cleaned_data.get('proprietario')

      dominio.date_start_contract = domainedit.cleaned_data.get('date_start_contract')
      dominio.date_expire_contract = domainedit.cleaned_data.get('date_expire_contract')
      dominio.date_expire_registrar = domainedit.cleaned_data.get('date_expire_registrar')
      print("date:", dominio.date_start_contract,dominio.date_expire_contract,dominio.date_expire_registrar)

      dominio.nota = domainedit.cleaned_data.get('nota')

      dominio.enabled = domainedit.cleaned_data.get('enabled')
      dominio.tobedeleted = domainedit.cleaned_data.get('tobedeleted')
      dominio.mail = domainedit.cleaned_data.get('mail')
      dominio.pop3 = domainedit.cleaned_data.get('pop3')
      dominio.imap = domainedit.cleaned_data.get('imap')
      dominio.smtp = domainedit.cleaned_data.get('smtp')
      dominio.smtp_relay = domainedit.cleaned_data.get('smtp_relay')
      dominio.webmail = domainedit.cleaned_data.get('webmail')
      dominio.nextcloud = domainedit.cleaned_data.get('nextcloud')
      dominio.nextcloud_pwd = domainedit.cleaned_data.get('nextcloud_pwd')
      dominio.sms = domainedit.cleaned_data.get('sms')

      dominio.lmtp = domainedit.cleaned_data.get('lmtp')
      dominio.sieve = domainedit.cleaned_data.get('sieve')
      dominio.antivirus = domainedit.cleaned_data.get('antivirus')
      dominio.spf = domainedit.cleaned_data.get('spf')
      dominio.blacklist = domainedit.cleaned_data.get('blacklist')

      dominio.ftp = domainedit.cleaned_data.get('ftp')
      dominio.sql = domainedit.cleaned_data.get('sql')
      dominio.http = domainedit.cleaned_data.get('http')
      dominio.proxy = domainedit.cleaned_data.get('proxy')

      dominio.sendafile = domainedit.cleaned_data.get('sendafile')

      dominio.registrar_id = domainedit.cleaned_data.get('registrar')

      dominio.mail_server_id = domainedit.cleaned_data.get('mail_server')
      dominio.lmtp_server_id = domainedit.cleaned_data.get('lmtp_server')
      dominio.mail_proxy_id = domainedit.cleaned_data.get('mail_proxy')
      dominio.sql_remote_id = domainedit.cleaned_data.get('sql_remote')

      dominio.max_account = domainedit.cleaned_data.get('max_account')
      dominio.max_alias = domainedit.cleaned_data.get('max_alias')
      dominio.max_list = domainedit.cleaned_data.get('max_list')
      dominio.rinnovo_automatico = domainedit.cleaned_data.get('rinnovo_automatico')
      dominio.target_id = domainedit.cleaned_data.get('target')

      if not dominio.edit:
         dominio.edit = domainedit.cleaned_data.get('edit')
      else: 
         dominio.edit = False
      if len(dominio.home) < 1:
        print('attenzione: aggiorno il nome dominio')
        dominio.home = dominio.nome
      dominio.save()
      session['_domain2edit_']=dominio.id
      domain2edit = dominio.id
      print("dominio 2 edit ",domain2edit)

    else:
      print("ERRORI",domainedit.errors)
      print("cleaned:",domainedit.cleaned_data.get('http_server'))
      fde = FormDomainEdit(request.POST)
      fde.update()
      value['domainedit']=fde

  t = {}
  t['dominio'] = dominio.nome
  t['public_email'] = dominio.public_email
  t['home'] = dominio.home
 
  t['date_start_contract'] = dominio.date_start_contract
  t['date_expire_contract'] = dominio.date_expire_contract
  t['date_expire_registrar'] = dominio.date_expire_registrar
    
  t['proprietario'] = dominio.proprietario
  t['contatti'] = dominio.contatti
  t['rinnovo_automatico'] = dominio.rinnovo_automatico 
  t['nota'] = dominio.nota
  print("nota: ",t['nota'])
    
  #stats
  t['max_account'] = dominio.max_account
  t['max_alias'] = dominio.max_alias
  t['max_list'] = dominio.max_list

  try:
    t['account_used'] = dominio.user_set.count()
    t['alias_used'] = dominio.alias_set.count()
    t['list_used'] = dominio.liste_set.count()
    print('count: ',dominio.user_set.count(),dominio.alias_set.count(),dominio.liste_set.count())
  except ValueError as ve:
    print('errore:',ve)
    t['account_used'] = 0
    t['alias_used'] = 0
    t['list_used'] = 0

  t['enabled'] = dominio.enabled
  t['tobedeleted'] = dominio.tobedeleted
  t['mail'] = dominio.mail
  t['pop3'] = dominio.pop3
  t['imap'] = dominio.imap
  t['smtp'] = dominio.smtp
  t['smtp_relay'] = dominio.smtp_relay
  t['webmail'] = dominio.webmail
  t['nextcloud'] = dominio.nextcloud
  t['nextcloud_pwd'] = dominio.nextcloud_pwd
  t['sms'] = dominio.sms
  t['sendafile'] = dominio.sendafile
  t['lmtp'] = dominio.lmtp
  t['sieve'] = dominio.sieve
  t['antivirus'] = dominio.antivirus
  t['spf'] = dominio.spf
  t['blacklist'] = dominio.blacklist
  t['ftp'] = dominio.ftp
  t['sql'] = dominio.sql
  t['http'] = dominio.http
  t['proxy'] = dominio.proxy
  t['edit'] = dominio.edit

  try:
    t['dominio_storia'] = dominio.storia_set.all()
  except ValueError as ve:
    print('Errore:',ve)

  try: 
    t['registrar'] = dominio.registrar_id
  except Registrar.DoesNotExist as dne:
    print(dne)

  try:
    t['mail_server'] = dominio.mail_server_id
  except MailServer.DoesNotExist as dne:
    print(dne)
    t['mail_server'] = getConfigurazione('default_mail_server')

  try:
    t['mail_proxy'] = dominio.mail_proxy_id
  except MailProxy.DoesNotExist as dne:
    print(dne)
    t['mail_proxy'] = getConfigurazione('default_mail_proxy')

  try:
    t['lmtp_server'] = dominio.lmtp_server_id
  except LmtpServer.DoesNotExist as dne:
    print(dne)
    t['lmtp_server'] = getConfigurazione('default_lmtp_server')

  try:
    t['sql_remote'] = dominio.mail_proxy_id
  except MailProxy.DoesNotExist as dne:
    print(dne)
    t['sql_remote'] = getConfigurazione('default_sql_remote')

  try:
    t['last_causale'] = dominio.last_causale_id
  except Causale.DoesNotExist as dne:
    print("Causale indicata inesistente")
    t['last_causale'] = 0
  except ValueError as ve:
    print("Errore di valore")
    t['last_causale'] = 0

  try:
    t['target'] = dominio.target_id
    print('target',t['target'])
  except Target.DoesNotExist as dne:
    print("Target indicato inesistente")
    t['target'] = getConfigurazione('default-target')

  value['totale'] = 0
  try: 
    value['totale'] += dominio.mail_quota
  except TypeError:
    value['totale'] += 0
  try:
    value['totale'] += dominio.http_quota
  except TypeError:
    value['totale'] += 0
  try:
    value['totale'] +=dominio.ftp_quota
  except TypeError:
    value['totale'] += 0
  try:
    value['totale'] += dominio.sql_quota
  except TypeError:
    value['totale'] += 0
  try:
    value['totale'] += dominio.nextcloud_quota
  except TypeError:
    value['totale'] += 0

  print('totale',value['totale'])
  print(t)
  fde = FormDomainEdit(t)
  fde.update()
  value['domainedit']=fde

 
  try:
    value['display_last_causale'] = dominio.last_causale.nome
  except Causale.DoesNotExist as dne:
    value['display_last_causale'] = 'non assegnata'
  except ValueError:
    value['display_last_causale' ] = 'non assegnata'
 
  value['UltimaStoriaCausali'] = UltimaStoriaCausali(dominio,5)

  # mostra assegnazione ftp
  ftplist = FTPUser.objects.all().filter(dominio=dominio.id)
  value['ftplist'] = ftplist

  return render(request,'gestione.domain.edit.html',value)


def DomainShow(request):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  utenteautorizzato = User.objects.get(pk=userauth)

  dominio = Domini()
  domain2edit = session['_domain2edit_']
  if not domain2edit:
    domain2edit = utenteautorizzato.domain.id

  dominio = Domini.objects.get(pk=domain2edit)
    
  print("domain2Edit: ",domain2edit)
  
  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['used_account' ] = len(User.objects.filter(domain=dominio))
  value['used_alias'] = len(Alias.objects.filter(domain=dominio))
  value['registrar'] = Registrar.objects.all().filter(enabled=True).order_by('nome')
  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel_id)
  securityrow = getSecurityRow(securitylevel.id)
  securitylist = getSecurityList(securityrow)
  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['securitylist'] = securitylist
  value['navbar']=True

  value['dominio'] = dominio
 
  value['totale'] = 0
  try: 
    value['totale'] += dominio.mail_quota
  except TypeError:
    value['totale'] += 0
  try:
    value['totale'] += dominio.http_quota
  except TypeError:
    value['totale'] += 0
  try:
    value['totale'] +=dominio.ftp_quota
  except TypeError:
    value['totale'] += 0
  try:
    value['totale'] += dominio.sql_quota
  except TypeError:
    value['totale'] += 0
  try:
    value['totale'] += dominio.nextcloud_quota
  except TypeError:
    value['totale'] += 0

  print('totale',value['totale'])

  # mostra assegnazione ftp
  ftplist = FTPUser.objects.all().filter(dominio=dominio.id)
  value['ftplist'] = ftplist

  return render(request,'gestione.domain.show.html',value)


def DomainServiziLista(request):
  '''
  lista dei servizi disponibili indipendentemente dal dominio
  '''
  session = getSessionParms(request)
  userauth = session['_userauth_']
  utenteautorizzato = User.objects.get(pk=userauth)

  # da qui carica i dati dal db.
  #domain2edit = session['_domain2edit_']
  #dominio = Domini.objects.get(pk=domain2edit)

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  #value['dominio'] = dominio

  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel.id)
  securityrow = getSecurityRow(securitylevel.id)
  securitylist = getSecurityList(securityrow)
  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['securitylist'] = securitylist
  value['navbar']=True

  value['domainservice'] = DominiServizi.objects.all()

  if request.method=="POST":
    pass

  return render(request,"gestione.domain.servizi.lista.html",value)

def DomainServiceEdit(request):
  '''
  accesso ai servizi legati al dominio
  '''
  session = getSessionParms(request)
  userauth = session['_userauth_']
  utenteautorizzato = User.objects.get(pk=userauth)

  # da qui carica i dati dal db.
  domain2edit = session['_domainservice2edit_']
  dommainservice = DomainService.objects.get(pk=domainservice2edit)

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['dominio'] = dominio

  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel.id)
  securityrow = getSecurityRow(securitylevel.id)
  securitylist = getSecurityList(securityrow)
  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['securitylist'] = securitylist
  value['navbar']=True

  domainservice = DomainService()

  try:
    domainservice = DomainService.objects.get(ok=domainservice2edit)
  except DomainService.DoesNotExist as dne:
    print(dne)

  if request.method=="POST":
    if 'edit' in request.POST:
      pass

  temp = {}
  temp['nome'] = domainservice.nome
  temp['classe'] = domainservice.classe
  temp['enabled'] = domainservice.enabled
  temp['home'] = domainservice.home
  domainserviceform = DomainServiceForm(temp)
  value['doaminserviceform'] = domainserviceform

  
  return render(request,"gestioneDomainService.html",value)

def ServiziLista(request):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  request.session['_from_']="Domini:ServiziList"

  try:
    utenteautorizzato = User.objects.get(pk=userauth)
  except User.DoesNotExist as dne:
    return  HttpResponseRedirect(reverse('Login:login',args={}))

  servizi = Servizi.objects.all().order_by('nome')

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['causali'] = causali
  value['navbar'] = True

  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel_id)
  securityrow = getSecurityRow(utenteautorizzato.securitylevel_id)

  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  return render(request,'gestione.servizi.list.html',value)

def DomainServizi(request):
  '''
  accesso ai servizi legati al domini x singolo dominio
  '''
  session = getSessionParms(request)
  userauth = session['_userauth_']
  utenteautorizzato = User.objects.get(pk=userauth)

  # da qui carica i dati dal db.
  domain2edit = session['_domain2edit_']
  dominio = Domini.objects.get(pk=domain2edit)

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['dominio'] = dominio

  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel.id)
  securityrow = getSecurityRow(securitylevel.id)
  securitylist = getSecurityList(securityrow)
  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['securitylist'] = securitylist
  value['navbar']=True

  return render(request,"gestione.domain.servizi.html",value)



def DomainServiceAssignment(request):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  utenteautorizzato = User.objects.get(pk=userauth)

  # da qui carica i dati dal db.
  domain2edit = session['_domain2edit_']
  dominio = Domini.objects.get(pk=domain2edit)

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['dominio'] = dominio

  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel.id)
  securityrow = getSecurityRow(securitylevel.id)
  securitylist = getSecurityList(securityrow)

  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['securitylist'] = securitylist
  value['navbar']=True

  if request.method == 'POST':
    print(request.POST)
    if 'serviziodaaaggiungere' in request.POST:
      print('addservice')
      v = request.POST.get('serviziodaaggiungere')
      print(v)
      s = DominiServizi.objects.get(pk=v)
      d = DominiServiziAssegnati()
      d.dominio = dominio
      d.servizio = s
      d.attivazione = datetime.today().strftime('%Y-%m-%d')
      f = FormServiziNota(request.POST)
      if f.is_valid():
        d.nota = f.cleaned_data.get('nota')
        print(d.nota)
      else:
        print(f.errors)
      d.save() 

    if 'serviziodarimuovere' in request.POST:
      v = request.POST.get('serviziodarimuovere')
      print('delservice',v)
      s = DominiServiziAssegnati.objects.get(pk=int(v))
      s.disattivazione = datetime.today().strftime('%Y-%m-%d')
      f = FormServiziNota(request.POST)
      if f.is_valid():
        s.nota = f.cleaned_data['nota']
        print(".",s.nota)
      else:
        print(f.errors)
      s.save()


  value['domainservizi'] = DominiServizi.objects.all().filter(enabled=True)
  value['domainserviziassegnati'] = dominio.dominiserviziassegnati_set.all()

  return render(request,'gestione.servizi.assignment.html',value)

def DomainService(request):
  pass

def OnSync(request):
  #sincronizza alcuni parametri di un dominio
  session = getSessionParms(request)
  userauth = session['_userauth_']
  utenteautorizzato = User.objects.get(pk=userauth)

  domain2edit = session['_domain2edit_']

  # se e' a 0: associa il dominio dell'utente autorizzato
  # se e' a -1: nuovo dominio

  # se non e' indicato un dominio, usa il dominio dell'utente.
  if not domain2edit:
    return HttpResponseNonFound('Not Valid')

  dominio = Domini.objects.get(pk=domain2edit)

  data = { 'Status': 'freghete' }
  return JsonResponse(data)