dashboard4/database/views.py

from django.shortcuts import render
from django.http import HttpResponseRedirect,HttpResponse,HttpRequest
from django.urls import reverse
from datetime import datetime
import json
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 time import time,strftime
from configurazione.views import *
import re 

from mqtt import views as m
from mqtt.views import mqtt

# Create your views here.
def SqlDatabaseList(request):

  session = getSessionParms(request)
  userauth = session['_userauth_']
  sqldatabase2edit = session['_sqldatabase2edit_']
  domain2edit = session['_domain2edit_']
  request.session['_from_']="Sql:SqlDatabaseList"

  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)

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['user'] = None
  value['sqldatabaselist'] = SqlDatabase.objects.filter(dominio=domain2edit).order_by('nome')
  value['dominio'] = dominio
  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)
  value['CANWRITE']=True #per il momento, questo flag serve a capire se e' un record nuovo

  # step: procurare la riga ftp master
  path = None
  print('dominio',dominio.id)

  listaftp = dominio.ftpuser_set.all()
  path = None
  for f in listaftp:
    if f.ftpgroup.master:
      path = ''.join((f.ftpgroup.home,f.dominio.nome))
      print('home ftp',path)

  print('Test Database HTTP Server',dominio.id,dominio.nome)

  if path:
    value['has_http_server'] = True
  else:
    value['has_http_server']= False
    print('non risulta assegnato il server http')

  #vecchia versione mqtt
  c = m.start()

  # nuova versione mqtt
  mq = mqtt()
  mq.build('topic','Messaggio')
  mq.build('richiesta','Database')
  mq.build('stampa',False)
  tmp = dict()
  tmp['login'] = "".join((utenteautorizzato.nome,"@",utenteautorizzato.domain.nome))
  tmp['remote'] = request.META.get('REMOTE_ADDRESS')
  tmp['forwarder' ] = request.META.get('HTTP_X_FORWARDER_FOR','')
  tmp['host'] = request.META.get('REMOTE_ADDR','')
  mq.build('data',tmp)
  mq.pubblica()
  tmp=None
  mq=None

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

    if 'NuovoSqlDatabase' in request.POST:
      print('Richiesto nuovo database')
      request.session['_sqldatabase2edit_'] = 0
      return HttpResponseRedirect(reverse('Sql:SqlDatabaseEdit',args={}))

    if 'AggiornaDbConf' in request.POST and path != None:
      print('Richiesta Aggiornamento db.conf')

      mq = mqtt()
      mq.build('topic','richiesta/database')
      mq.build('richiesta','writedb.conf')
      mq.build('stampa',False)
      tmp = dict()

      data = list()
      for d in value['sqldatabaselist']:
        tmp=dict()
        if d.enabled and not d.tobedeleted:
          print('database',d.nome)
          tmp['do']=d.dominio.nome
          tmp['id']=d.dominio.id
          tmp['db']=d.nome
          tmp['us']=d.username
          tmp['ho']=d.server.server
          tmp['pw']=d.password
          tmp['pa']=path
          data.append(tmp)

      print('data',data)
      mq.build('data',data)
      mq.pubblica()
      tmp=None
      mq=None
      
    if 'LeggiDbConf' in request.POST and path != None:
      print('richiesta lettura db.conf')

      mq = mqtt()
      mq.build('topic','richiesta/database')
      mq.build('richiesta','readdb.conf')
      mq.build('stampa',False)

      data = list()
      q={}
      q['op']='readdbconf'
      q['do']=dominio.nome
      q['id']=dominio.id
      q['pa']=path
      print(q)
      data.append(q)
      print(data)

      mq.build('data',data)
      mq.pubblica()
      tmp=None
      mq=None

    # backup di tutti i db nel dominio
    sqlpath = getConfigurazione('sql:path')
    backuppath = getConfigurazione('sql:backuppath')

    if 'BackupDbDom' in request.POST:
      print('Richiesta backup Database Dominio')

      q = dict()

      database2backup = list()

      for i in value['sqldatabaselist']:
        if i.enabled:
          infodb = dict()
          infodb['db']=i.nome
          infodb['us']=i.username
          infodb['ho']=i.server.server
          infodb['pw']=i.password
          infodb['do']=i.dominio.nome
          infodb['id']=i.dominio.id
          infodb['dbid'] = i.id

          f = i.dominio.ftpuser_set.all().filter(ftpgroup__master=True)

          for singleftp in f: 
            print(dir(singleftp))
            print(singleftp.homedir,singleftp.ftpgroup.l3,singleftp.ftpgroup.directory  % { 'ftp':singleftp.utente,'site':i.dominio.nome })
            #infodb['st'] = x.homedir + "/" + sqlpath
            tmp = singleftp.ftpgroup.directory % { 'ftp':singleftp.utente,'site':i.dominio.nome }
            infodb['st'] =tmp
            infodb['pa'] = "/" + backuppath
            infodb['pr'] = 0 #periodo singolo
            print('infodb',infodb)
            database2backup.append(infodb)
        
      print(q)
      mq = mqtt()
      mq.build('topic','richiesta/database')
      mq.build('richiesta','backupdatabasedominio')
      mq.build('stampa',True)
      mq.build('data',database2backup)
      mq.pubblica()
      tmp=None
      mq=None

    if 'edit' in request.POST:
      print('edit',request.POST.get('edit'))
      request.session['_sqldatabase2edit_'] = request.POST.get('edit')
      return HttpResponseRedirect(reverse('Sql:SqlDatabaseEdit',args={}))

    if 'enable' in request.POST:
      print('enabled in request.POST',request.POST.get('enable'))
      sqlsingledatabase = SqlDatabase.objects.get(pk=request.POST.get('enable'))
      sqlsingledatabase.enabled = True
      #qlsingledatabase.tobedeleted = False
      sqlsingledatabase.save()

      q={}
      q['op']='enable'
      q['db']=sqlsingledatabase.nome
      q['us']=sqlsingledatabase.username
      q['pw']=sqlsingledatabase.password
      q['ho']=sqlsingledatabase.server.server

      mq = mqtt()
      mq.build('topic','richiesta/database')
      mq.build('richiesta','enable_database')
      mq.build('stampa',True)
      mq.build('data',q)
      mq.pubblica()
      tmp=None
      mq=None

    if 'disable' in request.POST:
      print('disabled in request.POST',request.POST.get('disable'))
      sqlsingledatabase = SqlDatabase.objects.get(pk=request.POST.get('disable'))
      if not sqlsingledatabase.locked:
        sqlsingledatabase.enabled = False
        sqlsingledatabase.tobedeleted = False
        sqlsingledatabase.save()
        q={}
        q['op']='disable'
        q['db']=sqlsingledatabase.nome
        q['us']=sqlsingledatabase.username
        q['ho']=sqlsingledatabase.server.server

        #m.publish(c,"Richiesta/Sql","{}".format(json.dumps(q)))
        #m.publish(c,"Messaggio/Sql","{}".format(json.dumps(q)))
        
        mq = mqtt()
        mq.build('topic','richiesta/database')
        mq.build('richiesta','disable_database')
        mq.build('stampa',True)
        mq.build('data',q)
        mq.pubblica()
        tmp=None
        mq=None

    if 'delete' in request.POST:
      print('delete in request.POST',request.POST.get('delete'))
      sqlsingledatabase = SqlDatabase.objects.get(pk=request.POST.get('delete'))
      print("richiesta cancellazione db:",sqlsingledatabase.id)
      if not sqlsingledatabase.locked:
        print("coferma richiesta")
        sqlsingledatabase.enabled = False
        sqlsingledatabase.tobedeleted = True
        sqlsingledatabase.save()
        
        q={}
        q['op']='disable'
        q['db']=sqlsingledatabase.nome
        q['us']=sqlsingledatabase.username
        q['ho']=sqlsingledatabase.server.server

        #m.publish(c,"Richiesta/Sql","{}".format(json.dumps(q)))
        #m.publish(c,"Messaggio/Sql","{}".format(json.dumps(q)))

        mq = mqtt()
        mq.build('topic','richiesta/database')
        mq.build('richiesta','disable_database')
        mq.build('stampa',True)
        mq.build('data',q)
        mq.pubblica()
        tmp=None
        mq=None

    if 'backup' in request.POST:
      print('effettuo backup request.POST',request.POST.get('backup'))
      sqlsingledatabase = SqlDatabase.objects.get(pk=request.POST.get('backup'))
      qq={}
      qq['op']='backup'
      qq['db']=sqlsingledatabase.nome
      qq['us']=sqlsingledatabase.username
      qq['pw']=sqlsingledatabase.password
      qq['ho']=sqlsingledatabase.server.server
      qq['do']=sqlsingledatabase.dominio.nome
      qq['id']=sqlsingledatabase.dominio.id
      qq['dbid']=sqlsingledatabase.id
      qq['pa']=path
      qq['dd']=sqlsingledatabase.id

      f = sqlsingledatabase.dominio.ftpuser_set.all().filter(ftpgroup__master=True)
      for singleftp in f: 
        print(dir(singleftp))
        print(singleftp.homedir,singleftp.ftpgroup.l3,singleftp.ftpgroup.directory  % { 'ftp':singleftp.utente,'site':sqlsingledatabase.dominio.nome })
        #infodb['st'] = x.homedir + "/" + sqlpath
        tmp = singleftp.ftpgroup.directory % { 'ftp':singleftp.utente,'site':sqlsingledatabase.dominio.nome }
        qq['st'] =tmp
        qq['pa'] = "/" + backuppath
        qq['pr'] = 0 #periodo

      mq = mqtt()
      mq.build('topic','richiesta/database')
      mq.build('richiesta','backupdatabasesingolo')
      mq.build('stampa',True)
      mq.build('data',[qq])
      mq.pubblica()
      tmp=None
      mq=None


    if 'phpmyadmin' in request.POST:
      sqlsingledatabase = SqlDatabase.objects.get(pk=request.POST.get('phpmyadmin'))
      #sqlsingledatabase.allowexternal=True
      #sqlsingledatabase.save()
      print('Eseguo PhpMyAdmin',request.POST.get('phpmyadmin'))
      html = HttpResponse('Eseguo php...',status=302)
      html['location']='https://altemica.net/phpmyadmin/index.php'
      html['Target'] = '_blank'

      html.set_cookie('PMA_username',sqlsingledatabase.username,max_age=None)
      html.set_cookie('PMA_password',sqlsingledatabase.password,max_age=None)
      html.set_cookie('PMA_host',sqlsingledatabase.server.server,max_age=None)
      html.set_cookie('PMA_database',sqlsingledatabase.nome,max_age=None)
      return html


  return render(request,"sql.database.list.html",value)

def SqlServerList(request):

  session = getSessionParms(request)
  userauth = session['_userauth_']
  sqlserver2edit = session['_sqlserver2edit_']
  domain2edit = session['_domain2edit_']
  request.session['_from_']="Sql:SqlServerList"

  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)

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['user'] = None
  value['dominio'] = dominio
  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)
  value['CANWRITE']=True #per il momento, questo flag serve a capire se e' un record nuovo

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

    if 'NuovoSqlServer' in request.POST:
      request.session['_sqlserver2edit_'] = 0
      return HttpResponseRedirect(reverse('Sql:SqlServerEdit',args={}))

    if 'enabled' in request.POST:
      print('enabled in request.POST',request.POST.get('enabled'))
      sqlsingleserver = SqlServer.objects.get(pk=request.POST.get('enabled'))
      sqlsingleserver.enabled = True
      sqlsingleserver.save()

    if 'disabled' in request.POST:
      print('disabled in request.POST',request.POST.get('disabled'))
      sqlsingleserver = SqlServer.objects.get(pk=request.POST.get('disabled'))
      sqlsingleserver.enabled = False
      sqlsingleserver.save()

    if 'edit' in request.POST:
      print('edit',request.POST.get('edit'))
      request.session['_sqlserver2edit_'] = request.POST.get('edit')
      return HttpResponseRedirect(reverse('Sql:SqlServerEdit',args={}))

  value['sqlserverlist'] = SqlServer.objects.all().order_by('nome')

  return render(request,"sql.server.list.html",value)

def SqlDatabaseEdit(request):
  session = getSessionParms(request)
  if not '_userauth_' in session:
      return HttpResponseRedirect(reverse('Login:login',args={}))

  userauth = session['_userauth_']
  sqldatabase2edit = session['_sqldatabase2edit_']
  domain2edit = session['_domain2edit_']
  request.session['_from_']="Sql:SqlDatabaseEdit"

  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)

  c = m.start()
  m.publish(c,"Messaggio/Sql","Accesso al DB di {}".format(utenteautorizzato.nome))

  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)
 
  sqldatabase = SqlDatabase()
  value['nuovorecord']=False
  try:
    sqldatabase = SqlDatabase.objects.get(pk=sqldatabase2edit)
  except SqlDatabase.DoesNotExist as dne:
    print("errore nella ricerca del server",sqldatabase2edit)
    value['nuovorecord']=True
    # il database e' vuoto, quindi possiamo inserire username e password predefiniti
    # 1: otteniamo un nome valido per un db, normalizzazione dominio
    # 2: otteniamo un nome normalizzato valido per un db

    dominio_parte_prima_delpunto =  dominio.nome.split('.')[0]
    dominio_parte_dopo_delpunto = dominio.nome.split('.')[1]
    dominio_senza_punto = dominio_parte_prima_delpunto + dominio_parte_dopo_delpunto

    dominio_normalizzato = dominio_senza_punto.translate(''.maketrans('-','_'))
    utente_normalizzato  = dominio_parte_prima_delpunto.translate(''.maketrans('-','_'))

    now = datetime.now().strftime('%f')[:3]

    numero_db_presenti = len(SqlDatabase.objects.filter(dominio=dominio.id))
    sqldatabase.nome =     '{}_db{}'.format(dominio_normalizzato,numero_db_presenti+1)
    sqldatabase.username = '{}U{}'.format(utente_normalizzato,now)
    sqldatabase.password = getPassword()
    sqldatabase.dominio = dominio
    sqldatabase.enabled = True
    sqldatabase.tobedeleted = False
    sqldatabase.locked = False
    sqldatabase.password_change_enabled=True
    sqldatabase.inbackup=False
    sqldatabase.datebackup=None

    #sqldatabase.server = getConfigurazione('sql server default')

    print(dominio_parte_prima_delpunto,dominio_normalizzato,utente_normalizzato,now,numero_db_presenti)
    print(sqldatabase.nome,sqldatabase.username)

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

    if 'Ritorna' in request.POST:
      request.session['_sqldatabase2edit_'] = sqldatabase2edit
      return HttpResponseRedirect(reverse('Sql:SqlDatabaseList',args={}))

    
    # step: procuratori la riga ftp master
    listaftp = sqldatabase.dominio.ftpuser_set.all()
    path = None
    for f in listaftp:
      if f.ftpgroup.master:
        path = f.homedir
        print(f.homedir)

    # step: invio comando mqtt
    if 'AggiornaDbConf' in request.POST and path != None:
      print("Aggiorno il db")
      q={}
      q['op']='writedbconf'
      q['db']=sqldatabase.nome
      q['us']=sqldatabase.username
      q['ho']=sqldatabase.server.server
      q['pw']=sqldatabase.password
      q['pa']=f.homedir
      q['do']=sqldatabase.dominio.nome
      q['id']=sqldatabase.dominio.id

      #m.publish(c,"Richiesta/Sql","{}".format(json.dumps(q)))
      #m.publish(c,"Messaggio/Sql","{}".format(json.dumps(q)))

      mq = mqtt()
      mq.build('topic','richiesta/database')
      mq.build('richiesta','writedb.conf')
      mq.build('stampa',True)
      mq.build('data',q)
      mq.pubblica()
      tmp=None
      mq=None


    formsqldatabase=formSqlDatabase(request.POST)
    if formsqldatabase.is_valid():
      print('formsqldatabase.is_valid',formsqldatabase.is_valid())

      oldsqldatabase = sqldatabase #faccio una copia del record per confrontarmi.

      if not sqldatabase.server_id:
        sqldatabase.server_id = formsqldatabase.cleaned_data.get('server')

      # sqldatabase.dominio = xxxx 
      sqldatabase.locked = formsqldatabase.cleaned_data.get('locked')
      print('sqldatabase.locked',sqldatabase.locked)

      if value['nuovorecord']:
        sqldatabase.nome = formsqldatabase.cleaned_data.get('nome')
 
      if not sqldatabase.locked:
        sqldatabase.username = formsqldatabase.cleaned_data.get('username')
        oldpassword = sqldatabase.password
        sqldatabase.password = formsqldatabase.cleaned_data.get('password')
        if oldpassword != sqldatabase.password:
          sqldatabase.password_last_update = datetime.now()
        
      sqldatabase.enabled = formsqldatabase.cleaned_data.get('enabled')
      sqldatabase.tobedeleted = formsqldatabase.cleaned_data.get('tobedeleted')

      if sqldatabase.tobedeleted:
        sqldatabase.enabled = False

      sqldatabase.nota = formsqldatabase.cleaned_data.get('nota')
      sqldatabase.mail = formsqldatabase.cleaned_data.get('mail')
      print('sqldatabase.mail',sqldatabase.mail)
      sqldatabase.aggiornamento = datetime.now()
      sqldatabase.server_id = formsqldatabase.cleaned_data.get('server')
      noneseguire = formsqldatabase.cleaned_data.get('noneseguire')
      print('stato di :noneseguire:',noneseguire)
      sqldatabase.save()
      print('database salvato')

      # creato o cambiato nome utente
      if sqldatabase.username != oldsqldatabase.username:
        pass
      else:
        pass
      # creata o cambiata password
      if sqldatabase.password != oldsqldatabase.password:
        pass
      else:
        pass

      if not noneseguire:
        # creato nuovo db
        if value['nuovorecord']:
          q={}
          q['op']='create'
          q['db']=sqldatabase.nome
          q['us']=sqldatabase.username
          q['pw']=sqldatabase.password
          q['ho']=sqldatabase.server.server

          #m.publish(c,"Richiesta/Sql","{}".format(json.dumps(q)))
          #m.publish(c,"Messaggio/Sql","{}".format(json.dumps(q)))

          mq = mqtt()
          mq.build('topic','richiesta/database')
          mq.build('richiesta','create_database')
          mq.build('stampa',True)
          mq.build('data',q)
          mq.pubblica()
          tmp=None
          mq=None

        # abilitato accesso al db
        if sqldatabase.enabled:
          q={}
          q['op']='enable'
          q['db']=sqldatabase.nome
          q['us']=sqldatabase.username
          q['ho']=sqldatabase.server.server
          q['pw']=sqldatabase.password

          #m.publish(c,"Richiesta/Sql","{}".format(json.dumps(q)))
          #m.publish(c,"Messaggio/Sql","{}".format(json.dumps(q)))

          mq = mqtt()
          mq.build('topic','richiesta/database')
          mq.build('richiesta','enable_database')
          mq.build('stampa',True)
          mq.build('data',q)
          mq.pubblica()
          tmp=None
          mq=None
        else:
          q={}
          q['op']='disable'
          q['db']=sqldatabase.nome
          q['us']=sqldatabase.username
          q['ho']=sqldatabase.server.server

          #m.publish(c,"Richiesta/Sql","{}".format(json.dumps(q)))
          #m.publish(c,"Messaggio/Sql","{}".format(json.dumps(q)))

          mq = mqtt()
          mq.build('topic','richiesta/database')
          mq.build('richiesta','disable_database')
          mq.build('stampa',True)
          mq.build('data',q)
          mq.pubblica()
          tmp=None
          mq=None

        # cancella il database
        if sqldatabase.tobedeleted:
          q={}
          q['op']='delete'
          q['db']=sqldatabase.nome
          q['us']=sqldatabase.username
          q['ho']=sqldatabase.server.server

          #m.publish(c,"Richiesta/Sql","{}".format(json.dumps(q)))
          #m.publish(c,"Messaggio/Sql","{}".format(json.dumps(q)))

          mq = mqtt()
          mq.build('topic','richiesta/database')
          mq.build('richiesta','delete_database')
          mq.build('stampa',True)
          mq.build('data',q)
          mq.pubblica()
          tmp=None
          mq=None

      sm = ServizioMail()
      sql_notifica = getConfigurazione('sql:notifica')
      sql_notifica = re.split(',| ',sql_notifica)
      sm.set_listadestinatari(sql_notifica)

      if formsqldatabase.cleaned_data.get('mail_send'):
        mailweb = formsqldatabase.cleaned_data.get('mail')
        mailweb = re.split(',| ',mailweb)
        sm.add_listadestinatari(mailweb)

      # questo dovrebbe essere il profilo per la gestione via mail.
      #sm.add_listadestinatari(getConfigurazione('service'))
  
      #recuperiamo il template
      template = Template.objects.get(pk=getConfigurazione('sql:template'))
      template_soggetto = template.soggetto
      sm.set_soggetto(template_soggetto)
      template_oggetto = template.oggetto
      sm.set_oggetto(template_oggetto)

      template_dati = {}
      template_dati['sqldatabase'] = sqldatabase
      sm.set_data(template_dati)

      sqljs = {}
      sqljs['service'] = 'SQL'
      sqljs['nome'] = sqldatabase.nome
      sqljs['server'] = sqldatabase.server.server
      sqljs['username'] = sqldatabase.username
      sqljs['password'] = sqldatabase.password
      sqljs['enabled'] = sqldatabase.enabled
      sqljs['locked' ] = sqldatabase.locked
      sqljs['tobedeleted'] = sqldatabase.tobedeleted
      sm.set_json(sqljs) 

      sm.send()

      return  HttpResponseRedirect(reverse('Sql:SqlDatabaseList',args={}))
    else:
      print('formsqldatabase.errors',formsqldatabase.errors)

  tmp = {}
  tmp['nome'] = sqldatabase.nome
  tmp['dominio'] = sqldatabase.dominio_id
  tmp['server'] = sqldatabase.server_id
  tmp['username'] = sqldatabase.username
  tmp['password'] = sqldatabase.password
  tmp['enabled'] = sqldatabase.enabled
  tmp['tobedeleted'] = sqldatabase.tobedeleted
  tmp['locked'] = sqldatabase.locked
  print('locked',sqldatabase.locked)
  tmp['quota'] = sqldatabase.quota
  tmp['password_last_update'] = sqldatabase.password_last_update
  tmp['creazione'] = sqldatabase.creazione
  tmp['aggiornamento'] = sqldatabase.aggiornamento
  tmp['nota'] = sqldatabase.nota
  tmp['mail'] = sqldatabase.mail
  print('mail caricata',sqldatabase.mail)
  

  value['formsqldatabase'] = formSqlDatabase(tmp)
  value['sqldatabase'] = sqldatabase
  value['sqlserver'] = SqlServer.objects.all().filter(enabled=1)

  return render(request,"sql.database.edit.html",value)

def SqlServerEdit(request):
 
  session = getSessionParms(request)
  userauth = session['_userauth_']
  sqlserver2edit = session['_sqlserver2edit_']
  domain2edit = session['_domain2edit_']
  request.session['_from_']="Sql:SqlServerEdit"

  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)

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  value['user'] = None
  value['dominio'] = dominio
  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)
  value['CANWRITE']=True #per il momento, questo flag serve a capire se e' un record nuov

  sqlserver = SqlServer()

  try:
    sqlserver = SqlServer.objects.get(pk=sqlserver2edit)
  except SqlServer.DoesNotExist as dne:
    print("errore nella ricerca del server",sqlserver2edit)

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

    if 'Ritorna' in request.POST:
      request.session['_sqlserver2edit_'] = sqlserver2edit
      return HttpResponseRedirect(reverse('Sql:SqlServerList',args={}))

    formsqlserver = formSqlServer(request.POST)
    if formsqlserver.is_valid():
      print('formsqlserver.is_valid',formsqlserver.is_valid())

      sqlserver.nome = formsqlserver.cleaned_data.get('nome')
      sqlserver.server = formsqlserver.cleaned_data.get('server')
      sqlserver.adminuser = formsqlserver.cleaned_data.get('adminuser')
      sqlserver.adminpass = formsqlserver.cleaned_data.get('adminpass')
      sqlserver.enabled = formsqlserver.cleaned_data.get('enabled')
      sqlserver.nota = formsqlserver.cleaned_data.get('nota')
      sqlserver.save()


  tmp = {}
  tmp['nome'] = sqlserver.nome
  tmp['server'] = sqlserver.server
  tmp['adminuser'] = sqlserver.adminuser
  tmp['adminpass'] = sqlserver.adminpass
  tmp['enabled'] = sqlserver.enabled
  tmp['nota'] = sqlserver.nota

  value['formsqlserver'] = formSqlServer(tmp)

  return render(request,"sql.server.edit.html",value)

def SqlShow(request):
  '''
  questa pagina serve per fornire le informazioni per attivare il nuovo db.
  ho pensato che ogni aggiornamento, creazione e quant'altro memorizzano un timestamp.
  la funzione legge l'ultimo timestamp memorizzato. se e' anteriore a quelli registrati nei singoli record,
  li esegue e aggiorna il timestamp relativo.
  '''

  return render(request,"nomefile",value)

#effettua il backup di tutti i db (oppure di un singolo di, suddiviso per periodo 
def SqlDatabaseBackup(request,database=0,periodo=0):
  # tipo: vedere in urls.py: indica il tipo di backup da effettuare (q,s,m)
  c = m.start()
  m.publish(c,"Messaggio/Sql","Eseguo Backup di tutti i DB")

  '''
  cadenza={}
  cadenza[0]='Giorno'
  cadenza[1]='Settimana'
  cadenza[2]='Mese'
  cadenza[10]='Singolo'
  '''

  d = None
  alldb = False
  if not database:
    d = SqlDatabase.objects.all().filter(enabled=True)
    alldb = True
  else:
    d = SqlDatabase.objects.all().filter(pk=database)

  value = {}
  value['sqldatabaselist']=d
  value['sqldatabasecount'] = len(d)

  print("Database da sottoporre a backup",len(d))

  sqlpath = getConfigurazione('sql:path')
  backuppath = getConfigurazione('sql:backuppath')

  q = dict()
  if not database:
    q['op'] = 'backupDbAll'
  else:
    q['op'] = 'backupDbOne'

  database2backup = list()

  q['pr'] = periodo 

  for i in d:
    print('database: ',i.nome)

    infodb = dict()
    infodb['db']=i.nome
    infodb['us']=i.username
    try: 
      infodb['ho']=i.server.server
    except i.server.DosNotFound:
      print ("manca il db per: ",i.nome)
      m.publish(c,"Messaggio/Sql","Manca Server per db: {}".format(infodb['db']))
      continue
    infodb['pw']=i.password
    infodb['do']=i.dominio.nome
    infodb['id']=i.dominio.id
    infodb['dbid'] = i.id

    f = i.dominio.ftpuser_set.all().filter(ftpgroup__master=True)

    print('lista FTP per dominio',len(f))
    
    for singleftp in f: 
      print(singleftp.homedir,singleftp.ftpgroup.l3,singleftp.ftpgroup.directory % { 'ftp':singleftp.utente,'site':i.dominio.nome })
      #infodb['st'] = x.homedir + "/" + sqlpath
      tmp = singleftp.ftpgroup.directory % { 'ftp':singleftp.utente,'site':i.dominio.nome }
      infodb['st'] =tmp
      if alldb:
        infodb['pa'] = "/" + sqlpath
      else: 
        infodb['pa'] = "/" + backuppath
      infodb['pr'] = periodo
      print('infodb',infodb)
      database2backup.append(infodb)
        
  q['db'] = database2backup

  mq = mqtt()
  mq.build('topic','richiesta/database')
  mq.build('richiesta','backupdatabaseperiodico')
  mq.build('nota','cliid=22')
  mq.build('periodo',periodo)
  mq.build('stampa',True)


  mq.build('data',database2backup)
  mq.pubblica()
  tmp=None
  mq=None

  return render(request,"sql.database.backup.html",value)