译：在Go中转向领域驱动设计

package github

type User struct {
  ID    string
  Email string
  OrgIDs []string
}

type Client struct {
  Key   string
}

func (c *Client) User(token string) (User, error) {
  // 与Github API进行交互，并返回用户。如果他们在一个组织中，返回组织的c.OrgID
}

package mw

func AuthMiddleware(client *github.Client, reqOrgID string, next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    token, _, ok := r.BasicAuth()
    if !ok {
      http.Error(w, “Unauthorized”, http.StatusUnauthorized)
      return
    }
    user, err := client.User(token)
    if err != nil {
      http.Error(w, “Unauthorized”, http.StatusUnauthorized)
      return
    }
    permit := false
    for _, orgID := range user.OrgIDs {
      if orgId == reqOrgID {
        permit = true
        break
      }
    }
    if !permit {
      http.Error(w, “Unauthorized”, http.StatusUnauthorized)
      return
    }
    // 用户已认证，放他们进来
    next.ServeHTTP(w, r)
  })
}

package mw

type UserService interface {
  User(token string) (github.User, error)
}

func AuthMiddleware(us UserService, reqOrgID string, next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    token, _, ok := r.BasicAuth()
    if !ok {
      http.Error(w, “Unauthorized”, http.StatusUnauthorized)
      return
    }
    user, err := us.User(token)
    if err != nil {
      http.Error(w, “Unauthorized”, http.StatusUnauthorized)
      return
    }
    permit := false
    for _, orgID := range user.OrgIDs {
      if orgId == reqOrgID {
        permit = true
        break
      }
    }
    if !permit {
      http.Error(w, “Unauthorized”, http.StatusUnauthorized)
      return
    }
    // user is authenticated, let them in
    next.ServeHTTP(w, r)
  })
}

package mock

type UserService struct {
  UserFn func(token string) (github.User, error)
}

func (us *UserService) Authenticate(token string) (github.User, error) {
  return us.UserFn(token)
}

package gitlab

type User struct {
  ID    string
  Email string
  OrgIDs []string
}

type Client struct {
  Key   string
}

func (c *Client) User(token string) (User, error) {
  // 与Gitlab API交互，返回用户和对应的组织c.OrgID
}

type UserService interface {
  User(token string) (github.User, error)
                      ^^^^^^^^^^^
}

package mw

type User struct {
  OrgIDs []string
}

type UserService interface {
  User(token string) (User, error)
}

// Package adapter probably isn’t a great package name, but this is a
// demo so deal with it.
package adapter

type GitHubUserService struct {
  Client *github.Client
}

func (us *GitHubUserService) User(token string) (mw.User, error) {
  ghUser, err := us.Client.User(token)
  if err != nil {
    return mw.User{}, err
  }
  return mw.User{
    OrgIDs: ghUser.OrgIDs,
  }, nil
}

type GitLabUserService struct {
  Client *gitlab.Client
}

func (us *GitLabUserservice) User(token string) (mw.User, error) {
  glUser, err := us.Client.User(token)
  if err != nil {
    return mw.User{}, err
  }
  return mw.User{
    OrgIDs: glUser.OrgIDs,
  }, nil
}

package mock

type UserService struct {
  UserFn func(token string) (mw.User, error)
}

func (us *UserService) Authenticate(token string) (mw.User, error) {
  return us.UserFn(token)
}

var myHandler http.Handler
var us mw.UserService
us = &GitLabUserservice{
  Client: &gitlab.Client{
    Key: “abc-123”,
  },
}
// This protects your handler
myHandler = mw.AuthMiddleware(us, “my-org-id”, myHandler)

// Package enroll provides HTTP handlers for enrolling a user into a new
// course.
// This package is entirely for demonstrative purposes and hasn’t been tested,
// but if you do see obvious bugs feel free to let me know and I’ll address
// them.
package enroll

import (
  “io”
	“net/http”

	“github.com/gorilla/schema”
)

// Data defines the data that will be provided to the HTML template when it is
// rendered.
type Data struct {
  Form    Form
  // Map of form fields with errors and their error message
  Errors  map[string]string

  User    User
	License License
}

// License is used to show the user more info about what they are enrolling in.
// Eg if they URL query params have a valid key, we might show them:
//
//   “You are about to enroll in Gophercises - FREE using the key `abc-123`”
//                               ^             ^                   ^
//                             Course       Package               Key
//
type License struct {
  Key     string
  Course  string
  Package string
}

// User defines a user that can be enrolled in courses.
type User struct {
  ID string
  // Email is used when rendering a navbar with the user’s email address, among
  // other areas of an HTML page.
  Email string
  Avatar string
  // …
}

// Form defines all of the HTML form fields. It assumes the Form will be
// rendered using struct tags and a form package I created
// (https://github.com/joncalhoun/form), but it isn’t really mandatory as
// long as the form field names match the `schema` part here.
type Form struct {
	License  string `form:"name=license;label=License key;footer=You can find this in an email sent over by Gumroad after purchasing a course. Or in the case of Gophercises it will be in an email from me ([email protected])." schema:"license"`
}

// Handler provides GET and POST http.Handlers
type Handler struct {
  // Interfaces and function types here serve roughly the same purpose. funcs
  // just tend to be easier to write adapters for since you don’t need a
  // struct type with a method.
  UserFn    func(r *http.Request) (User, error)
  LicenseFn func(key string) (License, error)

  // Interface because this one is the least likely to need an adapter
  Enroller interface {
    Enroll(userID, licenseKey string) error
  }

  // Typically satisfied with an HTML template
  Executor interface {
    Execute(wr io.Writer, data interface{}) error
  }
}

// Get handles rendering the Form for a user to enroll in a new course.
func (h *Handler) Get() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
    user, err := h.UserFn(r)
    if err != nil {
      // redirect or render an error
      return
    }
    var data Data
    data.User = user

    var form Form
    err := r.ParseForm()
    if err != nil {
      // maybe log this? We can still render
    }
    dec := schema.NewDecoder()
    dec.IgnoreUnknownKeys(true)
    err = dec.Decode(&form, r.Form)
    if err != nil {
      // maybe log this? We can still render
    }
    data.Form = form

    if form.License != “” {
      lic, err := h.LicenseFn(form.License)
      data.License = lic
      if err != nil {
        data.Errors = map[string]string{
          “license”: “is not valid”,
        }
      }
    }

    h.Executor.Execute(r, data)
	}
}

// Post handles processing the form and enrolling a user.
func (h *Handler) Post() http.HandlerFunc {
  return func(w http.ResponseWriter, r *http.Request) {
    user, err := h.UserFn(r)
    if err != nil {
      // redirect or render an error
      return
    }
    var data Data
    data.User = user

    var form Form
    err := r.ParseForm()
    if err != nil {
      // maybe log this? We can still render
    }
    dec := schema.NewDecoder()
    dec.IgnoreUnknownKeys(true)
    err = dec.Decode(&form, r.Form)
    if err != nil {
      // maybe log this? We can still render
    }
    data.Form = form

    err = h.Enroller.Enroll(user.ID, form.License)
    if err != nil {
      data.Errors = map[string]string{
        “license”: “is not valid”,
      }
      // Re-render the form
      h.View.Execute(r, data)
      return
    }
    http.Redirect(w, r, “/courses”, http.StatusFound)
	}
}

package domain

type User struct {
  ID    string
  Email string
  OrgIDs []string
}

package gitlab // github is the same basically

type Client struct {
  Key   string
}

// Note the return type is domain.User here - this code is now coupled to our
// domain.
func (c *Client) User(token string) (domain.User, error) {
  // … interact with the gitlab API, and return a user if they are in an org with the c.OrgID
}

package mw

type UserService interface {
  User(token string) (domain.User, error)
}

func AuthMiddleware(us UserService, reqOrgID string, next http.Handler) http.Handler {
  // unchanged
}

package mock

type UserService struct {
  UserFn func(token string) (domain.User, error)
}

func (us *UserService) Authenticate(token string) (domain.User, error) {
  return us.UserFn(token)
}

package domain

type User struct {
  ID    string
  Email string
  OrgIDs []string
}

package domain

type User struct { … }

type UserService interface {
  User(token string) (User, error)
}

package domain

type UserStore interface {
	Create(NewUser) (*User, RememberToken, error)
	Authenticate(email, pw string) (*User, RememberToken, error)
	ByToken(RememberToken) (*User, error)
	ResetToken(email string) (ResetToken, error)
	UpdatePw(pw string, tok ResetToken) (RememberToken, error)
}

package sql

type UserStore struct {
  DB *sql.DB
}

func (us *UserStore) Create(newUser domain.NewUser) (*domain.User, domain.RememberToken, error) {
  // …
}

// … and more methods

package userapi

type UserStore struct {
  HTTPClient *http.Client
}

func (us *UserStore) Create(newUser domain.NewUser) (*domain.User, domain.RememberToken, error) {
  // interact with a third party API instead of a local SQL database
}

// …

type UserAuthenticator interface {
	Authenticate(email, pw string) (error)
}