inicial

cnpj.go

@@ -0,0 +1,79 @@
+package utils
+
+import(
+    "fmt"
+    "regexp"
+    "strconv"
+)
+
+func cnpjDigitoVerificado(cnpj []int, b int) (dv int) {
+    i, j, soma, limit := 0, 4 + b, 0, 11 + b
+
+    for ; i < limit; i++ {
+        soma +=  cnpj[i] * j;
+        if j == 2 {  j = 9 } else { j -= 1 }
+    }
+    resto := soma % 11
+    if resto < 2 { dv = 0  } else { dv = 11 - resto }
+    return
+}
+
+func somenteNumeros(c string, vsize int) ([]int, error) {
+    tmp   := regexp.MustCompile("[^0-9]").ReplaceAll([]byte(c), []byte("") )
+    size  := len(tmp)
+    cnpji := make([]int, size)
+    // Valida tamanho
+    if len(cnpji) != vsize {
+        return cnpji, fmt.Errorf("Tamanho deve conter %d digitos sem caracteres especiais", vsize);
+    }
+
+    for i, val := range tmp {
+        cnpji[i], _ = strconv.Atoi(string(val))
+    }
+
+    return cnpji, nil
+}
+
+func ValidarCnpj(cnpj string) error {
+
+    cnpji, err := somenteNumeros(cnpj, 14)
+    if err != nil {
+        return err
+    }
+
+    // Valida primeiro dígito verificador
+    if cnpji[12] == cnpjDigitoVerificado(cnpji, 1) {
+        // Valida segundo dígito verificador
+        if cnpji[13] == cnpjDigitoVerificado(cnpji, 2) {
+            return nil
+        }
+    }
+    return fmt.Errorf("CNPJ inválido");
+}
+
+
+func cpfDigitoVerificado(cpf []int, b int) (dv int) {
+    soma, ini := 0, 9 + b
+    for i := ini; i > 1; i -- {
+        soma += i * cpf[ini - i]
+    }
+    resto := soma * 10%11
+    if resto == 10 { dv = 0 } else { dv = resto }
+    return
+}
+
+func ValidarCpf(cpf string) error {
+    cpfi, err := somenteNumeros(cpf, 11)
+    if err != nil {
+        return err
+    }
+
+    // Valida primeiro dígito verificador
+    if cpfi[9] == cpfDigitoVerificado(cpfi, 1) {
+        // Valida segundo dígito verificador
+        if cpfi[10] == cpfDigitoVerificado(cpfi, 2) {
+            return nil
+        }
+    }
+    return fmt.Errorf("CPF inválido");
+}

cnpj_test.go

@@ -0,0 +1,33 @@
+package utils
+
+import "testing"
+
+func TestCNPJValido(t *testing.T) {
+    if err := ValidarCnpj("17.060.704/0001-52"); err != nil {
+        t.Fatal(err)
+    }
+}
+
+func TestCNPJValido2(t *testing.T) {
+    if err := ValidarCnpj("24.871.503/0001-09"); err != nil {
+        t.Fatal(err)
+    }
+}
+
+func TestCNPJInvalido(t *testing.T) {
+    if err := ValidarCnpj("24.871.503/0001-03"); err == nil {
+        t.Fatal("Falha ao validar o cnpj")
+    }
+}
+
+func TestCPF(t *testing.T) {
+    if err := ValidarCpf("529.982.247-25"); err != nil {
+        t.Fatal(err)
+    }
+}
+
+func TestCPFInvalido(t *testing.T) {
+    if err := ValidarCpf("529.982.247-35"); err == nil {
+        t.Fatal(err)
+    }
+}

utils.go

@@ -0,0 +1,176 @@
+package utils
+
+import(
+    "fmt"
+    //"fmt"
+    //"html"
+    //"net/mail"
+    "os"
+    "time"
+    "bytes"
+    "regexp"
+    "os/exec"
+    //"reflect"
+    "strings"
+    "io/ioutil"
+    "encoding/base64"
+    "golang.org/x/net/html/charset"
+    //"errors"
+    //"strings"
+    //"encoding/json"
+    //"gopkg.in/mgo.v2"
+    //"gopkg.in/mgo.v2/bson"
+    //"git.gojus.com.br/eugeniucarvalho/gojus/shared"
+    //"git.gojus.com.br/eugeniucarvalho/gojus/config"
+    //"git.gojus.com.br/eugeniucarvalho/gojus/services"
+)
+
+func Now() int64{
+    return time.Now().Unix()
+}
+
+func ToUTF8(str, origEncoding string) string {
+    byteReader  := bytes.NewReader([]byte(str))
+    reader, _   := charset.NewReaderLabel(origEncoding, byteReader)
+    strBytes, _ := ioutil.ReadAll(reader)
+    return string(strBytes)
+}
+
+func FileGetContents(filename string) (string, error){
+    b, err := ioutil.ReadFile(filename)
+    if err != nil { return "", err }
+    return string(b), nil
+}
+
+func FilePutContents(filename string, content string, perm os.FileMode) error {
+    cont := []byte(content)
+    if err := ioutil.WriteFile(filename, cont, perm) ; err != nil { return err }
+    f, err1 := os.Create(filename)
+    if err1 != nil { return err1 }
+    defer f.Close()
+    _, err2 := f.Write(cont)
+    //if err2 != nil { return err2 }
+    //f.Sync()
+    return err2
+}
+
+func RemoveFile(file string) error {
+    err := os.Remove(file)
+    if err != nil {
+        return err
+    }
+    return nil
+}
+
+func Encode(delimiter string, values ...string) string {
+    return ToBase64(strings.Join(values, delimiter))
+}
+
+func ToBase64(s string) string {
+    return  base64.StdEncoding.EncodeToString([]byte(s))
+}
+
+func FromBase64(value string) (string, error) {
+    dec, err := base64.StdEncoding.DecodeString(value)
+    return string(dec), err
+}
+
+func Decode(delimiter, value string) ([]string, error) {
+    decoded, err := FromBase64(value)
+    if err != nil { return []string{}, err }
+    return strings.Split(string(decoded), delimiter), nil
+}
+
+type Thumbnail struct {
+    Resolution string
+
+// Adiciona o arquivo de entrada
+// path e o caminho do arquivo e pages sao as paginas a serem convertidas
+// pages = "[0]" - representa a pagina 1
+// pages = "" - representa todas as paginas
+    Input      string
+
+    Output     string
+    InExt      string
+    Page       string
+}
+
+func NewThumbnail() *Thumbnail {
+    t := &Thumbnail{}
+    t.Resolution = "x300"
+    return t;
+}
+var (
+    ThumbSoffice = regexp.MustCompile("(doc|ppt|pps|pot|xls|xlt|xlw|dot|csv|txt|rtf)(x|m)?")
+)
+func(t *Thumbnail) Gen() error {
+    var err error
+
+    if t.Input == "" {
+        return fmt.Errorf("Input is empty")
+    }
+    if t.InExt == "" {
+        // todo -- pegar a extensao do arquivo de entrada
+    }
+    cmd := ""
+    remove := false
+    // Converte alguns tipos de arquivo para a imagem para depois converter para thumbnail
+    if ThumbSoffice.Match([]byte(strings.ToLower(t.InExt))) {
+        //cmd = "convert -thumbnail %s -background white -alpha remove %s %s"
+        cmd = "soffice --headless --convert-to png --outdir %s %s"
+
+        index     := strings.LastIndex(t.Output,"/")
+        outputdir := t.Output[0: index]
+
+        if err = Exec(fmt.Sprintf(cmd, outputdir, t.Input)); err != nil {
+            return err
+        }
+
+        t.Input = t.Output
+        // strings.Replace(t.Input, t.InExt, ".png", -1)
+        fmt.Println("new input -", t.InExt,"-", t.Input)
+        remove = true
+    }
+    // Cria o thumbnail
+    cmd = "convert -thumbnail %s -background white -alpha remove %s %s"
+    Exec(fmt.Sprintf(cmd, t.Resolution, t.Input + t.Page, t.Output))
+    // Apaga o arquivo temporario gerado pela conversao intermediaria
+    if remove {
+    //    RemoveFile(t.Input)
+    }
+    return nil;
+}
+
+func Exec(cmd string) error {
+    fmt.Println("Executando .. ", cmd)
+    out, err := exec.Command("bash", "-c", cmd).Output()
+
+    if err != nil {
+        fmt.Println("error occured ", err.Error())
+        return err
+    }
+    fmt.Println("out >> ", string(out))
+
+    return err
+
+}
+
+/*
+func Push(slice interface{}, el interface{}, call func(interface{}) bool) {
+
+    switch reflect.TypeOf(slice).Kind() {
+    case reflect.Slice:
+        s    := reflect.ValueOf(t)
+        push := true
+        item := reflect.ValueOf(el).Elem()
+        for i := 0; i < s.Len(); i++ {
+            push = call(s. ,item)
+        }
+
+        if push {
+            s = append(s, item)
+        }
+    }
+
+}
+*/