package database
 
import (
    "fmt"
    "time"
 
    _ "github.com/go-sql-driver/mysql" // load mysql driver for xorm
    "github.com/go-xorm/core"
    "github.com/go-xorm/xorm"
)
 
var engine *xorm.Engine
 
func init() {
    loc, err := time.LoadLocation("UTC")
    if err != nil {
        panic(err)
    }
    time.Local = loc
}
 
// UseEngine reutrns db resource
func UseEngine() *xorm.Engine {
    if engine == nil {
        engine = initEngine()
    }
    return engine
}
 
func initEngine() *xorm.Engine {
    dbUser := "user"
    dbPass := "pass"
    dbHost := "127.0.0.1"
    dbPort := 3306
    dbName := "blogdb"
    dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s", dbUser, dbPass, dbHost, dbPort, dbName)
 
    e, err := xorm.NewEngine("mysql", dsn)
    if err != nil {
        panic(err)
    }
 
    // as default mapper, underscore is inserted on every capital case for table or field name.
    // (e.g.) UserID => user_i_d, IPAddress => i_p_address
    // to prevent this rule, use GonicMapper.
    e.SetMapper(core.NewCacheMapper(new(core.GonicMapper)))
 
    err = e.Ping()
    if err != nil {
        panic(err)
    }
    return e
}

package resource
 
import (
    "github.com/go-xorm/xorm"
    "golang.org/x/net/context"
 
    "github.com/eure/example-blog-golang/library/database"
)
 
// GetDB returns database engine
func GetDB(c context.Context) *xorm.Engine {
    v, ok := c.Value("database").(*xorm.Engine)
    if !ok {
        return nil
    }
    return v
}
 
// UseDB returns database engine
func UseDB(c context.Context) *xorm.Engine {
    db := GetDB(c)
    if db == nil {
        db = database.UseEngine()
        c = context.WithValue(c, "database", db)
    }
    return db
}
 
// UseTx returns database transaction
func UseTx(c context.Context) *xorm.Session {
    tx := c.Value("transaction").(*xorm.Session)
    if tx == nil {
        db := UseDB(c)
        tx := db.NewSession()
        tx.Begin()
        c = context.WithValue(c, "transaction", tx)
    }
    return tx
}
 
// Commit commits database transaction
func Commit(c context.Context) error {
    tx := c.Value("transaction").(*xorm.Session)
    if tx == nil {
        return nil
    }
 
    err := tx.Commit()
    if err != nil {
        return err
    }
 
    c = context.WithValue(c, "transaction", nil)
    tx.Close()
    return nil
}
 
// Rollback rollbacks database transaction
func Rollback(c context.Context) error {
    tx := c.Value("transaction").(*xorm.Session)
    if tx == nil {
        return nil
    }
 
    err := tx.Rollback()
    if err != nil {
        return err
    }
 
    c = context.WithValue(c, "transaction", nil)
    tx.Close()
    return nil
}
 
// Release releases all resources
func Release(c context.Context) {
    if c == nil {
        return
    }
 
    tx := c.Value("transaction").(*xorm.Session)
    if tx != nil {
        tx.Close()
    }
}

package author
 
import (
    "fmt"
)
 
// Entity is struct for author
type Entity struct {
    Email string `response:"email" xorm:"pk not null unique"`
    Name  string `response:"name" xorm:"not null unique"`
}
 
const (
    tableName = "authors"
    pkName    = "email"
)
 
// TableName define table name for Xorm
func (e Entity) TableName() string {
    return tableName
}
 
func (e Entity) String() string {
    return fmt.Sprintf("{email: %s, name: %s}", e.Email, e.Name)
}

package model
 
import (
    "fmt"
 
    "github.com/go-xorm/xorm"
    "golang.org/x/net/context"
 
    "github.com/eure/example-blog-golang/library/net/context/resource"
)
 
// RootRepository is root struct for all repositories
type RootRepository struct {
    Ctx    context.Context
    Engine *xorm.Engine
 
    PrimaryKey string
    Seed       interface{}
    omitList   []string
}
 
// NewRootRepositoryWithSeed creates new RootRepository
func NewRootRepositoryWithSeed(ctx context.Context, pk string, seed interface{}) *RootRepository {
    return &RootRepository{
        Ctx:        ctx,
        Engine:     resource.UseDB(ctx),
        PrimaryKey: pk,
        Seed:       seed,
    }
}
 
// ============================================================
//  helper
// ============================================================
 
// NewSession return session
func (r *RootRepository) NewSession() *xorm.Session {
    return r.Engine.NewSession()
}
 
// AddOmit adds column name to omit list
func (r *RootRepository) AddOmit(col string) {
    r.omitList = append(r.omitList, col)
}
 
// GetLastSQL returns the executed SQL statement
func (r *RootRepository) GetLastSQL(s *xorm.Session) string {
    sql, args := s.LastSQL()
    return fmt.Sprintf("%s -- [args] %v", sql, args)
}
 
// ============================================================
//  create
// ============================================================
 
// CreateOne inserts new entity data to database
func (r *RootRepository) CreateOne(e interface{}) error {
    s := r.Engine.NewSession()
    if len(r.omitList) > 0 {
        for _, col := range r.omitList {
            s.Omit(col)
        }
        r.omitList = []string{}
    }
 
    _, err := s.Insert(e)
    if err != nil {
        return err
    }
    return nil
}
 
// ============================================================
//  get
// ============================================================
 
// GetOneByPK fetches a single row by primary key
func (r *RootRepository) GetOneByPK(ent, pk interface{}) (bool, error) {
    s := r.Engine.NewSession()
    s.And(r.PrimaryKey+" = ?", pk)
    return r.GetOneBySession(s, ent)
}
 
// GetOneBySession fetches a single row using the given session
func (r *RootRepository) GetOneBySession(s *xorm.Session, ent interface{}) (bool, error) {
    has, err := s.Get(ent)
    if err != nil {
        return has, err
    }
    return has, nil
}

package author
 
import (
    "golang.org/x/net/context"
 
    "github.com/eure/example-blog-golang/model"
)
 
// Repository is repo for author
type Repository struct {
    *model.RootRepository
}
 
// NewRepository creates new Repository
func NewRepository(ctx context.Context) *Repository {
    return &Repository{
        RootRepository: model.NewRootRepositoryWithSeed(ctx, pkName, new(Entity)),
    }
}
 
 
// GetByEmail fetches a single author by email
func (r *Repository) GetByEmail(email string) *Entity {
    ent := new(Entity)
    has, err := r.GetOneByPK(ent, email)
    switch {
    case err != nil:
        // TODO: logging
        return nil
    case !has:
        return nil
    }
    return ent
}