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

40
app/api/enterprise/api/technology.go
View File

@ -44,19 +44,20 @@ type (
}
// patentForm 专利参数
patentForm struct {
Kind int `json:"kind" form:"kind" binding:"kind"`
Title string `json:"title" form:"title" binding:"required"`
IPCCode string `json:"ipc_code" form:"ipc_code" binding:"required"`
CPCCode string `json:"cpc_code" form:"cpc_code" binding:"required"`
FileUrl string `json:"file_url" form:"file_url"`
ApplyCode string `json:"apply_code" form:"apply_code" binding:"required"`
ApplyName string `json:"apply_name" form:"apply_name" binding:"required"`
ApplyAddress string `json:"apply_address" form:"apply_address" binding:"required"`
ApplyZipCode string `json:"apply_zip_code" form:"apply_zip_code" binding:"required"`
Inventor string `json:"inventor" form:"inventor" binding:"required"`
PriorityCode string `json:"priority_code" form:"priority_code" binding:"required"`
OpenCode string `json:"open_code" form:"open_code" binding:"required"`
ApplyAt string `json:"apply_at" form:"apply_at" binding:"required"`
PriorityAt string `json:"priority_at" form:"priority_at" binding:"required"`
OpenCode string `json:"open_code" form:"open_code" binding:"required"`
OpenAt string `json:"open_at" form:"open_at" binding:"required"`
IPCCode string `json:"ipc_code" form:"ipc_code"`
Inventor string `json:"inventor" form:"inventor"`
PrincipalClaim string `json:"principal_claim" form:"principal_claim"`
Description string `json:"description" form:"description"`
Status int `json:"status" form:"status" binding:"status"`
}
// demandForm 需求参数
demandForm struct {
@ -261,7 +262,11 @@ func (a *Technology) PaperDelete(c *gin.Context) {
func (a *Technology) Patent(c *gin.Context) {
form := &struct {
Kind int `json:"kind" form:"kind"`
Title string `json:"title" form:"title"`
ApplyCode string `json:"apply_code" form:"apply_code"`
OpenCode string `json:"open_code" form:"open_code"`
IPCCode string `json:"ipc_code" form:"ipc_code"`
api.PageForm
}{}
if err := api.Bind(form)(c); err != nil {
@ -269,7 +274,7 @@ func (a *Technology) Patent(c *gin.Context) {
return
}
data, err := technology2.NewPatent()(api.GetSession()(c).(*session.Enterprise), api.GetLocal()(c).(string)).
List(form.Title, form.Page, form.PageSize)
List(form.Kind, form.Title, form.ApplyCode, form.OpenCode, form.IPCCode, form.Page, form.PageSize)
api.APIResponse(err, data)(c)
}
@ -293,11 +298,10 @@ func (a *Technology) PatentAdd(c *gin.Context) {
return
}
err := technology2.NewPatent()(api.GetSession()(c).(*session.Enterprise), api.GetLocal()(c).(string)).
Form(&technology2.PatentParams{
Title: form.Title, IPCCode: form.IPCCode, CPCCode: form.CPCCode, ApplyCode: form.ApplyCode,
ApplyName: form.ApplyName, ApplyAddress: form.ApplyAddress, ApplyZipCode: form.ApplyZipCode,
Inventor: form.Inventor, PriorityCode: form.PriorityCode, OpenCode: form.OpenCode, ApplyAt: form.ApplyAt,
PriorityAt: form.PriorityAt, OpenAt: form.OpenAt,
Form(&technology2.PatentParams{Kind: form.Kind, Title: form.Title, FileUrl: (&api.FileForm{File: form.FileUrl}).FilterURL(),
ApplyCode: form.ApplyCode, ApplyName: form.ApplyName, ApplyAddress: form.ApplyAddress, ApplyAt: form.ApplyAt,
OpenCode: form.OpenCode, OpenAt: form.OpenAt, Inventor: form.Inventor, IPCCode: form.IPCCode,
Description: form.Description, PrincipalClaim: form.PrincipalClaim,
})
api.APIResponse(err)(c)
}
@ -312,11 +316,11 @@ func (a *Technology) PatentEdit(c *gin.Context) {
return
}
err := technology2.NewPatent()(api.GetSession()(c).(*session.Enterprise), api.GetLocal()(c).(string)).
Form(&technology2.PatentParams{
ID: form.Convert(), Title: form.Title, IPCCode: form.IPCCode, CPCCode: form.CPCCode,
ApplyCode: form.ApplyCode, ApplyName: form.ApplyName, ApplyAddress: form.ApplyAddress,
ApplyZipCode: form.ApplyZipCode, Inventor: form.Inventor, PriorityCode: form.PriorityCode, OpenCode: form.OpenCode,
ApplyAt: form.ApplyAt, PriorityAt: form.PriorityAt, OpenAt: form.OpenAt,
Form(&technology2.PatentParams{ID: form.Convert(), Kind: form.Kind, Title: form.Title,
FileUrl: (&api.FileForm{File: form.FileUrl}).FilterURL(), ApplyCode: form.ApplyCode,
ApplyName: form.ApplyName, ApplyAddress: form.ApplyAddress, ApplyAt: form.ApplyAt, OpenCode: form.OpenCode,
OpenAt: form.OpenAt, Inventor: form.Inventor, IPCCode: form.IPCCode, Description: form.Description,
PrincipalClaim: form.PrincipalClaim, Status: form.Status,
})
api.APIResponse(err)(c)
}

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

@ -7,6 +7,7 @@ import (
"SciencesServer/app/session"
"SciencesServer/utils"
"strings"
"time"
)
// Patent 专利信息
@ -22,6 +23,11 @@ type (
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}

243
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
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{
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
return params.edit(c.UID)
}
return params.add(c.UID, c.local)
isExist, err := model2.FirstField(mTechnologyPatent.TechnologyPatent, []string{"id", "m_uid"})
}
// 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 mTechnologyPatent.MUid != c.ManageUID {
return errors.New("操作错误，用户专利信息不存在或已被删除")
} else if mUserPatent.UID != c.UID {
return errors.New("无权限操作")
}
}
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)
mSysPatent := model.NewSysPatent()
mSysPatent.ID = mUserPatent.PatentID
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)
return model2.Updates(mSysPatent.SysPatent, map[string]interface{}{
"shelf": status, "updated_at": time.Now(),
})
}
// Delete 删除操作
func (c *Patent) Delete(id uint64) error {
mTechnologyPatent := model.NewTechnologyPatent()
mTechnologyPatent.ID = id
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)
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,
}
}
}

19
app/api/enterprise/model/sys_patent.go
View File

@ -1,12 +1,29 @@
package model
import "SciencesServer/app/common/model"
import (
"SciencesServer/app/common/model"
"SciencesServer/serve/orm"
"fmt"
)
// SysPatent 专利信息
type SysPatent struct {
*model.SysPatent
}
func (m *SysPatent) IsExistParams(params map[string]interface{}) (bool, error) {
var count int64
db := orm.GetDB().Table(m.TableName())
if len(params) > 0 {
for k, v := range params {
db = db.Or(fmt.Sprintf("%s = %v AND is_deleted = %d", k, v, model.DeleteStatusForNot))
}
}
err := db.Count(&count).Error
return count > 0, err
}
func NewSysPatent() *SysPatent {
return &SysPatent{model.NewSysPatent()}
}

11
app/api/enterprise/model/technology_patent.go
View File

@ -1,11 +0,0 @@
package model
import "SciencesServer/app/common/model"
type TechnologyPatent struct {
*model.TechnologyPatent
}
func NewTechnologyPatent() *TechnologyPatent {
return &TechnologyPatent{TechnologyPatent: model.NewTechnologyPatent()}
}

29
app/api/enterprise/model/user_patent.go
View File

@ -1,11 +1,38 @@
package model
import "SciencesServer/app/common/model"
import (
"SciencesServer/app/common/model"
"SciencesServer/serve/orm"
"fmt"
)
type UserPatent struct {
*model.UserPatent
}
// Patents 专利信息
func (m *UserPatent) Patents(page, pageSize int, count *int64, where ...*model.ModelWhere) ([]*model.SysPatent, error) {
db := orm.GetDB().Table(m.TableName()+" AS u").
Select("u.id", "p.title", "p.apply_code", "p.apply_name", "p.apply_at", "shelf", "status", "u.created_at").
Joins(fmt.Sprintf("LEFT JOIN %s AS p ON u.patent_id = p.id", model.NewSysPatent().TableName())).
Where("u.is_deleted = ? AND p.is_deleted = ?", model.DeleteStatusForNot, model.DeleteStatusForNot)
if len(where) > 0 {
for _, wo := range where {
db = db.Where(wo.Condition, wo.Value)
}
}
out := make([]*model.SysPatent, 0)
if err := db.Count(count).Error; err != nil {
return nil, err
}
if err := db.Order("u.id " + model.OrderModeToDesc).Offset((page - 1) * pageSize).Limit(pageSize).Scan(&out).Error; err != nil {
return nil, err
}
return out, nil
}
func NewUserPatent() *UserPatent {
return &UserPatent{model.NewUserPatent()}
}

8
app/basic/api/struct.go
View File

@ -37,6 +37,14 @@ func (this *ImageForm) FilterImageURL() string {
return strings.Replace(this.Image, config.SettingInfo.Domain, "", -1)
}
type FileForm struct {
File string `json:"file" form:"file"`
}
func (this *FileForm) FilterURL() string {
return strings.Replace(this.File, config.SettingInfo.Domain, "", -1)
}
type PositionForm struct {
Longitude float64 `json:"longitude" form:"longitude" binding:"required"`
Latitude float64 `json:"latitude" form:"latitude" binding:"required"`

34
app/common/model/technology_patent.go
View File

@ -1,34 +0,0 @@
package model
import "time"
// TechnologyPatent 技术专利
type TechnologyPatent struct {
Model
ModelTenant
Local
MUid uint64 `gorm:"column:m_uid;type:int;default:0;comment:用户manage_uuid" json:"-"`
Title string `gorm:"column:title;type:varchar(50);default:null;comment:专利名称" json:"title"`
IPCCode string `gorm:"column:ipc_code;type:varchar(30);default:null;comment:IPC分类号" json:"ipc_code"`
CPCCode string `gorm:"column:cpc_code;type:varchar(30);default:null;comment:CPC分类号" json:"cpc_code"`
ApplyCode string `gorm:"column:apply_code;type:varchar(30);default:null;comment:专利申请号" json:"apply_code"`
ApplyName string `gorm:"column:apply_name;type:varchar(15);default:null;comment:专利申请人" json:"apply_name"`
ApplyAddress string `gorm:"column:apply_address;type:varchar(100);default:null;comment:专利申请人地址" json:"apply_address"`
ApplyZipCode string `gorm:"column:apply_zip_code;type:varchar(10);default:null;comment:专利申请人邮编" json:"apply_zip_code"`
ApplyAt time.Time `gorm:"column:apply_at;type:date;not null;comment:专利申请人时间" json:"apply_at"`
Inventor string `gorm:"column:inventor;type:varchar(15);default:null;comment:发明人" json:"inventor"`
PriorityCode string `gorm:"column:priority_code;type:varchar(30);default:null;comment:优先权号" json:"priority_code"`
PriorityAt time.Time `gorm:"column:priority_at;type:date;not null;comment:优先权日" json:"priority_at"`
OpenCode string `gorm:"column:open_code;type:varchar(100);default:null;comment:公开（公告）号" json:"open_code"`
OpenAt time.Time `gorm:"column:open_at;type:date;not null;comment:公开（公告）日" json:"open_at"`
ModelDeleted
ModelAt
}
func (m *TechnologyPatent) TableName() string {
return m.NewTableName("technology_patent")
}
func NewTechnologyPatent() *TechnologyPatent {
return &TechnologyPatent{}
}