williamet/cas_tt_cloud_backend
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat：完善用户专利数据模型

Browse Source
This commit is contained in:
henry
2021-11-29 13:31:33 +08:00
parent dabb567d41
commit fb5a3d910b
9 changed files with 298 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
app/api/enterprise/controller/sys/patent.go
View File

@ -7,6 +7,7 @@ import (
"SciencesServer/app/session"
"SciencesServer/utils"
"strings"
"time"
)
// Patent 专利信息
@ -19,9 +20,14 @@ type PatentHandle func(session *session.Enterprise) *Patent
type (
// PatentInfo 专利信息
PatentInfo struct {
ID string `json:"id"`
Kind model2.SysParentKind `json:"kind"`
Title string `json:"title"`
ID string `json:"id"`
Kind model2.SysParentKind `json:"kind"`
Title string `json:"title"`
ApplyName string `json:"apply_name"`
ApplyCode string `json:"apply_code"`
ApplyAt string `json:"apply_at"`
Inventor string `json:"inventor"`
CreatedAt time.Time `json:"created_at"`
}
)
@ -36,7 +42,10 @@ func (c *Patent) filter(src string) string {
func (c *Patent) List(kind int, title, applyCode, openCode, ipcCode string, page, pageSize int) (*controller.ReturnPages, error) {
mSysPatent := model.NewSysPatent()
where := []*model2.ModelWhereOrder{&model2.ModelWhereOrder{Order: model2.NewOrder("id", model2.OrderModeToDesc)}}
where := []*model2.ModelWhereOrder{&model2.ModelWhereOrder{
Where: model2.NewWhere("shelf", model2.ShelfStatusForUp),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}}
if kind <= 0 {
where = append(where, &model2.ModelWhereOrder{
@ -67,7 +76,7 @@ func (c *Patent) List(kind int, title, applyCode, openCode, ipcCode string, page
var count int64
if err := model2.Pages(mSysPatent.SysPatent, &out, page, pageSize, &count); err != nil {
if err := model2.PagesFields(mSysPatent.SysPatent, &out, []string{"id", "title", "apply_code", "apply_name", "apply_at", "created_at"}, page, pageSize, &count); err != nil {
return nil, err
}
@ -75,14 +84,14 @@ func (c *Patent) List(kind int, title, applyCode, openCode, ipcCode string, page
for _, v := range out {
list = append(list, &PatentInfo{
ID: v.GetEncodeID(),
Kind: v.Kind,
Title: v.Title,
ID: v.GetEncodeID(), Kind: v.Kind, Title: v.Title,
ApplyName: v.ApplyName, ApplyCode: v.ApplyCode, ApplyAt: v.ApplyAt,
CreatedAt: v.CreatedAt,
})
v.ApplyName = c.filter(v.ApplyName)
v.ApplyAddress = c.filter(v.ApplyAddress)
v.Inventor = c.filter(v.Inventor)
v.Description = c.filter(v.Description)
//v.ApplyName = c.filter(v.ApplyName)
//v.ApplyAddress = c.filter(v.ApplyAddress)
//v.Inventor = c.filter(v.Inventor)
//v.Description = c.filter(v.Description)
}
return &controller.ReturnPages{
Data: out,
@ -90,6 +99,10 @@ func (c *Patent) List(kind int, title, applyCode, openCode, ipcCode string, page
}, nil
}
func (c *Patent) Select() {
}
func NewPatent() PatentHandle {
return func(session *session.Enterprise) *Patent {
return &Patent{Enterprise: session}

267
app/api/enterprise/controller/technology/patent.go
View File

@ -1,12 +1,14 @@
package technology
import (
"SciencesServer/app/api/enterprise/controller/sys"
"SciencesServer/app/api/enterprise/model"
"SciencesServer/app/api/manage/controller"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/session"
"SciencesServer/utils"
"SciencesServer/serve/orm"
"errors"
"gorm.io/gorm"
"time"
)
@ -21,54 +23,160 @@ type PatentHandle func(session *session.Enterprise, local string) *Patent
type (
// PatentInfo 专利信息
PatentInfo struct {
ID string `json:"id"`
Title string `json:"title"`
ApplyCode string `json:"apply_code"` // 申请号
ApplyName string `json:"apply_name"` // 申请人
ApplyAt time.Time `json:"apply_at"` // 申请时间
Inventor string `json:"inventor"` // 发明人
*sys.PatentInfo
Shelf model2.ShelfStatusKind
Status model2.SysParentStatus
}
// PatentDetailInfo 专利详细信息
PatentDetailInfo struct {
ID string `json:"id"`
*model2.TechnologyPatent
*model2.SysPatent
}
// PatentParams 专利参数信息
PatentParams struct {
ID uint64
Title, IPCCode, CPCCode, ApplyCode, ApplyName, ApplyAddress, ApplyZipCode,
Inventor, PriorityCode, OpenCode, ApplyAt, PriorityAt, OpenAt string
ID uint64
Kind int
Title, FileUrl string
ApplyCode, ApplyName, ApplyAddress, ApplyAt,
OpenCode, OpenAt string
Inventor, IPCCode, Description, PrincipalClaim string
Status int
}
)
// List 列表信息
func (c *Patent) List(title string, page, pageSize int) (*controller.ReturnPages, error) {
mTechnologyPatent := model.NewTechnologyPatent()
where := []*model2.ModelWhereOrder{&model2.ModelWhereOrder{
Where: model2.NewWhere("uid", c.ManageUID),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}}
if title != "" {
where = append(where, &model2.ModelWhereOrder{
Where: model2.NewWhereLike("title", title),
})
// add 新增专利信息
func (c *PatentParams) add(uid uint64, local string) error {
mSysPatent := model.NewSysPatent()
isExist, err := mSysPatent.IsExistParams(map[string]interface{}{
"apply_code": c.ApplyCode, "open_code": c.OpenCode,
})
if err != nil {
return err
} else if isExist {
return errors.New("操作错误，申请号或公开（公告）号已存在")
}
out := make([]*model2.TechnologyPatent, 0)
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
mSysPatent.Kind = model2.SysParentKind(c.Kind)
mSysPatent.Title = c.Title
mSysPatent.FileUrl = c.FileUrl
mSysPatent.ApplyCode = c.ApplyCode
mSysPatent.ApplyAt = c.ApplyAt
mSysPatent.OpenCode = c.OpenCode
mSysPatent.OpenAt = c.OpenAt
mSysPatent.ApplyName = c.ApplyName
mSysPatent.ApplyAddress = c.ApplyAddress
mSysPatent.Inventor = c.Inventor
mSysPatent.Description = c.Description
mSysPatent.PrincipalClaim = c.PrincipalClaim
mSysPatent.IPCCode = c.IPCCode
mSysPatent.Status = model2.SysParentStatus(c.Status)
if err = model2.Create(mSysPatent.SysPatent, tx); err != nil {
return err
}
mUserPatent := model.NewUserPatent()
mUserPatent.Local.Local = local
mUserPatent.UID = uid
mUserPatent.PatentID = mSysPatent.ID
return model2.Create(mUserPatent.UserPatent, tx)
})
}
// edit 删除专利信息
func (c *PatentParams) edit(uid uint64) error {
mUserPatent := model.NewUserPatent()
mUserPatent.ID = c.ID
isExist, err := model2.FirstField(mUserPatent.UserPatent, []string{"id", "uid", "patent_id"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，用户专利信息不存在或已被删除")
} else if mUserPatent.UID != uid {
return errors.New("无权限操作")
}
mSysPatent := model.NewSysPatent()
mSysPatent.ID = mUserPatent.PatentID
if isExist, err = model2.FirstField(mSysPatent.SysPatent, []string{"id", "apply_code", "open_code"}); err != nil {
return err
} else if !isExist {
return errors.New("操作错误，专利信息不存在或已被删除")
}
_condition := make(map[string]interface{}, 0)
if mSysPatent.ApplyCode != c.ApplyCode {
_condition["apply_code"] = c.ApplyCode
}
if mSysPatent.OpenCode != c.OpenCode {
_condition["open_code"] = c.OpenCode
}
if len(_condition) > 0 {
if isExist, err = mSysPatent.IsExistParams(_condition); err != nil {
return err
} else if !isExist {
return errors.New("操作错误，申请号或公开（公告）号已存在")
}
}
mSysPatent.Kind = model2.SysParentKind(c.Kind)
mSysPatent.Title = c.Title
mSysPatent.FileUrl = c.FileUrl
mSysPatent.ApplyCode = c.ApplyCode
mSysPatent.ApplyAt = c.ApplyAt
mSysPatent.OpenCode = c.OpenCode
mSysPatent.OpenAt = c.OpenAt
mSysPatent.ApplyName = c.ApplyName
mSysPatent.ApplyAddress = c.ApplyAddress
mSysPatent.Inventor = c.Inventor
mSysPatent.Description = c.Description
mSysPatent.PrincipalClaim = c.PrincipalClaim
mSysPatent.IPCCode = c.IPCCode
mSysPatent.Status = model2.SysParentStatus(c.Status)
return model2.Updates(mSysPatent.SysPatent, mSysPatent.SysPatent)
}
// List 列表信息
func (c *Patent) List(kind int, title, applyCode, openCode, ipcCode string, page, pageSize int) (*controller.ReturnPages, error) {
mUserPatent := model.NewUserPatent()
where := []*model2.ModelWhere{
model2.NewWhere("u.uid", c.UID),
}
if kind <= 0 {
where = append(where, model2.NewWhere("p.kind", kind))
}
if title != "" {
where = append(where, model2.NewWhereLike("p.title", title))
}
if applyCode != "" {
where = append(where, model2.NewWhereLike("p.apply_code", applyCode))
}
if openCode != "" {
where = append(where, model2.NewWhereLike("p.open_code", openCode))
}
if ipcCode != "" {
where = append(where, model2.NewWhereLike("p.ipc_code", ipcCode))
}
var count int64
if err := model2.PagesFields(mTechnologyPatent.TechnologyPatent, &out, []string{"id", "title", "apply_code", "inventor",
"apply_name", "apply_at"}, page, pageSize, &count, where...); err != nil {
out, err := mUserPatent.Patents(page, pageSize, &count, where...)
if err != nil {
return nil, err
}
list := make([]*PatentInfo, 0)
for _, v := range out {
list = append(list, &PatentInfo{
ID: v.GetEncodeID(), Title: v.Title, ApplyCode: v.ApplyCode, ApplyName: v.ApplyName,
ApplyAt: v.ApplyAt, Inventor: v.Inventor,
PatentInfo: &sys.PatentInfo{
ID: v.GetEncodeID(), Title: v.Title, ApplyCode: v.ApplyCode, ApplyName: v.ApplyName,
ApplyAt: v.ApplyAt, Inventor: v.Inventor,
},
Shelf: v.Shelf, Status: v.Status,
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
@ -76,75 +184,80 @@ func (c *Patent) List(title string, page, pageSize int) (*controller.ReturnPages
// Detail 详细信息
func (c *Patent) Detail(id uint64) (*PatentDetailInfo, error) {
mTechnologyPatent := model.NewTechnologyPatent()
mTechnologyPatent.ID = id
mUserPatent := model.NewUserPatent()
mUserPatent.ID = id
isExist, err := model2.First(mTechnologyPatent.TechnologyPatent)
isExist, err := model2.FirstField(mUserPatent.UserPatent, []string{"id", "uid", "patent_id"})
if err != nil {
return nil, err
} else if !isExist {
return nil, errors.New("操作错误，专利信息不存在")
return nil, errors.New("操作错误，用户专利信息不存在或已被删除")
}
return &PatentDetailInfo{
ID: mTechnologyPatent.GetEncodeID(), TechnologyPatent: mTechnologyPatent.TechnologyPatent,
}, nil
mSysPatent := model.NewSysPatent()
mSysPatent.ID = mUserPatent.PatentID
_, err = model2.First(mSysPatent.SysPatent)
if err != nil {
return nil, err
}
return &PatentDetailInfo{ID: mUserPatent.GetEncodeID(), SysPatent: mSysPatent.SysPatent}, nil
}
func (c *Patent) Form(params *PatentParams) error {
mTechnologyPatent := model.NewTechnologyPatent()
if params.ID > 0 {
mTechnologyPatent.ID = params.ID
isExist, err := model2.FirstField(mTechnologyPatent.TechnologyPatent, []string{"id", "m_uid"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，专利信息不存在")
} else if mTechnologyPatent.MUid != c.ManageUID {
return errors.New("无权限操作")
}
return params.edit(c.UID)
}
mTechnologyPatent.Title = params.Title
mTechnologyPatent.IPCCode = params.IPCCode
mTechnologyPatent.CPCCode = params.CPCCode
mTechnologyPatent.ApplyCode = params.ApplyCode
mTechnologyPatent.ApplyName = params.ApplyName
mTechnologyPatent.ApplyZipCode = params.ApplyZipCode
mTechnologyPatent.ApplyAt = utils.DataTimeToDate(params.ApplyAt)
mTechnologyPatent.Inventor = params.Inventor
mTechnologyPatent.PriorityCode = params.PriorityCode
mTechnologyPatent.PriorityAt = utils.DataTimeToDate(params.PriorityAt)
mTechnologyPatent.OpenCode = params.OpenCode
mTechnologyPatent.OpenAt = utils.DataTimeToDate(params.OpenAt)
return params.add(c.UID, c.local)
if mTechnologyPatent.ID > 0 {
mTechnologyPatent.UpdatedAt = time.Now()
return model2.Updates(mTechnologyPatent.TechnologyPatent, mTechnologyPatent.TechnologyPatent)
}
mTechnologyPatent.TenantID = c.TenantID
mTechnologyPatent.Local.Local = c.local
mTechnologyPatent.MUid = c.ManageUID
return model2.Create(mTechnologyPatent.TechnologyPatent)
}
// Delete 删除操作
func (c *Patent) Delete(id uint64) error {
mTechnologyPatent := model.NewTechnologyPatent()
mTechnologyPatent.ID = id
// Shelf 上下架操作
func (c *Patent) Shelf(id uint64, status int) error {
mUserPatent := model.NewUserPatent()
mUserPatent.ID = id
isExist, err := model2.FirstField(mTechnologyPatent.TechnologyPatent, []string{"id", "uid"})
isExist, err := model2.FirstField(mUserPatent.UserPatent, []string{"id", "uid", "patent_id"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，专利信息不存在")
} else if mTechnologyPatent.MUid != c.ManageUID {
return errors.New("操作错误，用户专利信息不存在或已被删除")
} else if mUserPatent.UID != c.UID {
return errors.New("无权限操作")
}
return model2.Delete(mTechnologyPatent.TechnologyPatent)
mSysPatent := model.NewSysPatent()
mSysPatent.ID = mUserPatent.PatentID
return model2.Updates(mSysPatent.SysPatent, map[string]interface{}{
"shelf": status, "updated_at": time.Now(),
})
}
// Delete 删除操作
func (c *Patent) Delete(id uint64) error {
mUserPatent := model.NewUserPatent()
mUserPatent.ID = id
isExist, err := model2.FirstField(mUserPatent.UserPatent, []string{"id", "uid", "patent_id"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，用户专利信息不存在或已被删除")
} else if mUserPatent.UID != c.UID {
return errors.New("无权限操作")
}
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
if err = model2.Delete(mUserPatent.UserPatent); err != nil {
return err
}
mSysPatent := model.NewSysPatent()
mSysPatent.ID = mUserPatent.PatentID
return model2.Delete(mSysPatent.SysPatent)
})
}
func NewPatent() PatentHandle {

105
app/api/enterprise/controller/user/patent.go
View File

@ -1,105 +0,0 @@
package user
import (
"SciencesServer/app/api/enterprise/model"
"SciencesServer/app/basic/controller"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/session"
"SciencesServer/serve/orm"
"errors"
"gorm.io/gorm"
"time"
)
type Patent struct {
*session.Enterprise
local string
}
type PatentHandle func(session *session.Enterprise, local string) *Patent
type (
// PatentParams 专利参数信息
PatentParams struct {
ID uint64
Title string
}
)
func (c *PatentParams) add() error {
return nil
}
func (c *PatentParams) edit() error {
return nil
}
func (c *Patent) List(kind int, title, applyCode, openCode, ipcCode string, page, pageSize int) (*controller.ReturnPages, error) {
return &controller.ReturnPages{
Data: nil,
Count: 0,
}, nil
}
func (c *Patent) Form(params *PatentParams) error {
if params.ID <= 0 {
return params.add()
}
return params.edit()
}
// Shelf 上下架操作
func (c *Patent) Shelf(id uint64, status int) error {
mUserPatent := model.NewUserPatent()
mUserPatent.ID = id
isExist, err := model2.FirstField(mUserPatent.UserPatent, []string{"id", "uid", "patent_id"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，用户专利信息不存在或已被删除")
} else if mUserPatent.UID != c.UID {
return errors.New("无权限操作")
}
mSysPatent := model.NewSysPatent()
mSysPatent.ID = mUserPatent.PatentID
return model2.Updates(mSysPatent.SysPatent, map[string]interface{}{
"shelf": status, "updated_at": time.Now(),
})
}
// Delete 删除操作
func (c *Patent) Delete(id uint64) error {
mUserPatent := model.NewUserPatent()
mUserPatent.ID = id
isExist, err := model2.FirstField(mUserPatent.UserPatent, []string{"id", "uid", "patent_id"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，用户专利信息不存在或已被删除")
} else if mUserPatent.UID != c.UID {
return errors.New("无权限操作")
}
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
if err = model2.Delete(mUserPatent.UserPatent); err != nil {
return err
}
mSysPatent := model.NewSysPatent()
mSysPatent.ID = mUserPatent.PatentID
return model2.Delete(mSysPatent.SysPatent)
})
}
func NewPatent() PatentHandle {
return func(session *session.Enterprise, local string) *Patent {
return &Patent{
Enterprise: session,
local: local,
}
}
}