架构整洁之道的实用指南

├── api│   ├── handler│   │   ├── admin.go│   │   └── user.go│   ├── main.go│   ├── middleware│   │   ├── auth.go│   │   └── cors.go│   └── views│       └── errors.go├── bin│   └── main├── config.json├── docker-compose.yml├── go.mod├── go.sum├── Makefile├── pkg│   ├── admin│   │   ├── entity.go│   │   ├── postgres.go│   │   ├── repository.go│   │   └── service.go│   ├── errors.go│   └── user│       ├── entity.go│       ├── postgres.go│       ├── repository.go│       └── service.go├── README.md

package user
import "github.com/jinzhu/gorm"
type User struct {  gorm.Model  FirstName   string `json:"first_name,omitempty"`  LastName    string `json:"last_name,omitempty"`  Password    string `json:"password,omitempty"`  PhoneNumber string `json:"phone_number,omitempty"`  Email       string `json:"email,omitempty"`  Address     string `json:"address,omitempty"`  DisplayPic  string `json:"display_pic,omitempty"`}

package userimport (  "context")type Repository interface {  FindByID(ctx context.Context, id uint) (*User, error)  BuildProfile(ctx context.Context, user *User) (*User, error)  CreateMinimal(ctx context.Context, email, password, phoneNumber string) (*User, error)  FindByEmailAndPassword(ctx context.Context, email, password string) (*User, error)  FindByEmail(ctx context.Context, email string) (*User, error)  DoesEmailExist(ctx context.Context, email string) (bool, error)  ChangePassword(ctx context.Context, email, password string) error}

package userimport (  "context"  "crypto/md5"  "encoding/hex"  "errors")type Service interface {  Register(ctx context.Context, email, password, phoneNumber string) (*User, error)  Login(ctx context.Context, email, password string) (*User, error)  ChangePassword(ctx context.Context, email, password string) error  BuildProfile(ctx context.Context, user *User) (*User, error)  GetUserProfile(ctx context.Context, email string) (*User, error)  IsValid(user *User) (bool, error)  GetRepo() Repository}type service struct {  repo Repository}func NewService(r Repository) Service {  return &service{    repo: r,  }}func (s *service) Register(ctx context.Context, email, password, phoneNumber string) (u *User, err error) {  exists, err := s.repo.DoesEmailExist(ctx, email)  if err != nil {    return nil, err  }  if exists {    return nil, errors.New("User already exists")  }  hasher := md5.New()  hasher.Write([]byte(password))  return s.repo.CreateMinimal(ctx, email, hex.EncodeToString(hasher.Sum(nil)), phoneNumber)}func (s *service) Login(ctx context.Context, email, password string) (u *User, err error) {  hasher := md5.New()  hasher.Write([]byte(password))  return s.repo.FindByEmailAndPassword(ctx, email, hex.EncodeToString(hasher.Sum(nil)))}func (s *service) ChangePassword(ctx context.Context, email, password string) (err error) {  hasher := md5.New()  hasher.Write([]byte(password))  return s.repo.ChangePassword(ctx, email, hex.EncodeToString(hasher.Sum(nil)))}func (s *service) BuildProfile(ctx context.Context, user *User) (u *User, err error) {  return s.repo.BuildProfile(ctx, user)}func (s *service) GetUserProfile(ctx context.Context, email string) (u *User, err error) {  return s.repo.FindByEmail(ctx, email)}func (s *service) IsValid(user *User) (ok bool, err error) {  return ok, err}func (s *service) GetRepo() Repository {  return s.repo}

package handler
import (  "encoding/json"  "net/http"
  "github.com/L04DB4L4NC3R/jobs-mhrd/api/middleware"  "github.com/L04DB4L4NC3R/jobs-mhrd/api/views"  "github.com/L04DB4L4NC3R/jobs-mhrd/pkg/user"  "github.com/dgrijalva/jwt-go"  "github.com/spf13/viper")
func register(svc user.Service) http.Handler {  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {    if r.Method != http.MethodPost {      views.Wrap(views.ErrMethodNotAllowed, w)      return    }
    var user user.User    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {      views.Wrap(err, w)      return    }
    u, err := svc.Register(r.Context(), user.Email, user.Password, user.PhoneNumber)    if err != nil {      views.Wrap(err, w)      return    }    w.WriteHeader(http.StatusCreated)    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{      "email": u.Email,      "id":    u.ID,      "role":  "user",    })    tokenString, err := token.SignedString([]byte(viper.GetString("jwt_secret")))    if err != nil {      views.Wrap(err, w)      return    }    json.NewEncoder(w).Encode(map[string]interface{}{      "token": tokenString,      "user":  u,    })    return  })}
func login(svc user.Service) http.Handler {  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {    if r.Method != http.MethodPost {      views.Wrap(views.ErrMethodNotAllowed, w)      return    }    var user user.User    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {      views.Wrap(err, w)      return    }
    u, err := svc.Login(r.Context(), user.Email, user.Password)    if err != nil {      views.Wrap(err, w)      return    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{      "email": u.Email,      "id":    u.ID,      "role":  "user",    })    tokenString, err := token.SignedString([]byte(viper.GetString("jwt_secret")))    if err != nil {      views.Wrap(err, w)      return    }    json.NewEncoder(w).Encode(map[string]interface{}{      "token": tokenString,      "user":  u,    })    return  })}
func profile(svc user.Service) http.Handler {  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // @protected    // @description build profile    if r.Method == http.MethodPost {      var user user.User      if err := json.NewDecoder(r.Body).Decode(&user); err != nil {        views.Wrap(err, w)        return      }
      claims, err := middleware.ValidateAndGetClaims(r.Context(), "user")      if err != nil {        views.Wrap(err, w)        return      }      user.Email = claims["email"].(string)      u, err := svc.BuildProfile(r.Context(), &user)      if err != nil {        views.Wrap(err, w)        return      }
      json.NewEncoder(w).Encode(u)      return    } else if r.Method == http.MethodGet {
      // @description view profile      claims, err := middleware.ValidateAndGetClaims(r.Context(), "user")      if err != nil {        views.Wrap(err, w)        return      }      u, err := svc.GetUserProfile(r.Context(), claims["email"].(string))      if err != nil {        views.Wrap(err, w)        return      }
      json.NewEncoder(w).Encode(map[string]interface{}{        "message": "User profile",        "data":    u,      })      return    } else {      views.Wrap(views.ErrMethodNotAllowed, w)      return    }  })}
func changePassword(svc user.Service) http.Handler {  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {    if r.Method == http.MethodPost {      var u user.User      if err := json.NewDecoder(r.Body).Decode(&u); err != nil {        views.Wrap(err, w)        return      }
      claims, err := middleware.ValidateAndGetClaims(r.Context(), "user")      if err != nil {        views.Wrap(err, w)        return      }      if err := svc.ChangePassword(r.Context(), claims["email"].(string), u.Password); err != nil {        views.Wrap(err, w)        return      }      return    } else {      views.Wrap(views.ErrMethodNotAllowed, w)      return    }  })}
// expose handlersfunc MakeUserHandler(r *http.ServeMux, svc user.Service) {  r.Handle("/api/v1/user/ping", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {    w.WriteHeader(http.StatusOK)    return  }))  r.Handle("/api/v1/user/register", register(svc))  r.Handle("/api/v1/user/login", login(svc))  r.Handle("/api/v1/user/profile", middleware.Validate(profile(svc)))  r.Handle("/api/v1/user/pwd", middleware.Validate(changePassword(svc)))}

package errors
import (  "errors")
var (  ErrNotFound     = errors.New("Error: Document not found")  ErrNoContent    = errors.New("Error: Document not found")  ErrInvalidSlug  = errors.New("Error: Invalid slug")  ErrExists       = errors.New("Error: Document already exists")  ErrDatabase     = errors.New("Error: Database error")  ErrUnauthorized = errors.New("Error: You are not allowed to perform this action")  ErrForbidden    = errors.New("Error: Access to this resource is forbidden"))

package views
import (  "encoding/json"  "errors"  "net/http"
  log "github.com/sirupsen/logrus"
  pkg "github.com/L04DB4L4NC3R/jobs-mhrd/pkg")
type ErrView struct {  Message string `json:"message"`  Status  int    `json:"status"`}
var (  ErrMethodNotAllowed = errors.New("Error: Method is not allowed")  ErrInvalidToken     = errors.New("Error: Invalid Authorization token")  ErrUserExists       = errors.New("User already exists"))
var ErrHTTPStatusMap = map[string]int{  pkg.ErrNotFound.Error():     http.StatusNotFound,  pkg.ErrInvalidSlug.Error():  http.StatusBadRequest,  pkg.ErrExists.Error():       http.StatusConflict,  pkg.ErrNoContent.Error():    http.StatusNotFound,  pkg.ErrDatabase.Error():     http.StatusInternalServerError,  pkg.ErrUnauthorized.Error(): http.StatusUnauthorized,  pkg.ErrForbidden.Error():    http.StatusForbidden,  ErrMethodNotAllowed.Error(): http.StatusMethodNotAllowed,  ErrInvalidToken.Error():     http.StatusBadRequest,  ErrUserExists.Error():       http.StatusConflict,}
func Wrap(err error, w http.ResponseWriter) {  msg := err.Error()  code := ErrHTTPStatusMap[msg]
  // If error code is not found  // like a default case  if code == 0 {    code = http.StatusInternalServerError  }
  w.WriteHeader(code)
  errView := ErrView{    Message: msg,    Status:  code,  }  log.WithFields(log.Fields{    "message": msg,    "code":    code,  }).Error("Error occurred")
  json.NewEncoder(w).Encode(errView)}