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

package technology

import (
	"SciencesServer/app/api/enterprise/model"
	"SciencesServer/app/basic/config"
	"SciencesServer/app/basic/controller"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/app/session"
	"SciencesServer/serve/orm"
	"errors"
	"gorm.io/gorm"
	"strings"
)

// Patent 专利管理
type Patent struct {
	*session.Enterprise
	tenantID uint64
}

type PatentHandle func(session *session.Enterprise, tenantID uint64) *Patent

type (
	// PatentInfo 专利信息
	PatentInfo struct {
		ID string `json:"id"`
		*model.TechnologyPatentExpertInfo
	}
	// PatentMatchInfo 专利匹配信息
	PatentMatchInfo struct {
		ID          string                      `json:"id"`
		Kind        model2.TechnologyPatentKind `json:"kind"`
		Title       string                      `json:"title"`
		Description string                      `json:"description"`
		ApplyAt     string                      `json:"apply_at"`
	}
	// PatentDetailInfo 专利详细信息
	PatentDetailInfo struct {
		ID string `json:"id"`
		*model2.TechnologyPatent
	}
	// PatentParams 专利参数信息
	PatentParams struct {
		ID             uint64
		Kind           int
		Title, FileUrl string
		ApplyCode, ApplyName, ApplyAddress, ApplyAt,
		OpenCode, OpenAt string
		Inventor, IPCCode, Description, PrincipalClaim string
		Status                                         int
	}
)

// add 新增专利信息
func (c *PatentParams) add(tenantID, uid uint64) error {
	mTechnologyPatent := model.NewTechnologyPatent()

	isExist, err := mTechnologyPatent.IsExistParams(map[string]interface{}{
		"apply_code": c.ApplyCode, "open_code": c.OpenCode,
	})
	if err != nil {
		return err
	} else if isExist {
		return errors.New("操作错误，申请号或公开（公告）号已存在")
	}
	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		mTechnologyPatent.Kind = model2.TechnologyPatentKind(c.Kind)
		mTechnologyPatent.Title = c.Title
		mTechnologyPatent.FileUrl = c.FileUrl
		mTechnologyPatent.ApplyCode = c.ApplyCode
		mTechnologyPatent.ApplyAt = c.ApplyAt
		mTechnologyPatent.OpenCode = c.OpenCode
		mTechnologyPatent.OpenAt = c.OpenAt
		mTechnologyPatent.ApplyName = c.ApplyName
		mTechnologyPatent.ApplyAddress = c.ApplyAddress
		mTechnologyPatent.Inventor = c.Inventor
		mTechnologyPatent.Description = c.Description
		mTechnologyPatent.PrincipalClaim = c.PrincipalClaim
		mTechnologyPatent.IPCCode = c.IPCCode
		mTechnologyPatent.Status = model2.TechnologyPatentStatus(c.Status)

		if err = model2.Create(mTechnologyPatent.TechnologyPatent, tx); err != nil {
			return err
		}
		// 查询当前的专家信息
		mUserExpert := model.NewUserExpert()

		if isExist, err = model2.LastWhere(mUserExpert.UserExpert, []string{"id", "expert_id"}, model2.NewWhere("uid", uid),
			model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，无专家信息")
		}
		mTechnologyPatentExpert := model.NewTechnologyPatentExpert()
		mTechnologyPatentExpert.ExpertID = mUserExpert.ExpertID
		mTechnologyPatentExpert.PatentID = mTechnologyPatent.ID

		if err = model2.Create(mTechnologyPatentExpert.TechnologyPatentExpert, tx); err != nil {
			return err
		}

		manage := service.NewESPatent(
			service.WithPatentID(mTechnologyPatent.ID),
			service.WithPatentTitle(mTechnologyPatent.Title),
		)
		// 查询分类信息
		mTechnologyPatentClassify := model.NewTechnologyPatentClassify()

		isExist, err = model2.FirstField(mTechnologyPatentClassify.TechnologyPatentClassify, []string{"id", "ipc", "industry_detail"},
			model2.NewWhere("ipc", c.IPCCode))

		if err != nil {
			return err
		} else if isExist {
			_industrys := make([]string, 0)

			for _, v := range mTechnologyPatentClassify.GetIndustryDetailAttribute() {
				_industrys = append(_industrys, config.GetIndustryInfo(v, "-", "-").Value)
			}
			service.WithPatentIndustry(strings.Join(_industrys, "；"))(manage)
		}
		return manage.Create()
	})
}

// edit 删除专利信息
func (c *PatentParams) edit(uid uint64) error {
	mTechnologyPatentExpert := model.NewTechnologyPatentExpert()
	mTechnologyPatentExpert.ID = c.ID

	isExist, err := model2.FirstField(mTechnologyPatentExpert.TechnologyPatentExpert, []string{"id", "expert_id", "patent_id"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，用户专利信息不存在或已被删除")
	}
	// 查询当前用户是否存在对应的专家信息
	mUserExpert := model.NewUserExpert()

	var count int64

	if err = model2.Count(mUserExpert.UserExpert, &count, model2.NewWhere("uid", uid),
		model2.NewWhere("expert_id", mTechnologyPatentExpert.ExpertID),
		model2.NewWhere("invalid_status", model2.InvalidStatusForNot),
	); err != nil {
		return err
	} else if count > 0 {
		return errors.New("操作错误，无权限操作")
	}
	mTechnologyPatent := model.NewTechnologyPatent()
	mTechnologyPatent.ID = mTechnologyPatentExpert.PatentID

	if isExist, err = model2.FirstField(mTechnologyPatent.TechnologyPatent, []string{"id", "apply_code", "open_code", "created_at"}); err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，专利信息不存在或已被删除")
	}
	_condition := make(map[string]interface{}, 0)

	if mTechnologyPatent.ApplyCode != c.ApplyCode {
		_condition["apply_code"] = c.ApplyCode
	}
	if mTechnologyPatent.OpenCode != c.OpenCode {
		_condition["open_code"] = c.OpenCode
	}
	if len(_condition) > 0 {
		if isExist, err = mTechnologyPatent.IsExistParams(_condition); err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，申请号或公开（公告）号已存在")
		}
	}
	mTechnologyPatent.Kind = model2.TechnologyPatentKind(c.Kind)
	mTechnologyPatent.Title = c.Title
	mTechnologyPatent.FileUrl = c.FileUrl
	mTechnologyPatent.ApplyCode = c.ApplyCode
	mTechnologyPatent.ApplyAt = c.ApplyAt
	mTechnologyPatent.OpenCode = c.OpenCode
	mTechnologyPatent.OpenAt = c.OpenAt
	mTechnologyPatent.ApplyName = c.ApplyName
	mTechnologyPatent.ApplyAddress = c.ApplyAddress
	mTechnologyPatent.Inventor = c.Inventor
	mTechnologyPatent.Description = c.Description
	mTechnologyPatent.PrincipalClaim = c.PrincipalClaim
	mTechnologyPatent.IPCCode = c.IPCCode
	mTechnologyPatent.Status = model2.TechnologyPatentStatus(c.Status)

	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = model2.Updates(mTechnologyPatent.TechnologyPatent, mTechnologyPatent.TechnologyPatent, tx); err != nil {
			return err
		}
		manage := service.NewESPatent(
			service.WithPatentID(mTechnologyPatent.ID),
			service.WithPatentTitle(mTechnologyPatent.Title),
		)
		return manage.Update()
	})
}

// List 列表信息
func (c *Patent) List(kind int, title, applyCode, openCode, ipcCode string, page, pageSize int) (*controller.ReturnPages, error) {
	// 查询当前用户对应的专家信息
	mUserExpert := model.NewUserExpert()

	isExist, err := model2.LastWhere(mUserExpert.UserExpert, []string{"id", "expert_id"},
		model2.NewWhere("uid", c.UID),
		model2.NewWhere("invalid_status", model2.InvalidStatusForNot),
	)
	if err != nil {
		return nil, err
	} else if !isExist {
		return nil, nil
	}
	mTechnologyPatentExpert := model.NewTechnologyPatentExpert()

	where := []*model2.ModelWhere{model2.NewWhere("u.expert_id", mUserExpert.ExpertID)}

	if kind <= 0 {
		where = append(where, model2.NewWhere("p.kind", kind))
	}
	if title != "" {
		where = append(where, model2.NewWhereLike("p.title", title))
	}
	if applyCode != "" {
		where = append(where, model2.NewWhereLike("p.apply_code", applyCode))
	}
	if openCode != "" {
		where = append(where, model2.NewWhereLike("p.open_code", openCode))
	}
	if ipcCode != "" {
		where = append(where, model2.NewWhereLike("p.ipc_code", ipcCode))
	}
	var count int64

	out := make([]*model.TechnologyPatentExpertInfo, 0)

	if out, err = mTechnologyPatentExpert.Patent(page, pageSize, &count, where...); err != nil {
		return nil, err
	}
	list := make([]*PatentInfo, 0)

	for _, v := range out {
		list = append(list, &PatentInfo{
			ID: v.GetEncodeID(), TechnologyPatentExpertInfo: v,
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

// Match 搜索信息
func (c *Patent) Match(title string, industrys, keywords []string) (*controller.ReturnPages, error) {
	params := strings.Join([]string{
		title, strings.Join(industrys, ","), strings.Join(keywords, ","),
	}, ",")
	patent := service.NewESPatent(
		service.WithPatentTitle(params),
		service.WithPatentIndustry(params),
	)
	out, count, err := patent.Search(0, 0)

	if err != nil {
		return nil, err
	}
	ids := make([]uint64, 0)

	for _, v := range out.([]interface{}) {
		val := v.(*service.ESAchievement)
		ids = append(ids, val.ID)
	}
	mTechnologyPatent := model.NewTechnologyPatent()

	patents := make([]*model2.TechnologyPatent, 0)

	if err = model2.ScanFields(mTechnologyPatent.TechnologyPatent, &patents, []string{"id", "kind", "title", "description", "apply_at"}, &model2.ModelWhereOrder{
		Where: model2.NewWhereIn("id", ids),
		Order: model2.NewOrder("id", model2.OrderModeToDesc),
	}); err != nil {
		return nil, err
	}
	list := make([]*PatentMatchInfo, 0)

	for _, v := range patents {
		list = append(list, &PatentMatchInfo{
			ID: v.GetEncodeID(), Title: v.Title, Description: v.Description, ApplyAt: v.ApplyAt,
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, 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 (c *Patent) Form(params *PatentParams) error {
	if params.ID > 0 {
		return params.edit(c.UID)
	}
	return params.add(c.tenantID, c.UID)

}

// Delete 删除操作
func (c *Patent) Delete(id uint64) error {
	mTechnologyPatentExpert := model.NewTechnologyPatentExpert()
	mTechnologyPatentExpert.ID = id

	isExist, err := model2.FirstField(mTechnologyPatentExpert.TechnologyPatentExpert, []string{"id", "patent_id"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，用户专利信息不存在或已被删除")
	}
	// 只删除关联关系
	if err = model2.Delete(mTechnologyPatentExpert.TechnologyPatentExpert); err != nil {
		return err
	}
	//mTechnologyPatent := model.NewTechnologyPatent()
	//mTechnologyPatent.ID = mUserPatent.PatentID
	//
	//if isExist, err := model2.FirstField(mTechnologyPatent.TechnologyPatent, []string{"id"}); err != nil {
	//	return err
	//} else if !isExist {
	//	return errors.New("操作错误，专利信息不存在或已被删除")
	//}
	//if err = model2.Delete(mTechnologyPatent.TechnologyPatent); err != nil {
	//	return err
	//}
	//manage := service.NewESPatent(
	//	service.WithPatentID(mTechnologyPatent.ID),
	//)
	//return manage.Delete()
	return nil
}

func NewPatent() PatentHandle {
	return func(session *session.Enterprise, tenantID uint64) *Patent {
		return &Patent{Enterprise: session, tenantID: tenantID}
	}
}