PasswordGenerator/generator.go

package mod

import (
  "fmt"
  "os"
  "bufio"
  "container/list"
  "math/rand"
  "time"
  "unicode"
  "strings"
  "strconv"
)


func caricaFile(file_da_leggere string) *os.File {
  /*
  lettura file.
  nel caso di errore, ritorna nil
  */ 

  /*
  verificare anche che il file non sia qualche altra cosa
  */
  fi,err := os.Stat(file_da_leggere)
  if err != nil {
    fmt.Println("Errore analisi file",err)
    return nil
  }
 
  if !fi.Mode().IsRegular() { 
    fmt.Println(" cazzo - directory")
    return nil       
  }

  /*
  apertura quindi del file
  */
  f,err := os.Open(file_da_leggere)
  if err != nil {
    fmt.Println("Errore apertura files",err)
    return nil
  }


  // fmt.Println("Valore tornato:",f)
  return f
}

func scansioneFile(result *os.File) *list.List {
  /*
  effettua la lettura del file attraverso
  un apposito buffer.
  */
  l := list.New()
  fs := bufio.NewScanner(result)

  for  fs.Scan() {
  /* 
  l è una lista che viene 
  alimentata leggendo il file di testo bufferizzato
  */
    l.PushBack(fs.Text())
  }

  if err := fs.Err(); err != nil {
    fmt.Println("Errore finale:",err)
    return nil 
  }

  return l
}

func returnRandom(l int) int {
  /*
  ritorna un numero random da 0 a l
  ogni volta resetta il contatore
  */
  r1 := rand.NewSource(time.Now().UnixNano())
  s1 := rand.New(r1)
  return s1.Intn(l)+1
}


func returnStringCharUp(stringa string) string {
  /*
  prende una stringa e cambia lo stato di un carattere (da lower a upper e viceversa)
  */
  lunghezza := len(stringa)
  random := returnRandom(lunghezza) -1
  s := []byte(stringa)
  
  
  if unicode.IsUpper(rune(s[random])) {
    s[random]=byte(unicode.ToLower(rune(s[random])))
  } else {
    s[random]=byte(unicode.ToUpper(rune(s[random])))
  }
  return string(s)
  
}

func returnStringToLower(stringa string) string {
  /*
  ritorna la stringa passata in lower.mode
  */
  return strings.ToLower(stringa)
}

func estraeDaFile(filedaleggere string) string {
  /*
  effettua la lettura vera e propria del file
  */
  result := caricaFile(filedaleggere)
  if result == nil {
    fmt.Printf("Errore di lettura file '%s', esco.\n",filedaleggere)
    os.Exit(98)
  }
  /*
  effettua la scansione e il caricamento in memoria
  */
  l := scansioneFile(result)
  if l == nil {
    fmt.Println("Errore di lettura, esco.")
    return ""
  }
  defer result.Close()

  // estrae un valore a caso da 0 alla lunghezza del file.
  position := returnRandom(l.Len())

  counter := 0
  risultato1 := "               "

  /*
  estrae una riga dal file in base a 'position'
  */
  for e := l.Front(); e != nil; e = e.Next() {
    if position == counter {
      risultato1 = fmt.Sprintf("%s",e.Value)
    }
    counter++
  }
  return risultato1
  } 

func RunNumber(lunghezza int,verbose bool) string {
  /*
  ritorna il numero di elementi indicati racchiusi in una string
  */

  risultato := ""
  fmt.Println("Verbose",verbose)

  for i:=0;i<lunghezza;i++ {
	  risultato = risultato + strconv.Itoa(returnRandom(9))
  }
  return risultato
}
    
func Run(filedaleggere string, verbose bool) string {
  /*
  vengono effettuati diversi passaggi:
    lettura del file
    passaggio della frase estratta a tutto minuscolo
    scelta random di una lettera da far diventare maiuscola
    estrazione di simboli
    esrazione di numeri
  */

  fmt.Println("Verbose",verbose)

  risultato1 := estraeDaFile(filedaleggere)
  risultato1 = returnStringToLower(risultato1)
  risultato1 = returnStringCharUp(risultato1)
   
  /* estrae un simbolo */
  var simboli string = "\"'!?,.;:#%"

  simbolo1 := simboli[returnRandom(len(simboli))-1]
  simbolo2 := simboli[returnRandom(len(simboli))-1]
  
  elementi := []int{returnRandom(9),returnRandom(9),returnRandom(9),returnRandom(9)}

  stringa := fmt.Sprintf("%d%d%c%s%c%d%d",elementi[0],elementi[1],simbolo1,risultato1,simbolo2,elementi[2],elementi[3])

  return stringa

  // qui ci sarebbe da aggiungere un sistema per personalizzare il formato  sulla base della stringa che dovrebbe venir passata
}