package cn.flightfeather.supervision.lightshare.service.impl
|
|
import cn.flightfeather.supervision.common.exception.BizException
|
import cn.flightfeather.supervision.common.log.BizLog
|
import cn.flightfeather.supervision.common.log.WorkStreamLogInfo
|
import cn.flightfeather.supervision.common.utils.Constant
|
import cn.flightfeather.supervision.common.utils.FileUtil
|
import cn.flightfeather.supervision.common.utils.UUIDGenerator
|
import cn.flightfeather.supervision.domain.ds1.entity.*
|
import cn.flightfeather.supervision.domain.ds1.mapper.*
|
import cn.flightfeather.supervision.domain.ds1.repository.ProblemRep
|
import cn.flightfeather.supervision.domain.ds1.repository.SubTaskRep
|
import cn.flightfeather.supervision.domain.ds1.repository.TaskRep
|
import cn.flightfeather.supervision.lightshare.service.MediafileService
|
import cn.flightfeather.supervision.lightshare.service.ProblemlistService
|
import cn.flightfeather.supervision.lightshare.service.TaskService
|
import cn.flightfeather.supervision.lightshare.vo.*
|
import com.fasterxml.jackson.core.type.TypeReference
|
import com.fasterxml.jackson.databind.ObjectMapper
|
import com.github.pagehelper.PageHelper
|
import org.springframework.beans.BeanUtils
|
import org.springframework.beans.factory.annotation.Value
|
import org.springframework.stereotype.Service
|
import org.springframework.web.multipart.MultipartFile
|
import tk.mybatis.mapper.entity.Example
|
import tk.mybatis.mapper.util.StringUtil
|
import java.text.SimpleDateFormat
|
import javax.annotation.Resource
|
import java.math.BigDecimal
|
import java.time.LocalDate
|
import java.time.LocalDateTime
|
import java.time.ZoneId
|
import java.time.format.DateTimeFormatter
|
import java.util.*
|
|
|
@Service
|
class ProblemlistServiceImpl(
|
val problemlistMapper: ProblemlistMapper,
|
val inspectionMapper: InspectionMapper,
|
val mediafileMapper: MediafileMapper,
|
private val taskRep: TaskRep,
|
private val subTaskRep: SubTaskRep,
|
private val problemRep: ProblemRep,
|
private val bizLog: BizLog,
|
@Value("\${filePath}") var filePath: String,
|
@Value("\${imgPath}") var imgPath: String,
|
) : ProblemlistService {
|
|
@Resource
|
lateinit var scenseMapper: ScenseMapper
|
|
@Resource
|
lateinit var problemtypeMapper: ProblemtypeMapper
|
|
@Resource
|
lateinit var taskMapper: TaskMapper
|
|
@Resource
|
lateinit var taskService: TaskService
|
|
@Resource
|
lateinit var mediafileService: MediafileService
|
|
override fun getByTopTask(tguid: String): List<ProblemListVo> {
|
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
|
}
|
|
//根据场景id和时间获取对应顶层任务下的所有问题
|
override fun getProblemByScene(sceneId: String, date: String): List<ProblemListVo> {
|
val simpleDateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
|
val date1 = simpleDateFormat.parse(date)
|
val scene = scenseMapper.selectByPrimaryKey(sceneId)
|
val district = scene.districtcode
|
val taskVolist = taskService.getByDistrictCode(district!!, date1)
|
val problemListVolistTemp1 = mutableListOf<ProblemListVo>()
|
if (!taskVolist.isEmpty()) {
|
val problemlists = (problemlistMapper.getProblemByScene(sceneId, taskVolist[0].tguid!!))
|
problemlists.forEach {
|
// 限制企业查看未审核的问题
|
if (it.extension3 != Constant.PROBLEM_UNCHECKED && it.extension3 != Constant.PROBLEM_CHECK_FAIL) {
|
val problemVo = ProblemListVo();
|
BeanUtils.copyProperties(it, problemVo)
|
problemListVolistTemp1.add(problemVo)
|
}
|
}
|
problemListVolistTemp1.forEach {
|
if (it.ptguid != null) {
|
val tmp1 = problemtypeMapper.selectByPrimaryKey(it.ptguid)
|
if (tmp1 != null) {
|
it.typeid = tmp1.typeid
|
it.typename = tmp1.typename
|
}
|
}
|
val mediafileVo = mediafileService.findByBusinessGUID(it.guid!!)
|
//判断是否有媒体资料
|
if (!mediafileVo.isEmpty()) {
|
//赋值
|
it.mediafileList = mediafileVo
|
} else {
|
it.mediafileList = mutableListOf()
|
}
|
}
|
}
|
return problemListVolistTemp1
|
}
|
|
//获取某顶层任务下，某个场景下的问题整改情况
|
override fun getStatisticalResultById(topTaskId: String, sceneTypeId: String): List<StatisticsVo> {
|
val map = problemlistMapper.getStatisticalResultById(topTaskId, sceneTypeId)
|
val statisticsVos = mutableListOf<StatisticsVo>()
|
map.forEach {
|
if (!it.isEmpty() && it.get("name") != null) {
|
val statisticsVo = StatisticsVo()
|
statisticsVo.name = it.get("name").toString()
|
try {
|
statisticsVo.count = it.get("count").toString().toInt()
|
} catch (e: Exception) {
|
}
|
try {
|
statisticsVo.changeCount = it.get("changeCount").toString().toInt()
|
} catch (e: Exception) {
|
}
|
statisticsVos.add(statisticsVo)
|
}
|
}
|
|
return statisticsVos
|
}
|
|
//根据区县、场景类型、时间获取各个问题数量
|
override fun getStatisticalResult(areaVo: AreaVo): List<StatisticsVo> {
|
val districtcode = areaVo.districtcode
|
val sceneType = areaVo.scensetypeid
|
val startTime = areaVo.starttime?.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
|
val endTime = areaVo.endtime?.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
|
return problemlistMapper.getStatisticalResult(districtcode, startTime, endTime, sceneType, areaVo.sceneId)
|
}
|
|
override fun getChargeResult(areaVo: AreaVo): ChargeInfoVo {
|
// val example = Example(Task::class.java)
|
// example.createCriteria()
|
// .andEqualTo("levelnum", "2")
|
// .andLessThanOrEqualTo("starttime", areaVo.starttime)
|
// .andGreaterThanOrEqualTo("endtime", areaVo.endtime)
|
// .andEqualTo("districtcode", areaVo.districtcode)
|
val chargeInfoVo = ChargeInfoVo()
|
val sTime = areaVo.starttime?.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
|
val eTime = areaVo.endtime?.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
|
val sql =
|
"select T_GUID, T_Name from tm_t_task where TS_GUID IS NULL and T_StartTime <= '" + sTime + "' and T_EndTime" +
|
" >= '" + eTime + "' and T_DistrictCode = '" + areaVo.districtcode + "'"
|
|
val maps1 = taskMapper.selectSE(sql)
|
var topTaskId = String()
|
var topTaskName = String()
|
if (maps1.isNotEmpty()) {
|
topTaskName = maps1[0].get("T_Name").toString()
|
topTaskId = maps1.get(0).get("T_GUID").toString()
|
chargeInfoVo.topTaskId = topTaskId
|
chargeInfoVo.topTaskName = topTaskName
|
}
|
val maps2 = problemlistMapper.getChangeResult(topTaskId, areaVo.scensetypeid)
|
maps2.forEach {
|
val sceneInfo = ChargeInfoVo.SceneInfo()
|
sceneInfo.id = it["id"].toString()
|
sceneInfo.name = it.get("name").toString()
|
sceneInfo.type = it.get("type").toString()
|
try {
|
sceneInfo.problemCount = it.get("problemCount").toString().toInt()
|
} catch (e: Exception) {
|
}
|
try {
|
sceneInfo.changeCount = it.get("changeCount").toString().toInt()
|
} catch (e: Exception) {
|
}
|
chargeInfoVo.sceneInfos.add(sceneInfo)
|
}
|
val scoreInfo1 = ChargeInfoVo.ScoreInfo()
|
val scoreInfo2 = ChargeInfoVo.ScoreInfo()
|
val scoreInfo3 = ChargeInfoVo.ScoreInfo()
|
val scoreInfo4 = ChargeInfoVo.ScoreInfo()
|
scoreInfo1.type = "规范"
|
scoreInfo2.type = "基本规范"
|
scoreInfo3.type = "不规范"
|
scoreInfo4.type = "严重不规范"
|
val maps3 = problemlistMapper.getScoreResult(topTaskId, areaVo.scensetypeid)
|
maps3.forEach {
|
if (it.isNotEmpty()) {
|
var curScore = -1
|
if (it.get("scoreAft") != null) {
|
curScore = it.get("scoreAft").toString().toInt()
|
} else if (it.get("scoreBef") != null) {
|
curScore = it.get("scoreBef").toString().toInt()
|
}
|
if (curScore >= 100) {
|
scoreInfo1.count++
|
} else if (curScore >= 78 && curScore < 100) {
|
scoreInfo2.count++
|
} else if (curScore >= 54 && curScore < 78) {
|
scoreInfo3.count++
|
} else if (curScore < 54 && curScore >= 0) {
|
scoreInfo4.count++
|
}
|
}
|
}
|
chargeInfoVo.scoreInfos.add(scoreInfo1)
|
chargeInfoVo.scoreInfos.add(scoreInfo2)
|
chargeInfoVo.scoreInfos.add(scoreInfo3)
|
chargeInfoVo.scoreInfos.add(scoreInfo4)
|
|
return chargeInfoVo
|
}
|
|
//根据地域获取问题
|
override fun getByArea(areaVo: AreaVo): List<ProblemListVo> {
|
val problemlist = mutableListOf<ProblemListVo>()
|
// val tmpproblemlsit = mutableListOf<Problemlist>()
|
val example = Example(Scense::class.java)
|
val criteria = example.createCriteria()
|
//根据区域和场景类型获取指定场景
|
if (StringUtil.isNotEmpty(areaVo.provincecode))
|
criteria.andEqualTo("provincecode", areaVo.provincecode)
|
if (StringUtil.isNotEmpty(areaVo.citycode))
|
criteria.andEqualTo("citycode", areaVo.citycode)
|
if (StringUtil.isNotEmpty(areaVo.districtcode))
|
criteria.andEqualTo("districtcode", areaVo.districtcode)
|
if (StringUtil.isNotEmpty(areaVo.towncode))
|
criteria.andEqualTo("towncode", areaVo.towncode)
|
criteria.andEqualTo("typeid", areaVo.scensetypeid)
|
val result1 = scenseMapper.selectByExample(example)
|
if (result1.isNotEmpty()) {
|
result1.forEach {
|
val tmpexample = Example(Problemlist::class.java)
|
val tmpcriteria = tmpexample.createCriteria()
|
//对于确定的每个场景，根据时间查询问题
|
tmpcriteria.andEqualTo("sguid", it.guid)
|
tmpcriteria.andBetween("time", areaVo.starttime, areaVo.endtime)
|
val tmp = problemlistMapper.selectByExample(tmpexample)
|
tmp.forEach {
|
val problem = ProblemListVo();
|
BeanUtils.copyProperties(it, problem)
|
problemlist.add(problem)
|
}
|
}
|
}
|
problemlist.forEach {
|
if (it.ptguid != null) {
|
val tmp1 = problemtypeMapper.selectByPrimaryKey(it.ptguid)
|
if (tmp1 != null) {
|
it.typeid = tmp1.typeid
|
it.typename = tmp1.typename
|
}
|
}
|
}
|
|
return problemlist
|
}
|
|
//根据巡查ID获取问题
|
override fun findByInspectionID(inspectionID: String): List<ProblemListVo> {
|
val problemListVoList = mutableListOf<ProblemListVo>()
|
val problemlist = Problemlist()
|
problemlist.iguid = inspectionID
|
val problemlists = problemlistMapper.select(problemlist)
|
problemlists.forEach {
|
val problemlistVo = ProblemListVo()
|
if (it.remark != Constant.PROBLEM_DELETED) {
|
BeanUtils.copyProperties(it, problemlistVo)
|
problemListVoList.add(problemlistVo)
|
}
|
}
|
//排序
|
problemListVoList.sortBy { it.time }
|
return problemListVoList
|
}
|
|
//新增一个问题
|
override fun addProblem(problemlistVo: ProblemListVo) {
|
val probemlist = Problemlist()
|
BeanUtils.copyProperties(problemlistVo, probemlist)
|
problemlistMapper.insert(probemlist)
|
}
|
|
//根据子任务ID查询问题
|
override fun findBySubtaskId(subTaskID: String): List<ProblemListVo> {
|
val problemListVoList = mutableListOf<ProblemListVo>()
|
val problemlist = Problemlist()
|
problemlist.stguid = subTaskID
|
val problemlists = problemlistMapper.select(problemlist)
|
problemlists.forEach {
|
val problemlistVo = ProblemListVo()
|
BeanUtils.copyProperties(it, problemlistVo)
|
problemListVoList.add(problemlistVo)
|
}
|
return problemListVoList
|
}
|
|
//根据问题ID获取一个问题
|
override fun findByID(id: String): ProblemListVo {
|
val problemlistVo = ProblemListVo()
|
val problemlist = problemlistMapper.selectByPrimaryKey(id)
|
if (problemlist != null) {
|
BeanUtils.copyProperties(problemlist, problemlistVo)
|
}
|
return problemlistVo
|
}
|
|
override fun findAll(): MutableList<Problemlist> = problemlistMapper.selectAll()
|
|
override fun save(problemlist: Problemlist): Int = problemlistMapper.insert(problemlist)
|
|
override fun update(problemlist: Problemlist): Int = problemlistMapper.updateByPrimaryKey(problemlist)
|
|
override fun delete(id: String): Int = problemlistMapper.deleteByPrimaryKey(id)
|
|
override fun setDeleteStatus(id: String): BaseResponse<Int> {
|
val p = problemlistMapper.selectByPrimaryKey(id)
|
|
return when {
|
p.ischanged == true -> BaseResponse(false, "问题已整改，无法删除", data = 0)
|
p.extension3 != Constant.PROBLEM_UNCHECKED -> BaseResponse(false, "问题已审核，无法删除", data = 0)
|
else -> {
|
// 2021/4/25 将原来的添加删除状态改为直接删除
|
// p.remark = Constant.PROBLEM_DELETED
|
val i = problemlistMapper.deleteByPrimaryKey(id)
|
mediafileMapper.deleteByExample(Example(Mediafile::class.java).apply {
|
createCriteria().andEqualTo("businessguid", id)
|
})
|
//更新巡查信息中的问题数量
|
val inspection = inspectionMapper.selectByPrimaryKey(p.iguid)
|
if (inspection.problemcount != null && inspection.problemcount!! > 0) {
|
inspection.problemcount = inspection.problemcount!! - 1
|
inspectionMapper.updateByPrimaryKey(inspection)
|
}
|
BaseResponse(true, "问题删除成功", data = i)
|
}
|
}
|
}
|
|
// @Override
|
//// public List<MonthProblemVo> findMonthProblemById(taskId: String, sceneId: String)
|
//// {
|
|
override fun findMonthProblemById(taskId: String, sceneId: Int?): List<MonthProblemVo> {
|
val monthProblemlistVoList = mutableListOf<MonthProblemVo>()
|
var map = problemlistMapper.findMonthProblemById(taskId, sceneId)
|
map.forEach { m ->
|
val monthProblemVo = MonthProblemVo()
|
monthProblemVo.townCode =
|
if (m.get("towncode") != null) BigDecimal(m.get("towncode").toString()).toString() else null
|
monthProblemVo.townName = if (m.get("townname") != null) m.get("townname").toString() else null
|
monthProblemVo.scenetype = if (m.get("scenetype") != null) m.get("scenetype").toString().toInt() else null
|
monthProblemVo.scenetypename =
|
if (m.get("scenetypename") != null) m.get("scenetypename").toString() else null
|
monthProblemVo.totalscenecount =
|
if (m.get("totalscenecount") != null) m.get("totalscenecount").toString().toInt() else null
|
monthProblemVo.problemscenes =
|
if (m.get("problemscenes") != null) m.get("problemscenes").toString().toInt() else null
|
monthProblemVo.totalproblems =
|
if (m.get("totalproblems") != null) m.get("totalproblems").toString().toInt() else null
|
monthProblemVo.changedproblems =
|
if (m.get("changedproblems") != null) m.get("changedproblems").toString().toInt() else null
|
monthProblemlistVoList.add(monthProblemVo)
|
}
|
return monthProblemlistVoList;
|
}
|
|
override fun check(
|
pId: String,
|
action: Byte,
|
remark: String,
|
userId: String,
|
userName: String,
|
): BaseResponse<String> {
|
if (action !in 0..3) {
|
return BaseResponse(false, "非法的操作指令")
|
}
|
val p = problemlistMapper.selectByPrimaryKey(pId) ?: return BaseResponse(false, "问题不存在")
|
val subtask = p.stguid?.let { subTaskRep.findOne(it) }
|
val response = BaseResponse<String>(true)
|
var event = ""
|
|
p.apply {
|
this.remark = userName
|
if (extension3 == Constant.PROBLEM_UNCHECKED) {
|
event = "在${subtask?.scensename}审核了一个问题"
|
when (action) {
|
0.toByte() -> {
|
extension3 = Constant.PROBLEM_CHECK_PASS
|
}
|
1.toByte() -> {
|
extension3 = Constant.PROBLEM_CHECK_FAIL
|
}
|
2.toByte(),
|
3.toByte(),
|
-> {
|
response.success = false
|
response.message = "问题提交还未审核，无法进行整改审核！"
|
}
|
}
|
} else if (extension3 == Constant.PROBLEM_CHECK_PASS || extension3 == Constant.PROBLEM_CHECK_FAIL) {
|
when (action) {
|
0.toByte() -> extension3 = Constant.PROBLEM_CHECK_PASS
|
1.toByte() -> extension3 = Constant.PROBLEM_CHECK_FAIL
|
2.toByte(),
|
3.toByte(),
|
-> {
|
if (ischanged == true && extension3 == Constant.PROBLEM_CHECK_PASS) {
|
response.success = true
|
extension3 = if (action == 2.toByte()) {
|
Constant.CHANGE_CHECK_PASS
|
} else {
|
Constant.CHANGE_CHECK_FAIL
|
}
|
event = "在${subtask?.scensename}审核了一个整改"
|
} else {
|
response.success = false
|
response.message = "问题还未整改，无法进行整改审核！操作无效"
|
}
|
}
|
}
|
} else if (extension3 == Constant.CHANGE_UNCHECKED) {
|
event = "在${subtask?.scensename}审核了一个整改"
|
when (action) {
|
0.toByte(),
|
1.toByte(),
|
-> {
|
response.success = false
|
response.message = "问题提交已审核，并且已被整改。操作无效"
|
}
|
2.toByte() -> extension3 = Constant.CHANGE_CHECK_PASS
|
3.toByte() -> extension3 = Constant.CHANGE_CHECK_FAIL
|
}
|
} else if (extension3 == Constant.CHANGE_CHECK_PASS || extension3 == Constant.CHANGE_CHECK_FAIL) {
|
when (action) {
|
0.toByte(),
|
1.toByte(),
|
-> {
|
response.success = false
|
response.message = "问题提交已审核，并且已被整改。操作无效"
|
}
|
2.toByte() -> extension3 = Constant.CHANGE_CHECK_PASS
|
3.toByte() -> extension3 = Constant.CHANGE_CHECK_FAIL
|
}
|
}
|
}
|
|
if (response.success) {
|
val r = problemlistMapper.updateByPrimaryKey(p)
|
if (r != 1) {
|
response.success = false
|
response.message = "问题更新失败！"
|
} else {
|
bizLog.info(WorkStreamLogInfo(userId, userName, event))
|
}
|
}
|
return response
|
}
|
|
override fun newProblem(problem: String, files: Array<MultipartFile>): BaseResponse<String> {
|
//json转object
|
val problemVo = ObjectMapper().readValue(problem, object : TypeReference<ProblemVo>() {})
|
|
val inspection = inspectionMapper.selectByPrimaryKey(problemVo.insGuid) ?: return BaseResponse(false, "巡查记录不存在")
|
val scene = scenseMapper.selectByPrimaryKey(inspection.sguid) ?: return BaseResponse(false, "巡查记录对应场景不存在")
|
// 保存问题
|
val problemlist = ProblemListVo.newPro(inspection, problemVo, scene)
|
problemlistMapper.insert(problemlist)
|
|
// 保存图片
|
mediafileService.saveMediaFile(files) { MediaFileVo.newProFile(inspection, problemlist, scene) }
|
|
//更新巡查信息的问题数
|
if (inspection.problemcount != null) {
|
inspection.problemcount = inspection.problemcount!! + 1
|
inspectionMapper.updateByPrimaryKey(inspection)
|
}
|
|
problemlist.stguid?.let {
|
val subtask = subTaskRep.findOne(it)
|
val event = "在${subtask?.scensename}新增一个问题"
|
bizLog.info(WorkStreamLogInfo(subtask?.executorguids, subtask?.executorrealtimes, event))
|
}
|
|
return BaseResponse(true)
|
}
|
|
override fun updateProblem(problem: ProblemListVo, deleteImg: List<String>, files: Array<MultipartFile>): String {
|
problemRep.findOne(problem.guid) ?: throw BizException("该问题不存在")
|
problemRep.update(problem)
|
val inspection = inspectionMapper.selectByPrimaryKey(problem.iguid) ?: throw BizException("巡查记录不存在")
|
val scene = scenseMapper.selectByPrimaryKey(inspection.sguid) ?: throw BizException("巡查记录对应场景不存在")
|
mediafileService.saveMediaFile(files) { MediaFileVo.newProFile(inspection, problem, scene) }
|
mediafileService.deleteList(deleteImg)
|
return "success"
|
}
|
|
override fun changeProblem(problemId: String, files: Array<MultipartFile>): BaseResponse<String> {
|
// 问题和问题图片合法性检查
|
val p = problemlistMapper.selectByPrimaryKey(problemId) ?: return BaseResponse(false, "问题不存在")
|
val mediaFiles = mediafileMapper.selectByExample(Example(Mediafile::class.java).apply {
|
createCriteria().andEqualTo("businessguid", p.guid)
|
.andEqualTo("businesstypeid", 1)
|
.andEqualTo("ischanged", false)
|
})
|
if (mediaFiles.isEmpty()) return BaseResponse(false, "问题不存在或已整改，无法重复整改")
|
|
// 更新问题
|
p.apply {
|
ischanged = true
|
changedtime = Date()
|
extension3 = Constant.CHANGE_UNCHECKED
|
val today = LocalDate.now()
|
val pTime = LocalDateTime.ofInstant(time?.toInstant(), ZoneId.systemDefault()).toLocalDate()
|
changecatalog = if (p.extension1 != null) {
|
if (today.isAfter(pTime)) {
|
Constant.PROMISE_CHANGE
|
} else {
|
Constant.LOCAL_CHANGE
|
}
|
} else {
|
Constant.UN_PROMISE_CHANGE
|
}
|
}
|
problemlistMapper.updateByPrimaryKey(p)
|
|
// 保存整改图片
|
val m = mediaFiles[0]
|
m.path = m.path + "整改/"
|
m.savetime = Date()
|
m.ischanged = true
|
mediafileService.saveMediaFile(files) {
|
m.apply {
|
guid = UUIDGenerator.generate16ShortUUID()
|
description = p.problemname + " " + p.location + " 整改 " + UUIDGenerator.generateUUID(4) + ".jpg"
|
}
|
}
|
|
return BaseResponse(true)
|
}
|
|
override fun updateChange(problemId: String, deleteImg: List<String>, files: Array<MultipartFile>): String {
|
val p = problemRep.findOne(problemId) ?: throw BizException("该问题不存在")
|
val mediaFiles = mediafileMapper.selectByExample(Example(Mediafile::class.java).apply {
|
createCriteria().andEqualTo("businessguid", problemId)
|
.andEqualTo("businesstypeid", 1)
|
.andEqualTo("ischanged", true)
|
})
|
if (mediaFiles.isEmpty()) throw BizException("问题还未整改，无法修改整改")
|
|
// 保存新的整改图片
|
val m = mediaFiles[0]
|
m.savetime = Date()
|
mediafileService.saveMediaFile(files) {
|
m.apply {
|
guid = UUIDGenerator.generate16ShortUUID()
|
description = p.problemname + " " + p.location + " 整改 " + UUIDGenerator.generateUUID(4) + ".jpg"
|
}
|
}
|
mediafileService.deleteList(deleteImg)
|
return "success"
|
}
|
|
override fun getBySubTask(stGuid: String, all: Boolean?): List<ProblemListVo> {
|
//根据子任务ID获取问题列表
|
val problemListVo = mutableListOf<ProblemListVo>()
|
if (all == false) {
|
//去除未审核以及审核不通过的问题
|
findBySubtaskId(stGuid).forEach {
|
if (it.extension3 != Constant.PROBLEM_UNCHECKED && it.extension3 != Constant.PROBLEM_CHECK_FAIL) {
|
problemListVo.add(it)
|
}
|
}
|
} else {
|
problemListVo.addAll(findBySubtaskId(stGuid))
|
}
|
//根据每个问题,获取媒体文件
|
problemListVo.forEach {
|
val mediafileVo = mediafileService.findByBusinessGUID(it.guid!!)
|
//判断是否有媒体资料
|
if (mediafileVo.isNotEmpty()) {
|
//赋值
|
it.mediafileList = mediafileVo
|
}
|
}
|
return problemListVo
|
}
|
|
override fun getSceneByProType(areaVo: AreaVo, pType: String): List<Subtask?> {
|
areaVo.scensetypeid ?: throw BizException("缺少场景类型参数")
|
val task = taskRep.findOneTask(areaVo) ?: throw BizException("未找到对应的巡查总任务")
|
return subTaskRep.findSubtasks(task.tguid!!, areaVo.scensetypeid!!, pType)
|
}
|
|
override fun getSceneProSummary(
|
areaVo: AreaVo,
|
sortBy: String,
|
page: Int,
|
per_page: Int,
|
): Pair<DataHead?, List<SceneProblemSummary>?> {
|
areaVo.scensetypeid ?: throw BizException("缺少场景类型参数")
|
val task = taskRep.findOneTask(areaVo) ?: throw BizException("未找到对应的巡查总任务")
|
val p = PageHelper.startPage<SceneProblemSummary>(page, per_page)
|
val res = problemRep.selectSceneProSummary(task.tguid!!, areaVo.scensetypeid!!, areaVo.sort, sortBy)
|
return DataHead(p.pageNum, p.pages, p.total) to res
|
}
|
}
|
