From 7579200104d43468d3a7f501e63066cf8919f3d5 Mon Sep 17 00:00:00 2001 From: weizhihong Date: Tue, 22 Aug 2023 16:44:34 +0800 Subject: [PATCH] =?UTF-8?q?=E3=80=90=E5=88=97=E8=BD=A6=E5=9E=8B=E5=8F=B7?= =?UTF-8?q?=E7=AE=A1=E7=90=86=E3=80=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- api/category.go | 2 +- api/drafting.go | 2 +- api/simulation.go | 54 ++- api/trainModel.go | 179 ++++++++ .../wayside/memory/wayside_memory_generate.go | 42 +- db/dbquery/gen.go | 8 + db/dbquery/train_group.gen.go | 396 ++++++++++++++++++ db/dbquery/train_model.gen.go | 396 ++++++++++++++++++ db/model/train_group.gen.go | 25 ++ db/model/train_model.gen.go | 25 ++ dto/simulation.go | 4 + dto/trainModel.go | 16 + service/trainModel.go | 122 ++++++ 13 files changed, 1225 insertions(+), 46 deletions(-) create mode 100644 api/trainModel.go create mode 100644 db/dbquery/train_group.gen.go create mode 100644 db/dbquery/train_model.gen.go create mode 100644 db/model/train_group.gen.go create mode 100644 db/model/train_model.gen.go create mode 100644 dto/trainModel.go create mode 100644 service/trainModel.go diff --git a/api/category.go b/api/category.go index eff70e1..ebd4ec3 100644 --- a/api/category.go +++ b/api/category.go @@ -204,7 +204,7 @@ func deleteCategory(c *gin.Context) { id, err := strconv.Atoi(idStr) if err != nil { c.JSON(http.StatusBadRequest, "id参数解析错误") - panic("id参数解析错误") + return } zap.S().Debug("id查询草稿的图形数据", id) service.DeleteCategoryById(id) diff --git a/api/drafting.go b/api/drafting.go index ed1fc40..1f0ee6b 100644 --- a/api/drafting.go +++ b/api/drafting.go @@ -217,7 +217,7 @@ func deleteDrafting(c *gin.Context) { id, err := strconv.Atoi(idStr) if err != nil { c.JSON(http.StatusBadRequest, "id参数解析错误") - panic("id参数解析错误") + return } zap.S().Debug("id查询草稿的图形数据", id) service.DeleteDraftingById(id) diff --git a/api/simulation.go b/api/simulation.go index 61d3158..91c3bf5 100644 --- a/api/simulation.go +++ b/api/simulation.go @@ -183,34 +183,27 @@ func checkSimMapData(c *gin.Context) { // @Failure 500 {object} dto.ErrorDto // @Router /api/v1/simulation/train/add [post] func addTrain(c *gin.Context) { - //user,_:=c.Get(middleware.IdentityKey) req := dto.AddTrainReqDto{} if err := c.ShouldBind(&req); err != nil { panic(err) } zap.S().Debug("ATS测试仿真-添加列车,请求：", req) simulation := checkDeviceDataAndReturn(req.SimulationId) - trainMap := &simulation.Memory.Status.TrainStateMap - // 获取列车ID - i := 1 - for { - _, ok := trainMap.Load(strconv.Itoa(i)) - if ok { - i++ - } else { - break + id := getAddTrainPrimaryKey(simulation) + if id == -1 { + c.JSON(http.StatusBadRequest, "已存在在线列车") + } else { + rsp := &state.TrainState{ + Id: strconv.Itoa(id), + HeadDeviceId: req.Id, + HeadOffset: req.HeadOffset, + DevicePort: req.DevicePort, + RunDirection: req.RunDirection, + TrainLength: int64(service.CalcTrainLenght(req.TrainModelId, req.CarriageNum)), } + memory.AddTrainState(simulation, rsp) + c.JSON(http.StatusOK, &rsp) } - id := strconv.Itoa(i) - rsp := &state.TrainState{ - Id: id, - HeadDeviceId: req.Id, - HeadOffset: req.HeadOffset, - DevicePort: req.DevicePort, - RunDirection: req.RunDirection, - } - memory.AddTrainState(simulation, rsp) - c.JSON(http.StatusOK, &rsp) } // ATS测试仿真-移除列车 @@ -280,3 +273,24 @@ func checkDeviceDataAndReturn(simId string) *memory.VerifySimulation { } return deviceMemory } + +// 获取列车主键 +func getAddTrainPrimaryKey(simulation *memory.VerifySimulation) int { + trainMap := &simulation.Memory.Status.TrainStateMap + // 获取列车ID + i := 1 + for { + t, ok := trainMap.Load(strconv.Itoa(i)) + if ok { + ts := t.(*state.TrainState) + if ts.Show { + i = -1 + break + } + i++ + } else { + break + } + } + return i +} diff --git a/api/trainModel.go b/api/trainModel.go new file mode 100644 index 0000000..d698873 --- /dev/null +++ b/api/trainModel.go @@ -0,0 +1,179 @@ +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/middleware" + "joylink.club/bj-rtsts-server/service" +) + +func InitTrainModelRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) { + authed := api.Group("/v1/trainModel").Use(authMiddleware.MiddlewareFunc()) + authed.GET("/paging", pageQueryTrainModel) + authed.POST("", createTrainModel) + authed.GET("/:id", queryTrainModel) + authed.PUT("/:id", updateTrainModel) + authed.DELETE("/:id", deleteTrainModel) +} + +// 分页查询列车型号列表 +// +// @Summary 分页查询列车型号信息列表 +// +// @Security JwtAuth +// +// @Description 可以通过列车型号名称过滤，分页查询列车型号信息列表 +// @Tags 列车型号Api +// @Accept json +// @Produce json +// @Param pageTrainModelReqDto query dto.PageTrainModelReqDto true "列车型号查询条件带分页信息" +// @Success 200 {object} dto.PageDto +// @Failure 401 {object} dto.ErrorDto +// @Failure 404 {object} dto.ErrorDto +// @Failure 500 {object} dto.ErrorDto +// @Router /api/v1/trainModel/paging [get] +func pageQueryTrainModel(c *gin.Context) { + user, _ := c.Get(middleware.IdentityKey) + zap.S().Debug("分页查询列车组次", user) + req := dto.PageTrainModelReqDto{} + 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/trainModel [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/trainModel/: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/trainModel/: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/trainModel/: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) +} diff --git a/ats/verify/simulation/wayside/memory/wayside_memory_generate.go b/ats/verify/simulation/wayside/memory/wayside_memory_generate.go index f80b62b..e64c201 100644 --- a/ats/verify/simulation/wayside/memory/wayside_memory_generate.go +++ b/ats/verify/simulation/wayside/memory/wayside_memory_generate.go @@ -250,42 +250,36 @@ func getGraphicTurnoutRefDevices(refVal *graphicData.RelatedRef, deviceMap map[s } // 处理道岔上的应答器 transponders := turnout.transponders[refVal.DevicePort] - if transponders != nil { - for _, t := range transponders { - if judgeKilometerIsVaild(t.KilometerSystem) && deviceMap[t.Common.Id] == nil { - deviceMap[t.Common.Id] = &graphicData.CalculateLink_DevicePosition{ - DeviceId: t.Common.Id, - Offset: offset + int32(math.Abs(float64(t.KilometerSystem.Kilometer-prevKm))), - DeviceType: "Transponder", - } + for _, t := range transponders { + if judgeKilometerIsVaild(t.KilometerSystem) && deviceMap[t.Common.Id] == nil { + deviceMap[t.Common.Id] = &graphicData.CalculateLink_DevicePosition{ + DeviceId: t.Common.Id, + Offset: offset + int32(math.Abs(float64(t.KilometerSystem.Kilometer-prevKm))), + DeviceType: "Transponder", } } } // 坡度 sm := turnout.slopes[refVal.DevicePort] - if sm != nil { - for id, s := range sm { - if judgeKilometerIsVaild(s) && deviceMap[id] == nil { - deviceMap[id] = &graphicData.CalculateLink_DevicePosition{ - DeviceId: id, - Offset: offset + int32(math.Abs(float64(s.Kilometer-prevKm))), - DeviceType: "slopes", - } + for id, s := range sm { + if judgeKilometerIsVaild(s) && deviceMap[id] == nil { + deviceMap[id] = &graphicData.CalculateLink_DevicePosition{ + DeviceId: id, + Offset: offset + int32(math.Abs(float64(s.Kilometer-prevKm))), + DeviceType: "slopes", } } } // 曲度 cm := turnout.curvatures[refVal.DevicePort] - if cm != nil { - for id, c := range cm { - if judgeKilometerIsVaild(c) && deviceMap[id] == nil { - deviceMap[id] = &graphicData.CalculateLink_DevicePosition{ - DeviceId: id, - Offset: offset + int32(math.Abs(float64(c.Kilometer-prevKm))), - DeviceType: "curvatures", - } + for id, c := range cm { + if judgeKilometerIsVaild(c) && deviceMap[id] == nil { + deviceMap[id] = &graphicData.CalculateLink_DevicePosition{ + DeviceId: id, + Offset: offset + int32(math.Abs(float64(c.Kilometer-prevKm))), + DeviceType: "curvatures", } } } diff --git a/db/dbquery/gen.go b/db/dbquery/gen.go index 284f136..840abac 100644 --- a/db/dbquery/gen.go +++ b/db/dbquery/gen.go @@ -20,6 +20,7 @@ var ( Category *category Drafting *drafting PublishedGi *publishedGi + TrainModel *trainModel User *user ) @@ -28,6 +29,7 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) { Category = &Q.Category Drafting = &Q.Drafting PublishedGi = &Q.PublishedGi + TrainModel = &Q.TrainModel User = &Q.User } @@ -37,6 +39,7 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query { Category: newCategory(db, opts...), Drafting: newDrafting(db, opts...), PublishedGi: newPublishedGi(db, opts...), + TrainModel: newTrainModel(db, opts...), User: newUser(db, opts...), } } @@ -47,6 +50,7 @@ type Query struct { Category category Drafting drafting PublishedGi publishedGi + TrainModel trainModel User user } @@ -58,6 +62,7 @@ func (q *Query) clone(db *gorm.DB) *Query { Category: q.Category.clone(db), Drafting: q.Drafting.clone(db), PublishedGi: q.PublishedGi.clone(db), + TrainModel: q.TrainModel.clone(db), User: q.User.clone(db), } } @@ -76,6 +81,7 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query { Category: q.Category.replaceDB(db), Drafting: q.Drafting.replaceDB(db), PublishedGi: q.PublishedGi.replaceDB(db), + TrainModel: q.TrainModel.replaceDB(db), User: q.User.replaceDB(db), } } @@ -84,6 +90,7 @@ type queryCtx struct { Category ICategoryDo Drafting IDraftingDo PublishedGi IPublishedGiDo + TrainModel ITrainModelDo User IUserDo } @@ -92,6 +99,7 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx { Category: q.Category.WithContext(ctx), Drafting: q.Drafting.WithContext(ctx), PublishedGi: q.PublishedGi.WithContext(ctx), + TrainModel: q.TrainModel.WithContext(ctx), User: q.User.WithContext(ctx), } } diff --git a/db/dbquery/train_group.gen.go b/db/dbquery/train_group.gen.go new file mode 100644 index 0000000..ae08f54 --- /dev/null +++ b/db/dbquery/train_group.gen.go @@ -0,0 +1,396 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dbquery + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "joylink.club/bj-rtsts-server/db/model" +) + +func newTrainGroup(db *gorm.DB, opts ...gen.DOOption) trainGroup { + _trainGroup := trainGroup{} + + _trainGroup.trainGroupDo.UseDB(db, opts...) + _trainGroup.trainGroupDo.UseModel(&model.TrainGroup{}) + + tableName := _trainGroup.trainGroupDo.TableName() + _trainGroup.ALL = field.NewAsterisk(tableName) + _trainGroup.ID = field.NewInt32(tableName, "id") + _trainGroup.Name = field.NewString(tableName, "name") + _trainGroup.CarriageLength = field.NewInt32(tableName, "carriage_length") + _trainGroup.CreatedAt = field.NewTime(tableName, "created_at") + _trainGroup.UpdateAt = field.NewTime(tableName, "update_at") + + _trainGroup.fillFieldMap() + + return _trainGroup +} + +type trainGroup struct { + trainGroupDo + + ALL field.Asterisk + ID field.Int32 + Name field.String // 组次名称 + CarriageLength field.Int32 // 单个车厢长度 + CreatedAt field.Time // 创建时间 + UpdateAt field.Time // 更新时间 + + fieldMap map[string]field.Expr +} + +func (t trainGroup) Table(newTableName string) *trainGroup { + t.trainGroupDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t trainGroup) As(alias string) *trainGroup { + t.trainGroupDo.DO = *(t.trainGroupDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *trainGroup) updateTableName(table string) *trainGroup { + t.ALL = field.NewAsterisk(table) + t.ID = field.NewInt32(table, "id") + t.Name = field.NewString(table, "name") + t.CarriageLength = field.NewInt32(table, "carriage_length") + t.CreatedAt = field.NewTime(table, "created_at") + t.UpdateAt = field.NewTime(table, "update_at") + + t.fillFieldMap() + + return t +} + +func (t *trainGroup) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *trainGroup) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 5) + t.fieldMap["id"] = t.ID + t.fieldMap["name"] = t.Name + t.fieldMap["carriage_length"] = t.CarriageLength + t.fieldMap["created_at"] = t.CreatedAt + t.fieldMap["update_at"] = t.UpdateAt +} + +func (t trainGroup) clone(db *gorm.DB) trainGroup { + t.trainGroupDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t trainGroup) replaceDB(db *gorm.DB) trainGroup { + t.trainGroupDo.ReplaceDB(db) + return t +} + +type trainGroupDo struct{ gen.DO } + +type ITrainGroupDo interface { + gen.SubQuery + Debug() ITrainGroupDo + WithContext(ctx context.Context) ITrainGroupDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ITrainGroupDo + WriteDB() ITrainGroupDo + As(alias string) gen.Dao + Session(config *gorm.Session) ITrainGroupDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ITrainGroupDo + Not(conds ...gen.Condition) ITrainGroupDo + Or(conds ...gen.Condition) ITrainGroupDo + Select(conds ...field.Expr) ITrainGroupDo + Where(conds ...gen.Condition) ITrainGroupDo + Order(conds ...field.Expr) ITrainGroupDo + Distinct(cols ...field.Expr) ITrainGroupDo + Omit(cols ...field.Expr) ITrainGroupDo + Join(table schema.Tabler, on ...field.Expr) ITrainGroupDo + LeftJoin(table schema.Tabler, on ...field.Expr) ITrainGroupDo + RightJoin(table schema.Tabler, on ...field.Expr) ITrainGroupDo + Group(cols ...field.Expr) ITrainGroupDo + Having(conds ...gen.Condition) ITrainGroupDo + Limit(limit int) ITrainGroupDo + Offset(offset int) ITrainGroupDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ITrainGroupDo + Unscoped() ITrainGroupDo + Create(values ...*model.TrainGroup) error + CreateInBatches(values []*model.TrainGroup, batchSize int) error + Save(values ...*model.TrainGroup) error + First() (*model.TrainGroup, error) + Take() (*model.TrainGroup, error) + Last() (*model.TrainGroup, error) + Find() ([]*model.TrainGroup, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.TrainGroup, err error) + FindInBatches(result *[]*model.TrainGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.TrainGroup) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ITrainGroupDo + Assign(attrs ...field.AssignExpr) ITrainGroupDo + Joins(fields ...field.RelationField) ITrainGroupDo + Preload(fields ...field.RelationField) ITrainGroupDo + FirstOrInit() (*model.TrainGroup, error) + FirstOrCreate() (*model.TrainGroup, error) + FindByPage(offset int, limit int) (result []*model.TrainGroup, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ITrainGroupDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (t trainGroupDo) Debug() ITrainGroupDo { + return t.withDO(t.DO.Debug()) +} + +func (t trainGroupDo) WithContext(ctx context.Context) ITrainGroupDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t trainGroupDo) ReadDB() ITrainGroupDo { + return t.Clauses(dbresolver.Read) +} + +func (t trainGroupDo) WriteDB() ITrainGroupDo { + return t.Clauses(dbresolver.Write) +} + +func (t trainGroupDo) Session(config *gorm.Session) ITrainGroupDo { + return t.withDO(t.DO.Session(config)) +} + +func (t trainGroupDo) Clauses(conds ...clause.Expression) ITrainGroupDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t trainGroupDo) Returning(value interface{}, columns ...string) ITrainGroupDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t trainGroupDo) Not(conds ...gen.Condition) ITrainGroupDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t trainGroupDo) Or(conds ...gen.Condition) ITrainGroupDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t trainGroupDo) Select(conds ...field.Expr) ITrainGroupDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t trainGroupDo) Where(conds ...gen.Condition) ITrainGroupDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t trainGroupDo) Order(conds ...field.Expr) ITrainGroupDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t trainGroupDo) Distinct(cols ...field.Expr) ITrainGroupDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t trainGroupDo) Omit(cols ...field.Expr) ITrainGroupDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t trainGroupDo) Join(table schema.Tabler, on ...field.Expr) ITrainGroupDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t trainGroupDo) LeftJoin(table schema.Tabler, on ...field.Expr) ITrainGroupDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t trainGroupDo) RightJoin(table schema.Tabler, on ...field.Expr) ITrainGroupDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t trainGroupDo) Group(cols ...field.Expr) ITrainGroupDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t trainGroupDo) Having(conds ...gen.Condition) ITrainGroupDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t trainGroupDo) Limit(limit int) ITrainGroupDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t trainGroupDo) Offset(offset int) ITrainGroupDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t trainGroupDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ITrainGroupDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t trainGroupDo) Unscoped() ITrainGroupDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t trainGroupDo) Create(values ...*model.TrainGroup) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t trainGroupDo) CreateInBatches(values []*model.TrainGroup, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t trainGroupDo) Save(values ...*model.TrainGroup) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t trainGroupDo) First() (*model.TrainGroup, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.TrainGroup), nil + } +} + +func (t trainGroupDo) Take() (*model.TrainGroup, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.TrainGroup), nil + } +} + +func (t trainGroupDo) Last() (*model.TrainGroup, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.TrainGroup), nil + } +} + +func (t trainGroupDo) Find() ([]*model.TrainGroup, error) { + result, err := t.DO.Find() + return result.([]*model.TrainGroup), err +} + +func (t trainGroupDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.TrainGroup, err error) { + buf := make([]*model.TrainGroup, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t trainGroupDo) FindInBatches(result *[]*model.TrainGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t trainGroupDo) Attrs(attrs ...field.AssignExpr) ITrainGroupDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t trainGroupDo) Assign(attrs ...field.AssignExpr) ITrainGroupDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t trainGroupDo) Joins(fields ...field.RelationField) ITrainGroupDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t trainGroupDo) Preload(fields ...field.RelationField) ITrainGroupDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t trainGroupDo) FirstOrInit() (*model.TrainGroup, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.TrainGroup), nil + } +} + +func (t trainGroupDo) FirstOrCreate() (*model.TrainGroup, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.TrainGroup), nil + } +} + +func (t trainGroupDo) FindByPage(offset int, limit int) (result []*model.TrainGroup, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t trainGroupDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t trainGroupDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t trainGroupDo) Delete(models ...*model.TrainGroup) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +func (t *trainGroupDo) withDO(do gen.Dao) *trainGroupDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/db/dbquery/train_model.gen.go b/db/dbquery/train_model.gen.go new file mode 100644 index 0000000..da39e72 --- /dev/null +++ b/db/dbquery/train_model.gen.go @@ -0,0 +1,396 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dbquery + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "joylink.club/bj-rtsts-server/db/model" +) + +func newTrainModel(db *gorm.DB, opts ...gen.DOOption) trainModel { + _trainModel := trainModel{} + + _trainModel.trainModelDo.UseDB(db, opts...) + _trainModel.trainModelDo.UseModel(&model.TrainModel{}) + + tableName := _trainModel.trainModelDo.TableName() + _trainModel.ALL = field.NewAsterisk(tableName) + _trainModel.ID = field.NewInt32(tableName, "id") + _trainModel.Name = field.NewString(tableName, "name") + _trainModel.CarriageLength = field.NewInt32(tableName, "carriage_length") + _trainModel.CreatedAt = field.NewTime(tableName, "created_at") + _trainModel.UpdateAt = field.NewTime(tableName, "update_at") + + _trainModel.fillFieldMap() + + return _trainModel +} + +type trainModel struct { + trainModelDo + + ALL field.Asterisk + ID field.Int32 + Name field.String // 组次名称 + CarriageLength field.Int32 // 单个车厢长度 + CreatedAt field.Time // 创建时间 + UpdateAt field.Time // 更新时间 + + fieldMap map[string]field.Expr +} + +func (t trainModel) Table(newTableName string) *trainModel { + t.trainModelDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t trainModel) As(alias string) *trainModel { + t.trainModelDo.DO = *(t.trainModelDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *trainModel) updateTableName(table string) *trainModel { + t.ALL = field.NewAsterisk(table) + t.ID = field.NewInt32(table, "id") + t.Name = field.NewString(table, "name") + t.CarriageLength = field.NewInt32(table, "carriage_length") + t.CreatedAt = field.NewTime(table, "created_at") + t.UpdateAt = field.NewTime(table, "update_at") + + t.fillFieldMap() + + return t +} + +func (t *trainModel) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *trainModel) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 5) + t.fieldMap["id"] = t.ID + t.fieldMap["name"] = t.Name + t.fieldMap["carriage_length"] = t.CarriageLength + t.fieldMap["created_at"] = t.CreatedAt + t.fieldMap["update_at"] = t.UpdateAt +} + +func (t trainModel) clone(db *gorm.DB) trainModel { + t.trainModelDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t trainModel) replaceDB(db *gorm.DB) trainModel { + t.trainModelDo.ReplaceDB(db) + return t +} + +type trainModelDo struct{ gen.DO } + +type ITrainModelDo interface { + gen.SubQuery + Debug() ITrainModelDo + WithContext(ctx context.Context) ITrainModelDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ITrainModelDo + WriteDB() ITrainModelDo + As(alias string) gen.Dao + Session(config *gorm.Session) ITrainModelDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ITrainModelDo + Not(conds ...gen.Condition) ITrainModelDo + Or(conds ...gen.Condition) ITrainModelDo + Select(conds ...field.Expr) ITrainModelDo + Where(conds ...gen.Condition) ITrainModelDo + Order(conds ...field.Expr) ITrainModelDo + Distinct(cols ...field.Expr) ITrainModelDo + Omit(cols ...field.Expr) ITrainModelDo + Join(table schema.Tabler, on ...field.Expr) ITrainModelDo + LeftJoin(table schema.Tabler, on ...field.Expr) ITrainModelDo + RightJoin(table schema.Tabler, on ...field.Expr) ITrainModelDo + Group(cols ...field.Expr) ITrainModelDo + Having(conds ...gen.Condition) ITrainModelDo + Limit(limit int) ITrainModelDo + Offset(offset int) ITrainModelDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ITrainModelDo + Unscoped() ITrainModelDo + Create(values ...*model.TrainModel) error + CreateInBatches(values []*model.TrainModel, batchSize int) error + Save(values ...*model.TrainModel) error + First() (*model.TrainModel, error) + Take() (*model.TrainModel, error) + Last() (*model.TrainModel, error) + Find() ([]*model.TrainModel, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.TrainModel, err error) + FindInBatches(result *[]*model.TrainModel, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.TrainModel) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ITrainModelDo + Assign(attrs ...field.AssignExpr) ITrainModelDo + Joins(fields ...field.RelationField) ITrainModelDo + Preload(fields ...field.RelationField) ITrainModelDo + FirstOrInit() (*model.TrainModel, error) + FirstOrCreate() (*model.TrainModel, error) + FindByPage(offset int, limit int) (result []*model.TrainModel, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ITrainModelDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (t trainModelDo) Debug() ITrainModelDo { + return t.withDO(t.DO.Debug()) +} + +func (t trainModelDo) WithContext(ctx context.Context) ITrainModelDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t trainModelDo) ReadDB() ITrainModelDo { + return t.Clauses(dbresolver.Read) +} + +func (t trainModelDo) WriteDB() ITrainModelDo { + return t.Clauses(dbresolver.Write) +} + +func (t trainModelDo) Session(config *gorm.Session) ITrainModelDo { + return t.withDO(t.DO.Session(config)) +} + +func (t trainModelDo) Clauses(conds ...clause.Expression) ITrainModelDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t trainModelDo) Returning(value interface{}, columns ...string) ITrainModelDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t trainModelDo) Not(conds ...gen.Condition) ITrainModelDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t trainModelDo) Or(conds ...gen.Condition) ITrainModelDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t trainModelDo) Select(conds ...field.Expr) ITrainModelDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t trainModelDo) Where(conds ...gen.Condition) ITrainModelDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t trainModelDo) Order(conds ...field.Expr) ITrainModelDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t trainModelDo) Distinct(cols ...field.Expr) ITrainModelDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t trainModelDo) Omit(cols ...field.Expr) ITrainModelDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t trainModelDo) Join(table schema.Tabler, on ...field.Expr) ITrainModelDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t trainModelDo) LeftJoin(table schema.Tabler, on ...field.Expr) ITrainModelDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t trainModelDo) RightJoin(table schema.Tabler, on ...field.Expr) ITrainModelDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t trainModelDo) Group(cols ...field.Expr) ITrainModelDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t trainModelDo) Having(conds ...gen.Condition) ITrainModelDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t trainModelDo) Limit(limit int) ITrainModelDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t trainModelDo) Offset(offset int) ITrainModelDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t trainModelDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ITrainModelDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t trainModelDo) Unscoped() ITrainModelDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t trainModelDo) Create(values ...*model.TrainModel) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t trainModelDo) CreateInBatches(values []*model.TrainModel, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t trainModelDo) Save(values ...*model.TrainModel) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t trainModelDo) First() (*model.TrainModel, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.TrainModel), nil + } +} + +func (t trainModelDo) Take() (*model.TrainModel, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.TrainModel), nil + } +} + +func (t trainModelDo) Last() (*model.TrainModel, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.TrainModel), nil + } +} + +func (t trainModelDo) Find() ([]*model.TrainModel, error) { + result, err := t.DO.Find() + return result.([]*model.TrainModel), err +} + +func (t trainModelDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.TrainModel, err error) { + buf := make([]*model.TrainModel, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t trainModelDo) FindInBatches(result *[]*model.TrainModel, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t trainModelDo) Attrs(attrs ...field.AssignExpr) ITrainModelDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t trainModelDo) Assign(attrs ...field.AssignExpr) ITrainModelDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t trainModelDo) Joins(fields ...field.RelationField) ITrainModelDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t trainModelDo) Preload(fields ...field.RelationField) ITrainModelDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t trainModelDo) FirstOrInit() (*model.TrainModel, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.TrainModel), nil + } +} + +func (t trainModelDo) FirstOrCreate() (*model.TrainModel, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.TrainModel), nil + } +} + +func (t trainModelDo) FindByPage(offset int, limit int) (result []*model.TrainModel, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t trainModelDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t trainModelDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t trainModelDo) Delete(models ...*model.TrainModel) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +func (t *trainModelDo) withDO(do gen.Dao) *trainModelDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/db/model/train_group.gen.go b/db/model/train_group.gen.go new file mode 100644 index 0000000..3f67e07 --- /dev/null +++ b/db/model/train_group.gen.go @@ -0,0 +1,25 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameTrainGroup = "train_group" + +// TrainGroup mapped from table +type TrainGroup struct { + ID int32 `gorm:"column:id;primaryKey;autoIncrement:true" json:"id"` + Name string `gorm:"column:name;comment:组次名称" json:"name"` // 组次名称 + CarriageLength int32 `gorm:"column:carriage_length;comment:单个车厢长度" json:"carriage_length"` // 单个车厢长度 + CreatedAt time.Time `gorm:"column:created_at;comment:创建时间" json:"created_at"` // 创建时间 + UpdateAt time.Time `gorm:"column:update_at;comment:更新时间" json:"update_at"` // 更新时间 +} + +// TableName TrainGroup's table name +func (*TrainGroup) TableName() string { + return TableNameTrainGroup +} diff --git a/db/model/train_model.gen.go b/db/model/train_model.gen.go new file mode 100644 index 0000000..271516f --- /dev/null +++ b/db/model/train_model.gen.go @@ -0,0 +1,25 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameTrainModel = "train_model" + +// TrainModel mapped from table +type TrainModel struct { + ID int32 `gorm:"column:id;primaryKey;autoIncrement:true" json:"id"` + Name string `gorm:"column:name;comment:组次名称" json:"name"` // 组次名称 + CarriageLength int32 `gorm:"column:carriage_length;comment:单个车厢长度" json:"carriage_length"` // 单个车厢长度 + CreatedAt time.Time `gorm:"column:created_at;comment:创建时间" json:"created_at"` // 创建时间 + UpdateAt time.Time `gorm:"column:update_at;comment:更新时间" json:"update_at"` // 更新时间 +} + +// TableName TrainModel's table name +func (*TrainModel) TableName() string { + return TableNameTrainModel +} diff --git a/dto/simulation.go b/dto/simulation.go index 1520119..5cbc050 100644 --- a/dto/simulation.go +++ b/dto/simulation.go @@ -32,6 +32,10 @@ type AddTrainReqDto struct { DevicePort string `json:"devicePort" form:"devicePort"` //车头所在link内的偏移量，单位为mm HeadOffset int64 `json:"headOffset" form:"headOffset"` + //列车信号ID + TrainModelId int32 `json:"trainModelId" from:"trainModelId"` + //列车车厢数 + CarriageNum int32 `json:"carriageNum" from:"carriageNum"` } // 为仿真添加测试车请求 diff --git a/dto/trainModel.go b/dto/trainModel.go new file mode 100644 index 0000000..fd477d3 --- /dev/null +++ b/dto/trainModel.go @@ -0,0 +1,16 @@ +package dto + +type PageTrainModelReqDto struct { + PageQueryDto + Name string `json:"name" form:"name"` +} + +type TrainModelReqDto struct { + Name string `json:"name" form:"name"` +} + +type TrainModelDto struct { + Id int `json:"id" form:"id"` + Name string `json:"name" form:"name"` + CarriageLength int32 `json:"carriageLength" form:"carriageLength"` +} diff --git a/service/trainModel.go b/service/trainModel.go new file mode 100644 index 0000000..00e61b0 --- /dev/null +++ b/service/trainModel.go @@ -0,0 +1,122 @@ +package service + +import ( + "fmt" + "time" + + "joylink.club/bj-rtsts-server/db/dbquery" + "joylink.club/bj-rtsts-server/db/model" + "joylink.club/bj-rtsts-server/dto" +) + +// 查询列车型号信息列表 +func PageTrainModelQuery(query *dto.PageTrainModelReqDto) (*dto.PageDto, error) { + d := dbquery.TrainModel + dq := d.Where() + if query.Name != "" { + dq = dq.Where(d.Name.Like(fmt.Sprintf("%%%s%%", query.Name))) + } + records, total, err := dq.Debug().Select(d.ID, d.Name, d.CarriageLength, d.UpdateAt, d.CreatedAt).FindByPage(query.Offset(), query.Size) + if err != nil { + panic(err) + } + return &dto.PageDto{Total: int(total), PageQueryDto: query.PageQueryDto, Records: records}, nil +} + +// 查询列车型号信息列表 +func ListTrainModelQuery(query *dto.TrainModelReqDto) ([]*model.TrainModel, error) { + d := dbquery.TrainModel + dq := d.Where() + if query.Name != "" { + dq = dq.Where(d.Name.Like(fmt.Sprintf("%%%s%%", query.Name))) + } + records, err := dq.Debug().Select(d.ID, d.Name, d.CarriageLength, d.UpdateAt, d.CreatedAt).Find() + if err != nil { + panic(err) + } + return records, nil +} + +// 创建列车型号信息 +func CreateTrainModel(dto *dto.TrainModelDto) (*model.TrainModel, error) { + if err := checkTrainModel(dto.Name, 0); err != nil { + panic(err) + } + d := model.TrainModel{ + Name: dto.Name, + CarriageLength: dto.CarriageLength, + CreatedAt: time.Now(), + UpdateAt: time.Now(), + } + dt := dbquery.TrainModel + err := dt.Save(&d) + if err != nil { + panic(err) + } + return dt.Where(dt.Name.Eq(dto.Name)).Order(dt.CreatedAt).Debug().First() +} + +// 查询列车型号信息 +func QueryTrainModel(id int32) *model.TrainModel { + dt := dbquery.TrainModel + data, err := dt.Where(dt.ID.Eq(id)).Debug().First() + if err != nil { + panic(err) + } + return data +} + +// 更新列车型号信息 +func UpdateTrainModel(id int32, dto *dto.TrainModelDto) bool { + if err := checkTrainModel(dto.Name, id); err != nil { + panic(err) + } + findOldQuery := dbquery.TrainModel + oldD, err := findOldQuery.Where(findOldQuery.ID.Eq(id)).Debug().First() + if oldD == nil || err != nil { + panic(err) + } + if len(dto.Name) > 0 { + oldD.Name = dto.Name + } + oldD.UpdateAt = time.Now() + _, error := dbquery.TrainModel.Updates(oldD) + if error != nil { + panic(error) + } + return true +} + +// 删除列车型号 +func DeleteTrainModelById(id int) { + _, _ = dbquery.TrainModel.Debug().Where(dbquery.TrainModel.ID.Eq(int32(id))).Delete() +} + +// 根据列车型号跟车厢数量计算列车长度 +func CalcTrainLenght(id, num int32) int32 { + dt := dbquery.TrainModel + data, err := dt.Select(dt.CarriageLength).Where(dt.ID.Eq(id)).Debug().First() + if err != nil { + panic(err) + } + return data.CarriageLength * num +} + +// 检查列车型号名称 +func checkTrainModel(name string, id int32) error { + findNameQuery := dbquery.TrainModel + w := findNameQuery.Where() + if id != 0 { + w = w.Where(findNameQuery.ID.Eq(id)) + } + if name != "" { + count, err := w.Where(findNameQuery.Name.Eq(name)).Debug().Count() + if err != nil { + panic(err) + } + if count > 0 { + panic("名称已存在") + } + } + return nil +}