xps-server-go/repositories/x_bus_rebo.go

package repositories

import (
    "errors"
    "fmt"
    "math"
    "strconv"
    "time"
    "xorm.io/xorm"
    "xps/cache"
    "xps/constant"
    "xps/viewmodels"
)

type XBusRepo struct {
    engine *xorm.Engine
}

func NewXBusRepo(engine *xorm.Engine) *XBusRepo {
    return &XBusRepo{
        engine: engine,
    }
}

func (d *XBusRepo) BuildPageQueryParam(params []viewmodels.QueryParam)(string, int, int, error) {
    sqlWhere := " WHERE 1 = 1 "
    limit    := int(0)
    page     := int(0)
    ok       := false
    for _, param := range params {
        if param.Name == "limit" {
            limit, ok = param.Value.(int)
            if !ok {
                return sqlWhere, limit, page, errors.New("limit值不正确")
            }
        } else if param.Name == "page" {
            page, ok = param.Value.(int)
            if !ok {
                return sqlWhere, limit, page, errors.New("page值不正确")
            }
        } else {
            sqlWhere += fmt.Sprintf(" %s %v %s %v", param.LogicalOperator, param.Name, param.CompareOperator, param.Value )
        }
    }
    return sqlWhere, limit, page, nil
}

func (d *XBusRepo) BuildQueryParam(params []viewmodels.QueryParam)(string, error) {
    sqlWhere := " WHERE 1 = 1 "
    for _, param := range params {
        sqlWhere += fmt.Sprintf(" %s %v %s %v", param.LogicalOperator, param.Name, param.CompareOperator, param.Value )
    }
    return sqlWhere, nil
}

func (d *XBusRepo) GetPage(sqlStatement, sqlCount string, params []viewmodels.QueryParam) (*viewmodels.PageResult, error) {
    sqlWhere, limit, page, err1 := d.BuildPageQueryParam(params)
    if err1 != nil {
        return nil, err1
    }
    
    res, err2 := d.engine.Query(sqlCount + sqlWhere)
    if err2 != nil {
        return nil, err2
    }
    
    total := int64(0)
    for _, v := range res[0] {
        total, _ = strconv.ParseInt(string(v), 10, 64)
    }
    
    pageStart  := (page - 1) * limit
    sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
    
    results, err4 := d.engine.QueryInterface(sqlStatement + sqlWhere + sqlLimit)
    if err4 != nil {
        return nil, err4
    }
    
    pageResult := &viewmodels.PageResult{}
    pageResult.Data     = results
    pageResult.Total    = total
    pageResult.PageSize = limit
    pageResult.Page     = page
    pageResult.TotalPage= int64(math.Ceil(float64(total / int64(limit))))
    return pageResult, nil
}

func (d *XBusRepo) GetList(sqlStatement string, params []viewmodels.QueryParam) ([]map[string]interface{}, error) {
    sqlWhere, err1 := d.BuildQueryParam(params)
    if err1 != nil {
        return nil, err1
    }
    
    results, err := d.engine.QueryInterface(sqlStatement + sqlWhere)
    if err != nil {
        return nil, err
    }
    return results, nil
}

func (d *XBusRepo) GetById(sqlStatement string, params []viewmodels.QueryParam)(map[string]interface{}, error){
    sqlWhere, err1 := d.BuildQueryParam(params)
    if err1 != nil {
        return nil, err1
    }
    
    results, err   := d.engine.QueryInterface(sqlStatement + sqlWhere)
    if err != nil {
        return nil, err
    }
    if len(results) > 1 {
        return nil, errors.New(" 主键不唯一")
    }
    
    return results[0], nil
}

func (d *XBusRepo) Create(objectCode string, values map[string]interface{}) error {
    object, err1 := cache.GetModelObject(objectCode)
    if err1 != nil {
        return err1
    }
    
    tableName := object.ObjectCode
    fields, err2 := cache.GetModelObjectAttrs(objectCode)
    if err2 != nil {
        return err2
    }
    
    sql := "INSERT INTO" + fmt.Sprintf(" %s ", tableName)
    sqlFields := "( "
    sqlValues := "VALUES ( "
    for idx, field := range fields {
        fieldName := field.AttrCode
        fieldType := field.AttrType
        fieldValue, ok := values[fieldName]
        if !ok {
            return nil
        }
        
        if idx > 0 {
            sqlFields += ","
            sqlValues += ","
        }
    
        sqlFields += fieldName + ""
        if fieldType == constant.DATA_TYPE_DATE ||
            fieldType == constant.DATA_TYPE_DATETIME ||
            fieldType == constant.DATA_TYPE_VARCHAR {
            sqlValues += fmt.Sprintf("'%v'", fieldValue) + ""
        } else {
            sqlValues += fmt.Sprintf("%v", fieldValue) + ""
        }
        
    }
    sqlFields += ") "
    sqlValues += ") "
    
    _, err3 := d.engine.Exec(sql + sqlFields + sqlValues)
    return err3
}

func (d *XBusRepo) Update(objectCode string, values map[string]interface{}) error {
    object, err1 := cache.GetModelObject(objectCode)
    if err1 != nil {
        return err1
    }
    
    tableName := object.ObjectCode
    fields, err2 := cache.GetModelObjectAttrs(objectCode)
    if err2 != nil {
        return err2
    }
    
    sql := fmt.Sprintf("UPDATE %s ", tableName)
    
    sqlFieldSets := " SET "
    sqlWhere     := " WHERE 1 = 1 "
    bFirstSetValue := true
    for _, field := range fields {
        fieldName := field.AttrCode
        fieldType := field.AttrType
        fieldValue, ok := values[fieldName]
        if !ok {
            return nil
        }
    
        if !bFirstSetValue {
            sqlFieldSets += ","
        }
        
        if field.IsPKey <= 0 {
            bFirstSetValue = false
            if fieldType == constant.DATA_TYPE_DATE ||
                fieldType == constant.DATA_TYPE_DATETIME ||
                fieldType == constant.DATA_TYPE_VARCHAR {
                sqlFieldSets += fmt.Sprintf(" %s = '%v' ", fieldName, fieldValue) + ""
            } else {
                sqlFieldSets += fmt.Sprintf(" %s = %v ", fieldName, fieldValue) + ""
            }
            
        } else {
            if fieldType == constant.DATA_TYPE_DATE ||
                fieldType == constant.DATA_TYPE_DATETIME ||
                fieldType == constant.DATA_TYPE_VARCHAR {
                sqlWhere += fmt.Sprintf(" AND %s = '%v' ", fieldName, fieldValue) + ""
            } else {
                sqlWhere += fmt.Sprintf(" AND %s = %v ", fieldName, fieldValue) + ""
            }
        }
    }
    
    _, err := d.engine.Exec(sql + sqlFieldSets + sqlWhere)
    return err
}

func (d *XBusRepo) Patch(objectCode string, values map[string]interface{}) error {
    object, err1 := cache.GetModelObject(objectCode)
    if err1 != nil {
        return err1
    }
    
    tableName := object.ObjectCode
    fields, err2 := cache.GetModelObjectAttrs(objectCode)
    if err2 != nil {
        return err2
    }
    
    sql := fmt.Sprintf("UPDATE table %s ", tableName)
    
    sqlFieldSets := "SET "
    sqlWhere     := "WHERE 1 = 1"
    for idx, field := range fields {
        fieldName := field.AttrCode
        fieldType := field.AttrType
        fieldValue, ok := values[fieldName]
        if !ok {
            return nil
        }
        
        if idx > 0 {
            sqlFieldSets += ","
        }
        
        if field.IsPKey <= 0 {
            if fieldType == constant.DATA_TYPE_DATE ||
                fieldType == constant.DATA_TYPE_DATETIME ||
                fieldType == constant.DATA_TYPE_VARCHAR {
                sqlFieldSets += fmt.Sprintf(" %s = '%v' ", fieldName, fieldValue) + ""
            } else {
                sqlFieldSets += fmt.Sprintf(" %s = %v ", fieldName, fieldValue) + ""
            }
            
        } else {
            if fieldType == constant.DATA_TYPE_DATE ||
                fieldType == constant.DATA_TYPE_DATETIME ||
                fieldType == constant.DATA_TYPE_VARCHAR {
                sqlWhere += fmt.Sprintf(" AND %s = '%v' ", fieldName, fieldValue) + ""
            } else {
                sqlWhere += fmt.Sprintf(" AND %s = %v ", fieldName, fieldValue) + ""
            }
        }
    }
    _, err := d.engine.Exec(sql + sqlFieldSets + sqlWhere)
    return err
}

func (d *XBusRepo) Delete(objectCode string, values map[string]interface{}) error {
    object, err1 := cache.GetModelObject(objectCode)
    if err1 == nil {
        return err1
    }
    
    tableName := object.ObjectCode
    fields, err2 := cache.GetModelObjectAttrs(objectCode)
    if err2 != nil {
        return err2
    }
    
    deletedBy := values["deletedBy"].(int64)
    
    sql := fmt.Sprintf("UPDATE table %s ", tableName)
    sqlFieldSets   := fmt.Sprintf("SET deleted_flag = 1 AND deleted_by = %d AND deleted_at = %s", deletedBy, time.Now().String())
    
    sqlWhere := "WHERE 1 = 1"
    for idx, field := range fields {
        fieldName := field.AttrCode
        fieldType := field.AttrType
        fieldValue, ok := values[fieldName]
        if !ok {
            return nil
        }
        
        if idx > 0 {
            sqlFieldSets += ","
        }
        
        if field.IsPKey >= 1 {
            if fieldType == constant.DATA_TYPE_DATE ||
                fieldType == constant.DATA_TYPE_DATETIME ||
                fieldType == constant.DATA_TYPE_VARCHAR {
                sqlFieldSets += fmt.Sprintf(" %s = '%v' ", fieldName, fieldValue) + ""
            } else {
                sqlFieldSets += fmt.Sprintf(" %s = %v ", fieldName, fieldValue) + ""
            }
        }
    }
    
    _, err := d.engine.Exec(sql + sqlFieldSets + sqlWhere)
    return err
}