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-18 16:29:29 +08:00
parent 478182dcb0
commit 10224e8db6
21 changed files with 572 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
app/api/admin/controller/sys/industry.go
View File

@ -79,7 +79,7 @@ func (c *Industry) Form(params *IndustryParams) error {
// Delete 删除操作
func (c *Industry) Delete(id uint64) error {
mSysIndustry := new(model.SysIndustry)
mSysIndustry := model.NewSysIndustry()
mSysIndustry.ID = id
isExist, err := model2.FirstField(mSysIndustry.SysIndustry, []string{"id"})

2
app/api/enterprise/controller/technology/demand.go
View File

@ -128,6 +128,8 @@ func (c *Demand) Form(params *DemandParams) error {
mTechnologyDemand.Name = params.Name
mTechnologyDemand.Mobile = params.Mobile
mTechnologyDemand.Introduce = params.Introduce
// TODO：用户公司模式
mTechnologyDemand.Mode = params.Introduce
mTechnologyDemand.SetKindAttribute(params.Kinds)
mTechnologyDemand.SetIndustryAttribute(params.Industry)
mTechnologyDemand.Budget = params.Budget

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

@ -23,19 +23,20 @@ func (*ES) Create(c *gin.Context) {
api.APIFailure(err.(error))(c)
return
}
//manage := service.NewESManage(
// service.WithManageID(form.ID),
// service.WithManageIdentity(form.Identity),
// service.WithManageTitle(form.Title),
// service.WithManageKeyword(form.Keyword),
// service.WithManageResearch(form.Research),
//)
manage := service.NewESPatent(
service.WithPatentID(form.ID),
//service.WithManageIdentity(form.Identity),
service.WithPatentTitle(form.Title),
service.WithPatentIndustry(form.Industry),
manage := service.NewESManage(
service.WithManageID(form.ID),
service.WithManageIdentity(form.Identity),
service.WithManageIndustry(form.Industry),
service.WithManageTitle(form.Title),
service.WithManageKeyword(form.Keyword),
service.WithManageResearch(form.Research),
)
//manage := service.NewESPatent(
// service.WithPatentID(form.ID),
// //service.WithManageIdentity(form.Identity),
// service.WithPatentTitle(form.Title),
// service.WithPatentIndustry(form.Industry),
//)
api.APIResponse(manage.Create())(c)
}
@ -49,16 +50,16 @@ func (*ES) Search(c *gin.Context) {
api.APIFailure(err.(error))(c)
return
}
//manage := service.NewESManage(service.WithManageIdentity(form.Identity),
// service.WithManageTitle(form.Param),
// service.WithManageIndustry(form.Industry),
// service.WithManageKeyword(form.Param),
// service.WithManageResearch(form.Param))
manage := service.NewESPatent(
service.WithPatentTitle(form.Param),
service.WithPatentIndustry(form.Industry),
)
data, err := manage.Search(1, 10)
manage := service.NewESManage(service.WithManageIdentity(form.Identity),
service.WithManageTitle(form.Param),
service.WithManageIndustry(form.Industry),
service.WithManageKeyword(form.Param),
service.WithManageResearch(form.Param))
//manage := service.NewESPatent(
// service.WithPatentTitle(form.Param),
// service.WithPatentIndustry(form.Industry),
//)
data, err := manage.Search(1, 10, nil)
for _, v := range data.([]interface{}) {
fmt.Println(reflect.TypeOf(v).String())

11
app/api/website/api/search.go
View File

@ -1,7 +1,7 @@
package api
import (
"SciencesServer/app/api/website/controller"
"SciencesServer/app/api/website/controller/search"
"SciencesServer/app/basic/api"
"github.com/gin-gonic/gin"
)
@ -10,15 +10,16 @@ type Search struct{}
func (*Search) Launch(c *gin.Context) {
form := &struct {
Mode int `json:"mode" form:"mode" binding:"required"`
Keyword string `json:"keyword" form:"keyword" binding:"required"`
Industry string `json:"industry" form:"industry"`
Mode int `json:"mode" form:"mode" binding:"required"`
Keyword string `json:"keyword" form:"keyword" binding:"required"`
Industry string `json:"industry" form:"industry"`
Params map[string]interface{} `json:"params" form:"params"`
api.PageForm
}{}
if err := api.Bind(form)(c); err != nil {
api.APIFailure(err.(error))(c)
return
}
data, err := controller.NewSearch()().Launch(form.Mode, form.Keyword, form.Industry, form.Page, form.PageSize)
data, err := search.NewInstance()().Launch(form.Mode, form.Keyword, form.Industry, form.Params, form.Page, form.PageSize)
api.APIResponse(err, data)(c)
}

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

@ -57,7 +57,7 @@ func achievement(uids []uint64, page, pageSize int) (*controller.ReturnPages, er
var count int64
out, err := mTechnologyAchievement.Achievement(page, pageSize, &count, model2.NewWhereIn("uid", uids))
out, err := mTechnologyAchievement.Achievements(page, pageSize, &count, model2.NewWhereIn("uid", uids))
if err != nil {
return nil, err

59
app/api/website/controller/search.go
View File

@ -1,59 +0,0 @@
package controller
import (
"SciencesServer/app/basic/config"
"SciencesServer/app/service"
"errors"
)
type Search struct{}
type SearchHandle func() *Search
var searchHandle = map[int]func(int, int, string, string) (interface{}, error){
1: searchCompany,
}
// searchCompany 公司搜索
func searchCompany(page, pageSize int, keyword, industry string) (interface{}, error) {
manage := service.NewESManage(
service.WithManageIdentity(config.TenantUserIdentityForCompany),
service.WithManageTitle(keyword),
service.WithManageKeyword(keyword),
service.WithManageResearch(keyword),
)
if industry != "" {
manage.Industry = industry
}
out, err := manage.Search(page, pageSize, nil)
if err != nil {
return nil, err
}
ids := make([]uint64, 0)
for _, v := range out.([]interface{}) {
val := v.(*service.ESManage)
ids = append(ids, val.ID)
}
if len(ids) <= 0 {
return nil, nil
}
return nil, nil
}
// Launch 发起搜索
func (c *Search) Launch(mode int, keyword, industry string, page, pageSize int) (interface{}, error) {
handle, has := searchHandle[mode]
if !has {
return nil, errors.New("操作错误，未知的搜索模式")
}
return handle(page, pageSize, keyword, industry)
}
func NewSearch() SearchHandle {
return func() *Search {
return &Search{}
}
}

69
app/api/website/controller/search/achievement.go Normal file
View File

@ -0,0 +1,69 @@
package search
import (
"SciencesServer/app/api/website/model"
"SciencesServer/app/basic/config"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
config2 "SciencesServer/config"
)
type (
AchievementInfo struct {
ID string `json:"id"`
*model.TechnologyAchievementInfo
Customers []string `json:"customers"`
Industrys []string `json:"industrys"`
Keywords []string `json:"keywords"`
}
)
func achievementSearch(page, pageSize int, keyword, industry string, params map[string]interface{}) (interface{}, error) {
manage := service.NewESAchievement(
service.WithAchievementTitle(keyword),
service.WithAchievementKeyword(keyword),
)
if industry != "" {
service.WithAchievementIndustry(keyword)(manage)
}
out, err := manage.Search(page, pageSize)
if err != nil {
return nil, err
}
ids := make([]uint64, 0)
for _, v := range out.([]interface{}) {
val := v.(*service.ESAchievement)
ids = append(ids, val.ID)
}
if len(ids) <= 0 {
return nil, nil
}
mTechnologyAchievement := model.NewTechnologyAchievement()
achievements := make([]*model.TechnologyAchievementInfo, 0)
if achievements, err = mTechnologyAchievement.Achievement(model2.NewWhereIn("a.id", ids)); err != nil {
return nil, err
}
list := make([]*AchievementInfo, 0)
for _, v := range achievements {
_industrys := make([]string, 0)
for _, v := range v.GetIndustryAttribute() {
_industrys = append(_industrys, config.GetIndustryInfo(v, "-", "/"))
}
v.Image.Image = v.Image.Analysis(config2.SystemConfig[config2.SysImageDomain])
list = append(list, &AchievementInfo{
ID: v.GetEncodeID(), TechnologyAchievementInfo: v,
Customers: v.GetCustomerAttribute(),
Industrys: _industrys, Keywords: v.GetKeywordAttribute(),
})
}
return list, nil
}

72
app/api/website/controller/search/company.go Normal file
View File

@ -0,0 +1,72 @@
package search
import (
"SciencesServer/app/api/website/model"
"SciencesServer/app/basic/config"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
config2 "SciencesServer/config"
)
type (
CompanyInfo 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"`
Industrys []string `json:"industrys"`
Keywords []string `json:"keywords"`
}
)
// searchCompany 公司搜索
func searchCompany(page, pageSize int, keyword, industry string, params map[string]interface{}) (interface{}, error) {
manage := service.NewESManage(
service.WithManageIdentity(config.TenantUserIdentityForCompany),
service.WithManageTitle(keyword),
service.WithManageKeyword(keyword),
service.WithManageResearch(keyword),
)
if industry != "" {
service.WithManageIndustry(industry)(manage)
}
out, err := manage.Search(page, pageSize, nil)
if err != nil {
return nil, err
}
ids := make([]uint64, 0)
for _, v := range out.([]interface{}) {
val := v.(*service.ESManage)
ids = append(ids, val.ID)
}
if len(ids) <= 0 {
return nil, nil
}
mManageCompany := model.NewManageCompany()
companys := make([]*model2.ManageCompany, 0)
if err = model2.ScanFields(mManageCompany.ManageCompany, &companys, []string{"id", "name", "kind", "image", "product",
"industry", "keyword", "url"}, &model2.ModelWhereOrder{Where: model2.NewWhereIn("id", ids)}); err != nil {
return nil, err
}
list := make([]*CompanyInfo, 0)
for _, v := range companys {
_industrys := make([]string, 0)
for _, v := range v.GetIndustryAttribute() {
_industrys = append(_industrys, config.GetIndustryInfo(v, "-", "/"))
}
list = append(list, &CompanyInfo{
ID: v.GetEncodeID(), Kind: v.Kind, Name: v.Name,
Image: v.Image.Analysis(config2.SystemConfig[config2.SysImageDomain]),
Product: v.Product, Industrys: _industrys, Keywords: v.GetKeywordAttribute(),
})
}
return list, nil
}

74
app/api/website/controller/search/demand.go Normal file
View File

@ -0,0 +1,74 @@
package search
import (
"SciencesServer/app/api/website/model"
model2 "SciencesServer/app/common/model"
"fmt"
"time"
)
type (
// DemandInfo 需求信息
DemandInfo struct {
ID string `json:"id"`
Title string `json:"title"`
Mode string `json:"mode"`
Kind string `json:"kind"`
Industrys []string `json:"industrys"`
Budget float64 `json:"budget"`
BudgetMode model2.TechnologyDemandBudgetMode `json:"budget_mode"`
Deadline time.Time `json:"deadline"`
}
)
// searchDemand 需求搜索
func searchDemand(page, pageSize int, keyword, industry string, params map[string]interface{}) (interface{}, error) {
mTechnologyDemand := model.NewTechnologyDemand()
out := make([]*model2.TechnologyDemand, 0)
where := []*model2.ModelWhereOrder{
&model2.ModelWhereOrder{
Where: model2.NewWhere("status", model2.TechnologyDemandStatusForAgree),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
},
}
if keyword != "" {
where = append(where, &model2.ModelWhereOrder{
Where: model2.NewWhereLike("title", keyword),
})
}
if industry != "" {
where = append(where, &model2.ModelWhereOrder{Where: model2.NewWhereCondition("industry", "LIKE",
"%"+fmt.Sprintf(`"%v`, industry)+"%")})
}
if len(params) > 0 {
for k, v := range params {
where = append(where, &model2.ModelWhereOrder{
Where: model2.NewWhere(k, v),
})
}
}
var count int64
if err := model2.PagesFields(mTechnologyDemand.TechnologyDemand, &out, []string{"id", "title", "mode", "kind", "industry",
"budget", "budget_mode", "deadline"}, page, pageSize, &count, where...); err != nil {
return nil, err
}
list := make([]*DemandInfo, 0)
for _, v := range out {
list = append(list, &DemandInfo{
ID: v.GetEncodeID(), Title: v.Title,
Mode: v.Mode,
Kind: v.Kind,
Industrys: v.GetIndustryAttribute(),
Budget: v.Budget,
BudgetMode: v.BudgetMode,
Deadline: v.Deadline,
})
}
return list, nil
}

70
app/api/website/controller/search/expert.go Normal file
View File

@ -0,0 +1,70 @@
package search
import (
"SciencesServer/app/api/website/model"
"SciencesServer/app/basic/config"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
config2 "SciencesServer/config"
)
type (
// ExpertInfo 专家信息
ExpertInfo struct {
ID string `json:"id"`
*model.ManageExpertInfo
Industrys []string `json:"industrys"`
Keywords []string `json:"keywords"`
}
)
// searchExpert 专家搜索
func searchExpert(page, pageSize int, keyword, industry string, params map[string]interface{}) (interface{}, error) {
manage := service.NewESManage(
service.WithManageIdentity(config.TenantUserIdentityForExpert),
service.WithManageTitle(keyword),
service.WithManageKeyword(keyword),
service.WithManageResearch(keyword),
)
if industry != "" {
service.WithManageIndustry(industry)(manage)
}
out, err := manage.Search(page, pageSize, nil)
if err != nil {
return nil, err
}
ids := make([]uint64, 0)
for _, v := range out.([]interface{}) {
val := v.(*service.ESManage)
ids = append(ids, val.ID)
}
if len(ids) <= 0 {
return nil, nil
}
mManageExpert := model.NewManageExpert()
experts := make([]*model.ManageExpertInfo, 0)
if experts, err = mManageExpert.Expert(3, model2.NewWhereIn("e.id", ids)); err != nil {
return nil, err
}
list := make([]*ExpertInfo, 0)
for _, v := range experts {
_industrys := make([]string, 0)
for _, v := range v.GetIndustryAttribute() {
_industrys = append(_industrys, config.GetIndustryInfo(v, "-", "/"))
}
v.Image.Image = v.Image.Analysis(config2.SystemConfig[config2.SysImageDomain])
list = append(list, &ExpertInfo{
ID: v.GetEncodeID(), ManageExpertInfo: v,
Industrys: _industrys, Keywords: v.GetKeywordAttribute(),
})
}
return list, nil
}

30
app/api/website/controller/search/instance.go Normal file
View File

@ -0,0 +1,30 @@
package search
import (
"errors"
)
type Instance struct{}
type InstanceHandle func() *Instance
var instanceHandle = map[int]func(int, int, string, string, map[string]interface{}) (interface{}, error){
1: searchCompany, 2: achievementSearch, 3: searchLaboratory,
4: searchPatent, 5: searchExpert, 6: searchDemand,
}
// Launch 发起搜索
func (c *Instance) Launch(mode int, keyword, industry string, params map[string]interface{}, page, pageSize int) (interface{}, error) {
handle, has := instanceHandle[mode]
if !has {
return nil, errors.New("操作错误，未知的搜索模式")
}
return handle(page, pageSize, keyword, industry, params)
}
func NewInstance() InstanceHandle {
return func() *Instance {
return &Instance{}
}
}

70
app/api/website/controller/search/laboratory.go Normal file
View File

@ -0,0 +1,70 @@
package search
import (
"SciencesServer/app/api/website/model"
"SciencesServer/app/basic/config"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
config2 "SciencesServer/config"
)
type (
// LaboratoryInfo 实验室信息
LaboratoryInfo struct {
ID string `json:"id"`
*model.ManageLaboratoryInfo
Industrys []string `json:"industrys"`
Keywords []string `json:"keywords"`
}
)
// searchLaboratory 实验室搜索
func searchLaboratory(page, pageSize int, keyword, industry string, params map[string]interface{}) (interface{}, error) {
manage := service.NewESManage(
service.WithManageIdentity(config.TenantUserIdentityForLaboratory),
service.WithManageTitle(keyword),
service.WithManageKeyword(keyword),
service.WithManageResearch(keyword),
)
if industry != "" {
service.WithManageIndustry(industry)(manage)
}
out, err := manage.Search(page, pageSize, nil)
if err != nil {
return nil, err
}
ids := make([]uint64, 0)
for _, v := range out.([]interface{}) {
val := v.(*service.ESAchievement)
ids = append(ids, val.ID)
}
if len(ids) <= 0 {
return nil, nil
}
mManageLaboratory := model.NewManageLaboratory()
laboratorys := make([]*model.ManageLaboratoryInfo, 0)
if laboratorys, err = mManageLaboratory.Laboratory(model2.NewWhereIn("l.id", ids)); err != nil {
return nil, err
}
list := make([]*LaboratoryInfo, 0)
for _, v := range laboratorys {
_industrys := make([]string, 0)
for _, v := range v.GetIndustryAttribute() {
_industrys = append(_industrys, config.GetIndustryInfo(v, "-", "/"))
}
v.Image.Image = v.Image.Analysis(config2.SystemConfig[config2.SysImageDomain])
list = append(list, &LaboratoryInfo{
ID: v.GetEncodeID(), ManageLaboratoryInfo: v,
Industrys: _industrys, Keywords: v.GetKeywordAttribute(),
})
}
return list, nil
}

59
app/api/website/controller/search/patent.go Normal file
View File

@ -0,0 +1,59 @@
package search
import (
"SciencesServer/app/api/website/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
)
type (
// PatentInfo 专利信息
PatentInfo struct {
ID string `json:"id"`
Kind model2.SysParentKind `json:"kind"`
Title string `json:"title"`
ApplyAt string `json:"apply_at"`
Description string `json:"description"`
}
)
// searchPatent 专利搜索
func searchPatent(page, pageSize int, keyword, industry string, params map[string]interface{}) (interface{}, error) {
manage := service.NewESPatent(
service.WithPatentTitle(keyword),
)
if industry != "" {
service.WithPatentIndustry(industry)(manage)
}
out, err := manage.Search(page, pageSize)
if err != nil {
return nil, err
}
ids := make([]uint64, 0)
for _, v := range out.([]interface{}) {
val := v.(*service.ESPatent)
ids = append(ids, val.ID)
}
if len(ids) <= 0 {
return nil, nil
}
mSysPatent := model.NewSysPatent()
patents := make([]*model2.SysPatent, 0)
if err = model2.ScanFields(mSysPatent.SysPatent, &patents, []string{"id", "kind", "title", "apply_at", "description"},
&model2.ModelWhereOrder{Where: model2.NewWhereIn("id", ids)}); err != nil {
return nil, err
}
list := make([]*PatentInfo, 0)
for _, v := range patents {
list = append(list, &PatentInfo{
ID: v.GetEncodeID(), Kind: v.Kind, Title: v.Title, ApplyAt: v.ApplyAt, Description: v.Description,
})
}
return list, nil
}

2
app/api/website/controller/technology/achievement.go
View File

@ -54,7 +54,7 @@ func (c *Achievement) Instance(title, industry string, page, pageSize int) (*con
}
var count int64
out, err := mTechnologyAchievement.Achievement(page, pageSize, &count, where...)
out, err := mTechnologyAchievement.Achievements(page, pageSize, &count, where...)
if err != nil {
return nil, err

2
app/api/website/controller/technology/patent.go
View File

@ -57,7 +57,7 @@ func (c *Patent) Instance(title, industry string, page, pageSize int) (*controll
}
ret := make([]*model.SysPatentInfo, 0)
if ret, err = mSysPatent.Patent(page, pageSize, &count, model2.NewWhereIn("p.id", ids)); err != nil {
if ret, err = mSysPatent.Patents(page, pageSize, &count, model2.NewWhereIn("p.id", ids)); err != nil {
return nil, err
}
for _, v := range ret {

4
app/api/website/model/sys_patent.go
View File

@ -40,8 +40,8 @@ func (m *SysPatent) Instance(where ...*model.ModelWhere) ([]*SysPatentInfo, erro
return out, nil
}
// Patent 专利信息
func (m *SysPatent) Patent(page, pageSize int, count *int64, where ...*model.ModelWhere) ([]*SysPatentInfo, error) {
// Patents 专利信息
func (m *SysPatent) Patents(page, pageSize int, count *int64, where ...*model.ModelWhere) ([]*SysPatentInfo, error) {
db := orm.GetDB().Table(m.TableName()+" AS p").
Select("p.id", "p.title", "LEFT(p.description, 80) AS description", "p.apply_at").
Joins(fmt.Sprintf("LEFT JOIN %s AS c ON p.ipc_code = c.ipc AND c.is_deleted = %d",

30
app/api/website/model/technology_achievement.go
View File

@ -17,8 +17,8 @@ type TechnologyAchievementInfo struct {
CollectCount int `json:"collect_count"`
}
// Achievement 成果信息
func (m *TechnologyAchievement) Achievement(page, pageSize int, count *int64, where ...*model.ModelWhere) ([]*TechnologyAchievementInfo, error) {
// Achievements 成果信息
func (m *TechnologyAchievement) Achievements(page, pageSize int, count *int64, where ...*model.ModelWhere) ([]*TechnologyAchievementInfo, error) {
db := orm.GetDB().Table(m.TableName()+" AS a").
Select("a.id", "a.title", "a.mode", "a.image", "a.charge_info", "a.industry", "a.customer", "a.maturity",
"a.cooperation_mode", "a.keyword", "v.count AS visit_count", "c.count AS collect_count").
@ -45,6 +45,32 @@ func (m *TechnologyAchievement) Achievement(page, pageSize int, count *int64, wh
return out, nil
}
// Achievement 成果信息
func (m *TechnologyAchievement) Achievement(where ...*model.ModelWhere) ([]*TechnologyAchievementInfo, error) {
db := orm.GetDB().Table(m.TableName()+" AS a").
Select("a.id", "a.title", "a.mode", "a.image", "a.charge_info", "a.industry", "a.customer", "a.maturity",
"a.cooperation_mode", "a.keyword", "v.count AS visit_count", "c.count AS collect_count").
Joins(fmt.Sprintf("LEFT JOIN (SELECT object_id, SUM(count) AS count FROM %s WHERE kind = %d AND is_deleted = %d GROUP BY object_id) AS v ON a.id = v.object_id",
model.NewUserVisit().TableName(), model.UserCollectKindForTechnologyAchievement, model.DeleteStatusForNot)).
Joins(fmt.Sprintf("LEFT JOIN (SELECT object_id, COUNT(id) AS count FROM %s WHERE kind = %d AND is_deleted = %d GROUP BY object_id) AS c ON a.id = c.object_id",
model.NewUserCollect().TableName(), model.UserCollectKindForTechnologyAchievement, model.DeleteStatusForNot)).
Where("a.status = ?", model.TechnologyAchievementStatusForAgree).
Where("a.is_deleted = ?", model.DeleteStatusForNot)
out := make([]*TechnologyAchievementInfo, 0)
if len(where) > 0 {
for _, v := range where {
db = db.Where(v.Condition, v.Value)
}
}
if err := db.Order("a.id " + model.OrderModeToDesc).Scan(&out).Error; err != nil {
return nil, err
}
return out, nil
}
// Detail 成果详细信息
func (m *TechnologyAchievement) Detail(id uint64) (*TechnologyAchievementInfo, error) {
db := orm.GetDB().Table(m.TableName()+" AS a").