dashboard4/login/views.py

from django.shortcuts import render
#from supporto import managepassword
from .forms import *
from configurazione.views import *
from sicurezza.views import *
import crypt
import random
import string
import uuid
from datetime import date,datetime
from comunicazioni.views import *
from configurazione.views import *
from supporto import managepassword
import django as dd

from mqtt.views import mqtt

# Create your views here.

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

def login(request):

  request.session.flush()
  c={}
  c['login']=LoginUser()


  if getConfigurazione('OffLine')=='1':
    return render(request,'offline.html')

  if request.method=="POST":
    result = LoginUser(request.POST)
    if result.is_valid():
      username = result.cleaned_data['username']
      password = result.cleaned_data['password']

      mq = mqtt()
      mq.topic('messaggio')
      mq.richiesta('login')
      mq.stampa(False)
      mq.demo(False)

      #mq.build('topic','messaggio')
      #mq.build('richiesta','login')

      tmp = dict()
      tmp['login'] = username
      tmp['remote'] = request.META.get('REMOTE_ADDRESS')
      tmp['forwarder' ] = request.META.get('HTTP_X_FORWARDER_FOR','')
      tmp['host'] = request.META.get('REMOTE_ADDR','')
      mq.data(tmp)

      mq.pubblica()
      tmp=None

      #ottenuti i dati dalla form, provvediamo a:
      # 1: verificare il login
      # 2: inviare mail di notifica a chi ha fatto l'accesso
      # 3: attivare o impostare le voci di menu' valide per il livello dell'utente.

      # 1.1 lo username deve essere diviso in due per estrapolare dominio e mail
      try:
        (mail,domain) = username.split('@')
      except ValueError as ve:
        (mail,domain) = ('','')

      print('dati inseriti',mail,domain)

      # 1.2 ricerchiamo l'utente/dominio
      record = User.objects.filter(mail=mail,domain__nome=domain,enabled=1,domain__enabled=1)
      print('numero di record:',len(record))
      if record:
        # 1.2.1: verifica la password
        print(record[0].crypt)
        codedpassword = crypt.crypt(password,record[0].crypt)
        if codedpassword == record[0].crypt:

          print("accepted:",record[0].id) #primo controllo superato.
          request.session['_userauth_'] = record[0].id

          record[0].accesso = datetime.now()
          print('ultimo_accesso',record[0].accesso)
          print('tipo record',type(record[0]))
          record[0].save()
          print('session timeleft',request.session.get_expiry_age())
          request.session.set_expiry(3600)

          # invia la notifica all'utente che si e' collegato.
          sm = ServizioMail()
          sm.set_rcptto(record[0].mail+"@"+record[0].domain.nome)
          template=Template.objects.get(pk=getConfigurazione("AccessoPannello"))
          sm.set_oggetto(template.oggetto)
          sm.set_soggetto(template.soggetto)
          dictdict={}
          dictdict['utente'] = record[0]
          dictdict['data'] = datetime.now()
          dictdict['connessione'] = request.META #consente di acquisire dati di connessione.
          sm.set_data(dictdict)
          sm.send() 

          #invia la notifica all'amministratore.
          # le email sono le stesse, cambia il template in modo da inviare notifiche diversificate
          #sm = ServizioMail()
          #sm.set_rcptto([getConfigurazione('mail:notifica'),])
          #template=Template.objects.get(pk=getConfigurazione("AccessoPannello:admin"))
          #sm.set_oggetto(template.oggetto)
          #sm.set_soggetto(template.soggetto)
          #dictdict={}
          #dictdict['utente'] = record[0]
          #dictdict['data'] = datetime.now()
          #dictdict['connessione'] = request.META #consente di acquisire dati di connessione.
          #print("::",dictdict['connessione'])
          #sm.set_data(dictdict)
          #sm.send() 

          return HttpResponseRedirect(reverse('Login:welcome',args={}))
        else:
          print('login failed',username)
      else:
          print('record non trovato',username)

  return render(request,'login.html',c)

def welcome(request):

  print('session timeleft',request.session.get_expiry_age())

  session = getSessionParms(request)
  try:
    userauth = session['_userauth_']
  except KeyError:
    return HttpResponseRedirect(reverse("Login:login",args={}))
  request.session['_from_']="Login:welcome"

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

  securitylevel = getSecurityLevel(record.securitylevel_id)

  value={}
  value['utenteautorizzato'] = record
  value['securitylevel'] = securitylevel
  value['versione'] = dd.get_version()
  print("id",record.securitylevel_id)

  securitylevel = getSecurityLevel(record.securitylevel_id)
  securityrow = getSecurityRow(securitylevel.id)

  value['securityrow'] = securityrow
  #print(securityrow)
  #for i in securityrow:
  #  try:
  #    print("-{}-".format(i.securityoptions.id),)
  #  except SecurityOptions.DoesNotExist as dne:
  #    print("-{}-".format('-!-'))
  value['securityparms'] = {'utente':record.id,'dominio':record.domain.id }
  value['securityrowLen'] = len(securityrow)
  value['navbar']=True

  note = Note.objects.all().filter(livello__gte=securitylevel).filter(timestamp__gte=record.accesso).order_by('timestamp')
  if len(note) > 3: note = note[:3]

  value['note'] = note
  return render(request,'welcome.html',value)

def recupero(request):

  if request.method == 'POST':
    tasto = request.session['button_recover']
    if tasto in request.POST:
      campo = request.session['campo_recover']
      if campo in request.POST:
        richiesta = request.POST.get(campo)
        if richiesta: #possiamo provvedere al resto
          try:
            (mail,dominio) = richiesta.split('@')
          except ValueError as ve:
            return HttpResponseRedirect(reverse('Login:login',args={}))

          utente = User.objects.filter(mail=mail).filter(domain__nome=dominio)
          if utente:
            #possiamo inviare mail
            print("spedizione: {}".format(utente[0].mail_di_recupero))
            if utente[0].mail_di_recupero:
              uuidvalue = uuid.uuid1()
              print(uuidvalue)
              utente[0].chiave_temporanea=uuidvalue
              utente[0].save()

              sm = ServizioMail()
              mail_utente = [] #vediamo la lista utente
              mail_utente.append('{}'.format(utente[0].mail_di_recupero))
              sm.set_rcptto(mail_utente)

              #recuperiamo il template
              template = Template.objects.get(pk=getConfigurazione('mail_password_recover'))
              template_soggetto = template.soggetto
              sm.set_soggetto(template_soggetto)
              template_oggetto = template.oggetto
              sm.set_oggetto(template_oggetto)

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

              sm.send_mail()
    value = {}
    return render(request,'recupero.done.html',value)

  key=str(random.randint(0,9999999999))
  value={}
  value['button'] = "t{}".format(key)
  value['campo'] = "c{}".format(str(random.randint(0,999999999999)))
  request.session['button_recover'] = value['button']
  request.session['campo_recover'] = value['campo']

  return render(request,'recupero.html',value)

def change(request,code=None):
  if not code:
    return HttpResponseRedirect(reverse('Login:login',args={}))

  '''
  il codice viene indicato nella mail indicata al cliente.
  ricevuto il codice, si cerca il record mail corretto
  una volta trovato, si chiedono le nuove credenziali
  si salvano e si resetta il codice a null
  '''

  try:
    record = User.objects.get(chiave_temporanea=code)
  except User.DoesNotExist as dne:
    return HttpResponseRedirect(reverse('Login:login',args={}))

  nc = NuoveCredenziali()

  if request.method == 'POST':
    nc = NuoveCredenziali(request.POST)
    if nc.is_valid():
      record.clear = nc.cleaned_data.get('password1')
      record.crypt =  managepassword.GeneraPassword(record.clear)
      t = date.today()
      record.last_password_update = t.strftime("%Y-%m-%d")
      record.chiave_temporanea=''
      record.save()
      return render(request,'change.done.html')
    else:
      nc = NuoveCredenziali(request.POST)
  else:
    nc = NuoveCredenziali(request.POST)

  value={}
  value['mail_password_length'] = getConfigurazione('mail_password_length')
  value['nc']=nc

  return render(request,'change.html',value)