opms_backend/opms_parent/app/handler/opsdev/operation.go

package opsdev

import (
	"context"

	"dashoo.cn/common_definition/comm_def"
	"dashoo.cn/opms_libary/myerrors"
	opsdevmodel "dasho
	opsdevmodel "dashoo.cn/opms_parent/app/model/opsdev"
	"dashoo.cn/opms_libary/myerrors"

	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gvalid"
)

type OperationHandler struct{}

func (h *OperationHandler) GetList(ctx context.Context, req *opsdevmodel.OpsOperationEventSearchReq, rsp *comm_def.CommonMsg) error {
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	total, list, err := srv.GetList(req)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list, "total": total}
	return nil
}

func (h *OperationHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	detail, err := srv.GetEntityById(req)
	if err != nil {
		return err
	}
	rsp.Data = detail
	return nil
}

func (h *OperationHandler) Create(ctx context.Context, req *opsdevmodel.OpsOperationEventReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	if err := srv.Create(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "创建成功"}
	return nil
}

func (h *OperationHandler) UpdateById(ctx context.Context, req *opsdevmodel.UpdateOpsOperationEventReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	if err := srv.UpdateById(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "更新成功"}
	return nil
}

func (h *OperationHandler) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
	if len(req.Ids) == 0 {
		return myerrors.ValidError("参数有误!")
	}
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	if err := srv.DeleteByIds(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "删除成功"}
	return nil
}

func (h *OperationHandler) Process(ctx context.Context, req *opsdevmodel.OpsOperationEventProcessReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	if err := srv.Process(ctx, req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "处理成功"}
	return nil
}

func (h *OperationHandler) GetRecords(ctx context.Context, req *opsdevmodel.OpsOperationEventRecordSearchReq, rsp *comm_def.CommonMsg) error {
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	total, list, err := srv.GetRecords(req)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list, "total": total}
	return nil
}

func (h *OperationHandler) UploadAttachment(ctx context.Context, req *opsdevmodel.OpsOperationEventAttachmentReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	attachment, err := srv.UploadAttachment(req)
	if err != nil {
		return err
	}
	rsp.Data = attachment
	return nil
}

func (h *OperationHandler) GetAttachments(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	list, err := srv.GetAttachments(int(req.Id))
	if err != nil {
		return err
	}
	rsp.Data = list
	return nil
}

func (h *OperationHandler) GetStats(ctx context.Context, req *comm_def.CommonMsg, rsp *comm_def.CommonMsg) error {
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	stats, err := srv.GetStats()
	if err != nil {
		return err
	}
	rsp.Data = stats
	return nil
}

func (h *OperationHandler) GetKanbanData(ctx context.Context, req *opsdevmodel.OpsOperationEventKanbanSearchReq, rsp *comm_def.CommonMsg) error {
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	result, err := srv.GetKanbanData(req)
	if err != nil {
		return err
	}
	rsp.Data = result
	return nil
}

func (h *OperationHandler) AssignOpsUser(ctx context.Context, req *opsdevmodel.AssignOpsUserReq, rsp *comm_def.CommonMsg) error {
	if req.Id <= 0 {
		return myerrors.ValidError("事件ID不能为空")
	}
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	if err := srv.AssignOpsUser(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "分配成功"}
	return nil
}

func (h *OperationHandler) AddRecord(ctx context.Context, req *opsdevmodel.AddRecordReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	if err := srv.AddRecord(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "添加成功"}
	return nil
}

func (h *OperationHandler) DeleteAttachment(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
	if req.Id <= 0 {
		return myerrors.ValidError("参数有误!")
	}
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	if err := srv.DeleteAttachment(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "删除成功"}
	return nil
}

func (h *OperationHandler) GetHistoryList(ctx context.Context, req *opsdevmodel.OpsOperationEventHistorySearchReq, rsp *comm_def.CommonMsg) error {
	srv, err := opsdevSrv.NewOperationService(ctx)
	if err != nil {
		return err
	}
	total, list, err := srv.GetHistoryList(req)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list, "total": total}
	return nil
}
}