entity.template

/**
 * Generation Details
 * Opal Version: {{.Version}}
 * Date: {{.Date}}
 * Time: {{.Time}}
 */
package {{.Package}}

import (
	. "github.com/twinj/opal"
	"reflect"
)

// Compile time check of Model implementation
var _ Model = &{{.Model}}{}

// Compile time check of {{.DAOName}}DAO implementation
var _ {{.DAOName}}DAO = &{{.DAOName}}IDAO{}

// Constant ModelName used to identify type
const {{.Model}}Model ModelName = "{{.ImportName}}"

// The {{.Model}} Entity - deliberately private
var _{{.Model}} Entity

// The Global {{.Model}} access object
var {{.DAOName}} {{.DAOName}}DAO

// *************************************************** MODEL

func Raw{{.Model}}() *{{.Model}} {
	o := new({{.Model}})
	o.Entity = _{{.Model}}.New(o)
	return o
}

func ({{.Model}}) ScanInto() (Model, []interface{}) {
	o := Raw{{.Model}}()
	return o, BindArgs(o)
}

func (o *{{.Model}}) Keys() []interface{} {
	return []interface{}{ {{range $i, $e := .Keys}}{{if $i}}, {{end}}&o.{{.Name}}{{end}} }
}

func (o *{{.Model}}) Parameters() []interface{} {
	return []interface{}{ {{range $i, $e := .Columns}}{{if $i}}, {{end}}&o.{{.Name}}{{end}} }
}

func ({{.Model}}) Gather(pModelMetadata *ModelMetadata) (ModelName, *Entity, func(*ModelIDAO)ModelDAO) {
	pModelMetadata.AddTable(Table{ {{.Table}} })
	{{range $i, $e := .Keys}}{{if $i}}{{/* Extra range args determines whether a newline is required at the end */}}
	{{end}}pModelMetadata.AddKey({{printf "%q" .Name}}, {{.Index}}, Column{ {{.Tag}} }, {{.Kind}}){{end}}
	{{range $i, $e := .Columns}}{{if $i}}
	{{end}}pModelMetadata.AddColumn({{printf "%q" .Name}}, {{.Index}}, Column{ {{.Tag}} }, {{.Kind}}){{end}}
	return {{.Model}}Model, &_{{.Model}}, new{{.DAOName}}DAO
}

// ************************************************* HELPERS

type {{.Model}}_ struct {
	{{range $i, $e := .Keys}}{{if $i}}{{/* Extra range args determines whether a newline is required at the end */}}
	{{end}}{{.Name}} interface{}{{end}}
	{{range $i, $e := .Columns}}{{if $i}}
	{{end}}{{.Name}} interface{}{{end}}
}

func (o *{{.Model}}_) Args() []interface{} {
	return []interface{}{
		{{range $i, $e := .Keys}}{{if $i}}{{/* Extra range args determines whether a newline is required at the end */}}
		{{end}}o.{{.Name}},{{end}}
		{{range $i, $e := .Columns}}{{if $i}}
		{{end}}o.{{.Name}},{{end}}
	}
}

func (o *{{.Model}}_) Scan(pModel *{{.Model}}) {
		{{range $i, $e := .Keys}}{{if $i}}{{/* Extra range args determines whether a newline is required at the end */}}
		{{end}}pModel.{{.Name}}.Scan(o.{{.Name}}){{end}}
		{{range $i, $e := .Columns}}{{if $i}}
		{{end}}pModel.{{.Name}}.Scan(o.{{.Name}}){{end}}
}

func (o {{.Model}}_) New() *{{.Model}} {
	return o.Insert()
}

func (o {{.Model}}_) Create() *{{.Model}} {
	return o.Insert()
}

func (o {{.Model}}_) Merge() *{{.Model}} {
	return o.Save()
}

func (o {{.Model}}_) Update() *{{.Model}} {
	return o.Save()
}

func (o {{.Model}}_) Insert() *{{.Model}} {
	m := Raw{{.Model}}()
	o.Scan(m)
	m.Insert()
	return m
}

func (o {{.Model}}_) Save() *{{.Model}} {
	if {{range $i, $e := .Keys}}{{if $i}}&& {{end}}o.{{.Name}} != nil{{end}} {
		m := {{.DAOName}}.Find({{range $i, $e := .Keys}}{{if $i}}, {{end}}o.{{.Name}}.({{.Primitive}}){{end}})
		if m != nil {
			o.Scan(m)
			m.Save()
			return m
		}
	}
	return o.Insert()
}

// ***************************************************** DAO

type {{.DAOName}}DAO interface {
	ModelDAO
	All() []{{.Model}}
	Find({{range $i, $e := .Keys}}{{if $i}},{{end}}{{.Primitive}}{{end}}) *{{.Model}}
	Exec(Sql) ([]{{.Model}}, error)
}

type {{.DAOName}}IDAO struct {
	*ModelIDAO
}

func new{{.DAOName}}DAO(pModelDAO *ModelIDAO) ModelDAO {
	o := new({{.DAOName}}IDAO)
	o.ModelIDAO = pModelDAO
	{{.DAOName}} = o
	return o
}

func (o {{.DAOName}}IDAO) All() []{{.Model}} {
	return o.CastAll(o.FindAllModels())
}

func (o {{.DAOName}}IDAO) Find({{range $i, $e := .Keys}}{{if $i}}, {{end}}p{{printf "%d" $i}} {{.Primitive}}{{end}}) *{{.Model}} {
	return o.Cast(o.FindModel({{range $i, $e := .Keys}}{{if $i}}, {{end}}New{{.TypeName}}(p{{printf "%d" $i}}){{end}}))
}

func (o {{.DAOName}}IDAO) Exec(pSql Sql) ([]{{.Model}}, error) {
	rows, err := o.Gem().Query({{.Model}}Model, pSql)
	if err != nil {
		return nil, err
	}
	return o.CastAll(rows), nil
}

func (o {{.DAOName}}IDAO) CastAll(pModels []Model) []{{.Model}} {
	list := make([]{{.Model}}, len(pModels))
	for i, model := range pModels {
		list[i] = *o.Cast(model)
	}
	return list
}

func ({{.DAOName}}IDAO) Cast(pModel Model) *{{.Model}} {
	if pModel != nil {
		return pModel.(*{{.Model}})
	}
	return nil
}