go语言查询的通用写法

package sentencepage

import (
    "gowfa/domain/db/dbdao"
    "gowfa/domain/db/dbentity"
    "gowfa/domain/db/dbfacade"
    "gowfa/domain/dbservice/baseservice"
    "gowfa/platform/platdb/platdao"
    "gowfa/platform/platdb/platentity"
    "strings"
    "time"

    "gitee.com/gowebframe3/webframe.git/goconfig/base/basedto"
    "gitee.com/gowebframe3/webframe.git/goconfig/ichublog/golog"
    "gitee.com/gowebframe3/webframe.git/gomini/gotool/dbtool/uipageframe"
    "gitee.com/gowebframe3/webframe.git/goweb/pagemodel"
)

type WfaSentenceReq struct {
    dbentity.WfaSentence
    //关联单词
    LinkWord string `json:"linkWord"`
    //年份范围
    YearRange []int `json:"yearRange"`
}

type WfaSentenceVo struct {
    dbentity.WfaSentence
    //考试等级
    ExamLevelStr string `json:"examLevelStr" gorm:"column:exam_level;type:text"`
    //题目类型
    QuestionTypeStr string `json:"questionTypeStr" gorm:"column:question_type;type:text"`

    //关联单词
    LinkWords []*dbentity.WfaToken `json:"linkWords" gorm:"column:link_words;type:text"`
}
type SentencePage struct {
    basedto.BaseEntity
    Users *platentity.Users `json:"-"`
    uipageframe.UiSimpleQR[*WfaSentenceReq, *dbentity.WfaSentence, *WfaSentenceVo]
}

func NewSentencePage() *SentencePage {
    var req = &SentencePage{}
    req.InitDao()
    req.initQuery()
    return req
}

func (self *SentencePage) initQuery() *SentencePage {
    self.SetBeforeQuery(func() {
       self.BuildGeneralParams(self.PageDbRequest)

       if self.Query.Id > 0 {
          self.DbEq("id", self.Query.Id)
       }
       if self.Query.YearRange != nil && len(self.Query.YearRange) > 0 {
          self.DbWhere("year >= ? AND year <= ?", self.Query.YearRange[0], self.Query.YearRange[1])
       }
       if self.Query.LinkWord != "" {
          self.DbLike("sentence", self.Query.LinkWord)
          self.DbWhere(`exists (select 1 from wfa_token
          where wfa_token.sentence_id = wfa_sentence.id
          and ( actual = ?))`, self.Query.LinkWord)
       }
       if self.Query.PaperId > 0 {
          self.DbEq("paper_id", self.Query.PaperId)
       }

       if self.Query.Year > 0 {
          self.DbEq("year", self.Query.Year)
       }

       if self.Query.QuestionType > 0 {
          self.DbEq("question_type", self.Query.QuestionType)
       }

       if self.Query.ExamLevel > 0 {
          self.DbEq("exam_level", self.Query.ExamLevel)
       }
       if self.Query.PaperName != "" {
          self.DbLike("paper_name", self.Query.PaperName)
       }
       if self.Query.Sentence != "" {
          self.DbWhere("sentence like ? or sentence like ?",
             "% "+self.Query.Sentence+"%", "%"+self.Query.Sentence+" %")
       }
       self.DbEq("if_link", self.Query.IfLink)

    })
    return self
}

func (self *SentencePage) UiList() *pagemodel.PageResult[*WfaSentenceVo] {
    var ret = self.List()
    if ret.IsFailed() {
       golog.Error(ret)
    }
    var pret = self.PageTo(ret)
    if pret.ExistRecord() {
       self.Fills(pret)
    }
    return pret
}

// 查询
func (self *SentencePage) List() *pagemodel.PageResult[*dbentity.WfaSentence] {
    self.BuildRequestQuery()
    if self.OrderBys == "" {
       self.OrderByDesc("updated_at")
    }
    return self.QueryModel()
}
func (self *SentencePage) Fills(pret *pagemodel.PageResult[*WfaSentenceVo]) {
    for _, item := range pret.Data {
       self.Fill(item)

    }
}
func (self *SentencePage) Fill(item *WfaSentenceVo) {
    if fret := self.GetDictItem(item.QuestionType); fret.ExistRecord() {
       item.QuestionTypeStr = fret.Data.Name
    }
    if fret := self.GetDictItem(item.ExamLevel); fret.ExistRecord() {
       item.ExamLevelStr = fret.Data.Name
    }
    if fret := self.QueryLinkWords(item.Id); fret.ExistRecord() {
       item.LinkWords = fret.Data
    }
}
func (self *SentencePage) GetDictItem(dictId int64) *pagemodel.IchubResult[*dbentity.WfaDict] {
    var dao = dbdao.FindBeanWfaDictDao()
    var ret = dao.FindById2Result(dictId)
    if ret.IsFailed() {
       golog.Error("GetDictItem ret:", ret)
    }
    return ret
}
func (self *SentencePage) UiFind(id int64) *pagemodel.IchubResult[*dbentity.WfaSentence] {
    if id <= 0 {
       return pagemodel.ResultFail[*dbentity.WfaSentence]("id不能为空")
    }

    ret := self.FindById2Result(id)
    if ret.IsFailed() {
       golog.Error(ret)
       return pagemodel.ResultFail[*dbentity.WfaSentence](ret.Msg)
    }
    return ret
}

// batchSave
type BatchSaveReq struct {
    //试卷id
    PaperId int64 `json:"paper_id,string"`
    //题目类型
    QuestionType int64 `json:"question_type,string"`
    //句子
    Sentence []string `json:"sentence"`
}

func (self *SentencePage) BatchSave2Result(req *BatchSaveReq) *basedto.IchubResult {
    if req.PaperId <= 0 {
       return basedto.ResultFailUser("试卷不能为空")
    }
    if req.QuestionType <= 0 {
       return basedto.ResultFailUser("题目类型不能为空")
    }
    if len(req.Sentence) <= 0 {
       return basedto.ResultFailUser("句子不能为空")
    }
    var row = dbentity.FindBeanWfaSentence()

    row.CreatedBy = self.Users.Id
    row.UpdatedBy = self.Users.Id
    row.PaperId = req.PaperId
    row.IfLink = false
    var dao = dbdao.FindBeanWfaExamPapersDao()
    var ret = dao.FindById2Result(req.PaperId)
    if ret.ExistRecord() {
       row.Year = ret.Data.ExamYear
       row.PaperName = ret.Data.PaperName
       row.ExamLevel = ret.Data.ExamLevel
    }
    row.ExamLevel = ret.Data.ExamLevel
    row.QuestionType = req.QuestionType
    for i := 0; i < len(req.Sentence); i++ {
       row.Id = 0
       row.Sentence = req.Sentence[i]
       if ret := self.Save2Result(row); ret.IsFailed() {
          golog.Error("BatchSave2Result ret:", ret)
          return ret
       }
    }
    return basedto.ResultSuccess()
}

func (self *SentencePage) UiSave2Result(req *dbentity.WfaSentence) *basedto.IchubResult {
    req.CreatedBy = self.Users.Id
    req.UpdatedBy = self.Users.Id

    var ret = self.Save2Result(req)
    if ret.IsFailed() {
       golog.Error("UiSave2Result ret:", ret)
    }
    return ret
}

func (self *SentencePage) UiUpdate2Result(req *dbentity.WfaSentence) *basedto.IchubResult {
    req.UpdatedBy = self.Users.Id

    if req.Id <= 0 {
       return basedto.ResultFailUser("id不能为空")
    }

    ret := self.Save2Result(req)
    if ret.IsFailed() {
       golog.Error("UiUpdate2Result ret:", ret)
    }
    return ret
}

func (self *SentencePage) UiDelete(id int64) *pagemodel.IchubResult[int64] {
    if id <= 0 {
       return pagemodel.ResultFailUser[int64]("id不能为空")
    }

    var ret = self.DeleteByIdResult(id)
    if ret.IsSuccess() {
       var dret = dbfacade.FindBeanDbFacade().DeleteTokenBySentence(id)
       if dret.IsFailed() {
          golog.Error("UiDelete ret:", dret)
          ret.ResultFailUser(dret.Msg)
       }
    }
    return ret
}

func (self *SentencePage) QueryLinkWords(id int64) *pagemodel.PageResult[*dbentity.WfaToken] {
    if id <= 0 {
       return pagemodel.PageFail[*dbentity.WfaToken]("id不能为空")
    }

    var dao = dbdao.FindBeanWfaTokenDao()
    dao.DbEq("sentence_id", id)

    return dao.QueryModelAll()
}
func (self *SentencePage) QuerySentence(id int64) *pagemodel.PageResult[*dbentity.WfaSentence] {
    if id <= 0 {
       return pagemodel.PageFail[*dbentity.WfaSentence]("id不能为空")
    }

    var dao = dbdao.FindBeanWfaSentenceDao()
    dao.DbEq("id", id)

    return dao.QueryModelAll()
}
func (self *SentencePage) ListLinkWords(id int64, reFind bool) *pagemodel.PageResult[*dbentity.WfaToken] {
    if id <= 0 {
       return pagemodel.PageFail[*dbentity.WfaToken]("id不能为空")
    }
    var ret = self.QuerySentence(id)
    if ret.NoExistRecord() {
       return pagemodel.PageFail[*dbentity.WfaToken]("句子不存在！")
    }
    var dao = dbdao.FindBeanWfaTokenDao()
    dao.DbEq("sentence_id", id)
    if reFind {
       if ret := dao.DeleteWhere2Result(); ret.IsFailed() {
          golog.Error(ret)
          return pagemodel.PageFail[*dbentity.WfaToken](ret.Msg)
       }
    }
    if ret := dao.QueryModelAll(); ret.ExistRecord() {
       return ret
    }

    var words = strings.Split(ret.GetOne().Sentence, " ")
    for i := range words {
       words[i] = baseservice.FindBeanBaseService().RemoveWordPunctuations(words[i])
       var wfaToken = dbentity.FindBeanWfaToken()
       wfaToken.SentenceId = id
       wfaToken.UpdatedBy = self.Users.Id
       wfaToken.CreatedBy = self.Users.Id
       wfaToken.UpdatedAt = time.Now()
       wfaToken.CreatedAt = time.Now()
       wfaToken.Position = int32(i + 1)
       wfaToken.Actual = words[i]
       wfaToken.Pos = 0
       if r := self.FillBase(wfaToken); r.IsFailed() {
          golog.Error("填充基础词失败,r:", r)
       }
       if ret := dao.Save2Result(wfaToken); ret.IsFailed() {
          golog.Error("保存关联词失败,ret:", ret)
          return pagemodel.PageFail[*dbentity.WfaToken](ret.Msg)
       }
    }
    return dao.QueryModelAll()

}
func splitOnlyOne(ps string) string {
    if strings.Contains(ps, "&") {
       var pss = strings.Split(ps, "&")
       return strings.TrimSpace(pss[0])
    }
    return strings.TrimSpace(ps)
}
func (self *SentencePage) FillBase(token *dbentity.WfaToken) *basedto.IchubResult {
    var dao = platdao.FindBeanWordsDao()
    dao.DbEq("word", token.Actual)
    ret := dao.QueryModelOne()
    if ret.ExistRecord() {
       token.PartSpeech = ret.GetOne().PartSpeech
       token.IfSpecial = ret.GetOne().IfSpecial

       var ps = splitOnlyOne(ret.GetOne().PartSpeech)
       token.Pos = dbentity.PosMap[ps]
       if ret.GetOne().BaseWordId != nil {
          var fret = dao.FindByIdAtCache(*ret.GetOne().BaseWordId)
          if fret.ExistRecord() {
             token.Base = fret.Data.Word
             token.BaseId = fret.Data.Id
             if find := dbfacade.FindBeanDbFacade().QueryPos(token.BaseId); find.ExistRecord() {
                token.Pos = find.GetOne().Pos
             }
          }
          if fret.IsFailed() {
             golog.Error("查询标准词失败,fret:", fret)
             return fret.IchubResult
          }
       }

    }
    return &ret.IchubResult
}
func (self *SentencePage) SaveLinkWords(rows []*dbentity.WfaToken) *basedto.IchubResult {
    if len(rows) <= 0 {
       return basedto.ResultFailUser("词不能为空")
    }
    var dao = dbdao.FindBeanWfaTokenDao()
    for i := range rows {
       rows[i].UpdatedBy = self.Users.Id
       rows[i].UpdatedAt = time.Now()
       if ret := dao.Save2Result(rows[i]); ret.IsFailed() {
          golog.Error(ret)
          return ret
       }
    }

    ret := self.UpdateMap2NewResult(rows[0].SentenceId, map[string]any{"if_link": true})
    if ret.IsFailed() {
       golog.Error("SaveLinkWords ret:", ret)
    }

    return ret
}

// 批量保存关联词
func (self *SentencePage) BatchSaveLinkWords(rows []*dbentity.WfaToken) *basedto.IchubResult {
    if len(rows) <= 0 {
       return basedto.ResultFailUser("词不能为空")
    }
    var dao = dbdao.FindBeanWfaTokenDao()
    var sentMaps = make(map[int64]bool)
    for i := range rows {
       rows[i].UpdatedBy = self.Users.Id
       rows[i].UpdatedAt = time.Now()
       if ret := dao.Save2Result(rows[i]); ret.IsFailed() {
          golog.Error("BatchSaveLinkWords ret:", ret)
          return ret
       }
       sentMaps[rows[i].SentenceId] = true
    }

    var ret *basedto.IchubResult
    for sentId := range sentMaps {
       if r := self.UpdateMap2NewResult(sentId, map[string]any{"if_link": true}); r.IsFailed() {
          golog.Error(r)
          return r
       }
    }
    return ret
}