dashboard4/utenti/views.py

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.urls import reverse

from .models import *
from .forms import *

from supporto import managepassword
from sicurezza.views import *
from logger.views import *
from comunicazioni.views import *
from datetime import date,datetime
from configurazione.views import *
from django.db import IntegrityError

from mqtt import views as mm #questo dovrebbe essere il vecchio sistema
from mqtt.views import mqtt

import re
import json

def UserList(request):

  session = getSessionParms(request)

  userauth = session['_userauth_']

  user2edit = session['_user2edit_']
  domain2edit = session['_domain2edit_']
  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

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

  userlist = User.objects.filter(domain=domain2edit).order_by('mail')

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

  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel_id)
  securityrow = getSecurityRow(utenteautorizzato.securitylevel_id)
  securitylist = getSecurityList(securityrow)
  value['securitylist'] = securitylist
  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['CANWRITE']=True #per il momento, questo flag serve a capire se e' un record nuovo

  if request.method=="POST":

    if "Nuova Email" in request.POST:
      print('nuova email')
      request.session['_user2edit_'] = -1 
      return  HttpResponseRedirect(reverse('Utenti:UserEdit',args={}))

    if "Lista Email" in request.POST:
      request.session['_user2edit_'] = -1
      return HttpResponseRedirect(reverse('Utenti:UserReadOnlyList',args={}))

    if "editbutton" in request.POST:
      print('id da editare',request.POST['editbutton'])
      request.session['_user2edit_'] = request.POST['editbutton']
      return HttpResponseRedirect(reverse('Utenti:UserEdit',args={}))

    if "enabledisablebutton" in request.POST:
      print('id da disattivare',request.POST['enabledisablebutton'])
      idpost = request.POST['enabledisablebutton']
      u = User.objects.get(pk=idpost)
      u.enabled = not u.enabled
      if u.enabled: u.tobedeleted = False
      t = date.today()
      u.account_date_disabled=t.strftime("%Y-%m-%d")
      u.save()

    if 'enablepassword' in request.POST:
      print('id da attivare',request.POST['enablepassword'])
      idpost = request.POST['enablepassword']
      u = User.objects.get(pk=idpost)
      u.enabled = True
      u.tobedeleted = False
      u.account_date_disabled = None
      u.clear = getPassword()
      u.crypt = managepassword.GeneraPassword(u.clear)
      u.save()
      request.session['_user2edit_'] = idpost
      return HttpResponseRedirect(reverse('Utenti:UserEdit',args={}))

    if 'tobedeletedbutton' in request.POST:
      print('id da cancellare',request.POST['tobedeletedbutton'])
      idpost = request.POST['tobedeletedbutton']
      u = User.objects.get(pk=idpost)
      u.tobedeleted = not u.tobedeleted
      u.save()
 
    # invia le info sull'email all'utente autorizzato all'editing
    # le info vengono ottenute da quanto contenuto nel record
    if 'sendInfoToMe' in request.POST:
      print('richista informazioni mail')
      sm = ServizioMail()
      idpost = request.POST['sendInfoToMe']
      record = User.objects.get(pk=idpost)
      print(record.nome)
      sm.set_rcptto(r'{}@{}'.format(utenteautorizzato.mail.strip(),utenteautorizzato.domain.nome.strip()))
      template=Template.objects.get(pk=getConfigurazione("mail:info:info"))
      sm.set_oggetto(template.oggetto)
      sm.set_soggetto(template.soggetto)
      dictdict={}
      dictdict['utente'] = record
      dictdict['utenteautorizzato'] = utenteautorizzato
      dictdict['data'] = datetime.now()
      sm.set_data(dictdict)
      sm.send() 

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

    # cazz'e' sta sezione?
    if 'notaSubmit' in request.POST:
      fm = formMsg(request.POST)
      if fm.is_valid():
        oggetto = fm.cleaned_data.get('oggetto')
        soggetto = fm.cleaned_data.get('soggetto')
        conferma = fm.cleaned_data.get('conferma')
        utentiToSend = User.objects.filter(domain=dominio).filter(enabled=True)

        print('dominio',dominio.id)
        print('numero di utenti da raggiungere',len(utentiToSend))
        print('soggetto',soggetto)
        print('oggetto',oggetto)
        print('conferma',conferma)

        if conferma:
          count=0
          for uts in utentiToSend:
            count = count +1
            print('generato nuovo record',count,uts.mail)
            sm = ServizioMail()
            sm.set_rcptto(r'{}@{}'.format(uts.mail.strip(),uts.domain.nome.strip()))
            sm.set_oggetto(oggetto)
            sm.set_soggetto(soggetto)
            dictdict={}
            dictdict['utente'] = uts
            dictdict['utenteautorizzato'] = utenteautorizzato
            dictdict['data'] = datetime.now()
            sm.set_data(dictdict)
            sm.send() 

    if 'alldeletedbutton' in request.POST:
      print('Richiesta di cancellazione di tutte le email disattivate')
      listaemail = User.objects.filter(domain=dominio.id)
      for lm in listaemail:
        if not lm.enabled:
          print('email',lm.mail)
          lm.tobedeleted=True
          lm.save()

      print('elenco delle email da rimuovere',len(listaemail))

  return render(request,"Utente.List.html",value)

'''
sia userEdit che UserNew usano uno schema semplificato per gestire gli utenti.
per evitare di usare due funzioni che per la maggior parte del tempo si sovrappongono,
genero una terza funzione proprio per gestire tutte le parti comuni.
Questa parte comune, chiamata usermaster, ricevera' svariati parametri e ne ritornera'
altrettanti per gestire l'oggetto mail sia vuoto,nuovo, che da editare.
'''

def UserEdit(request):

  session = getSessionParms(request)
  userauth = session['_userauth_']
  user2edit = session['_user2edit_']
  print('user2edit: ',user2edit)

  domain2edit = session['_domain2edit_']
  _from_ = session['_from_']

  print("_from_",_from_)

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

  try:
    dominio = Domini.objects.get(pk=domain2edit)
  except Domini.DoesNotExist as dne:
    print("errore, il dominio non e' correttamente gestito in useredit")
    dominio = utenteautorizzato.domain

  value={}
  value['CANWRITE']=False
  mailinglist = list()
  nuovorecord = False

  if not user2edit:
    # non e' presente un utente.
    record = utenteautorizzato

  elif int(user2edit)>0:
    record = User.objects.get(pk=user2edit)
    totalmailinglist = record.domain.liste_set.all()
    for i in totalmailinglist:
      if i.listeaccount_set.filter(mail__id = record.id):
        mailinglist.append(i)

    print("stato mailinglist",mailinglist)
    value['mailinglist'] = mailinglist

    #13.9.22
    #questo campo deve essere sempre  valorizzato.
    #soprattutto in vista del cambiamento al riferimento server dal dominio al singolo account.
    if not record.mail_server_id:
      record.mail_server_id = dominio.mail_server_id

  elif int(user2edit)-1:
    nuovorecord = True
    print('dominio:',dominio.nome)
    record = User()
    record.domain = dominio
    record.enabled = dominio.enabled
    record.pop3 = dominio.pop3
    record.imap = dominio.imap
    record.webmail = dominio.webmail
    record.smtp = dominio.smtp
    record.smtp_relay = dominio.smtp_relay
    record.sieve = dominio.sieve
    record.antivirus = dominio.antivirus
    record.spf = dominio.spf
    record.blacklist = dominio.blacklist
    record.nextcloud = dominio.nextcloud
    record.nextcloud_pwd = dominio.nextcloud_pwd
    record.proxy = dominio.proxy
    record.lmtp = dominio.lmtp
    record.password_change_enable=1

  # memorizza i dati del server di posta dal dominio
  # ma solo se l'utente non e' gia presente.

    record.mail_server_id = dominio.mail_server_id
    record.mail_proxy_id = dominio.mail_proxy_id
    record.lmtp_server_id = dominio.lmtp_server_id
    record.sql_remote_id = dominio.sql_remote_id

    record.securitylevel_id = getConfigurazione('default-level')
    record.warning_mail_quota = dominio.warning_mail_quota
    #record.limit_mail_quota = dominio.limit_mail_quota
    record.clear = getPassword()
    record.crypt =  managepassword.GeneraPassword(record.clear)

    print('record.clear:',record.clear)

  mq = mqtt()
  # mq.build('topic','messaggio') #vediamo se il default funziona
  # mq.build('richiesta','MailingList')
  mq.build('stampa',True)
  tmp = dict()
  tmp['utenteautorizzato'] = "".join((utenteautorizzato.mail,'@',utenteautorizzato.domain.nome))
  mq.build('data',tmp)
  mq.pubblica()
  tmp=None

  value['utenteautorizzato'] = utenteautorizzato
  value['user'] = record
  value['userlist'] = None
  value['dominio'] = record.domain
  value['navbar'] = True
  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel_id)
  securityrow = getSecurityRow(utenteautorizzato.securitylevel_id)
  securitylist = getSecurityList(securityrow)

  value['securityrow'] = securityrow
  value['securityrowLen'] = len(securityrow)
  value['securitylist'] = securitylist
  value['mail_password_length']=getConfigurazione('mail_password_length')
  value['mail_password_message'] = getConfigurazione('mail_password_message')
  
  d = Domini.objects.all().order_by('nome')
  domainlist = []
  for i in d:
    domainlist.append((i.id,i.nome))
  value['domainlist'] = domainlist

  m = MailServer.objects.all().order_by('ip')
  value['mailserverlist'] = m.filter(enabled=True)
  value['lmtpserverlist'] = m.filter(enabled=True)
  value['sqlremotelist'] = m.filter(enabled=True)
  value['mailproxylist'] = m.filter(enabled=True)

  # livello utenti (si da' la possibilita di selezionare fino al livello proprio)
  livello =  SecurityLevel.objects.filter(id__lte = utenteautorizzato.securitylevel_id).filter(enabled=True)
  value['livello']=livello

  # non effettua il salvataggio, ma ritorna alla lista FTP
  if 'Ritorno' in request.POST:
      return HttpResponseRedirect(reverse('Utenti:UserList'))

  oldpassword = None

  if request.method=="POST":
    formemail = formEmail(request.POST)
    formemail.update()

    print("request Method: ",request.method)

    if 'emailtest' in request.POST:
      '''
      richiesta di invio dei parametri di test
      '''

      print("richiesto invio prova di stampa")
      buildemail(getConfigurazione('mail_from'),["{}@{}".format(record.mail,record.domain.nome)],'mail_test_subject','mail_test_body_html','mail_test_body_text',{'domain':record.domain.nome,'mail':record.mail})

    if 'sendInfoToMe' in request.POST:
      print('richiesta informazioni mail')
      sm = ServizioMail()
      sm.set_rcptto(r'{}@{}'.format(utenteautorizzato.mail.strip(),utenteautorizzato.domain.nome.strip()))
      template=Template.objects.get(pk=getConfigurazione("mail:info:info"))
      sm.set_oggetto(template.oggetto)
      sm.set_soggetto(template.soggetto)
      dictdict={}
      dictdict['utente'] = record
      dictdict['utenteautorizzato'] = utenteautorizzato
      dictdict['precedente_password'] = oldpassword
      dictdict['data'] = datetime.now()
      sm.set_data(dictdict)
      sm.send() 

    if formemail.is_valid():
      print("Formemail.is_valid()")
      if 'mail' in formemail.cleaned_data:
        record.mail = formemail.cleaned_data.get('mail').lower() #le mail dovrebbero essere sempre salvate in minuscolo.

      record.nome = formemail.cleaned_data.get('nome') #dovrebbe venir modificato solo alla creazione
      record.domain_id = formemail.cleaned_data.get('dominio')

      # pero' non mi piace... dovrebbe reagire in base alla presenza dei campi nel form
      # secondo me devo toglierli dalla form di validazione e usarla solo per le cose importanti
      if utenteautorizzato.securitylevel_id > 5:
        if 'enabled' in formemail.cleaned_data:
          record.enabled = formemail.cleaned_data.get('enabled')
        if 'pop3' in formemail.cleaned_data:
          record.pop3 = formemail.cleaned_data.get('pop3')
        if 'imap' in formemail.cleaned_data:
          record.imap = formemail.cleaned_data.get('imap')
        if 'smtp' in formemail.cleaned_data:
          record.smtp = formemail.cleaned_data.get('smtp')
        if 'smtp_relay' in formemail.cleaned_data:
          record.smtp_relay = formemail.cleaned_data.get('smtp_relay')

        print(formemail.cleaned_data)
        if 'lmtp' in formemail.cleaned_data:
          record.lmtp = formemail.cleaned_data.get('lmtp')
        if 'lmtp_server' in formemail.cleaned_data:
          record.lmtp_server_id = formemail.cleaned_data.get('lmtp_server')
        if 'mail_server' in formemail.cleaned_data:
          record.mail_server_id = formemail.cleaned_data.get('mail_server')
        if 'mail_proxy' in formemail.cleaned_data:
          record.mail_proxy_id = formemail.cleaned_data.get('mail_proxy')
          if record.mail_proxy_id:
            record.proxy_host = record.mail_proxy.ip #dovra' essere rimosso in futuro
        if 'sql_remote' in formemail.cleaned_data:
          record.sql_remote_id = formemail.cleaned_data.get('sql_remote')
        else: record_sql_remote_id = 0 

        if 'webmail' in formemail.cleaned_data:
          record.webmail = formemail.cleaned_data.get('webmail')
        if 'securitylevel' in formemail.cleaned_data:
          record.securitylevel_id = formemail.cleaned_data.get('securitylevel')
        if 'nextcloud' in formemail.cleaned_data:
          record.nextcloud = formemail.cleaned_data.get('nextcloud')
        if 'nextcloud_pwd' in formemail.cleaned_data:
          record.nextcloud_pwd = formemail.cleaned_data.get('nextcloud_pwd')
        if 'sms' in formemail.cleaned_data:
          record.sms = formemail.cleaned_data.get('sms')
        if 'sendafile' in formemail.cleaned_data:
          record.sendafile = formemail.cleaned_data.get('sendafile')
        if 'sieve' in formemail.cleaned_data:
          record.sieve = formemail.cleaned_data.get('sieve')
        if 'antivirus' in formemail.cleaned_data:
          record.antivirus = formemail.cleaned_data.get('antivirus')
        if 'blacklist' in formemail.cleaned_data:
          record.blacklist = formemail.cleaned_data.get('blacklist')
        if 'spf' in formemail.cleaned_data:
          record.spf = formemail.cleaned_data.get('spf')

      record.warning_mail_quota = formemail.cleaned_data.get('warning_mail_quota')
      record.limit_mail_quota = formemail.cleaned_data.get('limit_mail_quota')
      record.nota = formemail.cleaned_data.get('nota')
      record.mail_di_recupero = formemail.cleaned_data.get('mail_di_recupero')
      record.forward = formemail.cleaned_data.get('forward')

      print('stato password_change_enabled')
      print('password_change_enabled originale',record.password_change_enabled)
      print('password_change_enabled rilevato',formemail.cleaned_data.get('password_change_enabled'))

      if not 'password_change_enabled' in formemail.changed_data:
        print("presente campo password_change_enabled")
        record.password_change_enabled = formemail.cleaned_data.get('password_change_enabled')
      else:
        print("Campo password_change_enabled non presente")

      print('record.password_change_enabled',record.password_change_enabled)

      if record.password_change_enabled:
        oldpassword =record.clear #memorizza la vecchia password
        record.clear = formemail.cleaned_data.get('password1')
        record.crypt =  managepassword.GeneraPassword(record.clear)
        if oldpassword != record.clear:
          oldchanged = True

          mq = mqtt()
          # mq.build('topic','messaggio') #vediamo se il default funziona
          # mq.build('richiesta','MailingList')
          mq.build('stampa',True)
          tmp = dict()
          tmp['utenteautorizzato'] = "".join((utenteautorizzato.mail,'@',utenteautorizzato.domain.nome))
          tmp['utentepassword'] = ''.join((record.mail,"@",record.domain.nome))
          tmp['vecchia password'] = oldpassword
          tmp['nuova password'] = record.clear
          mq.build('data',tmp)
          mq.pubblica()
          tmp=None

      t = date.today()
      record.last_password_update = t.strftime("%Y-%m-%d")

      record.tobedeleted = formemail.cleaned_data.get('tobedeleted')

      if record.tobedeleted:
        record.enabled = False
        record.save()

        mq = mqtt()
        # mq.build('topic','messaggio') #vediamo se il default funziona
        # mq.build('richiesta','MailingList')
        mq.build('stampa',True)
        tmp = dict()
        tmp['utenteautorizzato'] = "".join((utenteautorizzato.mail,'@',utenteautorizzato.domain.nome))
        tmp['utentetobedeleted'] = ''.join((record.mail,"@",record.domain.nome))
        mq.build('data',tmp)
        mq.pubblica()
        tmp=None


        return HttpResponseRedirect(reverse('Utenti:UserList'))
      try:
        record.save()
      except IntegrityError as ie:
        print('Integrity Error',ie)
        user2edit = record.id
        # quesito: come faccio a tornare alla pagina orginale?
        return HttpResponseRedirect(reverse(_from_,args={}))

      '''
      salvato il record, provvediamo anche a inviare i dati per mqtt per i server remoti
      l'operazione viene eseguita solo se sql_remote e' diverso da 0
      '''
      c = mm.start()
      if record.sql_remote_id:
        mml={}
        mml['op']='upd'
        mml['id']=record.id
        mml['rm']=record.sql_remote.ip
        print(mml)
        mm.publish(c,"Richiesta/Mail",json.dumps(mml))
      else: print("mqtt: sql_remote e' impostato a 0")

      '''
      salvato il recordo, provvediamo a inviare una mail
      sia all'account ufficiale che alla mail di riserva (se esiste)
      per comunicare l'effettivo aggiornamento e avvisare.
      '''

      mail_who = formemail.cleaned_data.get('mail_who')

      # si tratta di un nuovo record
      if nuovorecord:
        print('generato nuovo record')
        sm = ServizioMail()
        # inserisce la mail dell'utente appena creato
        sm.set_rcptto(r'{}@{}'.format(record.mail.strip(),record.domain.nome.strip()))
        # viene inviata una notifica anche all'utente supremo/assoluto
        sm.add_to(re.findall("[\w\.-_]+@[\w\.]+",getConfigurazione('mail:notifica')))
        #aggiunge l'utente autorizzato all'editing (tipicamenteo l'amministratore del dominio)
        sm.add_to(utenteautorizzato.mail + "@" + utenteautorizzato.domain.nome)
        # se presente, aggiunge anche la nota all'utente indicato nel campo (Invia credenziali a)
        if mail_who:
          sm.add_to(re.findall("[\w\.-_]+@[\w\.]+",mail_who))

        template=Template.objects.get(pk=getConfigurazione("mail:info:account"))
        sm.set_oggetto(template.oggetto)
        sm.set_soggetto(template.soggetto)
        dictdict={}
        dictdict['utente'] = record
        dictdict['utenteautorizzato'] = utenteautorizzato
        dictdict['precedente_password'] = oldpassword
        dictdict['data'] = datetime.now()
        sm.set_data(dictdict)
        sm.send() 
      else:
        if record.password_change_enabled and oldpassword != record.clear:
          print('richiesto aggiornamento password')
          sm = ServizioMail()
          # invia la mail all'utente in fase di editing
          sm.set_rcptto(r'{}@{}'.format(record.mail.strip(),record.domain.nome.strip()))
          # invia la mail agli utenti di notifica indicati nella configurazione
          sm.add_to(re.findall("[\w\.-_]+@[\w\.]+",getConfigurazione('mail:notifica')))
          # infine  viene aggiunta una mail all'utente autorizzato per l'editing
          sm.add_to(utenteautorizzato.mail + "@" + utenteautorizzato.domain.nome)
          if mail_who:
            sm.add_to(re.findall("[\w\.-_]+@[\w\.]+",mail_who))
          template=Template.objects.get(pk=getConfigurazione("mail:info:newpassword"))
          sm.set_oggetto(template.oggetto)
          sm.set_soggetto(template.soggetto)
          dictdict={}
          dictdict['utente'] = record
          dictdict['utenteautorizzato'] = utenteautorizzato
          dictdict['precedente_password'] = oldpassword
          dictdict['data'] = datetime.now()
          sm.set_data(dictdict)
          sm.send() 

      if record.nextcloud and record.nextcloud_pwd:
        # la sezione nextcloud e' attiva per l'utente e la password e' in sync
        mq = mqtt()
        mq.build('stampa',True)
        mq.build('topic','nextcloud/password')
        tmp = dict()
        tmp['utenteautorizzato'] = "".join((utenteautorizzato.mail,'@',utenteautorizzato.domain.nome))
        tmp['utente'] = ''.join((record.mail,"@",record.domain.nome))
        tmp['password'] = record.clear
        mq.build('data',tmp)
        mq.pubblica()
        tmp=None
        mq = None

      ''' salvato il record, provvediamo anche a fare il flush delle autenticazioni.
      '''
      print('send request flush')
      mq = mqtt()
      mq.build('stampa',True)
      mq.build('topic','richiesta/mail')
      mq.build('richiesta','dovecot/auth/cache/flush')
      #mq.build('data',tmp)
      mq.pubblica()

      user2edit = record.id
      request.session['_user2edit_'] = user2edit
      # quesito: come faccio a tornare alla pagina orginale?
      return HttpResponseRedirect(reverse(_from_,args={}))
      # pero' non vale, nel caso non dovessi dover tornare alla lista?
      # stavo giusto pensando di inviare il referer, per far capire dove tornare.
    else:
      print("formemail.is_valid non passato")
      print("formemail.errors")
      print(formemail.errors)
      for e in formemail.errors:
        print("errors:",e)
      print("***")
     
      # tecnicamente ricarica i dati dal post, ma se alcuni campi non ci sono, come si fa.

      formemail  = formEmail(request.POST)
      formemail.update()
      value['formemail'] = formemail
     
  else:
    
    ## verifica se e' post o meno....
    print('Post Non validato')

    temp={}
    temp['sieve'] = record.sieve
    temp['antivirus'] = record.antivirus
    temp['blacklist'] = record.blacklist
    temp['spf'] = record.spf
    temp['mail'] = record.mail
    print("mail: ",temp['mail'])
    temp['nome'] = record.nome
    temp['dominio'] = record.domain_id
    temp['dominio_domain'] = record.domain.nome
    print('record.clear',record.clear)
    temp['password1'] = record.clear
    temp['password2'] = record.clear
    temp['clear'] = record.clear
    temp['securitylevel'] = record.securitylevel_id
    temp['enabled'] = record.enabled
    temp['pop3'] = record.pop3
    temp['imap'] = record.imap
    temp['smtp'] = record.smtp
    temp['smtp_relay'] = record.smtp_relay
    temp['lmtp'] = record.lmtp
    temp['lmtp_server'] = record.lmtp_server_id
    temp['mail_server'] = record.mail_server_id
    temp['sql_remote'] = record.sql_remote_id
    temp['mail_proxy'] = record.mail_proxy_id
    temp['nextcloud'] = record.nextcloud
    temp['nextcloud_pwd'] = record.nextcloud_pwd
    temp['webmail'] = record.webmail
    temp['sms'] = record.sms
    temp['sendafile'] = record.sendafile
    temp['tobedeleted'] = record.tobedeleted
    temp['mail_quota'] = record.mail_quota
    temp['date_mail_quota'] = record.date_mail_quota
    temp['accountdatecreation'] = record.account_date_creation
    temp['accountdatedisabled'] = record.account_date_disabled
    temp['sms_communication'] = record.sms_communication
    temp['nota'] = record.nota
    temp['proxy_host'] = record.proxy_host
    #temp['bigmail'] = record.bigmail
    temp['mail_di_recupero'] = record.mail_di_recupero
    temp['warning_mail_quota'] = record.warning_mail_quota
    temp['limit_mail_quota'] = record.limit_mail_quota
    temp['password_change_enabled'] = record.password_change_enabled
    temp['passwordchanged'] = False
    temp['forward'] = record.forward
  
    formemail  = formEmail(temp)
    formemail.update()
    value['formemail'] = formemail

  return render(request,'Utente.Edit.html',value)

def UserInfo(request):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  domain2edit = session['_domain2edit_']

  # da qui carica i dati dal db.
  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=dict()
  value['utenteautorizzato']=utenteautorizzato
  print(utenteautorizzato.nome)
  print("livello autorizzazione",utenteautorizzato.securitylevel_id)
  securitylevel = getSecurityLevel(utenteautorizzato.securitylevel_id)
  securityrow = getSecurityRow(utenteautorizzato.securitylevel_id)

  value['securitylevel'] = getSecurityLevel(utenteautorizzato.securitylevel_id)
  value['securityrow'] = securityrow
  value['securitylist'] = getSecurityList(securityrow)

  for i in securityrow: print("-{}-".format(i.securityoptions.id))
  value['securityparms'] = {'utente':utenteautorizzato.id,'dominio':utenteautorizzato.domain.id }
  value['securityrowLen'] = len(securityrow)
  value['navbar']=True

  ### recupero informazioni utente:
  listautenti = User.objects.filter(domain_id = domain2edit)
  size=0
  for i in listautenti:
    size = size + i.mail_quota

  value['dominio_mail_quota'] = size
  nota={'data':datetime.now().strftime('%m/%d%Y %H:%M:%S')}
  registra(utenteautorizzato,5,nota)

  return render(request,'Utente.Info.html',value)

def UserReadOnlyList(request):
  session = getSessionParms(request)

  userauth = session['_userauth_']

  user2edit = session['_user2edit_']
  domain2edit = session['_domain2edit_']
  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

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

  userlist = User.objects.filter(domain=domain2edit).order_by('mail')

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

  value['userlist'] = userlist
  value['dominio'] = dominio
  value['navbar'] = True

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

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

  return render(request,'Utente.ReadOnlyList.html',value)