cas_tt_cloud_backend/app/api/website/controller/technology/patent.go

package technology

import (
	"SciencesServer/app/api/website/model"
	"SciencesServer/app/basic/controller"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"errors"
)

type Patent struct{}

type PatentHandle func() *Patent

type (
	// PatentInfo 专利信息
	PatentInfo struct {
		ID string `json:"id"`
		*model.TechnologyPatentInfo
	}
	// PatentDetailInfo 专利详细信息
	PatentDetailInfo struct {
		ID string `json:"id"`
		*model2.TechnologyPatent
	}
)

// Instance 查询信息
func (c *Patent) Instance(title, industry string, page, pageSize int) (*controller.ReturnPages, error) {
	// TODO：缺少会员判断标准
	// ES标准判定
	manage := service.NewESPatent()

	if title != "" {
		service.WithPatentTitle(title)(manage)
	}
	if industry != "" {
		service.WithPatentIndustry(industry)(manage)
	}
	out, count1, err := manage.Search(page, pageSize)

	list := make([]*PatentInfo, 0)

	var count int64

	if err != nil {
		return nil, err
	} else if out == nil {
		return &controller.ReturnPages{Data: list, Count: count}, nil
	}
	mTechnologyPatent := model.NewTechnologyPatent()

	ids := make([]uint64, 0)

	for _, v := range out.([]interface{}) {
		val := v.(*service.ESPatent)
		ids = append(ids, val.ID)
	}
	ret := make([]*model.TechnologyPatentInfo, 0)

	if ret, err = mTechnologyPatent.Patents(page, pageSize, &count, model2.NewWhereIn("p.id", ids)); err != nil {
		return nil, err
	}
	for _, v := range ret {
		list = append(list, &PatentInfo{
			ID:                   v.GetEncodeID(),
			TechnologyPatentInfo: v,
		})
	}
	return &controller.ReturnPages{Data: list, Count: count1}, nil
}

// Detail 详细信息
func (c *Patent) Detail(id uint64) (*PatentDetailInfo, error) {
	mTechnologyPatent := model.NewTechnologyPatent()
	mTechnologyPatent.ID = id

	isExist, err := model2.First(mTechnologyPatent.TechnologyPatent)

	if err != nil {
		return nil, err
	} else if !isExist {
		return nil, errors.New("操作错误，专利信息不存在或已被删除")
	}
	return &PatentDetailInfo{ID: mTechnologyPatent.GetEncodeID(), TechnologyPatent: mTechnologyPatent.TechnologyPatent}, nil
}

func NewPatent() PatentHandle {
	return func() *Patent {
		return &Patent{}
	}
}