jiangyq
/
YZProjectCloud
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

塔基检测配置开发

dev_xd
haha 2025-03-19 21:59:22 +08:00
parent 002abc4774
commit 04213e6d91
31 changed files with 2646 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
yanzhu-common/yanzhu-common-core/src/main/java/com/yanzhu/common/core/web/domain/BaseEntity.java
View File

@ -62,6 +62,16 @@ public class BaseEntity implements Serializable
/** 数据来源 */
private String dataSource;
private String activeName;
public String getActiveName() {
return activeName;
}
public void setActiveName(String activeName) {
this.activeName = activeName;
}
/** 请求参数 */
@JsonInclude(JsonInclude.Include.NON_EMPTY)
private Map<String, Object> params;

2
yanzhu-common/yanzhu-common-mapper/src/main/resources/mapper/device/DevTowerProjectConfigMapper.xml
View File

@ -76,7 +76,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="projectName != null and projectName != ''"> and sp.projectName like concat('%', #{projectName}, '%')</if>
<if test="comId != null "> and dtpc.com_id = #{comId}</if>
<if test="comName != null and comName != ''"> and sd.dept_name like concat('%', #{comName}, '%')</if>
<if test="deviceSn != null and deviceSn != ''"> and dtpc.device_sn = #{deviceSn}</if>
<if test="deviceSn != null and deviceSn != ''"> and dtpc.device_sn like concat('%', #{deviceSn}, '%')</if>
<if test="deviceName != null and deviceName != ''"> and dtpc.device_name like concat('%', #{deviceName}, '%')</if>
<if test="deviceSource != null and deviceSource != ''"> and dtpc.device_source = #{deviceSource}</if>
<if test="towerId != null and towerId != ''"> and dtpc.tower_id = #{towerId}</if>

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/controller/device/DevTowerDataCollideController.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.controller.device;
import com.yanzhu.common.core.utils.poi.ExcelUtil;
import com.yanzhu.common.core.web.controller.BaseController;
import com.yanzhu.common.core.web.domain.AjaxResult;
import com.yanzhu.common.core.web.page.TableDataInfo;
import com.yanzhu.common.log.enums.BusinessType;
import com.yanzhu.common.security.annotation.RequiresPermissions;
import com.yanzhu.device.domain.DevTowerDataCollide;
import com.yanzhu.manage.service.IDevTowerDataCollideService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.yanzhu.common.log.annotation.Log;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 塔机碰撞信息Controller
*
* @author JiangYuQi
* @date 2024-08-04
*/
@RestController
@RequestMapping("/device/towerDataCollide")
public class DevTowerDataCollideController extends BaseController
{
@Autowired
private IDevTowerDataCollideService devTowerDataCollideService;
/**
* 查询塔机碰撞信息列表
*/
@RequiresPermissions("device:towerDataCollide:list")
@GetMapping("/list")
public TableDataInfo list(DevTowerDataCollide devTowerDataCollide)
{
startPage();
List<DevTowerDataCollide> list = devTowerDataCollideService.selectDevTowerDataCollideList(devTowerDataCollide);
return getDataTable(list);
}
/**
* 导出塔机碰撞信息列表
*/
@RequiresPermissions("device:towerDataCollide:export")
@Log(title = "塔机碰撞信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, DevTowerDataCollide devTowerDataCollide)
{
List<DevTowerDataCollide> list = devTowerDataCollideService.selectDevTowerDataCollideList(devTowerDataCollide);
ExcelUtil<DevTowerDataCollide> util = new ExcelUtil<DevTowerDataCollide>(DevTowerDataCollide.class);
util.exportExcel(response, list, "塔机碰撞信息数据");
}
/**
* 获取塔机碰撞信息详细信息
*/
@RequiresPermissions("device:towerDataCollide:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(devTowerDataCollideService.selectDevTowerDataCollideById(id));
}
/**
* 新增塔机碰撞信息
*/
@RequiresPermissions("device:towerDataCollide:add")
@Log(title = "塔机碰撞信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody DevTowerDataCollide devTowerDataCollide)
{
return toAjax(devTowerDataCollideService.insertDevTowerDataCollide(devTowerDataCollide));
}
/**
* 修改塔机碰撞信息
*/
@RequiresPermissions("device:towerDataCollide:edit")
@Log(title = "塔机碰撞信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody DevTowerDataCollide devTowerDataCollide)
{
return toAjax(devTowerDataCollideService.updateDevTowerDataCollide(devTowerDataCollide));
}
/**
* 删除塔机碰撞信息
*/
@RequiresPermissions("device:towerDataCollide:remove")
@Log(title = "塔机碰撞信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(devTowerDataCollideService.deleteDevTowerDataCollideByIds(ids));
}
}

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/controller/device/DevTowerDataLimitController.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.controller.device;
import com.yanzhu.common.core.utils.poi.ExcelUtil;
import com.yanzhu.common.core.web.controller.BaseController;
import com.yanzhu.common.core.web.domain.AjaxResult;
import com.yanzhu.common.core.web.page.TableDataInfo;
import com.yanzhu.common.log.annotation.Log;
import com.yanzhu.common.log.enums.BusinessType;
import com.yanzhu.common.security.annotation.RequiresPermissions;
import com.yanzhu.device.domain.DevTowerDataLimit;
import com.yanzhu.manage.service.IDevTowerDataLimitService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 塔机限位信息Controller
*
* @author JiangYuQi
* @date 2024-08-04
*/
@RestController
@RequestMapping("/device/towerDataLimit")
public class DevTowerDataLimitController extends BaseController
{
@Autowired
private IDevTowerDataLimitService devTowerDataLimitService;
/**
* 查询塔机限位信息列表
*/
@RequiresPermissions("device:towerDataLimit:list")
@GetMapping("/list")
public TableDataInfo list(DevTowerDataLimit devTowerDataLimit)
{
startPage();
List<DevTowerDataLimit> list = devTowerDataLimitService.selectDevTowerDataLimitList(devTowerDataLimit);
return getDataTable(list);
}
/**
* 导出塔机限位信息列表
*/
@RequiresPermissions("device:towerDataLimit:export")
@Log(title = "塔机限位信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, DevTowerDataLimit devTowerDataLimit)
{
List<DevTowerDataLimit> list = devTowerDataLimitService.selectDevTowerDataLimitList(devTowerDataLimit);
ExcelUtil<DevTowerDataLimit> util = new ExcelUtil<DevTowerDataLimit>(DevTowerDataLimit.class);
util.exportExcel(response, list, "塔机限位信息数据");
}
/**
* 获取塔机限位信息详细信息
*/
@RequiresPermissions("device:towerDataLimit:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(devTowerDataLimitService.selectDevTowerDataLimitById(id));
}
/**
* 新增塔机限位信息
*/
@RequiresPermissions("device:towerDataLimit:add")
@Log(title = "塔机限位信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody DevTowerDataLimit devTowerDataLimit)
{
return toAjax(devTowerDataLimitService.insertDevTowerDataLimit(devTowerDataLimit));
}
/**
* 修改塔机限位信息
*/
@RequiresPermissions("device:towerDataLimit:edit")
@Log(title = "塔机限位信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody DevTowerDataLimit devTowerDataLimit)
{
return toAjax(devTowerDataLimitService.updateDevTowerDataLimit(devTowerDataLimit));
}
/**
* 删除塔机限位信息
*/
@RequiresPermissions("device:towerDataLimit:remove")
@Log(title = "塔机限位信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(devTowerDataLimitService.deleteDevTowerDataLimitByIds(ids));
}
}

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/controller/device/DevTowerDataLocalController.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.controller.device;
import com.yanzhu.common.core.utils.poi.ExcelUtil;
import com.yanzhu.common.core.web.controller.BaseController;
import com.yanzhu.common.core.web.domain.AjaxResult;
import com.yanzhu.common.core.web.page.TableDataInfo;
import com.yanzhu.common.log.annotation.Log;
import com.yanzhu.common.log.enums.BusinessType;
import com.yanzhu.common.security.annotation.RequiresPermissions;
import com.yanzhu.device.domain.DevTowerDataLocal;
import com.yanzhu.manage.service.IDevTowerDataLocalService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 塔机定位信息Controller
*
* @author JiangYuQi
* @date 2024-08-04
*/
@RestController
@RequestMapping("/device/towerDataLocal")
public class DevTowerDataLocalController extends BaseController
{
@Autowired
private IDevTowerDataLocalService devTowerDataLocalService;
/**
* 查询塔机定位信息列表
*/
@RequiresPermissions("device:towerDataLocal:list")
@GetMapping("/list")
public TableDataInfo list(DevTowerDataLocal devTowerDataLocal)
{
startPage();
List<DevTowerDataLocal> list = devTowerDataLocalService.selectDevTowerDataLocalList(devTowerDataLocal);
return getDataTable(list);
}
/**
* 导出塔机定位信息列表
*/
@RequiresPermissions("device:towerDataLocal:export")
@Log(title = "塔机定位信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, DevTowerDataLocal devTowerDataLocal)
{
List<DevTowerDataLocal> list = devTowerDataLocalService.selectDevTowerDataLocalList(devTowerDataLocal);
ExcelUtil<DevTowerDataLocal> util = new ExcelUtil<DevTowerDataLocal>(DevTowerDataLocal.class);
util.exportExcel(response, list, "塔机定位信息数据");
}
/**
* 获取塔机定位信息详细信息
*/
@RequiresPermissions("device:towerDataLocal:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(devTowerDataLocalService.selectDevTowerDataLocalById(id));
}
/**
* 新增塔机定位信息
*/
@RequiresPermissions("device:towerDataLocal:add")
@Log(title = "塔机定位信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody DevTowerDataLocal devTowerDataLocal)
{
return toAjax(devTowerDataLocalService.insertDevTowerDataLocal(devTowerDataLocal));
}
/**
* 修改塔机定位信息
*/
@RequiresPermissions("device:towerDataLocal:edit")
@Log(title = "塔机定位信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody DevTowerDataLocal devTowerDataLocal)
{
return toAjax(devTowerDataLocalService.updateDevTowerDataLocal(devTowerDataLocal));
}
/**
* 删除塔机定位信息
*/
@RequiresPermissions("device:towerDataLocal:remove")
@Log(title = "塔机定位信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(devTowerDataLocalService.deleteDevTowerDataLocalByIds(ids));
}
}

99
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/controller/device/DevTowerDataRoundController.java 100644
View File

@ -0,0 +1,99 @@
package com.yanzhu.manage.controller.device;
import com.yanzhu.common.core.utils.poi.ExcelUtil;
import com.yanzhu.common.core.web.controller.BaseController;
import com.yanzhu.common.core.web.domain.AjaxResult;
import com.yanzhu.common.core.web.page.TableDataInfo;
import com.yanzhu.common.log.annotation.Log;
import com.yanzhu.common.log.enums.BusinessType;
import com.yanzhu.common.security.annotation.RequiresPermissions;
import com.yanzhu.device.domain.DevTowerDataRound;
import com.yanzhu.manage.service.IDevTowerDataRoundService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 塔机工作循环Controller
*
* @author JiangYuQi
* @date 2024-08-04
*/
@RestController
@RequestMapping("/device/towerDataRound")
public class DevTowerDataRoundController extends BaseController
{
@Autowired
private IDevTowerDataRoundService devTowerDataRoundService;
/**
* 查询塔机工作循环列表
*/
@RequiresPermissions("device:towerDataRound:list")
@GetMapping("/list")
public TableDataInfo list(DevTowerDataRound devTowerDataRound)
{
startPage();
List<DevTowerDataRound> list = devTowerDataRoundService.selectDevTowerDataRoundList(devTowerDataRound);
return getDataTable(list);
}
/**
* 导出塔机工作循环列表
*/
@RequiresPermissions("device:towerDataRound:export")
@Log(title = "塔机工作循环", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, DevTowerDataRound devTowerDataRound)
{
List<DevTowerDataRound> list = devTowerDataRoundService.selectDevTowerDataRoundList(devTowerDataRound);
ExcelUtil<DevTowerDataRound> util = new ExcelUtil<DevTowerDataRound>(DevTowerDataRound.class);
util.exportExcel(response, list, "塔机工作循环数据");
}
/**
* 获取塔机工作循环详细信息
*/
@RequiresPermissions("device:towerDataRound:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(devTowerDataRoundService.selectDevTowerDataRoundById(id));
}
/**
* 新增塔机工作循环
*/
@RequiresPermissions("device:towerDataRound:add")
@Log(title = "塔机工作循环", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody DevTowerDataRound devTowerDataRound)
{
return toAjax(devTowerDataRoundService.insertDevTowerDataRound(devTowerDataRound));
}
/**
* 修改塔机工作循环
*/
@RequiresPermissions("device:towerDataRound:edit")
@Log(title = "塔机工作循环", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody DevTowerDataRound devTowerDataRound)
{
return toAjax(devTowerDataRoundService.updateDevTowerDataRound(devTowerDataRound));
}
/**
* 删除塔机工作循环
*/
@RequiresPermissions("device:towerDataRound:remove")
@Log(title = "塔机工作循环", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(devTowerDataRoundService.deleteDevTowerDataRoundByIds(ids));
}
}

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/controller/device/DevTowerDataRunController.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.controller.device;
import com.yanzhu.common.core.utils.poi.ExcelUtil;
import com.yanzhu.common.core.web.controller.BaseController;
import com.yanzhu.common.core.web.domain.AjaxResult;
import com.yanzhu.common.core.web.page.TableDataInfo;
import com.yanzhu.common.log.annotation.Log;
import com.yanzhu.common.log.enums.BusinessType;
import com.yanzhu.common.security.annotation.RequiresPermissions;
import com.yanzhu.device.domain.DevTowerDataRun;
import com.yanzhu.manage.service.IDevTowerDataRunService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 塔机实时数据Controller
*
* @author JiangYuQi
* @date 2024-08-04
*/
@RestController
@RequestMapping("/device/towerDataRun")
public class DevTowerDataRunController extends BaseController
{
@Autowired
private IDevTowerDataRunService devTowerDataRunService;
/**
* 查询塔机实时数据列表
*/
@RequiresPermissions("device:towerDataRun:list")
@GetMapping("/list")
public TableDataInfo list(DevTowerDataRun devTowerDataRun)
{
startPage();
List<DevTowerDataRun> list = devTowerDataRunService.selectDevTowerDataRunList(devTowerDataRun);
return getDataTable(list);
}
/**
* 导出塔机实时数据列表
*/
@RequiresPermissions("device:towerDataRun:export")
@Log(title = "塔机实时数据", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, DevTowerDataRun devTowerDataRun)
{
List<DevTowerDataRun> list = devTowerDataRunService.selectDevTowerDataRunList(devTowerDataRun);
ExcelUtil<DevTowerDataRun> util = new ExcelUtil<DevTowerDataRun>(DevTowerDataRun.class);
util.exportExcel(response, list, "塔机实时数据数据");
}
/**
* 获取塔机实时数据详细信息
*/
@RequiresPermissions("device:towerDataRun:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(devTowerDataRunService.selectDevTowerDataRunById(id));
}
/**
* 新增塔机实时数据
*/
@RequiresPermissions("device:towerDataRun:add")
@Log(title = "塔机实时数据", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody DevTowerDataRun devTowerDataRun)
{
return toAjax(devTowerDataRunService.insertDevTowerDataRun(devTowerDataRun));
}
/**
* 修改塔机实时数据
*/
@RequiresPermissions("device:towerDataRun:edit")
@Log(title = "塔机实时数据", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody DevTowerDataRun devTowerDataRun)
{
return toAjax(devTowerDataRunService.updateDevTowerDataRun(devTowerDataRun));
}
/**
* 删除塔机实时数据
*/
@RequiresPermissions("device:towerDataRun:remove")
@Log(title = "塔机实时数据", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(devTowerDataRunService.deleteDevTowerDataRunByIds(ids));
}
}

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/controller/device/DevTowerDataWarningController.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.controller.device;
import com.yanzhu.common.core.utils.poi.ExcelUtil;
import com.yanzhu.common.core.web.controller.BaseController;
import com.yanzhu.common.core.web.domain.AjaxResult;
import com.yanzhu.common.core.web.page.TableDataInfo;
import com.yanzhu.common.log.annotation.Log;
import com.yanzhu.common.log.enums.BusinessType;
import com.yanzhu.common.security.annotation.RequiresPermissions;
import com.yanzhu.device.domain.DevTowerDataWarning;
import com.yanzhu.manage.service.IDevTowerDataWarningService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 塔机预警管理Controller
*
* @author JiangYuQi
* @date 2024-08-04
*/
@RestController
@RequestMapping("/device/towerDataWarning")
public class DevTowerDataWarningController extends BaseController
{
@Autowired
private IDevTowerDataWarningService devTowerDataWarningService;
/**
* 查询塔机预警管理列表
*/
@RequiresPermissions("device:towerDataWarning:list")
@GetMapping("/list")
public TableDataInfo list(DevTowerDataWarning devTowerDataWarning)
{
startPage();
List<DevTowerDataWarning> list = devTowerDataWarningService.selectDevTowerDataWarningList(devTowerDataWarning);
return getDataTable(list);
}
/**
* 导出塔机预警管理列表
*/
@RequiresPermissions("device:towerDataWarning:export")
@Log(title = "塔机预警管理", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, DevTowerDataWarning devTowerDataWarning)
{
List<DevTowerDataWarning> list = devTowerDataWarningService.selectDevTowerDataWarningList(devTowerDataWarning);
ExcelUtil<DevTowerDataWarning> util = new ExcelUtil<DevTowerDataWarning>(DevTowerDataWarning.class);
util.exportExcel(response, list, "塔机预警管理数据");
}
/**
* 获取塔机预警管理详细信息
*/
@RequiresPermissions("device:towerDataWarning:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(devTowerDataWarningService.selectDevTowerDataWarningById(id));
}
/**
* 新增塔机预警管理
*/
@RequiresPermissions("device:towerDataWarning:add")
@Log(title = "塔机预警管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody DevTowerDataWarning devTowerDataWarning)
{
return toAjax(devTowerDataWarningService.insertDevTowerDataWarning(devTowerDataWarning));
}
/**
* 修改塔机预警管理
*/
@RequiresPermissions("device:towerDataWarning:edit")
@Log(title = "塔机预警管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody DevTowerDataWarning devTowerDataWarning)
{
return toAjax(devTowerDataWarningService.updateDevTowerDataWarning(devTowerDataWarning));
}
/**
* 删除塔机预警管理
*/
@RequiresPermissions("device:towerDataWarning:remove")
@Log(title = "塔机预警管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(devTowerDataWarningService.deleteDevTowerDataWarningByIds(ids));
}
}

106
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/controller/device/DevTowerProjectConfigController.java 100644
View File

@ -0,0 +1,106 @@
package com.yanzhu.manage.controller.device;
import com.yanzhu.common.core.utils.poi.ExcelUtil;
import com.yanzhu.common.core.web.controller.BaseController;
import com.yanzhu.common.core.web.domain.AjaxResult;
import com.yanzhu.common.core.web.page.TableDataInfo;
import com.yanzhu.common.log.annotation.Log;
import com.yanzhu.common.log.enums.BusinessType;
import com.yanzhu.common.security.annotation.RequiresPermissions;
import com.yanzhu.common.security.utils.SecurityUtils;
import com.yanzhu.device.domain.DevTowerProjectConfig;
import com.yanzhu.manage.service.IDevTowerProjectConfigService;
import com.yanzhu.system.api.domain.SysUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 塔基检测配置Controller
*
* @author JiangYuQi
* @date 2024-08-04
*/
@RestController
@RequestMapping("/device/towerProjectConfig")
public class DevTowerProjectConfigController extends BaseController
{
@Autowired
private IDevTowerProjectConfigService devTowerProjectConfigService;
/**
* 查询塔基检测配置列表
*/
@RequiresPermissions("device:towerProjectConfig:list")
@GetMapping("/list")
public TableDataInfo list(DevTowerProjectConfig where)
{
startPage();
SysUser sysUser=SecurityUtils.getLoginUser().getSysUser();
where.setComId(sysUser.getActiveComId());
where.setProjectId(sysUser.getActiveProjectId());
if(SecurityUtils.isAdmin(SecurityUtils.getUserId()) || SecurityUtils.isGSAdmin()) {
where.setProjectId(null);
}
List<DevTowerProjectConfig> list = devTowerProjectConfigService.selectDevTowerProjectConfigList(where);
return getDataTable(list);
}
/**
* 导出塔基检测配置列表
*/
@RequiresPermissions("device:towerProjectConfig:export")
@Log(title = "塔基检测配置", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, DevTowerProjectConfig devTowerProjectConfig)
{
List<DevTowerProjectConfig> list = devTowerProjectConfigService.selectDevTowerProjectConfigList(devTowerProjectConfig);
ExcelUtil<DevTowerProjectConfig> util = new ExcelUtil<DevTowerProjectConfig>(DevTowerProjectConfig.class);
util.exportExcel(response, list, "塔基检测配置数据");
}
/**
* 获取塔基检测配置详细信息
*/
@RequiresPermissions("device:towerProjectConfig:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(devTowerProjectConfigService.selectDevTowerProjectConfigById(id));
}
/**
* 新增塔基检测配置
*/
@RequiresPermissions("device:towerProjectConfig:add")
@Log(title = "塔基检测配置", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody DevTowerProjectConfig devTowerProjectConfig)
{
return toAjax(devTowerProjectConfigService.insertDevTowerProjectConfig(devTowerProjectConfig));
}
/**
* 修改塔基检测配置
*/
@RequiresPermissions("device:towerProjectConfig:edit")
@Log(title = "塔基检测配置", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody DevTowerProjectConfig devTowerProjectConfig)
{
return toAjax(devTowerProjectConfigService.updateDevTowerProjectConfig(devTowerProjectConfig));
}
/**
* 删除塔基检测配置
*/
@RequiresPermissions("device:towerProjectConfig:remove")
@Log(title = "塔基检测配置", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(devTowerProjectConfigService.deleteDevTowerProjectConfigByIds(ids));
}
}

63
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/IDevTowerDataCollideService.java 100644
View File

@ -0,0 +1,63 @@
package com.yanzhu.manage.service;
import com.yanzhu.device.domain.DevTowerDataCollide;
import java.util.List;
/**
* 塔机碰撞信息Service接口
*
* @author JiangYuQi
* @date 2024-08-04
*/
public interface IDevTowerDataCollideService
{
/**
* 查询塔机碰撞信息
*
* @param id 塔机碰撞信息主键
* @return 塔机碰撞信息
*/
public DevTowerDataCollide selectDevTowerDataCollideById(Long id);
/**
* 查询塔机碰撞信息列表
*
* @param devTowerDataCollide 塔机碰撞信息
* @return 塔机碰撞信息集合
*/
public List<DevTowerDataCollide> selectDevTowerDataCollideList(DevTowerDataCollide devTowerDataCollide);
/**
* 新增塔机碰撞信息
*
* @param devTowerDataCollide 塔机碰撞信息
* @return 结果
*/
public int insertDevTowerDataCollide(DevTowerDataCollide devTowerDataCollide);
/**
* 修改塔机碰撞信息
*
* @param devTowerDataCollide 塔机碰撞信息
* @return 结果
*/
public int updateDevTowerDataCollide(DevTowerDataCollide devTowerDataCollide);
/**
* 批量删除塔机碰撞信息
*
* @param ids 需要删除的塔机碰撞信息主键集合
* @return 结果
*/
public int deleteDevTowerDataCollideByIds(Long[] ids);
/**
* 删除塔机碰撞信息信息
*
* @param id 塔机碰撞信息主键
* @return 结果
*/
public int deleteDevTowerDataCollideById(Long id);
}

62
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/IDevTowerDataLimitService.java 100644
View File

@ -0,0 +1,62 @@
package com.yanzhu.manage.service;
import com.yanzhu.device.domain.DevTowerDataLimit;
import java.util.List;
/**
* 塔机限位信息Service接口
*
* @author JiangYuQi
* @date 2024-08-04
*/
public interface IDevTowerDataLimitService
{
/**
* 查询塔机限位信息
*
* @param id 塔机限位信息主键
* @return 塔机限位信息
*/
public DevTowerDataLimit selectDevTowerDataLimitById(Long id);
/**
* 查询塔机限位信息列表
*
* @param devTowerDataLimit 塔机限位信息
* @return 塔机限位信息集合
*/
public List<DevTowerDataLimit> selectDevTowerDataLimitList(DevTowerDataLimit devTowerDataLimit);
/**
* 新增塔机限位信息
*
* @param devTowerDataLimit 塔机限位信息
* @return 结果
*/
public int insertDevTowerDataLimit(DevTowerDataLimit devTowerDataLimit);
/**
* 修改塔机限位信息
*
* @param devTowerDataLimit 塔机限位信息
* @return 结果
*/
public int updateDevTowerDataLimit(DevTowerDataLimit devTowerDataLimit);
/**
* 批量删除塔机限位信息
*
* @param ids 需要删除的塔机限位信息主键集合
* @return 结果
*/
public int deleteDevTowerDataLimitByIds(Long[] ids);
/**
* 删除塔机限位信息信息
*
* @param id 塔机限位信息主键
* @return 结果
*/
public int deleteDevTowerDataLimitById(Long id);
}

62
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/IDevTowerDataLocalService.java 100644
View File

@ -0,0 +1,62 @@
package com.yanzhu.manage.service;
import com.yanzhu.device.domain.DevTowerDataLocal;
import java.util.List;
/**
* 塔机定位信息Service接口
*
* @author JiangYuQi
* @date 2024-08-04
*/
public interface IDevTowerDataLocalService
{
/**
* 查询塔机定位信息
*
* @param id 塔机定位信息主键
* @return 塔机定位信息
*/
public DevTowerDataLocal selectDevTowerDataLocalById(Long id);
/**
* 查询塔机定位信息列表
*
* @param devTowerDataLocal 塔机定位信息
* @return 塔机定位信息集合
*/
public List<DevTowerDataLocal> selectDevTowerDataLocalList(DevTowerDataLocal devTowerDataLocal);
/**
* 新增塔机定位信息
*
* @param devTowerDataLocal 塔机定位信息
* @return 结果
*/
public int insertDevTowerDataLocal(DevTowerDataLocal devTowerDataLocal);
/**
* 修改塔机定位信息
*
* @param devTowerDataLocal 塔机定位信息
* @return 结果
*/
public int updateDevTowerDataLocal(DevTowerDataLocal devTowerDataLocal);
/**
* 批量删除塔机定位信息
*
* @param ids 需要删除的塔机定位信息主键集合
* @return 结果
*/
public int deleteDevTowerDataLocalByIds(Long[] ids);
/**
* 删除塔机定位信息信息
*
* @param id 塔机定位信息主键
* @return 结果
*/
public int deleteDevTowerDataLocalById(Long id);
}

62
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/IDevTowerDataRoundService.java 100644
View File

@ -0,0 +1,62 @@
package com.yanzhu.manage.service;
import com.yanzhu.device.domain.DevTowerDataRound;
import java.util.List;
/**
* 塔机工作循环Service接口
*
* @author JiangYuQi
* @date 2024-08-04
*/
public interface IDevTowerDataRoundService
{
/**
* 查询塔机工作循环
*
* @param id 塔机工作循环主键
* @return 塔机工作循环
*/
public DevTowerDataRound selectDevTowerDataRoundById(Long id);
/**
* 查询塔机工作循环列表
*
* @param devTowerDataRound 塔机工作循环
* @return 塔机工作循环集合
*/
public List<DevTowerDataRound> selectDevTowerDataRoundList(DevTowerDataRound devTowerDataRound);
/**
* 新增塔机工作循环
*
* @param devTowerDataRound 塔机工作循环
* @return 结果
*/
public int insertDevTowerDataRound(DevTowerDataRound devTowerDataRound);
/**
* 修改塔机工作循环
*
* @param devTowerDataRound 塔机工作循环
* @return 结果
*/
public int updateDevTowerDataRound(DevTowerDataRound devTowerDataRound);
/**
* 批量删除塔机工作循环
*
* @param ids 需要删除的塔机工作循环主键集合
* @return 结果
*/
public int deleteDevTowerDataRoundByIds(Long[] ids);
/**
* 删除塔机工作循环信息
*
* @param id 塔机工作循环主键
* @return 结果
*/
public int deleteDevTowerDataRoundById(Long id);
}

69
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/IDevTowerDataRunService.java 100644
View File

@ -0,0 +1,69 @@
package com.yanzhu.manage.service;
import com.yanzhu.device.domain.DevTowerDataRun;
import java.util.List;
import java.util.Map;
/**
* 塔机实时数据Service接口
*
* @author JiangYuQi
* @date 2024-08-04
*/
public interface IDevTowerDataRunService
{
/**
* 查询塔机实时数据
*
* @param id 塔机实时数据主键
* @return 塔机实时数据
*/
public DevTowerDataRun selectDevTowerDataRunById(Long id);
/**
* 查询塔机实时数据列表
*
* @param devTowerDataRun 塔机实时数据
* @return 塔机实时数据集合
*/
public List<DevTowerDataRun> selectDevTowerDataRunList(DevTowerDataRun devTowerDataRun);
/**
* 新增塔机实时数据
*
* @param devTowerDataRun 塔机实时数据
* @return 结果
*/
public int insertDevTowerDataRun(DevTowerDataRun devTowerDataRun);
/**
* 修改塔机实时数据
*
* @param devTowerDataRun 塔机实时数据
* @return 结果
*/
public int updateDevTowerDataRun(DevTowerDataRun devTowerDataRun);
/**
* 批量删除塔机实时数据
*
* @param ids 需要删除的塔机实时数据主键集合
* @return 结果
*/
public int deleteDevTowerDataRunByIds(Long[] ids);
/**
* 删除塔机实时数据信息
*
* @param id 塔机实时数据主键
* @return 结果
*/
public int deleteDevTowerDataRunById(Long id);
/**
* 查询塔机运行数据
* @return
*/
public Map<String, Object> findtowerStatisticsView(String deviceSn);
}

62
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/IDevTowerDataWarningService.java 100644
View File

@ -0,0 +1,62 @@
package com.yanzhu.manage.service;
import com.yanzhu.device.domain.DevTowerDataWarning;
import java.util.List;
/**
* 塔机预警管理Service接口
*
* @author JiangYuQi
* @date 2024-08-04
*/
public interface IDevTowerDataWarningService
{
/**
* 查询塔机预警管理
*
* @param id 塔机预警管理主键
* @return 塔机预警管理
*/
public DevTowerDataWarning selectDevTowerDataWarningById(Long id);
/**
* 查询塔机预警管理列表
*
* @param devTowerDataWarning 塔机预警管理
* @return 塔机预警管理集合
*/
public List<DevTowerDataWarning> selectDevTowerDataWarningList(DevTowerDataWarning devTowerDataWarning);
/**
* 新增塔机预警管理
*
* @param devTowerDataWarning 塔机预警管理
* @return 结果
*/
public int insertDevTowerDataWarning(DevTowerDataWarning devTowerDataWarning);
/**
* 修改塔机预警管理
*
* @param devTowerDataWarning 塔机预警管理
* @return 结果
*/
public int updateDevTowerDataWarning(DevTowerDataWarning devTowerDataWarning);
/**
* 批量删除塔机预警管理
*
* @param ids 需要删除的塔机预警管理主键集合
* @return 结果
*/
public int deleteDevTowerDataWarningByIds(Long[] ids);
/**
* 删除塔机预警管理信息
*
* @param id 塔机预警管理主键
* @return 结果
*/
public int deleteDevTowerDataWarningById(Long id);
}

83
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/IDevTowerProjectConfigService.java 100644
View File

@ -0,0 +1,83 @@
package com.yanzhu.manage.service;
import com.yanzhu.device.domain.DevTowerProjectConfig;
import java.util.List;
import java.util.Map;
/**
* 塔基检测配置Service接口
*
* @author JiangYuQi
* @date 2024-08-04
*/
public interface IDevTowerProjectConfigService
{
/**
* 项目启动时，初始化塔吊检测配置到缓存
*/
public void loadingDevTowerProjectConfigCache();
/**
* 查询塔基检测配置
*
* @param id 塔基检测配置主键
* @return 塔基检测配置
*/
public DevTowerProjectConfig selectDevTowerProjectConfigById(Long id);
/**
* 查询塔基检测配置列表
*
* @param devTowerProjectConfig 塔基检测配置
* @return 塔基检测配置集合
*/
public List<DevTowerProjectConfig> selectDevTowerProjectConfigList(DevTowerProjectConfig devTowerProjectConfig);
/**
* 新增塔基检测配置
*
* @param devTowerProjectConfig 塔基检测配置
* @return 结果
*/
public int insertDevTowerProjectConfig(DevTowerProjectConfig devTowerProjectConfig);
/**
* 修改塔基检测配置
*
* @param devTowerProjectConfig 塔基检测配置
* @return 结果
*/
public int updateDevTowerProjectConfig(DevTowerProjectConfig devTowerProjectConfig);
/**
* 修改塔基检测配置
*
* @param devTowerProjectConfig 塔基检测配置
* @return 结果
*/
public int updateDevTowerProjectConfigNoCache(DevTowerProjectConfig devTowerProjectConfig);
/**
* 批量删除塔基检测配置
*
* @param ids 需要删除的塔基检测配置主键集合
* @return 结果
*/
public int deleteDevTowerProjectConfigByIds(Long[] ids);
/**
* 删除塔基检测配置信息
*
* @param id 塔基检测配置主键
* @return 结果
*/
public int deleteDevTowerProjectConfigById(Long id);
/**
* 根据设备状态统计设备
* @param devTowerProjectConfig
* @return
*/
public List<Map<String, Object>> findtowerConfigGroupOnline(DevTowerProjectConfig devTowerProjectConfig);
}

136
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/impl/DevTowerDataCollideServiceImpl.java 100644
View File

@ -0,0 +1,136 @@
package com.yanzhu.manage.service.impl;
import com.yanzhu.common.core.utils.DateUtils;
import com.yanzhu.common.core.utils.StringUtils;
import com.yanzhu.device.domain.DevTowerDataCollide;
import com.yanzhu.device.domain.DevTowerDataCollideDetail;
import com.yanzhu.device.mapper.DevTowerDataCollideMapper;
import com.yanzhu.manage.service.IDevTowerDataCollideService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
/**
* 塔机碰撞信息Service业务层处理
*
* @author JiangYuQi
* @date 2024-08-04
*/
@Service
public class DevTowerDataCollideServiceImpl implements IDevTowerDataCollideService
{
@Autowired
private DevTowerDataCollideMapper devTowerDataCollideMapper;
/**
* 查询塔机碰撞信息
*
* @param id 塔机碰撞信息主键
* @return 塔机碰撞信息
*/
@Override
public DevTowerDataCollide selectDevTowerDataCollideById(Long id)
{
return devTowerDataCollideMapper.selectDevTowerDataCollideById(id);
}
/**
* 查询塔机碰撞信息列表
*
* @param devTowerDataCollide 塔机碰撞信息
* @return 塔机碰撞信息
*/
@Override
public List<DevTowerDataCollide> selectDevTowerDataCollideList(DevTowerDataCollide devTowerDataCollide)
{
return devTowerDataCollideMapper.selectDevTowerDataCollideList(devTowerDataCollide);
}
/**
* 新增塔机碰撞信息
*
* @param devTowerDataCollide 塔机碰撞信息
* @return 结果
*/
@Transactional
@Override
public int insertDevTowerDataCollide(DevTowerDataCollide devTowerDataCollide)
{
//devTowerDataCollide.setCreateBy(SecurityUtils.getUsername());
devTowerDataCollide.setCreateTime(DateUtils.getNowDate());
int rows = devTowerDataCollideMapper.insertDevTowerDataCollide(devTowerDataCollide);
insertDevTowerDataCollideDetail(devTowerDataCollide);
return rows;
}
/**
* 修改塔机碰撞信息
*
* @param devTowerDataCollide 塔机碰撞信息
* @return 结果
*/
@Transactional
@Override
public int updateDevTowerDataCollide(DevTowerDataCollide devTowerDataCollide)
{
//devTowerDataCollide.setUpdateBy(SecurityUtils.getUsername());
devTowerDataCollide.setUpdateTime(DateUtils.getNowDate());
devTowerDataCollideMapper.deleteDevTowerDataCollideDetailByCollideId(devTowerDataCollide.getId());
insertDevTowerDataCollideDetail(devTowerDataCollide);
return devTowerDataCollideMapper.updateDevTowerDataCollide(devTowerDataCollide);
}
/**
* 批量删除塔机碰撞信息
*
* @param ids 需要删除的塔机碰撞信息主键
* @return 结果
*/
@Transactional
@Override
public int deleteDevTowerDataCollideByIds(Long[] ids)
{
devTowerDataCollideMapper.deleteDevTowerDataCollideDetailByCollideIds(ids);
return devTowerDataCollideMapper.deleteDevTowerDataCollideByIds(ids);
}
/**
* 删除塔机碰撞信息信息
*
* @param id 塔机碰撞信息主键
* @return 结果
*/
@Transactional
@Override
public int deleteDevTowerDataCollideById(Long id)
{
devTowerDataCollideMapper.deleteDevTowerDataCollideDetailByCollideId(id);
return devTowerDataCollideMapper.deleteDevTowerDataCollideById(id);
}
/**
* 新增碰撞详情信息
*
* @param devTowerDataCollide 塔机碰撞信息对象
*/
public void insertDevTowerDataCollideDetail(DevTowerDataCollide devTowerDataCollide)
{
List<DevTowerDataCollideDetail> devTowerDataCollideDetailList = devTowerDataCollide.getDevTowerDataCollideDetailList();
Long id = devTowerDataCollide.getId();
if (StringUtils.isNotNull(devTowerDataCollideDetailList))
{
List<DevTowerDataCollideDetail> list = new ArrayList<DevTowerDataCollideDetail>();
for (DevTowerDataCollideDetail devTowerDataCollideDetail : devTowerDataCollideDetailList)
{
devTowerDataCollideDetail.setCollideId(id);
list.add(devTowerDataCollideDetail);
}
if (list.size() > 0)
{
devTowerDataCollideMapper.batchDevTowerDataCollideDetail(list);
}
}
}
}

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/impl/DevTowerDataLimitServiceImpl.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.service.impl;
import com.yanzhu.common.core.utils.DateUtils;
import com.yanzhu.device.domain.DevTowerDataLimit;
import com.yanzhu.device.mapper.DevTowerDataLimitMapper;
import com.yanzhu.manage.service.IDevTowerDataLimitService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 塔机限位信息Service业务层处理
*
* @author JiangYuQi
* @date 2024-08-04
*/
@Service
public class DevTowerDataLimitServiceImpl implements IDevTowerDataLimitService
{
@Autowired
private DevTowerDataLimitMapper devTowerDataLimitMapper;
/**
* 查询塔机限位信息
*
* @param id 塔机限位信息主键
* @return 塔机限位信息
*/
@Override
public DevTowerDataLimit selectDevTowerDataLimitById(Long id)
{
return devTowerDataLimitMapper.selectDevTowerDataLimitById(id);
}
/**
* 查询塔机限位信息列表
*
* @param devTowerDataLimit 塔机限位信息
* @return 塔机限位信息
*/
@Override
public List<DevTowerDataLimit> selectDevTowerDataLimitList(DevTowerDataLimit devTowerDataLimit)
{
return devTowerDataLimitMapper.selectDevTowerDataLimitList(devTowerDataLimit);
}
/**
* 新增塔机限位信息
*
* @param devTowerDataLimit 塔机限位信息
* @return 结果
*/
@Override
public int insertDevTowerDataLimit(DevTowerDataLimit devTowerDataLimit)
{
//devTowerDataLimit.setCreateBy(SecurityUtils.getUsername());
devTowerDataLimit.setCreateTime(DateUtils.getNowDate());
return devTowerDataLimitMapper.insertDevTowerDataLimit(devTowerDataLimit);
}
/**
* 修改塔机限位信息
*
* @param devTowerDataLimit 塔机限位信息
* @return 结果
*/
@Override
public int updateDevTowerDataLimit(DevTowerDataLimit devTowerDataLimit)
{
//devTowerDataLimit.setUpdateBy(SecurityUtils.getUsername());
devTowerDataLimit.setUpdateTime(DateUtils.getNowDate());
return devTowerDataLimitMapper.updateDevTowerDataLimit(devTowerDataLimit);
}
/**
* 批量删除塔机限位信息
*
* @param ids 需要删除的塔机限位信息主键
* @return 结果
*/
@Override
public int deleteDevTowerDataLimitByIds(Long[] ids)
{
return devTowerDataLimitMapper.deleteDevTowerDataLimitByIds(ids);
}
/**
* 删除塔机限位信息信息
*
* @param id 塔机限位信息主键
* @return 结果
*/
@Override
public int deleteDevTowerDataLimitById(Long id)
{
return devTowerDataLimitMapper.deleteDevTowerDataLimitById(id);
}
}

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/impl/DevTowerDataLocalServiceImpl.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.service.impl;
import com.yanzhu.common.core.utils.DateUtils;
import com.yanzhu.device.domain.DevTowerDataLocal;
import com.yanzhu.device.mapper.DevTowerDataLocalMapper;
import com.yanzhu.manage.service.IDevTowerDataLocalService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 塔机定位信息Service业务层处理
*
* @author JiangYuQi
* @date 2024-08-04
*/
@Service
public class DevTowerDataLocalServiceImpl implements IDevTowerDataLocalService
{
@Autowired
private DevTowerDataLocalMapper devTowerDataLocalMapper;
/**
* 查询塔机定位信息
*
* @param id 塔机定位信息主键
* @return 塔机定位信息
*/
@Override
public DevTowerDataLocal selectDevTowerDataLocalById(Long id)
{
return devTowerDataLocalMapper.selectDevTowerDataLocalById(id);
}
/**
* 查询塔机定位信息列表
*
* @param devTowerDataLocal 塔机定位信息
* @return 塔机定位信息
*/
@Override
public List<DevTowerDataLocal> selectDevTowerDataLocalList(DevTowerDataLocal devTowerDataLocal)
{
return devTowerDataLocalMapper.selectDevTowerDataLocalList(devTowerDataLocal);
}
/**
* 新增塔机定位信息
*
* @param devTowerDataLocal 塔机定位信息
* @return 结果
*/
@Override
public int insertDevTowerDataLocal(DevTowerDataLocal devTowerDataLocal)
{
//devTowerDataLocal.setCreateBy(SecurityUtils.getUsername());
devTowerDataLocal.setCreateTime(DateUtils.getNowDate());
return devTowerDataLocalMapper.insertDevTowerDataLocal(devTowerDataLocal);
}
/**
* 修改塔机定位信息
*
* @param devTowerDataLocal 塔机定位信息
* @return 结果
*/
@Override
public int updateDevTowerDataLocal(DevTowerDataLocal devTowerDataLocal)
{
//devTowerDataLocal.setUpdateBy(SecurityUtils.getUsername());
devTowerDataLocal.setUpdateTime(DateUtils.getNowDate());
return devTowerDataLocalMapper.updateDevTowerDataLocal(devTowerDataLocal);
}
/**
* 批量删除塔机定位信息
*
* @param ids 需要删除的塔机定位信息主键
* @return 结果
*/
@Override
public int deleteDevTowerDataLocalByIds(Long[] ids)
{
return devTowerDataLocalMapper.deleteDevTowerDataLocalByIds(ids);
}
/**
* 删除塔机定位信息信息
*
* @param id 塔机定位信息主键
* @return 结果
*/
@Override
public int deleteDevTowerDataLocalById(Long id)
{
return devTowerDataLocalMapper.deleteDevTowerDataLocalById(id);
}
}

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/impl/DevTowerDataRoundServiceImpl.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.service.impl;
import com.yanzhu.common.core.utils.DateUtils;
import com.yanzhu.device.domain.DevTowerDataRound;
import com.yanzhu.device.mapper.DevTowerDataRoundMapper;
import com.yanzhu.manage.service.IDevTowerDataRoundService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 塔机工作循环Service业务层处理
*
* @author JiangYuQi
* @date 2024-08-04
*/
@Service
public class DevTowerDataRoundServiceImpl implements IDevTowerDataRoundService
{
@Autowired
private DevTowerDataRoundMapper devTowerDataRoundMapper;
/**
* 查询塔机工作循环
*
* @param id 塔机工作循环主键
* @return 塔机工作循环
*/
@Override
public DevTowerDataRound selectDevTowerDataRoundById(Long id)
{
return devTowerDataRoundMapper.selectDevTowerDataRoundById(id);
}
/**
* 查询塔机工作循环列表
*
* @param devTowerDataRound 塔机工作循环
* @return 塔机工作循环
*/
@Override
public List<DevTowerDataRound> selectDevTowerDataRoundList(DevTowerDataRound devTowerDataRound)
{
return devTowerDataRoundMapper.selectDevTowerDataRoundList(devTowerDataRound);
}
/**
* 新增塔机工作循环
*
* @param devTowerDataRound 塔机工作循环
* @return 结果
*/
@Override
public int insertDevTowerDataRound(DevTowerDataRound devTowerDataRound)
{
//devTowerDataRound.setCreateBy(SecurityUtils.getUsername());
devTowerDataRound.setCreateTime(DateUtils.getNowDate());
return devTowerDataRoundMapper.insertDevTowerDataRound(devTowerDataRound);
}
/**
* 修改塔机工作循环
*
* @param devTowerDataRound 塔机工作循环
* @return 结果
*/
@Override
public int updateDevTowerDataRound(DevTowerDataRound devTowerDataRound)
{
//devTowerDataRound.setUpdateBy(SecurityUtils.getUsername());
devTowerDataRound.setUpdateTime(DateUtils.getNowDate());
return devTowerDataRoundMapper.updateDevTowerDataRound(devTowerDataRound);
}
/**
* 批量删除塔机工作循环
*
* @param ids 需要删除的塔机工作循环主键
* @return 结果
*/
@Override
public int deleteDevTowerDataRoundByIds(Long[] ids)
{
return devTowerDataRoundMapper.deleteDevTowerDataRoundByIds(ids);
}
/**
* 删除塔机工作循环信息
*
* @param id 塔机工作循环主键
* @return 结果
*/
@Override
public int deleteDevTowerDataRoundById(Long id)
{
return devTowerDataRoundMapper.deleteDevTowerDataRoundById(id);
}
}

165
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/impl/DevTowerDataRunServiceImpl.java 100644
View File

@ -0,0 +1,165 @@
package com.yanzhu.manage.service.impl;
import com.yanzhu.common.core.utils.DateUtils;
import com.yanzhu.device.domain.DevTowerDataRound;
import com.yanzhu.device.domain.DevTowerDataRun;
import com.yanzhu.device.mapper.DevTowerDataCollideMapper;
import com.yanzhu.device.mapper.DevTowerDataRoundMapper;
import com.yanzhu.device.mapper.DevTowerDataRunMapper;
import com.yanzhu.manage.service.IDevTowerDataRunService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 塔机实时数据Service业务层处理
*
* @author JiangYuQi
* @date 2024-08-04
*/
@Service
public class DevTowerDataRunServiceImpl implements IDevTowerDataRunService
{
@Autowired
private DevTowerDataRunMapper devTowerDataRunMapper;
@Autowired
private DevTowerDataRoundMapper devTowerDataRoundMapper;
@Autowired
private DevTowerDataCollideMapper devTowerDataCollideMapper;
/**
* 查询塔机实时数据
*
* @param id 塔机实时数据主键
* @return 塔机实时数据
*/
@Override
public DevTowerDataRun selectDevTowerDataRunById(Long id)
{
return devTowerDataRunMapper.selectDevTowerDataRunById(id);
}
/**
* 查询塔机实时数据列表
*
* @param devTowerDataRun 塔机实时数据
* @return 塔机实时数据
*/
@Override
public List<DevTowerDataRun> selectDevTowerDataRunList(DevTowerDataRun devTowerDataRun)
{
return devTowerDataRunMapper.selectDevTowerDataRunList(devTowerDataRun);
}
/**
* 新增塔机实时数据
*
* @param devTowerDataRun 塔机实时数据
* @return 结果
*/
@Override
public int insertDevTowerDataRun(DevTowerDataRun devTowerDataRun)
{
//devTowerDataRun.setCreateBy(SecurityUtils.getUsername());
devTowerDataRun.setCreateTime(DateUtils.getNowDate());
return devTowerDataRunMapper.insertDevTowerDataRun(devTowerDataRun);
}
/**
* 修改塔机实时数据
*
* @param devTowerDataRun 塔机实时数据
* @return 结果
*/
@Override
public int updateDevTowerDataRun(DevTowerDataRun devTowerDataRun)
{
//devTowerDataRun.setUpdateBy(SecurityUtils.getUsername());
devTowerDataRun.setUpdateTime(DateUtils.getNowDate());
return devTowerDataRunMapper.updateDevTowerDataRun(devTowerDataRun);
}
/**
* 批量删除塔机实时数据
*
* @param ids 需要删除的塔机实时数据主键
* @return 结果
*/
@Override
public int deleteDevTowerDataRunByIds(Long[] ids)
{
return devTowerDataRunMapper.deleteDevTowerDataRunByIds(ids);
}
/**
* 删除塔机实时数据信息
*
* @param id 塔机实时数据主键
* @return 结果
*/
@Override
public int deleteDevTowerDataRunById(Long id)
{
return devTowerDataRunMapper.deleteDevTowerDataRunById(id);
}
/**
* 查询塔机运行数据
* @return
*/
@Override
public Map<String, Object> findtowerStatisticsView(String deviceSn){
Map<String, Object> dataMap = new HashMap<>();
DevTowerDataRound devTowerDataRound = new DevTowerDataRound();
devTowerDataRound.setDeviceKey(deviceSn);
int a0 = devTowerDataRoundMapper.findRoundCountByDeviceKey(devTowerDataRound);
dataMap.put("a0",a0);
devTowerDataRound.setActiveName("cz");
int b0 = devTowerDataRoundMapper.findRoundCountByDeviceKey(devTowerDataRound);
dataMap.put("b0",b0);
devTowerDataRound.setActiveName("gj");
int c0 = devTowerDataRunMapper.findRunCountByDeviceKey(devTowerDataRound);
//int d0 = devTowerDataRoundMapper.findRoundCountByDeviceKey(devTowerDataRound);
//int e0 = devTowerDataCollideMapper.findCollideCountByDeviceKey(devTowerDataRound);
dataMap.put("c0",c0);
Calendar cale = Calendar.getInstance();
// 获取当月第一天和最后一天
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
// 第一天
String firstDay = "";
cale = Calendar.getInstance();
cale.add(Calendar.MONTH, 0);
cale.set(Calendar.DAY_OF_MONTH, 1);
firstDay = format.format(cale.getTime());
// 最后一天
String lastDay = "";
cale = Calendar.getInstance();
cale.add(Calendar.MONTH, 1);
cale.set(Calendar.DAY_OF_MONTH, 0);
lastDay = format.format(cale.getTime());
Map<String, Object> params = new HashMap<>();
params.put("beginCreateTime",firstDay);
params.put("endCreateTime",lastDay);
devTowerDataRound.setParams(params);
int a1 = devTowerDataRoundMapper.findRoundCountByDeviceKey(devTowerDataRound);
dataMap.put("a1",a1);
devTowerDataRound.setActiveName("cz");
int b1 = devTowerDataRoundMapper.findRoundCountByDeviceKey(devTowerDataRound);
dataMap.put("b1",b1);
devTowerDataRound.setActiveName("gj");
int c1 = devTowerDataRunMapper.findRunCountByDeviceKey(devTowerDataRound);
//int d1 = devTowerDataRoundMapper.findRoundCountByDeviceKey(devTowerDataRound);
//int e1 = devTowerDataCollideMapper.findCollideCountByDeviceKey(devTowerDataRound);
dataMap.put("c1",c1);
return dataMap;
}
}

98
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/impl/DevTowerDataWarningServiceImpl.java 100644
View File

@ -0,0 +1,98 @@
package com.yanzhu.manage.service.impl;
import com.yanzhu.common.core.utils.DateUtils;
import com.yanzhu.device.domain.DevTowerDataWarning;
import com.yanzhu.device.mapper.DevTowerDataWarningMapper;
import com.yanzhu.manage.service.IDevTowerDataWarningService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 塔机预警管理Service业务层处理
*
* @author JiangYuQi
* @date 2024-08-04
*/
@Service
public class DevTowerDataWarningServiceImpl implements IDevTowerDataWarningService
{
@Autowired
private DevTowerDataWarningMapper devTowerDataWarningMapper;
/**
* 查询塔机预警管理
*
* @param id 塔机预警管理主键
* @return 塔机预警管理
*/
@Override
public DevTowerDataWarning selectDevTowerDataWarningById(Long id)
{
return devTowerDataWarningMapper.selectDevTowerDataWarningById(id);
}
/**
* 查询塔机预警管理列表
*
* @param devTowerDataWarning 塔机预警管理
* @return 塔机预警管理
*/
@Override
public List<DevTowerDataWarning> selectDevTowerDataWarningList(DevTowerDataWarning devTowerDataWarning)
{
return devTowerDataWarningMapper.selectDevTowerDataWarningList(devTowerDataWarning);
}
/**
* 新增塔机预警管理
*
* @param devTowerDataWarning 塔机预警管理
* @return 结果
*/
@Override
public int insertDevTowerDataWarning(DevTowerDataWarning devTowerDataWarning)
{
//devTowerDataWarning.setCreateBy(SecurityUtils.getUsername());
devTowerDataWarning.setCreateTime(DateUtils.getNowDate());
return devTowerDataWarningMapper.insertDevTowerDataWarning(devTowerDataWarning);
}
/**
* 修改塔机预警管理
*
* @param devTowerDataWarning 塔机预警管理
* @return 结果
*/
@Override
public int updateDevTowerDataWarning(DevTowerDataWarning devTowerDataWarning)
{
//devTowerDataWarning.setUpdateBy(SecurityUtils.getUsername());
devTowerDataWarning.setUpdateTime(DateUtils.getNowDate());
return devTowerDataWarningMapper.updateDevTowerDataWarning(devTowerDataWarning);
}
/**
* 批量删除塔机预警管理
*
* @param ids 需要删除的塔机预警管理主键
* @return 结果
*/
@Override
public int deleteDevTowerDataWarningByIds(Long[] ids)
{
return devTowerDataWarningMapper.deleteDevTowerDataWarningByIds(ids);
}
/**
* 删除塔机预警管理信息
*
* @param id 塔机预警管理主键
* @return 结果
*/
@Override
public int deleteDevTowerDataWarningById(Long id)
{
return devTowerDataWarningMapper.deleteDevTowerDataWarningById(id);
}
}

169
yanzhu-modules/yanzhu-manage/src/main/java/com/yanzhu/manage/service/impl/DevTowerProjectConfigServiceImpl.java 100644
View File

@ -0,0 +1,169 @@
package com.yanzhu.manage.service.impl;
import com.yanzhu.common.core.utils.DateUtils;
import com.yanzhu.common.redis.service.RedisService;
import com.yanzhu.common.security.utils.SecurityUtils;
import com.yanzhu.device.domain.DevTowerProjectConfig;
import com.yanzhu.device.mapper.DevTowerProjectConfigMapper;
import com.yanzhu.manage.service.IDevTowerProjectConfigService;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 塔基检测配置Service业务层处理
*
* @author JiangYuQi
* @date 2024-08-04
*/
@Service
public class DevTowerProjectConfigServiceImpl implements IDevTowerProjectConfigService
{
public static final String YANZHU_DEVICE_TOWER = "device.tower_cfg:";
@Autowired
private RedisService redisService;
@Autowired
private DevTowerProjectConfigMapper devTowerProjectConfigMapper;
/**
* 项目启动时，初始化塔吊检测配置到缓存
*/
@PostConstruct
public void init()
{
loadingDevTowerProjectConfigCache();
}
/**
* 加载注册应用
*/
@Override
public void loadingDevTowerProjectConfigCache()
{
this.clearConfigCache();
List<DevTowerProjectConfig> configList = devTowerProjectConfigMapper.selectDevTowerProjectConfigList(new DevTowerProjectConfig());
if(CollectionUtils.isNotEmpty(configList)){
for (DevTowerProjectConfig config : configList) {
redisService.setCacheObject(YANZHU_DEVICE_TOWER + config.getDeviceSn(), config);
}
}
}
private void clearConfigCache()
{
Collection<String> keys = redisService.keys(YANZHU_DEVICE_TOWER + "*");
redisService.deleteObject(keys);
}
/**
* 查询塔基检测配置
*
* @param id 塔基检测配置主键
* @return 塔基检测配置
*/
@Override
public DevTowerProjectConfig selectDevTowerProjectConfigById(Long id)
{
return devTowerProjectConfigMapper.selectDevTowerProjectConfigById(id);
}
/**
* 查询塔基检测配置列表
*
* @param devTowerProjectConfig 塔基检测配置
* @return 塔基检测配置
*/
@Override
public List<DevTowerProjectConfig> selectDevTowerProjectConfigList(DevTowerProjectConfig devTowerProjectConfig)
{
return devTowerProjectConfigMapper.selectDevTowerProjectConfigList(devTowerProjectConfig);
}
/**
* 新增塔基检测配置
*
* @param devTowerProjectConfig 塔基检测配置
* @return 结果
*/
@Override
public int insertDevTowerProjectConfig(DevTowerProjectConfig devTowerProjectConfig)
{
devTowerProjectConfig.setCreateBy(SecurityUtils.getUsername());
devTowerProjectConfig.setCreateTime(DateUtils.getNowDate());
int res = devTowerProjectConfigMapper.insertDevTowerProjectConfig(devTowerProjectConfig);
this.loadingDevTowerProjectConfigCache();
return res;
}
/**
* 修改塔基检测配置
*
* @param devTowerProjectConfig 塔基检测配置
* @return 结果
*/
@Override
public int updateDevTowerProjectConfig(DevTowerProjectConfig devTowerProjectConfig)
{
devTowerProjectConfig.setUpdateBy(SecurityUtils.getUsername());
devTowerProjectConfig.setUpdateTime(DateUtils.getNowDate());
int res = devTowerProjectConfigMapper.updateDevTowerProjectConfig(devTowerProjectConfig);
this.loadingDevTowerProjectConfigCache();
return res;
}
/**
* 修改塔基检测配置
*
* @param devTowerProjectConfig 塔基检测配置
* @return 结果
*/
@Override
public int updateDevTowerProjectConfigNoCache(DevTowerProjectConfig devTowerProjectConfig)
{
devTowerProjectConfig.setUpdateTime(DateUtils.getNowDate());
return devTowerProjectConfigMapper.updateDevTowerProjectConfig(devTowerProjectConfig);
}
/**
* 批量删除塔基检测配置
*
* @param ids 需要删除的塔基检测配置主键
* @return 结果
*/
@Override
public int deleteDevTowerProjectConfigByIds(Long[] ids)
{
int res = devTowerProjectConfigMapper.deleteDevTowerProjectConfigByIds(ids);
this.loadingDevTowerProjectConfigCache();
return res;
}
/**
* 删除塔基检测配置信息
*
* @param id 塔基检测配置主键
* @return 结果
*/
@Override
public int deleteDevTowerProjectConfigById(Long id)
{
int res = devTowerProjectConfigMapper.deleteDevTowerProjectConfigById(id);
this.loadingDevTowerProjectConfigCache();
return res;
}
/**
* 根据设备状态统计设备
* @param devTowerProjectConfig
* @return
*/
public List<Map<String, Object>> findtowerConfigGroupOnline(DevTowerProjectConfig devTowerProjectConfig){
return devTowerProjectConfigMapper.findtowerConfigGroupOnline(devTowerProjectConfig);
}
}

44
yanzhu-ui-vue3/src/api/device/towerProjectConfig.js 100644
View File

@ -0,0 +1,44 @@
import request from "@/utils/request";
// 查询塔基检测配置列表
export function listTowerProjectConfig(query) {
return request({
url: "/manage/device/towerProjectConfig/list",
method: "get",
params: query,
});
}
// 查询塔基检测配置详细
export function getTowerProjectConfig(id) {
return request({
url: "/manage/device/towerProjectConfig/" + id,
method: "get",
});
}
// 新增塔基检测配置
export function addTowerProjectConfig(data) {
return request({
url: "/manage/device/towerProjectConfig",
method: "post",
data: data,
});
}
// 修改塔基检测配置
export function updateTowerProjectConfig(data) {
return request({
url: "/manage/device/towerProjectConfig",
method: "put",
data: data,
});
}
// 删除塔基检测配置
export function delTowerProjectConfig(id) {
return request({
url: "/manage/device/towerProjectConfig/" + id,
method: "delete",
});
}

15
yanzhu-ui-vue3/src/views/device/towerDataCollide/index.vue 100644
View File

@ -0,0 +1,15 @@
<template>
<div class="app-container tower-data-collide">
222222
</div>
</template>
<script>
export default {
}
</script>
<style lang="scss">
.tower-data-collide {}
</style>

15
yanzhu-ui-vue3/src/views/device/towerDataLimit/index.vue 100644
View File

@ -0,0 +1,15 @@
<template>
<div class="app-container tower-data-limit">
222222
</div>
</template>
<script>
export default {
}
</script>
<style lang="scss">
.tower-data-limit {}
</style>

15
yanzhu-ui-vue3/src/views/device/towerDataLocal/index.vue 100644
View File

@ -0,0 +1,15 @@
<template>
<div class="app-container tower-data-local">
222222
</div>
</template>
<script>
export default {
}
</script>
<style lang="scss">
.tower-data-local {}
</style>

15
yanzhu-ui-vue3/src/views/device/towerDataRound/index.vue 100644
View File

@ -0,0 +1,15 @@
<template>
<div class="app-container tower-data-round">
222222
</div>
</template>
<script>
export default {
}
</script>
<style lang="scss">
.tower-data-round {}
</style>

15
yanzhu-ui-vue3/src/views/device/towerDataRun/index.vue 100644
View File

@ -0,0 +1,15 @@
<template>
<div class="app-container tower-data-run">
222222
</div>
</template>
<script>
export default {
}
</script>
<style lang="scss">
.tower-data-run {}
</style>

15
yanzhu-ui-vue3/src/views/device/towerDataWarning/index.vue 100644
View File

@ -0,0 +1,15 @@
<template>
<div class="app-container tower-data-warning">
222222
</div>
</template>
<script>
export default {
}
</script>
<style lang="scss">
.tower-data-warning {}
</style>

481
yanzhu-ui-vue3/src/views/device/towerProjectConfig/index.vue 100644
View File

@ -0,0 +1,481 @@
<template>
<div class="app-container tower-project-config">
<el-form :model="queryParams" ref="queryForm" size="small" :inline="true" v-show="showSearch"
label-width="68px">
<el-form-item label="项目名称" prop="projectId">
<el-select v-model="queryParams.projectId" :disabled="currentPrjId ? true : false" filterable
placeholder="请选择所属项目" style="width: 200px">
<el-option v-for="item in projects" :key="item.id" :label="item.projectName" :value="item.id">
</el-option>
</el-select>
</el-form-item>
<el-form-item label="设备名称" prop="deviceName">
<el-input v-model="queryParams.deviceName" placeholder="请输入设备名称" clearable @keyup.enter="handleQuery" />
</el-form-item>
<el-form-item label="设备序号" prop="deviceSn">
<el-input v-model="queryParams.deviceSn" placeholder="请输入设备序列号" clearable @keyup.enter="handleQuery" />
</el-form-item>
<el-form-item>
<el-button type="primary" icon="el-icon-search" size="small" @click="handleQuery">搜索</el-button>
<el-button icon="el-icon-refresh" size="small" @click="resetQuery">重置</el-button>
</el-form-item>
</el-form>
<el-row :gutter="10" class="mb8">
<el-col :span="1.5">
<el-button type="primary" plain icon="el-icon-plus" size="small" @click="handleAdd"
v-hasPermi="['device:towerProjectConfig:add']">新增</el-button>
</el-col>
<el-col :span="1.5">
<el-button type="success" plain icon="el-icon-edit" size="small" :disabled="single"
@click="handleUpdate" v-hasPermi="['device:towerProjectConfig:edit']">修改</el-button>
</el-col>
<el-col :span="1.5">
<el-button type="danger" plain icon="el-icon-delete" size="small" :disabled="multiple"
@click="handleDelete" v-hasPermi="['device:towerProjectConfig:remove']">删除</el-button>
</el-col>
<el-col :span="1.5">
<el-button type="warning" plain icon="el-icon-download" size="small" @click="handleExport"
v-hasPermi="['device:towerProjectConfig:export']">导出</el-button>
</el-col>
<right-toolbar :showSearch="showSearch" @queryTable="getList"></right-toolbar>
</el-row>
<el-table v-loading="loading" :data="towerProjectConfigList" @selection-change="handleSelectionChange">
<el-table-column type="selection" width="55" align="center" />
<el-table-column label="项目名称" align="center" prop="projectName" width="150"
v-if="currentPrjId ? false : true" />
<el-table-column label="设备名称" align="center" prop="deviceName" width="150" />
<el-table-column label="设备序号" align="center" prop="deviceSn" width="150" />
<el-table-column label="塔机类型" align="center" prop="towerType">
<template #default="scope">
<dict-tag :options="dict.device_tower_type" :value="scope.row.towerType" />
</template>
</el-table-column>
<el-table-column label="设备厂商" align="center" prop="deviceSource" />
<el-table-column label="塔机坐标x" align="center" prop="coordinateX" width="100" />
<el-table-column label="塔机坐标y" align="center" prop="coordinateY" width="100" />
<el-table-column label="前臂长度" align="center" prop="frontBrachium" />
<el-table-column label="平衡臂长度" align="center" prop="afterBrachium" width="100" />
<el-table-column label="塔身高度" align="center" prop="towerBodyHeight" />
<el-table-column label="塔帽高度" align="center" prop="towerCapHeight" />
<el-table-column label="塔节高度" align="center" prop="towerSectionHeight" />
<el-table-column label="司机" align="center">
<template #default="scope">
<div>{{ scope.row.driName }}</div>
<div>{{ scope.row.driPhone }}</div>
</template>
</el-table-column>
<el-table-column label="安全员" align="center">
<template #default="scope">
<div>{{ scope.row.safName }}</div>
<div>{{ scope.row.safPhone }}</div>
</template>
</el-table-column>
<el-table-column label="塔机状态" align="center" prop="online">
<template #default="scope">
<dict-tag :options="dict.project_video_signal_state" :value="scope.row.online" />
</template>
</el-table-column>
<el-table-column label="启用状态" align="center" prop="isDel" width="80">
<template #default="scope">
<el-switch v-model="scope.row.isDel" active-value="0" inactive-value="1"
@change="setStatus(scope.row, $event)"></el-switch>
</template>
</el-table-column>
<el-table-column label="更新时间" align="center" prop="updateTime" width="160">
<template #default="scope">
<span>{{ parseTime(scope.row.updateTime, "{y}-{m}-{d} {h}:{i}") }}</span>
</template>
</el-table-column>
<el-table-column label="操作" align="center" class-name="small-padding fixed-width" width="100" fixed="right">
<template #default="scope">
<el-button size="small" type="text" icon="el-icon-edit" @click="handleUpdate(scope.row)"
v-hasPermi="['device:towerProjectConfig:edit']">修改</el-button>
</template>
</el-table-column>
</el-table>
<pagination v-show="total > 0" :total="total" :page="queryParams.pageNum" :limit="queryParams.pageSize"
@pagination="getList" />
<!-- 添加或修改塔基检测配置对话框 -->
<el-dialog :title="title" v-model="open" width="960px" append-to-body>
<el-form ref="form" :model="form" :rules="rules" label-width="120px">
<el-row>
<el-col :span="12">
<el-form-item label="所属项目" prop="projectId">
<el-select v-model="form.projectId" :disabled="currentPrjId ? true : false" filterable
placeholder="请选择所属项目" style="width: 100%">
<el-option v-for="item in projects" :key="item.id" :label="item.projectName"
:value="item.id">
</el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="设备名称" prop="deviceName">
<el-input v-model="form.deviceName" placeholder="请输入设备名称" maxlength="32" show-word-limit />
</el-form-item>
</el-col>
</el-row>
<el-row>
<el-col :span="12">
<el-form-item label="设备序列号" prop="deviceSn">
<el-input v-model="form.deviceSn" placeholder="请输入设备序列号" maxlength="32" show-word-limit />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="设备厂商" prop="deviceSource">
<el-input v-model="form.deviceSource" placeholder="请输入设备厂商" />
</el-form-item>
</el-col>
</el-row>
<el-row>
<el-col :span="12">
<el-form-item label="塔机司机" prop="driName">
<el-input v-model="form.driName" placeholder="请输入塔机司机" />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="司机电话" prop="driPhone">
<el-input v-model="form.driPhone" placeholder="请输入司机电话" />
</el-form-item>
</el-col></el-row>
<el-row>
<el-col :span="12">
<el-form-item label="安全员" prop="safName">
<el-input v-model="form.safName" placeholder="请输入安全员" />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="安全员电话" prop="safPhone">
<el-input v-model="form.safPhone" placeholder="请输入安全员电话" />
</el-form-item>
</el-col>
</el-row>
<el-alert title="温馨提示：" type="warning" description="以下数据在设备运行过程中，不定时更新。无需填写，填写后会被定时覆盖！！！" show-icon>
</el-alert>
<el-row>
<el-col :span="12">
<el-form-item label="塔机类型" prop="towerType" style="margin-top: 16px;">
<el-select v-model="form.towerType" placeholder="请选择塔机类型" style="width:100%">
<el-option v-for="dict in dict.device_tower_type" :key="dict.value" :label="dict.label"
:value="parseInt(dict.value)"></el-option>
</el-select>
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="塔机坐标x" prop="coordinateX">
<el-input v-model="form.coordinateX" placeholder="请输入塔机坐标x" />
</el-form-item>
</el-col></el-row>
<el-row>
<el-col :span="12">
<el-form-item label="塔机坐标y" prop="coordinateY">
<el-input v-model="form.coordinateY" placeholder="请输入塔机坐标y" />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="前臂长度" prop="frontBrachium">
<el-input v-model="form.frontBrachium" placeholder="请输入前臂长度" />
</el-form-item>
</el-col></el-row>
<el-row>
<el-col :span="12">
<el-form-item label="平衡臂长度" prop="afterBrachium">
<el-input v-model="form.afterBrachium" placeholder="请输入平衡臂长度" />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="塔身高度" prop="towerBodyHeight">
<el-input v-model="form.towerBodyHeight" placeholder="请输入塔身高度" />
</el-form-item>
</el-col>
</el-row>
<el-row>
<el-col :span="12">
<el-form-item label="塔帽高度" prop="towerCapHeight">
<el-input v-model="form.towerCapHeight" placeholder="请输入塔帽高度" />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="塔节高度" prop="towerSectionHeight">
<el-input v-model="form.towerSectionHeight" placeholder="请输入塔节高度" />
</el-form-item>
</el-col>
</el-row>
</el-form>
<div slot-slot="footer" class="dialog-footer">
<el-button type="primary" @click="submitForm">确 定</el-button>
<el-button @click="cancel">取 消</el-button>
</div>
</el-dialog>
</div>
</template>
<script>
import {
listTowerProjectConfig,
getTowerProjectConfig,
delTowerProjectConfig,
addTowerProjectConfig,
updateTowerProjectConfig,
} from "@/api/device/towerProjectConfig";
import useUserStore from '@/store/modules/user'
import { findMyProjectList } from "@/api/publics";
export default {
name: "TowerProjectConfig",
data() {
return {
// 遮罩层
loading: true,
// 选中数组
ids: [],
// 非单个禁用
single: true,
// 非多个禁用
multiple: true,
// 显示搜索条件
showSearch: true,
// 总条数
total: 0,
// 塔基检测配置表格数据
towerProjectConfigList: [],
// 弹出层标题
title: "",
// 是否显示弹出层
open: false,
// 查询参数
queryParams: {
pageNum: 1,
pageSize: 10,
projectId: null,
projectName: null,
comtId: null,
comName: null,
deviceSn: null,
deviceSource: null,
towerType: null,
},
// 表单参数
form: {},
// 表单校验
rules: {
projectId: [{ required: true, message: "请选择所属项目", trigger: "change" }],
deptId: [{ required: true, message: "请选择所属单位", trigger: "change" }],
deviceName: [
{ required: true, message: "设备名称不能为空", trigger: "blur" },
],
deviceSn: [
{ required: true, message: "设备序列表不能为空", trigger: "blur" },
{ max: 64, message: "最多输入64个字符" },
],
},
projectOptions: [],
deptOptions: [],
dict: {
sys_common_isdel: [],
device_tower_type: [],
project_video_signal_state: []
},
userStore: {},
isAdmin: false,
projects: [],
currentPrjId: null,
};
},
created() {
this.getList();
this.dict = this.useDict('sys_common_isdel', 'device_tower_type', 'project_video_signal_state');
this.userStore = useUserStore()
this.isAdmin = this.userStore.isAdmin;
this.queryParams.projectId = this.userStore.currentPrjId;
this.queryParams.comId = this.userStore.currentComId;
this.currentPrjId = this.userStore.currentPrjId;
this.getProjectList();
},
methods: {
/** 查询项目列表 */
getProjectList() {
findMyProjectList({ pageNum: 1, pageSize: 100 }).then(response => {
this.projects = response.rows;
});
},
projectChange(val) {
this.form.deptId = null;
// 根据项目查询总包单位
this.initDept(val);
},
initDept(val) {
this.$api.publics
.queryUnitList({
projectId: val,
unitType: 2,
})
.then((d) => {
this.deptOptions = d.rows;
if (d.rows.length > 0) {
// 有总包单位
} else {
this.$message.error("当前项目未分配总包单位！");
}
});
},
/** 查询塔基检测配置列表 */
getList() {
this.loading = true;
listTowerProjectConfig(this.queryParams).then((response) => {
this.towerProjectConfigList = response.rows;
this.total = response.total;
setTimeout(() => {
this.loading = false;
}, 800);
});
},
// 取消按钮
cancel() {
this.open = false;
this.reset();
},
// 表单重置
reset() {
this.form = {
id: null,
projectId: null,
deptId: null,
deviceSn: null,
deviceSource: null,
towerType: null,
coordinateX: null,
coordinateY: null,
frontBrachium: null,
afterBrachium: null,
towerBodyHeight: null,
towerCapHeight: null,
towerSectionHeight: null,
driName: null,
driPhone: null,
safName: null,
safPhone: null,
isDel: null,
createBy: null,
createTime: null,
updateBy: null,
updateTime: null,
remark: null,
};
this.resetForm("form");
},
/** 搜索按钮操作 */
handleQuery() {
this.queryParams.pageNum = 1;
this.getList();
},
/** 重置按钮操作 */
resetQuery() {
this.resetForm("queryForm");
this.handleQuery();
},
// 多选框选中数据
handleSelectionChange(selection) {
this.ids = selection.map((item) => item.id);
this.single = selection.length !== 1;
this.multiple = !selection.length;
},
/** 新增按钮操作 */
handleAdd() {
this.reset();
this.form.comId = this.userStore.currentComId;
this.form.projectId = this.userStore.currentPrjId;
this.open = true;
this.title = "添加塔基检测配置";
},
/** 修改按钮操作 */
handleUpdate(row) {
this.reset();
const id = row.id || this.ids;
getTowerProjectConfig(id).then((response) => {
this.form = response.data;
this.form.towerType = this.form.towerType ? 1 * this.form.towerType : '';
this.open = true;
this.title = "修改塔基检测配置";
});
},
/** 提交按钮 */
submitForm() {
this.$refs["form"].validate((valid) => {
if (valid) {
if (this.form.id != null) {
updateTowerProjectConfig(this.form).then((response) => {
this.$modal.msgSuccess("修改成功");
this.open = false;
this.getList();
});
} else {
addTowerProjectConfig(this.form).then((response) => {
this.$modal.msgSuccess("新增成功");
this.open = false;
this.getList();
});
}
}
});
},
/** 删除按钮操作 */
handleDelete(row) {
const ids = row.id || this.ids;
this.$modal
.confirm('是否确认删除塔基检测配置编号为"' + ids + '"的数据项？')
.then(function () {
return delTowerProjectConfig(ids);
})
.then(() => {
this.getList();
this.$modal.msgSuccess("删除成功");
})
.catch(() => { });
},
/** 导出按钮操作 */
handleExport() {
this.download(
"device/towerProjectConfig/export",
{
...this.queryParams,
},
`towerProjectConfig_${new Date().getTime()}.xlsx`
);
},
//修改塔吊配置状态
setStatus(row, val) {
if (this.loading) {
return
}
this.$confirm(`是否确认${val == 0 ? "启用" : "停用"}当前数据配置？`, "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "warning",
})
.then(async () => {
delTowerProjectConfig(row.id).then((response) => {
this.$modal.msgSuccess("修改成功");
this.getList();
});
})
.catch(() => {
// 取消时恢复原始开关状态
if (val == "0") {
row.isDel = "1";
} else {
row.isDel = "0";
}
});
},
},
}
</script>
<style lang="scss">
.tower-project-config {}
</style>