History of language

First release November 10, 2009.

• Docker
• Kubernetes
• Treafik

The architecture does not depend on the existence of some library.

The business logic can be tested without external elements ie UI, databse.

Independent of UI. The UI can change easily, without changing the rest of the system.

Can change to other databse.

In fact your business rules simply don’t know anything at all about the outside world.

				    import "time"

					type Article struct {
						ID        int64     `json:"id"`
						Title     string    `json:"title"`
						Edition   string    `json:"edition"`
						Content   string    `json:"content"`
						UpdatedAt time.Time `json:"updated_at"`
						CreatedAt time.Time `json:"created_at"`
					}
					

					func (article *Article) FullTitle() string {
					  return article.Title + " " + article.Edition
					}
				        

• - database
• - file system
• - external API

				    package repository
					import (
						"database/sql"
						_ "github.com/go-sql-driver/mysql"

						"github.com/bmiles-development/shopify-game-player/player/models"
					)

					type ArticleRepo struct{
					  DB *sql.DB
					}
					

					func (repo *ArticleRepo) FindByID(id int64) (*models.Article, error) {
						result, err := repo.DB.Query("SELECT * FROM articles WHERE id = ?", id)
						if err != nil {
							panic(err.Error()) // proper error handling instead of panic in your app
						}
						defer result.Close()

						var article models.Article
						for result.Next() {
							// for each row, scan the result into our article composite object
							err = result.Scan(&article.ID, &article.Title, &article.Content)
							if err != nil {
								panic(err.Error()) // proper error handling instead of panic in your app
							}

						}

						return &article, err
					}
					

					func (repo *ArticleRepo) Save(article *models.Article) error {
						sqlQuery, err := repo.DB.Prepare("INSERT INTO articles(title, edition, content) VALUES(?, ?, ?)")
						if err != nil {
							panic(err.Error())
						}

						sqlQuery.Exec(article.Title, article.Edition, article.Content)

						return err
					}
							
						

Usecase Layer

package usecase

import (
	"github.com/bmiles-development/shopify-game-player/player/models"
	"github.com/bmiles-development/shopify-game-player/player/repository"
)

type UserUsecase struct {
	userRepo        repository.UserRepo
	userShopifyRepo repository.UserShopify
}

func NewUserUseCase(userRepo repository.UserRepo, userShopifyRepo repository.UserShopify) *UserUsecase {
	return &UserUsecase{
		userRepo:        userRepo,
		userShopifyRepo: userShopifyRepo,
	}
}

func (userUseCase *UserUsecase) SyncUsers(userCount int) []models.User {
	return userUseCase.userShopifyRepo.Fetch(userCount)
}

func (userUseCase *UserUsecase) AddTagsToShopifyUsers(userID string, tags string) models.User {
	return userUseCase.userShopifyRepo.AddTags(userID, tags)
}

• - REST API,
• - HTML File

				 
package controller

import (
	"net/http"

	"github.com/manakuro/golang-clean-architecture/domain/model"
	"github.com/manakuro/golang-clean-architecture/usecase/interactor"
)

type userController struct {
	userInteractor interactor.UserInteractor
}

type UserController interface {
	GetUsers(c Context) error
}

func NewUserController(us interactor.UserInteractor) UserController {
	return &userController{us}
}

func (uc *userController) GetUsers(c Context) error {
	var u []*model.User

	u, err := uc.userInteractor.Get(u)
	if err != nil {
		return err
	}

	return c.JSON(http.StatusOK, u)
}