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
2022-01-21 16:52:08 +08:00
parent adb5bd7283
commit bdb570d19a
14 changed files with 328 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
app/api/admin/api/manage.go
View File

@ -291,3 +291,29 @@ func (*Manage) AgentExamine(c *gin.Context) {
err := form.handle(api.GetSession()(c).(*session.Admin), nil)
api.APIResponse(err)(c)
}
func (*Manage) Enterprise(c *gin.Context) {
form := &struct {
Name string `json:"name" form:"name"`
Mode int `json:"mode" form:"mode" binding:"required"`
api.PageForm
}{}
if err := api.Bind(form)(c); err != nil {
api.APIFailure(err.(error))(c)
return
}
data, err := manage.NewEnterprise()(api.GetSession()(c).(*session.Admin)).Instance(form.Name, form.Mode, form.Page, form.PageSize)
api.APIResponse(err, data)(c)
}
func (*Manage) EnterpriseDelete(c *gin.Context) {
form := new(api.IDStringForm)
if err := api.Bind(form)(c); err != nil {
api.APIFailure(err.(error))(c)
return
}
err := manage.NewEnterprise()(api.GetSession()(c).(*session.Admin)).Delete(form.Convert())
api.APIResponse(err)(c)
}

81
app/api/admin/controller/manage/enterprise.go Normal file
View File

@ -0,0 +1,81 @@
package manage
import (
"SciencesServer/app/api/admin/model"
"SciencesServer/app/basic/controller"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/session"
"errors"
)
type Enterprise struct {
*session.Admin
}
type EnterpriseHandle func(session *session.Admin) *Enterprise
type (
// EnterpriseInstance 基本信息
EnterpriseInstance struct {
ID string `json:"id"`
TenantID string `json:"tenant_id"`
*model2.ManageCooperateEnterprise
Area string `json:"area"`
}
)
// Instance 首页信息
func (*Enterprise) Instance(name string, mode, page, pageSize int) (*controller.ReturnPages, error) {
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
where := make([]*model2.ModelWhere, 0)
if name != "" {
where = append(where, model2.NewWhereLike("name", name))
}
if mode > 0 {
where = append(where, model2.NewWhere("mode", mode))
}
var count int64
out, err := mManageCooperateEnterprise.CooperateEnterprises(page, pageSize, &count, where...)
if err != nil {
return nil, err
}
list := make([]*EnterpriseInstance, 0)
for _, v := range out {
list = append(list, &EnterpriseInstance{
ID: v.GetEncodeID(),
TenantID: v.GetEncodeTenantID(),
ManageCooperateEnterprise: v.ManageCooperateEnterprise,
Area: v.FormatBasic(),
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
}
// Delete 删除操作
func (c *Enterprise) Delete(id uint64) error {
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
mManageCooperateEnterprise.ID = id
isExist, err := model2.FirstField(mManageCooperateEnterprise.ManageCooperateEnterprise, []string{"id", "tenant_id"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，企业合作信息不存在或已被删除")
}
if c.TenantID > 0 && mManageCooperateEnterprise.TenantID != c.TenantID {
return errors.New("操作错误，无权限操作")
}
return model2.Delete(mManageCooperateEnterprise.ManageCooperateEnterprise)
}
func NewEnterprise() EnterpriseHandle {
return func(session *session.Admin) *Enterprise {
return &Enterprise{session}
}
}

43
app/api/admin/model/manage_cooperate_enterprise.go Normal file
View File

@ -0,0 +1,43 @@
package model
import (
"SciencesServer/app/common/model"
"SciencesServer/serve/orm"
"fmt"
)
type ManageCooperateEnterprise struct {
*model.ManageCooperateEnterprise
}
// ManageCooperateEnterpriseInfo 企业信息
type ManageCooperateEnterpriseInfo struct {
*model.ManageCooperateEnterprise
model.Area
}
// CooperateEnterprises 企业信息
func (m *ManageCooperateEnterprise) CooperateEnterprises(page, pageSize int, count *int64, where ...*model.ModelWhere) ([]*ManageCooperateEnterpriseInfo, error) {
db := orm.GetDB().Table(m.TableName()+" AS c").
Select("c.*", "t.province", "t.city").
Joins(fmt.Sprintf("LEFT JOIN %s AS t ON c.tenant_id = t.id", model.NewSysTenant().TableName()))
if len(where) > 0 {
for _, wo := range where {
db = db.Where(wo.Condition, wo.Value)
}
}
out := make([]*ManageCooperateEnterpriseInfo, 0)
if err := db.Count(count).Error; err != nil {
return nil, err
}
if err := db.Order("c.id " + model.OrderModeToDesc).Offset((page - 1) * pageSize).Limit(pageSize).Scan(&out).Error; err != nil {
return nil, err
}
return out, nil
}
func NewManageCooperateEnterprise() *ManageCooperateEnterprise {
return &ManageCooperateEnterprise{model.NewManageCooperateEnterprise()}
}

26
app/api/enterprise/api/manage.go
View File

@ -12,13 +12,13 @@ type Manage struct{}
type (
// enterpriseForm 设备信息
enterpriseForm struct {
Mode int `json:"mode" form:"mode" binding:"required"`
Title string `json:"title" form:"title" binding:"required"`
Name string `json:"name" form:"name"`
Mobile string `json:"mobile" form:"mobile"`
Content string `json:"content" form:"content"`
Papers []string `json:"papers" form:"papers"`
Patents []string `json:"patents" form:"patents"`
Mode int `json:"mode" form:"mode" binding:"required"`
Name string `json:"name" form:"name" binding:"required"`
Contact string `json:"contact" form:"contact"`
ContactMobile string `json:"contact_mobile" form:"contact_mobile"`
Content string `json:"content" form:"content"`
Papers []string `json:"papers" form:"papers"`
Patents []string `json:"patents" form:"patents"`
}
// equipmentForm 设备信息
equipmentForm struct {
@ -54,8 +54,8 @@ func (a *enterpriseForm) PatentInfo() []uint64 {
func (*Manage) Enterprise(c *gin.Context) {
form := &struct {
Mode int `json:"mode" form:"mode" binding:"required"`
Title string `json:"title" form:"title"`
Name string `json:"name" form:"name"`
Mode int `json:"mode" form:"mode" binding:"required"`
api.PageForm
}{}
if err := api.Bind(form)(c); err != nil {
@ -63,7 +63,7 @@ func (*Manage) Enterprise(c *gin.Context) {
return
}
data, err := manage.NewEnterprise()(api.GetSession()(c).(*session.Enterprise), api.GetTenantID()(c).(uint64)).
List(form.Mode, form.Title, form.Page, form.PageSize)
List(form.Name, form.Mode, form.Page, form.PageSize)
api.APIResponse(err, data)(c)
}
@ -75,7 +75,7 @@ func (*Manage) EnterpriseAdd(c *gin.Context) {
return
}
err := manage.NewEnterprise()(api.GetSession()(c).(*session.Enterprise), api.GetTenantID()(c).(uint64)).
Form(&manage.EnterpriseParams{Mode: form.Mode, Title: form.Title, Name: form.Name, Mobile: form.Mobile,
Form(&manage.EnterpriseParams{Mode: form.Mode, Name: form.Name, Contact: form.Contact, ContactMobile: form.ContactMobile,
Papers: form.paperInfo(), Patents: form.PatentInfo(), Content: form.Content,
})
api.APIResponse(err)(c)
@ -91,8 +91,8 @@ func (*Manage) EnterpriseEdit(c *gin.Context) {
return
}
err := manage.NewEnterprise()(api.GetSession()(c).(*session.Enterprise), api.GetTenantID()(c).(uint64)).
Form(&manage.EnterpriseParams{ID: form.Convert(), Mode: form.Mode, Title: form.Title, Name: form.Name,
Mobile: form.Mobile, Papers: form.paperInfo(), Patents: form.PatentInfo(), Content: form.Content,
Form(&manage.EnterpriseParams{ID: form.Convert(), Mode: form.Mode, Name: form.Name, Contact: form.Contact,
ContactMobile: form.ContactMobile, Papers: form.paperInfo(), Patents: form.PatentInfo(), Content: form.Content,
})
api.APIResponse(err)(c)
}

26
app/api/enterprise/controller/manage/common.go
View File

@ -46,13 +46,13 @@ type (
// CooperateInfo 合作的企业信息
CooperateInfo struct {
ID string `json:"id"`
Title string `json:"title"`
Name string `json:"name"`
PatentCount int `json:"patent_count"`
PaperCount int `json:"paper_count"`
}
// CooperateDetailInfo 合作的企业详细信息
CooperateDetailInfo struct {
Title string `json:"title"`
Name string `json:"name"`
Patent []*PatentInstance `json:"patent"`
Paper []*PaperInstance `json:"paper"`
}
@ -158,18 +158,18 @@ func paper(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
// cooperate 合作的信息
func cooperate(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
out := make([]*model2.UserCooperateEnterprise, 0)
out := make([]*model2.ManageCooperateEnterprise, 0)
var count int64
if err := model2.PagesFields(mUserCooperateEnterprise.UserCooperateEnterprise, &out, []string{"id", "title", "paper", "patent"},
if err := model2.PagesFields(mManageCooperateEnterprise.ManageCooperateEnterprise, &out, []string{"id", "title", "paper", "patent"},
page, pageSize, &count, &model2.ModelWhereOrder{
Where: model2.NewWhereIn("uid", uids),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}, &model2.ModelWhereOrder{
Where: model2.NewWhere("kind", model2.UserCooperateEnterpriseModeForCooperateAlready)}); err != nil {
Where: model2.NewWhere("kind", model2.ManageCooperateEnterpriseModeForCooperateAlready)}); err != nil {
return nil, err
}
@ -178,7 +178,7 @@ func cooperate(uids []uint64, page, pageSize int) (*controller.ReturnPages, erro
for _, v := range out {
list = append(list, &CooperateInfo{
ID: v.GetEncodeID(),
Title: v.Title,
Name: v.Name,
PatentCount: len(v.GetPatentAttribute()),
PaperCount: len(v.GetPaperAttribute()),
})
@ -188,10 +188,10 @@ func cooperate(uids []uint64, page, pageSize int) (*controller.ReturnPages, erro
// cooperateDetail 合作企业详情
func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
mUserCooperateEnterprise.ID = id
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
mManageCooperateEnterprise.ID = id
isExist, err := model2.FirstField(mUserCooperateEnterprise.UserCooperateEnterprise, []string{"id", "title", "paper", "patent"})
isExist, err := model2.FirstField(mManageCooperateEnterprise.ManageCooperateEnterprise, []string{"id", "title", "paper", "patent"})
if err != nil {
return nil, err
@ -199,7 +199,7 @@ func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
return nil, errors.New("操作错误，企业信息不存在或已被删除")
}
out := &CooperateDetailInfo{
Title: mUserCooperateEnterprise.Title,
Name: mManageCooperateEnterprise.Name,
Patent: make([]*PatentInstance, 0),
Paper: make([]*PaperInstance, 0),
}
@ -208,7 +208,7 @@ func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
patents := make([]*model.SysPatentInfo, 0)
if patents, err = mSysPatent.Instance(model2.NewWhereIn("p.id", mUserCooperateEnterprise.GetPatentAttribute())); err != nil {
if patents, err = mSysPatent.Instance(model2.NewWhereIn("p.id", mManageCooperateEnterprise.GetPatentAttribute())); err != nil {
return nil, err
}
for _, v := range patents {
@ -224,7 +224,7 @@ func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
if err = model2.ScanFields(mTechnologyPaper.TechnologyPaper, &papers, []string{"id", "title", "ext", "keyword"},
&model2.ModelWhereOrder{
Where: model2.NewWhereIn("id", mUserCooperateEnterprise.GetPaperAttribute()),
Where: model2.NewWhereIn("id", mManageCooperateEnterprise.GetPaperAttribute()),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}); err != nil {
return nil, err

78
app/api/enterprise/controller/manage/enterprise.go
View File

@ -20,35 +20,35 @@ type (
// EnterpriseInfo 企业信息
EnterpriseInfo struct {
ID string `json:"id"`
*model.UserCooperateEnterpriseInfo
*model.ManageCooperateEnterpriseInfo
Papers []string `json:"papers"`
Patents []string `json:"patents"`
}
// EnterpriseParams 企业参数信息
EnterpriseParams struct {
ID uint64
Mode int
Title, Name, Mobile string
Papers, Patents []uint64
Content string
ID uint64
Mode int
Name, Contact, ContactMobile string
Papers, Patents []uint64
Content string
}
)
// List 列表信息
func (c *Enterprise) List(mode int, title string, page, pageSize int) (*controller.ReturnPages, error) {
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
func (c *Enterprise) List(name string, mode, page, pageSize int) (*controller.ReturnPages, error) {
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
where := []*model2.ModelWhere{
model2.NewWhere("mode", mode),
//model2.NewWhere("tenant_id", c.tenantID),
model2.NewWhere("tenant_id", c.tenantID),
model2.NewWhere("uid", c.UID),
}
if title != "" {
where = append(where, model2.NewWhereLike("title", title))
if name != "" {
where = append(where, model2.NewWhereLike("name", name))
}
var count int64
out, err := mUserCooperateEnterprise.Enterprise(page, pageSize, &count, where...)
out, err := mManageCooperateEnterprise.Enterprise(page, pageSize, &count, where...)
if err != nil {
return nil, err
@ -57,10 +57,10 @@ func (c *Enterprise) List(mode int, title string, page, pageSize int) (*controll
for _, v := range out {
list = append(list, &EnterpriseInfo{
ID: v.GetEncodeID(),
UserCooperateEnterpriseInfo: v,
Papers: v.GetPaperAttribute(),
Patents: v.GetPatentAttribute(),
ID: v.GetEncodeID(),
ManageCooperateEnterpriseInfo: v,
Papers: v.GetPaperAttribute(),
Patents: v.GetPatentAttribute(),
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
@ -68,57 +68,57 @@ func (c *Enterprise) List(mode int, title string, page, pageSize int) (*controll
// Form 数据操作
func (c *Enterprise) Form(params *EnterpriseParams) error {
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
if params.ID > 0 {
mUserCooperateEnterprise.ID = params.ID
mManageCooperateEnterprise.ID = params.ID
isExist, err := model2.FirstField(mUserCooperateEnterprise.UserCooperateEnterprise, []string{"id", "uid", "created_at"})
isExist, err := model2.FirstField(mManageCooperateEnterprise.ManageCooperateEnterprise, []string{"id", "uid", "created_at"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，企业信息不存在或已被删除")
} else if mUserCooperateEnterprise.UID != c.UID {
} else if mManageCooperateEnterprise.UID != c.UID {
return errors.New("无权限操作")
}
}
mUserCooperateEnterprise.Title = params.Title
mUserCooperateEnterprise.Mode = model2.UserCooperateEnterpriseMode(params.Mode)
mManageCooperateEnterprise.Name = params.Name
mManageCooperateEnterprise.Mode = model2.ManageCooperateEnterpriseMode(params.Mode)
// 已合作信息
if mUserCooperateEnterprise.Mode == model2.UserCooperateEnterpriseModeForCooperateAlready {
mUserCooperateEnterprise.SetPaperAttribute(params.Papers)
mUserCooperateEnterprise.SetPatentAttribute(params.Patents)
if mManageCooperateEnterprise.Mode == model2.ManageCooperateEnterpriseModeForCooperateAlready {
mManageCooperateEnterprise.SetPaperAttribute(params.Papers)
mManageCooperateEnterprise.SetPatentAttribute(params.Patents)
// 想合作信息
} else if mUserCooperateEnterprise.Mode == model2.UserCooperateEnterpriseModeForCooperateToWant {
mUserCooperateEnterprise.Name = params.Name
mUserCooperateEnterprise.Mobile = params.Mobile
mUserCooperateEnterprise.Content = params.Content
} else if mManageCooperateEnterprise.Mode == model2.ManageCooperateEnterpriseModeForCooperateToWant {
mManageCooperateEnterprise.Contact = params.Contact
mManageCooperateEnterprise.ContactMobile = params.ContactMobile
mManageCooperateEnterprise.Content = params.Content
}
if mUserCooperateEnterprise.ID > 0 {
return model2.Updates(mUserCooperateEnterprise.UserCooperateEnterprise, mUserCooperateEnterprise.UserCooperateEnterprise)
if mManageCooperateEnterprise.ID > 0 {
return model2.Updates(mManageCooperateEnterprise.ManageCooperateEnterprise, mManageCooperateEnterprise.ManageCooperateEnterprise)
}
mUserCooperateEnterprise.TenantID = c.tenantID
mUserCooperateEnterprise.UID = c.UID
return model2.Create(mUserCooperateEnterprise.UserCooperateEnterprise)
mManageCooperateEnterprise.TenantID = c.tenantID
mManageCooperateEnterprise.UID = c.UID
return model2.Create(mManageCooperateEnterprise.ManageCooperateEnterprise)
}
// Delete 删除操作
func (c *Enterprise) Delete(id uint64) error {
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
mUserCooperateEnterprise.ID = id
mManageCooperateEnterprise.ID = id
isExist, err := model2.FirstField(mUserCooperateEnterprise.UserCooperateEnterprise, []string{"id", "uid", "created_at"})
isExist, err := model2.FirstField(mManageCooperateEnterprise.ManageCooperateEnterprise, []string{"id", "uid", "created_at"})
if err != nil {
return err
} else if !isExist {
return errors.New("操作错误，企业信息不存在或已被删除")
} else if mUserCooperateEnterprise.UID != c.UID {
} else if mManageCooperateEnterprise.UID != c.UID {
return errors.New("无权限操作")
}
return model2.Delete(mUserCooperateEnterprise.UserCooperateEnterprise)
return model2.Delete(mManageCooperateEnterprise.ManageCooperateEnterprise)
}
func NewEnterprise() EnterpriseHandle {

18
app/api/enterprise/model/user_cooperate_enterprise.go → app/api/enterprise/model/manage_cooperate_enterprise.go
View File

@ -5,26 +5,26 @@ import (
"SciencesServer/serve/orm"
)
type UserCooperateEnterprise struct {
*model.UserCooperateEnterprise
type ManageCooperateEnterprise struct {
*model.ManageCooperateEnterprise
}
// UserCooperateEnterpriseInfo 用户企业关联信息
type UserCooperateEnterpriseInfo struct {
*model.UserCooperateEnterprise
// ManageCooperateEnterpriseInfo 用户企业关联信息
type ManageCooperateEnterpriseInfo struct {
*model.ManageCooperateEnterprise
PaperTitle string `json:"paper_title"`
PatentTitle string `json:"patent_title"`
}
// Enterprise 企业信息
func (m *UserCooperateEnterprise) Enterprise(page, pageSize int, count *int64, where ...*model.ModelWhere) ([]*UserCooperateEnterpriseInfo, error) {
func (m *ManageCooperateEnterprise) Enterprise(page, pageSize int, count *int64, where ...*model.ModelWhere) ([]*ManageCooperateEnterpriseInfo, error) {
db := orm.GetDB().Table(m.TableName()+" AS u").
Select("u.*",
"(SELECT GROUP_CONCAT(t_p.title) FROM (SELECT id, title FROM technology_paper) AS t_p WHERE FIND_IN_SET(t_p.id, u.paper)) AS paper_title",
"(SELECT GROUP_CONCAT(s_p.title) FROM (SELECT id, title FROM sys_patent) AS s_p WHERE FIND_IN_SET(s_p.id, u.patent)) AS patent_title").
Where("u.is_deleted = ?", model.DeleteStatusForNot)
out := make([]*UserCooperateEnterpriseInfo, 0)
out := make([]*ManageCooperateEnterpriseInfo, 0)
if len(where) > 0 {
for _, v := range where {
@ -40,6 +40,6 @@ func (m *UserCooperateEnterprise) Enterprise(page, pageSize int, count *int64, w
return out, nil
}
func NewUserCooperateEnterprise() *UserCooperateEnterprise {
return &UserCooperateEnterprise{model.NewUserCooperateEnterprise()}
func NewManageCooperateEnterprise() *ManageCooperateEnterprise {
return &ManageCooperateEnterprise{model.NewManageCooperateEnterprise()}
}

26
app/api/website/controller/manage/common.go
View File

@ -35,13 +35,13 @@ type (
// CooperateInfo 合作的企业信息
CooperateInfo struct {
ID string `json:"id"`
Title string `json:"title"`
Name string `json:"name"`
PatentCount int `json:"patent_count"`
PaperCount int `json:"paper_count"`
}
// CooperateDetailInfo 合作的企业详细信息
CooperateDetailInfo struct {
Title string `json:"title"`
Name string `json:"name"`
Patent []*technology.PatentInfo `json:"patent"`
Paper []*technology.PaperInfo `json:"paper"`
}
@ -148,18 +148,18 @@ func paper(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
// cooperate 合作的信息
func cooperate(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
out := make([]*model2.UserCooperateEnterprise, 0)
out := make([]*model2.ManageCooperateEnterprise, 0)
var count int64
if err := model2.PagesFields(mUserCooperateEnterprise.UserCooperateEnterprise, &out, []string{"id", "title", "paper", "patent"},
if err := model2.PagesFields(mManageCooperateEnterprise.ManageCooperateEnterprise, &out, []string{"id", "title", "paper", "patent"},
page, pageSize, &count, &model2.ModelWhereOrder{
Where: model2.NewWhereIn("uid", uids),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}, &model2.ModelWhereOrder{
Where: model2.NewWhere("kind", model2.UserCooperateEnterpriseModeForCooperateAlready)}); err != nil {
Where: model2.NewWhere("kind", model2.ManageCooperateEnterpriseModeForCooperateAlready)}); err != nil {
return nil, err
}
@ -168,7 +168,7 @@ func cooperate(uids []uint64, page, pageSize int) (*controller.ReturnPages, erro
for _, v := range out {
list = append(list, &CooperateInfo{
ID: v.GetEncodeID(),
Title: v.Title,
Name: v.Name,
PatentCount: len(v.GetPatentAttribute()),
PaperCount: len(v.GetPaperAttribute()),
})
@ -178,10 +178,10 @@ func cooperate(uids []uint64, page, pageSize int) (*controller.ReturnPages, erro
// cooperateDetail 合作企业详情
func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
mUserCooperateEnterprise.ID = id
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
mManageCooperateEnterprise.ID = id
isExist, err := model2.FirstField(mUserCooperateEnterprise.UserCooperateEnterprise, []string{"id", "title", "paper", "patent"})
isExist, err := model2.FirstField(mManageCooperateEnterprise.ManageCooperateEnterprise, []string{"id", "title", "paper", "patent"})
if err != nil {
return nil, err
@ -189,7 +189,7 @@ func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
return nil, errors.New("操作错误，企业信息不存在或已被删除")
}
out := &CooperateDetailInfo{
Title: mUserCooperateEnterprise.Title,
Name: mManageCooperateEnterprise.Name,
Patent: make([]*technology.PatentInfo, 0),
Paper: make([]*technology.PaperInfo, 0),
}
@ -198,7 +198,7 @@ func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
patents := make([]*model.SysPatentInfo, 0)
if patents, err = mSysPatent.Instance(model2.NewWhereIn("p.id", mUserCooperateEnterprise.GetPatentAttribute())); err != nil {
if patents, err = mSysPatent.Instance(model2.NewWhereIn("p.id", mManageCooperateEnterprise.GetPatentAttribute())); err != nil {
return nil, err
}
for _, v := range patents {
@ -214,7 +214,7 @@ func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
if err = model2.ScanFields(mTechnologyPaper.TechnologyPaper, &papers, []string{"id", "title", "ext", "keyword"},
&model2.ModelWhereOrder{
Where: model2.NewWhereIn("id", mUserCooperateEnterprise.GetPaperAttribute()),
Where: model2.NewWhereIn("id", mManageCooperateEnterprise.GetPaperAttribute()),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}); err != nil {
return nil, err

11
app/api/website/model/manage_cooperate_enterprise.go Normal file
View File

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

11
app/api/website/model/user_cooperate_enterprise.go
View File

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

1
app/common/migrate/instance.go
View File

@ -137,6 +137,7 @@ func (this *Instance) Handle() {
&synchronized{iModel: model.NewManageCompany()}, &synchronized{iModel: model.NewManageExpert()},
&synchronized{iModel: model.NewManageLaboratory()}, &synchronized{iModel: model.NewManageResearch()},
&synchronized{iModel: model.NewManageAgent()},
&synchronized{iModel: model.NewManageCooperateEnterprise()},
&synchronized{iModel: model.NewTechnologyAchievement()}, &synchronized{iModel: model.NewTechnologyDemand()},
&synchronized{iModel: model.NewTechnologyPaper()}, &synchronized{iModel: model.NewTechnologyProduct()},
&synchronized{iModel: model.NewTechnologyProject()}, &synchronized{iModel: model.NewTechnologyTopic()},

77
app/common/model/manage_cooperate_enterprise.go Normal file
View File

@ -0,0 +1,77 @@
package model
import (
"SciencesServer/utils"
"fmt"
"strings"
)
// ManageCooperateEnterprise 企业数据模型管理
type ManageCooperateEnterprise struct {
Model
ModelTenant
UID uint64 `gorm:"column:uid;type:int;default:0;comment:用户uuid" json:"-"`
Mode ManageCooperateEnterpriseMode `gorm:"column:mode;type:int;default:0;comment:合作模式（1：已合作，2：想合作）" json:"mode"`
Name string `gorm:"column:name;type:varchar(30);default:'';comment:企业名称" json:"name"`
Contact string `gorm:"column:contact;type:varchar(50);default:'';comment:企业联系人" json:"contact"`
ContactMobile string `gorm:"column:contact_mobile;type:varchar(20);default:'';comment:企业联系方式" json:"contact_mobile"`
Paper string `gorm:"column:paper;type:varchar(255);default:'';comment:论文信息" json:"-"`
Patent string `gorm:"column:patent;type:varchar(255);default:'';comment:专利信息" json:"-"`
Content string `gorm:"column:content;type:varchar(255);default:'';comment:合作内容" json:"content"`
ModelDeleted
ModelAt
}
// ManageCooperateEnterpriseMode 用户企业合作模式
type ManageCooperateEnterpriseMode int
const (
// ManageCooperateEnterpriseModeForCooperateAlready 已合作
ManageCooperateEnterpriseModeForCooperateAlready ManageCooperateEnterpriseMode = iota + 1
// ManageCooperateEnterpriseModeForCooperateToWant 想合作
ManageCooperateEnterpriseModeForCooperateToWant
)
func (m *ManageCooperateEnterprise) TableName() string {
return "manage_cooperate_enterprise"
}
func (m *ManageCooperateEnterprise) GetPaperAttribute() []string {
out := make([]string, 0)
for _, v := range strings.Split(m.Paper, ",") {
out = append(out, (&Model{ID: utils.StringToUnit64(v)}).GetEncodeID())
}
return out
}
func (m *ManageCooperateEnterprise) SetPaperAttribute(value []uint64) {
out := make([]string, 0)
for _, v := range value {
out = append(out, fmt.Sprintf("%d", v))
}
m.Paper = strings.Join(out, ",")
}
func (m *ManageCooperateEnterprise) GetPatentAttribute() []string {
out := make([]string, 0)
for _, v := range strings.Split(m.Patent, ",") {
out = append(out, (&Model{ID: utils.StringToUnit64(v)}).GetEncodeID())
}
return out
}
func (m *ManageCooperateEnterprise) SetPatentAttribute(value []uint64) {
out := make([]string, 0)
for _, v := range value {
out = append(out, fmt.Sprintf("%d", v))
}
m.Patent = strings.Join(out, ",")
}
func NewManageCooperateEnterprise() *ManageCooperateEnterprise {
return &ManageCooperateEnterprise{}
}

77
app/common/model/user_cooperate_enterprise.go
View File

@ -1,77 +0,0 @@
package model
import (
"SciencesServer/utils"
"fmt"
"strings"
)
// UserCooperateEnterprise 用户企业数据模型管理
type UserCooperateEnterprise struct {
Model
ModelTenant
UID uint64 `gorm:"column:uid;type:int;default:0;comment:用户uuid" json:"-"`
Mode UserCooperateEnterpriseMode `gorm:"column:mode;type:int;default:0;comment:合作模式（1：已合作，2：想合作）" json:"mode"`
Title string `gorm:"column:title;type:varchar(30);default:'';comment:企业名称" json:"title"`
Name string `gorm:"column:name;type:varchar(50);default:'';comment:企业联系人" json:"name"`
Mobile string `gorm:"column:mobile;type:varchar(15);default:'';comment:企业联系方式" json:"mobile"`
Paper string `gorm:"column:paper;type:varchar(255);default:'';comment:论文信息" json:"-"`
Patent string `gorm:"column:patent;type:varchar(255);default:'';comment:专利信息" json:"-"`
Content string `gorm:"column:content;type:varchar(255);default:'';comment:合作内容" json:"content"`
ModelDeleted
ModelAt
}
// UserCooperateEnterpriseMode 用户企业合作模式
type UserCooperateEnterpriseMode int
const (
// UserCooperateEnterpriseModeForCooperateAlready 已合作
UserCooperateEnterpriseModeForCooperateAlready UserCooperateEnterpriseMode = iota + 1
// UserCooperateEnterpriseModeForCooperateToWant 想合作
UserCooperateEnterpriseModeForCooperateToWant
)
func (m *UserCooperateEnterprise) TableName() string {
return "user_cooperate_enterprise"
}
func (m *UserCooperateEnterprise) GetPaperAttribute() []string {
out := make([]string, 0)
for _, v := range strings.Split(m.Paper, ",") {
out = append(out, (&Model{ID: utils.StringToUnit64(v)}).GetEncodeID())
}
return out
}
func (m *UserCooperateEnterprise) SetPaperAttribute(value []uint64) {
out := make([]string, 0)
for _, v := range value {
out = append(out, fmt.Sprintf("%d", v))
}
m.Paper = strings.Join(out, ",")
}
func (m *UserCooperateEnterprise) GetPatentAttribute() []string {
out := make([]string, 0)
for _, v := range strings.Split(m.Patent, ",") {
out = append(out, (&Model{ID: utils.StringToUnit64(v)}).GetEncodeID())
}
return out
}
func (m *UserCooperateEnterprise) SetPatentAttribute(value []uint64) {
out := make([]string, 0)
for _, v := range value {
out = append(out, fmt.Sprintf("%d", v))
}
m.Patent = strings.Join(out, ",")
}
func NewUserCooperateEnterprise() *UserCooperateEnterprise {
return &UserCooperateEnterprise{}
}