package temp

var Dao = `
{{$modelName:=.GetModelPathName}}
{{$daoName:=.GetStructName}}

package {{.DaoPackage}}

import (
	"cjjy-cases-server/business/dto"
	"cjjy-cases-server/business/exception"
	"cjjy-cases-server/business/model"
	"cjjy-cases-server/business/util/pagination"
	"context"
	"gitea.ckfah.com/cjjy/gocommon/pkg/cerror"
	"gitea.ckfah.com/cjjy/gocommon/pkg/database/db"
	"gitea.ckfah.com/cjjy/gocommon/pkg/logger"
	"xorm.io/xorm"
)

type {{$daoName}} struct {
}

func {{.GetNewStructFunc}}() *{{$daoName}} {
	return &{{$daoName}}{}
}

var (
	_{{.GetModelName}} = new({{$modelName}})
)

func (*{{$daoName}}) TableName() string {
	return _{{.GetModelName}}.TableName()
}

func (thisDao *{{$daoName}}) GetById(ctx context.Context, id uint64) (*{{$modelName}}, cerror.Cerror) {
	methodName := "{{$daoName}}.GetById"
	logger.Infoc(ctx, "[%s] start,id:%d", methodName, id)
	result := &{{$modelName}}{}
	session := db.StdSlaveDB().Where("id=?", id)
	isExist, err := SoftDeleteFilterDao(ctx, session).Cols("*").Get(result)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.Get() err,err:%+v,id:%d", methodName, err, id)
		return nil, exception.DbExecError(err)
	}
	logger.Infoc(ctx, "[%s] end,id:%d,result:%+v", methodName, id, result)
	if !isExist {
		return nil, nil
	}
	return result, nil
}

func (thisDao *{{$daoName}}) GetByIds(ctx context.Context, ids []uint64) ([]{{$modelName}}, cerror.Cerror) {
	methodName := "{{$daoName}}.GetByIds"
	logger.Infoc(ctx, "[%s] start,ids:%+v", methodName, ids)
	result := make([]{{$modelName}}, 0)
	session := db.StdSlaveDB().In("id", ids)
	err := SoftDeleteFilterDao(ctx, session).Cols("*").Find(&result)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.Find() err,err:%+v,ids:%+v", methodName, err, ids)
		return nil, exception.DbExecError(err)
	}
	logger.Infoc(ctx, "[%s] end,ids:%+v,result:%+v", methodName, ids, result)
	return result, nil
}

func (thisDao *{{$daoName}}) GetMapsByIds(ctx context.Context, ids []uint64) (map[uint64]{{$modelName}}, cerror.Cerror) {
	methodName := "{{$daoName}}.GetMapsByIds"
	logger.Infoc(ctx, "[%s] start,ids:%+v", methodName, ids)
	resultMaps := make(map[uint64]{{$modelName}})
	result, err := thisDao.GetByIds(ctx, ids)
	if err != nil {
		logger.Errorc(ctx, "[%s] call thisDao.GetByIds() err,err:%+v,ids:%+v", methodName, err, ids)
		return nil, exception.DbExecError(err)
	}
	if len(result) > 0 {
		for _, item := range result {
			resultMaps[item.ID] = item
		}
	}
	logger.Infoc(ctx, "[%s] end,ids:%+v,result:%+v,resultMaps:%+v", methodName, ids, result, resultMaps)
	return resultMaps, nil
}

func (thisDao *{{$daoName}}) DeleteById(ctx context.Context, session *xorm.Session, id uint64) (int64, cerror.Cerror) {
	methodName := "{{$daoName}}.DeleteById"
	logger.Infoc(ctx, "[%s] start,id:%d", methodName, id)	
	effectRow, err := SoftDeleteFilterDao(ctx, session).Where("id=?", id).Delete(thisDao)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.Delete() err,err:%+v,id:%d", methodName, err, id)
		return 0, exception.DbDeleteError(err)
	}
	logger.Infoc(ctx, "[%s] end,id:%d,effectRow:%+v", methodName, id, effectRow)
	return effectRow, nil
}

func (thisDao *{{$daoName}}) UpdateById(ctx context.Context, session *xorm.Session, params *model.CjjyCase) (int64, cerror.Cerror) {
	methodName := "{{$daoName}}.UpdateById"
	logger.Infoc(ctx, "[%s] start,params:%+v", methodName, params)
	effectRow, err := session.Table(thisDao).Where("id=?", params.ID).Update(params)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.Update() err,err:%+v,params:%+v", methodName, err, params)
		return 0, exception.DbUpdateError(err)
	}
	logger.Infoc(ctx, "[%s] end,params:%+v,effectRow:%d", methodName, params, effectRow)
	return effectRow, nil
}

func (thisDao *{{$daoName}}) UpdateMapById(ctx context.Context, session *xorm.Session, id uint64, params map[string]interface{}) (int64, cerror.Cerror) {
	methodName := "{{$daoName}}.UpdateMapById"
	logger.Infoc(ctx, "[%s] start,id:%d,params:%+v", methodName, id, params)
	effectRow, err := SoftDeleteFilterDao(ctx, session).Table(thisDao).Where("id=?", id).Update(params)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.Update() err,err:%+v,id:%d,params:%+v", methodName, err, id, params)
		return 0, exception.DbUpdateError(err)
	}
	logger.Infoc(ctx, "[%s] end,id:%d,params:%+v,effectRow:%+v", methodName, id, params, effectRow)
	return effectRow, nil
}

func (thisDao *{{$daoName}}) UpdateMapByIds(ctx context.Context, session *xorm.Session, ids []uint64, params map[string]interface{}) (int64, cerror.Cerror) {
	methodName := "{{$daoName}}.UpdateMapByIds"	
	logger.Infoc(ctx, "[%s] start,ids:%+v,params:%+v", methodName, ids, params)	
	effectRow, err := SoftDeleteFilterDao(ctx, session).Table(thisDao).In("id", ids).Update(params)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.Update() err,err:%+v,ids:%+v,params:%+v", methodName, err, ids, params)
		return 0, exception.DbUpdateError(err)
	}
	logger.Infoc(ctx, "[%s] end,ids:%+v,params:%+v,effectRow:%+v", methodName, ids, params, effectRow)
	return effectRow, nil
}

func (thisDao *{{$daoName}}) InsertOne(ctx context.Context, session *xorm.Session, params *{{$modelName}}) (int64, cerror.Cerror) {
	methodName := "{{$daoName}}.InsertOne"
	logger.Infoc(ctx, "[%s] start,params:%+v", methodName, params)
	effectRow, err := session.InsertOne(params)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.InsertOne() err,err:%+v,params:%+v", methodName, err, params)
		return 0, exception.DbInsertError(err)
	}
	logger.Infoc(ctx, "[%s] end,params:%+v,effectRow:%+v", methodName, params, effectRow)
	return effectRow, nil
}

func (thisDao *{{$daoName}}) InsertMany(ctx context.Context, session *xorm.Session, params *[]{{$modelName}}) (int64, cerror.Cerror) {
	methodName := "{{$daoName}}.InsertMany"
	logger.Infoc(ctx, "[%s] start,params:%+v", methodName, params)
	effectRow, err := session.Insert(params)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.Insert() err,err:%+v,params:%+v", methodName, err, params)
		return 0, exception.DbInsertError(err)
	}
	logger.Infoc(ctx, "[%s] end,params:%+v,effectRow:%+v", methodName, params, effectRow)
	return effectRow, nil
}

func (thisDao *{{$daoName}}) GetAll(ctx context.Context) ([]{{$modelName}}, cerror.Cerror) {
	methodName := "{{$daoName}}.GetAll"
	logger.Infoc(ctx, "[%s] start", methodName)
	result := make([]{{$modelName}}, 0)
	session := db.StdSlaveDB().Cols("*")
	err := SoftDeleteFilterDao(ctx, session).Find(&result)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.Find() err,err:%+v", methodName, err)
		return nil, exception.DbExecError(err)
	}
	logger.Infoc(ctx, "[%s] end,result:%+v", methodName, result)
	return result, nil
}

func (thisDao *{{$daoName}}) GetAllMaps(ctx context.Context) (map[uint64]{{$modelName}}, cerror.Cerror) {
	methodName := "{{$daoName}}.GetAllMaps"
	logger.Infoc(ctx, "[%s] start", methodName)
	resultMaps := make(map[uint64]{{$modelName}})
	result, err := thisDao.GetAll(ctx)
	if err != nil {
		logger.Errorc(ctx, "[%s] call thisDao.GetAll() err,err:%+v", methodName, err)
		return nil, exception.DbExecError(err)
	}
	if len(result) > 0 {
		for _, item := range result {
			resultMaps[item.ID] = item
		}
	}
	logger.Infoc(ctx, "[%s] end,result:%+v,resultMaps:%+v", methodName, result, resultMaps)
	return resultMaps, nil
}

func (thisDao *{{$daoName}}) GetPageList(ctx context.Context, params *dto.GetPageListParams) ([]{{$modelName}}, int64, cerror.Cerror) {
	methodName := "{{$daoName}}.GetPageList"	
	logger.Infoc(ctx, "[%s] start,params:%+v", methodName, params)
	result := make([]{{$modelName}}, 0)
	session := db.StdSlaveDB().Table(new({{$modelName}}))
	start, limit := pagination.GetLimitAndCount(params.NewPageRequest)
	count, err := SoftDeleteFilterDao(ctx, session).Limit(limit, start).Desc("id").FindAndCount(&result)
	if err != nil {
		logger.Errorc(ctx, "[%s] call db.FindAndCount() err,err:%+v,params:%+v", methodName, err, params)
		return nil, 0, exception.DbExecError(err)
	}
	logger.Infoc(ctx, "[%s] end,result:%+v,count:%d,params:%+v", methodName, result, count, params)
	return result, count, nil
}
`

var Model = `
package {{.PackageName}}

{{if .HasTimeFiled}}
import (
	"time"
)
{{end}}

/**
{{.GetCreateSql}}
*/

type {{.ModelName}} struct {
    {{range .Fields}}
    {{.GetGoField}} {{.GetGoType}} {{if .GetTag}}{{.GetTag}}{{end}}{{end}}
}

func (*{{.ModelName}}) TableName() string {
	return "{{.TableName}}"
}
`

var Dto = `
type {{Upper .TableName}}Dto struct {
    {{range .TableField}}
	{{.GetGoField}} {{.GetGoDaoType}} {{.GetDtoTag}} {{if .ColumnComment}}//{{.ColumnComment}}{{end}}{{end}}
}
`