rts-sim-testing-service/api/trainManage.go

package api

// 列车相关的关系管理
import (
	"net/http"
	"strconv"

	jwt "github.com/appleboy/gin-jwt/v2"
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
	"joylink.club/bj-rtsts-server/dto"
	"joylink.club/bj-rtsts-server/service"
)

func InitTrainManageRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	authed := api.Group("/v1/trainManage").Use(authMiddleware.MiddlewareFunc())
	authed.GET("/model/paging", pageQueryTrainModel)
	authed.GET("/model/list", queryTrainModelList)
	authed.POST("/model", createTrainModel)
	authed.GET("/model/:id", queryTrainModel)
	authed.PUT("/model/:id", updateTrainModel)
	authed.DELETE("/model/:id", deleteTrainModel)
	authed.GET("/size/paging", pageQueryTrainSize)
	authed.GET("/size/list", queryTrainSizeList)
	authed.POST("/size", createTrainSize)
	authed.GET("/size/:id", queryTrainSize)
	authed.PUT("/size/:id", updateTrainSize)
	authed.DELETE("/size/:id", deleteTrainSize)
	authed.GET("/wheelDiameter/paging", pageQueryTrainWheelDiameter)
	authed.GET("/wheelDiameter/list", queryTrainWheelDiameterList)
	authed.POST("/wheelDiameter", createTrainWheelDiameter)
	authed.GET("/wheelDiameter/:id", queryTrainWheelDiameter)
	authed.PUT("/wheelDiameter/:id", updateTrainWheelDiameter)
	authed.DELETE("/wheelDiameter/:id", deleteTrainWheelDiameter)
}

// 分页查询列车型号列表
//
//	@Summary		分页查询列车型号信息列表
//
//	@Security		JwtAuth
//
//	@Description	可以通过列车型号名称过滤，分页查询列车型号信息列表
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			pageTrainManageReqDto	query		dto.PageTrainManageReqDto	true	"列车型号查询条件带分页信息"
//	@Success		200	{object}	dto.PageDto
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/model/paging [get]
func pageQueryTrainModel(c *gin.Context) {
	req := dto.PageTrainManageReqDto{}
	if err := c.ShouldBind(&req); err != nil {
		zap.S().Warn("分页查询参数绑定错误，使用默认参数", err)
		req.Default()
	}
	zap.S().Debug("分页查列车信号参数", req)
	page, err := service.PageTrainModelQuery(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, page)
}

// 创建列车型号
//
//	@Summary		创建列车型号
//
//	@Security		JwtAuth
//
//	@Description	创建列车型号数据
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			trainModelDto	query	dto.TrainModelDto	true	"创建的列车型号信息"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/model [post]
func createTrainModel(c *gin.Context) {
	req := dto.TrainModelDto{}
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, "传入参数错误")
		return
	}
	zap.S().Debug("保存数据", req)
	data, err := service.CreateTrainModel(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, data)
}

// 查询列车型号详情
//
//	@Summary		查询列车型号详情
//
//	@Security		JwtAuth
//
//	@Description	查询列车型号详情
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车型号ID"
//	@Success		200	{object}    model.TrainModel
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/model/{id} [get]
func queryTrainModel(c *gin.Context) {
	id, exist := c.Params.Get("id")
	if !exist {
		c.JSON(http.StatusBadRequest, "必要参数id不存在")
		return
	}
	zap.S().Debug("传入参数id为" + id)
	int64Id, _ := strconv.ParseInt(id, 10, 64)
	c.JSON(http.StatusOK, service.QueryTrainModel(int32(int64Id)))
}

// 修改列车型号信息
//
//	@Summary		修改列车型号信息
//
//	@Security		JwtAuth
//
//	@Description	修改列车型号信息
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车型号ID"
//	@Param			trainModelDto	query	dto.TrainModelDto	true	"修改的列车型号信息"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/model/{id} [put]
func updateTrainModel(c *gin.Context) {
	id, exist := c.Params.Get("id")
	if !exist {
		c.JSON(http.StatusBadRequest, "必要参数id不存在")
		return
	}
	zap.S().Debug("传入参数id为" + id)
	req := dto.TrainModelDto{}
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, "保存参数出错")
		return
	}
	int64Id, _ := strconv.ParseInt(id, 10, 64)
	result := service.UpdateTrainModel(int32(int64Id), &req)
	if !result {
		c.JSON(http.StatusInternalServerError, "保存参数出错")
		return
	}
	c.JSON(http.StatusOK, result)
}

// 删除列车型号数据
//
//	@Summary		删除列车型号数据
//
//	@Security		JwtAuth
//
//	@Description	删除列车型号数据
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车型号ID"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/model/{id} [delete]
func deleteTrainModel(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, "id参数解析错误")
		return
	}
	zap.S().Debug("id查询列车型号的图形数据", id)
	service.DeleteTrainModelById(id)
	c.JSON(http.StatusOK, true)
}

// 查询列车型号列表
//
//	@Summary		查询列车型号信息列表
//
//	@Security		JwtAuth
//
//	@Description	可以通过列车型号名称过滤，查询列车型号信息列表
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			trainManageReqDto	query		dto.TrainManageReqDto	true	"列车型号查询条件"
//	@Success		200	{object}	dto.PageDto
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/model/list [get]
func queryTrainModelList(c *gin.Context) {
	req := dto.TrainManageReqDto{}
	if err := c.ShouldBind(&req); err != nil {
		zap.S().Warn("查询参数绑定错误，使用默认参数", err)
	}
	zap.S().Debug("分页查列车信号参数", req)
	models, err := service.ListTrainModelQuery(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, models)
}

// 分页查询列车尺寸列表
//
//	@Summary		分页查询列车尺寸信息列表
//
//	@Security		JwtAuth
//
//	@Description	可以通过列车尺寸名称过滤，分页查询列车尺寸信息列表
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			pageTrainManageReqDto	query		dto.PageTrainManageReqDto	true	"列车尺寸查询条件带分页信息"
//	@Success		200	{object}	dto.PageDto
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/size/paging [get]
func pageQueryTrainSize(c *gin.Context) {
	req := dto.PageTrainManageReqDto{}
	if err := c.ShouldBind(&req); err != nil {
		zap.S().Warn("分页查询参数绑定错误，使用默认参数", err)
		req.Default()
	}
	zap.S().Debug("分页查列车尺寸参数", req)
	page, err := service.PageTrainSizeQuery(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, page)
}

// 查询列车尺寸列表
//
//	@Summary		查询列车尺寸信息列表
//
//	@Security		JwtAuth
//
//	@Description	可以通过列车尺寸名称过滤，查询列车尺寸信息列表
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			trainManageReqDto	query		dto.TrainManageReqDto	true	"列车尺寸查询条件"
//	@Success		200	{object}	dto.PageDto
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/size/list [get]
func queryTrainSizeList(c *gin.Context) {
	req := dto.TrainManageReqDto{}
	if err := c.ShouldBind(&req); err != nil {
		zap.S().Warn("查询参数绑定错误，使用默认参数", err)
	}
	zap.S().Debug("分页查列车尺寸参数", req)
	sizeList, err := service.ListTrainSizeQuery(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, sizeList)
}

// 创建列车尺寸
//
//	@Summary		创建列车尺寸
//
//	@Security		JwtAuth
//
//	@Description	创建列车尺寸数据
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			trainSizeDto	query	dto.TrainSizeDto	true	"创建的列车尺寸信息"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/size [post]
func createTrainSize(c *gin.Context) {
	req := dto.TrainSizeDto{}
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, "传入参数错误")
		return
	}
	zap.S().Debug("保存数据", req)
	data, err := service.CreateTrainSize(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, data)
}

// 查询列车尺寸详情
//
//	@Summary		查询列车尺寸详情
//
//	@Security		JwtAuth
//
//	@Description	查询列车尺寸详情
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车尺寸ID"
//	@Success		200	{object}    model.TrainSize
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/size/{id} [get]
func queryTrainSize(c *gin.Context) {
	id, exist := c.Params.Get("id")
	if !exist {
		c.JSON(http.StatusBadRequest, "必要参数id不存在")
		return
	}
	zap.S().Debug("传入参数id为" + id)
	int64Id, _ := strconv.ParseInt(id, 10, 64)
	c.JSON(http.StatusOK, service.QueryTrainSize(int32(int64Id)))
}

// 修改列车尺寸信息
//
//	@Summary		修改列车尺寸信息
//
//	@Security		JwtAuth
//
//	@Description	修改列车尺寸信息
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车尺寸ID"
//	@Param			trainSizeDto	query	dto.TrainSizeDto	true	"修改的列车尺寸信息"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/size/{id} [put]
func updateTrainSize(c *gin.Context) {
	id, exist := c.Params.Get("id")
	if !exist {
		c.JSON(http.StatusBadRequest, "必要参数id不存在")
		return
	}
	zap.S().Debug("传入参数id为" + id)
	req := dto.TrainSizeDto{}
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, "保存参数出错")
		return
	}
	int64Id, _ := strconv.ParseInt(id, 10, 64)
	result := service.UpdateTrainSize(int32(int64Id), &req)
	if !result {
		c.JSON(http.StatusInternalServerError, "保存参数出错")
		return
	}
	c.JSON(http.StatusOK, result)
}

// 删除列车尺寸数据
//
//	@Summary		删除列车尺寸数据
//
//	@Security		JwtAuth
//
//	@Description	删除列车尺寸数据
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车尺寸ID"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/size/{id} [delete]
func deleteTrainSize(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, "id参数解析错误")
		return
	}
	zap.S().Debug("id查询列车型号的图形数据", id)
	service.DeleteTrainSizeById(id)
	c.JSON(http.StatusOK, true)
}

// 分页查询列车轮径列表
//
//	@Summary		分页查询列车轮径信息列表
//
//	@Security		JwtAuth
//
//	@Description	可以通过列车轮径名称过滤，分页查询列车轮径信息列表
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			pageTrainManageReqDto	query		dto.PageTrainManageReqDto	true	"列车轮径查询条件带分页信息"
//	@Success		200	{object}	dto.PageDto
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/wheelDiameter/paging [get]
func pageQueryTrainWheelDiameter(c *gin.Context) {
	req := dto.PageTrainManageReqDto{}
	if err := c.ShouldBind(&req); err != nil {
		zap.S().Warn("分页查询参数绑定错误，使用默认参数", err)
		req.Default()
	}
	zap.S().Debug("分页查列车轮径参数", req)
	page, err := service.PageTrainWheelDiameterQuery(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, page)
}

// 查询列车轮径列表
//
//	@Summary		查询列车轮径信息列表
//
//	@Security		JwtAuth
//
//	@Description	可以通过列车轮径名称过滤，查询列车轮径信息列表
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			pageTrainManageReqDto	query		dto.PageTrainManageReqDto	true	"列车轮径查询条件"
//	@Success		200	{object}	dto.PageDto
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/wheelDiameter/list [get]
func queryTrainWheelDiameterList(c *gin.Context) {
	req := dto.TrainManageReqDto{}
	if err := c.ShouldBind(&req); err != nil {
		zap.S().Warn("查询参数绑定错误，使用默认参数", err)
	}
	zap.S().Debug("分页查列车轮径参数", req)
	wheels, err := service.ListTrainWheelDiameterQuery(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, wheels)
}

// 创建列车轮径
//
//	@Summary		创建列车轮径
//
//	@Security		JwtAuth
//
//	@Description	创建列车轮径数据
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			trainWheelDiameterDto	query	dto.TrainWheelDiameterDto	true	"创建的列车轮径信息"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/wheelDiameter [post]
func createTrainWheelDiameter(c *gin.Context) {
	req := dto.TrainWheelDiameterDto{}
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, "传入参数错误")
		return
	}
	zap.S().Debug("保存数据", req)
	data, err := service.CreateTrainWheelDiameter(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	c.JSON(http.StatusOK, data)
}

// 查询列车轮径详情
//
//	@Summary		查询列车轮径详情
//
//	@Security		JwtAuth
//
//	@Description	查询列车轮径详情
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车轮径ID"
//	@Success		200	{object}    model.TrainWheelDiameter
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/wheelDiameter/{id} [get]
func queryTrainWheelDiameter(c *gin.Context) {
	id, exist := c.Params.Get("id")
	if !exist {
		c.JSON(http.StatusBadRequest, "必要参数id不存在")
		return
	}
	zap.S().Debug("传入参数id为" + id)
	int64Id, _ := strconv.ParseInt(id, 10, 64)
	c.JSON(http.StatusOK, service.QueryTrainWheelDiameter(int32(int64Id)))
}

// 修改列车轮径信息
//
//	@Summary		修改列车轮径信息
//
//	@Security		JwtAuth
//
//	@Description	修改列车轮径信息
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车轮径ID"
//	@Param			trainWheelDiameterDto	query	dto.TrainWheelDiameterDto	true	"修改的列车轮径信息"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/wheelDiameter/{id} [put]
func updateTrainWheelDiameter(c *gin.Context) {
	id, exist := c.Params.Get("id")
	if !exist {
		c.JSON(http.StatusBadRequest, "必要参数id不存在")
		return
	}
	zap.S().Debug("传入参数id为" + id)
	req := dto.TrainWheelDiameterDto{}
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, "保存参数出错")
		return
	}
	int64Id, _ := strconv.ParseInt(id, 10, 64)
	result := service.UpdateTrainWheelDiameter(int32(int64Id), &req)
	if !result {
		c.JSON(http.StatusInternalServerError, "保存参数出错")
		return
	}
	c.JSON(http.StatusOK, result)
}

// 删除列车轮径数据
//
//	@Summary		删除列车轮径数据
//
//	@Security		JwtAuth
//
//	@Description	删除列车轮径数据
//	@Tags			列车管理Api
//	@Accept			json
//	@Produce		json
//	@Param			id	path		int	true	"列车轮径ID"
//	@Success		200	{object}	nil
//	@Failure		401	{object}	dto.ErrorDto
//	@Failure		404	{object}	dto.ErrorDto
//	@Failure		500	{object}	dto.ErrorDto
//	@Router			/api/v1/trainManage/wheelDiameter/{id} [delete]
func deleteTrainWheelDiameter(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, "id参数解析错误")
		return
	}
	zap.S().Debug("id查询列车型号的图形数据", id)
	service.DeleteTrainWheelDiameterById(id)
	c.JSON(http.StatusOK, true)
}