type {{Table}} struct {
{% for col in structArr %} {{col.key}} {{col.type}} json:"{{col.jsonTag}}"{% if col.sql %} sql:"{{col.sql}}"{% endif %}
{% if !col.type %} // TODO: 类型判断错误,请自行选择类型 {% endif %}
{% endfor %}
}
const {{Table}}Table = "{{snake}}"
func Create{{Table}}(e *{{Table}}) *{{Table}} {
return DBCreate{{Table}}(DB({{Table}}Table), e)
}
func DBCreate{{Table}}(db *gorm.DB, e *{{Table}}) *{{Table}} {
err := db.Create(e).Error
if err != nil {
logger.Errorf("create {{table}} [%v] fails: %s", e, err.Error())
return nil
}
return e
}
func Update{{Table}}({{pk}} {{type}}, m map[string]interface{}) (*{{Table}}, int64, bool, error) {
return DBUpdate{{Table}}(DB({{Table}}Table), {{pk}}, m)
}
func DBUpdate{{Table}}(db gorm.DB, {{pk}} {{type}}, m map[string]interface{}) ({{Table}}, int64, bool, error) {
delete(m, "{{pk_snake}}")
delete(m, "ctime")
delete(m, "utime")
aff := db.Model(&{{Table}}{}).Where("{{pk_snake}} = ?", {{pk}}).UpdateColumns(m).RowsAffected
e := &{{Table}}{}
if err := db.Where("{{pk_snake}} = ?", {{pk}}).First(e).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, aff, false, nil
} else {
logger.Errorf("%v", err)
return nil, aff, false, err
}
}
return e, aff, true, nil
}
func Get{{Table}}({{pk}} {{type}}) *{{Table}} {
return DBGet{{Table}}(DB({{Table}}Table), {{pk}})
}
func DBGet{{Table}}(db *gorm.DB, {{pk}} {{type}}) *{{Table}} {
e := &{{Table}}{}
if err := db.Where("{{pk_snake}} = ?", {{pk}}).First(e).Error; err != nil {
logger.Errorf("get {{table}} [%d] fails: %s", {{pk}}, err.Error())
return nil
}
return e
}
func Get{{Table}}s(m map[string]interface{}) []*{{Table}} {
return DBGet{{Table}}s(DB({{Table}}Table), m)
}
func DBGet{{Table}}s(db gorm.DB, m map[string]interface{}) []{{Table}} {
result := []*{{Table}}{}
if err := db.Where(m).Find(&result).Error; err != nil {
logger.Errorf("get {{table}} with filter [%v] fails: %s", m, err.Error())
return nil
}
return result
}
func Get{{Table}}sBy{{Pk}}s({{pk}}s []{{type}}) []*{{Table}} {
return DBGet{{Table}}sBy{{Pk}}s(DB({{Table}}Table), {{pk}}s)
}
func DBGet{{Table}}sBy{{Pk}}s(db gorm.DB, {{pk}}s []{{type}}) []{{Table}} {
result := []*{{Table}}{}
if err := db.Where("{{pk_snake}} in (?)", {{pk}}s).Order("{{pk_snake}} asc").Find(&result).Error; err != nil {
logger.Errorf("get {{table}} with {{pk}}s %v fails: %s", {{pk}}s, err.Error())
return nil
}
return result
}
func Delete{{Table}}({{pk}} {{type}}) {
DBDelete{{Table}}(DB({{Table}}Table), {{pk}})
}
func DBDelete{{Table}}(db *gorm.DB, {{pk}} {{type}}){
if err := db.Where("{{pk_snake}} = ?", {{pk}}).Delete({{Table}}{}).Error; err != nil {
logger.Errorf("delete {{table}} [%d] fails: %s", {{pk}}, err.Error())
}
func Get{{Table}}sByOffset(offset int, m map[string]interface{}, rawq string, order int, ordcond string, limit int, getCount bool) ([]*{{Table}}, int) {
return DBGet{{Table}}sByOffset(DB({{Table}}Table), offset, m, rawq, order, ordcond, limit, getCount)
}
func DBGet{{Table}}sByOffset(db gorm.DB, offset int, m map[string]interface{}, rawq string, order int, ordcond string, limit int, getCount bool) ([]{{Table}}, int) {
totalCount := 0
result := make([]*{{Table}}, 0)
db = db.Model({{Table}}{})
if m != nil {
db = db.Where(m)
}
if len(rawq) > 0 {
db = db.Where(rawq)
}
if order > 0 {
db = db.Order("{{pk_snake}} asc")
} else if order < 0 {
db = db.Order("{{pk_snake}} desc")
} else if len(ordcond) > 0 {
db = db.Order(ordcond)
}
if getCount {
db.Count(&totalCount)
}
if limit > 0 {
db = db.Limit(limit)
}
if err := db.Offset(offset).Find(&result).Error; err != nil {
logger.Errorf("get {{table}} by offset fails: %s", err.Error)
return nil, 0
}
return result, totalCount
}
func Get{{Table}}sByTime(start time.Time, end time.Time, m map[string]interface{}, rawq string, limit int, getCount bool) ([]*{{Table}}, int) {
return DBGet{{Table}}sByTime(DB({{Table}}Table), start, end, m, rawq, limit, getCount)
}
func DBGet{{Table}}sByTime(db gorm.DB, start time.Time, end time.Time, m map[string]interface{}, rawq string, limit int, getCount bool) ([]{{Table}}, int) {
totalCount := 0
result := make([]*{{Table}}, 0)
db = db.Model({{Table}}{})
if m != nil {
db = db.Where(m)
}
if len(rawq) > 0 {
db = db.Where(rawq)
}
db = db.Where("ctime > ?", start)
if end.After(start) {
db = db.Where("ctime < ?", end)
}
if getCount {
db.Count(&totalCount)
}
if err := db.Order("ctime asc").Limit(limit).Find(&result).Error; err != nil {
logger.Errorf("get {{table}} by time fails: %s", err.Error())
return nil, 0
}
return result, totalCount
}
// Get{{Table}}sByFilter json 分页获取
// @param filter query string false "{"key":value}"
// @param pageSize query int false "PageSize"
// @param current query int false "Current"
// @success 200 {object} dao.{{Table}}
// @router /{{AppName}}/table/{{table}}sByFilter [get]
func Get{{Table}}sByFilter(c *gin.Context) {
current := c.MustGet("current").(int64)
pagesize := c.MustGet("pageSize").(int64)
jsonstring := c.MustGet("filter").(string)
filter := make(map[string]interface{})
err := json.Unmarshal([]byte(jsonstring), &filter)
if err != nil {
c.JSON(http.StatusOK, &utils.Response{Code:e.INVALID_PARAMS,Msg:err.Error(),Data:nil})
return
}
res, cnt := dao.Get{{Table}}sByOffset(
int(uint(current-1))*int(pagesize),
utils.MCamelToSnake(filter),
"", 0, "", int(pagesize),true,
)
c.JSON(http.StatusOK, &utils.Response{Code: e.SUCCESS, Msg: "", Data: map[string]interface{}{
"list": res,
"count": cnt,
}})
}