feat：完善项目信息

app/api/admin/api/manage.go

@@ -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)
+}

app/api/admin/controller/manage/enterprise.go

@@ -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}
+	}
+}

app/api/admin/model/manage_cooperate_enterprise.go

@@ -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()}
+}

app/api/enterprise/api/manage.go

@@ -12,13 +12,13 @@ type Manage struct{}
 type (
 	// enterpriseForm 设备信息
 	enterpriseForm struct {
-		Mode    int      `json:"mode" form:"mode" binding:"required"`
+		Mode          int      `json:"mode" form:"mode" binding:"required"`
-		Title   string   `json:"title" form:"title" binding:"required"`
+		Name          string   `json:"name" form:"name" binding:"required"`
-		Name    string   `json:"name" form:"name"`
+		Contact       string   `json:"contact" form:"contact"`
-		Mobile  string   `json:"mobile" form:"mobile"`
+		ContactMobile string   `json:"contact_mobile" form:"contact_mobile"`
-		Content string   `json:"content" form:"content"`
+		Content       string   `json:"content" form:"content"`
-		Papers  []string `json:"papers" form:"papers"`
+		Papers        []string `json:"papers" form:"papers"`
-		Patents []string `json:"patents" form:"patents"`
+		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"`
+		Name string `json:"name" form:"name"`
-		Title string `json:"title" form:"title"`
+		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,
+		Form(&manage.EnterpriseParams{ID: form.Convert(), Mode: form.Mode, Name: form.Name, Contact: form.Contact,
-			Mobile: form.Mobile, Papers: form.paperInfo(), Patents: form.PatentInfo(), Content: form.Content,
+			ContactMobile: form.ContactMobile, Papers: form.paperInfo(), Patents: form.PatentInfo(), Content: form.Content,
 		})
 	api.APIResponse(err)(c)
 }

app/api/enterprise/controller/manage/common.go

@@ -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()
+	mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
-	mUserCooperateEnterprise.ID = id
+	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

app/api/enterprise/controller/manage/enterprise.go

@@ -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
+		ID                           uint64
-		Mode                int
+		Mode                         int
-		Title, Name, Mobile string
+		Name, Contact, ContactMobile string
-		Papers, Patents     []uint64
+		Papers, Patents              []uint64
-		Content             string
+		Content                      string
 	}
 )
 
 // List 列表信息
-func (c *Enterprise) List(mode int, title string, page, pageSize int) (*controller.ReturnPages, error) {
+func (c *Enterprise) List(name string, mode, page, pageSize int) (*controller.ReturnPages, error) {
-	mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
+	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 != "" {
+	if name != "" {
-		where = append(where, model2.NewWhereLike("title", title))
+		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(),
+			ID:                            v.GetEncodeID(),
-			UserCooperateEnterpriseInfo: v,
+			ManageCooperateEnterpriseInfo: v,
-			Papers:                      v.GetPaperAttribute(),
+			Papers:                        v.GetPaperAttribute(),
-			Patents:                     v.GetPatentAttribute(),
+			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
+	mManageCooperateEnterprise.Name = params.Name
-	mUserCooperateEnterprise.Mode = model2.UserCooperateEnterpriseMode(params.Mode)
+	mManageCooperateEnterprise.Mode = model2.ManageCooperateEnterpriseMode(params.Mode)
 	// 已合作信息
-	if mUserCooperateEnterprise.Mode == model2.UserCooperateEnterpriseModeForCooperateAlready {
+	if mManageCooperateEnterprise.Mode == model2.ManageCooperateEnterpriseModeForCooperateAlready {
-		mUserCooperateEnterprise.SetPaperAttribute(params.Papers)
+		mManageCooperateEnterprise.SetPaperAttribute(params.Papers)
-		mUserCooperateEnterprise.SetPatentAttribute(params.Patents)
+		mManageCooperateEnterprise.SetPatentAttribute(params.Patents)
 		// 想合作信息
-	} else if mUserCooperateEnterprise.Mode == model2.UserCooperateEnterpriseModeForCooperateToWant {
+	} else if mManageCooperateEnterprise.Mode == model2.ManageCooperateEnterpriseModeForCooperateToWant {
-		mUserCooperateEnterprise.Name = params.Name
+		mManageCooperateEnterprise.Contact = params.Contact
-		mUserCooperateEnterprise.Mobile = params.Mobile
+		mManageCooperateEnterprise.ContactMobile = params.ContactMobile
-		mUserCooperateEnterprise.Content = params.Content
+		mManageCooperateEnterprise.Content = params.Content
 	}
-	if mUserCooperateEnterprise.ID > 0 {
+	if mManageCooperateEnterprise.ID > 0 {
-		return model2.Updates(mUserCooperateEnterprise.UserCooperateEnterprise, mUserCooperateEnterprise.UserCooperateEnterprise)
+		return model2.Updates(mManageCooperateEnterprise.ManageCooperateEnterprise, mManageCooperateEnterprise.ManageCooperateEnterprise)
 	}
-	mUserCooperateEnterprise.TenantID = c.tenantID
+	mManageCooperateEnterprise.TenantID = c.tenantID
-	mUserCooperateEnterprise.UID = c.UID
+	mManageCooperateEnterprise.UID = c.UID
-	return model2.Create(mUserCooperateEnterprise.UserCooperateEnterprise)
+	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 {

app/api/enterprise/model/manage_cooperate_enterprise.go

@@ -5,26 +5,26 @@ import (
 	"SciencesServer/serve/orm"
 )
 
-type UserCooperateEnterprise struct {
+type ManageCooperateEnterprise struct {
-	*model.UserCooperateEnterprise
+	*model.ManageCooperateEnterprise
 }
 
-// UserCooperateEnterpriseInfo 用户企业关联信息
+// ManageCooperateEnterpriseInfo 用户企业关联信息
-type UserCooperateEnterpriseInfo struct {
+type ManageCooperateEnterpriseInfo struct {
-	*model.UserCooperateEnterprise
+	*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 {
+func NewManageCooperateEnterprise() *ManageCooperateEnterprise {
-	return &UserCooperateEnterprise{model.NewUserCooperateEnterprise()}
+	return &ManageCooperateEnterprise{model.NewManageCooperateEnterprise()}
 }

app/api/website/controller/manage/common.go

@@ -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()
+	mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
-	mUserCooperateEnterprise.ID = id
+	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

app/api/website/model/manage_cooperate_enterprise.go

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

app/api/website/model/user_cooperate_enterprise.go

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

app/common/migrate/instance.go

@@ -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()},

app/common/model/manage_cooperate_enterprise.go

@@ -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{}
+}

app/common/model/user_cooperate_enterprise.go

@@ -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{}
-}

router/address.go

@@ -309,6 +309,8 @@ func registerAdminAPI(app *gin.Engine) {
 		manage.POST("/laboratory/edit", _api.LaboratoryForm)
 		manage.POST("/laboratory/detail", _api.LaboratoryDetail)
 		manage.POST("/laboratory/examine", _api.LaboratoryExamine)
+		manage.POST("/enterprise", _api.Enterprise)
+		manage.POST("/enterprise/delete", _api.EnterpriseDelete)
 	}
 	// Service 服务管理
 	service := v1.Group("/service")