Go实战全家桶之十二: go dbWebClient基于泛型的通用DB客户端dbwebreq封装

编程语言 2024-11-01 19:51:58 阅读次数: 0

测试用例

package dbwebreq

import (
    "git.ichub.com/general/webcli120/goconfig/base/basedto"
    "git.ichub.com/general/webcli120/goconfig/base/basemodel"
    "git.ichub.com/general/webcli120/goconfig/ichublog/golog"
    "git.ichub.com/general/webcli120/internal/domain/db/model"
    "github.com/sirupsen/logrus"
    "github.com/stretchr/testify/suite"
    "testing"
)

type TestDbWebReqSuite struct {
    suite.Suite
}

func TestDbWebReqSuites(t *testing.T) {
    suite.Run(t, new(TestDbWebReqSuite))
}

func (suite *TestDbWebReqSuite) SetupSuite() {
    logrus.Info(" setup suite")

}

func (suite *TestDbWebReqSuite) TearDownSuite() {
    logrus.Info(" teardown suite")

}
func (suite *TestDbWebReqSuite) SetupTest() {
    logrus.Info(" setup test")
}

func (suite *TestDbWebReqSuite) TearDownTest() {
    logrus.Info(" teardown test")
}

func (suite *TestDbWebReqSuite) Test001_GeneralQuery() {
    var req = Default[*model.ServiceApiList]()
    req.SetPageSize(2)
    req.Eq("id", 1014952995308011523)
    var result = req.GeneralQuery()
    golog.Info(result)
}
func (suite *TestDbWebReqSuite) Test002_Query() {
    var req = Default[*model.ServiceApiList]()
    req.SetPageSize(23)
    var result = req.Query()
    golog.Info(result)
}

func (suite *TestDbWebReqSuite) Test004_automigrate() {
    var req = Default[*model.ServiceApiList]()
    var result = req.Automigrate()
    golog.Info(result)
}

func (suite *TestDbWebReqSuite) Test006_update() {
    var req = Default[*model.ServiceApiList]()
    var result = req.Update(&model.ServiceApiList{Name: "leijmdas11111"}, 1014848431407104003)
    golog.Info(result)
}
func (suite *TestDbWebReqSuite) Test006_qryupdate() {

    var req = Default[*model.ServiceApiList]()
    // req.Eq("id", 1014848431407104003)
    var result = req.Query()
    golog.Info(result)
}
func (suite *TestDbWebReqSuite) Test007_delete() {

    var req = Default[*model.ServiceApiList]()
    var result = req.Delete(1014847422142676995)
    golog.Info(result)
}
func (suite *TestDbWebReqSuite) Test008_Findby() {

    var req = Default[*model.ServiceApiList]()
    var result = req.Find(1012572619744575491)
    golog.Info(result)
}

func (suite *TestDbWebReqSuite) Test010_updateMap() {
    var req = Default[*model.ServiceApiList]()
    var result = req.UpdateMap(map[string]any{"name": "leijmdas", "http_method": "get"},
       1014854303687802883)
    golog.Info(result)
    suite.Equal(200, result.Code)
    var ret = req.Find(1014854303687802883)
    golog.Info(ret)
}
func (suite *TestDbWebReqSuite) Test011_automigrate() {
    var req = Default[*ServiceApiList]()
    var result = req.Automigrate()
    golog.Info(result)
}

type ServiceApiList struct {
    basedto.BaseEntity `gorm:"-"`

    /*  主键  */
    Id int64 `gorm:"column:id;type:INT8;PRIMARY_KEY;default:unique_rowid()" json:"id"`
    /*  名称  */
    Name string `gorm:"column:name;type:STRING" json:"name"`
    /*  权限项  */
    PermissionId int64 `gorm:"column:permission_id;type:INT8;" json:"permission_id"`
    /*  服务名称  */
    ServiceName string `gorm:"column:service_name;type:STRING" json:"service_name"`
    /*  HTTP方法  */
    HttpMethod string `gorm:"column:http_method;type:STRING" json:"http_method"`
    /*  路由PATH  */
    Path string `gorm:"column:path;type:STRING" json:"path"`
    /*  资源  */
    Res string `gorm:"column:res;type:STRING" json:"res"`

    *basemodel.BaseModel
}

func NewServiceApiList() *ServiceApiList {
    var m = &ServiceApiList{
       BaseModel: basemodel.NewBaseModel(),
    }
    m.InitProxy(m)
    return m
}

func (entity *ServiceApiList) TableName() string {

    return "Aservice_api_list1"
}

func (suite *TestDbWebReqSuite) Test012_metaquery() {
    var req = Default[*ServiceApiList]()
    var result = req.MetaQuery()
    golog.Info(result)
}
func (suite *TestDbWebReqSuite) Test013_deleteWhere() {

    var req = Default[*model.ServiceApiList]()
    req.Eq("id", 1014854303687802883)
    var result = req.DeleteWhere()
    golog.Info(result)
}

func (suite *TestDbWebReqSuite) Test014_saveAsInsert() {
    var req = Default[*model.ServiceApiList]()
    var record = &model.ServiceApiList{Name: "song"}
    var result = req.Save(record)
    golog.Info(result)
}

// 1014862143933906947
func (suite *TestDbWebReqSuite) Test015_saveAsUpdate() {
    var req = Default[*model.ServiceApiList]()
    var record = &model.ServiceApiList{Name: "pchua", Id: 1014862178893889539}
    var result = req.Save(record)
    golog.Info(result)
}
func (suite *TestDbWebReqSuite) Test016_GroupFieldStat() {

    var req = Default[*model.ServiceApiList]()
    var result = req.GroupStat("id", "id")
    golog.Info(result)
}
func (suite *TestDbWebReqSuite) Test017_stat() {
    var req = Default[*model.ServiceApiList]()
    req.SetPageSize(23)
    var result = req.Stat("id")
    golog.Info(result)
}
func (suite *TestDbWebReqSuite) Test018_update_notnull() {
    var req = Default[*model.ServiceApiList]()
    var result = req.UpdateNotNull(&model.ServiceApiList{Name: "leijmdas11111"}, 1014848431407104003)
    golog.Info(result)
}代码package dbwebreq

import (
    "git.ichub.com/general/webcli120/goconfig/base/basedto"
    "git.ichub.com/general/webcli120/goconfig/base/jsonutils"
    "git.ichub.com/general/webcli120/goweb/generaldb/generaliface"
    "git.ichub.com/general/webcli120/goweb/page"
    "git.ichub.com/general/webcli120/goweb/pagedb"
    "git.ichub.com/general/webcli120/goweb/pagedb/dbconsts"
    "git.ichub.com/general/webcli120/goweb/webclient/dbwebclient"
    "gorm.io/gorm/schema"
    "reflect"
)

type DbWebReq[T schema.Tabler] struct {
    basedto.BaseEntity
    *pagedb.PageDbWebRequest

    DbWebClient *dbwebclient.DbWebClient
}

func Default[T schema.Tabler]() *DbWebReq[T] {
    var d = &DbWebReq[T]{
       DbWebClient:      dbwebclient.FindBeanDbWebClient(),
       PageDbWebRequest: pagedb.NewPageDbWebRequest(),
    }
    d.SetTabler(NewOfTablerType[T]())
    return d
}
func NewDbWebReq[T schema.Tabler]() *DbWebReq[T] {
    return Default[T]()
}
func NewOfTablerType[T schema.Tabler]() T {
    var t T
    var typeOf = reflect.TypeOf(t)
    if typeOf.Kind() == reflect.Ptr {
       typeOf = typeOf.Elem()
    }
    var value = reflect.New(typeOf)
    return value.Interface().(T)
}

// GeneralQuery
func (self *DbWebReq[T]) GeneralQuery() *page.PageResult {
    return self.DbWebClient.GeneralQuery(self.PageDbWebRequest)
}
func (self *DbWebReq[T]) Query() *page.PageResult {
    self.CmdType = dbconsts.DB_CMD_TYPE_QUERY

    return self.DbWebClient.Query(self.PageDbWebRequest)
}

func (self *DbWebReq[T]) Automigrate() *page.PageResult {

    self.CmdType = dbconsts.DB_CMD_TYPE_AutoMigrate

    return self.DbWebClient.AutoMigrate(self.Tabler())
}

func (self *DbWebReq[T]) MetaQuery() *page.PageResult {

    self.CmdType = dbconsts.DB_CMD_TYPE_METAQUERY
    //self.TableName=self.Tabler().TableName()
    return self.DbWebClient.Meta(self.PageDbWebRequest)
}
func (self *DbWebReq[T]) Delete(pkeyvalue any) *page.PageResult {

    return self.DbWebClient.Delete(self.Tabler(), pkeyvalue)
}
func (self *DbWebReq[T]) DeleteWhere() *page.PageResult {

    return self.DbWebClient.DeleteWhere(self.PageDbWebRequest)
}
func (self *DbWebReq[T]) Find(pkeyvalue any) *page.PageResult {

    return self.DbWebClient.Find(self.Tabler(), pkeyvalue)
}

func (self *DbWebReq[T]) GroupStat(groupFields string, statFields ...string) *page.PageResult {

    return self.DbWebClient.GroupStat(self.PageDbWebRequest, groupFields, statFields...)
}
func (self *DbWebReq[T]) Stat(statFields string) *page.PageResult {

    self.StatFields = statFields
    self.CmdType = dbconsts.DB_CMD_TYPE_STAT

    return self.DbWebClient.Query(self.PageDbWebRequest)
}
func (self *DbWebReq[T]) Save(record generaliface.IBaseModel[int64]) *page.PageResult {

    if record.PkeyValue() == 0 {
       return self.DbWebClient.Insert(record)
    } else {
       return self.DbWebClient.Update(record, record.PkeyValue())
    }

}
func (self *DbWebReq[T]) SavePkeyInt32(record generaliface.IBaseModel[int32]) *page.PageResult {

    if record.PkeyValue() == 0 {
       return self.DbWebClient.Insert(record)
    } else {
       return self.DbWebClient.Update(record, record.PkeyValue())
    }

}
func (self *DbWebReq[T]) SavePkeyStr(record generaliface.IBaseModel[string]) *page.PageResult {

    if record.PkeyValue() == "" {
       return self.DbWebClient.Insert(record)
    } else {
       return self.DbWebClient.Update(record, record.PkeyValue())
    }

}
func (self *DbWebReq[T]) INSERT(record schema.Tabler) *page.PageResult {

    self.CmdType = dbconsts.DB_CMD_TYPE_INSERT
    self.CmdCatagory = dbconsts.DB_CATAGORY_CMD
    self.Record = jsonutils.Stru2Map(record)
    return self.DbWebClient.Cmd(self.PageDbWebRequest)
}

// update all include pkey
func (self *DbWebReq[T]) Update(record schema.Tabler, pkeyvalue any) *page.PageResult {

    return self.DbWebClient.Update(record, pkeyvalue)
}
func (self *DbWebReq[T]) UpdateMap(doc map[string]any, pkeyvalue any) *page.PageResult {

    return self.DbWebClient.UpdateMap(self.Tabler(), doc, pkeyvalue)
}
func (self *DbWebReq[T]) UpdateNotNull(record schema.Tabler, pkeyvalue any) *page.PageResult {

    self.CmdType = dbconsts.DB_CMD_TYPE_UPDATE_NOTNULL
    self.CmdCatagory = dbconsts.DB_CATAGORY_CMD
    self.PkeyValue = pkeyvalue
    self.Record = jsonutils.Stru2Map(record)
    return self.DbWebClient.UpdateNotNull(record, pkeyvalue)
}

INFO[2024-10-1024 23:04:16]D:/git.ichub.com/web/webcli120/goconfig/base/goutils/go_log.go:88 git.ichub.com/general/webcli120/goconfig/base/goutils.Info() {
     "code": 200,
     "msg": "成功",
     "data": {
          "deleted_by": 0,
          "http_method": "",
          "path": "",
          "permission_id": 0,
          "res": "",
          "updated_at": "2024-10-24T23:04:16.4700978+08:00",
          "created_at": "2024-10-24T23:04:16.4700978+08:00",
          "deleted_at": null,
          "id": 1014863811307405315,
          "name": "song",
          "service_name": "",
          "updated_by": 0,
          "created_by": 0
     },
     "hosturl": "http://localhost:91/dbserver/v3/cmd",
     "total": 0,
     "cmd_name": "Insert",
     "cmd_type": 3
} 

代码实现封装

package dbwebreq

import (
    "git.ichub.com/general/webcli120/goconfig/base/basedto"
    "git.ichub.com/general/webcli120/goweb/generaldb/generaliface"
    "git.ichub.com/general/webcli120/goweb/page"
    "git.ichub.com/general/webcli120/goweb/pagedb"
    "git.ichub.com/general/webcli120/goweb/pagemodel"
    "git.ichub.com/general/webcli120/goweb/webclient/dbwebclient"
    "git.ichub.com/general/webcli120/goweb/webclient/dbwebclient/dbconsts"
    "gorm.io/gorm/schema"
    "reflect"
)

type DbWebReq[T schema.Tabler] struct {
    basedto.BaseEntity
    *pagedb.PageDbWebRequest

    DbWebClient *dbwebclient.DbWebClient
}

func Default[T schema.Tabler]() *DbWebReq[T] {
    var d = &DbWebReq[T]{
       DbWebClient:      dbwebclient.FindBeanDbWebClient(),
       PageDbWebRequest: pagedb.NewPageDbWebRequest(),
    }
    d.SetTabler(NewOfTablerType[T]())
    return d
}
func NewDbWebReq[T schema.Tabler]() *DbWebReq[T] {
    return Default[T]()
}
func NewOfTablerType[T schema.Tabler]() T {
    var t T
    var typeOf = reflect.TypeOf(t)
    if typeOf.Kind() == reflect.Ptr {
       typeOf = typeOf.Elem()
    }
    var value = reflect.New(typeOf)
    return value.Interface().(T)
}

// GeneralQuery
func (self *DbWebReq[T]) GeneralQuery() *pagemodel.PageResult[T] {
    var result = self.DbWebClient.GeneralQuery(self.PageDbWebRequest)
    return self.pageResult2PageModel(result)
}
func (self *DbWebReq[T]) pageResult2PageModel(result *page.PageResult) *pagemodel.PageResult[T] {

    var modelret = pagemodel.DefaultResult[T]()
    modelret.ValueOfPageResult(result)
    return modelret

}
func (self *DbWebReq[T]) Query() *pagemodel.PageResult[T] {
    self.CmdType = dbconsts.DB_CMD_TYPE_QUERY

    var result = self.DbWebClient.Query(self.PageDbWebRequest)

    return self.pageResult2PageModel(result)
}

func (self *DbWebReq[T]) Automigrate() *page.PageResult {

    self.CmdType = dbconsts.DB_CMD_TYPE_AutoMigrate

    return self.DbWebClient.AutoMigrate(self.Tabler())
}

func (self *DbWebReq[T]) MetaQuery() *page.PageResult {

    self.CmdType = dbconsts.DB_CMD_TYPE_METAQUERY
    //self.TableName=self.Tabler().TableName()
    return self.DbWebClient.Meta(self.PageDbWebRequest)
}
func (self *DbWebReq[T]) Delete(pkeyvalue any) *page.PageResult {

    return self.DbWebClient.Delete(self.Tabler(), pkeyvalue)
}
func (self *DbWebReq[T]) DeleteWhere() *page.PageResult {

    return self.DbWebClient.DeleteWhere(self.PageDbWebRequest)
}
func (self *DbWebReq[T]) Find(pkeyvalue any) *pagemodel.IchubResult[T] {

    var result = self.DbWebClient.Find(self.Tabler(), pkeyvalue)
    return self.pageResult2Model(result)
}

func (self *DbWebReq[T]) GroupStat(groupFields string, statFields ...string) *page.PageResult {

    return self.DbWebClient.GroupStat(self.PageDbWebRequest, groupFields, statFields...)
}
func (self *DbWebReq[T]) Stat(statFields string) *page.PageResult {

    self.StatFields = statFields
    self.CmdType = dbconsts.DB_CMD_TYPE_STAT

    return self.DbWebClient.Query(self.PageDbWebRequest)
}
func (self *DbWebReq[T]) Save(record generaliface.IBaseModel[int64]) *pagemodel.IchubResult[T] {

    if record.PkeyValue() == 0 {
       return self.Insert(record)
    }
    return self.Update(record, record.PkeyValue())

}
func (self *DbWebReq[T]) pageResult2Model(result *page.PageResult) *pagemodel.IchubResult[T] {

    var modelret = pagemodel.DefaultIchubResult[T]()
    modelret.ValueOfPageResult(result)
    return modelret

}
func (self *DbWebReq[T]) SavePkeyInt32(record generaliface.IBaseModel[int32]) *pagemodel.IchubResult[T] {

    if record.PkeyValue() == 0 {
       return self.Insert(record)
    } else {
       return self.Update(record, record.PkeyValue())
    }

}
func (self *DbWebReq[T]) SavePkeyStr(record generaliface.IBaseModel[string]) *pagemodel.IchubResult[T] {

    if record.PkeyValue() == "" {
       return self.Insert(record)
    } else {
       return self.Update(record, record.PkeyValue())
    }

}
func (self *DbWebReq[T]) Insert(record schema.Tabler) *pagemodel.IchubResult[T] {

    var result = self.DbWebClient.Insert(record)
    return self.pageResult2Model(result)
}

// update all include pkey
func (self *DbWebReq[T]) Update(record schema.Tabler, pkeyvalue any) *pagemodel.IchubResult[T] {
    var result = self.DbWebClient.Update(record, pkeyvalue)
    return self.pageResult2Model(result)

}
func (self *DbWebReq[T]) UpdateMap(doc map[string]any, pkeyvalue any) *page.PageResult {

    return self.DbWebClient.UpdateMap(self.Tabler(), doc, pkeyvalue)
}
func (self *DbWebReq[T]) UpdateNotNull(record schema.Tabler, pkeyvalue any) *pagemodel.IchubResult[T] {
 
    var result = self.DbWebClient.UpdateNotNull(record, pkeyvalue)
    return self.pageResult2Model(result)
}

package pagedb

import (
    "errors"
    "git.ichub.com/general/webcli120/goconfig/base/basedto"
    "git.ichub.com/general/webcli120/goweb/page"
    "git.ichub.com/general/webcli120/goweb/pagedb/dbconsts"
    "git.ichub.com/general/webcli120/goweb/pagees/esconst"
    "gorm.io/gorm/schema"
)

type PageDbWebRequest struct {
    basedto.BaseEntity
    *PagedbGroup

    CmdCatagory int `json:"cmd_catagory"`
    CmdType     int `json:"cmd_type"`
}

func DefaultWebRequest() *PageDbWebRequest {
    var req = &PageDbWebRequest{
       PagedbGroup: DefaultDbGroup(),
    }
    req.InitProxy(req)
    return req
}

func NewPageDbWebRequest() *PageDbWebRequest {
    return DefaultWebRequest()
}
func (self *PageDbWebRequest) FindExecute() IPagedbExecute {

    switch self.CmdCatagory {
    case dbconsts.DB_CATAGORY_QUERY:
       return FindBeanPageDbQuery()
    case dbconsts.DB_CATAGORY_CMD:
       return FindBeanPageDbCmd()
    case dbconsts.DB_CATAGORY_METADATA:
       return FindBeanPageDbMeta()
    default:
       return nil
    }
}

func (self *PageDbWebRequest) Execute() *page.PageResult {

    var dbexe = self.FindExecute()
    if dbexe == nil {
       return page.NewPageResultError("not found execute")
    }
    var result = self.FindExecute().Execute(self)
    result.CmdType = esconst.CMDTYPE(self.CmdType)
    result.CmdName = dbconsts.CmdName[self.CmdType]
    return result

}
func (self *PageDbWebRequest) Query() *page.PageResult {
    if self.CmdType == 0 {
       self.CmdType = dbconsts.DB_CMD_TYPE_QUERY
    }
    self.CmdCatagory = dbconsts.DB_CATAGORY_QUERY

    return self.Execute()

}
func (self *PageDbWebRequest) GeneralQuery() *page.PageResult {

    self.CmdType = dbconsts.DB_CMD_TYPE_GENERALQUERY
    self.CmdCatagory = dbconsts.DB_CATAGORY_QUERY

    return self.Execute()

}
func (self *PageDbWebRequest) FindById(pkeyValue any) *page.PageResult {

    self.CmdType = dbconsts.DB_CMD_TYPE_FINDBYID
    self.PkeyValue = pkeyValue

    return self.Query()

}
func (self *PageDbWebRequest) GroupStat(groupFields, statFields string) *page.PageResult {
    self.GroupFields = groupFields
    self.StatFields = statFields
    self.CmdType = dbconsts.DB_CMD_TYPE_GROUPSTAT
    self.CmdCatagory = dbconsts.DB_CATAGORY_QUERY

    return self.Execute()

}
func (self *PageDbWebRequest) Stat(statFields string) *page.PageResult {

    self.StatFields = statFields
    self.CmdType = dbconsts.DB_CMD_TYPE_STAT
    self.CmdCatagory = dbconsts.DB_CATAGORY_QUERY

    return self.Execute()

}
func (self *PageDbWebRequest) Cmd() *page.PageResult {
    self.CmdCatagory = dbconsts.DB_CATAGORY_CMD
    if self.TableName == "" && self.tabler != nil {
       self.SetTableName(self.tabler.TableName())
    }
    return self.Execute()

}
func (self *PageDbWebRequest) MetaQuery() *page.PageResult {
    self.CmdCatagory = dbconsts.DB_CATAGORY_METADATA

    return self.Execute()

}
func (self *PageDbWebRequest) AutoMeta(stru schema.Tabler) *PageDbWebRequest {
    self.SetTabler(stru)
    return self
}

func (c *PageDbWebRequest) SetTabler(tabler schema.Tabler) {
    c.PagedbGroup.SetTabler(tabler)
    c.MakeMeta()

}
func (self *PageDbWebRequest) MakeMeta() error {
    if self.tabler == nil {
       return errors.New("tabelr is nil")
    }
    self.TableName = self.tabler.TableName()
    self.FromStru(self.tabler)
    return nil
}

package dbwebclient

import (
    "git.ichub.com/general/webcli120/goconfig/base/basedto"
    "git.ichub.com/general/webcli120/goconfig/base/jsonutils"
    "git.ichub.com/general/webcli120/goconfig/ichubconfig"
    "git.ichub.com/general/webcli120/goconfig/ichublog/golog"
    "git.ichub.com/general/webcli120/goweb/iface"
    "git.ichub.com/general/webcli120/goweb/page"
    "git.ichub.com/general/webcli120/goweb/pagedb"
    "git.ichub.com/general/webcli120/goweb/pagedb/dbconsts"
    "git.ichub.com/general/webcli120/goweb/webclient"
    webmsg2 "git.ichub.com/general/webcli120/goweb/webclient/webmsg"
    "gorm.io/gorm/schema"
    "strings"
)

const (
    DBSERVER_WEB_PREFIX = "/dbserver/v3"
    URL_QUERY           = "/query"
    URL_CMD             = "/cmd"
    URL_META            = "/meta"
)

type DbWebClient struct {
    basedto.BaseEntitySingle
    *webclient.WebClient
    webPrefix string `json:-`
}

func Default() *DbWebClient {
    var webcli = &DbWebClient{}
    webcli.Init()
    return webcli
}
func DefaultDb() *DbWebClient {
    var webcli = &DbWebClient{}
    return webcli.initDb()
}

func NewDbWebClient() *DbWebClient {

    return Default()
}
func (self *DbWebClient) Init() {
    self.WebClient = webclient.NewWebClient()
    self.InitProxy(self)
    self.webPrefix = ichubconfig.FindBeanIchubConfig().Software.WebPrefix
    if self.WebPrefix() == "/" {
       self.SetWebPrefix("")
    }

}

func (self *DbWebClient) Query(req *pagedb.PageDbWebRequest) *page.PageResult {
    req.CmdCatagory = dbconsts.DB_CATAGORY_QUERY
    if req.CmdType == 0 {
       req.CmdType = dbconsts.DB_CMD_TYPE_QUERY
    }
    var msg = webmsg2.NewWebMsg()
    msg.SetUrl(self.webPrefix + URL_QUERY)
    msg.SetBody(req.ToJsonBytes())

    var result = self.PostWeb(msg)
    if req.Models() != nil {
       result.As(req.Models())
    }
    return result

}
func (self *DbWebClient) GeneralQuery(req *pagedb.PageDbWebRequest) *page.PageResult {

    req.CmdType = dbconsts.DB_CMD_TYPE_GENERALQUERY

    return self.Query(req)

}

func (self *DbWebClient) Cmd(req *pagedb.PageDbWebRequest) *page.PageResult {
    req.CmdCatagory = dbconsts.DB_CATAGORY_CMD
    if req.CmdType == 0 {
       req.CmdType = dbconsts.DB_CMD_TYPE_INSERT
    }
    var msg = webmsg2.NewWebMsg()
    msg.SetUrl(self.webPrefix + URL_CMD)
    msg.SetBody(req.ToJsonBytes())

    return self.PostWeb(msg)

}
func (self *DbWebClient) Meta(req *pagedb.PageDbWebRequest) *page.PageResult {
    req.CmdCatagory = dbconsts.DB_CATAGORY_METADATA
    if req.CmdType == 0 {
       return page.NewPageResultError("cmdType is 0")
    }

    var msg = webmsg2.NewWebMsg()
    msg.SetUrl(self.webPrefix + URL_META)
    msg.SetBody(req.ToJsonBytes())

    return self.PostWeb(msg)

}
func (self *DbWebClient) AutoMigrates(tables ...schema.Tabler) *page.PageResult {
    for _, table := range tables {
       var result = self.AutoMigrate(table)
       if !result.IsSuccess() {
          return result
       }
    }

    return page.ResultOk("ok")

}
func (self *DbWebClient) AutoMigrate(table schema.Tabler) *page.PageResult {
    var req = pagedb.DefaultWebRequest()
    req.SetTabler(table) //    req.AutoMeta(table)
    req.CmdCatagory = dbconsts.DB_CATAGORY_METADATA
    req.CmdType = dbconsts.DB_CMD_TYPE_AutoMigrate

    return self.Meta(req)

}
func (self *DbWebClient) WebPrefix() string {
    return self.webPrefix
}
func (webcli *DbWebClient) initDb() *DbWebClient {

    var Config = ichubconfig.FindBeanIchubConfig()
    clientDto := Config.ReadDbWebClient()
    webcli.WebClient = webclient.New(clientDto)
    webcli.Config = Config
    webcli.webPrefix = DBSERVER_WEB_PREFIX //ichubconfig.FindBeanIchubConfig().Software.WebPrefix
    golog.Info(clientDto)
    return webcli
}
func (self *DbWebClient) SetWebPrefix(webPrefix string) {
    self.webPrefix = webPrefix
}
func (self *DbWebClient) UpdateEntity(table string, entity any, pkey any) *page.PageResult {

    var req = pagedb.NewPageDbWebRequest()
    req.SetTableName(table)
    req.PkeyValue = pkey
    req.Record = jsonutils.Stru2Map(entity)
    req.CmdCatagory = dbconsts.DB_CATAGORY_CMD
    req.CmdType = dbconsts.DB_CMD_TYPE_UPDATE

    var msg = webmsg2.NewWebMsg()
    msg.SetUrl(self.webPrefix + "/cmd")
    msg.SetBody(req.ToJsonBytes())

    return self.PostWeb(msg)

}
func (self *DbWebClient) UpdateNotNullEntity(table string, entity any, pkey any) *page.PageResult {

    var req = pagedb.NewPageDbWebRequest()
    req.SetTableName(table)
    req.PkeyValue = pkey
    req.Record = jsonutils.Stru2Map(entity)
    req.CmdCatagory = dbconsts.DB_CATAGORY_CMD
    req.CmdType = dbconsts.DB_CMD_TYPE_UPDATE_NOTNULL

    var msg = webmsg2.NewWebMsg()
    msg.SetUrl(self.webPrefix + "/cmd")
    msg.SetBody(req.ToJsonBytes())

    return self.PostWeb(msg)

}
func (self *DbWebClient) InsertEntity(table string, entity any) *page.PageResult {
    var req = pagedb.NewPageDbWebRequest()
    req.SetTableName(table)
    req.Record = jsonutils.Stru2Map(entity)
    req.CmdCatagory = dbconsts.DB_CATAGORY_CMD
    req.CmdType = dbconsts.DB_CMD_TYPE_INSERT

    var msg = webmsg2.NewWebMsg()
    msg.SetUrl(self.webPrefix + "/cmd")
    msg.SetBody(req.ToJsonBytes())

    return self.PostWeb(msg)

}
func (self *DbWebClient) InsertTable(entity iface.ITableName) *page.PageResult {
    return self.InsertEntity(entity.TableName(), entity)
}
func (self *DbWebClient) UpdateTable(entity iface.ITableName, pkey any) *page.PageResult {
    return self.UpdateEntity(entity.TableName(), entity, pkey)
}
func (self *DbWebClient) UpdateNotNull(entity schema.Tabler, pkey any) *page.PageResult {
    return self.UpdateNotNullEntity(entity.TableName(), entity, pkey)
}
func (self *DbWebClient) FindById(tablename string, pkey any) *page.PageResult {
    var req = pagedb.DefaultWebRequest()
    req.PkeyValue = pkey
    req.TableName = tablename
    req.CmdType = dbconsts.DB_CMD_TYPE_FINDBYID
    return self.Query(req)

}
func (self *DbWebClient) DeleteById(tablename string, pkey any) *page.PageResult {
    var req = pagedb.DefaultWebRequest()
    req.PkeyValue = pkey
    req.TableName = tablename
    req.CmdType = dbconsts.DB_CMD_TYPE_DELETEBYID
    return self.Cmd(req)

}
func (self *DbWebClient) Stat(req *pagedb.PageDbWebRequest, statFields ...string) *page.PageResult {

    req.StatFields = strings.Join(statFields, ",")

    req.CmdType = dbconsts.DB_CMD_TYPE_STAT
    return self.Query(req)

}
func (self *DbWebClient) GroupStat(req *pagedb.PageDbWebRequest, groupFields string, statFields ...string) *page.PageResult {

    req.StatFields = strings.Join(statFields, ",")
    req.GroupFields = groupFields
    req.CmdType = dbconsts.DB_CMD_TYPE_GROUPSTAT
    return self.Query(req)

}
func (self *DbWebClient) Update(entity schema.Tabler, pkey any) *page.PageResult {
    return self.UpdateEntity(entity.TableName(), entity, pkey)
}
func (self *DbWebClient) Insert(entity schema.Tabler) *page.PageResult {
    return self.InsertEntity(entity.TableName(), entity)
}
func (self *DbWebClient) UpdateMap(tabler schema.Tabler, record map[string]any, pkey any) *page.PageResult {
    var req = pagedb.NewPageDbWebRequest()
    req.SetTableName(tabler.TableName())
    req.PkeyValue = pkey
    req.Record = record
    req.CmdCatagory = dbconsts.DB_CATAGORY_CMD
    req.CmdType = dbconsts.DB_CMD_TYPE_UPDATE

    var msg = webmsg2.NewWebMsg()
    msg.SetUrl(self.webPrefix + "/cmd")
    msg.SetBody(req.ToJsonBytes())

    return self.PostWeb(msg)
}
func (self *DbWebClient) Delete(tablename schema.Tabler, pkey any) *page.PageResult {
    var req = pagedb.DefaultWebRequest()
    req.PkeyValue = pkey
    req.TableName = tablename.TableName()
    req.CmdType = dbconsts.DB_CMD_TYPE_DELETEBYID
    return self.Cmd(req)

}
func (self *DbWebClient) DeleteWhere(req *pagedb.PageDbWebRequest) *page.PageResult {
    // var req = pagedb.DefaultWebRequest()
    // req.PkeyValue = pkey
    // req.TableName = tablename.TableName()
    req.CmdType = dbconsts.DB_CMD_TYPE_DELETE_WHERE
    return self.Cmd(req)

}
func (self *DbWebClient) Find(tablename schema.Tabler, pkey any) *page.PageResult {
    var req = pagedb.DefaultWebRequest()
    req.PkeyValue = pkey
    req.TableName = tablename.TableName()
    req.CmdType = dbconsts.DB_CMD_TYPE_FINDBYID
    return self.Query(req)

}

猜你喜欢

转载自blog.csdn.net/leijmdas/article/details/143221942
go
今日推荐
周排行
阿里云服务器ECS开放8080端口
求正弦和余弦
链表倒数第n个节点
vue.js入门（13）实战demo
Java学习——day 15
My First Day in CSDN
Oracle11g 密码延迟认证导致library cache lock的情况分析
SAP ALV输出字段内容前增加空格
CloudFlare 推出免费 VPN 服务「Warp」，你懂的！
BUG(跑SLAM14-ch10)
每日归档
更多
2025-03-16(0)
2025-03-15(0)
2025-03-14(0)
2025-03-13(0)
2025-03-12(0)
2025-03-11(0)
2025-03-10(0)
2025-03-09(0)
2025-03-08(0)
2025-03-07(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022