model.go

package yaorm

import (
	"database/sql"
	"fmt"
	"reflect"
	"strings"

	"github.com/geoffreybauduin/yaorm/tools"
	"github.com/geoffreybauduin/yaorm/yaormfilter"
	"github.com/juju/errors"
)

// Model is the interface every model should implement from
type Model interface {
	// GetDBP should return the DBProvider tied to this model
	GetDBP() DBProvider
	// SetDBP allows setting a DBProvider to the model, then returned by GetDBP
	SetDBP(dbp DBProvider)
	// Save allows saving the model
	Save() error
	// Load loads the model from database given the current struct
	Load(dbp DBProvider) error
	// Delete removes the model from database
	Delete() error
	// DBHookBeforeInsert is a hook called before performing a DB insertion
	DBHookBeforeInsert() error
	// DBHookBeforeUpdate is a hook called before performing a DB update
	DBHookBeforeUpdate() error
	// DBHookBeforeDelete is a hook called before performing a DB delete
	DBHookBeforeDelete() error
}

// DatabaseModel is the struct every model should compose
type DatabaseModel struct {
	dbp DBProvider `db:"-"`
}

// SetDBP allows setting a DBProvider to the model, then returned by GetDBP
func (dm *DatabaseModel) SetDBP(dbp DBProvider) {
	dm.dbp = dbp
}

// GetDBP should return the DBProvider tied to this model
func (dm *DatabaseModel) GetDBP() DBProvider {
	return dm.dbp
}

// Save allows saving the model
// In order to be usable, this function needs to be redfined by each
// composition of this structure
func (dm *DatabaseModel) Save() error {
	return errors.NotImplementedf("Save")
}

// Load loads the model from database given the current struct
// In order to be usable, this function needs to be redfined by each
// composition of this structure
func (dm *DatabaseModel) Load(dbp DBProvider) error {
	return errors.NotImplementedf("Load")
}

// Delete removes the model from database
// In order to be usable, this function needs to be redfined by each
// composition of this structure
func (dm *DatabaseModel) Delete() error {
	return errors.NotImplementedf("Delete")
}

// DBHookBeforeInsert is a hook called before performing a DB insertion
// By default, this function does not do anything. If needed, you will have
// to implement this function in your structure composing this one
// in order to have your code hook executed
func (dm *DatabaseModel) DBHookBeforeInsert() error {
	return nil
}

// DBHookBeforeUpdate is a hook called before performing a DB update
// By default, this function does not do anything. If needed, you will have
// to implement this function in your structure composing this one
// in order to have your code hook executed
func (dm *DatabaseModel) DBHookBeforeUpdate() error {
	return nil
}

// DBHookBeforeDelete is a hook called before performing a DB delete
// By default, this function does not do anything. If needed, you will have
// to implement this function in your structure composing this one
// in order to have your code hook executed
func (dm *DatabaseModel) DBHookBeforeDelete() error {
	return nil
}

type cnt struct {
	Count uint64 `db:"count"`
}

// GenericCount selects counts the row in the database
// panics if filter or dbp is nil
func GenericCount(dbp DBProvider, filter yaormfilter.Filter) (uint64, error) {
	table, err := GetTableByFilter(filter)
	if err != nil {
		return 0, err
	}
	statement, err := buildCount(dbp, table)
	if err != nil {
		return 0, err
	}
	statement = apply(statement, filter, dbp)
	query, params, err := statement.ToSql()
	if err != nil {
		return 0, err
	}
	counter := &cnt{}
	err = dbp.DB().SelectOne(counter, query, params...)
	if err != nil {
		return 0, err
	}
	return counter.Count, nil
}

// GenericSelectOne selects one row in the database
// panics if filter or dbp is nil
func GenericSelectOne(dbp DBProvider, filter yaormfilter.Filter) (Model, error) {
	table, err := GetTableByFilter(filter)
	if err != nil {
		return nil, err
	}
	m, err := table.NewModel()
	if err != nil {
		return nil, err
	}
	err = GenericSelectOneWithModel(dbp, filter, m)
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GenericSelectOneFromModel selects one row in the database from a model value
// panics if filter or dbp is nil
func GenericSelectOneFromModel(dbp DBProvider, m Model) error {
	table, err := GetTableByModel(m)
	if err != nil {
		return err
	}
	filter, err := table.NewFilter()
	if err != nil {
		return err
	}
	valueM := tools.GetNonPtrValue(m)
	typeM := valueM.Type()
	for i := 0; i < typeM.NumField(); i++ {
		tagValue, ok := typeM.Field(i).Tag.Lookup("db")
		if !ok || tagValue == "-" {
			continue
		}
		tagData := strings.Split(tagValue, ",")
		value := valueM.Field(i)
		if !tools.IsZeroValue(value) {
			idx := table.FilterFieldIndex(tagData[0])
			if idx < 0 {
				return errors.Errorf("Cannot find field with filter tag '%s' in filter %T", tagData[0], filter)
			}
			filterToApply := reflect.ValueOf(yaormfilter.Equals(value.Interface()))
			tools.GetNonPtrValue(filter).Field(idx).Set(filterToApply)
		}
	}
	return GenericSelectOneWithModel(dbp, filter, m)
}

// GenericSelectOneWithModel selects one row in the database providing the destination model directly
// panics if filter or dbp is nil
func GenericSelectOneWithModel(dbp DBProvider, filter yaormfilter.Filter, m Model) error {
	statement, err := buildSelect(dbp, m, buildSelectColumns{
		loadColumns:     filter.GetLoadColumns(),
		dontLoadColumns: filter.GetDontLoadColumns(),
	})
	if err != nil {
		return err
	}
	statement = apply(statement, filter, dbp)
	query, params, err := statement.ToSql()
	if err != nil {
		return err
	}
	err = dbp.DB().SelectOne(m, query, params...)
	if err != nil {
		if err == sql.ErrNoRows {
			return errors.NotFoundf(formatTablenameFromError(m))
		}
		return err
	}
	m.SetDBP(dbp)
	if filter != nil {
		err = finishSelect(dbp, m, filter)
	}
	return err
}

// GenericSelectAll selects all rows in the database
// panics if filter or dbp is nil
func GenericSelectAll(dbp DBProvider, filter yaormfilter.Filter) ([]Model, error) {
	table, err := GetTableByFilter(filter)
	if err != nil {
		return nil, err
	}
	m, err := table.NewModel()
	if err != nil {
		return nil, err
	}
	statement, err := buildSelect(dbp, m, buildSelectColumns{
		loadColumns:     filter.GetLoadColumns(),
		dontLoadColumns: filter.GetDontLoadColumns(),
	})
	if err != nil {
		return nil, err
	}
	sm, _ := table.NewSlicePtr()
	statement = apply(statement, filter, dbp)
	query, params, err := statement.ToSql()
	if err != nil {
		return nil, err
	}
	_, err = dbp.DB().Select(sm, query, params...)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, errors.NotFoundf(formatTablenameFromError(m))
		}
		return nil, err
	}
	models := make([]Model, 0)
	smValue := tools.GetNonPtrValue(sm)
	for i := 0; i < smValue.Len(); i++ {
		m := smValue.Index(i).Interface().(Model)
		m.SetDBP(dbp)
		models = append(models, m)
	}
	if filter != nil {
		err = finishSelect(dbp, models, filter)
	}
	return models, err
}

// GenericSave updates or inserts the provided model in the database
// panics if model is nil or not linked to dbp
func GenericSave(m Model) error {
	table, err := GetTableByModel(m)
	if err != nil {
		return err
	}
	// loop over primary keys
	// if they are both to zero value, then it means it's an insert
	// if they are both set to values, then it's an update
	// otherwise, scream
	keys := table.KeyFields()
	if len(keys) == 1 {
		return genericSaveOnePK(m, keys)
	}
	return genericSaveMultiplePK(table, m, keys)
}

// SaveWithPrimaryKeys updates or inserts the provided model in the database, using the provided keys to
// check if it exists
func SaveWithPrimaryKeys(m Model, keys []string) error {
	table, err := GetTableByModel(m)
	if err != nil {
		return err
	}
	keyIndices := table.KeyFields()
	keysMap := map[string]int{}
	for _, key := range keys {
		if _, ok := keyIndices[key]; !ok {
			return errors.Errorf("Field %s is not a primary key of table %s", key, table.Name())
		}
		keysMap[key] = table.FieldIndex(key)
		if keysMap[key] == -1 {
			return errors.Errorf("Field %s is not defined in table %s", key, table.Name())
		}
	}
	return genericSaveMultiplePK(table, m, keysMap)
}

func genericSaveMultiplePK(table *Table, m Model, keys map[string]int) error {
	f, err := table.NewFilter()
	if err != nil {
		return err
	}
	reflectedModel := tools.GetNonPtrValue(m)
	for fieldName, idx := range keys {
		field := reflectedModel.Field(idx)
		if tools.IsNil(field) {
			return errors.Errorf("Cannot save this model: one Primary Key has zero value")
		}
		filterIdx := table.FilterFieldIndex(fieldName)
		if filterIdx == -1 {
			return errors.Errorf("Cannot find field %s inside table %s filter", fieldName, table.Name())
		}
		tools.GetNonPtrValue(f).Field(filterIdx).Set(reflect.ValueOf(yaormfilter.Equals(field.Interface())))
	}
	_, err = GenericSelectOne(m.GetDBP(), f)
	if err != nil && errors.IsNotFound(err) {
		return GenericInsert(m)
	} else if err == nil {
		return GenericUpdate(m)
	}
	return err
}

func genericSaveOnePK(m Model, keys map[string]int) error {
	isZero := true
	reflectedModel := tools.GetNonPtrValue(m)
	for _, idx := range keys {
		field := reflectedModel.Field(idx)
		if !tools.IsZeroValue(field) {
			isZero = false
			break
		}
	}
	if isZero {
		return GenericInsert(m)
	}
	return GenericUpdate(m)
}

// GenericUpdate updates the provided model in the database
// panics if model is nil or not linked to dbp
func GenericUpdate(m Model) error {
	err := m.DBHookBeforeUpdate()
	if err != nil {
		return err
	}
	_, err = m.GetDBP().DB().Update(m)
	return err
}

// GenericInsert inserts the provided model in the database
// panics if model is nil or not linked to dbp
func GenericInsert(m Model) error {
	err := m.DBHookBeforeInsert()
	if err != nil {
		return err
	}
	err = m.GetDBP().DB().Insert(m)
	return err
}

func formatTablenameFromError(m Model) string {
	table, err := GetTableByModel(m)
	if err != nil {
		return ""
	}
	tableName := table.Name()
	tableName = strings.Replace(tableName, "_", " ", -1)
	words := strings.Split(tableName, " ")
	for i := 0; i < len(words); i++ {
		words[i] = strings.Title(words[i])
	}
	return strings.Join(words, "")
}

func filterShouldSubqueryload(filterFound reflect.Value) bool {
	f := filterFound.Interface()
	switch f.(type) {
	case yaormfilter.Filter:
		return f.(yaormfilter.Filter).ShouldSubqueryload()
	case []yaormfilter.Filter:
		arr := f.([]yaormfilter.Filter)
		for _, arrElem := range arr {
			if arrElem.ShouldSubqueryload() {
				return true
			}
		}
	}
	return false
}

func finishSelect(dbp DBProvider, m interface{}, f yaormfilter.Filter) error {
	fkPerModel := map[string]map[interface{}][]reflect.Value{}
	valueF := reflect.Indirect(reflect.ValueOf(f))
	if !valueF.IsValid() {
		return nil
	}
	st := valueF.Type()
	for i := 0; i < st.NumField(); i++ {
		field := st.Field(i)
		dbFieldData, ok := field.Tag.Lookup("filterload")
		if !ok || dbFieldData == "-" {
			// Skip
			continue
		}
		filterFound := valueF.Field(i)
		if !filterFound.IsNil() && filterShouldSubqueryload(filterFound) {
			// prevent scope overriding of fkPerModel
			var err error
			fkPerModel, err = feedFkPerModel(m, fkPerModel, dbFieldData)
			if err != nil {
				return err
			}
		}
	}
	d, err := subqueryload(dbp, fkPerModel)
	if err != nil {
		return err
	}
	for model, data := range d {
		realModel := strings.Split(model, "_per_")[0]
		for i := 0; i < st.NumField(); i++ {
			field := st.Field(i)
			dbFieldData, ok := field.Tag.Lookup("filterload")
			if !ok || dbFieldData != realModel {
				// Skip
				continue
			}
			filterFound := valueF.Field(i)
			if !filterFound.IsNil() && filterShouldSubqueryload(filterFound) {
				err = finishSelectFromFilter(dbp, data, filterFound.Interface())
				if err != nil {
					return err
				}
			}
		}
	}
	return nil
}

func finishSelectFromFilter(dbp DBProvider, m interface{}, f interface{}) error {
	switch f.(type) {
	case yaormfilter.Filter:
		err := finishSelect(dbp, m, f.(yaormfilter.Filter))
		if err != nil {
			return err
		}
		return nil
	case []yaormfilter.Filter:
		arr := f.([]yaormfilter.Filter)
		for _, arrElem := range arr {
			err := finishSelect(dbp, m, arrElem)
			if err != nil {
				return err
			}
		}
		return nil
	}
	return errors.Errorf("Could not cast filter provided to correct type")
}

func feedFkPerModel(m interface{}, fkPerModel map[string]map[interface{}][]reflect.Value, dbFieldData string) (map[string]map[interface{}][]reflect.Value, error) {
	s := reflect.Indirect(reflect.ValueOf(m))
	if s.Kind() == reflect.Slice {
		for i := 0; i < s.Len(); i++ {
			var err error
			fkPerModel, err = feedFkPerModel(s.Index(i).Interface(), fkPerModel, dbFieldData)
			if err != nil {
				return nil, err
			}
		}
	} else {
		idx, tag := getFieldInModel(m.(Model), "filterload", dbFieldData)
		if idx > -1 {
			tagData := strings.Split(tag, ",")
			if len(tagData) < 2 {
				return nil, errors.Errorf("tag 'filterload' %+v is invalid, must have at least 2 parts", tagData)
			}
			if len(tagData) == 3 {
				// it's a reverse filter
				tagData[0] = fmt.Sprintf("%s_per_%s", tagData[0], tagData[2])
			}
			idxFk, _ := getFieldInModel(m.(Model), "db", tagData[1])
			if idxFk > -1 {
				fkReflectedvalue := s.Field(idxFk)
				if !tools.IsZeroValue(fkReflectedvalue) {
					fkValue := reflect.Indirect(fkReflectedvalue).Interface()
					if _, ok := fkPerModel[tagData[0]]; !ok {
						fkPerModel[tagData[0]] = map[interface{}][]reflect.Value{}
					}
					if _, ok := fkPerModel[tagData[0]][fkValue]; !ok {
						fkPerModel[tagData[0]][fkValue] = []reflect.Value{}
					}
					fkPerModel[tagData[0]][fkValue] = append(fkPerModel[tagData[0]][fkValue], s.Field(idx).Addr())
				}
			} else {
				t, err := GetTableByModel(m.(Model))
				if err != nil {
					return nil, err
				}
				return nil, errors.Errorf("Cannot find fk %s in model %s struct", tagData[1], t.Name())
			}
		} else {
			return nil, errors.Errorf("Cannot find tag filterload:%v in model struct", dbFieldData)
		}
	}
	return fkPerModel, nil
}

func getFieldInModel(m Model, tag, equals string) (int, string) {
	st := reflect.Indirect(reflect.ValueOf(m)).Type()
	for i := 0; i < st.NumField(); i++ {
		field := st.Field(i)
		dbFieldData, ok := field.Tag.Lookup(tag)
		if !ok {
			continue
		}
		tagData := strings.Split(dbFieldData, ",")
		if tagData[0] == equals {
			return i, dbFieldData
		}
	}
	return -1, ""
}

// GenericDelete will delete the provided model from its database
// Returns the number of rows deleted
func GenericDelete(m Model) (int64, error) {
	err := m.DBHookBeforeDelete()
	if err != nil {
		return 0, err
	}
	return m.GetDBP().DB().Delete(m)
}