boyue2025/dbd-meeting
3
0
Fork 0
mirror of https://gitee.com/elegant_wings/dbd-meeting.git synced 2025-06-21 20:39:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

表结构更新

Browse Source
This commit is contained in:
lujiang 2024-08-09 19:47:55 +08:00
parent 51f0278667
commit c35263aec0
80 changed files with 2808 additions and 3232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairAddressFloorController.java Normal file
View File

@ -0,0 +1,76 @@
package com.ics.admin.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ics.common.core.domain.R;
import com.ics.common.core.controller.BaseController;
import com.ics.admin.domain.RepairAddressFloor;
import com.ics.admin.service.IRepairAddressFloorService;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* 地点楼层
*
* @author ics
* @date 2024-08-06
*/
@RestController
@RequestMapping("repairAddressFloor")
public class RepairAddressFloorController extends BaseController {
@Autowired
private IRepairAddressFloorService repairAddressFloorService;
/**
* 查询地点楼层
*/
@GetMapping("get/{id}")
public RepairAddressFloor get(@PathVariable("id") Long id) {
return repairAddressFloorService.selectRepairAddressFloorById(id);
}
/**
* 查询地点楼层列表
*/
@RequiresPermissions("floor:floor:list")
@GetMapping("list")
public R list(RepairAddressFloor repairAddressFloor) {
startPage();
return result(repairAddressFloorService.selectRepairAddressFloorList(repairAddressFloor));
}
/**
* 新增保存地点楼层
*/
@RequiresPermissions("floor:floor:add")
@PostMapping("save")
public R addSave(@RequestBody RepairAddressFloor repairAddressFloor) {
return toAjax(repairAddressFloorService.insertRepairAddressFloor(repairAddressFloor));
}
/**
* 修改保存地点楼层
*/
@RequiresPermissions("floor:floor:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairAddressFloor repairAddressFloor) {
return toAjax(repairAddressFloorService.updateRepairAddressFloor(repairAddressFloor));
}
/**
* 删除地点楼层
*/
@RequiresPermissions("floor:floor:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairAddressFloorService.deleteRepairAddressFloorByIds(ids));
}
}

76
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairAttachController.java Normal file
View File

@ -0,0 +1,76 @@
package com.ics.admin.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ics.common.core.domain.R;
import com.ics.common.core.controller.BaseController;
import com.ics.admin.domain.RepairAttach;
import com.ics.admin.service.IRepairAttachService;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* 附件 提供者
*
* @author chen
* @date 2024-07-31
*/
@RestController
@RequestMapping("repairAttach")
public class RepairAttachController extends BaseController {
@Autowired
private IRepairAttachService repairAttachService;
/**
* 查询附件
*/
@GetMapping("get/{id}")
public RepairAttach get(@PathVariable("id") Long id) {
return repairAttachService.selectRepairAttachById(id);
}
/**
* 查询附件列表
*/
@RequiresPermissions("admin:attach:list")
@GetMapping("list")
public R list(RepairAttach repairAttach) {
startPage();
return result(repairAttachService.selectRepairAttachList(repairAttach));
}
/**
* 新增保存附件
*/
@RequiresPermissions("admin:attach:add")
@PostMapping("save")
public R addSave(@RequestBody RepairAttach repairAttach) {
return toAjax(repairAttachService.insertRepairAttach(repairAttach));
}
/**
* 修改保存附件
*/
@RequiresPermissions("admin:attach:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairAttach repairAttach) {
return toAjax(repairAttachService.updateRepairAttach(repairAttach));
}
/**
* 删除附件
*/
@RequiresPermissions("admin:attach:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairAttachService.deleteRepairAttachByIds(ids));
}
}

300
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairController.java
View File

@ -1,23 +1,9 @@
package com.ics.admin.controller;
import com.ics.admin.domain.*;
import com.ics.admin.service.*;
import com.ics.admin.vo.ParkVO;
import com.ics.admin.vo.RepairVO;
import com.ics.common.annotation.LoginUser;
import com.ics.common.core.controller.BaseController;
import com.ics.common.core.domain.IcsCustomerStaff;
import com.ics.common.core.domain.R;
import com.ics.common.utils.bean.BeanUtils;
import com.ics.system.domain.User;
import com.ics.system.domain.vo.UserVO;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.wf.jwtp.annotation.Ignore;
import org.wf.jwtp.annotation.RequiresPermissions;
import java.util.List;
/**
* 工单管理 提供者
@ -39,7 +25,7 @@ public class RepairController extends BaseController {
private IIcsCustomerStaffService customerStaffService;
@Autowired
private IRepairTypeService repairTypeService;
private IRepairDeviceTypeService repairTypeService;
@Autowired
private IRepairDeviceService deviceService;
@ -47,153 +33,153 @@ public class RepairController extends BaseController {
@Autowired
private IRepairFailureTypeService repairFailureTypeService;
@Autowired
private IRepairRecordService repairRecordService;
// @Autowired
// private IRepairRecordService repairRecordService;
/**
* 查询工单管理
*/
@RequiresPermissions("admin:repair:edit")
@GetMapping("get/{id}")
public RepairVO get(@PathVariable("id") Long id) {
RepairVO repairVO = new RepairVO();
Repair repair = repairService.selectRepairById(id);
if (repair != null) {
BeanUtils.copyBeanProp(repairVO, repair);
repairVO.setStatus(repair.getStatus().getValue());
repairVO.setStatusName(repair.getStatus().getName());
//设备类型
RepairType repairType = repairTypeService.selectRepairTypeById(Long.valueOf(repair.getTypeId()));
if (null != repairType){
repairVO.setTypeName(repairType.getName());
}
//设备名称
RepairDevice repairDevice = deviceService.selectRepairDeviceById(Long.valueOf(repair.getRepairDevice()));
if (repairDevice != null) {
repairVO.setRepairDeviceName(repairDevice.getName());
}
//故障
RepairFailureType repairFailureType = repairFailureTypeService.selectRepairFailureTypeById(repair.getFailureTypeId());
if (repairFailureType != null) {
repairVO.setFailureTypeName(repairFailureType.getName());
}
IcsCustomerStaff staff = customerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair.getUserId()));
if (null != staff){
repairVO.setUserName(staff.getUsername());
}
IcsCustomerStaff worker = customerStaffService.selectIcsCustomerStaffById(repair.getWorkerId());
if (null != worker){
repairVO.setWorkerName(worker.getUsername());
}
RepairRecord repairRecord = repairRecordService.selectByRepairId(id);
if (null != repairRecord){
repairVO.setSpeed(repairRecord.getSpeed());
repairVO.setServe(repairRecord.getServe());
repairVO.setEffect(repairRecord.getEffect());
}
RepairLog repairLog = new RepairLog();
repairLog.setRepairId(id);
List<RepairLog> repairLogs = repairLogService.selectRepairLogList(repairLog);
repairVO.setRepairLogs(repairLogs);
}
return repairVO;
}
/**
* 查询工单管理列表
*/
@RequiresPermissions("admin:repair:list")
@GetMapping("list")
public R list(Repair repair, @LoginUser User user) {
startPage();
List<Repair> repairList = repairService.selectRepairList(repair);
for (Repair repair1 : repairList) {
repair1.setStatusValue(repair1.getStatus().getValue());
repair1.setStatusName(repair1.getStatus().getName());
//设备类型
if (repair1.getTypeId() != null) {
RepairType repairType = repairTypeService.selectRepairTypeById(Long.valueOf(repair1.getTypeId()));
repair1.setTypeName(repairType.getName());
}
//设备名称
if (repair1.getRepairDevice() != null){
RepairDevice repairDevice = deviceService.selectRepairDeviceById(Long.valueOf(repair1.getRepairDevice()));
repair1.setRepairDeviceName(repairDevice.getName());
}
//故障
if (repair1.getFailureTypeId() != null){
RepairFailureType repairFailureType = repairFailureTypeService.selectRepairFailureTypeById(repair1.getFailureTypeId());
repair1.setFailureTypeName(repairFailureType.getName());
}
if (repair1.getUserId() != null){
IcsCustomerStaff staff = customerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair1.getUserId()));
repair1.setUserName(staff.getUsername());
}
if (repair1.getWorkerId() != null){
IcsCustomerStaff worker = customerStaffService.selectIcsCustomerStaffById(repair1.getWorkerId());
repair1.setWorkerName(worker.getUsername());
}
}
return result(repairList);
}
/**
* 新增
*/
@RequiresPermissions("admin:repair:edit")
@PostMapping("/review")
public R review(@RequestBody Repair repair) {
Repair pRepair = repairService.selectRepairById(repair.getId());
// if (repair == null || !Repair.Status.PENDING_ASSIGN.equals(pRepair.getStatus())) {
// return R.error("报修为空或状态不是待分配");
// @RequiresPermissions("admin:repair:edit")
// @GetMapping("get/{id}")
// public RepairVO get(@PathVariable("id") Long id) {
// RepairVO repairVO = new RepairVO();
// Repair repair = repairService.selectRepairById(id);
// if (repair != null) {
// BeanUtils.copyBeanProp(repairVO, repair);
// repairVO.setStatus(repair.getStatus().getValue());
// repairVO.setStatusName(repair.getStatus().getName());
// //设备类型
// RepairDeviceType repairType = repairTypeService.selectRepairTypeById(Long.valueOf(repair.getTypeId()));
// if (null != repairType){
// repairVO.setTypeName(repairType.getName());
// }
// //设备名称
// RepairDevice repairDevice = deviceService.selectRepairDeviceById(Long.valueOf(repair.getRepairDevice()));
// if (repairDevice != null) {
// repairVO.setRepairDeviceName(repairDevice.getName());
// }
// //故障
// RepairFailureType repairFailureType = repairFailureTypeService.selectRepairFailureTypeById(repair.getFailureTypeId());
// if (repairFailureType != null) {
// repairVO.setFailureTypeName(repairFailureType.getName());
// }
// IcsCustomerStaff staff = customerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair.getUserId()));
// if (null != staff){
// repairVO.setUserName(staff.getUsername());
// }
//
// IcsCustomerStaff worker = customerStaffService.selectIcsCustomerStaffById(repair.getWorkerId());
// if (null != worker){
// repairVO.setWorkerName(worker.getUsername());
// }
//
// RepairEval repairRecord = repairRecordService.selectByRepairId(id);
// if (null != repairRecord){
// repairVO.setSpeed(repairRecord.getSpeed());
// repairVO.setServe(repairRecord.getServe());
// repairVO.setEffect(repairRecord.getEffect());
// }
// RepairLog repairLog = new RepairLog();
// repairLog.setRepairId(id);
// List<RepairLog> repairLogs = repairLogService.selectRepairLogList(repairLog);
// repairVO.setRepairLogs(repairLogs);
// }
// return repairVO;
// }
//
// /**
// * 查询工单管理列表
// */
// @RequiresPermissions("admin:repair:list")
// @GetMapping("list")
// public R list(Repair repair, @LoginUser User user) {
// startPage();
// List<Repair> repairList = repairService.selectRepairList(repair);
// for (Repair repair1 : repairList) {
// repair1.setStatusValue(repair1.getStatus().getValue());
// repair1.setStatusName(repair1.getStatus().getName());
// //设备类型
// if (repair1.getTypeId() != null) {
// RepairDeviceType repairType = repairTypeService.selectRepairTypeById(Long.valueOf(repair1.getTypeId()));
// repair1.setTypeName(repairType.getName());
// }
// //设备名称
// if (repair1.getRepairDevice() != null){
// RepairDevice repairDevice = deviceService.selectRepairDeviceById(Long.valueOf(repair1.getRepairDevice()));
// repair1.setRepairDeviceName(repairDevice.getName());
// }
// //故障
// if (repair1.getFailureTypeId() != null){
//
// RepairFailureType repairFailureType = repairFailureTypeService.selectRepairFailureTypeById(repair1.getFailureTypeId());
// repair1.setFailureTypeName(repairFailureType.getName());
// }
// if (repair1.getUserId() != null){
// IcsCustomerStaff staff = customerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair1.getUserId()));
// repair1.setUserName(staff.getUsername());
// }
//
// if (repair1.getWorkerId() != null){
// IcsCustomerStaff worker = customerStaffService.selectIcsCustomerStaffById(repair1.getWorkerId());
// repair1.setWorkerName(worker.getUsername());
// }
// }
// return result(repairList);
// }
//
// /**
// * 新增
// */
// @RequiresPermissions("admin:repair:edit")
// @PostMapping("/review")
// public R review(@RequestBody Repair repair) {
// Repair pRepair = repairService.selectRepairById(repair.getId());
//// if (repair == null || !Repair.Status.PENDING_ASSIGN.equals(pRepair.getStatus())) {
//// return R.error("报修为空或状态不是待分配");
//// }
//// repair.setStatus(Repair.Status.PENDING_PROCESS);
// repair.setStatus(Repair.Status.PENDING_PROCESS);
repair.setStatus(Repair.Status.PENDING_PROCESS);
return toAjax(repairService.insertRepair(repair));
}
/**
* 完成
*/
@RequiresPermissions("admin:repair:edit")
@PostMapping("/complete")
public R complete(@RequestBody Repair repair) {
Repair pRepair = repairService.selectRepairById(repair.getId());
if (repair == null || !Repair.Status.PENDING_PROCESS.equals(pRepair.getStatus())) {
return R.error("报修为空或状态不是待处理");
}
repair.setStatus(Repair.Status.COMPLETED);
return toAjax(repairService.updateRepair(repair));
}
/**
* 删除工单管理
*/
@RequiresPermissions("admin:repair:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairService.deleteRepairByIds(ids));
}
@Ignore
@GetMapping("selectWorkerIdByTypeId")
public R selectWorkerIdByTypeId(String typeId) {
List<IcsCustomerStaff> customerStaffs = repairService.selectWorkerIdByTypeId(typeId);
return R.data(customerStaffs);
}
//查询派单员列表
@Ignore
@GetMapping("selectDispatcher")
public R selectDispatcher() {
List<IcsCustomerStaff> customerStaffs = repairService.selectDispatcher();
return R.data(customerStaffs);
}
// return toAjax(repairService.insertRepair(repair));
// }
//
// /**
// * 完成
// */
// @RequiresPermissions("admin:repair:edit")
// @PostMapping("/complete")
// public R complete(@RequestBody Repair repair) {
// Repair pRepair = repairService.selectRepairById(repair.getId());
// if (repair == null || !Repair.Status.PENDING_PROCESS.equals(pRepair.getStatus())) {
// return R.error("报修为空或状态不是待处理");
// }
// repair.setStatus(Repair.Status.COMPLETED);
// return toAjax(repairService.updateRepair(repair));
// }
//
// /**
// * 删除工单管理
// */
// @RequiresPermissions("admin:repair:remove")
// @PostMapping("remove")
// public R remove(String ids) {
// return toAjax(repairService.deleteRepairByIds(ids));
// }
//
//
//
// @Ignore
// @GetMapping("selectWorkerIdByTypeId")
// public R selectWorkerIdByTypeId(String typeId) {
// List<IcsCustomerStaff> customerStaffs = repairService.selectWorkerIdByTypeId(typeId);
// return R.data(customerStaffs);
// }
//
// //查询派单员列表
// @Ignore
// @GetMapping("selectDispatcher")
// public R selectDispatcher() {
// List<IcsCustomerStaff> customerStaffs = repairService.selectDispatcher();
// return R.data(customerStaffs);
// }
}

23
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairDeviceController.java
View File

@ -15,7 +15,7 @@ import com.ics.admin.service.IRepairDeviceService;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* 保修设备类型 提供者
* 保修设备 提供者
*
* @author ics
* @date 2024-07-30
@ -28,7 +28,7 @@ public class RepairDeviceController extends BaseController {
private IRepairDeviceService repairDeviceService;
/**
* 查询保修设备类型
* 查询报修设备
*/
@GetMapping("get/{id}")
public RepairDevice get(@PathVariable("id") Long id) {
@ -36,9 +36,9 @@ public class RepairDeviceController extends BaseController {
}
/**
* 查询保修设备类型列表
* 查询报修设备列表
*/
@RequiresPermissions("core:repairDevice:list")
@RequiresPermissions("RepairDevice:device:list")
@GetMapping("list")
public R list(RepairDevice repairDevice) {
startPage();
@ -47,33 +47,30 @@ public class RepairDeviceController extends BaseController {
/**
* 新增保存保修设备类型
* 新增保存报修设备
*/
@RequiresPermissions("core:repairDevice:add")
@RequiresPermissions("RepairDevice:device:add")
@PostMapping("save")
public R addSave(@RequestBody RepairDevice repairDevice) {
return toAjax(repairDeviceService.insertRepairDevice(repairDevice));
}
/**
* 修改保存保修设备类型
* 修改保存报修设备
*/
@RequiresPermissions("core:repairDevice:edit")
@RequiresPermissions("RepairDevice:device:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairDevice repairDevice) {
return toAjax(repairDeviceService.updateRepairDevice(repairDevice));
}
/**
* 删除保修设备类型
* 删除报修设备
*/
@RequiresPermissions("core:repairDevice:remove")
@RequiresPermissions("RepairDevice:device:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairDeviceService.deleteRepairDeviceByIds(ids));
}
}

75
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairDeviceTypeController.java Normal file
View File

@ -0,0 +1,75 @@
package com.ics.admin.controller;
import com.ics.admin.domain.RepairDeviceType;
import com.ics.admin.service.IRepairDeviceTypeService;
import com.ics.common.core.controller.BaseController;
import com.ics.common.core.domain.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* 设备类型 提供者
*
* @author ics
* @date 2024-07-30
*/
@RestController
@RequestMapping("repairDeviceType")
public class RepairDeviceTypeController extends BaseController {
@Autowired
private IRepairDeviceTypeService repairDeviceTypeService;
/**
* 查询设备类型
*/
@GetMapping("get/{id}")
public RepairDeviceType get(@PathVariable("id") Long id) {
return repairDeviceTypeService.selectRepairDeviceTypeById(id);
}
/**
* 查询设备类型列表
*/
@RequiresPermissions("RepairDeviceType:type:list")
@GetMapping("list")
public R list(RepairDeviceType repairDeviceType) {
startPage();
return result(repairDeviceTypeService.selectRepairDeviceTypeList(repairDeviceType));
}
/**
* 新增保存设备类型
*/
@RequiresPermissions("RepairDeviceType:type:add")
@PostMapping("save")
public R addSave(@RequestBody RepairDeviceType repairDeviceType) {
return toAjax(repairDeviceTypeService.insertRepairDeviceType(repairDeviceType));
}
/**
* 修改保存设备类型
*/
@RequiresPermissions("RepairDeviceType:type:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairDeviceType repairDeviceType) {
return toAjax(repairDeviceTypeService.updateRepairDeviceType(repairDeviceType));
}
/**
* 删除设备类型
*/
@RequiresPermissions("RepairDeviceType:type:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairDeviceTypeService.deleteRepairDeviceTypeByIds(ids));
}
}

76
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairRecordController.java
View File

@ -1,76 +0,0 @@
package com.ics.admin.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ics.common.core.domain.R;
import com.ics.common.core.controller.BaseController;
import com.ics.admin.domain.RepairRecord;
import com.ics.admin.service.IRepairRecordService;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* 保修评价 提供者
*
* @author ics
* @date 2024-07-30
*/
@RestController
@RequestMapping("repairRecord")
public class RepairRecordController extends BaseController {
@Autowired
private IRepairRecordService repairRecordService;
/**
* 查询保修评价
*/
@GetMapping("get/{id}")
public RepairRecord get(@PathVariable("id") Long id) {
return repairRecordService.selectRepairRecordById(id);
}
/**
* 查询保修评价列表
*/
@RequiresPermissions("RepairRecord:record:list")
@GetMapping("list")
public R list(RepairRecord repairRecord) {
startPage();
return result(repairRecordService.selectRepairRecordList(repairRecord));
}
/**
* 新增保存保修评价
*/
@RequiresPermissions("RepairRecord:record:add")
@PostMapping("save")
public R addSave(@RequestBody RepairRecord repairRecord) {
return toAjax(repairRecordService.insertRepairRecord(repairRecord));
}
/**
* 修改保存保修评价
*/
@RequiresPermissions("RepairRecord:record:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairRecord repairRecord) {
return toAjax(repairRecordService.updateRepairRecord(repairRecord));
}
/**
* 删除保修评价
*/
@RequiresPermissions("RepairRecord:record:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairRecordService.deleteRepairRecordByIds(ids));
}
}

76
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairRelationalController.java Normal file
View File

@ -0,0 +1,76 @@
package com.ics.admin.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ics.common.core.domain.R;
import com.ics.common.core.controller.BaseController;
import com.ics.admin.domain.RepairRelational;
import com.ics.admin.service.IRepairRelationalService;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* 设备类型与派单员、维修人员的关联关系 提供者
*
* @author chen
* @date 2024-07-30
*/
@RestController
@RequestMapping("repairRelational")
public class RepairRelationalController extends BaseController {
@Autowired
private IRepairRelationalService repairRelationalService;
/**
* 查询设备类型与派单员、维修人员的关联关系
*/
@GetMapping("get/{id}")
public RepairRelational get(@PathVariable("id") Long id) {
return repairRelationalService.selectRepairRelationalById(id);
}
/**
* 查询设备类型与派单员、维修人员的关联关系列表
*/
@RequiresPermissions("admin:relational:list")
@GetMapping("list")
public R list(RepairRelational repairRelational) {
startPage();
return result(repairRelationalService.selectRepairRelationalList(repairRelational));
}
/**
* 新增保存设备类型与派单员、维修人员的关联关系
*/
@RequiresPermissions("admin:relational:add")
@PostMapping("save")
public R addSave(@RequestBody RepairRelational repairRelational) {
return toAjax(repairRelationalService.insertRepairRelational(repairRelational));
}
/**
* 修改保存设备类型与派单员、维修人员的关联关系
*/
@RequiresPermissions("admin:relational:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairRelational repairRelational) {
return toAjax(repairRelationalService.updateRepairRelational(repairRelational));
}
/**
* 删除设备类型与派单员、维修人员的关联关系
*/
@RequiresPermissions("admin:relational:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairRelationalService.deleteRepairRelationalByIds(ids));
}
}

76
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairRoomController.java
View File

@ -1,76 +0,0 @@
package com.ics.admin.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ics.common.core.domain.R;
import com.ics.common.core.controller.BaseController;
import com.ics.admin.domain.RepairRoom;
import com.ics.admin.service.IRepairRoomService;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* 报修房间 提供者
*
* @author ics
* @date 2024-08-06
*/
@RestController
@RequestMapping("repairRoom")
public class RepairRoomController extends BaseController {
@Autowired
private IRepairRoomService repairRoomService;
/**
* 查询报修房间
*/
@GetMapping("get/{id}")
public RepairRoom get(@PathVariable("id") Long id) {
return repairRoomService.selectRepairRoomById(id);
}
/**
* 查询报修房间列表
*/
@RequiresPermissions("repair:room:list")
@GetMapping("list")
public R list(RepairRoom repairRoom) {
startPage();
return result(repairRoomService.selectRepairRoomList(repairRoom));
}
/**
* 新增保存报修房间
*/
@RequiresPermissions("repair:room:add")
@PostMapping("save")
public R addSave(@RequestBody RepairRoom repairRoom) {
return toAjax(repairRoomService.insertRepairRoom(repairRoom));
}
/**
* 修改保存报修房间
*/
@RequiresPermissions("repair:room:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairRoom repairRoom) {
return toAjax(repairRoomService.updateRepairRoom(repairRoom));
}
/**
* 删除报修房间
*/
@RequiresPermissions("repair:room:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairRoomService.deleteRepairRoomByIds(ids));
}
}

76
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairStaffTypeController.java
View File

@ -1,76 +0,0 @@
package com.ics.admin.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ics.common.core.domain.R;
import com.ics.common.core.controller.BaseController;
import com.ics.admin.domain.RepairStaffType;
import com.ics.admin.service.IRepairStaffTypeService;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* RepairStaffType 提供者
*
* @author chen
* @date 2024-07-30
*/
@RestController
@RequestMapping("staffType")
public class RepairStaffTypeController extends BaseController {
@Autowired
private IRepairStaffTypeService repairStaffTypeService;
/**
* 查询RepairStaffType
*/
@GetMapping("get/{id}")
public RepairStaffType get(@PathVariable("id") Long id) {
return repairStaffTypeService.selectRepairStaffTypeById(id);
}
/**
* 查询RepairStaffType列表
*/
@RequiresPermissions("RepairStaffType:type:list")
@GetMapping("list")
public R list(RepairStaffType repairStaffType) {
startPage();
return result(repairStaffTypeService.selectRepairStaffTypeList(repairStaffType));
}
/**
* 新增保存RepairStaffType
*/
@RequiresPermissions("RepairStaffType:type:add")
@PostMapping("save")
public R addSave(@RequestBody RepairStaffType repairStaffType) {
return toAjax(repairStaffTypeService.insertRepairStaffType(repairStaffType));
}
/**
* 修改保存RepairStaffType
*/
@RequiresPermissions("RepairStaffType:type:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairStaffType repairStaffType) {
return toAjax(repairStaffTypeService.updateRepairStaffType(repairStaffType));
}
/**
* 删除RepairStaffType
*/
@RequiresPermissions("RepairStaffType:type:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairStaffTypeService.deleteRepairStaffTypeByIds(ids));
}
}

132
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairTypeController.java
View File

@ -1,132 +0,0 @@
package com.ics.admin.controller;
import com.ics.admin.domain.RepairStaffType;
import com.ics.admin.domain.RepairWorkerType;
import com.ics.admin.domain.meeting.StaffCustomer;
import com.ics.admin.service.IIcsCustomerStaffService;
import com.ics.admin.service.IRepairStaffTypeService;
import com.ics.admin.service.IRepairWorkerTypeService;
import com.ics.common.core.domain.IcsCustomerStaff;
import com.ics.common.utils.DateUtils;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ics.common.core.domain.R;
import com.ics.common.core.controller.BaseController;
import com.ics.admin.domain.RepairType;
import com.ics.admin.service.IRepairTypeService;
import org.wf.jwtp.annotation.RequiresPermissions;
import java.util.List;
/**
* 设备类型 提供者
*
* @author ics
* @date 2024-07-30
*/
@RestController
@RequestMapping("repairType")
public class RepairTypeController extends BaseController {
@Autowired
private IRepairTypeService repairTypeService;
@Autowired
private IRepairStaffTypeService repairStaffTypeService;
@Autowired
private IIcsCustomerStaffService customerStaffService;
@Autowired
private IRepairWorkerTypeService workerTypeService;
/**
* 查询设备类型
*/
@GetMapping("get/{id}")
public RepairType get(@PathVariable("id") Long id) {
return repairTypeService.selectRepairTypeById(id);
}
/**
* 查询设备类型列表
*/
@RequiresPermissions("RepairType:repairType:list")
@GetMapping("list")
public R list(RepairType repairType) {
startPage();
List<RepairType> repairTypes = repairTypeService.selectRepairTypeList(repairType);
for (RepairType type : repairTypes) {
//获取派单员名称
RepairStaffType repairStaffType = repairStaffTypeService.selectStaffIdByTypeId(type.getId());
if (repairStaffType != null) {
IcsCustomerStaff staff = customerStaffService.selectIcsCustomerStaffById(repairStaffType.getStaffId());
if (staff != null) {
type.setStaffName(staff.getName());
}
}
//获取维修工人数据
List<IcsCustomerStaff> customerStaffs = workerTypeService.selectRepairWorkerTypeListByTypeId(type.getId());
if (customerStaffs != null && customerStaffs.size() > 0) {
type.setWorkerNames(customerStaffs.get(0).getUsername()+"等"+customerStaffs.size()+"人");
type.setWorkerList(customerStaffs);
}
}
return result(repairTypes);
}
/**
* 新增保存设备类型
*/
@RequiresPermissions("RepairType:repairType:add")
@PostMapping("save")
public R addSave(@RequestBody RepairType repairType) {
int i = repairTypeService.insertRepairType(repairType);
if (i <= 0) {
return R.error("添加失败");
}
//添加设备类型和用户关联关系
RepairStaffType repairStaffType = new RepairStaffType();
repairStaffType.setTypeId(repairType.getId());
repairStaffType.setStaffId(repairType.getStaffId());
repairStaffType.setCreateTime(DateUtils.getNowDate());
repairStaffTypeService.insertRepairStaffType(repairStaffType);
IcsCustomerStaff staff = new IcsCustomerStaff();
staff.setStaffId(repairType.getStaffId());
staff.setDataType("2");
//更新用户数据类型
customerStaffService.updateIcsCustomerStaff(staff);
return toAjax(i);
}
/**
* 修改保存设备类型
*/
@RequiresPermissions("RepairType:repairType:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairType repairType) {
return toAjax(repairTypeService.updateRepairType(repairType));
}
/**
* 删除设备类型
*/
@RequiresPermissions("RepairType:repairType:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairTypeService.deleteRepairTypeByIds(ids));
}
}

76
shoot-hand/ics-admin/src/main/java/com/ics/admin/controller/RepairWorkerTypeController.java
View File

@ -1,76 +0,0 @@
package com.ics.admin.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ics.common.core.domain.R;
import com.ics.common.core.controller.BaseController;
import com.ics.admin.domain.RepairWorkerType;
import com.ics.admin.service.IRepairWorkerTypeService;
import org.wf.jwtp.annotation.RequiresPermissions;
/**
* 维修人分类关联 提供者
*
* @author chen
* @date 2024-07-31
*/
@RestController
@RequestMapping("type")
public class RepairWorkerTypeController extends BaseController {
@Autowired
private IRepairWorkerTypeService repairWorkerTypeService;
/**
* 查询维修人分类关联
*/
@GetMapping("get/{id}")
public RepairWorkerType get(@PathVariable("id") Long id) {
return repairWorkerTypeService.selectRepairWorkerTypeById(id);
}
/**
* 查询维修人分类关联列表
*/
@RequiresPermissions("RepairWorkerType:type:list")
@GetMapping("list")
public R list(RepairWorkerType repairWorkerType) {
startPage();
return result(repairWorkerTypeService.selectRepairWorkerTypeList(repairWorkerType));
}
/**
* 新增保存维修人分类关联
*/
@RequiresPermissions("RepairWorkerType:type:add")
@PostMapping("save")
public R addSave(@RequestBody RepairWorkerType repairWorkerType) {
return toAjax(repairWorkerTypeService.insertRepairWorkerType(repairWorkerType));
}
/**
* 修改保存维修人分类关联
*/
@RequiresPermissions("RepairWorkerType:type:edit")
@PostMapping("update")
public R editSave(@RequestBody RepairWorkerType repairWorkerType) {
return toAjax(repairWorkerTypeService.updateRepairWorkerType(repairWorkerType));
}
/**
* 删除维修人分类关联
*/
@RequiresPermissions("RepairWorkerType:type:remove")
@PostMapping("remove")
public R remove(String ids) {
return toAjax(repairWorkerTypeService.deleteRepairWorkerTypeByIds(ids));
}
}

328
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/Repair.java
View File

@ -1,20 +1,15 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.IEnum;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ics.admin.handler.BannerImageHandler;
import com.ics.common.core.domain.BaseEntity;
import com.ics.system.domain.User;
import lombok.Data;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* 工单管理对象 ics_repair
* 工单
*
* @author ics
* @date 2021-03-25
@ -22,37 +17,40 @@ import java.util.List;
@Data
@TableName("ics_repair")
public class Repair extends BaseEntity<Repair> {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = -202408072032L;
/**
* 报修单号
*/
private String sn;
/**
* 报修名称
*/
private String repairName;
/**
* 故障等级
*/
private String repairLevel;
/**
* 故障时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date repairTime;
/**
* 设备类别id
*/
private Integer typeId;
@TableField(exist = false)
/**
* 设备类别名称
*/
private String typeName;
private Integer repairDevice;
@TableField(exist = false)
private String repairDeviceName;
private String repairVoice;
private Integer userId;
@TableField(exist = false)
private String userName;
private Integer dispatcherId;
@TableField(exist = false)
private String dispatcherName;
/**
* 设备id
*/
private Integer deviceId;
/**
* 设备名称
*/
private String deviceName;
/**
* 报修人
@ -63,206 +61,152 @@ public class Repair extends BaseEntity<Repair> {
* 联系电话
*/
private String phone;
/**
* 报修区域
* 报修地点id
*/
private String area;
private String addressId;
/**
* 状态:待分配,待评估,处理中,已处理, 已处理,待评价,已评价
* 报修地点名称
*/
private Status status;
@TableField(exist = false)
private Integer statusValue;
@TableField(exist = false)
private String statusName;
public enum Status implements IEnum<Integer> {
/**
* 待分配
*/
PENDING_ASSIGN("待分配", 1),
/**
* 提交反馈
*/
SUBMIT_FEEDBACK("提交反馈", 2),
/**
* 维修员：显示待处理， 派单员：已派单
*/
PENDING_PROCESS("待处理", 3),
/**
* 处理中
*/
PROCESSING("处理中", 4),
/**
* 已完成
*/
COMPLETED("已完成", 5),
/**
* 已评价
*/
SCORE("已评价", 6),
/**
* 已取消
*/
CANCELED("已取消", 7);
private String name;
private int value;
Status(String name, int value) {
this.name = name;
this.value = value;
}
@Override
public Integer getValue() {
return this.value;
}
public String getName() {
return this.name;
}
public static Status parse(Integer value) {
for (Status status : values()) {
if (status.getValue().equals(value)) {
return status;
}
}
return null;
}
}
private String address;
/**
* 报修楼层id
*/
private String floorId;
/**
* 报修楼层名称
*/
private String floor;
/**
* 门牌号
*/
private String room;
/**
* 描述
*/
private String content;
//--派单
/**
* failure_date 故障时间
* 派单员id
*/
private long perUserId;
/**
* 派单员姓名
*/
@TableField(exist = false)
private String perUserrName;
/**
* 预计完成时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date failureDate;
private Date preDate;
//--维修人员反馈
/**
* 报修时间
* 分析原因
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date repairTime;
private String cause;
/**
* 报修图片
* 解决方案
*/
private String repairImages;
private String solution;
/**
* 维修费
* 故障类型id
*/
private Long repairFee;
private Long failureTypeId;
/**
* 评价
* 故障类型名称
*/
private Long repairScore;
private Long failureTypeName;
/**
* 维修材料
* 是否解决 1 已解决 0 未解决
*/
private String repairMateriel;
private Integer resolve;
/**
* 开始时间
* 维修人员id
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date beginDate;
private long repairUserId;
/**
* 结束时间
* 维修人员姓名
*/
@TableField(exist = false)
private String repairUserName;
/**
* 维修人员反馈时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date endDate;
//--评价
/** 服务评价 */
private Integer evalService;
/** 留言反馈 */
private String feedback;
/**
* 意见建议
* 评价时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date evalTime;
/**
* 评价人id
*/
private long evalUserId;
/**
* 评价人姓名
*/
@TableField(exist = false)
private long evalUserName;
//--超时
/**
* 设置超时时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date timeout;
/** 预警状态， 默认0 没有预警；设置时间后 1 绿色 3橙色 5红色 */
private Integer warn;
//工单状态，流程相关
/**
* 状态:1 待派单,3 重新派单,5 已派单,7 处理中, 9已完成 待评价, 11 已关闭 13 已评价
* 1 报修给派单员
* 3 给到网格长重新派单
* 5 指派维修工
* 7 维修工接单
* 9 维修工完成工单
* 11 派单员无效申请
* 13 已评价
*
*
* 报修人：全部、处理中、待评价、已评价
* 派单员：重新派单、待派单、已派单、已关闭
* 维修工：待完成、进行中、已完成
* 管理员：重派单，全部
*
*/
private Integer status;
/**
* 当前日志记录id
*/
private long logId;
/**
* 备注
*/
private String remark;
/**
* 评价工人
*/
private Long workerScore;
/**
* 维修工人
*/
private Long workerId;
@TableField(exist = false)
private String workerName;
/**
* 维修说明
*/
private String workerExplain;
/**
* 维修凭证
*/
private String workerProof;
/**
* 公司ID
*/
private Long customerId;
/**
* 公司
*/
@TableField(exist = false)
private Customer customer;
/**
* 园区
*/
@TableField(exist = false)
private Park park;
/**
* 用户
*/
@TableField(exist = false)
private User user;
private Long parkId;
private Long failureTypeId;
private Long addressId;
@TableField(exist = false)
private String addressName;
private Long roomId;
@TableField(exist = false)
private String roomName;
@TableField(exist = false)
private String failureTypeName;
private String ext1;
private String ext2;
private String ext3;
}

11
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairAddress.java
View File

@ -5,7 +5,7 @@ import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 报修地址对象 ics_repair_address
* 报修地点
*
* @author ics
* @date 2024-08-06
@ -13,15 +13,14 @@ import lombok.Data;
@Data
@TableName("ics_repair_address")
public class RepairAddress extends BaseEntity<RepairAddress> {
private static final long serialVersionUID = 1L;
/** $column.columnComment */
private static final long serialVersionUID = -202408082125L;
/**
* 地点名称
*/
private String name;
/** 备注 */
private String remark;
/** 园区ID */
private Long parkId;
}

36
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairAddressFloor.java Normal file
View File

@ -0,0 +1,36 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 报修地点楼层 ---ics_repair_room
*
* @author ics
* @date 2024-08-06
*/
@Data
@TableName("ics_repair_address_floor")
public class RepairAddressFloor extends BaseEntity<RepairAddressFloor> {
private static final long serialVersionUID = -202408082126L;
/** 地点id */
private Long addressId;
/**
* 楼层名称
*/
private String name;
/** 楼层管理员id */
private Long adminId;
/** 备注 */
private String remark;
}

46
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairAttach.java Normal file
View File

@ -0,0 +1,46 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 附件 --ics_repair_worker_type
*
* @author chen
* @date 2024-07-31
*/
@Data
@TableName("ics_repair_attach")
public class RepairAttach extends BaseEntity<RepairAttach> {
private static final long serialVersionUID = -202408082136L;
/**
* 工单id
*/
private Long repairId;
/**
* 文件所属环节 1保修 9维修工反馈附件 13 评价附件
*/
private Integer nodeId;
/**
* 源文件名
*/
private String originalFilename;
/**
* 附件名称
*/
private String fileName;
/**
* 文件路径
*/
private String url;
/**
* 文件大小
*/
private Long fileSize;
/**扩展*/
private String ext1;
private String ext2;
private String ext3;
}

18
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairDevice.java
View File

@ -5,7 +5,7 @@ import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 保修设备类型对象 ics_repair_device
* 报修设备类型对象
*
* @author ics
* @date 2024-07-30
@ -13,7 +13,12 @@ import lombok.Data;
@Data
@TableName("ics_repair_device")
public class RepairDevice extends BaseEntity<RepairDevice> {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = -202408072130L;
/**
* 类别id
*/
private Long typeId;
/** 名称 */
private String name;
@ -24,18 +29,9 @@ public class RepairDevice extends BaseEntity<RepairDevice> {
/** 规格 */
private String specification;
/** 图片url */
private String picUrl;
/** 附件url */
private String fileUrl;
/** 备注 */
private String remark;
/** 园区ID */
private Long parkId;
private Long typeId;
}

25
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairDeviceType.java Normal file
View File

@ -0,0 +1,25 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 设备类型对象 ics_repair_type
*
* @author ics
* @date 2024-07-30
*/
@Data
@TableName("ics_repair_device_type")
public class RepairDeviceType extends BaseEntity<RepairDeviceType> {
private static final long serialVersionUID = -20240808202541L;
/** 名称 */
private String name;
/** 备注 */
private String remark;
}

10
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairFailureType.java
View File

@ -5,7 +5,7 @@ import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 故障类型对象 ics_repair_failure_type
* 故障类型，维修人员反馈
*
* @author chen
* @date 2024-08-05
@ -13,15 +13,17 @@ import lombok.Data;
@Data
@TableName("ics_repair_failure_type")
public class RepairFailureType extends BaseEntity<RepairFailureType> {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = -202408082153L;
/** 名称 */
private String name;
/**
* 故障类型值
*/
private Integer kind;
/** 备注 */
private String remark;
/** 园区ID */
private Long parkId;
}

97
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairLog.java
View File

@ -1,14 +1,14 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.admin.domain.enumHandler.RepairStatusEnumHandler;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
import java.util.Date;
/**
* 报修记录对象 ics_repair_log
* 工单流程日志
*
* @author ics
* @date 2021-03-25
@ -16,26 +16,79 @@ import lombok.Data;
@Data
@TableName("ics_repair_log")
public class RepairLog extends BaseEntity<RepairLog> {
private static final long serialVersionUID = 1L;
/** 类型 */
@TableField(typeHandler = RepairStatusEnumHandler.class)
private Repair.Status type;
/** 详情 */
private String detail;
/** 报修单 */
private Long repairId;
@TableField(exist = false)
private Long tenantId;
private static final long serialVersionUID = -202408082032L;
/**
* 关联园区ID
* 父id
*/
// @TableField(fill = FieldFill.INSERT)
@TableField(exist = false)
private Long parkId;
private Long pid;
/**
* 工单id
*/
private Long repairId;
/**
* 源节点
*/
private Integer form;
/**
* 去向节点
*/
private Integer to;
/**
* 发送人id
*/
private long sendUserId;
/**
* 发送人姓名
*/
private String sendUserName;
/**
* 接受人id
*/
private long recUserId;
/**
* 接受人姓名
*/
private String recUserName;
/**
* 是否已读 0，未读 1，已读
*/
private Integer read;
/**
* 已读时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date readTime;
/**
* 完成状态 0，未完成 1，已完成
*/
private Integer status;
/**
* 结束时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date closeTime;
/** 日志内容 */
private String content;
/**
* 备注
*/
private String remark;
/**
* 扩展
*/
private String ext1;
private String ext2;
private String ext3;
}

45
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairRecord.java
View File

@ -1,45 +0,0 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 保修评价对象 ics_repair_record
*
* @author ics
* @date 2024-07-30
*/
@Data
@TableName("ics_repair_record")
public class RepairRecord extends BaseEntity<RepairRecord> {
private static final long serialVersionUID = 1L;
/** 维修速度 */
private Integer speed;
/** 服务评价 */
private Integer serve;
/** 效果评价 */
private Integer effect;
/** 留言反馈 */
private String remark;
/** 图片 */
private String img;
/** 园区ID */
private Long parkId;
/** 保修id */
private Long repairId;
/** 维修人员id */
private Long workerId;
/** 评价人id */
private Long userId;
}

42
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairRelational.java Normal file
View File

@ -0,0 +1,42 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 设备类型与派单员、维修人员的关联关系---ics_repair_staff_type
*
* @author chen
* @date 2024-07-30
*/
@Data
@TableName("ics_repair_relational")
public class RepairRelational extends BaseEntity<RepairRelational> {
private static final long serialVersionUID = 202408082157L;
/**
* 设备类型id
*/
private Long typeId;
/**
* 关系类型 1 派单员 3 维修工
*/
private Integer kind;
/**
* 组名，暂时无用
*/
private String groupName;
/**
* 人员id
*/
private Long userId;
}

30
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairRoom.java
View File

@ -1,30 +0,0 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 报修房间对象 ics_repair_room
*
* @author ics
* @date 2024-08-06
*/
@Data
@TableName("ics_repair_room")
public class RepairRoom extends BaseEntity<RepairRoom> {
private static final long serialVersionUID = 1L;
/** $column.columnComment */
private String name;
/** 备注 */
private String remark;
/** 园区ID */
private Long parkId;
/** 地址id */
private Long addressId;
}

27
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairStaffType.java
View File

@ -1,27 +0,0 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* RepairStaffType对象 ics_repair_staff_type
*
* @author chen
* @date 2024-07-30
*/
@Data
@TableName("ics_repair_staff_type")
public class RepairStaffType extends BaseEntity<RepairStaffType> {
private static final long serialVersionUID = 1L;
/** 派单员id */
private Long staffId;
/** 设备类型id */
private Long typeId;
/** 园区ID */
private Long parkId;
}

49
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairType.java
View File

@ -1,49 +0,0 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import com.ics.common.core.domain.IcsCustomerStaff;
import lombok.Data;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.util.List;
/**
* 设备类型对象 ics_repair_type
*
* @author ics
* @date 2024-07-30
*/
@Data
@TableName("ics_repair_type")
public class RepairType extends BaseEntity<RepairType> {
private static final long serialVersionUID = 1L;
/** 名称 */
private String name;
/** 备注 */
private String remark;
/** 园区ID */
private Long parkId;
//派单员id
@TableField(exist = false)
private Long staffId;
@TableField(exist = false)
private String staffName;
@TableField(exist = false)
private String workerNames;
@TableField(exist = false)
private List<IcsCustomerStaff> workerList;
}

27
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/RepairWorkerType.java
View File

@ -1,27 +0,0 @@
package com.ics.admin.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ics.common.core.domain.BaseEntity;
import lombok.Data;
/**
* 维修人分类关联对象 ics_repair_worker_type
*
* @author chen
* @date 2024-07-31
*/
@Data
@TableName("ics_repair_worker_type")
public class RepairWorkerType extends BaseEntity<RepairWorkerType> {
private static final long serialVersionUID = 1L;
/** 维修人id */
private Long workerId;
/** 设备类型id */
private Long typeId;
/** 园区ID */
private Long parkId;
}

44
shoot-hand/ics-admin/src/main/java/com/ics/admin/domain/enumHandler/RepairStatusEnumHandler.java
View File

@ -1,44 +0,0 @@
package com.ics.admin.domain.enumHandler;
import com.ics.admin.domain.Repair;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* @author 29361
*/
@MappedJdbcTypes({JdbcType.INTEGER})
@MappedTypes({Repair.Status.class})
public class RepairStatusEnumHandler extends BaseTypeHandler<Repair.Status> {
@Override
public void setNonNullParameter(PreparedStatement preparedStatement, int i, Repair.Status status, JdbcType jdbcType) throws SQLException {
preparedStatement.setInt(i,status.getValue());
}
@Override
public Repair.Status getNullableResult(ResultSet resultSet, String columnName) throws SQLException {
int value = resultSet.getInt(columnName);
Repair.Status instance = Repair.Status.parse(value);
return instance;
}
@Override
public Repair.Status getNullableResult(ResultSet resultSet, int columnIndex) throws SQLException {
int value = resultSet.getInt(columnIndex);
Repair.Status instance = Repair.Status.parse(value);
return instance;
}
@Override
public Repair.Status getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
return null;
}
}

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairAddressFloorMapper.java Normal file
View File

@ -0,0 +1,64 @@
package com.ics.admin.mapper;
import com.ics.admin.domain.RepairAddressFloor;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 地点楼层Mapper接口
*
* @author ics
* @date 2024-08-06
*/
@Mapper
public interface RepairAddressFloorMapper extends BaseMapper<RepairAddressFloor> {
/**
* 查询地点楼层
*
* @param id 地点楼层ID
* @return 地点楼层
*/
RepairAddressFloor selectRepairAddressFloorById(Long id);
/**
* 查询地点楼层列表
*
* @param repairAddressFloor 地点楼层
* @return 地点楼层集合
*/
List<RepairAddressFloor> selectRepairAddressFloorList(RepairAddressFloor repairAddressFloor);
/**
* 新增地点楼层
*
* @param repairAddressFloor 地点楼层
* @return 结果
*/
int insertRepairAddressFloor(RepairAddressFloor repairAddressFloor);
/**
* 修改地点楼层
*
* @param repairAddressFloor 地点楼层
* @return 结果
*/
int updateRepairAddressFloor(RepairAddressFloor repairAddressFloor);
/**
* 删除地点楼层
*
* @param id 地点楼层ID
* @return 结果
*/
int deleteRepairAddressFloorById(Long id);
/**
* 批量删除地点楼层
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairAddressFloorByIds(String[] ids);
}

12
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairAddressMapper.java
View File

@ -16,7 +16,7 @@ import java.util.List;
public interface RepairAddressMapper extends BaseMapper<RepairAddress> {
/**
* 查询报修地址
*
*
* @param id 报修地址ID
* @return 报修地址
*/
@ -24,7 +24,7 @@ public interface RepairAddressMapper extends BaseMapper<RepairAddress> {
/**
* 查询报修地址列表
*
*
* @param repairAddress 报修地址
* @return 报修地址集合
*/
@ -32,7 +32,7 @@ public interface RepairAddressMapper extends BaseMapper<RepairAddress> {
/**
* 新增报修地址
*
*
* @param repairAddress 报修地址
* @return 结果
*/
@ -40,7 +40,7 @@ public interface RepairAddressMapper extends BaseMapper<RepairAddress> {
/**
* 修改报修地址
*
*
* @param repairAddress 报修地址
* @return 结果
*/
@ -48,7 +48,7 @@ public interface RepairAddressMapper extends BaseMapper<RepairAddress> {
/**
* 删除报修地址
*
*
* @param id 报修地址ID
* @return 结果
*/
@ -56,7 +56,7 @@ public interface RepairAddressMapper extends BaseMapper<RepairAddress> {
/**
* 批量删除报修地址
*
*
* @param ids 需要删除的数据ID
* @return 结果
*/

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairAttachMapper.java Normal file
View File

@ -0,0 +1,64 @@
package com.ics.admin.mapper;
import com.ics.admin.domain.RepairAttach;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 维修人分类关联Mapper接口
*
* @author chen
* @date 2024-07-31
*/
@Mapper
public interface RepairAttachMapper extends BaseMapper<RepairAttach> {
/**
* 查询附件
*
* @param id 附件ID
* @return 附件
*/
RepairAttach selectRepairAttachById(Long id);
/**
* 查询附件列表
*
* @param repairAttach 附件
* @return 附件集合
*/
List<RepairAttach> selectRepairAttachList(RepairAttach repairAttach);
/**
* 新增附件
*
* @param repairAttach 附件
* @return 结果
*/
int insertRepairAttach(RepairAttach repairAttach);
/**
* 修改附件
*
* @param repairAttach 附件
* @return 结果
*/
int updateRepairAttach(RepairAttach repairAttach);
/**
* 删除附件
*
* @param id 附件ID
* @return 结果
*/
int deleteRepairAttachById(Long id);
/**
* 批量删除附件
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairAttachByIds(String[] ids);
}

40
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairDeviceMapper.java
View File

@ -7,7 +7,7 @@ import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 保修设备类型Mapper接口
* 报修设备Mapper接口
*
* @author ics
* @date 2024-07-30
@ -15,48 +15,48 @@ import java.util.List;
@Mapper
public interface RepairDeviceMapper extends BaseMapper<RepairDevice> {
/**
* 查询保修设备类型
*
* @param id 保修设备类型ID
* @return 保修设备类型
* 查询报修设备
*
* @param id 报修设备ID
* @return 报修设备
*/
RepairDevice selectRepairDeviceById(Long id);
/**
* 查询保修设备类型列表
*
* @param repairDevice 保修设备类型
* @return 保修设备类型集合
* 查询报修设备列表
*
* @param repairDevice 报修设备
* @return 报修设备集合
*/
List<RepairDevice> selectRepairDeviceList(RepairDevice repairDevice);
/**
* 新增保修设备类型
*
* @param repairDevice 保修设备类型
* 新增报修设备
*
* @param repairDevice 报修设备
* @return 结果
*/
int insertRepairDevice(RepairDevice repairDevice);
/**
* 修改保修设备类型
*
* @param repairDevice 保修设备类型
* 修改报修设备
*
* @param repairDevice 报修设备
* @return 结果
*/
int updateRepairDevice(RepairDevice repairDevice);
/**
* 删除保修设备类型
*
* @param id 保修设备类型ID
* 删除报修设备
*
* @param id 报修设备ID
* @return 结果
*/
int deleteRepairDeviceById(Long id);
/**
* 批量删除保修设备类型
*
* 批量删除报修设备
*
* @param ids 需要删除的数据ID
* @return 结果
*/

34
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairTypeMapper.java → shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairDeviceTypeMapper.java
View File

@ -1,6 +1,6 @@
package com.ics.admin.mapper;
import com.ics.admin.domain.RepairType;
import com.ics.admin.domain.RepairDeviceType;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@ -13,52 +13,52 @@ import java.util.List;
* @date 2024-07-30
*/
@Mapper
public interface RepairTypeMapper extends BaseMapper<RepairType> {
public interface RepairDeviceTypeMapper extends BaseMapper<RepairDeviceType> {
/**
* 查询设备类型
*
*
* @param id 设备类型ID
* @return 设备类型
*/
RepairType selectRepairTypeById(Long id);
RepairDeviceType selectRepairDeviceTypeById(Long id);
/**
* 查询设备类型列表
*
* @param repairType 设备类型
*
* @param repairDeviceType 设备类型
* @return 设备类型集合
*/
List<RepairType> selectRepairTypeList(RepairType repairType);
List<RepairDeviceType> selectRepairDeviceTypeList(RepairDeviceType repairDeviceType);
/**
* 新增设备类型
*
* @param repairType 设备类型
*
* @param repairDeviceType 设备类型
* @return 结果
*/
int insertRepairType(RepairType repairType);
int insertRepairDeviceType(RepairDeviceType repairDeviceType);
/**
* 修改设备类型
*
* @param repairType 设备类型
*
* @param repairDeviceType 设备类型
* @return 结果
*/
int updateRepairType(RepairType repairType);
int updateRepairDeviceType(RepairDeviceType repairDeviceType);
/**
* 删除设备类型
*
*
* @param id 设备类型ID
* @return 结果
*/
int deleteRepairTypeById(Long id);
int deleteRepairDeviceTypeById(Long id);
/**
* 批量删除设备类型
*
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairTypeByIds(String[] ids);
int deleteRepairDeviceTypeByIds(String[] ids);
}

48
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairLogMapper.java
View File

@ -7,7 +7,7 @@ import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 报修记录Mapper接口
* 流程日志Mapper接口
*
* @author ics
* @date 2021-03-25
@ -16,10 +16,50 @@ import java.util.List;
public interface RepairLogMapper extends BaseMapper<RepairLog> {
/**
* 查询报修记录列表
* 查询流程日志
*
* @param repairLog 报修记录
* @return 报修记录集合
* @param id 流程日志ID
* @return 流程日志
*/
RepairLog selectRepairLogById(Long id);
/**
* 查询流程日志列表
*
* @param repairLog 流程日志
* @return 流程日志集合
*/
List<RepairLog> selectRepairLogList(RepairLog repairLog);
/**
* 新增流程日志
*
* @param repairLog 流程日志
* @return 结果
*/
int insertRepairLog(RepairLog repairLog);
/**
* 修改流程日志
*
* @param repairLog 流程日志
* @return 结果
*/
int updateRepairLog(RepairLog repairLog);
/**
* 删除流程日志
*
* @param id 流程日志ID
* @return 结果
*/
int deleteRepairLogById(Long id);
/**
* 批量删除流程日志
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairLogByIds(String[] ids);
}

48
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairMapper.java
View File

@ -15,27 +15,51 @@ import java.util.List;
@Mapper
public interface RepairMapper extends BaseMapper<Repair> {
/**
* 查询工单管理
*
* @param id 工单管理ID
* @return 工单管理
* 查询工单
*
* @param id 工单ID
* @return 工单
*/
Repair selectRepairById(Long id);
/**
* 查询工单管理列表
*
* @param repair 工单管理
* @return 工单管理集合
* 查询工单列表
*
* @param repair 工单
* @return 工单集合
*/
List<Repair> selectRepairList(Repair repair);
/**
* 查询我的工单管理列表
* 新增工单
*
* @param repair 工单管理
* @return 工单管理集合
* @param repair 工单
* @return 结果
*/
List<Repair> selectMyRepairList(Repair repair);
int insertRepair(Repair repair);
/**
* 修改工单
*
* @param repair 工单
* @return 结果
*/
int updateRepair(Repair repair);
/**
* 删除工单
*
* @param id 工单ID
* @return 结果
*/
int deleteRepairById(Long id);
/**
* 批量删除工单
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairByIds(String[] ids);
}

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairRecordMapper.java
View File

@ -1,64 +0,0 @@
package com.ics.admin.mapper;
import com.ics.admin.domain.RepairRecord;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 保修评价Mapper接口
*
* @author ics
* @date 2024-07-30
*/
@Mapper
public interface RepairRecordMapper extends BaseMapper<RepairRecord> {
/**
* 查询保修评价
*
* @param id 保修评价ID
* @return 保修评价
*/
RepairRecord selectRepairRecordById(Long id);
/**
* 查询保修评价列表
*
* @param repairRecord 保修评价
* @return 保修评价集合
*/
List<RepairRecord> selectRepairRecordList(RepairRecord repairRecord);
/**
* 新增保修评价
*
* @param repairRecord 保修评价
* @return 结果
*/
int insertRepairRecord(RepairRecord repairRecord);
/**
* 修改保修评价
*
* @param repairRecord 保修评价
* @return 结果
*/
int updateRepairRecord(RepairRecord repairRecord);
/**
* 删除保修评价
*
* @param id 保修评价ID
* @return 结果
*/
int deleteRepairRecordById(Long id);
/**
* 批量删除保修评价
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairRecordByIds(String[] ids);
}

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairRelationalMapper.java Normal file
View File

@ -0,0 +1,64 @@
package com.ics.admin.mapper;
import com.ics.admin.domain.RepairRelational;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* RepairStaffTypeMapper接口
*
* @author chen
* @date 2024-07-30
*/
@Mapper
public interface RepairRelationalMapper extends BaseMapper<RepairRelational> {
/**
* 查询设备类型与派单员、维修人员的关联关系
*
* @param id 设备类型与派单员、维修人员的关联关系ID
* @return 设备类型与派单员、维修人员的关联关系
*/
RepairRelational selectRepairRelationalById(Long id);
/**
* 查询设备类型与派单员、维修人员的关联关系列表
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 设备类型与派单员、维修人员的关联关系集合
*/
List<RepairRelational> selectRepairRelationalList(RepairRelational repairRelational);
/**
* 新增设备类型与派单员、维修人员的关联关系
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 结果
*/
int insertRepairRelational(RepairRelational repairRelational);
/**
* 修改设备类型与派单员、维修人员的关联关系
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 结果
*/
int updateRepairRelational(RepairRelational repairRelational);
/**
* 删除设备类型与派单员、维修人员的关联关系
*
* @param id 设备类型与派单员、维修人员的关联关系ID
* @return 结果
*/
int deleteRepairRelationalById(Long id);
/**
* 批量删除设备类型与派单员、维修人员的关联关系
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairRelationalByIds(String[] ids);
}

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairRoomMapper.java
View File

@ -1,64 +0,0 @@
package com.ics.admin.mapper;
import com.ics.admin.domain.RepairRoom;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 报修房间Mapper接口
*
* @author ics
* @date 2024-08-06
*/
@Mapper
public interface RepairRoomMapper extends BaseMapper<RepairRoom> {
/**
* 查询报修房间
*
* @param id 报修房间ID
* @return 报修房间
*/
RepairRoom selectRepairRoomById(Long id);
/**
* 查询报修房间列表
*
* @param repairRoom 报修房间
* @return 报修房间集合
*/
List<RepairRoom> selectRepairRoomList(RepairRoom repairRoom);
/**
* 新增报修房间
*
* @param repairRoom 报修房间
* @return 结果
*/
int insertRepairRoom(RepairRoom repairRoom);
/**
* 修改报修房间
*
* @param repairRoom 报修房间
* @return 结果
*/
int updateRepairRoom(RepairRoom repairRoom);
/**
* 删除报修房间
*
* @param id 报修房间ID
* @return 结果
*/
int deleteRepairRoomById(Long id);
/**
* 批量删除报修房间
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairRoomByIds(String[] ids);
}

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairStaffTypeMapper.java
View File

@ -1,64 +0,0 @@
package com.ics.admin.mapper;
import com.ics.admin.domain.RepairStaffType;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* RepairStaffTypeMapper接口
*
* @author chen
* @date 2024-07-30
*/
@Mapper
public interface RepairStaffTypeMapper extends BaseMapper<RepairStaffType> {
/**
* 查询RepairStaffType
*
* @param id RepairStaffTypeID
* @return RepairStaffType
*/
RepairStaffType selectRepairStaffTypeById(Long id);
/**
* 查询RepairStaffType列表
*
* @param repairStaffType RepairStaffType
* @return RepairStaffType集合
*/
List<RepairStaffType> selectRepairStaffTypeList(RepairStaffType repairStaffType);
/**
* 新增RepairStaffType
*
* @param repairStaffType RepairStaffType
* @return 结果
*/
int insertRepairStaffType(RepairStaffType repairStaffType);
/**
* 修改RepairStaffType
*
* @param repairStaffType RepairStaffType
* @return 结果
*/
int updateRepairStaffType(RepairStaffType repairStaffType);
/**
* 删除RepairStaffType
*
* @param id RepairStaffTypeID
* @return 结果
*/
int deleteRepairStaffTypeById(Long id);
/**
* 批量删除RepairStaffType
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairStaffTypeByIds(String[] ids);
}

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/mapper/RepairWorkerTypeMapper.java
View File

@ -1,64 +0,0 @@
package com.ics.admin.mapper;
import com.ics.admin.domain.RepairWorkerType;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 维修人分类关联Mapper接口
*
* @author chen
* @date 2024-07-31
*/
@Mapper
public interface RepairWorkerTypeMapper extends BaseMapper<RepairWorkerType> {
/**
* 查询维修人分类关联
*
* @param id 维修人分类关联ID
* @return 维修人分类关联
*/
RepairWorkerType selectRepairWorkerTypeById(Long id);
/**
* 查询维修人分类关联列表
*
* @param repairWorkerType 维修人分类关联
* @return 维修人分类关联集合
*/
List<RepairWorkerType> selectRepairWorkerTypeList(RepairWorkerType repairWorkerType);
/**
* 新增维修人分类关联
*
* @param repairWorkerType 维修人分类关联
* @return 结果
*/
int insertRepairWorkerType(RepairWorkerType repairWorkerType);
/**
* 修改维修人分类关联
*
* @param repairWorkerType 维修人分类关联
* @return 结果
*/
int updateRepairWorkerType(RepairWorkerType repairWorkerType);
/**
* 删除维修人分类关联
*
* @param id 维修人分类关联ID
* @return 结果
*/
int deleteRepairWorkerTypeById(Long id);
/**
* 批量删除维修人分类关联
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairWorkerTypeByIds(String[] ids);
}

61
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairAddressFloorService.java Normal file
View File

@ -0,0 +1,61 @@
package com.ics.admin.service;
import com.ics.admin.domain.RepairAddressFloor;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* 报修房间Service接口
*
* @author ics
* @date 2024-08-06
*/
public interface IRepairAddressFloorService extends IService<RepairAddressFloor> {
/**
* 查询地点楼层
*
* @param id 地点楼层ID
* @return 地点楼层
*/
RepairAddressFloor selectRepairAddressFloorById(Long id);
/**
* 查询地点楼层列表
*
* @param repairAddressFloor 地点楼层
* @return 地点楼层集合
*/
List<RepairAddressFloor> selectRepairAddressFloorList(RepairAddressFloor repairAddressFloor);
/**
* 新增地点楼层
*
* @param repairAddressFloor 地点楼层
* @return 结果
*/
int insertRepairAddressFloor(RepairAddressFloor repairAddressFloor);
/**
* 修改地点楼层
*
* @param repairAddressFloor 地点楼层
* @return 结果
*/
int updateRepairAddressFloor(RepairAddressFloor repairAddressFloor);
/**
* 批量删除地点楼层
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairAddressFloorByIds(String ids);
/**
* 删除地点楼层信息
*
* @param id 地点楼层ID
* @return 结果
*/
int deleteRepairAddressFloorById(Long id);
}

12
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairAddressService.java
View File

@ -13,7 +13,7 @@ import java.util.List;
public interface IRepairAddressService extends IService<RepairAddress> {
/**
* 查询报修地址
*
*
* @param id 报修地址ID
* @return 报修地址
*/
@ -21,7 +21,7 @@ public interface IRepairAddressService extends IService<RepairAddress> {
/**
* 查询报修地址列表
*
*
* @param repairAddress 报修地址
* @return 报修地址集合
*/
@ -29,7 +29,7 @@ public interface IRepairAddressService extends IService<RepairAddress> {
/**
* 新增报修地址
*
*
* @param repairAddress 报修地址
* @return 结果
*/
@ -37,7 +37,7 @@ public interface IRepairAddressService extends IService<RepairAddress> {
/**
* 修改报修地址
*
*
* @param repairAddress 报修地址
* @return 结果
*/
@ -45,7 +45,7 @@ public interface IRepairAddressService extends IService<RepairAddress> {
/**
* 批量删除报修地址
*
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@ -53,7 +53,7 @@ public interface IRepairAddressService extends IService<RepairAddress> {
/**
* 删除报修地址信息
*
*
* @param id 报修地址ID
* @return 结果
*/

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairAttachService.java Normal file
View File

@ -0,0 +1,64 @@
package com.ics.admin.service;
import com.ics.admin.domain.RepairAttach;
import com.baomidou.mybatisplus.extension.service.IService;
import com.ics.common.core.domain.IcsCustomerStaff;
import java.util.List;
/**
* 附件Service接口
*
* @author chen
* @date 2024-07-31
*/
public interface IRepairAttachService extends IService<RepairAttach> {
/**
* 查询附件
*
* @param id 附件ID
* @return 附件
*/
RepairAttach selectRepairAttachById(Long id);
/**
* 查询附件列表
*
* @param repairAttach 附件
* @return 附件集合
*/
List<RepairAttach> selectRepairAttachList(RepairAttach repairAttach);
/**
* 新增附件
*
* @param repairAttach 附件
* @return 结果
*/
int insertRepairAttach(RepairAttach repairAttach);
/**
* 修改附件
*
* @param repairAttach 附件
* @return 结果
*/
int updateRepairAttach(RepairAttach repairAttach);
/**
* 批量删除附件
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairAttachByIds(String ids);
/**
* 删除附件信息
*
* @param id 附件ID
* @return 结果
*/
int deleteRepairAttachById(Long id);
}

40
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairDeviceService.java
View File

@ -5,56 +5,56 @@ import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* 保修设备类型Service接口
* 保修设备Service接口
*
* @author ics
* @date 2024-07-30
*/
public interface IRepairDeviceService extends IService<RepairDevice> {
/**
* 查询保修设备类型
*
* @param id 保修设备类型ID
* @return 保修设备类型
* 查询报修设备
*
* @param id 报修设备ID
* @return 报修设备
*/
RepairDevice selectRepairDeviceById(Long id);
/**
* 查询保修设备类型列表
*
* @param repairDevice 保修设备类型
* @return 保修设备类型集合
* 查询报修设备列表
*
* @param repairDevice 报修设备
* @return 报修设备集合
*/
List<RepairDevice> selectRepairDeviceList(RepairDevice repairDevice);
/**
* 新增保修设备类型
*
* @param repairDevice 保修设备类型
* 新增报修设备
*
* @param repairDevice 报修设备
* @return 结果
*/
int insertRepairDevice(RepairDevice repairDevice);
/**
* 修改保修设备类型
*
* @param repairDevice 保修设备类型
* 修改报修设备
*
* @param repairDevice 报修设备
* @return 结果
*/
int updateRepairDevice(RepairDevice repairDevice);
/**
* 批量删除保修设备类型
*
* 批量删除报修设备
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairDeviceByIds(String ids);
/**
* 删除保修设备类型信息
*
* @param id 保修设备类型ID
* 删除报修设备信息
*
* @param id 报修设备ID
* @return 结果
*/
int deleteRepairDeviceById(Long id);

34
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairTypeService.java → shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairDeviceTypeService.java
View File

@ -1,6 +1,6 @@
package com.ics.admin.service;
import com.ics.admin.domain.RepairType;
import com.ics.admin.domain.RepairDeviceType;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
@ -10,54 +10,54 @@ import java.util.List;
* @author ics
* @date 2024-07-30
*/
public interface IRepairTypeService extends IService<RepairType> {
public interface IRepairDeviceTypeService extends IService<RepairDeviceType> {
/**
* 查询设备类型
*
*
* @param id 设备类型ID
* @return 设备类型
*/
RepairType selectRepairTypeById(Long id);
RepairDeviceType selectRepairDeviceTypeById(Long id);
/**
* 查询设备类型列表
*
* @param repairType 设备类型
*
* @param repairDeviceType 设备类型
* @return 设备类型集合
*/
List<RepairType> selectRepairTypeList(RepairType repairType);
List<RepairDeviceType> selectRepairDeviceTypeList(RepairDeviceType repairDeviceType);
/**
* 新增设备类型
*
* @param repairType 设备类型
*
* @param repairDeviceType 设备类型
* @return 结果
*/
int insertRepairType(RepairType repairType);
int insertRepairDeviceType(RepairDeviceType repairDeviceType);
/**
* 修改设备类型
*
* @param repairType 设备类型
*
* @param repairDeviceType 设备类型
* @return 结果
*/
int updateRepairType(RepairType repairType);
int updateRepairDeviceType(RepairDeviceType repairDeviceType);
/**
* 批量删除设备类型
*
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairTypeByIds(String ids);
int deleteRepairDeviceTypeByIds(String ids);
/**
* 删除设备类型信息
*
*
* @param id 设备类型ID
* @return 结果
*/
int deleteRepairTypeById(Long id);
int deleteRepairDeviceTypeById(Long id);
}

38
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairLogService.java
View File

@ -13,49 +13,49 @@ import java.util.List;
*/
public interface IRepairLogService extends IService<RepairLog> {
/**
* 查询报修记录
*
* @param id 报修记录ID
* @return 报修记录
* 查询流程日志
*
* @param id 流程日志ID
* @return 流程日志
*/
RepairLog selectRepairLogById(Long id);
/**
* 查询报修记录列表
*
* @param repairLog 报修记录
* @return 报修记录集合
* 查询流程日志列表
*
* @param repairLog 流程日志
* @return 流程日志集合
*/
List<RepairLog> selectRepairLogList(RepairLog repairLog);
/**
* 新增报修记录
*
* @param repairLog 报修记录
* 新增流程日志
*
* @param repairLog 流程日志
* @return 结果
*/
int insertRepairLog(RepairLog repairLog);
/**
* 修改报修记录
*
* @param repairLog 报修记录
* 修改流程日志
*
* @param repairLog 流程日志
* @return 结果
*/
int updateRepairLog(RepairLog repairLog);
/**
* 批量删除报修记录
*
* 批量删除流程日志
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairLogByIds(String ids);
/**
* 删除报修记录信息
*
* @param id 报修记录ID
* 删除流程日志信息
*
* @param id 流程日志ID
* @return 结果
*/
int deleteRepairLogById(Long id);

64
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairRecordService.java
View File

@ -1,64 +0,0 @@
package com.ics.admin.service;
import com.ics.admin.domain.Repair;
import com.ics.admin.domain.RepairRecord;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* 保修评价Service接口
*
* @author ics
* @date 2024-07-30
*/
public interface IRepairRecordService extends IService<RepairRecord> {
/**
* 查询保修评价
*
* @param id 保修评价ID
* @return 保修评价
*/
RepairRecord selectRepairRecordById(Long id);
/**
* 查询保修评价列表
*
* @param repairRecord 保修评价
* @return 保修评价集合
*/
List<RepairRecord> selectRepairRecordList(RepairRecord repairRecord);
/**
* 新增保修评价
*
* @param repairRecord 保修评价
* @return 结果
*/
int insertRepairRecord(RepairRecord repairRecord);
/**
* 修改保修评价
*
* @param repairRecord 保修评价
* @return 结果
*/
int updateRepairRecord(RepairRecord repairRecord);
/**
* 批量删除保修评价
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairRecordByIds(String ids);
/**
* 删除保修评价信息
*
* @param id 保修评价ID
* @return 结果
*/
int deleteRepairRecordById(Long id);
RepairRecord selectByRepairId(Long id);
}

62
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairRelationalService.java Normal file
View File

@ -0,0 +1,62 @@
package com.ics.admin.service;
import com.ics.admin.domain.RepairRelational;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* RepairStaffTypeService接口
*
* @author chen
* @date 2024-07-30
*/
public interface IRepairRelationalService extends IService<RepairRelational> {
/**
* 查询设备类型与派单员、维修人员的关联关系
*
* @param id 设备类型与派单员、维修人员的关联关系ID
* @return 设备类型与派单员、维修人员的关联关系
*/
RepairRelational selectRepairRelationalById(Long id);
/**
* 查询设备类型与派单员、维修人员的关联关系列表
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 设备类型与派单员、维修人员的关联关系集合
*/
List<RepairRelational> selectRepairRelationalList(RepairRelational repairRelational);
/**
* 新增设备类型与派单员、维修人员的关联关系
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 结果
*/
int insertRepairRelational(RepairRelational repairRelational);
/**
* 修改设备类型与派单员、维修人员的关联关系
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 结果
*/
int updateRepairRelational(RepairRelational repairRelational);
/**
* 批量删除设备类型与派单员、维修人员的关联关系
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairRelationalByIds(String ids);
/**
* 删除设备类型与派单员、维修人员的关联关系信息
*
* @param id 设备类型与派单员、维修人员的关联关系ID
* @return 结果
*/
int deleteRepairRelationalById(Long id);
}

61
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairRoomService.java
View File

@ -1,61 +0,0 @@
package com.ics.admin.service;
import com.ics.admin.domain.RepairRoom;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* 报修房间Service接口
*
* @author ics
* @date 2024-08-06
*/
public interface IRepairRoomService extends IService<RepairRoom> {
/**
* 查询报修房间
*
* @param id 报修房间ID
* @return 报修房间
*/
RepairRoom selectRepairRoomById(Long id);
/**
* 查询报修房间列表
*
* @param repairRoom 报修房间
* @return 报修房间集合
*/
List<RepairRoom> selectRepairRoomList(RepairRoom repairRoom);
/**
* 新增报修房间
*
* @param repairRoom 报修房间
* @return 结果
*/
int insertRepairRoom(RepairRoom repairRoom);
/**
* 修改报修房间
*
* @param repairRoom 报修房间
* @return 结果
*/
int updateRepairRoom(RepairRoom repairRoom);
/**
* 批量删除报修房间
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairRoomByIds(String ids);
/**
* 删除报修房间信息
*
* @param id 报修房间ID
* @return 结果
*/
int deleteRepairRoomById(Long id);
}

51
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairService.java
View File

@ -14,64 +14,51 @@ import java.util.List;
*/
public interface IRepairService extends IService<Repair> {
/**
* 查询工单管理
*
* @param id 工单管理ID
* @return 工单管理
* 查询工单
*
* @param id 工单ID
* @return 工单
*/
Repair selectRepairById(Long id);
/**
* 查询工单管理列表
*
* @param repair 工单管理
* @return 工单管理集合
* 查询工单列表
*
* @param repair 工单
* @return 工单集合
*/
List<Repair> selectRepairList(Repair repair);
/**
* 新增工单管理
*
* @param repair 工单管理
* 新增工单
*
* @param repair 工单
* @return 结果
*/
int insertRepair(Repair repair);
/**
* 修改工单管理
*
* @param repair 工单管理
* 修改工单
*
* @param repair 工单
* @return 结果
*/
int updateRepair(Repair repair);
/**
* 批量删除工单管理
*
* 批量删除工单
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairByIds(String ids);
/**
* 删除工单管理信息
*
* @param id 工单管理ID
* 删除工单信息
*
* @param id 工单ID
* @return 结果
*/
int deleteRepairById(Long id);
/**
* 查询我的工单管理列表
*
* @param repair 创建用户
* @return 工单管理集合
*/
List<Repair> selectMyRepairList(Repair repair);
List<IcsCustomerStaff> selectWorkerIdByTypeId(String typeId);
List<IcsCustomerStaff> selectDispatcher();
}

66
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairStaffTypeService.java
View File

@ -1,66 +0,0 @@
package com.ics.admin.service;
import com.ics.admin.domain.RepairStaffType;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* RepairStaffTypeService接口
*
* @author chen
* @date 2024-07-30
*/
public interface IRepairStaffTypeService extends IService<RepairStaffType> {
/**
* 查询RepairStaffType
*
* @param id RepairStaffTypeID
* @return RepairStaffType
*/
RepairStaffType selectRepairStaffTypeById(Long id);
/**
* 查询RepairStaffType列表
*
* @param repairStaffType RepairStaffType
* @return RepairStaffType集合
*/
List<RepairStaffType> selectRepairStaffTypeList(RepairStaffType repairStaffType);
/**
* 新增RepairStaffType
*
* @param repairStaffType RepairStaffType
* @return 结果
*/
int insertRepairStaffType(RepairStaffType repairStaffType);
/**
* 修改RepairStaffType
*
* @param repairStaffType RepairStaffType
* @return 结果
*/
int updateRepairStaffType(RepairStaffType repairStaffType);
/**
* 批量删除RepairStaffType
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairStaffTypeByIds(String ids);
/**
* 删除RepairStaffType信息
*
* @param id RepairStaffTypeID
* @return 结果
*/
int deleteRepairStaffTypeById(Long id);
Long selectRepairTypeByUserId(Integer userId);
RepairStaffType selectStaffIdByTypeId(Long id);
}

66
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/IRepairWorkerTypeService.java
View File

@ -1,66 +0,0 @@
package com.ics.admin.service;
import com.ics.admin.domain.RepairWorkerType;
import com.baomidou.mybatisplus.extension.service.IService;
import com.ics.common.core.domain.IcsCustomerStaff;
import java.util.List;
/**
* 维修人分类关联Service接口
*
* @author chen
* @date 2024-07-31
*/
public interface IRepairWorkerTypeService extends IService<RepairWorkerType> {
/**
* 查询维修人分类关联
*
* @param id 维修人分类关联ID
* @return 维修人分类关联
*/
RepairWorkerType selectRepairWorkerTypeById(Long id);
/**
* 查询维修人分类关联列表
*
* @param repairWorkerType 维修人分类关联
* @return 维修人分类关联集合
*/
List<RepairWorkerType> selectRepairWorkerTypeList(RepairWorkerType repairWorkerType);
/**
* 新增维修人分类关联
*
* @param repairWorkerType 维修人分类关联
* @return 结果
*/
int insertRepairWorkerType(RepairWorkerType repairWorkerType);
/**
* 修改维修人分类关联
*
* @param repairWorkerType 维修人分类关联
* @return 结果
*/
int updateRepairWorkerType(RepairWorkerType repairWorkerType);
/**
* 批量删除维修人分类关联
*
* @param ids 需要删除的数据ID
* @return 结果
*/
int deleteRepairWorkerTypeByIds(String ids);
/**
* 删除维修人分类关联信息
*
* @param id 维修人分类关联ID
* @return 结果
*/
int deleteRepairWorkerTypeById(Long id);
List<IcsCustomerStaff> selectRepairWorkerTypeListByTypeId(Long type);
}

92
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairAddressFloorServiceImpl.java Normal file
View File

@ -0,0 +1,92 @@
package com.ics.admin.service.impl;
import java.util.List;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairAddressFloorMapper;
import com.ics.admin.domain.RepairAddressFloor;
import com.ics.admin.service.IRepairAddressFloorService;
/**
* 地点楼层Service业务层处理
*
* @author ics
* @date 2024-08-06
*/
@Service
public class RepairAddressFloorServiceImpl extends ServiceImpl<RepairAddressFloorMapper, RepairAddressFloor> implements IRepairAddressFloorService {
@Autowired
private RepairAddressFloorMapper repairAddressFloorMapper;
/**
* 查询地点楼层
*
* @param id 地点楼层ID
* @return 地点楼层
*/
@Override
public RepairAddressFloor selectRepairAddressFloorById(Long id) {
return repairAddressFloorMapper.selectById(id);
}
/**
* 查询地点楼层列表
*
* @param repairAddressFloor 地点楼层
* @return 地点楼层
*/
@Override
public List<RepairAddressFloor> selectRepairAddressFloorList(RepairAddressFloor repairAddressFloor) {
QueryWrapper queryWrapper = new QueryWrapper();
return repairAddressFloorMapper.selectList(queryWrapper);
}
/**
* 新增地点楼层
*
* @param repairAddressFloor 地点楼层
* @return 结果
*/
@Override
public int insertRepairAddressFloor(RepairAddressFloor repairAddressFloor) {
return repairAddressFloorMapper.insert(repairAddressFloor);
}
/**
* 修改地点楼层
*
* @param repairAddressFloor 地点楼层
* @return 结果
*/
@Override
public int updateRepairAddressFloor(RepairAddressFloor repairAddressFloor) {
return repairAddressFloorMapper.updateById(repairAddressFloor);
}
/**
* 删除地点楼层对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairAddressFloorByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairAddressFloorMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除地点楼层信息
*
* @param id 地点楼层ID
* @return 结果
*/
@Override
public int deleteRepairAddressFloorById(Long id) {
return repairAddressFloorMapper.deleteRepairAddressFloorById(id);
}
}

12
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairAddressServiceImpl.java
View File

@ -24,7 +24,7 @@ public class RepairAddressServiceImpl extends ServiceImpl<RepairAddressMapper, R
/**
* 查询报修地址
*
*
* @param id 报修地址ID
* @return 报修地址
*/
@ -35,7 +35,7 @@ public class RepairAddressServiceImpl extends ServiceImpl<RepairAddressMapper, R
/**
* 查询报修地址列表
*
*
* @param repairAddress 报修地址
* @return 报修地址
*/
@ -47,7 +47,7 @@ public class RepairAddressServiceImpl extends ServiceImpl<RepairAddressMapper, R
/**
* 新增报修地址
*
*
* @param repairAddress 报修地址
* @return 结果
*/
@ -58,7 +58,7 @@ public class RepairAddressServiceImpl extends ServiceImpl<RepairAddressMapper, R
/**
* 修改报修地址
*
*
* @param repairAddress 报修地址
* @return 结果
*/
@ -69,7 +69,7 @@ public class RepairAddressServiceImpl extends ServiceImpl<RepairAddressMapper, R
/**
* 删除报修地址对象
*
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@ -81,7 +81,7 @@ public class RepairAddressServiceImpl extends ServiceImpl<RepairAddressMapper, R
/**
* 删除报修地址信息
*
*
* @param id 报修地址ID
* @return 结果
*/

99
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairAttachServiceImpl.java Normal file
View File

@ -0,0 +1,99 @@
package com.ics.admin.service.impl;
import java.util.List;
import java.util.stream.Collectors;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ics.admin.mapper.IcsCustomerStaffMapper;
import com.ics.common.core.domain.IcsCustomerStaff;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairAttachMapper;
import com.ics.admin.domain.RepairAttach;
import com.ics.admin.service.IRepairAttachService;
/**
* 附件Service业务层处理
*
* @author chen
* @date 2024-07-31
*/
@Service
public class RepairAttachServiceImpl extends ServiceImpl<RepairAttachMapper, RepairAttach> implements IRepairAttachService {
@Autowired
private RepairAttachMapper repairAttachMapper;
/**
* 查询附件
*
* @param id 附件ID
* @return 附件
*/
@Override
public RepairAttach selectRepairAttachById(Long id) {
return repairAttachMapper.selectById(id);
}
/**
* 查询附件列表
*
* @param repairAttach 附件
* @return 附件
*/
@Override
public List<RepairAttach> selectRepairAttachList(RepairAttach repairAttach) {
QueryWrapper queryWrapper = new QueryWrapper();
return repairAttachMapper.selectList(queryWrapper);
}
/**
* 新增附件
*
* @param repairAttach 附件
* @return 结果
*/
@Override
public int insertRepairAttach(RepairAttach repairAttach) {
return repairAttachMapper.insert(repairAttach);
}
/**
* 修改附件
*
* @param repairAttach 附件
* @return 结果
*/
@Override
public int updateRepairAttach(RepairAttach repairAttach) {
return repairAttachMapper.updateById(repairAttach);
}
/**
* 删除附件对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairAttachByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairAttachMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除附件信息
*
* @param id 附件ID
* @return 结果
*/
@Override
public int deleteRepairAttachById(Long id) {
return repairAttachMapper.deleteRepairAttachById(id);
}
}

41
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairDeviceServiceImpl.java
View File

@ -12,7 +12,7 @@ import com.ics.admin.domain.RepairDevice;
import com.ics.admin.service.IRepairDeviceService;
/**
* 保修设备类型Service业务层处理
* 保修设备Service业务层处理
*
* @author ics
* @date 2024-07-30
@ -23,10 +23,10 @@ public class RepairDeviceServiceImpl extends ServiceImpl<RepairDeviceMapper, Rep
private RepairDeviceMapper repairDeviceMapper;
/**
* 查询保修设备类型
*
* @param id 保修设备类型ID
* @return 保修设备类型
* 查询报修设备
*
* @param id 报修设备ID
* @return 报修设备
*/
@Override
public RepairDevice selectRepairDeviceById(Long id) {
@ -34,22 +34,21 @@ public class RepairDeviceServiceImpl extends ServiceImpl<RepairDeviceMapper, Rep
}
/**
* 查询保修设备类型列表
*
* @param repairDevice 保修设备类型
* @return 保修设备类型
* 查询报修设备列表
*
* @param repairDevice 报修设备
* @return 报修设备
*/
@Override
public List<RepairDevice> selectRepairDeviceList(RepairDevice repairDevice) {
QueryWrapper queryWrapper = new QueryWrapper();
queryWrapper.eq(repairDevice.getTypeId() != null,"type_id",repairDevice.getTypeId());
return repairDeviceMapper.selectList(queryWrapper);
}
/**
* 新增保修设备类型
*
* @param repairDevice 保修设备类型
* 新增报修设备
*
* @param repairDevice 报修设备
* @return 结果
*/
@Override
@ -58,9 +57,9 @@ public class RepairDeviceServiceImpl extends ServiceImpl<RepairDeviceMapper, Rep
}
/**
* 修改保修设备类型
*
* @param repairDevice 保修设备类型
* 修改报修设备
*
* @param repairDevice 报修设备
* @return 结果
*/
@Override
@ -69,8 +68,8 @@ public class RepairDeviceServiceImpl extends ServiceImpl<RepairDeviceMapper, Rep
}
/**
* 删除保修设备类型对象
*
* 删除报修设备对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@ -81,9 +80,9 @@ public class RepairDeviceServiceImpl extends ServiceImpl<RepairDeviceMapper, Rep
}
/**
* 删除保修设备类型信息
*
* @param id 保修设备类型ID
* 删除报修设备信息
*
* @param id 报修设备ID
* @return 结果
*/
@Override

93
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairDeviceTypeServiceImpl.java Normal file
View File

@ -0,0 +1,93 @@
package com.ics.admin.service.impl;
import java.util.List;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairDeviceTypeMapper;
import com.ics.admin.domain.RepairDeviceType;
import com.ics.admin.service.IRepairDeviceTypeService;
/**
* 设备类型Service业务层处理
*
* @author ics
* @date 2024-07-30
*/
@Service
public class RepairDeviceTypeServiceImpl extends ServiceImpl<RepairDeviceTypeMapper, RepairDeviceType> implements IRepairDeviceTypeService {
@Autowired
private RepairDeviceTypeMapper repairDeviceTypeMapper;
/**
* 查询设备类型
*
* @param id 设备类型ID
* @return 设备类型
*/
@Override
public RepairDeviceType selectRepairDeviceTypeById(Long id) {
return repairDeviceTypeMapper.selectById(id);
}
/**
* 查询设备类型列表
*
* @param repairDeviceType 设备类型
* @return 设备类型
*/
@Override
public List<RepairDeviceType> selectRepairDeviceTypeList(RepairDeviceType repairDeviceType) {
QueryWrapper queryWrapper = new QueryWrapper();
return repairDeviceTypeMapper.selectList(queryWrapper);
}
/**
* 新增设备类型
*
* @param repairDeviceType 设备类型
* @return 结果
*/
@Override
public int insertRepairDeviceType(RepairDeviceType repairDeviceType) {
return repairDeviceTypeMapper.insert(repairDeviceType);
}
/**
* 修改设备类型
*
* @param repairDeviceType 设备类型
* @return 结果
*/
@Override
public int updateRepairDeviceType(RepairDeviceType repairDeviceType) {
return repairDeviceTypeMapper.updateById(repairDeviceType);
}
/**
* 删除设备类型对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairDeviceTypeByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairDeviceTypeMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除设备类型信息
*
* @param id 设备类型ID
* @return 结果
*/
@Override
public int deleteRepairDeviceTypeById(Long id) {
return repairDeviceTypeMapper.deleteRepairDeviceTypeById(id);
}
}

2
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairFailureTypeServiceImpl.java
View File

@ -76,7 +76,7 @@ public class RepairFailureTypeServiceImpl extends ServiceImpl<RepairFailureTypeM
@Override
public int deleteRepairFailureTypeByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairFailureTypeMapper.deleteBatchIds(CollUtil.toList(idsArray));
return repairFailureTypeMapper.deleteRepairFailureTypeByIds(idsArray);
}
/**

44
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairLogServiceImpl.java
View File

@ -2,6 +2,7 @@ package com.ics.admin.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ics.admin.domain.RepairLog;
import com.ics.admin.mapper.RepairLogMapper;
@ -23,10 +24,10 @@ public class RepairLogServiceImpl extends ServiceImpl<RepairLogMapper, RepairLog
private RepairLogMapper repairLogMapper;
/**
* 查询报修记录
*
* @param id 报修记录ID
* @return 报修记录
* 查询流程日志
*
* @param id 流程日志ID
* @return 流程日志
*/
@Override
public RepairLog selectRepairLogById(Long id) {
@ -34,20 +35,21 @@ public class RepairLogServiceImpl extends ServiceImpl<RepairLogMapper, RepairLog
}
/**
* 查询报修记录列表
*
* @param repairLog 报修记录
* @return 报修记录
* 查询流程日志列表
*
* @param repairLog 流程日志
* @return 流程日志
*/
@Override
public List<RepairLog> selectRepairLogList(RepairLog repairLog) {
return repairLogMapper.selectRepairLogList(repairLog);
QueryWrapper queryWrapper = new QueryWrapper();
return repairLogMapper.selectList(queryWrapper);
}
/**
* 新增报修记录
*
* @param repairLog 报修记录
* 新增流程日志
*
* @param repairLog 流程日志
* @return 结果
*/
@Override
@ -56,9 +58,9 @@ public class RepairLogServiceImpl extends ServiceImpl<RepairLogMapper, RepairLog
}
/**
* 修改报修记录
*
* @param repairLog 报修记录
* 修改流程日志
*
* @param repairLog 流程日志
* @return 结果
*/
@Override
@ -67,8 +69,8 @@ public class RepairLogServiceImpl extends ServiceImpl<RepairLogMapper, RepairLog
}
/**
* 删除报修记录对象
*
* 删除流程日志对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@ -79,13 +81,13 @@ public class RepairLogServiceImpl extends ServiceImpl<RepairLogMapper, RepairLog
}
/**
* 删除报修记录信息
*
* @param id 报修记录ID
* 删除流程日志信息
*
* @param id 流程日志ID
* @return 结果
*/
@Override
public int deleteRepairLogById(Long id) {
return repairLogMapper.deleteById(id);
return repairLogMapper.deleteRepairLogById(id);
}
}

102
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairRecordServiceImpl.java
View File

@ -1,102 +0,0 @@
package com.ics.admin.service.impl;
import java.util.List;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ics.admin.domain.Repair;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairRecordMapper;
import com.ics.admin.domain.RepairRecord;
import com.ics.admin.service.IRepairRecordService;
/**
* 保修评价Service业务层处理
*
* @author ics
* @date 2024-07-30
*/
@Service
public class RepairRecordServiceImpl extends ServiceImpl<RepairRecordMapper, RepairRecord> implements IRepairRecordService {
@Autowired
private RepairRecordMapper repairRecordMapper;
/**
* 查询保修评价
*
* @param id 保修评价ID
* @return 保修评价
*/
@Override
public RepairRecord selectRepairRecordById(Long id) {
return repairRecordMapper.selectById(id);
}
/**
* 查询保修评价列表
*
* @param repairRecord 保修评价
* @return 保修评价
*/
@Override
public List<RepairRecord> selectRepairRecordList(RepairRecord repairRecord) {
QueryWrapper queryWrapper = new QueryWrapper();
return repairRecordMapper.selectList(queryWrapper);
}
/**
* 新增保修评价
*
* @param repairRecord 保修评价
* @return 结果
*/
@Override
public int insertRepairRecord(RepairRecord repairRecord) {
return repairRecordMapper.insert(repairRecord);
}
/**
* 修改保修评价
*
* @param repairRecord 保修评价
* @return 结果
*/
@Override
public int updateRepairRecord(RepairRecord repairRecord) {
return repairRecordMapper.updateById(repairRecord);
}
/**
* 删除保修评价对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairRecordByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairRecordMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除保修评价信息
*
* @param id 保修评价ID
* @return 结果
*/
@Override
public int deleteRepairRecordById(Long id) {
return repairRecordMapper.deleteRepairRecordById(id);
}
@Override
public RepairRecord selectByRepairId(Long id) {
LambdaQueryWrapper<RepairRecord> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(RepairRecord::getRepairId,id);
return repairRecordMapper.selectOne(wrapper);
}
}

92
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairRelationalServiceImpl.java Normal file
View File

@ -0,0 +1,92 @@
package com.ics.admin.service.impl;
import java.util.List;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairRelationalMapper;
import com.ics.admin.domain.RepairRelational;
import com.ics.admin.service.IRepairRelationalService;
/**
* RepairStaffTypeService业务层处理
*
* @author chen
* @date 2024-07-30
*/
@Service
public class RepairRelationalServiceImpl extends ServiceImpl<RepairRelationalMapper, RepairRelational> implements IRepairRelationalService {
@Autowired
private RepairRelationalMapper repairRelationalMapper;
/**
* 查询设备类型与派单员、维修人员的关联关系
*
* @param id 设备类型与派单员、维修人员的关联关系ID
* @return 设备类型与派单员、维修人员的关联关系
*/
@Override
public RepairRelational selectRepairRelationalById(Long id) {
return repairRelationalMapper.selectById(id);
}
/**
* 查询设备类型与派单员、维修人员的关联关系列表
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 设备类型与派单员、维修人员的关联关系
*/
@Override
public List<RepairRelational> selectRepairRelationalList(RepairRelational repairRelational) {
QueryWrapper queryWrapper = new QueryWrapper();
return repairRelationalMapper.selectList(queryWrapper);
}
/**
* 新增设备类型与派单员、维修人员的关联关系
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 结果
*/
@Override
public int insertRepairRelational(RepairRelational repairRelational) {
return repairRelationalMapper.insert(repairRelational);
}
/**
* 修改设备类型与派单员、维修人员的关联关系
*
* @param repairRelational 设备类型与派单员、维修人员的关联关系
* @return 结果
*/
@Override
public int updateRepairRelational(RepairRelational repairRelational) {
return repairRelationalMapper.updateById(repairRelational);
}
/**
* 删除设备类型与派单员、维修人员的关联关系对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairRelationalByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairRelationalMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除设备类型与派单员、维修人员的关联关系信息
*
* @param id 设备类型与派单员、维修人员的关联关系ID
* @return 结果
*/
@Override
public int deleteRepairRelationalById(Long id) {
return repairRelationalMapper.deleteRepairRelationalById(id);
}
}

94
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairRoomServiceImpl.java
View File

@ -1,94 +0,0 @@
package com.ics.admin.service.impl;
import java.util.List;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairRoomMapper;
import com.ics.admin.domain.RepairRoom;
import com.ics.admin.service.IRepairRoomService;
/**
* 报修房间Service业务层处理
*
* @author ics
* @date 2024-08-06
*/
@Service
public class RepairRoomServiceImpl extends ServiceImpl<RepairRoomMapper, RepairRoom> implements IRepairRoomService {
@Autowired
private RepairRoomMapper repairRoomMapper;
/**
* 查询报修房间
*
* @param id 报修房间ID
* @return 报修房间
*/
@Override
public RepairRoom selectRepairRoomById(Long id) {
return repairRoomMapper.selectById(id);
}
/**
* 查询报修房间列表
*
* @param repairRoom 报修房间
* @return 报修房间
*/
@Override
public List<RepairRoom> selectRepairRoomList(RepairRoom repairRoom) {
QueryWrapper queryWrapper = new QueryWrapper();
queryWrapper.eq(repairRoom.getAddressId() != null,"address_id",repairRoom.getAddressId());
return repairRoomMapper.selectList(queryWrapper);
}
/**
* 新增报修房间
*
* @param repairRoom 报修房间
* @return 结果
*/
@Override
public int insertRepairRoom(RepairRoom repairRoom) {
return repairRoomMapper.insert(repairRoom);
}
/**
* 修改报修房间
*
* @param repairRoom 报修房间
* @return 结果
*/
@Override
public int updateRepairRoom(RepairRoom repairRoom) {
return repairRoomMapper.updateById(repairRoom);
}
/**
* 删除报修房间对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairRoomByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairRoomMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除报修房间信息
*
* @param id 报修房间ID
* @return 结果
*/
@Override
public int deleteRepairRoomById(Long id) {
return repairRoomMapper.deleteRepairRoomById(id);
}
}

122
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairServiceImpl.java
View File

@ -3,16 +3,17 @@ package com.ics.admin.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ics.admin.domain.Repair;
import com.ics.admin.domain.RepairLog;
import com.ics.admin.domain.RepairWorkerType;
import com.ics.admin.domain.RepairAttach;
import com.ics.admin.mapper.IcsCustomerStaffMapper;
import com.ics.admin.mapper.RepairMapper;
import com.ics.admin.mapper.RepairWorkerTypeMapper;
import com.ics.admin.mapper.RepairAttachMapper;
import com.ics.admin.service.IRepairLogService;
import com.ics.admin.service.IRepairService;
import com.ics.admin.service.IRepairWorkerTypeService;
import com.ics.admin.service.IRepairAttachService;
import com.ics.common.core.domain.IcsCustomerStaff;
import com.ics.common.utils.DateUtils;
import com.ics.system.domain.Sn;
@ -36,97 +37,53 @@ public class RepairServiceImpl extends ServiceImpl<RepairMapper, Repair> impleme
@Autowired
private RepairMapper repairMapper;
@Autowired
private ISnService snService;
@Autowired
private IRepairLogService repairLogService;
@Autowired
private ICurrentUserService currentUserService;
@Autowired
private IRepairWorkerTypeService repairWorkerTypeService;
@Autowired
private RepairWorkerTypeMapper repairWorkerTypeMapper;
@Autowired
private IcsCustomerStaffMapper customerStaffMapper;
/**
* 查询工单管理
* 查询工单
*
* @param id 工单管理ID
* @return 工单管理
* @param id 工单ID
* @return 工单
*/
@Override
public Repair selectRepairById(Long id) {
return repairMapper.selectRepairById(id);
return repairMapper.selectById(id);
}
/**
* 查询工单管理列表
* 查询工单列表
*
* @param repair 工单管理
* @return 工单管理
* @param repair 工单
* @return 工单
*/
@Override
public List<Repair> selectRepairList(Repair repair) {
return repairMapper.selectRepairList(repair);
QueryWrapper queryWrapper = new QueryWrapper();
return repairMapper.selectList(queryWrapper);
}
/**
* 新增工单管理
* 新增工单
*
* @param repair 工单管理
* @param repair 工单
* @return 结果
*/
@Override
@Transactional(rollbackFor = Exception.class)
public int insertRepair(Repair repair) {
repair.setSn(snService.generate(Sn.Type.REPAIR));
repair.setCreateTime(DateUtils.getNowDate());
repair.setRepairTime(DateUtils.getNowDate());
int result = repairMapper.insert(repair);
// 增加报修日志
RepairLog repairLog = new RepairLog();
repairLog.setType(repair.getStatus());
repairLog.setDetail(String.format("工单号：%s,已收到报修", repair.getSn()));
repairLog.setRepairId(repair.getId());
repairLog.setCreateBy(repair.getCreateBy());
repairLog.setCreateTime(DateUtils.getNowDate());
repairLog.setUpdateBy(repair.getCreateBy());
repairLog.setUpdateTime(DateUtils.getNowDate());
repairLog.setParkId(repair.getParkId());
repairLog.setTenantId(repair.getTenantId());
repairLogService.insertRepairLog(repairLog);
return result;
return repairMapper.insert(repair);
}
/**
* 修改工单管理
* 修改工单
*
* @param repair 工单管理
* @param repair 工单
* @return 结果
*/
@Override
public int updateRepair(Repair repair) {
// 增加报修日志
RepairLog repairLog = new RepairLog();
repairLog.setType(repair.getStatus());
repairLog.setDetail(repair.getStatus().getName());
repairLog.setRepairId(repair.getId());
repairLog.setCreateBy(repair.getUpdateBy());
repairLog.setCreateTime(DateUtils.getNowDate());
repairLog.setUpdateBy(repair.getUpdateBy());
repairLog.setUpdateTime(DateUtils.getNowDate());
repairLogService.insertRepairLog(repairLog);
return repairMapper.updateById(repair);
}
/**
* 删除工单管理对象
* 删除工单对象
*
* @param ids 需要删除的数据ID
* @return 结果
@ -138,49 +95,14 @@ public class RepairServiceImpl extends ServiceImpl<RepairMapper, Repair> impleme
}
/**
* 删除工单管理信息
* 删除工单信息
*
* @param id 工单管理ID
* @param id 工单ID
* @return 结果
*/
@Override
public int deleteRepairById(Long id) {
return repairMapper.deleteById(id);
}
/**
* 查询工单管理列表
*
* @param repair 工单管理
* @return 工单管理
*/
@Override
public List<Repair> selectMyRepairList(Repair repair) {
return repairMapper.selectMyRepairList(repair);
}
@Override
public List<IcsCustomerStaff> selectWorkerIdByTypeId(String typeId) {
LambdaQueryWrapper<RepairWorkerType> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(RepairWorkerType::getTypeId, typeId);
//获取用户ids
List<Long> collect = repairWorkerTypeMapper.selectList(wrapper).stream().map(RepairWorkerType::getWorkerId).collect(Collectors.toList());
LambdaQueryWrapper<IcsCustomerStaff> userWrapper = new LambdaQueryWrapper<>();
userWrapper.in(IcsCustomerStaff::getId, collect);
return customerStaffMapper.selectList(userWrapper);
}
@Override
public List<IcsCustomerStaff> selectDispatcher() {
LambdaQueryWrapper<IcsCustomerStaff> userWrapper = new LambdaQueryWrapper<>();
userWrapper.eq(IcsCustomerStaff::getDataType, "0");
return customerStaffMapper.selectList(userWrapper);
return repairMapper.deleteRepairById(id);
}
}

113
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairStaffTypeServiceImpl.java
View File

@ -1,113 +0,0 @@
package com.ics.admin.service.impl;
import java.util.List;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairStaffTypeMapper;
import com.ics.admin.domain.RepairStaffType;
import com.ics.admin.service.IRepairStaffTypeService;
/**
* RepairStaffTypeService业务层处理
*
* @author chen
* @date 2024-07-30
*/
@Service
public class RepairStaffTypeServiceImpl extends ServiceImpl<RepairStaffTypeMapper, RepairStaffType> implements IRepairStaffTypeService {
@Autowired
private RepairStaffTypeMapper repairStaffTypeMapper;
/**
* 查询RepairStaffType
*
* @param id RepairStaffTypeID
* @return RepairStaffType
*/
@Override
public RepairStaffType selectRepairStaffTypeById(Long id) {
return repairStaffTypeMapper.selectById(id);
}
/**
* 查询RepairStaffType列表
*
* @param repairStaffType RepairStaffType
* @return RepairStaffType
*/
@Override
public List<RepairStaffType> selectRepairStaffTypeList(RepairStaffType repairStaffType) {
QueryWrapper queryWrapper = new QueryWrapper();
return repairStaffTypeMapper.selectList(queryWrapper);
}
/**
* 新增RepairStaffType
*
* @param repairStaffType RepairStaffType
* @return 结果
*/
@Override
public int insertRepairStaffType(RepairStaffType repairStaffType) {
return repairStaffTypeMapper.insert(repairStaffType);
}
/**
* 修改RepairStaffType
*
* @param repairStaffType RepairStaffType
* @return 结果
*/
@Override
public int updateRepairStaffType(RepairStaffType repairStaffType) {
return repairStaffTypeMapper.updateById(repairStaffType);
}
/**
* 删除RepairStaffType对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairStaffTypeByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairStaffTypeMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除RepairStaffType信息
*
* @param id RepairStaffTypeID
* @return 结果
*/
@Override
public int deleteRepairStaffTypeById(Long id) {
return repairStaffTypeMapper.deleteRepairStaffTypeById(id);
}
@Override
public Long selectRepairTypeByUserId(Integer userId) {
QueryWrapper<RepairStaffType> wrapper = new QueryWrapper<>();
wrapper.eq("staff_id",userId);
RepairStaffType repairStaffType = baseMapper.selectOne(wrapper);
if (repairStaffType != null) {
return repairStaffType.getTypeId();
}
return null;
}
@Override
public RepairStaffType selectStaffIdByTypeId(Long id) {
QueryWrapper<RepairStaffType> wrapper = new QueryWrapper<>();
wrapper.eq("type_id",id);
RepairStaffType repairStaffType = baseMapper.selectOne(wrapper);
return repairStaffType;
}
}

94
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairTypeServiceImpl.java
View File

@ -1,94 +0,0 @@
package com.ics.admin.service.impl;
import java.util.List;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairTypeMapper;
import com.ics.admin.domain.RepairType;
import com.ics.admin.service.IRepairTypeService;
/**
* 设备类型Service业务层处理
*
* @author ics
* @date 2024-07-30
*/
@Service
public class RepairTypeServiceImpl extends ServiceImpl<RepairTypeMapper, RepairType> implements IRepairTypeService {
@Autowired
private RepairTypeMapper repairTypeMapper;
/**
* 查询设备类型
*
* @param id 设备类型ID
* @return 设备类型
*/
@Override
public RepairType selectRepairTypeById(Long id) {
return repairTypeMapper.selectById(id);
}
/**
* 查询设备类型列表
*
* @param repairType 设备类型
* @return 设备类型
*/
@Override
public List<RepairType> selectRepairTypeList(RepairType repairType) {
QueryWrapper queryWrapper = new QueryWrapper();
return repairTypeMapper.selectList(queryWrapper);
}
/**
* 新增设备类型
*
* @param repairType 设备类型
* @return 结果
*/
@Override
public int insertRepairType(RepairType repairType) {
return repairTypeMapper.insert(repairType);
}
/**
* 修改设备类型
*
* @param repairType 设备类型
* @return 结果
*/
@Override
public int updateRepairType(RepairType repairType) {
return repairTypeMapper.updateById(repairType);
}
/**
* 删除设备类型对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairTypeByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairTypeMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除设备类型信息
*
* @param id 设备类型ID
* @return 结果
*/
@Override
public int deleteRepairTypeById(Long id) {
return repairTypeMapper.deleteRepairTypeById(id);
}
}

118
shoot-hand/ics-admin/src/main/java/com/ics/admin/service/impl/RepairWorkerTypeServiceImpl.java
View File

@ -1,118 +0,0 @@
package com.ics.admin.service.impl;
import java.util.List;
import java.util.stream.Collectors;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ics.admin.mapper.IcsCustomerStaffMapper;
import com.ics.common.core.domain.IcsCustomerStaff;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ics.admin.mapper.RepairWorkerTypeMapper;
import com.ics.admin.domain.RepairWorkerType;
import com.ics.admin.service.IRepairWorkerTypeService;
/**
* 维修人分类关联Service业务层处理
*
* @author chen
* @date 2024-07-31
*/
@Service
public class RepairWorkerTypeServiceImpl extends ServiceImpl<RepairWorkerTypeMapper, RepairWorkerType> implements IRepairWorkerTypeService {
@Autowired
private RepairWorkerTypeMapper repairWorkerTypeMapper;
@Autowired
private IcsCustomerStaffMapper icsCustomerStaffMapper;
/**
* 查询维修人分类关联
*
* @param id 维修人分类关联ID
* @return 维修人分类关联
*/
@Override
public RepairWorkerType selectRepairWorkerTypeById(Long id) {
return repairWorkerTypeMapper.selectById(id);
}
/**
* 查询维修人分类关联列表
*
* @param repairWorkerType 维修人分类关联
* @return 维修人分类关联
*/
@Override
public List<RepairWorkerType> selectRepairWorkerTypeList(RepairWorkerType repairWorkerType) {
QueryWrapper queryWrapper = new QueryWrapper();
return repairWorkerTypeMapper.selectList(queryWrapper);
}
/**
* 新增维修人分类关联
*
* @param repairWorkerType 维修人分类关联
* @return 结果
*/
@Override
public int insertRepairWorkerType(RepairWorkerType repairWorkerType) {
return repairWorkerTypeMapper.insert(repairWorkerType);
}
/**
* 修改维修人分类关联
*
* @param repairWorkerType 维修人分类关联
* @return 结果
*/
@Override
public int updateRepairWorkerType(RepairWorkerType repairWorkerType) {
return repairWorkerTypeMapper.updateById(repairWorkerType);
}
/**
* 删除维修人分类关联对象
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
public int deleteRepairWorkerTypeByIds(String ids) {
String[] idsArray = StrUtil.split(ids,",");
return repairWorkerTypeMapper.deleteBatchIds(CollUtil.toList(idsArray));
}
/**
* 删除维修人分类关联信息
*
* @param id 维修人分类关联ID
* @return 结果
*/
@Override
public int deleteRepairWorkerTypeById(Long id) {
return repairWorkerTypeMapper.deleteRepairWorkerTypeById(id);
}
@Override
public List<IcsCustomerStaff> selectRepairWorkerTypeListByTypeId(Long type) {
LambdaQueryWrapper<RepairWorkerType> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(RepairWorkerType::getTypeId,type);
List<RepairWorkerType> repairWorkerTypes = repairWorkerTypeMapper.selectList(wrapper);
//获取用户ids
if (CollUtil.isNotEmpty(repairWorkerTypes)){
List<Long> collect = repairWorkerTypes.stream().map(RepairWorkerType::getWorkerId).collect(Collectors.toList());
LambdaQueryWrapper<IcsCustomerStaff> userWrapper = new LambdaQueryWrapper<>();
return icsCustomerStaffMapper.selectList(userWrapper.in(IcsCustomerStaff::getId, collect));
}
return null;
}
}

58
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairRoomMapper.xml → shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairAddressFloorMapper.xml
View File

@ -2,11 +2,13 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ics.admin.mapper.meeting.RepairRoomMapper">
<resultMap type="com.ics.admin.domain.RepairRoom" id="RepairRoomResult">
<mapper namespace="com.ics.admin.mapper.RepairAddressFloorMapper">
<resultMap type="com.ics.admin.domain.RepairAddressFloor" id="RepairAddressFloorResult">
<result property="id" column="id" />
<result property="addressId" column="address_id" />
<result property="name" column="name" />
<result property="adminId" column="admin_Id" />
<result property="remark" column="remark" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
@ -15,29 +17,30 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<result property="updateTime" column="update_time" />
<result property="tenantId" column="tenant_id" />
<result property="parkId" column="park_id" />
<result property="addressId" column="address_id" />
</resultMap>
<sql id="selectRepairRoomVo">
SELECT id, name, remark, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id, address_id FROM ics_repair_room
<sql id="selectRepairAddressFloorVo">
SELECT id, address_id, name, admin_Id, remark, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_address_floor
</sql>
<select id="selectRepairRoomList" parameterType="RepairRoom" resultMap="RepairRoomResult">
<include refid="selectRepairRoomVo"/>
<where>
<select id="selectRepairAddressFloorList" parameterType="RepairAddressFloor" resultMap="RepairAddressFloorResult">
<include refid="selectRepairAddressFloorVo"/>
<where>
<if test="name != null and name != ''"> AND name LIKE CONCAT('%', #{name}, '%')</if>
</where>
</select>
<select id="selectRepairRoomById" parameterType="Long" resultMap="RepairRoomResult">
<include refid="selectRepairRoomVo"/>
<select id="selectRepairAddressFloorById" parameterType="Long" resultMap="RepairAddressFloorResult">
<include refid="selectRepairAddressFloorVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairRoom" parameterType="RepairRoom" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_room
<insert id="insertRepairAddressFloor" parameterType="RepairAddressFloor" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_address_floor
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="addressId != null ">address_id,</if>
<if test="name != null and name != ''">name,</if>
<if test="adminId != null ">admin_Id,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
@ -46,10 +49,11 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
<if test="addressId != null ">address_id,</if>
</trim>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="addressId != null ">#{addressId},</if>
<if test="name != null and name != ''">#{name},</if>
<if test="adminId != null ">#{adminId},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="deleteFlag != null and deleteFlag != ''">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
@ -58,14 +62,15 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
<if test="addressId != null ">#{addressId},</if>
</trim>
</trim>
</insert>
<update id="updateRepairRoom" parameterType="RepairRoom">
UPDATE ics_repair_room
<update id="updateRepairAddressFloor" parameterType="RepairAddressFloor">
UPDATE ics_repair_address_floor
<trim prefix="SET" suffixOverrides=",">
<if test="addressId != null ">address_id = #{addressId},</if>
<if test="name != null and name != ''">name = #{name},</if>
<if test="adminId != null ">admin_Id = #{adminId},</if>
<if test="remark != null and remark != ''">remark = #{remark},</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
@ -74,20 +79,19 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">update_time = #{updateTime},</if>
<if test="tenantId != null ">tenant_id = #{tenantId},</if>
<if test="parkId != null ">park_id = #{parkId},</if>
<if test="addressId != null ">address_id = #{addressId},</if>
</trim>
WHERE id = #{id}
</update>
<delete id="deleteRepairRoomById" parameterType="Long">
DELETE FROM ics_repair_room WHERE id = #{id}
<delete id="deleteRepairAddressFloorById" parameterType="Long">
DELETE FROM ics_repair_address_floor WHERE id = #{id}
</delete>
<delete id="deleteRepairRoomByIds" parameterType="String">
DELETE FROM ics_repair_room where id in
<delete id="deleteRepairAddressFloorByIds" parameterType="String">
DELETE FROM ics_repair_address_floor where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>

16
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairAddressMapper.xml
View File

@ -2,8 +2,8 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ics.admin.mapper.meeting.RepairAddressMapper">
<mapper namespace="com.ics.admin.mapper.RepairAddressMapper">
<resultMap type="com.ics.admin.domain.RepairAddress" id="RepairAddressResult">
<result property="id" column="id" />
<result property="name" column="name" />
@ -23,16 +23,16 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<select id="selectRepairAddressList" parameterType="RepairAddress" resultMap="RepairAddressResult">
<include refid="selectRepairAddressVo"/>
<where>
<where>
<if test="name != null and name != ''"> AND name LIKE CONCAT('%', #{name}, '%')</if>
</where>
</select>
<select id="selectRepairAddressById" parameterType="Long" resultMap="RepairAddressResult">
<include refid="selectRepairAddressVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairAddress" parameterType="RepairAddress" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_address
<trim prefix="(" suffix=")" suffixOverrides=",">
@ -45,7 +45,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
</trim>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="name != null and name != ''">#{name},</if>
<if test="remark != null and remark != ''">#{remark},</if>
@ -56,7 +56,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
</trim>
</trim>
</insert>
<update id="updateRepairAddress" parameterType="RepairAddress">
@ -85,5 +85,5 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
#{id}
</foreach>
</delete>
</mapper>

118
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairAttachMapper.xml Normal file
View File

@ -0,0 +1,118 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ics.admin.mapper.RepairAttachMapper">
<resultMap type="com.ics.admin.domain.RepairAttach" id="RepairAttachResult">
<result property="id" column="id" />
<result property="repairId" column="repair_id" />
<result property="nodeId" column="node_id" />
<result property="originalFilename" column="original_filename" />
<result property="filename" column="filename" />
<result property="url" column="url" />
<result property="fileSize" column="filesize" />
<result property="ext1" column="ext1" />
<result property="ext2" column="ext2" />
<result property="ext3" column="ext3" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
<result property="tenantId" column="tenant_id" />
<result property="parkId" column="park_id" />
</resultMap>
<sql id="selectRepairAttachVo">
SELECT id, repair_id, node_id, original_filename, filename, url, filesize, ext1, ext2, ext3, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_attach
</sql>
<select id="selectRepairAttachList" parameterType="RepairAttach" resultMap="RepairAttachResult">
<include refid="selectRepairAttachVo"/>
<where>
<if test="originalFilename != null and originalFilename != ''"> AND original_filename LIKE CONCAT('%', #{originalFilename}, '%')</if>
<if test="filename != null and filename != ''"> AND filename LIKE CONCAT('%', #{filename}, '%')</if>
</where>
</select>
<select id="selectRepairAttachById" parameterType="Long" resultMap="RepairAttachResult">
<include refid="selectRepairAttachVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairAttach" parameterType="RepairAttach" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_attach
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="repairId != null ">repair_id,</if>
<if test="nodeId != null ">node_id,</if>
<if test="originalFilename != null and originalFilename != ''">original_filename,</if>
<if test="filename != null and filename != ''">filename,</if>
<if test="url != null and url != ''">url,</if>
<if test="filesize != null ">filesize,</if>
<if test="ext1 != null and ext1 != ''">ext1,</if>
<if test="ext2 != null and ext2 != ''">ext2,</if>
<if test="ext3 != null and ext3 != ''">ext3,</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
<if test="createTime != null ">create_time,</if>
<if test="updateBy != null and updateBy != ''">update_by,</if>
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="repairId != null ">#{repairId},</if>
<if test="nodeId != null ">#{nodeId},</if>
<if test="originalFilename != null and originalFilename != ''">#{originalFilename},</if>
<if test="filename != null and filename != ''">#{filename},</if>
<if test="url != null and url != ''">#{url},</if>
<if test="filesize != null ">#{filesize},</if>
<if test="ext1 != null and ext1 != ''">#{ext1},</if>
<if test="ext2 != null and ext2 != ''">#{ext2},</if>
<if test="ext3 != null and ext3 != ''">#{ext3},</if>
<if test="deleteFlag != null and deleteFlag != ''">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
<if test="createTime != null ">#{createTime},</if>
<if test="updateBy != null and updateBy != ''">#{updateBy},</if>
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
</trim>
</insert>
<update id="updateRepairAttach" parameterType="RepairAttach">
UPDATE ics_repair_attach
<trim prefix="SET" suffixOverrides=",">
<if test="repairId != null ">repair_id = #{repairId},</if>
<if test="nodeId != null ">node_id = #{nodeId},</if>
<if test="originalFilename != null and originalFilename != ''">original_filename = #{originalFilename},</if>
<if test="filename != null and filename != ''">filename = #{filename},</if>
<if test="url != null and url != ''">url = #{url},</if>
<if test="filesize != null ">filesize = #{filesize},</if>
<if test="ext1 != null and ext1 != ''">ext1 = #{ext1},</if>
<if test="ext2 != null and ext2 != ''">ext2 = #{ext2},</if>
<if test="ext3 != null and ext3 != ''">ext3 = #{ext3},</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
<if test="createTime != null ">create_time = #{createTime},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
<if test="updateTime != null ">update_time = #{updateTime},</if>
<if test="tenantId != null ">tenant_id = #{tenantId},</if>
<if test="parkId != null ">park_id = #{parkId},</if>
</trim>
WHERE id = #{id}
</update>
<delete id="deleteRepairAttachById" parameterType="Long">
DELETE FROM ics_repair_attach WHERE id = #{id}
</delete>
<delete id="deleteRepairAttachByIds" parameterType="String">
DELETE FROM ics_repair_attach where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>

36
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairDeviceMapper.xml
View File

@ -2,15 +2,14 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ics.admin.mapper.meeting.RepairDeviceMapper">
<mapper namespace="com.ics.admin.mapper.RepairDeviceMapper">
<resultMap type="com.ics.admin.domain.RepairDevice" id="RepairDeviceResult">
<result property="id" column="id" />
<result property="typeId" column="type_id" />
<result property="name" column="name" />
<result property="brand" column="brand" />
<result property="specification" column="specification" />
<result property="picUrl" column="pic_url" />
<result property="fileUrl" column="file_url" />
<result property="remark" column="remark" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
@ -19,35 +18,32 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<result property="updateTime" column="update_time" />
<result property="tenantId" column="tenant_id" />
<result property="parkId" column="park_id" />
<result property="typeId" column="type_id" />
</resultMap>
<sql id="selectRepairDeviceVo">
SELECT id, name, brand, specification, pic_url, file_url, remark,type_id, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_device
SELECT id, type_id, name, brand, specification, remark, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_device
</sql>
<select id="selectRepairDeviceList" parameterType="RepairDevice" resultMap="RepairDeviceResult">
<include refid="selectRepairDeviceVo"/>
<where>
<where>
<if test="name != null and name != ''"> AND name LIKE CONCAT('%', #{name}, '%')</if>
</where>
</select>
<select id="selectRepairDeviceById" parameterType="Long" resultMap="RepairDeviceResult">
<include refid="selectRepairDeviceVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairDevice" parameterType="RepairDevice" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_device
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="typeId != null ">type_id,</if>
<if test="name != null and name != ''">name,</if>
<if test="brand != null and brand != ''">brand,</if>
<if test="specification != null and specification != ''">specification,</if>
<if test="picUrl != null and picUrl != ''">pic_url,</if>
<if test="fileUrl != null and fileUrl != ''">file_url,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="typeId != null and typeId != ''">type_id,</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
<if test="createTime != null ">create_time,</if>
@ -55,14 +51,12 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
</trim>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="typeId != null ">#{typeId},</if>
<if test="name != null and name != ''">#{name},</if>
<if test="brand != null and brand != ''">#{brand},</if>
<if test="specification != null and specification != ''">#{specification},</if>
<if test="picUrl != null and picUrl != ''">#{picUrl},</if>
<if test="typeId != null and typeId != ''">#{typeId},</if>
<if test="fileUrl != null and fileUrl != ''">#{fileUrl},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="deleteFlag != null and deleteFlag != ''">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
@ -71,19 +65,17 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
</trim>
</trim>
</insert>
<update id="updateRepairDevice" parameterType="RepairDevice">
UPDATE ics_repair_device
<trim prefix="SET" suffixOverrides=",">
<if test="typeId != null ">type_id = #{typeId},</if>
<if test="name != null and name != ''">name = #{name},</if>
<if test="brand != null and brand != ''">brand = #{brand},</if>
<if test="specification != null and specification != ''">specification = #{specification},</if>
<if test="picUrl != null and picUrl != ''">pic_url = #{picUrl},</if>
<if test="fileUrl != null and fileUrl != ''">file_url = #{fileUrl},</if>
<if test="remark != null and remark != ''">remark = #{remark},</if>
<if test="typeId != null and typeId != ''">type_id = #{typeId},</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
<if test="createTime != null ">create_time = #{createTime},</if>
@ -105,5 +97,5 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
#{id}
</foreach>
</delete>
</mapper>
</mapper>

48
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairTypeMapper.xml → shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairDeviceTypeMapper.xml
View File

@ -2,9 +2,9 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ics.admin.mapper.meeting.RepairTypeMapper">
<resultMap type="com.ics.admin.domain.RepairType" id="RepairTypeResult">
<mapper namespace="com.ics.admin.mapper.RepairDeviceTypeMapper">
<resultMap type="com.ics.admin.domain.RepairDeviceType" id="RepairDeviceTypeResult">
<result property="id" column="id" />
<result property="name" column="name" />
<result property="remark" column="remark" />
@ -17,26 +17,25 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<result property="parkId" column="park_id" />
</resultMap>
<sql id="selectRepairTypeVo">
SELECT id, name, remark, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_type
<sql id="selectRepairDeviceTypeVo">
SELECT id, name, remark, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_device_type
</sql>
<select id="selectRepairTypeList" parameterType="RepairType" resultMap="RepairTypeResult">
<include refid="selectRepairTypeVo"/>
<where>
<select id="selectRepairDeviceTypeList" parameterType="RepairDeviceType" resultMap="RepairDeviceTypeResult">
<include refid="selectRepairDeviceTypeVo"/>
<where>
<if test="name != null and name != ''"> AND name LIKE CONCAT('%', #{name}, '%')</if>
</where>
</select>
<select id="selectRepairTypeById" parameterType="Long" resultMap="RepairTypeResult">
<include refid="selectRepairTypeVo"/>
<select id="selectRepairDeviceTypeById" parameterType="Long" resultMap="RepairDeviceTypeResult">
<include refid="selectRepairDeviceTypeVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairType" parameterType="RepairType">
INSERT INTO ics_repair_type
<insert id="insertRepairDeviceType" parameterType="RepairDeviceType" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_device_type
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null ">id,</if>
<if test="name != null and name != ''">name,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag,</if>
@ -46,9 +45,8 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
</trim>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null ">#{id},</if>
<if test="name != null and name != ''">#{name},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="deleteFlag != null and deleteFlag != ''">#{deleteFlag},</if>
@ -58,11 +56,11 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
</trim>
</trim>
</insert>
<update id="updateRepairType" parameterType="RepairType">
UPDATE ics_repair_type
<update id="updateRepairDeviceType" parameterType="RepairDeviceType">
UPDATE ics_repair_device_type
<trim prefix="SET" suffixOverrides=",">
<if test="name != null and name != ''">name = #{name},</if>
<if test="remark != null and remark != ''">remark = #{remark},</if>
@ -77,15 +75,15 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
WHERE id = #{id}
</update>
<delete id="deleteRepairTypeById" parameterType="Long">
DELETE FROM ics_repair_type WHERE id = #{id}
<delete id="deleteRepairDeviceTypeById" parameterType="Long">
DELETE FROM ics_repair_device_type WHERE id = #{id}
</delete>
<delete id="deleteRepairTypeByIds" parameterType="String">
DELETE FROM ics_repair_type where id in
<delete id="deleteRepairDeviceTypeByIds" parameterType="String">
DELETE FROM ics_repair_device_type where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>

17
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairFailureTypeMapper.xml
View File

@ -7,6 +7,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<resultMap type="com.ics.admin.domain.RepairFailureType" id="RepairFailureTypeResult">
<result property="id" column="id" />
<result property="name" column="name" />
<result property="kind" column="kind" />
<result property="remark" column="remark" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
@ -18,25 +19,27 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
</resultMap>
<sql id="selectRepairFailureTypeVo">
SELECT id, name, remark, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_failure_type
SELECT id, name, kind, remark, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_failure_type
</sql>
<select id="selectRepairFailureTypeList" parameterType="RepairFailureType" resultMap="RepairFailureTypeResult">
<include refid="selectRepairFailureTypeVo"/>
<where>
<if test="name != null and name != ''"> AND name LIKE CONCAT('%', #{name}, '%')</if>
and delete_flag = 0
</where>
</select>
<select id="selectRepairFailureTypeById" parameterType="Long" resultMap="RepairFailureTypeResult">
<include refid="selectRepairFailureTypeVo"/>
WHERE id = #{id}
WHERE id = #{id} and delete_flag = 0
</select>
<insert id="insertRepairFailureType" parameterType="RepairFailureType" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_failure_type
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="name != null and name != ''">name,</if>
<if test="kind != null and kind != ''">kind,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
@ -48,6 +51,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="name != null and name != ''">#{name},</if>
<if test="kind != null and kind != ''">#{kind},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="deleteFlag != null and deleteFlag != ''">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
@ -63,10 +67,11 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
UPDATE ics_repair_failure_type
<trim prefix="SET" suffixOverrides=",">
<if test="name != null and name != ''">name = #{name},</if>
<if test="kind != null and name != ''">kind = #{kind},</if>
<if test="remark != null and remark != ''">remark = #{remark},</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
<if test="createTime != null ">create_time = #{createTime},</if>
<!--<if test="deleteFlag != null and deleteFlag != ''">delete_flag = #{deleteFlag},</if>-->
<!--<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>-->
<!--<if test="createTime != null ">create_time = #{createTime},</if>-->
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
<if test="updateTime != null ">update_time = #{updateTime},</if>
<if test="tenantId != null ">tenant_id = #{tenantId},</if>
@ -76,7 +81,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
</update>
<delete id="deleteRepairFailureTypeById" parameterType="Long">
DELETE FROM ics_repair_failure_type WHERE id = #{id}
DELETE FROM ics_repair_failure_type where id = #{id}
</delete>
<delete id="deleteRepairFailureTypeByIds" parameterType="String">

154
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairLogMapper.xml
View File

@ -5,40 +5,146 @@
<mapper namespace="com.ics.admin.mapper.RepairLogMapper">
<resultMap type="com.ics.admin.domain.RepairLog" id="RepairLogResult">
<result property="id" column="id"/>
<result property="type" column="type"/>
<result property="detail" column="detail"/>
<result property="repairId" column="repair_id"/>
<result property="version" column="version"/>
<result property="deleteFlag" column="delete_flag"/>
<result property="createBy" column="create_by"/>
<result property="createTime" column="create_time"/>
<result property="updateBy" column="update_by"/>
<result property="updateTime" column="update_time"/>
<result property="tenantId" column="tenant_id"/>
<result property="id" column="id" />
<result property="pid" column="pid" />
<result property="repairId" column="repair_id" />
<result property="nodeForm" column="node_form" />
<result property="nodeTo" column="node_to" />
<result property="sendUserId" column="send_userid" />
<result property="sendUsername" column="send_username" />
<result property="recUserId" column="rec_userid" />
<result property="recUsername" column="rec_username" />
<result property="read" column="read" />
<result property="readTime" column="readtime" />
<result property="status" column="status" />
<result property="closeTime" column="closetime" />
<result property="content" column="content" />
<result property="remark" column="remark" />
<result property="ext1" column="ext1" />
<result property="ext2" column="ext2" />
<result property="ext3" column="ext3" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
<result property="parkId" column="park_id" />
<result property="tenantId" column="tenant_id" />
</resultMap>
<sql id="selectRepairLogVo">
SELECT id,
type,
detail,
repair_id,
version,
delete_flag,
create_by,
create_time,
update_by,
update_time,
tenant_id
FROM ics_repair_log
SELECT id, pid, repair_id, node_form, node_to, send_userid, send_username, rec_userid, rec_username, read, readtime, status, closetime, content, remark, ext1, ext2, ext3, delete_flag, create_by, create_time, update_by, update_time, park_id, tenant_id FROM ics_repair_log
</sql>
<select id="selectRepairLogList" parameterType="RepairLog" resultMap="RepairLogResult">
<include refid="selectRepairLogVo"/>
<where>
<if test="repairId != null">AND repair_id = #{repairId}</if>
<if test="sendUsername != null and sendUsername != ''"> AND send_username LIKE CONCAT('%', #{sendUsername}, '%')</if>
<if test="recUsername != null and recUsername != ''"> AND rec_username LIKE CONCAT('%', #{recUsername}, '%')</if>
</where>
</select>
<select id="selectRepairLogById" parameterType="Long" resultMap="RepairLogResult">
<include refid="selectRepairLogVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairLog" parameterType="RepairLog" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_log
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="pid != null ">pid,</if>
<if test="repairId != null ">repair_id,</if>
<if test="nodeForm != null ">node_form,</if>
<if test="nodeTo != null ">node_to,</if>
<if test="sendUserid != null ">send_userid,</if>
<if test="sendUsername != null and sendUsername != ''">send_username,</if>
<if test="recUserid != null ">rec_userid,</if>
<if test="recUsername != null and recUsername != ''">rec_username,</if>
<if test="read != null ">read,</if>
<if test="readtime != null ">readtime,</if>
<if test="status != null ">status,</if>
<if test="closetime != null ">closetime,</if>
<if test="content != null and content != ''">content,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="ext1 != null and ext1 != ''">ext1,</if>
<if test="ext2 != null and ext2 != ''">ext2,</if>
<if test="ext3 != null and ext3 != ''">ext3,</if>
<if test="deleteFlag != null ">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
<if test="createTime != null ">create_time,</if>
<if test="updateBy != null and updateBy != ''">update_by,</if>
<if test="updateTime != null ">update_time,</if>
<if test="parkId != null ">park_id,</if>
<if test="tenantId != null ">tenant_id,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="pid != null ">#{pid},</if>
<if test="repairId != null ">#{repairId},</if>
<if test="nodeForm != null ">#{nodeForm},</if>
<if test="nodeTo != null ">#{nodeTo},</if>
<if test="sendUserid != null ">#{sendUserid},</if>
<if test="sendUsername != null and sendUsername != ''">#{sendUsername},</if>
<if test="recUserid != null ">#{recUserid},</if>
<if test="recUsername != null and recUsername != ''">#{recUsername},</if>
<if test="read != null ">#{read},</if>
<if test="readtime != null ">#{readtime},</if>
<if test="status != null ">#{status},</if>
<if test="closetime != null ">#{closetime},</if>
<if test="content != null and content != ''">#{content},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="ext1 != null and ext1 != ''">#{ext1},</if>
<if test="ext2 != null and ext2 != ''">#{ext2},</if>
<if test="ext3 != null and ext3 != ''">#{ext3},</if>
<if test="deleteFlag != null ">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
<if test="createTime != null ">#{createTime},</if>
<if test="updateBy != null and updateBy != ''">#{updateBy},</if>
<if test="updateTime != null ">#{updateTime},</if>
<if test="parkId != null ">#{parkId},</if>
<if test="tenantId != null ">#{tenantId},</if>
</trim>
</insert>
<update id="updateRepairLog" parameterType="RepairLog">
UPDATE ics_repair_log
<trim prefix="SET" suffixOverrides=",">
<if test="pid != null ">pid = #{pid},</if>
<if test="repairId != null ">repair_id = #{repairId},</if>
<if test="nodeForm != null ">node_form = #{nodeForm},</if>
<if test="nodeTo != null ">node_to = #{nodeTo},</if>
<if test="sendUserid != null ">send_userid = #{sendUserid},</if>
<if test="sendUsername != null and sendUsername != ''">send_username = #{sendUsername},</if>
<if test="recUserid != null ">rec_userid = #{recUserid},</if>
<if test="recUsername != null and recUsername != ''">rec_username = #{recUsername},</if>
<if test="read != null ">read = #{read},</if>
<if test="readtime != null ">readtime = #{readtime},</if>
<if test="status != null ">status = #{status},</if>
<if test="closetime != null ">closetime = #{closetime},</if>
<if test="content != null and content != ''">content = #{content},</if>
<if test="remark != null and remark != ''">remark = #{remark},</if>
<if test="ext1 != null and ext1 != ''">ext1 = #{ext1},</if>
<if test="ext2 != null and ext2 != ''">ext2 = #{ext2},</if>
<if test="ext3 != null and ext3 != ''">ext3 = #{ext3},</if>
<if test="deleteFlag != null ">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
<if test="createTime != null ">create_time = #{createTime},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
<if test="updateTime != null ">update_time = #{updateTime},</if>
<if test="parkId != null ">park_id = #{parkId},</if>
<if test="tenantId != null ">tenant_id = #{tenantId},</if>
</trim>
WHERE id = #{id}
</update>
<delete id="deleteRepairLogById" parameterType="Long">
DELETE FROM ics_repair_log WHERE id = #{id}
</delete>
<delete id="deleteRepairLogByIds" parameterType="String">
DELETE FROM ics_repair_log where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>

320
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairMapper.xml
View File

@ -5,131 +5,229 @@
<mapper namespace="com.ics.admin.mapper.RepairMapper">
<resultMap type="com.ics.admin.domain.Repair" id="RepairResult">
<result property="id" column="id"/>
<result property="sn" column="sn"/>
<result property="repairName" column="repair_name"/>
<result property="repairLevel" column="repair_level"/>
<result property="repairDevice" column="repair_device"/>
<result property="typeId" column="type_id"/>
<result property="repairVoice" column="repair_voice"/>
<result property="dispatcherId" column="dispatcher_id"/>
<result property="failureTypeId" column="failure_type_id"/>
<result property="failureDate" column="failure_date"/>
<result property="addressId" column="address_id"/>
<result property="roomId" column="room_id"/>
<result property="name" column="name"/>
<result property="userId" column="user_id"/>
<result property="phone" column="phone"/>
<result property="area" column="area"/>
<result property="status" column="status" />
<result property="content" column="content"/>
<result property="repairTime" column="repair_time"/>
<result property="repairImages" column="repair_images" />
<result property="repairFee" column="repair_fee"/>
<result property="repairScore" column="repair_score"/>
<result property="repairMateriel" column="repair_materiel"/>
<result property="beginDate" column="begin_date"/>
<result property="endDate" column="end_date"/>
<result property="remark" column="remark"/>
<result property="workerScore" column="worker_score"/>
<result property="workerExplain" column="worker_explain"/>
<result property="workerProof" column="worker_proof"/>
<result property="workerId" column="worker_id"/>
<result property="customerId" column="customer_id"/>
<result property="version" column="version"/>
<result property="deleteFlag" column="delete_flag"/>
<result property="createBy" column="create_by"/>
<result property="createTime" column="create_time"/>
<result property="updateBy" column="update_by"/>
<result property="updateTime" column="update_time"/>
<result property="tenantId" column="tenant_id"/>
<result property="parkId" column="park_id"/>
<association property="customer" javaType="com.ics.admin.domain.Customer" resultMap="CustomerResult"/>
<association property="park" javaType="com.ics.admin.domain.Park" resultMap="ParkResult"/>
<association property="user" javaType="com.ics.system.domain.User" resultMap="UserResult"/>
</resultMap>
<resultMap id="CustomerResult" type="com.ics.admin.domain.Customer">
<result property="id" column="cid"/>
<result property="name" column="cname"/>
</resultMap>
<resultMap id="ParkResult" type="com.ics.admin.domain.Park">
<id property="id" column="pid"/>
<result property="name" column="pname"/>
</resultMap>
<resultMap id="UserResult" type="com.ics.system.domain.User">
<id property="id" column="userId"/>
<id property="username" column="username"/>
<result property="mobile" column="mobile"/>
<result property="id" column="id" />
<result property="sn" column="sn" />
<result property="repairName" column="repair_name" />
<result property="repairLevel" column="repair_level" />
<result property="repairTime" column="repair_time" />
<result property="typeId" column="type_id" />
<result property="typeName" column="type_name" />
<result property="deviceId" column="device_id" />
<result property="deviceName" column="device_name" />
<result property="name" column="name" />
<result property="phone" column="phone" />
<result property="addressId" column="address_id" />
<result property="address" column="address" />
<result property="floorId" column="floor_id" />
<result property="floor" column="floor" />
<result property="room" column="room" />
<result property="content" column="content" />
<result property="perUserId" column="per_userid" />
<result property="predate" column="predate" />
<result property="cause" column="cause" />
<result property="solution" column="solution" />
<result property="failureTypeId" column="failure_type_id" />
<result property="failureTypeName" column="failure_type_name" />
<result property="resolve" column="resolve" />
<result property="repairUserId" column="repair_user_id" />
<result property="endDate" column="end_date" />
<result property="evalService" column="eval_service" />
<result property="feedback" column="feedback" />
<result property="evalTime" column="eval_time" />
<result property="evalUserId" column="eval_user_id" />
<result property="timeout" column="timeout" />
<result property="warn" column="warn" />
<result property="status" column="status" />
<result property="logId" column="log_id" />
<result property="remark" column="remark" />
<result property="ext1" column="ext1" />
<result property="ext2" column="ext2" />
<result property="ext3" column="ext3" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
<result property="tenantId" column="tenant_id" />
<result property="parkId" column="park_id" />
</resultMap>
<sql id="selectRepairVo">
SELECT r.id,
r.sn,
r.name,
r.phone,
r.area,
r.status,
r.content,
r.failure_date,
r.repair_name,
r.user_id,
r.repair_level,
r.repair_voice,
r.address_id,
r.room_id,
r.worker_explain,
r.worker_proof,
r.dispatcher_id,
r.type_id,
r.repair_device,
r.failure_type_id,
r.repair_time,
r.repair_images,
r.repair_fee,
r.repair_score,
r.repair_materiel,
r.begin_date,
r.end_date,
r.remark,
r.worker_score,
r.worker_id,
r.customer_id,
r.create_by,
r.create_time,
r.update_by,
r.update_time,
r.tenant_id,
r.park_id
FROM ics_repair AS r
SELECT id, sn, repair_name, repair_level, repair_time, type_id, type_name, device_id, device_name, name, phone, address_id, address, floor_id, floor, room, content, per_userid, predate, cause, solution, failure_type_id, failure_type_name, resolve, repair_user_id, end_date, eval_service, feedback, eval_time, eval_user_id, timeout, warn, status, log_id, remark, ext1, ext2, ext3, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair
</sql>
<select id="selectRepairList" parameterType="com.ics.admin.domain.Repair" resultMap="RepairResult">
<select id="selectRepairList" parameterType="Repair" resultMap="RepairResult">
<include refid="selectRepairVo"/>
<where>
<if test="sn != null and sn != ''">AND r.sn LIKE CONCAT('%', #{sn}, '%')</if>
<if test="status != null"> AND r.status =#{status.ordinal}</if>
AND r.delete_flag = 0
<if test="repairName != null and repairName != ''"> AND repair_name LIKE CONCAT('%', #{repairName}, '%')</if>
<if test="typeName != null and typeName != ''"> AND type_name LIKE CONCAT('%', #{typeName}, '%')</if>
<if test="deviceName != null and deviceName != ''"> AND device_name LIKE CONCAT('%', #{deviceName}, '%')</if>
<if test="name != null and name != ''"> AND name LIKE CONCAT('%', #{name}, '%')</if>
<if test="failureTypeName != null and failureTypeName != ''"> AND failure_type_name LIKE CONCAT('%', #{failureTypeName}, '%')</if>
</where>
</select>
<select id="selectRepairById" parameterType="Long" resultMap="RepairResult">
<include refid="selectRepairVo"/>
WHERE r.id = #{id}
WHERE id = #{id}
</select>
<insert id="insertRepair" parameterType="Repair" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="sn != null and sn != ''">sn,</if>
<if test="repairName != null and repairName != ''">repair_name,</if>
<if test="repairLevel != null and repairLevel != ''">repair_level,</if>
<if test="repairTime != null ">repair_time,</if>
<if test="typeId != null ">type_id,</if>
<if test="typeName != null and typeName != ''">type_name,</if>
<if test="deviceId != null ">device_id,</if>
<if test="deviceName != null and deviceName != ''">device_name,</if>
<if test="name != null and name != ''">name,</if>
<if test="phone != null and phone != ''">phone,</if>
<if test="addressId != null ">address_id,</if>
<if test="address != null and address != ''">address,</if>
<if test="floorId != null ">floor_id,</if>
<if test="floor != null and floor != ''">floor,</if>
<if test="room != null and room != ''">room,</if>
<if test="content != null and content != ''">content,</if>
<if test="perUserid != null ">per_userid,</if>
<if test="predate != null ">predate,</if>
<if test="cause != null and cause != ''">cause,</if>
<if test="solution != null and solution != ''">solution,</if>
<if test="failureTypeId != null ">failure_type_id,</if>
<if test="failureTypeName != null and failureTypeName != ''">failure_type_name,</if>
<if test="resolve != null ">resolve,</if>
<if test="repairUserId != null ">repair_user_id,</if>
<if test="endDate != null ">end_date,</if>
<if test="evalService != null ">eval_service,</if>
<if test="feedback != null and feedback != ''">feedback,</if>
<if test="evalTime != null ">eval_time,</if>
<if test="evalUserId != null ">eval_user_id,</if>
<if test="timeout != null ">timeout,</if>
<if test="warn != null ">warn,</if>
<if test="status != null ">status,</if>
<if test="logId != null ">log_id,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="ext1 != null and ext1 != ''">ext1,</if>
<if test="ext2 != null and ext2 != ''">ext2,</if>
<if test="ext3 != null and ext3 != ''">ext3,</if>
<if test="deleteFlag != null ">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
<if test="createTime != null ">create_time,</if>
<if test="updateBy != null and updateBy != ''">update_by,</if>
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="sn != null and sn != ''">#{sn},</if>
<if test="repairName != null and repairName != ''">#{repairName},</if>
<if test="repairLevel != null and repairLevel != ''">#{repairLevel},</if>
<if test="repairTime != null ">#{repairTime},</if>
<if test="typeId != null ">#{typeId},</if>
<if test="typeName != null and typeName != ''">#{typeName},</if>
<if test="deviceId != null ">#{deviceId},</if>
<if test="deviceName != null and deviceName != ''">#{deviceName},</if>
<if test="name != null and name != ''">#{name},</if>
<if test="phone != null and phone != ''">#{phone},</if>
<if test="addressId != null ">#{addressId},</if>
<if test="address != null and address != ''">#{address},</if>
<if test="floorId != null ">#{floorId},</if>
<if test="floor != null and floor != ''">#{floor},</if>
<if test="room != null and room != ''">#{room},</if>
<if test="content != null and content != ''">#{content},</if>
<if test="perUserid != null ">#{perUserid},</if>
<if test="predate != null ">#{predate},</if>
<if test="cause != null and cause != ''">#{cause},</if>
<if test="solution != null and solution != ''">#{solution},</if>
<if test="failureTypeId != null ">#{failureTypeId},</if>
<if test="failureTypeName != null and failureTypeName != ''">#{failureTypeName},</if>
<if test="resolve != null ">#{resolve},</if>
<if test="repairUserId != null ">#{repairUserId},</if>
<if test="endDate != null ">#{endDate},</if>
<if test="evalService != null ">#{evalService},</if>
<if test="feedback != null and feedback != ''">#{feedback},</if>
<if test="evalTime != null ">#{evalTime},</if>
<if test="evalUserId != null ">#{evalUserId},</if>
<if test="timeout != null ">#{timeout},</if>
<if test="warn != null ">#{warn},</if>
<if test="status != null ">#{status},</if>
<if test="logId != null ">#{logId},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="ext1 != null and ext1 != ''">#{ext1},</if>
<if test="ext2 != null and ext2 != ''">#{ext2},</if>
<if test="ext3 != null and ext3 != ''">#{ext3},</if>
<if test="deleteFlag != null ">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
<if test="createTime != null ">#{createTime},</if>
<if test="updateBy != null and updateBy != ''">#{updateBy},</if>
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
</trim>
</insert>
<select id="selectMyRepairList" parameterType="com.ics.admin.domain.Repair" resultMap="RepairResult">
<include refid="selectRepairVo"/>
<where>
<if test="sn != null and sn != ''">AND r.sn LIKE CONCAT('%', #{sn}, '%')</if>
<if test="status != null"> AND r.status =#{status.ordinal}</if>
<if test="createBy != null and createBy !=''"> AND r.create_by =#{createBy}</if>
<if test="parkId != null"> AND r.park_id =#{parkId}</if>
AND r.delete_flag = 0
</where>
</select>
<update id="updateRepair" parameterType="Repair">
UPDATE ics_repair
<trim prefix="SET" suffixOverrides=",">
<if test="sn != null and sn != ''">sn = #{sn},</if>
<if test="repairName != null and repairName != ''">repair_name = #{repairName},</if>
<if test="repairLevel != null and repairLevel != ''">repair_level = #{repairLevel},</if>
<if test="repairTime != null ">repair_time = #{repairTime},</if>
<if test="typeId != null ">type_id = #{typeId},</if>
<if test="typeName != null and typeName != ''">type_name = #{typeName},</if>
<if test="deviceId != null ">device_id = #{deviceId},</if>
<if test="deviceName != null and deviceName != ''">device_name = #{deviceName},</if>
<if test="name != null and name != ''">name = #{name},</if>
<if test="phone != null and phone != ''">phone = #{phone},</if>
<if test="addressId != null ">address_id = #{addressId},</if>
<if test="address != null and address != ''">address = #{address},</if>
<if test="floorId != null ">floor_id = #{floorId},</if>
<if test="floor != null and floor != ''">floor = #{floor},</if>
<if test="room != null and room != ''">room = #{room},</if>
<if test="content != null and content != ''">content = #{content},</if>
<if test="perUserid != null ">per_userid = #{perUserid},</if>
<if test="predate != null ">predate = #{predate},</if>
<if test="cause != null and cause != ''">cause = #{cause},</if>
<if test="solution != null and solution != ''">solution = #{solution},</if>
<if test="failureTypeId != null ">failure_type_id = #{failureTypeId},</if>
<if test="failureTypeName != null and failureTypeName != ''">failure_type_name = #{failureTypeName},</if>
<if test="resolve != null ">resolve = #{resolve},</if>
<if test="repairUserId != null ">repair_user_id = #{repairUserId},</if>
<if test="endDate != null ">end_date = #{endDate},</if>
<if test="evalService != null ">eval_service = #{evalService},</if>
<if test="feedback != null and feedback != ''">feedback = #{feedback},</if>
<if test="evalTime != null ">eval_time = #{evalTime},</if>
<if test="evalUserId != null ">eval_user_id = #{evalUserId},</if>
<if test="timeout != null ">timeout = #{timeout},</if>
<if test="warn != null ">warn = #{warn},</if>
<if test="status != null ">status = #{status},</if>
<if test="logId != null ">log_id = #{logId},</if>
<if test="remark != null and remark != ''">remark = #{remark},</if>
<if test="ext1 != null and ext1 != ''">ext1 = #{ext1},</if>
<if test="ext2 != null and ext2 != ''">ext2 = #{ext2},</if>
<if test="ext3 != null and ext3 != ''">ext3 = #{ext3},</if>
<if test="deleteFlag != null ">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
<if test="createTime != null ">create_time = #{createTime},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
<if test="updateTime != null ">update_time = #{updateTime},</if>
<if test="tenantId != null ">tenant_id = #{tenantId},</if>
<if test="parkId != null ">park_id = #{parkId},</if>
</trim>
WHERE id = #{id}
</update>
<delete id="deleteRepairById" parameterType="Long">
DELETE FROM ics_repair WHERE id = #{id}
</delete>
<delete id="deleteRepairByIds" parameterType="String">
DELETE FROM ics_repair where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>

114
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairRecordMapper.xml
View File

@ -1,114 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ics.admin.mapper.meeting.RepairRecordMapper">
<resultMap type="com.ics.admin.domain.RepairRecord" id="RepairRecordResult">
<result property="id" column="id" />
<result property="speed" column="speed" />
<result property="serve" column="serve" />
<result property="effect" column="effect" />
<result property="remark" column="remark" />
<result property="img" column="img" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
<result property="tenantId" column="tenant_id" />
<result property="parkId" column="park_id" />
<result property="repairId" column="repair_id" />
<result property="workerId" column="worker_id" />
<result property="userId" column="user_id" />
</resultMap>
<sql id="selectRepairRecordVo">
SELECT id, speed, serve, effect, remark, img, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id, repair_id, worker_id, user_id FROM ics_repair_record
</sql>
<select id="selectRepairRecordList" parameterType="RepairRecord" resultMap="RepairRecordResult">
<include refid="selectRepairRecordVo"/>
<where>
</where>
</select>
<select id="selectRepairRecordById" parameterType="Long" resultMap="RepairRecordResult">
<include refid="selectRepairRecordVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairRecord" parameterType="RepairRecord">
INSERT INTO ics_repair_record
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null ">id,</if>
<if test="speed != null ">speed,</if>
<if test="serve != null ">serve,</if>
<if test="effect != null ">effect,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="img != null and img != ''">img,</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
<if test="createTime != null ">create_time,</if>
<if test="updateBy != null and updateBy != ''">update_by,</if>
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
<if test="repairId != null ">repair_id,</if>
<if test="workerId != null ">worker_id,</if>
<if test="userId != null ">user_id,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null ">#{id},</if>
<if test="speed != null ">#{speed},</if>
<if test="serve != null ">#{serve},</if>
<if test="effect != null ">#{effect},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="img != null and img != ''">#{img},</if>
<if test="deleteFlag != null and deleteFlag != ''">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
<if test="createTime != null ">#{createTime},</if>
<if test="updateBy != null and updateBy != ''">#{updateBy},</if>
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
<if test="repairId != null ">#{repairId},</if>
<if test="workerId != null ">#{workerId},</if>
<if test="userId != null ">#{userId},</if>
</trim>
</insert>
<update id="updateRepairRecord" parameterType="RepairRecord">
UPDATE ics_repair_record
<trim prefix="SET" suffixOverrides=",">
<if test="speed != null ">speed = #{speed},</if>
<if test="serve != null ">serve = #{serve},</if>
<if test="effect != null ">effect = #{effect},</if>
<if test="remark != null and remark != ''">remark = #{remark},</if>
<if test="img != null and img != ''">img = #{img},</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
<if test="createTime != null ">create_time = #{createTime},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
<if test="updateTime != null ">update_time = #{updateTime},</if>
<if test="tenantId != null ">tenant_id = #{tenantId},</if>
<if test="parkId != null ">park_id = #{parkId},</if>
<if test="repairId != null ">repair_id = #{repairId},</if>
<if test="workerId != null ">worker_id = #{workerId},</if>
<if test="userId != null ">user_id = #{userId},</if>
</trim>
WHERE id = #{id}
</update>
<delete id="deleteRepairRecordById" parameterType="Long">
DELETE FROM ics_repair_record WHERE id = #{id}
</delete>
<delete id="deleteRepairRecordByIds" parameterType="String">
DELETE FROM ics_repair_record where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>

65
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairWorkerTypeMapper.xml → shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairRelationalMapper.xml
View File

@ -2,12 +2,14 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ics.chen.mapper.meeting.RepairWorkerTypeMapper">
<resultMap type="com.ics.admin.domain.RepairWorkerType" id="RepairWorkerTypeResult">
<mapper namespace="com.ics.admin.mapper.RepairRelationalMapper">
<resultMap type="com.ics.admin.domain.RepairRelational" id="RepairRelationalResult">
<result property="id" column="id" />
<result property="workerId" column="worker_id" />
<result property="typeId" column="type_id" />
<result property="kind" column="kind" />
<result property="groupName" column="groupName" />
<result property="userId" column="user_id" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
@ -17,27 +19,29 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<result property="parkId" column="park_id" />
</resultMap>
<sql id="selectRepairWorkerTypeVo">
SELECT id, worker_id, type_id, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_worker_type
<sql id="selectRepairRelationalVo">
SELECT id, type_id, kind, groupName, user_id, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_relational
</sql>
<select id="selectRepairWorkerTypeList" parameterType="RepairWorkerType" resultMap="RepairWorkerTypeResult">
<include refid="selectRepairWorkerTypeVo"/>
<where>
<select id="selectRepairRelationalList" parameterType="RepairRelational" resultMap="RepairRelationalResult">
<include refid="selectRepairRelationalVo"/>
<where>
<if test="groupname != null and groupname != ''"> AND groupName LIKE CONCAT('%', #{groupname}, '%')</if>
</where>
</select>
<select id="selectRepairWorkerTypeById" parameterType="Long" resultMap="RepairWorkerTypeResult">
<include refid="selectRepairWorkerTypeVo"/>
<select id="selectRepairRelationalById" parameterType="Long" resultMap="RepairRelationalResult">
<include refid="selectRepairRelationalVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairWorkerType" parameterType="RepairWorkerType">
INSERT INTO ics_repair_worker_type
<insert id="insertRepairRelational" parameterType="RepairRelational" useGeneratedKeys="true" keyProperty="id">
INSERT INTO ics_repair_relational
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null ">id,</if>
<if test="workerId != null ">worker_id,</if>
<if test="typeId != null ">type_id,</if>
<if test="kind != null ">kind,</if>
<if test="groupname != null and groupname != ''">groupName,</if>
<if test="userId != null ">user_id,</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
<if test="createTime != null ">create_time,</if>
@ -45,11 +49,12 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
</trim>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null ">#{id},</if>
<if test="workerId != null ">#{workerId},</if>
<if test="typeId != null ">#{typeId},</if>
<if test="kind != null ">#{kind},</if>
<if test="groupname != null and groupname != ''">#{groupname},</if>
<if test="userId != null ">#{userId},</if>
<if test="deleteFlag != null and deleteFlag != ''">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
<if test="createTime != null ">#{createTime},</if>
@ -57,14 +62,16 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
</trim>
</trim>
</insert>
<update id="updateRepairWorkerType" parameterType="RepairWorkerType">
UPDATE ics_repair_worker_type
<update id="updateRepairRelational" parameterType="RepairRelational">
UPDATE ics_repair_relational
<trim prefix="SET" suffixOverrides=",">
<if test="workerId != null ">worker_id = #{workerId},</if>
<if test="typeId != null ">type_id = #{typeId},</if>
<if test="kind != null ">kind = #{kind},</if>
<if test="groupname != null and groupname != ''">groupName = #{groupname},</if>
<if test="userId != null ">user_id = #{userId},</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
<if test="createTime != null ">create_time = #{createTime},</if>
@ -76,15 +83,15 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
WHERE id = #{id}
</update>
<delete id="deleteRepairWorkerTypeById" parameterType="Long">
DELETE FROM ics_repair_worker_type WHERE id = #{id}
<delete id="deleteRepairRelationalById" parameterType="Long">
DELETE FROM ics_repair_relational WHERE id = #{id}
</delete>
<delete id="deleteRepairWorkerTypeByIds" parameterType="String">
DELETE FROM ics_repair_worker_type where id in
<delete id="deleteRepairRelationalByIds" parameterType="String">
DELETE FROM ics_repair_relational where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>

90
shoot-hand/ics-admin/src/main/resources/mapper/admin/RepairStaffTypeMapper.xml
View File

@ -1,90 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ics.admin.mapper.meeting.RepairStaffTypeMapper">
<resultMap type="com.ics.admin.domain.RepairStaffType" id="RepairStaffTypeResult">
<result property="id" column="id" />
<result property="staffId" column="staff_id" />
<result property="typeId" column="type_id" />
<result property="deleteFlag" column="delete_flag" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
<result property="tenantId" column="tenant_id" />
<result property="parkId" column="park_id" />
</resultMap>
<sql id="selectRepairStaffTypeVo">
SELECT id, staff_id, type_id, delete_flag, create_by, create_time, update_by, update_time, tenant_id, park_id FROM ics_repair_staff_type
</sql>
<select id="selectRepairStaffTypeList" parameterType="RepairStaffType" resultMap="RepairStaffTypeResult">
<include refid="selectRepairStaffTypeVo"/>
<where>
</where>
</select>
<select id="selectRepairStaffTypeById" parameterType="Long" resultMap="RepairStaffTypeResult">
<include refid="selectRepairStaffTypeVo"/>
WHERE id = #{id}
</select>
<insert id="insertRepairStaffType" parameterType="RepairStaffType" keyProperty="id" useGeneratedKeys="true">>
INSERT INTO ics_repair_staff_type
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null ">id,</if>
<if test="staffId != null ">staff_id,</if>
<if test="typeId != null ">type_id,</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
<if test="createTime != null ">create_time,</if>
<if test="updateBy != null and updateBy != ''">update_by,</if>
<if test="updateTime != null ">update_time,</if>
<if test="tenantId != null ">tenant_id,</if>
<if test="parkId != null ">park_id,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null ">#{id},</if>
<if test="staffId != null ">#{staffId},</if>
<if test="typeId != null ">#{typeId},</if>
<if test="deleteFlag != null and deleteFlag != ''">#{deleteFlag},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
<if test="createTime != null ">#{createTime},</if>
<if test="updateBy != null and updateBy != ''">#{updateBy},</if>
<if test="updateTime != null ">#{updateTime},</if>
<if test="tenantId != null ">#{tenantId},</if>
<if test="parkId != null ">#{parkId},</if>
</trim>
</insert>
<update id="updateRepairStaffType" parameterType="RepairStaffType">
UPDATE ics_repair_staff_type
<trim prefix="SET" suffixOverrides=",">
<if test="staffId != null ">staff_id = #{staffId},</if>
<if test="typeId != null ">type_id = #{typeId},</if>
<if test="deleteFlag != null and deleteFlag != ''">delete_flag = #{deleteFlag},</if>
<if test="createBy != null and createBy != ''">create_by = #{createBy},</if>
<if test="createTime != null ">create_time = #{createTime},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
<if test="updateTime != null ">update_time = #{updateTime},</if>
<if test="tenantId != null ">tenant_id = #{tenantId},</if>
<if test="parkId != null ">park_id = #{parkId},</if>
</trim>
WHERE id = #{id}
</update>
<delete id="deleteRepairStaffTypeById" parameterType="Long">
DELETE FROM ics_repair_staff_type WHERE id = #{id}
</delete>
<delete id="deleteRepairStaffTypeByIds" parameterType="String">
DELETE FROM ics_repair_staff_type where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>

616
shoot-hand/ics-web/src/main/java/com/ics/controller/mobile/member/RepairAPIController.java
View File

@ -1,37 +1,17 @@
package com.ics.controller.mobile.member;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.google.common.collect.Maps;
import com.ics.admin.domain.*;
import com.ics.admin.domain.meeting.StaffCustomer;
import com.ics.admin.service.*;
import com.ics.admin.vo.ParkVO;
import com.ics.admin.vo.RepairVO;
import com.ics.common.annotation.LoginUser;
import com.ics.common.core.controller.BaseController;
import com.ics.common.core.domain.IcsCustomerStaff;
import com.ics.common.core.domain.R;
import com.ics.common.core.page.PageDomain;
import com.ics.common.core.page.TableSupport;
import com.ics.common.utils.DateUtils;
import com.ics.common.utils.StringUtils;
import com.ics.common.utils.ValidatorUtils;
import com.ics.common.utils.bean.BeanUtils;
import com.ics.service.IRepairLogService;
import com.ics.service.IRepairService;
import com.ics.system.domain.User;
import com.ics.system.domain.vo.UserVO;
import org.apache.commons.compress.utils.Lists;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.wf.jwtp.annotation.Ignore;
import org.wf.jwtp.annotation.RequiresPermissions;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
@ -53,22 +33,19 @@ public class RepairAPIController extends BaseController {
private IRepairDeviceService repairDeviceService;
@Autowired
private IRepairRecordService repairRecordService;
private IRepairRelationalService staffTypeService;
@Autowired
private IRepairStaffTypeService staffTypeService;
private IRepairDeviceTypeService repairTypeService;
@Autowired
private IRepairTypeService repairTypeService;
@Autowired
private IRepairWorkerTypeService workerTypeService;
private IRepairAttachService workerTypeService;
@Autowired
private IRepairAddressService repairAddressService;
@Autowired
private IRepairRoomService repairRoomService;
private IRepairAddressFloorService repairRoomService;
@Autowired
private IIcsCustomerStaffService customerStaffService;
@ -85,55 +62,55 @@ public class RepairAPIController extends BaseController {
* 查询工单管理
*/
// @RequiresPermissions("member:center:view")
@Ignore
@GetMapping("get/{id}")
public R get(@PathVariable("id") Long id) {
Repair repair = repairService.selectRepairById(id);
if (repair != null) {
repair.setStatusValue(repair.getStatus().getValue());
//设备名称
RepairDevice repairDevice = repairDeviceService.selectRepairDeviceById(Long.valueOf(repair.getRepairDevice()));
if (repairDevice != null) {
repair.setRepairDeviceName(repairDevice.getName());
}
//维修人
Long workerId = repair.getWorkerId();
IcsCustomerStaff icsCustomerStaff = icsCustomerStaffService.selectIcsCustomerStaffById(workerId);
if (icsCustomerStaff != null) {
repair.setWorkerName(icsCustomerStaff.getName());
}
}
return R.data(repair);
}
// @Ignore
// @GetMapping("get/{id}")
// public R get(@PathVariable("id") Long id) {
// Repair repair = repairService.selectRepairById(id);
// if (repair != null) {
// repair.setStatusValue(repair.getStatus().getValue());
//
// //设备名称
// RepairDevice repairDevice = repairDeviceService.selectRepairDeviceById(Long.valueOf(repair.getRepairDevice()));
// if (repairDevice != null) {
// repair.setRepairDeviceName(repairDevice.getName());
// }
// //维修人
// Long workerId = repair.getWorkerId();
// IcsCustomerStaff icsCustomerStaff = icsCustomerStaffService.selectIcsCustomerStaffById(workerId);
// if (icsCustomerStaff != null) {
// repair.setWorkerName(icsCustomerStaff.getName());
// }
// }
// return R.data(repair);
// }
/**
* 查询工单管理列表
*/
@RequiresPermissions("member:center:view")
@GetMapping("list")
public R list(Repair.Status status, Long parkId) {
long currentUserId = getCurrentUserId();
IcsCustomerStaff staff = icsCustomerStaffService.selectIcsCustomerStaffById(currentUserId);
Repair repair = new Repair();
repair.setStatus(status);
repair.setCreateBy(staff.getUsername());
repair.setParkId(1L);
startPage();
List<Repair> repairList = repairService.selectMyRepairList(repair);
List<Map<String, Object>> repairVOList = Lists.newArrayList();
repairList.stream().forEach(item ->{
Map<String, Object> map = Maps.newHashMap();
map.put("id", item.getId());
map.put("sn", item.getSn());
map.put("repairTime", item.getRepairTime());
map.put("area", item.getArea());
map.put("content", item.getContent());
map.put("status",item.getStatus());
repairVOList.add(map);
});
return result(repairVOList);
}
// @RequiresPermissions("member:center:view")
// @GetMapping("list")
// public R list(Repair.Status status, Long parkId) {
// long currentUserId = getCurrentUserId();
// IcsCustomerStaff staff = icsCustomerStaffService.selectIcsCustomerStaffById(currentUserId);
// Repair repair = new Repair();
// repair.setStatus(status);
// repair.setCreateBy(staff.getUsername());
// repair.setParkId(1L);
// startPage();
// List<Repair> repairList = repairService.selectMyRepairList(repair);
// List<Map<String, Object>> repairVOList = Lists.newArrayList();
// repairList.stream().forEach(item ->{
// Map<String, Object> map = Maps.newHashMap();
// map.put("id", item.getId());
// map.put("sn", item.getSn());
// map.put("repairTime", item.getRepairTime());
// map.put("area", item.getArea());
// map.put("content", item.getContent());
// map.put("status",item.getStatus());
// repairVOList.add(map);
// });
// return result(repairVOList);
// }
/**
@ -158,26 +135,26 @@ public class RepairAPIController extends BaseController {
* 新增保存工单管理
*/
// @RequiresPermissions("member:center:view")
@Ignore
@PostMapping("save")
public R addSave(@RequestBody Repair repair) {
//获取用户id
ValidatorUtils.validateEntity(repair);
repair.setStatus(Repair.Status.PENDING_ASSIGN);
return toAjax(repairService.insertRepair(repair));
}
// @Ignore
// @PostMapping("save")
// public R addSave(@RequestBody Repair repair) {
//
// //获取用户id
// ValidatorUtils.validateEntity(repair);
// repair.setStatus(Repair.Status.PENDING_ASSIGN);
// return toAjax(repairService.insertRepair(repair));
// }
/**
* 获取设备分类列表
* @param repairType
* @param
* @return
*/
@Ignore
@GetMapping("deviceTypeList")
public R deviceTypeList(RepairType repairType) {
return result(repairTypeService.selectRepairTypeList(repairType));
}
// @Ignore
// @GetMapping("deviceTypeList")
// public R deviceTypeList(RepairDeviceType repairType) {
// return result(repairTypeService.selectRepairTypeList(repairType));
// }
@Ignore
@GetMapping("deviceList")
@ -193,8 +170,9 @@ public class RepairAPIController extends BaseController {
@Ignore
@GetMapping("selectRoomList")
public R selectRoomList(RepairRoom repairRoom) {
return result(repairRoomService.selectRepairRoomList(repairRoom));
public R selectRoomList(RepairAddressFloor repairRoom) {
//return result(repairRoomService.selectRepairRoomList(repairRoom));
return null;
}
@ -204,255 +182,255 @@ public class RepairAPIController extends BaseController {
* 用户评价工单
*/
// @RequiresPermissions("member:center:view")
@Ignore
@PostMapping("review")
public R review(@RequestBody RepairRecord repairRecord) {
Repair pRepair = repairService.selectRepairById(repairRecord.getId());
if (repairRecord == null || !Repair.Status.COMPLETED.equals(pRepair.getStatus())) {
return R.error("报修为空或状态已完成");
}
pRepair.setStatus(Repair.Status.SCORE);
//修改工单状态
int i = repairService.updateRepair(pRepair);
//新增评价
repairRecord.setCreateTime(DateUtils.getNowDate());
repairRecord.setDeleteFlag(0);
int count = repairRecordService.insertRepairRecord(repairRecord);
return toAjax(i);
}
// @Ignore
// @PostMapping("review")
// public R review(@RequestBody RepairEval repairRecord) {
// Repair pRepair = repairService.selectRepairById(repairRecord.getId());
// if (repairRecord == null || !Repair.Status.COMPLETED.equals(pRepair.getStatus())) {
// return R.error("报修为空或状态已完成");
// }
// pRepair.setStatus(Repair.Status.SCORE);
// //修改工单状态
// int i = repairService.updateRepair(pRepair);
// //新增评价
// repairRecord.setCreateTime(DateUtils.getNowDate());
// repairRecord.setDeleteFlag(0);
// int count = repairRecordService.insertRepairRecord(repairRecord);
//
// return toAjax(i);
// }
/**
* 用户取消工单
*/
@RequiresPermissions("member:center:view")
@GetMapping("cancel")
public R cancel(Long repairId) {
Repair repair = repairService.selectRepairById(repairId);
if (repair == null || !Repair.Status.PENDING_PROCESS.equals(repair.getStatus())) {
return R.error("报修为空或状态不是待处理");
}
repair.setStatus(Repair.Status.CANCELED);
repair.setUpdateBy(getLoginName());
return toAjax(repairService.updateRepair(repair));
}
// @RequiresPermissions("member:center:view")
// @GetMapping("cancel")
// public R cancel(Long repairId) {
// Repair repair = repairService.selectRepairById(repairId);
// if (repair == null || !Repair.Status.PENDING_PROCESS.equals(repair.getStatus())) {
// return R.error("报修为空或状态不是待处理");
// }
// repair.setStatus(Repair.Status.CANCELED);
// repair.setUpdateBy(getLoginName());
// return toAjax(repairService.updateRepair(repair));
// }
/**
* 根据用户id或者保修记录
*/
@Ignore
@GetMapping("/listByUserId")
public R listByUserId(Long userId,Integer status) {
List<Repair> repair = repairService.selectByUserId(userId,status);
for (Repair repair1 : repair) {
RepairDevice repairDevice = repairDeviceService.selectRepairDeviceById(Long.valueOf(repair1.getRepairDevice()));
if (repairDevice != null) {
repair1.setRepairDeviceName(repairDevice.getName());
}
}
return R.data(repair);
}
// @Ignore
// @GetMapping("/listByUserId")
// public R listByUserId(Long userId,Integer status) {
// List<Repair> repair = repairService.selectByUserId(userId,status);
// for (Repair repair1 : repair) {
// RepairDevice repairDevice = repairDeviceService.selectRepairDeviceById(Long.valueOf(repair1.getRepairDevice()));
// if (repairDevice != null) {
// repair1.setRepairDeviceName(repairDevice.getName());
// }
// }
// return R.data(repair);
// }
/*-------------------------以下为派单员接口------------------------*/
/**
* 派单中心列表
*/
@Ignore
@PostMapping("/dispatcherList")
public R dispatcherList(@RequestBody Repair repair) {
Integer userId = repair.getUserId();
Integer statusValue = repair.getStatusValue();
//根据用户id查询绑定的设备分类
Long type = staffTypeService.selectRepairTypeByUserId(userId);
//根据设备分类和状态查询对应的数据
PageDomain pageDomain = TableSupport.buildPageRequest();
Integer pageNum = pageDomain.getPageNum();
Integer pageSize = pageDomain.getPageSize();
IPage<Repair> repairList = repairService.selectRepairListByType(type,statusValue,pageNum,pageSize);
for (Repair repair1 : repairList.getRecords()) {
repair1.setStatusValue(repair1.getStatus().getValue());
repair1.setStatusName(repair1.getStatus().getName());
//设备类型
if (repair1.getTypeId() != null) {
RepairType repairType = repairTypeService.selectRepairTypeById(Long.valueOf(repair1.getTypeId()));
repair1.setTypeName(repairType.getName());
}
//设备名称
if (repair1.getRepairDevice() != null){
RepairDevice repairDevice = deviceService.selectRepairDeviceById(Long.valueOf(repair1.getRepairDevice()));
repair1.setRepairDeviceName(repairDevice.getName());
}
//地点
if (repair1.getAddressId() !=null){
RepairAddress repairAddress = repairAddressService.selectRepairAddressById(repair1.getAddressId());
repair1.setAddressName(repairAddress.getName());
}
//楼层
if (repair1.getRoomId() !=null){
RepairRoom repairRoom = repairRoomService.selectRepairRoomById(repair1.getRoomId());
repair1.setRoomName(repairRoom.getName());
}
//故障
if (repair1.getFailureTypeId() != null){
RepairFailureType repairFailureType = repairFailureTypeService.selectRepairFailureTypeById(repair1.getFailureTypeId());
repair1.setFailureTypeName(repairFailureType.getName());
}
if (repair1.getUserId() != null){
IcsCustomerStaff staff = customerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair1.getUserId()));
repair1.setUserName(staff.getUsername());
}
if (repair1.getWorkerId() != null){
IcsCustomerStaff worker = customerStaffService.selectIcsCustomerStaffById(repair1.getWorkerId());
repair1.setWorkerName(worker.getUsername());
}
}
return R.ok().put("data",repairList);
}
// @Ignore
// @PostMapping("/dispatcherList")
// public R dispatcherList(@RequestBody Repair repair) {
// Integer userId = repair.getUserId();
// Integer statusValue = repair.getStatusValue();
//
// //根据用户id查询绑定的设备分类
// Long type = staffTypeService.selectRepairTypeByUserId(userId);
// //根据设备分类和状态查询对应的数据
// PageDomain pageDomain = TableSupport.buildPageRequest();
//
// Integer pageNum = pageDomain.getPageNum();
// Integer pageSize = pageDomain.getPageSize();
// IPage<Repair> repairList = repairService.selectRepairListByType(type,statusValue,pageNum,pageSize);
// for (Repair repair1 : repairList.getRecords()) {
// repair1.setStatusValue(repair1.getStatus().getValue());
// repair1.setStatusName(repair1.getStatus().getName());
// //设备类型
// if (repair1.getTypeId() != null) {
// RepairDeviceType repairType = repairTypeService.selectRepairTypeById(Long.valueOf(repair1.getTypeId()));
// repair1.setTypeName(repairType.getName());
// }
// //设备名称
// if (repair1.getRepairDevice() != null){
// RepairDevice repairDevice = deviceService.selectRepairDeviceById(Long.valueOf(repair1.getRepairDevice()));
// repair1.setRepairDeviceName(repairDevice.getName());
// }
// //地点
// if (repair1.getAddressId() !=null){
// RepairAddress repairAddress = repairAddressService.selectRepairAddressById(repair1.getAddressId());
// repair1.setAddressName(repairAddress.getName());
// }
// //楼层
// if (repair1.getRoomId() !=null){
// RepairAddressFloor repairRoom = repairRoomService.selectRepairRoomById(repair1.getRoomId());
// repair1.setRoomName(repairRoom.getName());
// }
// //故障
// if (repair1.getFailureTypeId() != null){
//
// RepairFailureType repairFailureType = repairFailureTypeService.selectRepairFailureTypeById(repair1.getFailureTypeId());
// repair1.setFailureTypeName(repairFailureType.getName());
// }
// if (repair1.getUserId() != null){
// IcsCustomerStaff staff = customerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair1.getUserId()));
// repair1.setUserName(staff.getUsername());
// }
//
// if (repair1.getWorkerId() != null){
// IcsCustomerStaff worker = customerStaffService.selectIcsCustomerStaffById(repair1.getWorkerId());
// repair1.setWorkerName(worker.getUsername());
// }
// }
//
// return R.ok().put("data",repairList);
// }
//无效申请 取消派单
@Ignore
@PostMapping("dispatcherCancel")
public R dispatcherCancel(Long repairId) {
Repair repair = repairService.selectRepairById(repairId);
if (repair == null || !Repair.Status.PENDING_ASSIGN.equals(repair.getStatus())) {
return R.error("报修为空或状态不是待分配");
}
repair.setStatus(Repair.Status.CANCELED);
return toAjax(repairService.updateRepair(repair));
}
//提交反馈
@Ignore
@PostMapping("dispatcherSubmitFeedback")
public R dispatcherSubmitFeedback(Long repairId) {
Repair repair = repairService.selectRepairById(repairId);
if (repair == null || !Repair.Status.PENDING_ASSIGN.equals(repair.getStatus())) {
return R.error("报修为空或状态不是待分配");
}
repair.setStatus(Repair.Status.SUBMIT_FEEDBACK);
return toAjax(repairService.updateRepair(repair));
}
//选择维修人员
@Ignore
@GetMapping("selectDispatcherChooseWorker")
public R dispatcherChooseWorker(@RequestBody Map<String,Object> map) {
Integer userId = (Integer) map.get("userId");
//根据用户id查询绑定的设备分类
Long type = staffTypeService.selectRepairTypeByUserId(userId);
//根据设备分类查询对应的维修人员列表
List<IcsCustomerStaff> customerStaffs = workerTypeService.selectRepairWorkerTypeListByTypeId(type);
return R.data(customerStaffs);
}
//提交派单人员
@Ignore
@GetMapping("dispatcherPendingProcess")
public R dispatcherPendingProcess(@RequestBody Repair repair) {
Repair repair1 = repairService.selectRepairById(repair.getId());
if (repair1 == null || !Repair.Status.PENDING_ASSIGN.equals(repair.getStatus())) {
return R.error("报修为空或状态不是待分配");
}
repair1.setStatus(Repair.Status.PENDING_PROCESS);
repair1.setWorkerId(repair.getWorkerId());
repair1.setBeginDate(DateUtils.getNowDate());
return toAjax(repairService.updateRepair(repair1));
}
/*-------------------------以下为维修人员接口------------------------*/
/**
* 维修人员工单管理
* @param userId
* @param status
* @return
*/
@Ignore
@GetMapping("/listByWorkerId")
public R listByWorkerId(Long userId,Integer status) {
//待完成 状态为 1
Integer beCompleted = repairService.listByWorkerIdByCount(userId,1);
//进行中 状态为4
Integer ongoing = repairService.listByWorkerIdByCount(userId,4);
//已完成
Integer done2 = repairService.listByWorkerIdByCount(userId,5);
Integer done1 = repairService.listByWorkerIdByCount(userId,6);
Map<String,Object> map = new HashMap<>();
map.put("beCompleted",beCompleted);
map.put("ongoing",ongoing);
map.put("done",done1+done2);
// 待完成 1 进行中 2 已完成 3
List<Repair> repair = repairService.listByWorkerId(userId,status);
for (Repair repair1 : repair) {
RepairDevice repairDevice = repairDeviceService.selectRepairDeviceById(Long.valueOf(repair1.getRepairDevice()));
if (repairDevice != null) {
repair1.setRepairDeviceName(repairDevice.getName());
}
}
map.put("repair",repair);
return R.data(map);
}
/**
* 维修人员工单详情
*/
@Ignore
@GetMapping("/detailByWorkerId")
public R detailByWorkerId(Long repairId) {
Repair repair = repairService.selectRepairById(repairId);
if (repair == null) {
return R.error("报修为空");
}
Integer repairDevice = repair.getRepairDevice();
if (repairDevice != null) {
RepairDevice repairDevice1 = repairDeviceService.selectRepairDeviceById(Long.valueOf(repairDevice));
repair.setRepairDeviceName(repairDevice1.getName());
}
//派单员id 查找对应名称
IcsCustomerStaff icsCustomerStaff = icsCustomerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair.getDispatcherId()));
if (icsCustomerStaff != null) {
repair.setDispatcherName(icsCustomerStaff.getName());
}
//报修人id 查找对应名称
IcsCustomerStaff staff = icsCustomerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair.getUserId()));
if (staff != null) {
repair.setUserName(icsCustomerStaff.getName());
}
return R.data(repair);
}
/**
* 维修人员确认接单
*/
@Ignore
@PostMapping("/confirmOrder")
public R confirmOrder(Long repairId) {
Repair repair = repairService.selectRepairById(repairId);
repair.setStatus(Repair.Status.PROCESSING);
repair.setBeginDate(DateUtils.getNowDate());
repairService.updateRepair(repair);
return R.ok();
}
// @Ignore
// @PostMapping("dispatcherCancel")
// public R dispatcherCancel(Long repairId) {
// Repair repair = repairService.selectRepairById(repairId);
// if (repair == null || !Repair.Status.PENDING_ASSIGN.equals(repair.getStatus())) {
// return R.error("报修为空或状态不是待分配");
// }
// repair.setStatus(Repair.Status.CANCELED);
// return toAjax(repairService.updateRepair(repair));
// }
//
// //提交反馈
// @Ignore
// @PostMapping("dispatcherSubmitFeedback")
// public R dispatcherSubmitFeedback(Long repairId) {
// Repair repair = repairService.selectRepairById(repairId);
// if (repair == null || !Repair.Status.PENDING_ASSIGN.equals(repair.getStatus())) {
// return R.error("报修为空或状态不是待分配");
// }
// repair.setStatus(Repair.Status.SUBMIT_FEEDBACK);
// return toAjax(repairService.updateRepair(repair));
// }
//
// //选择维修人员
// @Ignore
// @GetMapping("selectDispatcherChooseWorker")
// public R dispatcherChooseWorker(@RequestBody Map<String,Object> map) {
// Integer userId = (Integer) map.get("userId");
//
// //根据用户id查询绑定的设备分类
// Long type = staffTypeService.selectRepairTypeByUserId(userId);
// //根据设备分类查询对应的维修人员列表
// List<IcsCustomerStaff> customerStaffs = workerTypeService.selectRepairWorkerTypeListByTypeId(type);
//
// return R.data(customerStaffs);
// }
//
//
// //提交派单人员
// @Ignore
// @GetMapping("dispatcherPendingProcess")
// public R dispatcherPendingProcess(@RequestBody Repair repair) {
// Repair repair1 = repairService.selectRepairById(repair.getId());
// if (repair1 == null || !Repair.Status.PENDING_ASSIGN.equals(repair.getStatus())) {
// return R.error("报修为空或状态不是待分配");
// }
// repair1.setStatus(Repair.Status.PENDING_PROCESS);
// repair1.setWorkerId(repair.getWorkerId());
// repair1.setBeginDate(DateUtils.getNowDate());
// return toAjax(repairService.updateRepair(repair1));
// }
//
// /*-------------------------以下为维修人员接口------------------------*/
//
// /**
// * 维修人员工单管理
// * @param userId
// * @param status
// * @return
// */
// @Ignore
// @GetMapping("/listByWorkerId")
// public R listByWorkerId(Long userId,Integer status) {
//
//
// //待完成 状态为 1
// Integer beCompleted = repairService.listByWorkerIdByCount(userId,1);
//
// //进行中 状态为4
// Integer ongoing = repairService.listByWorkerIdByCount(userId,4);
//
// //已完成
// Integer done2 = repairService.listByWorkerIdByCount(userId,5);
// Integer done1 = repairService.listByWorkerIdByCount(userId,6);
//
// Map<String,Object> map = new HashMap<>();
// map.put("beCompleted",beCompleted);
// map.put("ongoing",ongoing);
// map.put("done",done1+done2);
//
//
// // 待完成 1 进行中 2 已完成 3
// List<Repair> repair = repairService.listByWorkerId(userId,status);
// for (Repair repair1 : repair) {
// RepairDevice repairDevice = repairDeviceService.selectRepairDeviceById(Long.valueOf(repair1.getRepairDevice()));
// if (repairDevice != null) {
// repair1.setRepairDeviceName(repairDevice.getName());
// }
// }
// map.put("repair",repair);
// return R.data(map);
// }
//
// /**
// * 维修人员工单详情
// */
//
// @Ignore
// @GetMapping("/detailByWorkerId")
// public R detailByWorkerId(Long repairId) {
// Repair repair = repairService.selectRepairById(repairId);
// if (repair == null) {
// return R.error("报修为空");
// }
// Integer repairDevice = repair.getRepairDevice();
// if (repairDevice != null) {
// RepairDevice repairDevice1 = repairDeviceService.selectRepairDeviceById(Long.valueOf(repairDevice));
// repair.setRepairDeviceName(repairDevice1.getName());
// }
// //派单员id 查找对应名称
// IcsCustomerStaff icsCustomerStaff = icsCustomerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair.getDispatcherId()));
// if (icsCustomerStaff != null) {
// repair.setDispatcherName(icsCustomerStaff.getName());
// }
// //报修人id 查找对应名称
// IcsCustomerStaff staff = icsCustomerStaffService.selectIcsCustomerStaffById(Long.valueOf(repair.getUserId()));
// if (staff != null) {
// repair.setUserName(icsCustomerStaff.getName());
// }
// return R.data(repair);
// }
//
// /**
// * 维修人员确认接单
// */
// @Ignore
// @PostMapping("/confirmOrder")
// public R confirmOrder(Long repairId) {
// Repair repair = repairService.selectRepairById(repairId);
// repair.setStatus(Repair.Status.PROCESSING);
// repair.setBeginDate(DateUtils.getNowDate());
// repairService.updateRepair(repair);
// return R.ok();
// }

116
shoot-hand/ics-web/src/main/java/com/ics/service/impl/RepairServiceImpl.java
View File

@ -61,23 +61,24 @@ public class RepairServiceImpl extends ServiceImpl<RepairMapper, Repair> impleme
@Override
@Transactional(rollbackFor = Exception.class)
public int insertRepair(Repair repair) {
repair.setSn(snService.generate(Sn.Type.REPAIR));
repair.setCreateTime(DateUtils.getNowDate());
repair.setRepairTime(DateUtils.getNowDate());
int result = repairMapper.insert(repair);
// 增加报修日志
RepairLog repairLog = new RepairLog();
repairLog.setType(repair.getStatus());
repairLog.setDetail(String.format("工单号：%s,已收到报修", repair.getSn()));
repairLog.setRepairId(repair.getId());
repairLog.setCreateBy(repair.getCreateBy());
repairLog.setCreateTime(DateUtils.getNowDate());
repairLog.setUpdateBy(repair.getCreateBy());
repairLog.setUpdateTime(DateUtils.getNowDate());
repairLog.setParkId(repair.getParkId());
repairLog.setTenantId(repair.getTenantId());
repairLogService.insertRepairLog(repairLog);
return result;
// repair.setSn(snService.generate(Sn.Type.REPAIR));
// repair.setCreateTime(DateUtils.getNowDate());
// repair.setRepairTime(DateUtils.getNowDate());
// int result = repairMapper.insert(repair);
// // 增加报修日志
// RepairLog repairLog = new RepairLog();
// repairLog.setType(repair.getStatus());
// repairLog.setDetail(String.format("工单号：%s,已收到报修", repair.getSn()));
// repairLog.setRepairId(repair.getId());
// repairLog.setCreateBy(repair.getCreateBy());
// repairLog.setCreateTime(DateUtils.getNowDate());
// repairLog.setUpdateBy(repair.getCreateBy());
// repairLog.setUpdateTime(DateUtils.getNowDate());
// repairLog.setParkId(repair.getParkId());
// repairLog.setTenantId(repair.getTenantId());
// repairLogService.insertRepairLog(repairLog);
// return result;
return 0;
}
/**
@ -89,16 +90,17 @@ public class RepairServiceImpl extends ServiceImpl<RepairMapper, Repair> impleme
@Override
public int updateRepair(Repair repair) {
// 增加报修日志
RepairLog repairLog = new RepairLog();
repairLog.setType(repair.getStatus());
repairLog.setDetail(repair.getStatus().getName());
repairLog.setRepairId(repair.getId());
repairLog.setCreateBy(repair.getUpdateBy());
repairLog.setCreateTime(DateUtils.getNowDate());
repairLog.setUpdateBy(repair.getUpdateBy());
repairLog.setUpdateTime(DateUtils.getNowDate());
repairLogService.insertRepairLog(repairLog);
return repairMapper.updateById(repair);
// RepairLog repairLog = new RepairLog();
// repairLog.setType(repair.getStatus());
// repairLog.setDetail(repair.getStatus().getName());
// repairLog.setRepairId(repair.getId());
// repairLog.setCreateBy(repair.getUpdateBy());
// repairLog.setCreateTime(DateUtils.getNowDate());
// repairLog.setUpdateBy(repair.getUpdateBy());
// repairLog.setUpdateTime(DateUtils.getNowDate());
// repairLogService.insertRepairLog(repairLog);
// return repairMapper.updateById(repair);
return 0;
}
@ -111,19 +113,22 @@ public class RepairServiceImpl extends ServiceImpl<RepairMapper, Repair> impleme
*/
@Override
public List<Repair> selectMyRepairList(Repair repair) {
return repairMapper.selectMyRepairList(repair);
//return repairMapper.selectMyRepairList(repair);
return null;
}
@Override
public List<Repair> selectByUserId(Long userId,Integer status) {
LambdaQueryWrapper<Repair> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Repair::getUserId, userId);
wrapper.orderByAsc(Repair::getRepairTime);
if (status != null && status != 0) {
wrapper.eq(Repair::getStatus, status);
}
// LambdaQueryWrapper<Repair> wrapper = new LambdaQueryWrapper<>();
// wrapper.eq(Repair::getUserId, userId);
// wrapper.orderByAsc(Repair::getRepairTime);
// if (status != null && status != 0) {
// wrapper.eq(Repair::getStatus, status);
// }
//
// return repairMapper.selectList(wrapper);
return repairMapper.selectList(wrapper);
return null;
}
@Override
@ -146,31 +151,34 @@ public class RepairServiceImpl extends ServiceImpl<RepairMapper, Repair> impleme
@Override
public List<Repair> listByWorkerId(Long userId, Integer status) {
LambdaQueryWrapper<Repair> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Repair::getWorkerId, userId);
wrapper.orderByAsc(Repair::getRepairTime);
if ( status == 1) {
wrapper.eq(Repair::getStatus, 1);
}else if (status == 1){
wrapper.eq(Repair::getStatus, 4);
}else if (status == 2){
wrapper.eq(Repair::getStatus,5 ).or().eq(Repair::getStatus, 6);
}
return repairMapper.selectList(wrapper);
// LambdaQueryWrapper<Repair> wrapper = new LambdaQueryWrapper<>();
// wrapper.eq(Repair::getWorkerId, userId);
// wrapper.orderByAsc(Repair::getRepairTime);
// if ( status == 1) {
// wrapper.eq(Repair::getStatus, 1);
// }else if (status == 1){
// wrapper.eq(Repair::getStatus, 4);
// }else if (status == 2){
// wrapper.eq(Repair::getStatus,5 ).or().eq(Repair::getStatus, 6);
// }
//
// return repairMapper.selectList(wrapper);
return null;
}
@Override
public Integer listByWorkerIdByCount(Long userId, Integer status) {
LambdaQueryWrapper<Repair> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Repair::getWorkerId, userId);
wrapper.orderByAsc(Repair::getRepairTime);
if (status != null && status != 0) {
wrapper.eq(Repair::getStatus, status);
}
// LambdaQueryWrapper<Repair> wrapper = new LambdaQueryWrapper<>();
// wrapper.eq(Repair::getWorkerId, userId);
// wrapper.orderByAsc(Repair::getRepairTime);
// if (status != null && status != 0) {
// wrapper.eq(Repair::getStatus, status);
// }
//
// return repairMapper.selectCount(wrapper);
return repairMapper.selectCount(wrapper);
return 0;
}

4
shoot-hand/ics-web/src/main/resources/application-dev.yml
View File

@ -20,7 +20,7 @@ spring:
# url: jdbc:mysql://192.168.0.50:3306/dbd-meeting?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
# username: root
# password: boyuekeji2023
url: jdbc:mysql://222.184.49.22:3306/dbd-meeting?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
url: jdbc:mysql://222.184.49.22:3306/shoot-hand?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
username: root
password: boyue1!Z
# 从库数据源
@ -137,7 +137,7 @@ mybatis-plus:
weixin:
appid: wx5582a07c1fbbcf06 # appid
mch-serial-no: 5899B7D34B161F9E24EFFCD50E95245521CA40AB # 证书序列号
private-key-path: F:/cert/dbd/apiclient_key.pem # 证书路径
private-key-path: E:/apiclient_key.pem # 证书路径
mch-id: 1665472343 # 商户号
key: CHANGYANGKONGGUhenanjianandianzi # APIv3密钥
domain: https://api.mch.weixin.qq.com # 微信服务器地址

2
shoot-hand/ics-web/src/main/resources/application.yml
View File

@ -27,7 +27,7 @@ spring:
main:
allow-bean-definition-overriding: true
profiles:
active: prod
active: dev
jackson:
date-format: yyyy-MM-dd HH:mm:ss
time-zone: GMT+8

2
shoot-hand/pom.xml
View File

@ -16,7 +16,7 @@
<ics.version>1.0.0-SNAPSHOT</ics.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>11</java.version>
<java.version>8</java.version>
<spring-boot.version>2.4.0</spring-boot.version>
<druid.version>1.2.3</druid.version>
<bitwalker.version>1.19</bitwalker.version>