dashboard4/causali/views.py

from django.shortcuts import render
from .models import *
from .forms import *

from sicurezza.views import *
from logger.views import *
from configurazione.views import *

from django.db.models import Sum
from .templatetags.calctags import *

def CausaliList(request):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  request.session['_from_']="Causali:CausaliList"

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

  causali = Causale.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)

  print(getCausaliOptions(12))

  if request.method == 'POST':
    if 'Ordine_by_id' in request.POST:
      request.session['_causali_order'] = 'oi'
      value['causali'] = Causale.objects.all().order_by('id')

    elif 'Ordine_by_causale' in request.POST:
      request.session['_causali_order'] = 'oc'
      value['causali'] = Causale.objects.all().order_by('nome')

    elif 'Ordine_by_ordine' in request.POST:
      request.session['_causale_order'] = 'oo'
      value['causali'] = Causale.objects.all().order_by('ordine')

    if 'causaleedit' in request.POST:
      request.session['_causale2edit_'] = request.POST.get('causaleedit')
      print('causale richiesta:',request.session['_causale2edit_'])
      return HttpResponseRedirect(reverse('Causali:CausaliEdit',args={}))

  return render(request,'Causali.List.html',value)

def CausaliEdit(request):
  session = getSessionParms(request)
  userauth = session['_userauth_']
  causale2edit = session['_causale2edit_']
  print('causale2edit',causale2edit)
  request.session['_from_']="Causali:CausaliList"

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

  value={}
  value['utenteautorizzato'] = utenteautorizzato
  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)
  from_email = getConfigurazione('mail:notifica:from')
  value['from_email'] = from_email
  value['template'] = Template.objects.all().filter(enabled=True)
  value['servizi'] = Servizi.objects.all().filter(enabled=True)

  try:
    causale = Causale.objects.get(pk=causale2edit)
    print("causale recuperata:",causale.id)
  except Causale.DoesNotExist as dne:
    print("causale non trovata")
    causale = Causale()
    causale.valore = 0

  if not causale.from_email:
    causale.from_email = getConfigurazione('mail:notifica:from')

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

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

    fc = formCausale(request.POST)
    fc.update()

    if fc.is_valid():
      print('fc valida',causale.id)
      
      causale.nome = fc.cleaned_data.get('nome')
      causale.valore = fc.cleaned_data.get('valore')
      print(causale.valore)
      causale.enabled = fc.cleaned_data.get('enabled')

      causale.from_email = fc.cleaned_data.get('from_email')

      causale.send_email_user = fc.cleaned_data.get('send_email_user')

      causale.send_email_account = fc.cleaned_data.get('send_email_account')
      causale.send_email_admin = fc.cleaned_data.get('send_email_admin')
      causale.send_email_other = fc.cleaned_data.get('send_email_other')

      causale.to_account = fc.cleaned_data.get('to_account')
      causale.to_admin = fc.cleaned_data.get('to_admin')
      causale.to_other = fc.cleaned_data.get('to_other')

      causale.date_expire_contract = fc.cleaned_data.get('date_expire_contract')
      causale.date_expire_registrar = fc.cleaned_data.get('date_expire_registrar')
      causale.check_registrar = fc.cleaned_data.get('check_registrar')
      causale.sms = fc.cleaned_data.get('sms')
      causale.renew_request = fc.cleaned_data.get('renew_request')
      causale.renew_authorized = fc.cleaned_data.get('renew_authorized')
      causale.close_request = fc.cleaned_data.get('close_request')
      causale.ordine = fc.cleaned_data.get('ordine')
      causale.domain_tobedeleted = fc.cleaned_data.get('domain_tobedeleted')

      if 'template' in fc.cleaned_data and int(fc.cleaned_data.get('template')) > 0:
        print('template presente:',fc.cleaned_data.get('template'))
        causale.template_id = fc.cleaned_data.get('template')

      #causale.template_admin_id = fc.cleaned_data.get('template_admin')
      #causale.template_account_id = fc.cleaned_data.get('template_account')
      #causale.template_other_id = fc.cleaned_data.get('template_other')
      
      if 'domain_service' in fc.cleaned_data and int(fc.cleaned_data.get('domain_service')) > 0:
        print('domain_service presente:',fc.cleaned_data.get('domain_service'))
        causale.domain_service_id = fc.cleaned_data.get('domain_service')
       
      print('Causale.id',causale.id)
      print(dir(causale))
      causale.save()
    else:
      print('fc.is_valid saltato')
      print(fc.errors)

  else:
    temp = {}
    temp['nome'] = causale.nome
    temp['valore'] = causale.valore
    temp['enabled'] = causale.enabled
    temp['ordine'] = causale.ordine

    temp['from_email'] = causale.from_email

    temp['send_email_user'] = causale.send_email_user
    temp['send_email_admin'] = causale.send_email_admin
    temp['send_email_account'] = causale.send_email_account
    temp['send_email_other' ] = causale.send_email_other

    temp['to_admin'] = causale.to_admin
    temp['to_account'] = causale.to_account
    temp['to_other'] = causale.to_other

    temp['template'] = causale.template_id
    temp['template_admin'] = causale.template_admin_id
    temp['template_account'] = causale.template_account_id
    temp['template_other'] = causale.template_other_id

    temp['date_expire_contract'] = causale.date_expire_contract
    temp['date_expire_registrar'] = causale.date_expire_registrar
    temp['check_registrar'] = causale.check_registrar
    temp['sms'] = causale.sms
    temp['renew_request'] = causale.renew_request
    temp['renew_authorized'] = causale.renew_authorized
    temp['close_request'] = causale.close_request
    temp['ordine'] = causale.ordine
    temp['domain_tobedeleted'] = causale.domain_tobedeleted

    try:
      temp['domain_service'] = causale.domain_service_id
    except Servizi.DoesNotExist as dnf:
      temp['domain_service'] = 0

    print(temp)

    fc = formCausale(temp)
    fc.update()

  value['formcausale'] = fc

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

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>

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

  print('dominio trovato:',domini)

  listadomini=[]
  for d in domini:
    #l'avviso viene avviato quando viene raggiunto il limite di registrazione indicato
    if int((d.date_expire_registrar - date.today()).days) < int(getConfigurazione('registrar-giorni-preavviso')):
      print("scadenze: ",d.domain,d.date_expire_registrar,(d.date_expire_registrar - date.today()).days)
      # verifica eventuali causali gia'  registrate e presenti
      listadomini.append(d)

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

  # invia la mail
  for i in listadomini:
    sm = ServizioMail()
    print(i)

    print(i.domain)
    # 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:notifica'))

    dictdict={}
    dictdict['dominio'] = i.__dict__


    sm.set_rcptto(listadestinatari)
    sm.set_soggetto(template.soggetto)
    sm.set_oggetto(template.oggetto)
    sm.set_data(dictdict)
    if demo==1:  sm.send_mail()

      # ignoro la verifica dei contatti, tanto stiamo andando solo con la voce nel dominio

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

def getCausaliOptions(causale=None):
  if not causale: return causale

  causali = None
  try:
    causali = Causale.objects.all().get(id=causale)
  except Causale.DoesNotExist as dne:
    print('La causale indicata non esiste')
    print(dne)

  if not causali.enabled: return None

  # abbiamo trovato la causale
  # ora dobbiamo estrarre l'elenco delle righe su cui lavorare.

  cr = causali.causalerow_set.filter(enabled=True)
  print('numero di righe trovate',len(cr))
  for c in cr:
    print(c.id,c.causaleOptions.nome,c.causaleOptions.tag)

  return cr