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

feat：优化信息，完善es查询，完善网站首页公司信息查询

Browse Source
This commit is contained in:
henry
2021-12-23 17:43:27 +08:00
parent 741138b3ea
commit eb2cfcb06b
18 changed files with 441 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
app/api/website/api/es.go
View File

@ -11,6 +11,7 @@ type ES struct{}
func (*ES) Create(c *gin.Context) {
form := &struct {
ID uint64 `json:"id" form:"id"`
Identity int `json:"identity" form:"identity"`
Title string `json:"title" form:"title"`
Keyword string `json:"keyword" form:"keyword"`
Research string `json:"research" form:"research"`
@ -19,8 +20,9 @@ func (*ES) Create(c *gin.Context) {
api.APIFailure(err.(error))(c)
return
}
manage := service.NewManage(
manage := service.NewESManage(
service.WithManageID(form.ID),
service.WithManageIdentity(form.Identity),
service.WithManageTitle(form.Title),
service.WithManageKeyword(form.Keyword),
service.WithManageResearch(form.Research),
@ -30,13 +32,19 @@ func (*ES) Create(c *gin.Context) {
func (*ES) Search(c *gin.Context) {
form := &struct {
Params map[string]interface{} `json:"params" form:"params"`
Identity int `json:"identity" form:"identity" binding:"required"`
Industry string `json:"industry" form:"industry"`
Param string `json:"param" form:"params"`
}{}
if err := api.Bind(form)(c); err != nil {
api.APIFailure(err.(error))(c)
return
}
manage := service.NewManage()
data, err := manage.Search(1, 10, form.Params)
manage := service.NewESManage(service.WithManageIdentity(form.Identity),
service.WithManageTitle(form.Param),
service.WithManageIndustry(form.Industry),
service.WithManageKeyword(form.Param),
service.WithManageResearch(form.Param))
data, err := manage.Search(1, 1)
api.APIResponse(err, data)(c)
}

49
app/api/website/api/manage.go Normal file
View File

@ -0,0 +1,49 @@
package api
import (
"SciencesServer/app/api/website/controller/manage"
"SciencesServer/app/basic/api"
"github.com/gin-gonic/gin"
)
type Manage struct{}
func (*Manage) Search(c *gin.Context) {
form := &struct {
Identity int `json:"identity" form:"identity" binding:"required"`
Param string `json:"param" form:"param" binding:"required"`
Industry string `json:"industry" form:"industry"`
api.PageForm
}{}
if err := api.Bind(form)(c); err != nil {
api.APIFailure(err.(error))(c)
return
}
data, err := manage.NewSearch()().Launch(form.Identity, form.Param, form.Industry, form.Page, form.PageSize)
api.APIResponse(err, data)(c)
}
func (*Manage) Company(c *gin.Context) {
form := &struct {
CompanyID string `json:"company_id" form:"company_id" binding:"required"`
}{}
if err := api.Bind(form)(c); err != nil {
api.APIFailure(err.(error))(c)
return
}
data, err := manage.NewCompany()(nil).Instance((&api.IDStringForm{ID: form.CompanyID}).Convert())
api.APIResponse(err, data)(c)
}
func (*Manage) CompanyProduct(c *gin.Context) {
form := &struct {
CompanyID string `json:"company_id" form:"company_id" binding:"required"`
api.PageForm
}{}
if err := api.Bind(form)(c); err != nil {
api.APIFailure(err.(error))(c)
return
}
data, err := manage.NewCompany()(nil).Product((&api.IDStringForm{ID: form.CompanyID}).Convert(), form.Page, form.PageSize)
api.APIResponse(err, data)(c)
}

94
app/api/website/controller/manage/company.go Normal file
View File

@ -0,0 +1,94 @@
package manage
import (
"SciencesServer/app/api/website/model"
"SciencesServer/app/basic/controller"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/session"
config2 "SciencesServer/config"
"errors"
)
type Company struct {
*session.Enterprise
}
type CompanyHandle func(session *session.Enterprise) *Company
type (
// CompanyBasicInfo 公司基本信息
CompanyBasicInfo struct {
ID string `json:"id"`
Kind model2.ManageCompanyKind `json:"kind"`
Name string `json:"name"`
Image string `json:"image"`
Product string `json:"product"`
Url string `json:"url"`
Keywords []string `json:"keywords"`
}
// CompanyInstanceInfo 公司信息
CompanyInstanceInfo struct {
CompanyBasicInfo
Industrys []string `json:"industrys"`
Directions []string `json:"directions"`
Introduce string `json:"introduce"`
}
// CompanyProductInfo 公司产品信息
CompanyProductInfo struct {
*model.ManageCompanyProduct
ID string `json:"id"`
Industrys []string `json:"industrys"`
Keywords []string `json:"keywords"`
}
)
// Instance 公司企业信息
func (c *Company) Instance(id uint64) (*CompanyInstanceInfo, error) {
mManageCompany := model.NewManageCompany()
mManageCompany.ID = id
if isExist, err := model2.First(mManageCompany.ManageCompany); err != nil {
return nil, err
} else if !isExist {
return nil, errors.New("操作错误，公司信息不存在或已被删除")
}
return &CompanyInstanceInfo{
CompanyBasicInfo: CompanyBasicInfo{
ID: mManageCompany.GetEncodeID(), Kind: mManageCompany.Kind, Name: mManageCompany.Name,
Image: mManageCompany.Image.Analysis(config2.SettingInfo.Domain),
Url: mManageCompany.Url,
Keywords: mManageCompany.GetKeywordAttribute(),
},
Industrys: mManageCompany.GetIndustryAttribute(),
Directions: mManageCompany.GetDirectionAttribute(),
Introduce: mManageCompany.Introduce,
}, nil
}
// Product 产品信息
func (c *Company) Product(id uint64, page, pageSize int) (*controller.ReturnPages, error) {
mManageCompany := model.NewManageCompany()
var count int64
out, err := mManageCompany.Product(id, c.UID, page, pageSize, &count)
if err != nil {
return nil, err
}
list := make([]*CompanyProductInfo, 0)
for _, v := range out {
list = append(list, &CompanyProductInfo{
ManageCompanyProduct: v,
ID: v.GetEncodeID(),
Industrys: v.GetIndustryAttribute(),
Keywords: v.GetKeywordAttribute(),
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
}
func NewCompany() CompanyHandle {
return func(session *session.Enterprise) *Company {
return &Company{session}
}
}

34
app/api/website/controller/manage/search.go
View File

@ -5,6 +5,7 @@ import (
"SciencesServer/app/basic/config"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
config2 "SciencesServer/config"
"errors"
)
@ -27,6 +28,7 @@ var searchIdentityHandle = map[int]func(ids []uint64) (interface{}, error){
config.TenantUserIdentityForAgent: company,
}
// company 公司信息
func company(ids []uint64) (interface{}, error) {
mManageCompany := model.NewManageCompany()
out := make([]*model2.ManageCompany, 0)
@ -39,7 +41,17 @@ func company(ids []uint64) (interface{}, error) {
}); err != nil {
return nil, err
}
return out, nil
list := make([]*CompanyBasicInfo, 0)
for _, v := range out {
list = append(list, &CompanyBasicInfo{
ID: v.GetEncodeID(), Kind: v.Kind, Name: v.Name,
Image: v.Image.Analysis(config2.SettingInfo.Domain),
Url: v.Url,
Keywords: v.GetKeywordAttribute(),
})
}
return list, nil
}
func expert(ids []uint64) (interface{}, error) {
@ -87,20 +99,24 @@ func laboratory(ids []uint64) (interface{}, error) {
return out, nil
}
func (c *Search) Launch(identity int, params string) (interface{}, error) {
manage := service.NewManage()
_params := map[string]interface{}{
"title": params, "keyword": params, "research": params,
}
data, err := manage.Search(1, 1, _params)
func (c *Search) Launch(identity int, param, industry string, page, pageSize int) (interface{}, error) {
manage := service.NewESManage(
service.WithManageIdentity(identity),
service.WithManageTitle(param),
service.WithManageIndustry(industry),
service.WithManageKeyword(param),
service.WithManageResearch(param),
)
out, err := manage.Search(page, pageSize)
if err != nil {
return nil, err
} else if out == nil {
return nil, nil
}
ids := make([]uint64, 0)
for _, v := range data.([]*service.Manage) {
for _, v := range out.([]*service.ESManage) {
if v.Identity != identity {
continue
}

45
app/api/website/model/manage_company.go
View File

@ -1,11 +1,54 @@
package model
import "SciencesServer/app/common/model"
import (
"SciencesServer/app/common/model"
"SciencesServer/serve/orm"
"fmt"
)
type ManageCompany struct {
*model.ManageCompany
}
// ManageCompanyProduct 产品信息
type ManageCompanyProduct struct {
*model.TechnologyProduct
VisitCount int `json:"visit_count"`
IsCollect uint64 `json:"is_collect"`
CollectCount int `json:"collect_count"`
}
// Product 产品信息
func (m *ManageCompany) Product(id, uid uint64, page, pageSize int, count *int64) ([]*ManageCompanyProduct, error) {
mTechnologyProductCollect := model.NewTechnologyProductCollect()
db := orm.GetDB().Table(model.NewUserCompany().TableName()+" u_c").
Select("p.id", "p.title", "p.image", "p.industry", "p.maturity", "p.lead_standard", "p.cooperation_mode",
"p.keyword", "v.count AS visit_count", "IFNULL(c_u.id, 0) AS is_collect", "c.count AS collect_count").
Joins(fmt.Sprintf("LEFT JOIN %s AS p ON u_c.uid = p.uid AND p.shelf_status = %d AND p.status = %d AND p.is_deleted = %d",
model.NewTechnologyProduct().TableName(), model.ShelfStatusForUp, model.TechnologyProductStatusForAgree, model.DeleteStatusForNot)).
Joins(fmt.Sprintf("LEFT JOIN (SELECT product_id, SUM(count) AS count FROM %s WHERE is_deleted = %d GROUP BY product_id) AS v ON p.id = v.product_id",
model.NewTechnologyProductVisit().TableName(), model.DeleteStatusForNot)).
Joins(fmt.Sprintf("LEFT JOIN (SELECT product_id, COUNT(count) AS count FROM %s WHERE is_deleted = %d GROUP BY product_id) AS c ON p.id = c.product_id",
mTechnologyProductCollect.TableName(), model.DeleteStatusForNot)).
Joins(fmt.Sprintf("LEFT JOIN %s AS c_u ON p.id = c_u.product_id AND c_u.uid = %d AND c_u.is_deleted = %d",
mTechnologyProductCollect.TableName(), uid, model.DeleteStatusForNot)).
Joins(fmt.Sprintf("")).
Where("u_c.company_id = ?", id).
Where("u_c.invalid_status = ?", model.InvalidStatusForNot).
Where("u_c.is_deleted = ?", model.DeleteStatusForNot)
out := make([]*ManageCompanyProduct, 0)
if err := db.Count(count).Error; err != nil {
return nil, err
}
if err := db.Order("p.id " + model.OrderModeToDesc).Offset((page - 1) * pageSize).Limit(pageSize).Scan(&out).Error; err != nil {
return nil, err
}
return out, nil
}
func NewManageCompany() *ManageCompany {
return &ManageCompany{model.NewManageCompany()}
}