feat: 自动化控制模块

goadmin/env_monitor/env_device.yaml

@@ -0,0 +1,59 @@
+- name: EnvMonitorDevice
+  comment: 环境监测设备管理
+  disable_pagination: false
+  fill_gorm_commit: true
+  fill_router_prefix: true
+  fields:
+    - name: DeviceNo
+      type: string
+      comment: 环境监测编号
+      gorm_tag: "size:32;uniqueIndex"
+      form:
+        binding_tag: "required,max=32"
+    - name: Name
+      type: string
+      comment: 环境监测名称
+      gorm_tag: "size:64"
+      form:
+        binding_tag: "required,max=64"
+    - name: Type
+      type: int
+      comment: 环境监测设备类型（1水质监测仪、2水下视频监控、3车间视频监控）
+      form:
+        binding_tag: "required"
+    - name: Status
+      type: bool
+      comment: 环境监测设备状态（true=在线，false=离线）
+      form:
+        binding_tag: "required"
+    - name: Model
+      type: string
+      comment: 环境监测设备型号
+      gorm_tag: "size:64"
+      form:
+        binding_tag: "required,max=64"
+    - name: WorkshopID
+      type: int64
+      comment: 关联车间ID
+      gorm_tag: "index;foreignKey:ID;references:work_shop"
+      form:
+        binding_tag: "required"
+
+- name: EnvMonitorDeviceFishPond
+  comment: 环境监测设备-鱼池关联表
+  disable_pagination: false
+  fill_gorm_commit: true
+  fill_router_prefix: true
+  fields:
+    - name: DeviceID
+      type: int64
+      comment: 环境监测设备ID
+      gorm_tag: "index;foreignKey:ID;references:device"
+      form:
+        binding_tag: "required"
+    - name: FishPondID
+      type: int64
+      comment: 鱼池ID
+      gorm_tag: "index;foreignKey:ID;references:fish_pond"
+      form:
+        binding_tag: "required"

goadmin/env_monitor/env_device_type_info.yaml

@@ -0,0 +1,35 @@
+- name: EnvMonitorDeviceTypeInfo
+  comment: 环境监测设备类型信息
+  disable_pagination: false
+  fill_gorm_commit: true
+  fill_router_prefix: true
+  fields:
+    - name: Type
+      type: int
+      comment: 环境监测设备类型（1水质监测仪、2水下视频监控、3车间视频监控）
+      form:
+        binding_tag: "required"
+    - name: Model
+      type: string
+      comment: 设备型号
+      gorm_tag: "size:255"
+      form:
+        binding_tag: "required,max=255"
+    - name: Supplier
+      type: string
+      comment: 供应商
+      gorm_tag: "size:255"
+      form:
+        binding_tag: "required,max=255"
+    - name: Pic
+      type: string
+      comment: 图片地址
+      gorm_tag: "type:text"
+      form:
+        binding_tag: "required"
+    - name: Description
+      type: string
+      comment: 简介
+      gorm_tag: "type:text"
+      form:
+        binding_tag: "required"

internal/mods/autocontrol/dal/device.dal.go

@@ -36,7 +36,7 @@ func (a *Device) Query(ctx context.Context, params schema.DeviceQueryParam, opts
 	if params.Name != "" {
 		db = db.Where("name like ?", "%"+params.Name+"%")
 	}
-	if params.Type != nil {
+	if params.Type != nil && *params.Type != 0 {
 		db = db.Where("type=?", *params.Type)
 	}
 	var list schema.Devices

internal/mods/envmonitor/api/env_monitor_device.api.go

@@ -0,0 +1,132 @@
+package api
+
+import (
+	"ifms/internal/mods/envmonitor/biz"
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/util"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 环境监测设备管理
+type EnvMonitorDevice struct {
+	EnvMonitorDeviceBIZ *biz.EnvMonitorDevice
+}
+
+// @Tags EnvMonitorDeviceAPI
+// @Security ApiKeyAuth
+// @Summary Query env monitor device list
+// @Param current query int true "pagination index" default(1)
+// @Param pageSize query int true "pagination size" default(10)
+// @Success 200 {object} util.ResponseResult{data=[]schema.EnvMonitorDevice}
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-devices [get]
+func (a *EnvMonitorDevice) Query(c *gin.Context) {
+	ctx := c.Request.Context()
+	var params schema.EnvMonitorDeviceQueryParam
+	if err := util.ParseQuery(c, &params); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	result, err := a.EnvMonitorDeviceBIZ.Query(ctx, params)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResPage(c, result.Data, result.PageResult)
+}
+
+// @Tags EnvMonitorDeviceAPI
+// @Security ApiKeyAuth
+// @Summary Get env monitor device record by ID
+// @Param id path string true "unique id"
+// @Success 200 {object} util.ResponseResult{data=schema.EnvMonitorDevice}
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-devices/{id} [get]
+func (a *EnvMonitorDevice) Get(c *gin.Context) {
+	ctx := c.Request.Context()
+	item, err := a.EnvMonitorDeviceBIZ.Get(ctx, c.Param("id"))
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResSuccess(c, item)
+}
+
+// @Tags EnvMonitorDeviceAPI
+// @Security ApiKeyAuth
+// @Summary Create env monitor device record
+// @Param body body schema.EnvMonitorDeviceForm true "Request body"
+// @Success 200 {object} util.ResponseResult{data=schema.EnvMonitorDevice}
+// @Failure 400 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-devices [post]
+func (a *EnvMonitorDevice) Create(c *gin.Context) {
+	ctx := c.Request.Context()
+	item := new(schema.EnvMonitorDeviceForm)
+	if err := util.ParseJSON(c, item); err != nil {
+		util.ResError(c, err)
+		return
+	} else if err := item.Validate(); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	result, err := a.EnvMonitorDeviceBIZ.Create(ctx, item)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResSuccess(c, result)
+}
+
+// @Tags EnvMonitorDeviceAPI
+// @Security ApiKeyAuth
+// @Summary Update env monitor device record by ID
+// @Param id path string true "unique id"
+// @Param body body schema.EnvMonitorDeviceForm true "Request body"
+// @Success 200 {object} util.ResponseResult
+// @Failure 400 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-devices/{id} [put]
+func (a *EnvMonitorDevice) Update(c *gin.Context) {
+	ctx := c.Request.Context()
+	item := new(schema.EnvMonitorDeviceForm)
+	if err := util.ParseJSON(c, item); err != nil {
+		util.ResError(c, err)
+		return
+	} else if err := item.Validate(); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	err := a.EnvMonitorDeviceBIZ.Update(ctx, c.Param("id"), item)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResOK(c)
+}
+
+// @Tags EnvMonitorDeviceAPI
+// @Security ApiKeyAuth
+// @Summary Delete env monitor device record by ID
+// @Param id path string true "unique id"
+// @Success 200 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-devices/{id} [delete]
+func (a *EnvMonitorDevice) Delete(c *gin.Context) {
+	ctx := c.Request.Context()
+	err := a.EnvMonitorDeviceBIZ.Delete(ctx, c.Param("id"))
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResOK(c)
+}

internal/mods/envmonitor/api/env_monitor_device_fish_pond.api.go

@@ -0,0 +1,132 @@
+package api
+
+import (
+	"ifms/internal/mods/envmonitor/biz"
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/util"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 环境监测设备-鱼池关联表
+type EnvMonitorDeviceFishPond struct {
+	EnvMonitorDeviceFishPondBIZ *biz.EnvMonitorDeviceFishPond
+}
+
+// @Tags EnvMonitorDeviceFishPondAPI
+// @Security ApiKeyAuth
+// @Summary Query env monitor device fish pond list
+// @Param current query int true "pagination index" default(1)
+// @Param pageSize query int true "pagination size" default(10)
+// @Success 200 {object} util.ResponseResult{data=[]schema.EnvMonitorDeviceFishPond}
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-fish-ponds [get]
+func (a *EnvMonitorDeviceFishPond) Query(c *gin.Context) {
+	ctx := c.Request.Context()
+	var params schema.EnvMonitorDeviceFishPondQueryParam
+	if err := util.ParseQuery(c, &params); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	result, err := a.EnvMonitorDeviceFishPondBIZ.Query(ctx, params)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResPage(c, result.Data, result.PageResult)
+}
+
+// @Tags EnvMonitorDeviceFishPondAPI
+// @Security ApiKeyAuth
+// @Summary Get env monitor device fish pond record by ID
+// @Param id path string true "unique id"
+// @Success 200 {object} util.ResponseResult{data=schema.EnvMonitorDeviceFishPond}
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-fish-ponds/{id} [get]
+func (a *EnvMonitorDeviceFishPond) Get(c *gin.Context) {
+	ctx := c.Request.Context()
+	item, err := a.EnvMonitorDeviceFishPondBIZ.Get(ctx, c.Param("id"))
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResSuccess(c, item)
+}
+
+// @Tags EnvMonitorDeviceFishPondAPI
+// @Security ApiKeyAuth
+// @Summary Create env monitor device fish pond record
+// @Param body body schema.EnvMonitorDeviceFishPondForm true "Request body"
+// @Success 200 {object} util.ResponseResult{data=schema.EnvMonitorDeviceFishPond}
+// @Failure 400 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-fish-ponds [post]
+func (a *EnvMonitorDeviceFishPond) Create(c *gin.Context) {
+	ctx := c.Request.Context()
+	item := new(schema.EnvMonitorDeviceFishPondForm)
+	if err := util.ParseJSON(c, item); err != nil {
+		util.ResError(c, err)
+		return
+	} else if err := item.Validate(); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	result, err := a.EnvMonitorDeviceFishPondBIZ.Create(ctx, item)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResSuccess(c, result)
+}
+
+// @Tags EnvMonitorDeviceFishPondAPI
+// @Security ApiKeyAuth
+// @Summary Update env monitor device fish pond record by ID
+// @Param id path string true "unique id"
+// @Param body body schema.EnvMonitorDeviceFishPondForm true "Request body"
+// @Success 200 {object} util.ResponseResult
+// @Failure 400 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-fish-ponds/{id} [put]
+func (a *EnvMonitorDeviceFishPond) Update(c *gin.Context) {
+	ctx := c.Request.Context()
+	item := new(schema.EnvMonitorDeviceFishPondForm)
+	if err := util.ParseJSON(c, item); err != nil {
+		util.ResError(c, err)
+		return
+	} else if err := item.Validate(); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	err := a.EnvMonitorDeviceFishPondBIZ.Update(ctx, c.Param("id"), item)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResOK(c)
+}
+
+// @Tags EnvMonitorDeviceFishPondAPI
+// @Security ApiKeyAuth
+// @Summary Delete env monitor device fish pond record by ID
+// @Param id path string true "unique id"
+// @Success 200 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-fish-ponds/{id} [delete]
+func (a *EnvMonitorDeviceFishPond) Delete(c *gin.Context) {
+	ctx := c.Request.Context()
+	err := a.EnvMonitorDeviceFishPondBIZ.Delete(ctx, c.Param("id"))
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResOK(c)
+}

internal/mods/envmonitor/api/env_monitor_device_type_info.api.go

@@ -0,0 +1,132 @@
+package api
+
+import (
+	"ifms/internal/mods/envmonitor/biz"
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/util"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 环境监测设备类型信息
+type EnvMonitorDeviceTypeInfo struct {
+	EnvMonitorDeviceTypeInfoBIZ *biz.EnvMonitorDeviceTypeInfo
+}
+
+// @Tags EnvMonitorDeviceTypeInfoAPI
+// @Security ApiKeyAuth
+// @Summary Query env monitor device type info list
+// @Param current query int true "pagination index" default(1)
+// @Param pageSize query int true "pagination size" default(10)
+// @Success 200 {object} util.ResponseResult{data=[]schema.EnvMonitorDeviceTypeInfo}
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-type-infos [get]
+func (a *EnvMonitorDeviceTypeInfo) Query(c *gin.Context) {
+	ctx := c.Request.Context()
+	var params schema.EnvMonitorDeviceTypeInfoQueryParam
+	if err := util.ParseQuery(c, &params); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	result, err := a.EnvMonitorDeviceTypeInfoBIZ.Query(ctx, params)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResPage(c, result.Data, result.PageResult)
+}
+
+// @Tags EnvMonitorDeviceTypeInfoAPI
+// @Security ApiKeyAuth
+// @Summary Get env monitor device type info record by ID
+// @Param id path string true "unique id"
+// @Success 200 {object} util.ResponseResult{data=schema.EnvMonitorDeviceTypeInfo}
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-type-infos/{id} [get]
+func (a *EnvMonitorDeviceTypeInfo) Get(c *gin.Context) {
+	ctx := c.Request.Context()
+	item, err := a.EnvMonitorDeviceTypeInfoBIZ.Get(ctx, c.Param("id"))
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResSuccess(c, item)
+}
+
+// @Tags EnvMonitorDeviceTypeInfoAPI
+// @Security ApiKeyAuth
+// @Summary Create env monitor device type info record
+// @Param body body schema.EnvMonitorDeviceTypeInfoForm true "Request body"
+// @Success 200 {object} util.ResponseResult{data=schema.EnvMonitorDeviceTypeInfo}
+// @Failure 400 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-type-infos [post]
+func (a *EnvMonitorDeviceTypeInfo) Create(c *gin.Context) {
+	ctx := c.Request.Context()
+	item := new(schema.EnvMonitorDeviceTypeInfoForm)
+	if err := util.ParseJSON(c, item); err != nil {
+		util.ResError(c, err)
+		return
+	} else if err := item.Validate(); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	result, err := a.EnvMonitorDeviceTypeInfoBIZ.Create(ctx, item)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResSuccess(c, result)
+}
+
+// @Tags EnvMonitorDeviceTypeInfoAPI
+// @Security ApiKeyAuth
+// @Summary Update env monitor device type info record by ID
+// @Param id path string true "unique id"
+// @Param body body schema.EnvMonitorDeviceTypeInfoForm true "Request body"
+// @Success 200 {object} util.ResponseResult
+// @Failure 400 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-type-infos/{id} [put]
+func (a *EnvMonitorDeviceTypeInfo) Update(c *gin.Context) {
+	ctx := c.Request.Context()
+	item := new(schema.EnvMonitorDeviceTypeInfoForm)
+	if err := util.ParseJSON(c, item); err != nil {
+		util.ResError(c, err)
+		return
+	} else if err := item.Validate(); err != nil {
+		util.ResError(c, err)
+		return
+	}
+
+	err := a.EnvMonitorDeviceTypeInfoBIZ.Update(ctx, c.Param("id"), item)
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResOK(c)
+}
+
+// @Tags EnvMonitorDeviceTypeInfoAPI
+// @Security ApiKeyAuth
+// @Summary Delete env monitor device type info record by ID
+// @Param id path string true "unique id"
+// @Success 200 {object} util.ResponseResult
+// @Failure 401 {object} util.ResponseResult
+// @Failure 500 {object} util.ResponseResult
+// @Router /api/v1/envmonitor/env-monitor-device-type-infos/{id} [delete]
+func (a *EnvMonitorDeviceTypeInfo) Delete(c *gin.Context) {
+	ctx := c.Request.Context()
+	err := a.EnvMonitorDeviceTypeInfoBIZ.Delete(ctx, c.Param("id"))
+	if err != nil {
+		util.ResError(c, err)
+		return
+	}
+	util.ResOK(c)
+}

internal/mods/envmonitor/biz/env_monitor_device.biz.go

@@ -0,0 +1,107 @@
+package biz
+
+import (
+	"context"
+	"time"
+
+	"ifms/internal/mods/envmonitor/dal"
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/errors"
+	"ifms/pkg/util"
+)
+
+// 环境监测设备管理
+type EnvMonitorDevice struct {
+	Trans               *util.Trans
+	EnvMonitorDeviceDAL *dal.EnvMonitorDevice
+}
+
+// Query env monitor devices from the data access object based on the provided parameters and options.
+func (a *EnvMonitorDevice) Query(ctx context.Context, params schema.EnvMonitorDeviceQueryParam) (*schema.EnvMonitorDeviceQueryResult, error) {
+	params.Pagination = true
+
+	result, err := a.EnvMonitorDeviceDAL.Query(ctx, params, schema.EnvMonitorDeviceQueryOptions{
+		QueryOptions: util.QueryOptions{
+			OrderFields: []util.OrderByParam{
+				{Field: "created_at", Direction: util.DESC},
+			},
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+// Get the specified env monitor device from the data access object.
+func (a *EnvMonitorDevice) Get(ctx context.Context, id string) (*schema.EnvMonitorDevice, error) {
+	envMonitorDevice, err := a.EnvMonitorDeviceDAL.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	} else if envMonitorDevice == nil {
+		return nil, errors.NotFound("", "Env monitor device not found")
+	}
+	return envMonitorDevice, nil
+}
+
+// Create a new env monitor device in the data access object.
+func (a *EnvMonitorDevice) Create(ctx context.Context, formItem *schema.EnvMonitorDeviceForm) (*schema.EnvMonitorDevice, error) {
+	envMonitorDevice := &schema.EnvMonitorDevice{
+		ID:        util.NewXID(),
+		CreatedAt: time.Now(),
+	}
+
+	if err := formItem.FillTo(envMonitorDevice); err != nil {
+		return nil, err
+	}
+
+	err := a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceDAL.Create(ctx, envMonitorDevice); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return envMonitorDevice, nil
+}
+
+// Update the specified env monitor device in the data access object.
+func (a *EnvMonitorDevice) Update(ctx context.Context, id string, formItem *schema.EnvMonitorDeviceForm) error {
+	envMonitorDevice, err := a.EnvMonitorDeviceDAL.Get(ctx, id)
+	if err != nil {
+		return err
+	} else if envMonitorDevice == nil {
+		return errors.NotFound("", "Env monitor device not found")
+	}
+
+	if err := formItem.FillTo(envMonitorDevice); err != nil {
+		return err
+	}
+	envMonitorDevice.UpdatedAt = time.Now()
+
+	return a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceDAL.Update(ctx, envMonitorDevice); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+// Delete the specified env monitor device from the data access object.
+func (a *EnvMonitorDevice) Delete(ctx context.Context, id string) error {
+	exists, err := a.EnvMonitorDeviceDAL.Exists(ctx, id)
+	if err != nil {
+		return err
+	} else if !exists {
+		return errors.NotFound("", "Env monitor device not found")
+	}
+
+	return a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceDAL.Delete(ctx, id); err != nil {
+			return err
+		}
+		return nil
+	})
+}

internal/mods/envmonitor/biz/env_monitor_device_fish_pond.biz.go

@@ -0,0 +1,107 @@
+package biz
+
+import (
+	"context"
+	"time"
+
+	"ifms/internal/mods/envmonitor/dal"
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/errors"
+	"ifms/pkg/util"
+)
+
+// 环境监测设备-鱼池关联表
+type EnvMonitorDeviceFishPond struct {
+	Trans                       *util.Trans
+	EnvMonitorDeviceFishPondDAL *dal.EnvMonitorDeviceFishPond
+}
+
+// Query env monitor device fish ponds from the data access object based on the provided parameters and options.
+func (a *EnvMonitorDeviceFishPond) Query(ctx context.Context, params schema.EnvMonitorDeviceFishPondQueryParam) (*schema.EnvMonitorDeviceFishPondQueryResult, error) {
+	params.Pagination = true
+
+	result, err := a.EnvMonitorDeviceFishPondDAL.Query(ctx, params, schema.EnvMonitorDeviceFishPondQueryOptions{
+		QueryOptions: util.QueryOptions{
+			OrderFields: []util.OrderByParam{
+				{Field: "created_at", Direction: util.DESC},
+			},
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+// Get the specified env monitor device fish pond from the data access object.
+func (a *EnvMonitorDeviceFishPond) Get(ctx context.Context, id string) (*schema.EnvMonitorDeviceFishPond, error) {
+	envMonitorDeviceFishPond, err := a.EnvMonitorDeviceFishPondDAL.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	} else if envMonitorDeviceFishPond == nil {
+		return nil, errors.NotFound("", "Env monitor device fish pond not found")
+	}
+	return envMonitorDeviceFishPond, nil
+}
+
+// Create a new env monitor device fish pond in the data access object.
+func (a *EnvMonitorDeviceFishPond) Create(ctx context.Context, formItem *schema.EnvMonitorDeviceFishPondForm) (*schema.EnvMonitorDeviceFishPond, error) {
+	envMonitorDeviceFishPond := &schema.EnvMonitorDeviceFishPond{
+		ID:        util.NewXID(),
+		CreatedAt: time.Now(),
+	}
+
+	if err := formItem.FillTo(envMonitorDeviceFishPond); err != nil {
+		return nil, err
+	}
+
+	err := a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceFishPondDAL.Create(ctx, envMonitorDeviceFishPond); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return envMonitorDeviceFishPond, nil
+}
+
+// Update the specified env monitor device fish pond in the data access object.
+func (a *EnvMonitorDeviceFishPond) Update(ctx context.Context, id string, formItem *schema.EnvMonitorDeviceFishPondForm) error {
+	envMonitorDeviceFishPond, err := a.EnvMonitorDeviceFishPondDAL.Get(ctx, id)
+	if err != nil {
+		return err
+	} else if envMonitorDeviceFishPond == nil {
+		return errors.NotFound("", "Env monitor device fish pond not found")
+	}
+
+	if err := formItem.FillTo(envMonitorDeviceFishPond); err != nil {
+		return err
+	}
+	envMonitorDeviceFishPond.UpdatedAt = time.Now()
+
+	return a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceFishPondDAL.Update(ctx, envMonitorDeviceFishPond); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+// Delete the specified env monitor device fish pond from the data access object.
+func (a *EnvMonitorDeviceFishPond) Delete(ctx context.Context, id string) error {
+	exists, err := a.EnvMonitorDeviceFishPondDAL.Exists(ctx, id)
+	if err != nil {
+		return err
+	} else if !exists {
+		return errors.NotFound("", "Env monitor device fish pond not found")
+	}
+
+	return a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceFishPondDAL.Delete(ctx, id); err != nil {
+			return err
+		}
+		return nil
+	})
+}

internal/mods/envmonitor/biz/env_monitor_device_type_info.biz.go

@@ -0,0 +1,107 @@
+package biz
+
+import (
+	"context"
+	"time"
+
+	"ifms/internal/mods/envmonitor/dal"
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/errors"
+	"ifms/pkg/util"
+)
+
+// 环境监测设备类型信息
+type EnvMonitorDeviceTypeInfo struct {
+	Trans                       *util.Trans
+	EnvMonitorDeviceTypeInfoDAL *dal.EnvMonitorDeviceTypeInfo
+}
+
+// Query env monitor device type infos from the data access object based on the provided parameters and options.
+func (a *EnvMonitorDeviceTypeInfo) Query(ctx context.Context, params schema.EnvMonitorDeviceTypeInfoQueryParam) (*schema.EnvMonitorDeviceTypeInfoQueryResult, error) {
+	params.Pagination = true
+
+	result, err := a.EnvMonitorDeviceTypeInfoDAL.Query(ctx, params, schema.EnvMonitorDeviceTypeInfoQueryOptions{
+		QueryOptions: util.QueryOptions{
+			OrderFields: []util.OrderByParam{
+				{Field: "created_at", Direction: util.DESC},
+			},
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+// Get the specified env monitor device type info from the data access object.
+func (a *EnvMonitorDeviceTypeInfo) Get(ctx context.Context, id string) (*schema.EnvMonitorDeviceTypeInfo, error) {
+	envMonitorDeviceTypeInfo, err := a.EnvMonitorDeviceTypeInfoDAL.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	} else if envMonitorDeviceTypeInfo == nil {
+		return nil, errors.NotFound("", "Env monitor device type info not found")
+	}
+	return envMonitorDeviceTypeInfo, nil
+}
+
+// Create a new env monitor device type info in the data access object.
+func (a *EnvMonitorDeviceTypeInfo) Create(ctx context.Context, formItem *schema.EnvMonitorDeviceTypeInfoForm) (*schema.EnvMonitorDeviceTypeInfo, error) {
+	envMonitorDeviceTypeInfo := &schema.EnvMonitorDeviceTypeInfo{
+		ID:        util.NewXID(),
+		CreatedAt: time.Now(),
+	}
+
+	if err := formItem.FillTo(envMonitorDeviceTypeInfo); err != nil {
+		return nil, err
+	}
+
+	err := a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceTypeInfoDAL.Create(ctx, envMonitorDeviceTypeInfo); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return envMonitorDeviceTypeInfo, nil
+}
+
+// Update the specified env monitor device type info in the data access object.
+func (a *EnvMonitorDeviceTypeInfo) Update(ctx context.Context, id string, formItem *schema.EnvMonitorDeviceTypeInfoForm) error {
+	envMonitorDeviceTypeInfo, err := a.EnvMonitorDeviceTypeInfoDAL.Get(ctx, id)
+	if err != nil {
+		return err
+	} else if envMonitorDeviceTypeInfo == nil {
+		return errors.NotFound("", "Env monitor device type info not found")
+	}
+
+	if err := formItem.FillTo(envMonitorDeviceTypeInfo); err != nil {
+		return err
+	}
+	envMonitorDeviceTypeInfo.UpdatedAt = time.Now()
+
+	return a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceTypeInfoDAL.Update(ctx, envMonitorDeviceTypeInfo); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+// Delete the specified env monitor device type info from the data access object.
+func (a *EnvMonitorDeviceTypeInfo) Delete(ctx context.Context, id string) error {
+	exists, err := a.EnvMonitorDeviceTypeInfoDAL.Exists(ctx, id)
+	if err != nil {
+		return err
+	} else if !exists {
+		return errors.NotFound("", "Env monitor device type info not found")
+	}
+
+	return a.Trans.Exec(ctx, func(ctx context.Context) error {
+		if err := a.EnvMonitorDeviceTypeInfoDAL.Delete(ctx, id); err != nil {
+			return err
+		}
+		return nil
+	})
+}

internal/mods/envmonitor/dal/env_monitor_device.dal.go

@@ -0,0 +1,84 @@
+package dal
+
+import (
+	"context"
+
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/errors"
+	"ifms/pkg/util"
+
+	"gorm.io/gorm"
+)
+
+// Get env monitor device storage instance
+func GetEnvMonitorDeviceDB(ctx context.Context, defDB *gorm.DB) *gorm.DB {
+	return util.GetDB(ctx, defDB).Model(new(schema.EnvMonitorDevice))
+}
+
+// 环境监测设备管理
+type EnvMonitorDevice struct {
+	DB *gorm.DB
+}
+
+// Query env monitor devices from the database based on the provided parameters and options.
+func (a *EnvMonitorDevice) Query(ctx context.Context, params schema.EnvMonitorDeviceQueryParam, opts ...schema.EnvMonitorDeviceQueryOptions) (*schema.EnvMonitorDeviceQueryResult, error) {
+	var opt schema.EnvMonitorDeviceQueryOptions
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	db := GetEnvMonitorDeviceDB(ctx, a.DB)
+
+	var list schema.EnvMonitorDevices
+	pageResult, err := util.WrapPageQuery(ctx, db, params.PaginationParam, opt.QueryOptions, &list)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	queryResult := &schema.EnvMonitorDeviceQueryResult{
+		PageResult: pageResult,
+		Data:       list,
+	}
+	return queryResult, nil
+}
+
+// Get the specified env monitor device from the database.
+func (a *EnvMonitorDevice) Get(ctx context.Context, id string, opts ...schema.EnvMonitorDeviceQueryOptions) (*schema.EnvMonitorDevice, error) {
+	var opt schema.EnvMonitorDeviceQueryOptions
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	item := new(schema.EnvMonitorDevice)
+	ok, err := util.FindOne(ctx, GetEnvMonitorDeviceDB(ctx, a.DB).Where("id=?", id), opt.QueryOptions, item)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	} else if !ok {
+		return nil, nil
+	}
+	return item, nil
+}
+
+// Exists checks if the specified env monitor device exists in the database.
+func (a *EnvMonitorDevice) Exists(ctx context.Context, id string) (bool, error) {
+	ok, err := util.Exists(ctx, GetEnvMonitorDeviceDB(ctx, a.DB).Where("id=?", id))
+	return ok, errors.WithStack(err)
+}
+
+// Create a new env monitor device.
+func (a *EnvMonitorDevice) Create(ctx context.Context, item *schema.EnvMonitorDevice) error {
+	result := GetEnvMonitorDeviceDB(ctx, a.DB).Create(item)
+	return errors.WithStack(result.Error)
+}
+
+// Update the specified env monitor device in the database.
+func (a *EnvMonitorDevice) Update(ctx context.Context, item *schema.EnvMonitorDevice) error {
+	result := GetEnvMonitorDeviceDB(ctx, a.DB).Where("id=?", item.ID).Select("*").Omit("created_at").Updates(item)
+	return errors.WithStack(result.Error)
+}
+
+// Delete the specified env monitor device from the database.
+func (a *EnvMonitorDevice) Delete(ctx context.Context, id string) error {
+	result := GetEnvMonitorDeviceDB(ctx, a.DB).Where("id=?", id).Delete(new(schema.EnvMonitorDevice))
+	return errors.WithStack(result.Error)
+}

internal/mods/envmonitor/dal/env_monitor_device_fish_pond.dal.go

@@ -0,0 +1,84 @@
+package dal
+
+import (
+	"context"
+
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/errors"
+	"ifms/pkg/util"
+
+	"gorm.io/gorm"
+)
+
+// Get env monitor device fish pond storage instance
+func GetEnvMonitorDeviceFishPondDB(ctx context.Context, defDB *gorm.DB) *gorm.DB {
+	return util.GetDB(ctx, defDB).Model(new(schema.EnvMonitorDeviceFishPond))
+}
+
+// 环境监测设备-鱼池关联表
+type EnvMonitorDeviceFishPond struct {
+	DB *gorm.DB
+}
+
+// Query env monitor device fish ponds from the database based on the provided parameters and options.
+func (a *EnvMonitorDeviceFishPond) Query(ctx context.Context, params schema.EnvMonitorDeviceFishPondQueryParam, opts ...schema.EnvMonitorDeviceFishPondQueryOptions) (*schema.EnvMonitorDeviceFishPondQueryResult, error) {
+	var opt schema.EnvMonitorDeviceFishPondQueryOptions
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	db := GetEnvMonitorDeviceFishPondDB(ctx, a.DB)
+
+	var list schema.EnvMonitorDeviceFishPonds
+	pageResult, err := util.WrapPageQuery(ctx, db, params.PaginationParam, opt.QueryOptions, &list)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	queryResult := &schema.EnvMonitorDeviceFishPondQueryResult{
+		PageResult: pageResult,
+		Data:       list,
+	}
+	return queryResult, nil
+}
+
+// Get the specified env monitor device fish pond from the database.
+func (a *EnvMonitorDeviceFishPond) Get(ctx context.Context, id string, opts ...schema.EnvMonitorDeviceFishPondQueryOptions) (*schema.EnvMonitorDeviceFishPond, error) {
+	var opt schema.EnvMonitorDeviceFishPondQueryOptions
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	item := new(schema.EnvMonitorDeviceFishPond)
+	ok, err := util.FindOne(ctx, GetEnvMonitorDeviceFishPondDB(ctx, a.DB).Where("id=?", id), opt.QueryOptions, item)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	} else if !ok {
+		return nil, nil
+	}
+	return item, nil
+}
+
+// Exists checks if the specified env monitor device fish pond exists in the database.
+func (a *EnvMonitorDeviceFishPond) Exists(ctx context.Context, id string) (bool, error) {
+	ok, err := util.Exists(ctx, GetEnvMonitorDeviceFishPondDB(ctx, a.DB).Where("id=?", id))
+	return ok, errors.WithStack(err)
+}
+
+// Create a new env monitor device fish pond.
+func (a *EnvMonitorDeviceFishPond) Create(ctx context.Context, item *schema.EnvMonitorDeviceFishPond) error {
+	result := GetEnvMonitorDeviceFishPondDB(ctx, a.DB).Create(item)
+	return errors.WithStack(result.Error)
+}
+
+// Update the specified env monitor device fish pond in the database.
+func (a *EnvMonitorDeviceFishPond) Update(ctx context.Context, item *schema.EnvMonitorDeviceFishPond) error {
+	result := GetEnvMonitorDeviceFishPondDB(ctx, a.DB).Where("id=?", item.ID).Select("*").Omit("created_at").Updates(item)
+	return errors.WithStack(result.Error)
+}
+
+// Delete the specified env monitor device fish pond from the database.
+func (a *EnvMonitorDeviceFishPond) Delete(ctx context.Context, id string) error {
+	result := GetEnvMonitorDeviceFishPondDB(ctx, a.DB).Where("id=?", id).Delete(new(schema.EnvMonitorDeviceFishPond))
+	return errors.WithStack(result.Error)
+}

internal/mods/envmonitor/dal/env_monitor_device_type_info.dal.go

@@ -0,0 +1,84 @@
+package dal
+
+import (
+	"context"
+
+	"ifms/internal/mods/envmonitor/schema"
+	"ifms/pkg/errors"
+	"ifms/pkg/util"
+
+	"gorm.io/gorm"
+)
+
+// Get env monitor device type info storage instance
+func GetEnvMonitorDeviceTypeInfoDB(ctx context.Context, defDB *gorm.DB) *gorm.DB {
+	return util.GetDB(ctx, defDB).Model(new(schema.EnvMonitorDeviceTypeInfo))
+}
+
+// 环境监测设备类型信息
+type EnvMonitorDeviceTypeInfo struct {
+	DB *gorm.DB
+}
+
+// Query env monitor device type infos from the database based on the provided parameters and options.
+func (a *EnvMonitorDeviceTypeInfo) Query(ctx context.Context, params schema.EnvMonitorDeviceTypeInfoQueryParam, opts ...schema.EnvMonitorDeviceTypeInfoQueryOptions) (*schema.EnvMonitorDeviceTypeInfoQueryResult, error) {
+	var opt schema.EnvMonitorDeviceTypeInfoQueryOptions
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	db := GetEnvMonitorDeviceTypeInfoDB(ctx, a.DB)
+
+	var list schema.EnvMonitorDeviceTypeInfos
+	pageResult, err := util.WrapPageQuery(ctx, db, params.PaginationParam, opt.QueryOptions, &list)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	queryResult := &schema.EnvMonitorDeviceTypeInfoQueryResult{
+		PageResult: pageResult,
+		Data:       list,
+	}
+	return queryResult, nil
+}
+
+// Get the specified env monitor device type info from the database.
+func (a *EnvMonitorDeviceTypeInfo) Get(ctx context.Context, id string, opts ...schema.EnvMonitorDeviceTypeInfoQueryOptions) (*schema.EnvMonitorDeviceTypeInfo, error) {
+	var opt schema.EnvMonitorDeviceTypeInfoQueryOptions
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	item := new(schema.EnvMonitorDeviceTypeInfo)
+	ok, err := util.FindOne(ctx, GetEnvMonitorDeviceTypeInfoDB(ctx, a.DB).Where("id=?", id), opt.QueryOptions, item)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	} else if !ok {
+		return nil, nil
+	}
+	return item, nil
+}
+
+// Exists checks if the specified env monitor device type info exists in the database.
+func (a *EnvMonitorDeviceTypeInfo) Exists(ctx context.Context, id string) (bool, error) {
+	ok, err := util.Exists(ctx, GetEnvMonitorDeviceTypeInfoDB(ctx, a.DB).Where("id=?", id))
+	return ok, errors.WithStack(err)
+}
+
+// Create a new env monitor device type info.
+func (a *EnvMonitorDeviceTypeInfo) Create(ctx context.Context, item *schema.EnvMonitorDeviceTypeInfo) error {
+	result := GetEnvMonitorDeviceTypeInfoDB(ctx, a.DB).Create(item)
+	return errors.WithStack(result.Error)
+}
+
+// Update the specified env monitor device type info in the database.
+func (a *EnvMonitorDeviceTypeInfo) Update(ctx context.Context, item *schema.EnvMonitorDeviceTypeInfo) error {
+	result := GetEnvMonitorDeviceTypeInfoDB(ctx, a.DB).Where("id=?", item.ID).Select("*").Omit("created_at").Updates(item)
+	return errors.WithStack(result.Error)
+}
+
+// Delete the specified env monitor device type info from the database.
+func (a *EnvMonitorDeviceTypeInfo) Delete(ctx context.Context, id string) error {
+	result := GetEnvMonitorDeviceTypeInfoDB(ctx, a.DB).Where("id=?", id).Delete(new(schema.EnvMonitorDeviceTypeInfo))
+	return errors.WithStack(result.Error)
+}

internal/mods/envmonitor/main.go

@@ -0,0 +1,65 @@
+package envmonitor
+
+import (
+	"context"
+	"ifms/internal/config"
+
+	"ifms/internal/mods/envmonitor/api"
+	"ifms/internal/mods/envmonitor/schema"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type EnvMonitor struct {
+	DB                          *gorm.DB
+	EnvMonitorDeviceTypeInfoAPI *api.EnvMonitorDeviceTypeInfo
+	EnvMonitorDeviceAPI         *api.EnvMonitorDevice
+	EnvMonitorDeviceFishPondAPI *api.EnvMonitorDeviceFishPond
+}
+
+func (a *EnvMonitor) AutoMigrate(ctx context.Context) error {
+	return a.DB.AutoMigrate(new(schema.EnvMonitorDeviceTypeInfo), new(schema.EnvMonitorDevice), new(schema.EnvMonitorDeviceFishPond))
+}
+
+func (a *EnvMonitor) Init(ctx context.Context) error {
+	if config.C.Storage.DB.AutoMigrate {
+		if err := a.AutoMigrate(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (a *EnvMonitor) RegisterV1Routers(ctx context.Context, v1 *gin.RouterGroup) error {
+	v1 = v1.Group("envmonitor")
+	envMonitorDeviceTypeInfo := v1.Group("env-monitor-device-type-infos")
+	{
+		envMonitorDeviceTypeInfo.GET("", a.EnvMonitorDeviceTypeInfoAPI.Query)
+		envMonitorDeviceTypeInfo.GET(":id", a.EnvMonitorDeviceTypeInfoAPI.Get)
+		envMonitorDeviceTypeInfo.POST("", a.EnvMonitorDeviceTypeInfoAPI.Create)
+		envMonitorDeviceTypeInfo.PUT(":id", a.EnvMonitorDeviceTypeInfoAPI.Update)
+		envMonitorDeviceTypeInfo.DELETE(":id", a.EnvMonitorDeviceTypeInfoAPI.Delete)
+	}
+	envMonitorDevice := v1.Group("env-monitor-devices")
+	{
+		envMonitorDevice.GET("", a.EnvMonitorDeviceAPI.Query)
+		envMonitorDevice.GET(":id", a.EnvMonitorDeviceAPI.Get)
+		envMonitorDevice.POST("", a.EnvMonitorDeviceAPI.Create)
+		envMonitorDevice.PUT(":id", a.EnvMonitorDeviceAPI.Update)
+		envMonitorDevice.DELETE(":id", a.EnvMonitorDeviceAPI.Delete)
+	}
+	envMonitorDeviceFishPond := v1.Group("env-monitor-device-fish-ponds")
+	{
+		envMonitorDeviceFishPond.GET("", a.EnvMonitorDeviceFishPondAPI.Query)
+		envMonitorDeviceFishPond.GET(":id", a.EnvMonitorDeviceFishPondAPI.Get)
+		envMonitorDeviceFishPond.POST("", a.EnvMonitorDeviceFishPondAPI.Create)
+		envMonitorDeviceFishPond.PUT(":id", a.EnvMonitorDeviceFishPondAPI.Update)
+		envMonitorDeviceFishPond.DELETE(":id", a.EnvMonitorDeviceFishPondAPI.Delete)
+	}
+	return nil
+}
+
+func (a *EnvMonitor) Release(ctx context.Context) error {
+	return nil
+}

internal/mods/envmonitor/schema/env_monitor_device.go

@@ -0,0 +1,65 @@
+package schema
+
+import (
+	"time"
+
+	"ifms/pkg/util"
+)
+
+// 环境监测设备管理
+type EnvMonitorDevice struct {
+	ID         string    `json:"id" gorm:"size:20;primaryKey;comment:Unique ID;"`                             // Unique ID
+	DeviceNo   string    `json:"device_no" gorm:"size:32;uniqueIndex;comment:环境监测编号;"`                        // 环境监测编号
+	Name       string    `json:"name" gorm:"size:64;comment:环境监测名称;"`                                         // 环境监测名称
+	Type       int       `json:"type" gorm:"comment:环境监测设备类型（1水质监测仪、2水下视频监控、3车间视频监控）;"`                       // 环境监测设备类型（1水质监测仪、2水下视频监控、3车间视频监控）
+	Status     bool      `json:"status" gorm:"comment:环境监测设备状态（true=在线，false=离线）;"`                           // 环境监测设备状态（true=在线，false=离线）
+	Model      string    `json:"model" gorm:"size:64;comment:环境监测设备型号;"`                                      // 环境监测设备型号
+	WorkshopID int64     `json:"workshop_id" gorm:"index;foreignKey:ID;references:work_shop;comment:关联车间ID;"` // 关联车间ID
+	CreatedAt  time.Time `json:"created_at" gorm:"index;comment:Create time;"`                                // Create time
+	UpdatedAt  time.Time `json:"updated_at" gorm:"index;comment:Update time;"`                                // Update time
+}
+
+// Defining the query parameters for the `EnvMonitorDevice` struct.
+type EnvMonitorDeviceQueryParam struct {
+	util.PaginationParam
+}
+
+// Defining the query options for the `EnvMonitorDevice` struct.
+type EnvMonitorDeviceQueryOptions struct {
+	util.QueryOptions
+}
+
+// Defining the query result for the `EnvMonitorDevice` struct.
+type EnvMonitorDeviceQueryResult struct {
+	Data       EnvMonitorDevices
+	PageResult *util.PaginationResult
+}
+
+// Defining the slice of `EnvMonitorDevice` struct.
+type EnvMonitorDevices []*EnvMonitorDevice
+
+// Defining the data structure for creating a `EnvMonitorDevice` struct.
+type EnvMonitorDeviceForm struct {
+	DeviceNo   string `json:"device_no" binding:"required,max=32"` // 环境监测编号
+	Name       string `json:"name" binding:"required,max=64"`      // 环境监测名称
+	Type       int    `json:"type" binding:"required"`             // 环境监测设备类型（1水质监测仪、2水下视频监控、3车间视频监控）
+	Status     bool   `json:"status" binding:"required"`           // 环境监测设备状态（true=在线，false=离线）
+	Model      string `json:"model" binding:"required,max=64"`     // 环境监测设备型号
+	WorkshopID int64  `json:"workshop_id" binding:"required"`      // 关联车间ID
+}
+
+// A validation function for the `EnvMonitorDeviceForm` struct.
+func (a *EnvMonitorDeviceForm) Validate() error {
+	return nil
+}
+
+// Convert `EnvMonitorDeviceForm` to `EnvMonitorDevice` object.
+func (a *EnvMonitorDeviceForm) FillTo(envMonitorDevice *EnvMonitorDevice) error {
+	envMonitorDevice.DeviceNo = a.DeviceNo
+	envMonitorDevice.Name = a.Name
+	envMonitorDevice.Type = a.Type
+	envMonitorDevice.Status = a.Status
+	envMonitorDevice.Model = a.Model
+	envMonitorDevice.WorkshopID = a.WorkshopID
+	return nil
+}

internal/mods/envmonitor/schema/env_monitor_device_fish_pond.go

@@ -0,0 +1,53 @@
+package schema
+
+import (
+	"time"
+
+	"ifms/pkg/util"
+)
+
+// 环境监测设备-鱼池关联表
+type EnvMonitorDeviceFishPond struct {
+	ID         string    `json:"id" gorm:"size:20;primaryKey;comment:Unique ID;"`                            // Unique ID
+	DeviceID   int64     `json:"device_id" gorm:"index;foreignKey:ID;references:device;comment:环境监测设备ID;"`   // 环境监测设备ID
+	FishPondID int64     `json:"fish_pond_id" gorm:"index;foreignKey:ID;references:fish_pond;comment:鱼池ID;"` // 鱼池ID
+	CreatedAt  time.Time `json:"created_at" gorm:"index;comment:Create time;"`                               // Create time
+	UpdatedAt  time.Time `json:"updated_at" gorm:"index;comment:Update time;"`                               // Update time
+}
+
+// Defining the query parameters for the `EnvMonitorDeviceFishPond` struct.
+type EnvMonitorDeviceFishPondQueryParam struct {
+	util.PaginationParam
+}
+
+// Defining the query options for the `EnvMonitorDeviceFishPond` struct.
+type EnvMonitorDeviceFishPondQueryOptions struct {
+	util.QueryOptions
+}
+
+// Defining the query result for the `EnvMonitorDeviceFishPond` struct.
+type EnvMonitorDeviceFishPondQueryResult struct {
+	Data       EnvMonitorDeviceFishPonds
+	PageResult *util.PaginationResult
+}
+
+// Defining the slice of `EnvMonitorDeviceFishPond` struct.
+type EnvMonitorDeviceFishPonds []*EnvMonitorDeviceFishPond
+
+// Defining the data structure for creating a `EnvMonitorDeviceFishPond` struct.
+type EnvMonitorDeviceFishPondForm struct {
+	DeviceID   int64 `json:"device_id" binding:"required"`    // 环境监测设备ID
+	FishPondID int64 `json:"fish_pond_id" binding:"required"` // 鱼池ID
+}
+
+// A validation function for the `EnvMonitorDeviceFishPondForm` struct.
+func (a *EnvMonitorDeviceFishPondForm) Validate() error {
+	return nil
+}
+
+// Convert `EnvMonitorDeviceFishPondForm` to `EnvMonitorDeviceFishPond` object.
+func (a *EnvMonitorDeviceFishPondForm) FillTo(envMonitorDeviceFishPond *EnvMonitorDeviceFishPond) error {
+	envMonitorDeviceFishPond.DeviceID = a.DeviceID
+	envMonitorDeviceFishPond.FishPondID = a.FishPondID
+	return nil
+}

internal/mods/envmonitor/schema/env_monitor_device_type_info.go

@@ -0,0 +1,62 @@
+package schema
+
+import (
+	"time"
+
+	"ifms/pkg/util"
+)
+
+// 环境监测设备类型信息
+type EnvMonitorDeviceTypeInfo struct {
+	ID          string    `json:"id" gorm:"size:20;primaryKey;comment:Unique ID;"`       // Unique ID
+	Type        int       `json:"type" gorm:"comment:环境监测设备类型（1水质监测仪、2水下视频监控、3车间视频监控）;"` // 环境监测设备类型（1水质监测仪、2水下视频监控、3车间视频监控）
+	Model       string    `json:"model" gorm:"size:255;comment:设备型号;"`                   // 设备型号
+	Supplier    string    `json:"supplier" gorm:"size:255;comment:供应商;"`                 // 供应商
+	Pic         string    `json:"pic" gorm:"type:text;comment:图片地址;"`                    // 图片地址
+	Description string    `json:"description" gorm:"type:text;comment:简介;"`              // 简介
+	CreatedAt   time.Time `json:"created_at" gorm:"index;comment:Create time;"`          // Create time
+	UpdatedAt   time.Time `json:"updated_at" gorm:"index;comment:Update time;"`          // Update time
+}
+
+// Defining the query parameters for the `EnvMonitorDeviceTypeInfo` struct.
+type EnvMonitorDeviceTypeInfoQueryParam struct {
+	util.PaginationParam
+}
+
+// Defining the query options for the `EnvMonitorDeviceTypeInfo` struct.
+type EnvMonitorDeviceTypeInfoQueryOptions struct {
+	util.QueryOptions
+}
+
+// Defining the query result for the `EnvMonitorDeviceTypeInfo` struct.
+type EnvMonitorDeviceTypeInfoQueryResult struct {
+	Data       EnvMonitorDeviceTypeInfos
+	PageResult *util.PaginationResult
+}
+
+// Defining the slice of `EnvMonitorDeviceTypeInfo` struct.
+type EnvMonitorDeviceTypeInfos []*EnvMonitorDeviceTypeInfo
+
+// Defining the data structure for creating a `EnvMonitorDeviceTypeInfo` struct.
+type EnvMonitorDeviceTypeInfoForm struct {
+	Type        int    `json:"type" binding:"required"`             // 环境监测设备类型（1水质监测仪、2水下视频监控、3车间视频监控）
+	Model       string `json:"model" binding:"required,max=255"`    // 设备型号
+	Supplier    string `json:"supplier" binding:"required,max=255"` // 供应商
+	Pic         string `json:"pic" binding:"required"`              // 图片地址
+	Description string `json:"description" binding:"required"`      // 简介
+}
+
+// A validation function for the `EnvMonitorDeviceTypeInfoForm` struct.
+func (a *EnvMonitorDeviceTypeInfoForm) Validate() error {
+	return nil
+}
+
+// Convert `EnvMonitorDeviceTypeInfoForm` to `EnvMonitorDeviceTypeInfo` object.
+func (a *EnvMonitorDeviceTypeInfoForm) FillTo(envMonitorDeviceTypeInfo *EnvMonitorDeviceTypeInfo) error {
+	envMonitorDeviceTypeInfo.Type = a.Type
+	envMonitorDeviceTypeInfo.Model = a.Model
+	envMonitorDeviceTypeInfo.Supplier = a.Supplier
+	envMonitorDeviceTypeInfo.Pic = a.Pic
+	envMonitorDeviceTypeInfo.Description = a.Description
+	return nil
+}

internal/mods/envmonitor/wire.go

@@ -0,0 +1,22 @@
+package envmonitor
+
+import (
+	"ifms/internal/mods/envmonitor/api"
+	"ifms/internal/mods/envmonitor/biz"
+	"ifms/internal/mods/envmonitor/dal"
+
+	"github.com/google/wire"
+)
+
+var Set = wire.NewSet(
+	wire.Struct(new(EnvMonitor), "*"),
+	wire.Struct(new(dal.EnvMonitorDeviceTypeInfo), "*"),
+	wire.Struct(new(biz.EnvMonitorDeviceTypeInfo), "*"),
+	wire.Struct(new(api.EnvMonitorDeviceTypeInfo), "*"),
+	wire.Struct(new(dal.EnvMonitorDevice), "*"),
+	wire.Struct(new(biz.EnvMonitorDevice), "*"),
+	wire.Struct(new(api.EnvMonitorDevice), "*"),
+	wire.Struct(new(dal.EnvMonitorDeviceFishPond), "*"),
+	wire.Struct(new(biz.EnvMonitorDeviceFishPond), "*"),
+	wire.Struct(new(api.EnvMonitorDeviceFishPond), "*"),
+)

internal/mods/mods.go

@@ -8,6 +8,8 @@ import (
 
 	"ifms/internal/mods/autocontrol"
 
+	"ifms/internal/mods/envmonitor"
+
 	"github.com/gin-gonic/gin"
 	"github.com/google/wire"
 )
@@ -22,12 +24,14 @@ var Set = wire.NewSet(
 	rbac.Set,
 	digital.Set,
 	autocontrol.Set,
+	envmonitor.Set,
 )
 
 type Mods struct {
 	RBAC        *rbac.RBAC
 	DIGITAL     *digital.DIGITAL
 	AutoControl *autocontrol.AutoControl
+	EnvMonitor  *envmonitor.EnvMonitor
 }
 
 func (a *Mods) Init(ctx context.Context) error {
@@ -40,6 +44,9 @@ func (a *Mods) Init(ctx context.Context) error {
 	if err := a.AutoControl.Init(ctx); err != nil {
 		return err
 	}
+	if err := a.EnvMonitor.Init(ctx); err != nil {
+		return err
+	}
 
 	return nil
 }
@@ -63,6 +70,9 @@ func (a *Mods) RegisterRouters(ctx context.Context, e *gin.Engine) error {
 	if err := a.AutoControl.RegisterV1Routers(ctx, v1); err != nil {
 		return err
 	}
+	if err := a.EnvMonitor.RegisterV1Routers(ctx, v1); err != nil {
+		return err
+	}
 
 	return nil
 }
@@ -78,6 +88,14 @@ func (a *Mods) Release(ctx context.Context) error {
 		ctx); err != nil {
 		return err
 	}
+	if err := a.EnvMonitor.
+		Release(ctx); err != nil {
+		return err
+	}
+	if err := a.EnvMonitor.
+		Release(ctx); err != nil {
+		return err
+	}
 
 	return nil
 }

internal/wirex/wire_gen.go

@@ -17,6 +17,10 @@ import (
 	api2 "ifms/internal/mods/digital/api"
 	biz2 "ifms/internal/mods/digital/biz"
 	dal2 "ifms/internal/mods/digital/dal"
+	"ifms/internal/mods/envmonitor"
+	api4 "ifms/internal/mods/envmonitor/api"
+	biz4 "ifms/internal/mods/envmonitor/biz"
+	dal4 "ifms/internal/mods/envmonitor/dal"
 	"ifms/internal/mods/rbac"
 	"ifms/internal/mods/rbac/api"
 	"ifms/internal/mods/rbac/biz"
@@ -200,10 +204,47 @@ func BuildInjector(ctx context.Context) (*Injector, func(), error) {
 		DeviceFishPondAPI:   apiDeviceFishPond,
 		DeviceTypeInfoAPI:   apiDeviceTypeInfo,
 	}
+	envMonitorDeviceTypeInfo := &dal4.EnvMonitorDeviceTypeInfo{
+		DB: db,
+	}
+	bizEnvMonitorDeviceTypeInfo := &biz4.EnvMonitorDeviceTypeInfo{
+		Trans:                       trans,
+		EnvMonitorDeviceTypeInfoDAL: envMonitorDeviceTypeInfo,
+	}
+	apiEnvMonitorDeviceTypeInfo := &api4.EnvMonitorDeviceTypeInfo{
+		EnvMonitorDeviceTypeInfoBIZ: bizEnvMonitorDeviceTypeInfo,
+	}
+	envMonitorDevice := &dal4.EnvMonitorDevice{
+		DB: db,
+	}
+	bizEnvMonitorDevice := &biz4.EnvMonitorDevice{
+		Trans:               trans,
+		EnvMonitorDeviceDAL: envMonitorDevice,
+	}
+	apiEnvMonitorDevice := &api4.EnvMonitorDevice{
+		EnvMonitorDeviceBIZ: bizEnvMonitorDevice,
+	}
+	envMonitorDeviceFishPond := &dal4.EnvMonitorDeviceFishPond{
+		DB: db,
+	}
+	bizEnvMonitorDeviceFishPond := &biz4.EnvMonitorDeviceFishPond{
+		Trans:                       trans,
+		EnvMonitorDeviceFishPondDAL: envMonitorDeviceFishPond,
+	}
+	apiEnvMonitorDeviceFishPond := &api4.EnvMonitorDeviceFishPond{
+		EnvMonitorDeviceFishPondBIZ: bizEnvMonitorDeviceFishPond,
+	}
+	envMonitor := &envmonitor.EnvMonitor{
+		DB:                          db,
+		EnvMonitorDeviceTypeInfoAPI: apiEnvMonitorDeviceTypeInfo,
+		EnvMonitorDeviceAPI:         apiEnvMonitorDevice,
+		EnvMonitorDeviceFishPondAPI: apiEnvMonitorDeviceFishPond,
+	}
 	modsMods := &mods.Mods{
 		RBAC:        rbacRBAC,
 		DIGITAL:     digitalDIGITAL,
 		AutoControl: autoControl,
+		EnvMonitor:  envMonitor,
 	}
 	injector := &Injector{
 		DB:    db,