298 lines
9.4 KiB
Go
298 lines
9.4 KiB
Go
package service
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
|
|
"joylink.club/bj-rtsts-server/db/dbquery"
|
|
"joylink.club/bj-rtsts-server/db/model"
|
|
"joylink.club/bj-rtsts-server/dto"
|
|
"joylink.club/bj-rtsts-server/sys_error"
|
|
)
|
|
|
|
var publishMapMutex sync.Mutex
|
|
|
|
// 查找发布地图分页信息
|
|
func PageQueryPublished(req *dto.PagePublishedReqDto) *dto.PageDto {
|
|
p, pv, u := dbquery.Published, dbquery.PublishedVersion, dbquery.User
|
|
where := p.
|
|
Select(
|
|
p.ID, p.Code.As("name"), p.Type, p.Category, p.Status,
|
|
pv.Note, pv.PublishAt, pv.Version, u.Name.As("publisher"),
|
|
).
|
|
LeftJoin(pv, p.DataID.EqCol(pv.ID)).
|
|
LeftJoin(u, pv.UserID.EqCol(u.ID)).
|
|
Order(p.Status.Desc(), pv.PublishAt.Desc())
|
|
if req.Name != "" {
|
|
where = where.Where(p.Code.Like(fmt.Sprintf("%%%s%%", req.Name)))
|
|
}
|
|
if req.Release {
|
|
where = where.Where(p.Status.Eq(1))
|
|
}
|
|
var records []*dto.PublishedDto
|
|
count, err := where.Debug().ScanByPage(&records, req.Offset(), req.Size)
|
|
if err != nil {
|
|
panic(sys_error.New("查询发布地图信息失败", err))
|
|
}
|
|
return &dto.PageDto{Total: int(count), PageQueryDto: req.PageQueryDto, Records: records}
|
|
}
|
|
|
|
// 地图信息列表信息
|
|
func ListQueryPublished(req *dto.PublishedListReqDto) []*dto.PublishedDto {
|
|
p := dbquery.Published
|
|
where := p.Select(p.ID, p.Code.As("name"), p.Type, p.Category).Where(p.Status.Eq(1))
|
|
if req.Name != "" {
|
|
where = where.Where(dbquery.Published.Code.Like(fmt.Sprintf("%%%s%%", req.Name)))
|
|
}
|
|
if req.Type != 0 {
|
|
where = where.Where(dbquery.Published.Type.Eq(req.Type))
|
|
}
|
|
if req.Category != "" {
|
|
where = where.Where(dbquery.Published.Category.Eq(req.Category))
|
|
}
|
|
var records []*dto.PublishedDto
|
|
err := where.Debug().Scan(&records)
|
|
if err != nil {
|
|
panic(sys_error.New("查询发布地图信息失败", err))
|
|
}
|
|
return records
|
|
}
|
|
|
|
// 项目启动时查询发布地图信息
|
|
func ListAllPublished() []*dto.PublishedDto {
|
|
p, pv := dbquery.Published, dbquery.PublishedVersion
|
|
where := p.Select(p.ID, p.Code.As("name"), p.Type, p.Category, pv.Proto, pv.Version).
|
|
LeftJoin(pv, p.DataID.EqCol(pv.ID)).
|
|
Where(p.Status.Eq(1), p.Type.Neq(trainDataType)).Order(pv.PublishAt)
|
|
var records []*dto.PublishedDto
|
|
err := where.Debug().Scan(&records)
|
|
if err != nil {
|
|
panic(sys_error.New("查询发布地图信息失败", err))
|
|
}
|
|
return records
|
|
}
|
|
|
|
// 查询详细信息
|
|
func GetPublishedById(id int32) *dto.PublishedDto {
|
|
p, pv := dbquery.Published, dbquery.PublishedVersion
|
|
where := p.Select(p.ID, p.Code.As("name"), p.Type, p.Category, pv.Proto, pv.Version).
|
|
LeftJoin(pv, p.DataID.EqCol(pv.ID)).
|
|
Where(p.ID.Eq(id), p.Status.Eq(1))
|
|
var record dto.PublishedDto
|
|
err := where.Debug().Scan(&record)
|
|
if err != nil {
|
|
panic(sys_error.New("查询发布地图信息失败", err))
|
|
}
|
|
return &record
|
|
}
|
|
|
|
// 草稿发布
|
|
func PublishFormDraft(req *dto.PublishReqDto, user *model.User) int32 {
|
|
draft := QueryDrafting(req.DraftId)
|
|
if draft.Proto == nil || len(draft.Proto) == 0 {
|
|
panic(sys_error.New(fmt.Sprintf("草稿[%v]绘图数据信息为空", req.DraftId)))
|
|
}
|
|
return publishData(&dto.PublishedDto{
|
|
Name: req.Name,
|
|
Proto: draft.Proto,
|
|
Type: draft.Type,
|
|
Category: draft.Category,
|
|
UserID: user.ID,
|
|
Note: req.Note,
|
|
}, req.Force)
|
|
}
|
|
|
|
// 发布数据
|
|
func publishData(publishData *dto.PublishedDto, force bool) int32 {
|
|
publishMapMutex.Lock()
|
|
defer publishMapMutex.Unlock()
|
|
p, pv := dbquery.Published, dbquery.PublishedVersion
|
|
// 查询发布图数据
|
|
oldPs, err1 := p.Where(p.Code.Eq(publishData.Name)).Find()
|
|
if err1 != nil {
|
|
panic(sys_error.New("发布草稿数据失败", err1))
|
|
}
|
|
var pid, version int32 = 0, 1
|
|
if len(oldPs) > 0 { // 发布图数据不为空
|
|
pid = oldPs[0].ID
|
|
if oldPs[0].Category != publishData.Category || publishData.Type != oldPs[0].Type {
|
|
if !force { // 非强制覆盖
|
|
panic(sys_error.New("草稿数据与在线数据类型不一致"))
|
|
} else {
|
|
p.Where(p.ID.Eq(pid)).UpdateColumns(&model.Published{ID: pid, Type: publishData.Type, Category: publishData.Category})
|
|
}
|
|
}
|
|
vds, _ := pv.Select(pv.Version).Where(pv.PublishID.Eq(pid)).Order(pv.Version.Desc()).Find()
|
|
if len(vds) > 0 { // 版本号 + 1
|
|
version = version + vds[0].Version
|
|
}
|
|
}
|
|
// 存入新版本数据
|
|
pvd := &model.PublishedVersion{
|
|
Code: publishData.Name,
|
|
Proto: publishData.Proto,
|
|
UserID: publishData.UserID,
|
|
Note: publishData.Note,
|
|
Type: publishData.Type,
|
|
Category: publishData.Category,
|
|
PublishAt: time.Now(),
|
|
Version: version,
|
|
PublishID: pid,
|
|
}
|
|
err2 := pv.Create(pvd)
|
|
if err2 != nil {
|
|
panic(sys_error.New("发布草稿数据失败", err2))
|
|
}
|
|
// 更新发布数据
|
|
if pid == 0 {
|
|
pd := &model.Published{
|
|
Code: publishData.Name,
|
|
Type: publishData.Type,
|
|
Category: publishData.Category,
|
|
DataID: pvd.ID,
|
|
Status: 1,
|
|
}
|
|
// 保存发布信息
|
|
err4 := p.Create(pd)
|
|
if err4 != nil {
|
|
panic(sys_error.New("发布草稿数据失败", err4))
|
|
}
|
|
pid = pd.ID
|
|
// 更新发布版本信息
|
|
pv.Where(pv.ID.Eq(pvd.ID)).UpdateColumn(pv.PublishID, pd.ID)
|
|
} else {
|
|
// 更新发布信息
|
|
p.Where(p.ID.Eq(pid)).UpdateColumn(p.DataID, pvd.ID)
|
|
}
|
|
return pid
|
|
}
|
|
|
|
// 删除发布数据
|
|
func DeletePublishedById(id int32) {
|
|
dbquery.Published.Where(dbquery.Published.ID.Eq(id)).Delete()
|
|
dbquery.PublishedVersion.Where(dbquery.PublishedVersion.PublishID.Eq(id)).Delete()
|
|
dbquery.ProjectPublishLink.Where(dbquery.ProjectPublishLink.Mid.In(id)).Delete()
|
|
}
|
|
|
|
// SaveAsDraftingFromPublish 另存为草稿
|
|
func SaveAsDraftingFromPublish(id int32, user *model.User, req dto.PublishToDraftReqDto) *sys_error.BusinessError {
|
|
num, _ := dbquery.Drafting.Where(dbquery.Drafting.Name.Eq(req.DraftName)).Count()
|
|
if num > 0 { // 处理重名情况
|
|
return sys_error.New(fmt.Sprintf("草稿【%s】已存在", req.DraftName))
|
|
}
|
|
p, pv := dbquery.Published, dbquery.PublishedVersion
|
|
where := p.Select(p.Type, p.Category, pv.Proto).LeftJoin(pv, p.DataID.EqCol(pv.ID)).Where(p.ID.Eq(id))
|
|
var record dto.PublishedDto
|
|
err := where.Debug().Scan(&record)
|
|
if err != nil {
|
|
panic(sys_error.New("查询发布地图信息失败", err))
|
|
}
|
|
err1 := dbquery.Drafting.Save(&model.Drafting{
|
|
Name: req.DraftName,
|
|
Category: req.Category,
|
|
Proto: record.Proto,
|
|
CreatorID: user.ID,
|
|
CreatedAt: time.Now(),
|
|
UpdateAt: time.Now(),
|
|
Type: record.Type,
|
|
})
|
|
if err1 != nil {
|
|
return sys_error.New("保存草稿出错", err1)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 查询项目关联的详细数据
|
|
func QueryProjectPublished(id int32) []*model.Published {
|
|
// 获取项目关联的发布地图
|
|
dppl, p := dbquery.ProjectPublishLink, dbquery.Published
|
|
var publisheds []*model.Published
|
|
err := dppl.Select(p.ID, p.Code, p.Category, p.Type).
|
|
LeftJoin(p, p.ID.EqCol(dppl.Mid)).
|
|
Where(dppl.Pid.Eq(id), p.Status.Eq(1)).Debug().Order(p.Type, p.Code).Scan(&publisheds)
|
|
if err != nil {
|
|
panic(sys_error.New("发布草稿数据失败", err))
|
|
}
|
|
return publisheds
|
|
}
|
|
|
|
// 根据名称获取地图详细信息
|
|
func GetPublishedGiByName(param *dto.PublishedSingleQueryDto) *dto.PublishedDto {
|
|
p, pv := dbquery.Published, dbquery.PublishedVersion
|
|
where := p.Select(p.ID, p.Code.As("name"), p.Type, p.Category, pv.Proto).
|
|
LeftJoin(pv, p.DataID.EqCol(pv.ID)).
|
|
Where(p.Code.Eq(param.Name), p.Status.Eq(1))
|
|
var record dto.PublishedDto
|
|
err := where.Debug().Scan(&record)
|
|
if err != nil {
|
|
panic(sys_error.New("查询发布地图信息失败", err))
|
|
}
|
|
return &record
|
|
}
|
|
|
|
// 修改发布数据状态
|
|
func ChangePublishStatus(id int32, release bool) {
|
|
var status int
|
|
if release {
|
|
status = 1
|
|
}
|
|
dbquery.Published.Debug().Where(dbquery.Published.ID.Eq(id)).UpdateColumn(dbquery.Published.Status, status)
|
|
if !release { // 下架时，删除关联关系
|
|
dbquery.ProjectPublishLink.Where(dbquery.ProjectPublishLink.Mid.In(id)).Delete()
|
|
}
|
|
}
|
|
|
|
// 修改发布Code
|
|
func ChangePublishCode(id int32, code string) {
|
|
p := dbquery.Published
|
|
count, err := p.Where(p.ID.Neq(id), p.Code.Eq(code)).Count()
|
|
if err != nil {
|
|
panic(sys_error.New("修改发布名称失败", err))
|
|
}
|
|
if count > 0 {
|
|
panic(sys_error.New("修改名称失败：名称已存在"))
|
|
}
|
|
p.Debug().Where(dbquery.Published.ID.Eq(id)).UpdateColumn(dbquery.Published.Code, code)
|
|
}
|
|
|
|
// 查询发布历史
|
|
func GetPublishHistory(id int32) []*dto.PublishHistoryDto {
|
|
u, p, pv := dbquery.User, dbquery.Published, dbquery.PublishedVersion
|
|
pd, err1 := p.Select(p.ID, p.DataID).Where(p.ID.Eq(id)).First()
|
|
if err1 != nil {
|
|
panic(sys_error.New(fmt.Sprintf("地图【%d】不存在", id)))
|
|
}
|
|
var records []*dto.PublishHistoryDto
|
|
err := pv.
|
|
Select(pv.ID, pv.PublishAt, pv.Note, pv.Version, u.Name.As("publisher"), pv.ID.Eq(pd.DataID).As("current")).
|
|
LeftJoin(u, u.ID.EqCol(pv.UserID)).
|
|
Where(pv.PublishID.Eq(id)).Order(pv.Version.Desc()).Scan(&records)
|
|
if err != nil {
|
|
panic(sys_error.New("查询发布历史信息失败", err))
|
|
}
|
|
return records
|
|
}
|
|
|
|
// 回退发布版本
|
|
func FallBackPublishHistory(mapId, versionId int32) (bool, error) {
|
|
p, pv := dbquery.Published, dbquery.PublishedVersion
|
|
pd, err := p.Select(p.ID, p.DataID).Where(p.ID.Eq(mapId)).First()
|
|
if err != nil {
|
|
return false, fmt.Errorf("地图【%d】不存在", mapId)
|
|
}
|
|
pvd, err := pv.Select(pv.ID, pv.PublishID).Where(pv.ID.Eq(versionId)).First()
|
|
if err != nil {
|
|
return false, fmt.Errorf("地图【%d】版本【%d】数据不存在", mapId, versionId)
|
|
}
|
|
if pvd.PublishID != pd.ID {
|
|
return false, fmt.Errorf("地图【%d】版本【%d】数据不匹配", mapId, versionId)
|
|
}
|
|
if pd.DataID == pvd.ID {
|
|
return false, nil
|
|
}
|
|
// 更新版本数据
|
|
p.Where(p.ID.Eq(mapId)).UpdateColumn(p.DataID, versionId)
|
|
return true, nil
|
|
}
|