Browse Source

扫楼统计数量与列表数量不一致问题修复

linhuili 3 years ago
parent
commit
7026eed2d5

+ 49 - 1
scanbuilding/src/main/kotlin/com/persagy/server/controller/task/EquipScanTaskController.kt

@@ -28,12 +28,15 @@ package com.persagy.server.controller.task
 
 import com.persagy.base.extensions.toJson
 import com.persagy.database.SFilter
+import com.persagy.server.Opts
 import com.persagy.server.datacenter.models.entities.assistant.TaskPic
 import com.persagy.server.datacenter.models.entities.task.*
+import com.persagy.server.datacenter.models.entities.task.base.ScanTaskBase
 import com.persagy.server.services.EquipmentService
 import com.persagy.server.services.task.EquipScanTaskQueryService
 import com.persagy.server.services.task.EquipScanTaskService
 import com.persagy.server.services.task.ScanTaskBaseService
+import com.persagy.server.util.IdUtils
 import com.persagy.service.SPageContext
 import com.persagy.service.models.requests.SCreateRequest
 import com.persagy.service.models.requests.SQueryRequest
@@ -121,9 +124,29 @@ open class EquipScanTaskController {
     @PostMapping(value = ["/create"])
     fun create(@RequestBody request: SCreateRequest<EquipScanTask>): SCreateResponse<EquipScanTask> {
         logger.debug("equip =${request.toJson()}")
-        return EquipScanTaskService.createList(EquipScanTaskService.createBefore(request))
+        val createBefore = EquipScanTaskService.createBefore(request);
+        createEquipScanTaskBase(createBefore);
+        return EquipScanTaskService.createList(createBefore)
+
     } // Function create()
 
+
+    /**
+     * 同步创建基础设备台帐任务
+     */
+    fun createEquipScanTaskBase(@RequestBody createBefore: SCreateRequest<EquipScanTask>){
+        val scanTaskBase: ArrayList<EquipScanTask> = createBefore.content;
+
+        val sCreateRequest = SCreateRequest<ScanTaskBase>()
+        var newList = arrayListOf<ScanTaskBase>()
+        for(equip in scanTaskBase){
+            val scanTaskBase: ScanTaskBase = equip
+            scanTaskBase.projectId= Opts.projectId
+            newList.add(scanTaskBase);
+        }
+        sCreateRequest.content = newList
+        ScanTaskBaseService.createList(sCreateRequest)
+    }
     /**
      * 更新设备台账
      *
@@ -144,9 +167,29 @@ open class EquipScanTaskController {
     @Operation(summary = "更新设备台账任务", description = "所有属性名要以查询返回结果为准  例如:任务id应用TaskId;")
     @PostMapping(value = ["/update"])
     fun update(@RequestBody request: SUpdateRequest<EquipScanTask>): SBaseResponse {
+        updateScanTaskBase(request);
         return EquipScanTaskService.updateList(request)
     } // Function update()
 
+
+    /**
+     * 更新台帐基础信息
+     */
+    fun updateScanTaskBase(@RequestBody request: SUpdateRequest<EquipScanTask>){
+        //更新基础信息
+        val sUpdateRequest = SUpdateRequest<ScanTaskBase>()
+        var newList = arrayListOf<ScanTaskBase>()
+        val equipList = request.content;
+        if (equipList != null) {
+            for(equip in equipList){
+                val scanTaskBase: ScanTaskBase = equip
+                newList.add(scanTaskBase);
+            }
+        }
+        sUpdateRequest.content = newList
+        ScanTaskBaseService.updateList(sUpdateRequest)
+    }
+
     /**
      * 根据id删除设备台账
      *
@@ -164,6 +207,11 @@ open class EquipScanTaskController {
     @Operation(summary = "根据id删除设备台账", description = "所有属性名要以查询返回结果为准  例如:任务id应用TaskId;")
     @PostMapping(value = ["/delete"])
     fun delete(@RequestBody idList: ArrayList<EquipScanTask>): SBaseResponse {
+        var newList = arrayListOf<ScanTaskBase>()
+        for(id in idList){
+            newList.add(id);
+        }
+        ScanTaskBaseService.deleteByKeysList(newList)
         return EquipScanTaskService.deleteByKeysList(idList)
     } // Function delete()
 

+ 47 - 1
scanbuilding/src/main/kotlin/com/persagy/server/controller/task/ModelScanTaskController.kt

@@ -30,8 +30,11 @@ import com.persagy.base.extensions.toJson
 import com.persagy.database.SFilter
 import com.persagy.database.functions.SLength
 import com.persagy.mybatis.SMybatisDao
+import com.persagy.server.Opts
 import com.persagy.server.datacenter.models.entities.task.*
+import com.persagy.server.datacenter.models.entities.task.base.ScanTaskBase
 import com.persagy.server.datacenter.models.requests.ModelScanSQueryRequest
+import com.persagy.server.services.task.EquipScanTaskService
 import com.persagy.server.services.task.ModelScanTaskQueryService
 import com.persagy.server.services.task.ModelScanTaskService
 import com.persagy.server.services.task.ScanTaskBaseService
@@ -107,9 +110,28 @@ open class ModelScanTaskController {
     @PostMapping(value = ["/create"])
     fun create(@RequestBody request: SCreateRequest<ModelScanTask>): SCreateResponse<ModelScanTask> {
         logger.debug("equip =${request.toJson()}")
-        return ModelScanTaskService.createList(ModelScanTaskService.createBefore(request))
+        val createBefore = ModelScanTaskService.createBefore(request)
+        createModelScanTaskBase(createBefore)
+        return ModelScanTaskService.createList(createBefore)
     } // Function create()
 
+
+    /**
+     * 同步创建基础模型台帐任务
+     */
+    fun createModelScanTaskBase(@RequestBody createBefore : SCreateRequest<ModelScanTask>){
+        val scanTaskBase: ArrayList<ModelScanTask> = createBefore.content
+
+        val sCreateRequest = SCreateRequest<ScanTaskBase>()
+        var newList = arrayListOf<ScanTaskBase>()
+        for(equip in scanTaskBase){
+            val scanTaskBase: ScanTaskBase = equip
+            scanTaskBase.projectId= Opts.projectId
+            newList.add(scanTaskBase);
+        }
+        sCreateRequest.content = newList
+        ScanTaskBaseService.createList(sCreateRequest)
+    }
     /**
      * 更新模型任务
      *
@@ -120,11 +142,30 @@ open class ModelScanTaskController {
     @Operation(summary = "更新模型任务", description = "所有属性名要以查询返回结果为准  例如:任务id应用TaskId;")
     @PostMapping(value = ["/update"])
     fun update(@RequestBody request: SUpdateRequest<ModelScanTask>): SBaseResponse {
+        updateScanTaskBase(request);
         return ModelScanTaskService.updateList(request)
     } // Function update()
 
 
     /**
+     * 更新模型基础信息
+     */
+    fun updateScanTaskBase(@RequestBody request: SUpdateRequest<ModelScanTask>){
+        //更新基础信息
+        val sUpdateRequest = SUpdateRequest<ScanTaskBase>()
+        var newList = arrayListOf<ScanTaskBase>()
+        val equipList = request.content;
+        if (equipList != null) {
+            for(equip in equipList){
+                val scanTaskBase: ScanTaskBase = equip
+                newList.add(scanTaskBase);
+            }
+        }
+        sUpdateRequest.content = newList
+        ScanTaskBaseService.updateList(sUpdateRequest)
+    }
+
+    /**
      * 根据id删除模型任务
      *
      * @param   idList      id数组
@@ -135,6 +176,11 @@ open class ModelScanTaskController {
     @Operation(summary = "根据id删除模型任务", description = "所有属性名要以查询返回结果为准  例如:任务id应用TaskId;")
     @PostMapping(value = ["/delete"])
     fun delete(@RequestBody idList: ArrayList<ModelScanTask>): SBaseResponse {
+        var newList = arrayListOf<ScanTaskBase>()
+        for(id in idList){
+            newList.add(id);
+        }
+        ScanTaskBaseService.deleteByKeysList(newList)
         return ModelScanTaskService.deleteByKeysList(idList)
     } // Function delete()
 

+ 47 - 1
scanbuilding/src/main/kotlin/com/persagy/server/controller/task/PropertyScanTaskController.kt

@@ -28,9 +28,13 @@ package com.persagy.server.controller.task
 
 import com.persagy.base.extensions.toJson
 import com.persagy.database.SFilter
+import com.persagy.server.Opts
 import com.persagy.server.datacenter.models.entities.task.BuildingDic
 import com.persagy.server.datacenter.models.entities.task.EquipCategoryDic
+import com.persagy.server.datacenter.models.entities.task.ModelScanTask
 import com.persagy.server.datacenter.models.entities.task.PropertyScanTask
+import com.persagy.server.datacenter.models.entities.task.base.ScanTaskBase
+import com.persagy.server.services.task.ModelScanTaskService
 import com.persagy.server.services.task.PropertyScanTaskService
 import com.persagy.server.services.task.ScanTaskBaseService
 import com.persagy.service.SPageContext
@@ -92,9 +96,28 @@ open class PropertyScanTaskController {
     @PostMapping(value = ["/create"])
     fun create(@RequestBody request: SCreateRequest<PropertyScanTask>): SCreateResponse<PropertyScanTask> {
         logger.debug("equip =${request.toJson()}")
-        return PropertyScanTaskService.createList(PropertyScanTaskService.createBefore(request))
+        val createBefore = PropertyScanTaskService.createBefore(request)
+        createPropertyScanTaskBase(createBefore);
+        return PropertyScanTaskService.createList(createBefore)
     } // Function create()
 
+
+    /**
+     * 同步创建基础资产台帐任务
+     */
+    fun createPropertyScanTaskBase(@RequestBody createBefore: SCreateRequest<PropertyScanTask>){
+        val scanTaskBase: ArrayList<PropertyScanTask> = createBefore.content;
+        val sCreateRequest = SCreateRequest<ScanTaskBase>()
+        var newList = arrayListOf<ScanTaskBase>()
+        for(equip in scanTaskBase){
+            val scanTaskBase: ScanTaskBase = equip
+            scanTaskBase.projectId= Opts.projectId
+            newList.add(scanTaskBase);
+        }
+        sCreateRequest.content = newList
+        ScanTaskBaseService.createList(sCreateRequest)
+    }
+
     /**
      * 更新资产台账任务
      *
@@ -105,10 +128,28 @@ open class PropertyScanTaskController {
     @Operation(summary = "更新资产台账任务", description = "所有属性名要以查询返回结果为准  例如:任务id应用TaskId;")
     @PostMapping(value = ["/update"])
     fun update(@RequestBody request: SUpdateRequest<PropertyScanTask>): SBaseResponse {
+        updateScanTaskBase(request)
         return PropertyScanTaskService.updateList(request)
     } // Function update()
 
     /**
+     * 更新资产基础信息
+     */
+    fun updateScanTaskBase(@RequestBody request: SUpdateRequest<PropertyScanTask>){
+        //更新基础信息
+        val sUpdateRequest = SUpdateRequest<ScanTaskBase>()
+        var newList = arrayListOf<ScanTaskBase>()
+        val equipList = request.content;
+        if (equipList != null) {
+            for(equip in equipList){
+                val scanTaskBase: ScanTaskBase = equip
+                newList.add(scanTaskBase);
+            }
+        }
+        sUpdateRequest.content = newList
+        ScanTaskBaseService.updateList(sUpdateRequest)
+    }
+    /**
      * 根据id删除资产台账任务
      *
      * @param   idList      id数组
@@ -119,6 +160,11 @@ open class PropertyScanTaskController {
     @Operation(summary = "根据id删除资产台账任务", description = "所有属性名要以查询返回结果为准  例如:任务id应用TaskId;")
     @PostMapping(value = ["/delete"])
     fun delete(@RequestBody idList: ArrayList<PropertyScanTask>): SBaseResponse {
+        var newList = arrayListOf<ScanTaskBase>()
+        for(id in idList){
+            newList.add(id);
+        }
+        ScanTaskBaseService.deleteByKeysList(newList)
         return PropertyScanTaskService.deleteByKeysList(idList)
     } // Function delete()
 

+ 10 - 4
scanbuilding/src/main/kotlin/com/persagy/server/services/task/EquipScanTaskService.kt

@@ -108,9 +108,9 @@ object EquipScanTaskService : RService<EquipScanTask>(SMybatisDao(EquipScanTask:
             }
 
             val projectId = SPageContext.getHeader("projectId")
-//            if (equipScanTask.id.isNullOrEmpty()) {
+            if (equipScanTask.id.isNullOrEmpty()) {
                 equipScanTask.id = IdUtils.uuidCreate()
-//            }
+            }
             if(!projectId.isNullOrEmpty()){
                 equipScanTask.projectId = projectId
             }
@@ -368,8 +368,14 @@ object EquipScanTaskService : RService<EquipScanTask>(SMybatisDao(EquipScanTask:
             if(equipmentOld!!.taskState != -1){//未找到
                 val equip = Equipment()
                 equip.id = task.equipId!!
-                equip.taskState = task.taskState
-                equipmentService.update(equip)
+
+                val infos = HashMap<String, Any?>()
+                infos.put("taskState",task.taskState!!)
+                equip.infos = infos
+                // equipmentService.update(component)
+                admBaseService?.updateEquip(arrayListOf(equip))
+
+               // equipmentService.update(equip)
             }
 
             try {

+ 2 - 2
scanbuilding/src/main/kotlin/com/persagy/server/services/task/ModelScanTaskService.kt

@@ -132,9 +132,9 @@ object ModelScanTaskService : RService<ModelScanTask>(SMybatisDao(ModelScanTask:
                     resetTaskStatus(modelScanTask)
                 }
                 val projectId = SPageContext.getHeader("projectId")
-//                if (modelScanTask.id.isNullOrEmpty()) {
+                if (modelScanTask.id.isNullOrEmpty()) {
                     modelScanTask.id = UUID.randomUUID().toString()
-//                }
+                }
                 if (!projectId.isNullOrEmpty()) {
                     modelScanTask.projectId = projectId
                 }

+ 2 - 2
scanbuilding/src/main/kotlin/com/persagy/server/services/task/PropertyScanTaskService.kt

@@ -224,9 +224,9 @@ object PropertyScanTaskService : RService<PropertyScanTask>(SMybatisDao(Property
                 }
             }
             val projectId = SPageContext.getHeader("projectId")
-//            if (propertyScanTask.id.isNullOrEmpty()) {
+            if (propertyScanTask.id.isNullOrEmpty()) {
                 propertyScanTask.id = UUID.randomUUID().toString()
-//            }
+            }
             if(!projectId.isNullOrEmpty()){
                 propertyScanTask.projectId = projectId
             }

+ 212 - 0
scanbuilding/src/main/kotlin/com/persagy/server/services/task/ScanTaskBaseService.kt

@@ -26,11 +26,18 @@
 
 package com.persagy.server.services.task
 
+import cn.hutool.core.collection.CollUtil
 import com.alibaba.fastjson.JSONObject
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import com.persagy.base.extensions.toJson
 import com.persagy.database.SFilter
 import com.persagy.database.SPageQueryInfo
 import com.persagy.mybatis.SMybatisDao
+import com.persagy.server.Opts
+import com.persagy.server.datacenter.models.entities.assistant.TaskPic
 import com.persagy.server.datacenter.models.entities.objects.Building
+import com.persagy.server.datacenter.models.entities.objects.Equipment
 import com.persagy.server.datacenter.models.entities.task.*
 import com.persagy.server.datacenter.models.entities.task.base.ScanTaskBase
 import com.persagy.server.mappers.StatisticsCountMapper
@@ -39,12 +46,15 @@ import com.persagy.server.services.DmpBaseService
 import com.persagy.server.services.StatisticsCountService
 import com.persagy.server.services.base.RService
 import com.persagy.server.util.AdmEntityTransferUtil
+import com.persagy.server.util.IdUtils
+import com.persagy.service.SBaseService
 import com.persagy.service.SPageContext
 import com.persagy.service.models.SCascadeQuery
 import com.persagy.service.models.enums.SResponseType
 import com.persagy.service.models.requests.SQueryRequest
 import com.persagy.service.models.responses.SQueryResponse
 import com.persagy.service.utils.SSpringContextUtil
+import org.slf4j.LoggerFactory
 import org.springframework.beans.factory.annotation.Autowired
 
 /**
@@ -54,6 +64,8 @@ import org.springframework.beans.factory.annotation.Autowired
  */
 object ScanTaskBaseService : RService<ScanTaskBase>(SMybatisDao(ScanTaskBase::class.java))  {
 
+    // 日志
+    private val logger = LoggerFactory.getLogger(EquipScanTaskService::class.java)
     /** 实例化 mapper 对象 */
     val mapper by lazy {
         SSpringContextUtil.getBean(StatisticsCountMapper::class.java) as StatisticsCountMapper
@@ -344,7 +356,207 @@ object ScanTaskBaseService : RService<ScanTaskBase>(SMybatisDao(ScanTaskBase::cl
     } // Fun
 
 
+    /**
+     * 创建之前操作
+     */
+    override fun onCreateBefore(equipScanTask: ScanTaskBase): Boolean  {
+        try{
+            val gson = Gson()
+            var flag = false
+            if(equipScanTask.taskState == -1){//前台传数据过来状态为-1 表示当前任务是未找到状态 重新生成任务,将之前的设备任务状态和部件任务改为已完成
+                flag = true
+                ScanTaskBaseService.resetTaskStatus(equipScanTask)
+            }
+
+            val projectId = SPageContext.getHeader("projectId")
+            if (equipScanTask.id.isNullOrEmpty()) {
+                equipScanTask.id = IdUtils.uuidCreate()
+            }
+            if(!projectId.isNullOrEmpty()){
+                equipScanTask.projectId = projectId
+            }
+            equipScanTask.taskSource = 2//数据源为设备台账
+            equipScanTask.taskState = 1//任务状态为待验证
+            //equipScanTask.taskType = "1"
+
+            if (!equipScanTask.equipId.isNullOrEmpty()) {//当设备id不为空时,去设备表查询对应的详细信息
+                /* val equipmentService = SBaseService(SMybatisDao(Equipment::class.java))
+                 val equipment = equipmentService.select(SFilter.eq("id", equipScanTask.equipId!!)).entity()*/
+                //2021.10.26调整为从中间件查询设备信息
+                val equipmentList = ScanTaskBaseService.admBaseService?.queryEquipById(equipScanTask.equipId!!)
+                if(CollUtil.isEmpty(equipmentList)){
+                    return false
+                    logger.info("设备任务创建:设备不存在 id "+equipScanTask.equipId)
+                }
+                val equipment = equipmentList?.get(0)
+                if (equipScanTask.schemeId.isNullOrEmpty()){
+                    if (equipmentList != null) {
+                        val equipment = equipmentList.get(0);
+                        equipScanTask.schemeId = SchemeUtils.setScheme(equipment!!.classCode!!)
+                    }
+                }
+//                equipment.ledgerParam.PhotoDoc.Pic
+
+                if(equipment!!.infos != null){//设备图片信息
+                    val photoDoc = equipment!!.infos!!.get("photoDoc")
+                    if( photoDoc != null){
+                        val obj = JSONObject.parseObject(photoDoc!!.toJson())
+                        val pic = obj.getString("pic")
+
+                        val type = object : TypeToken<ArrayList<TaskPic>>() {
+                        }.type
+                        val siInSpList = gson.fromJson<ArrayList<TaskPic>>(pic, type)
+                        equipScanTask.taskPicList = siInSpList
+                    }
+
+                    val containsKey = equipment.infos!!.containsKey(Opts.INSTALLLOCATION)
+                    if (containsKey){
+                        equipScanTask.installLocation = equipment.infos!![Opts.INSTALLLOCATION].toString()
+                    }
+                }
+
+
+                try {
+                    if (!equipment.infos.isNullOrEmpty()){
+
+                        val containsKey = equipment.infos!!.containsKey(Opts.MANUFACTURER)
+                        if (containsKey){
+                            equipScanTask.manufacturer = equipment.infos!![Opts.MANUFACTURER].toString()
+                        }
+                        val containsKey2 = equipment.infos!!.containsKey(Opts.SPECIFICATION)
+                        if(containsKey2) {
+                            equipScanTask.specification = equipment.infos!![Opts.SPECIFICATION].toString()
+                        }
+
+                        val containsKeys = equipment.infos!!.containsKey(Opts.SUPPLIER)
+                        if (containsKeys){
+                            equipScanTask.supplier =  equipment.infos!![Opts.SUPPLIER].toString()
+                        }
+                    }
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+
+                if(flag){
+                    equipScanTask.equipName = equipment!!.name
+                    equipScanTask.localId = equipment!!.localId
+                    equipScanTask.localName = equipment!!.localName
+                    equipScanTask.bimId = equipment!!.bimId
+                    equipScanTask.classCode = equipment!!.classCode
+                    equipScanTask.buildingId = equipment!!.buildingId
+                    equipScanTask.floorId = equipment!!.floorId
+                    equipScanTask.cadId = equipment!!.cadId
+//                    equipScanTask.supplier = equipment!!.dpSupplierID
+
+
+//                    equipScanTask.specification = equipment!!.dpManufacturerID
+//                    equipScanTask.manufacturer = equipment!!.dpMaintainerID
+                    //equipScanTask.bimLocation = equipment.bimLocation
+//                    if (equipment.codeType!=null){
+//                        equipScanTask.taskType = equipment.codeType.toString()
+//                    }else{
+//                        equipScanTask.taskType = "1"
+//                    }
+
+
+                }else {
+                   // equipScanTask.bimLocation = equipment.bimLocation
+                    if (equipScanTask.equipName.isNullOrEmpty()) {
+                        equipScanTask.equipName = equipment!!.name
+                    }
+                    if (equipScanTask.localId.isNullOrEmpty()) {
+                        equipScanTask.localId = equipment!!.localId
+                    }
+                    if (equipScanTask.localName.isNullOrEmpty()) {
+                        equipScanTask.localName = equipment!!.localName
+                    }
+                    if (equipScanTask.bimId.isNullOrEmpty()) {
+                        equipScanTask.bimId = equipment!!.bimId
+                    }
+                    if (equipScanTask.classCode.isNullOrEmpty()) {
+                        equipScanTask.classCode = equipment!!.classCode
+                    }
+                    if (equipScanTask.buildingId.isNullOrEmpty()) {
+                        equipScanTask.buildingId = equipment!!.buildingId
+                    }
+                    if (equipScanTask.floorId.isNullOrEmpty()) {
+                        equipScanTask.floorId = equipment!!.floorId
+                    }
+                    if (equipScanTask.cadId.isNullOrEmpty()) {
+                        equipScanTask.cadId = equipment!!.cadId
+                    }
+                    if (equipScanTask.manufacturer.isNullOrEmpty()) {
+                        if (!equipment.infos.isNullOrEmpty()) {
+                            val contains = equipment.infos!!.contains("manufacturer")
+                            if (contains) {
+                                equipScanTask.manufacturer = equipment.infos!!["manufacturer"].toString()
+                            }
+                        }
+                    }
+
+                    if (equipScanTask.specification.isNullOrEmpty()) {
+                        if (!equipment.infos.isNullOrEmpty()) {
+                            val contains = equipment.infos!!.contains("specification")
+                            if (contains) {
+                                equipScanTask.specification = equipment.infos!!["specification"].toString()
+                            }
+                        }
+                    }
+
+                    if (equipScanTask.supplier.isNullOrEmpty()) {
+                        if (!equipment.infos.isNullOrEmpty()) {
+                            val contains = equipment.infos!!.contains("supplier")
+                            if (contains) {
+                                equipScanTask.supplier = equipment.infos!!["supplier"].toString()
+                            }
+                        }
+                    }
 
+//                    if (equipScanTask.taskType.isNullOrEmpty()){
+//                        if (equipment.codeType!=null){
+//                            equipScanTask.taskType = equipment.codeType.toString()
+//                        }else{
+//                            equipScanTask.taskType = "1"
+//                        }
+//                    }
+
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        return true
+    } // Function onCreateBefore()
+
+    /**
+     * 重新生成任务时,将任务状态改为已完成
+     */
+    fun resetTaskStatus(task: ScanTaskBase) {
+        val equipmentService = SBaseService(SMybatisDao(Equipment::class.java))
+        val equipScanTaskService = SBaseService(SMybatisDao(EquipScanTask::class.java))
+
+        //val resetTask = equipScanTaskService.select("equipId" to task.equipId!!, "taskState" to -1).entity()
+        val resetTask = ScanTaskBaseService.select(SFilter.eq("equipId", task!!.equipId!!), SFilter.eq("taskState",-1)).entity()
+        if (resetTask != null) {
+            resetTask.taskState = 0
+            ScanTaskBaseService.update(resetTask)//更改设备任务状态
+            updateComponetTaskStatus(resetTask)//更改部件任务状态
+        }
+    }
+
+    /**
+     * 更新设备任务状态时,对应更改部件任务状态
+     */
+    fun updateComponetTaskStatus(task: ScanTaskBase){
+        val equipmentService = SBaseService(SMybatisDao(Equipment::class.java))
+        val equipScanTaskService = SBaseService(SMybatisDao(EquipScanTask::class.java))
+        // val componentTaskList = equipScanTaskService.select("parentId" to task!!.equipId!!).exec()
+        val componentTaskList = ScanTaskBaseService.select(SFilter.eq("projectId", task!!.equipId!!)).exec()
+        for(childTask in componentTaskList){
+            childTask.taskState = task.taskState
+            ScanTaskBaseService.update(childTask)
+        }
+    } // Fun updateStatus
 
 
 }  // Fun