gulp>> dio-expert-session-finance>> 返回
项目作者： marcopollivier

项目描述 ：
Repositório do curso feito em parceria com a @digitalinnovationone
高级语言： Go
项目地址: git://github.com/marcopollivier/dio-expert-session-finance.git
创建时间： 2020-04-21T22:33:05Z
项目社区：https://github.com/marcopollivier/dio-expert-session-finance
开源协议：MIT License
下载


dio-expert-session-finance

Pré Desenvolvimento

  1. Vamos criar um projeto no Github chamado dio-expert-session-finance

    • Depois voltamos aqui para configurar mais nosso repositório. Por enquanto vamos ter apenas arquivos básicos
      • .gitignore
      • README.md

  2. Depois do nosso projeto criado no Github, vamos criar um projeto Go básico.

    • $ mkdir dio-expert-session-finance
    • $ cd dio-expert-session-finance

    • $ go mod init github.com/marcopollivier/dio-expert-session-finance

      Esses comandos vão criar dentro da pasta dio-expert-session-finance um arquivo go.mod.
      E esse arquivo vai ser a base do nosso projeto.

      Depois disso, você já pode abrir seu projeto na IDE de sua escolha

    • GoLand
    • VSCode
    • Vim

    1. Agora que temos o nosso projeto funcionando corretamente, vamos criar um Hello, World! para
      termos certeza que tudo está de acordo com o que esperávamos.

      • Dentro da pasta dio-expert-session-finance/cmd/server/ vamos criar o arquivo main.go
      1. package main
      3. import "fmt"
      5. func main() {
      6.   fmt.Print("Olá, Mundo!")
      7. }

      Com isso já vemos que nosso ambiente está ok e funcional, mas ainda não é isso que queremos exatamente, correto?

  3. Mas precisamos evoluir nosso código para começar a tomar forma de uma API. 

    1.  package main
    3.  import (
    4.         "fmt"
    5.         "net/http"
    6.  )
    8.  func main() {
    9.         http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    10.                 fmt.Fprintf(w, "Olá. Bem vindo a minha página!")
    11.         })
    13.         http.ListenAndServe(":8080", nil)
    14.  }

    $ curl curl http://localhost:8080/

  4. Vamos começar a pensar no nosso modelo. Nós queremos criar um sistema pras nossas finanças pessoais.
    Para isso vamos pensar num modelo para trabalharmos.

    5.1. Nosso modelo financeiro vai ser bem simples, mas flexível o suficiente para evoluirmos
    no futuro

    • Titulo
    • Valor
    • Tipo (ENTRADA, SAIDA)

    • Data

      5.2. Vamos pensar que, antes de mais nada, queremos retornar um JSON com esse modelo.

      1. package main
      3. import (
      4.   "encoding/json"
      5.   "net/http"
      6.   "time"
      7. )
      9. func main() {
      10.   http.HandleFunc("/transactions", getTransactions)
      12.   _ = http.ListenAndServe(":8080", nil)
      13. }
      15. type Transaction struct {
      16.   Title     string
      17.   Amount    float32
      18.   Type      int //0. entrada 1. saida
      19.   CreatedAt time.Time
      20. }
      22. type Transactions []Transaction
      24. func getTransactions(w http.ResponseWriter, r *http.Request) {
      25.   if r.Method != "GET" {
      26.       w.WriteHeader(http.StatusMethodNotAllowed)
      27.       return
      28.   }
      30.   w.Header().Set("Content-type", "application/json")
      32.   layout := "2006-01-02T15:04:05"
      33.   salaryReceived, _ := time.Parse(layout, "2020-04-05T11:45:26")
      34.   paidElectricityBill, _ := time.Parse(layout, "2020-04-12T22:00:00")
      35.   var transactions = Transactions{
      36.       Transaction{
      37.           Title:     "Salário",
      38.           Amount:    1200.0,
      39.           Type:      0,
      40.           CreatedAt: salaryReceived,
      41.       },
      42.       Transaction{
      43.           Title:     "Conta de luz",
      44.           Amount:    100.0,
      45.           Type:      1,
      46.           CreatedAt: paidElectricityBill,
      47.       },
      48.   }
      50.   _ = json.NewEncoder(w).Encode(transactions)
      51. }
      1. type Tction struct {
      2.   Title     string    `json:"title"`
      3.   Amount    float32   `json:"amount"`
      4.   Type      int       `json:"type"` //0. entrada 1. saida
      5.   CreatedAt time.Time `json:"created_at"`
      6. }

  5. E agora vamos fazer um método de inserção (POST)

    1.  http.HandleFunc("/transactions/create", createATransaction)
    3.  ...
    5.  func createATransaction(w http.ResponseWriter, r *http.Request) {
    6.      if r.Method != "POST" {
    7.          w.WriteHeader(http.StatusMethodNotAllowed)
    8.          return
    9.      }
    11.      var res = Transactions{}
    12.      var body, _ = ioutil.ReadAll(r.Body)
    13.      _ = json.Unmarshal(body, &res)
    15.      fmt.Println(res)
    16.      fmt.Println(res[0].Title)
    17.      fmt.Println(res[1].Title)
    18.  }
    1.  [
    2.     {
    3.         "title": "Salário",
    4.         "amount": 1200,
    5.         "type": 0,
    6.         "created_at": "2020-04-05T11:45:26Z"
    7.     }
    8.  ]

    ```shell script
    $ curl -X POST ‘http://localhost:8080/transactions/create‘ \
    -H ‘Content-Type: application/json’ \
    -d ‘[

    1.     {
    2.         "title": "Salário",
    3.         "amount": 1200,
    4.         "type": 0,
    5.         "created_at": "2020-04-05T11:45:26Z"
    6.     }
    7. ]'

    ```

  6. Hora de refatorar. Vamos colocar em memória e isolar em arquivos e pacotes

  7. Vamos começar a pensar em monitoramento? Então vamos criar um arquivo de Healthcheck

    1.  package actuator
    3.  import (
    4.      "encoding/json"
    5.      "net/http"
    6.  )
    8.  func Health(responseWriter http.ResponseWriter, request *http.Request) {
    9.      responseWriter.Header().Set("Content-Type", "application/json")
    11.      profile := HealthBody{"alive"}
    13.      returnBody, err := json.Marshal(profile)
    14.      if err != nil {
    15.          http.Error(responseWriter, err.Error(), http.StatusInternalServerError)
    16.          return
    17.      }
    19.      _, err = responseWriter.Write(returnBody)
    20.      if err != nil {
    21.          http.Error(responseWriter, err.Error(), http.StatusInternalServerError)
    22.          return
    23.      }
    24.  }
    26.  type HealthBody struct {
    27.      Status string
    28.  }

  8. Vamos aproveitar já que criamos um util e escrever um teste unitário para ele 

    1. package util
    3. import (
    4.     "testing"
    5. )
    7. func TestStringToDate(testing *testing.T) {
    8.     var convertedTime = StringToTime("2019-02-12T10:00:00")
    10.     if convertedTime.Year() != 2019 {
    11.         testing.Errorf("Converter StringToDate is failed. Expected Year %v, got %v", 2019, convertedTime.Year())
    12.     }
    14.     if convertedTime.Month() != 2 {
    15.         testing.Errorf("Converter StringToDate is failed. Expected Month %v, got %v", 2, convertedTime.Month())
    16.     }
    18.     if convertedTime.Hour() != 10 {
    19.         testing.Errorf("Converter StringToDate is failed. Expected Hour %v, got %v", 10, convertedTime.Hour())
    20.     }
    22. }

  9. Vamos começar a pensar em um pouco de qualidade de código também

    10.1. Para fazer análise de código estática, vamos instalar a dependencia do lint

    • $ go get -u golang.org/x/lint/golint

    10.2. E vamos executar nossos primeiros comandos relacionados

    • $ go test ./...
    • $ golint ./...

  10. Vamos configurar o CircleCI

  11. Vamos colocar métricas na nossa aplicação 

    1. $ go get github.com/prometheus/client_golang/prometheus
    2. $ go get github.com/prometheus/client_golang/prometheus/promauto
    3. $ go get github.com/prometheus/client_golang/prometheus/promhttp

  12. Para os passos seguintes, nós vamos fazer uma integração com um BD qualquer.
    Para isso, vamos subir uma imagem Docker do Postgres pra poder fazer o nosso teste.

    Vamos subir o BD via Docker Compose

    host: localhost
    user: postgres
    pass: postgres
    DB: diodb

    1. version: "3"
    2. services:
    3.   postgres:
    4.     image: postgres:9.6
    5.     container_name: "postgres"
    6.     environment:
    7.       - POSTGRES_DB=diodb
    8.       - POSTGRES_USER=postgres
    9.       - TZ=GMT
    10.     volumes:
    11.       - "./data/postgres:/var/lib/postgresql/data"
    12.     ports:
    13.       - 5432:5432
    1. prepare-tests:
    2.    docker-compose -f .devops/postgres.yml up -d

  13. Já com o banco acessível via Docker, vamos criar a base que utilizaremos no nosso teste

    1. CREATE TABLE transactions (
    2.     id SERIAL PRIMARY KEY,
    3.     title varchar(100),
    4.     amount decimal,
    5.     type smallint,
    6.     installment smallint,
    7.     created_at timestamp 
    8. );
    10. insert into transactions (title, amount, type, installment, created_at)
    11. values ('Freela', '100.0', 0, 1, '2020-04-10 04:05:06'); 
    13. select * from transactions;

  14. Agora com a estrutra de banco criada, vamos fazer as alterações necessárias no código. E a primeira delas é baixar a
    dependência do driver do Postgres.

    Lista de SQLDrivers disponíveis

    Execute o seguinte comando dentro da pasta do projeto

    shell script $ go get -u github.com/lib/pq

  15. E esse é o código que vai manipular as informações do banco de fato

    1. package postgres
    3. import (
    4.     "database/sql"
    5.     "fmt"
    6.     "github.com/marcopollivier/dio-expert-session-pre-class/model/transaction"
    8.     _ "github.com/lib/pq"
    9. )
    11. const (
    12.     host     = "localhost"
    13.     port     = 5432
    14.     user     = "postgres"
    15.     password = "postgres"
    16.     dbname   = "diodb"
    17. )
    19. func connect() *sql.DB {
    20.     psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
    21.     var db, _ = sql.Open("postgres", psqlInfo)
    22.     return db
    23. }
    25. func Create(transaction transaction.Transaction) int {
    26.     var db = connect()
    27.     defer db.Close()
    29.     var sqlStatement = `INSERT INTO  transactions (title, amount, type, installment, created_at)
    30.                         VALUES ($1, $2, $3, $4, $5)
    31.                         RETURNING id;`
    33.     var id int
    34.     _ = db.QueryRow(sqlStatement,
    35.                     transaction.Title,
    36.                     transaction.Amount,
    37.                     transaction.Type,
    38.                     transaction.Installment,
    39.                     transaction.CreatedAt).Scan(&id)
    40.     fmt.Println("New record ID is:", id)
    42.     return id
    43. }
    45. func main() {
    46.     //log.Fatal(http.Init())
    48.     //"Outro freela", 400.0, 0, 1, "2020-04-20 12:00:06"
    49.     postgres.Create(transaction.Transaction{Title: "Outro freela", Amount: 600.0, Type: 0, Installment: 1, CreatedAt: util.StringToTime("2020-04-20T12:00:06")})
    50. }
    52. func FetchAll() transaction.Transactions {
    53.     var db = connect()
    54.     defer db.Close()
    56.     rows, _ := db.Query("SELECT title, amount, type, installment, created_at FROM transactions")
    57.     defer rows.Close()
    59.     var transactionSlice []transaction.Transaction
    60.     for rows.Next() {
    61.         var transaction transaction.Transaction
    62.         _ = rows.Scan(&transaction.Title,
    63.                       &transaction.Amount,
    64.                       &transaction.Type,
    65.                       &transaction.Installment,
    66.                       &transaction.CreatedAt)
    68.         transactionSlice = append(transactionSlice, transaction)
    69.     }
    71.     return transactionSlice
    72. }
    74. fmt.Print(postgres.FetchAll())