package com.ruoyi.tc.controller;


import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.tc.entity.*;
import com.ruoyi.tc.entity.po.*;
import com.ruoyi.tc.entity.request.Acomma;
import com.ruoyi.tc.entity.request.AssetAuditPageRequest;
import com.ruoyi.tc.entity.request.AssetAuditRequest;
import com.ruoyi.tc.entity.request.AssetCurrentPageRequest;
import com.ruoyi.tc.entity.zztb.*;
import com.ruoyi.tc.service.*;
import com.ruoyi.tc.zztbService.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 现有资产表(AssetCurrent)表控制层
 *
 * @author makejava
 * @since 2024-11-15 10:03:56
 */
@Api(tags = "现有资产表")
@RestController
@RequestMapping("/tc/assetCurrent")
public class AssetCurrentController extends BaseController {
    /**
     * 服务对象
     */
    @Resource
    private AssetCurrentService assetCurrentService;
    @Resource
    private AssetSupplyChainService assetSupplyChainService;


    @Resource
    private AssetBasicNetworkService assetBasicNetworkService;

    @Resource
    private AssetBusinessFormService assetBusinessFormService;

    @Resource
    private UnitOtherConcatService unitOtherConcatService;

    @Resource
    private AssetTaskService assetTaskService;

    @Resource
    private AssetCurrentCpService assetCurrentCpService;

    @Resource
    private AssetBusinessFormCpService assetBusinessFormCpService;

    @Resource
    private AssetSupplyChainCpService assetSupplyChainCpService;


    @Resource
    private AssetBasicNetworkCpService assetBasicNetworkCpService;


    @Resource
    private UnitOtherConcatCpService unitOtherConcatCpService;

    @Resource
    private UnitService unitService;

    @Resource
    private AssetCurrentJyService assetCurrentJyService;


    @Resource
    private AssetBusinessFormJyService assetBusinessFormJyService;

    @Resource
    private AssetSupplyChainJyService assetSupplyChainJyService;

    @Resource
    private UnitOtherConcatJyservice unitOtherConcatJyservice;

    @Resource
    private AssetBasicNetworkJyService assetBasicNetworkJyService;


    @Resource
    private AssetCurrentZztbService assetCurrentZztbService;


    @Resource
    private AssetBasicNetworkZztbService assetBasicNetworkZztbService;


    @Resource
    private AssetBusinessFormZztbService assetBusinessFormZztbService;


    @Resource
    private AssetSupplyChainZztbService assetSupplyChainZztbService;


    @Resource
    private UnitOtherConcatZztbservice unitOtherConcatZztbservice;


    @Resource
    private AssetAssetSjCpService assetAssetSjCpService;


    @Resource
    private AssetAssetSjZztbService assetAssetSjZztbService;


    @Resource
    private AssetAssetSjService assetAssetSjService;

    /**
     * 分页查询所有数据
     *
     * @param as 查询实体
     * @return 所有数据
     */
    @ApiOperation(value = "分页查询所有数据", response = AssetCurrent.class)
    @GetMapping
    public AjaxResult selectAll(AssetCurrentPageRequest as) {
        Page<AssetCurrent> page = new Page<>();
        page.setSize(as.getSize());
        page.setCurrent(as.getCurrent());
        try {
            if (!SecurityUtils.getLoginUser().getUser().isAdmin() && !SecurityUtils.hasRole("common")) {
                as.setDwmc(SecurityUtils.getLoginUser().getUser().getNickName());
            }
        } catch (Exception e) {
            throw new ServiceException("获取用户信息异常");
        }
        return success(assetCurrentService.page(page, as));
    }

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @ApiOperation(value = "通过主键查询单条数据", response = AssetCurrent.class)
    @GetMapping("{id}")
    public AjaxResult selectOne(@PathVariable Serializable id) {
        return success(assetCurrentService.selectOne(id));
    }

    /**
     * 新增数据
     *
     * @param assetCurrent 实体对象
     * @return 新增结果
     */
    @ApiOperation(value = "新增数据")
    @PostMapping
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult insert(@RequestBody @Valid AssetCurrent assetCurrent) {

        List<Unit> list = unitService.lambdaQuery().eq(Unit::getNickName, assetCurrent.getDwmc()).eq(Unit::getDelFlag, 0).list();
        if (list == null || list.isEmpty()) {
            throw new ServiceException("请选择已有单位!");
        }
        List<AssetCurrent> list1 = assetCurrentService.lambdaQuery().eq(AssetCurrent::getXtmc, assetCurrent.getXtmc()).eq(AssetCurrent::getDwmc, assetCurrent.getDwmc()).list();
        if (list1 != null && !list1.isEmpty()) {
            throw new ServiceException("不允许新增重复资产!");
        }

        if (assetCurrent.getXzType() != 1) {
            //管理端新增
            StringBuilder a = new StringBuilder();
            if (assetCurrent.getGlymList() != null) {
                assetCurrent.getGlymList().forEach(x -> {
                    if (!Objects.equals(x.getKey(), "") && x.getKey() != null) {
                        a.append(x.getKey());
                        a.append(",");
                    }
                });
            }
            assetCurrent.setGlym(a.toString());
            List<Acomma> a2 = new ArrayList<>();
            if (assetCurrent.getGlIpList() != null) {
                if (assetCurrent.getGlIp() != null && !assetCurrent.getGlIp().isEmpty()) {
                    for (Object o : JSONArray.parseArray(assetCurrent.getGlIp())) {
                        Acomma acomma = new Acomma();
                        JSONObject jsonObject = JSONObject.parseObject(o.toString());
                        if (BeanUtil.isNotEmpty(jsonObject.get("key"))) {
                            acomma.setKey(jsonObject.get("key").toString());
                        } else {
                            acomma.setKey("");
                        }
                        if (BeanUtil.isNotEmpty(jsonObject.get("ipType"))) {
                            acomma.setIpType(jsonObject.get("ipType").toString());
                        } else {
                            acomma.setIpType("");
                        }
                        Object portValue = jsonObject.get("port");
                        if (portValue != null && !portValue.toString().isEmpty()) {
                            acomma.setPort(portValue.toString());
                        } else {
                            acomma.setPort("");
                        }
                        a2.add(acomma);
                    }
                    assetCurrent.setGlIpList(a2);
                }

            } else {
                assetCurrent.setGlIpList(new ArrayList<>());
            }
//        assetCurrent.setGlIp(b.toString());
            assetCurrentService.save(assetCurrent);
            //新增新监管业务形态
            if (assetCurrent.getXjgywxt() != null) {
                assetCurrent.getXjgywxt().setAssetId(assetCurrent.getId());
                assetBusinessFormService.save(assetCurrent.getXjgywxt());
            }
            if (assetCurrent.getGylxxList() != null) {
                for (AssetSupplyChain items : assetCurrent.getGylxxList()) {
                    items.setAssetId(assetCurrent.getId());
                }
                //新增供应链
                assetSupplyChainService.saveBatch(assetCurrent.getGylxxList());
            }
            if (assetCurrent.getJcwlList() != null) {
                for (AssetBasicNetwork items : assetCurrent.getJcwlList()) {
                    items.setAssetId(assetCurrent.getId());
                }
                //新增基础网络
                assetBasicNetworkService.saveBatch(assetCurrent.getJcwlList());
            }
            if (assetCurrent.getOtherConcat() != null) {
                for (UnitOtherConcat items : assetCurrent.getOtherConcat()) {
                    items.setAssetId(assetCurrent.getId());
                }
                //新增其他联系人
                unitOtherConcatService.saveBatch(assetCurrent.getOtherConcat());
            }
            if (assetCurrent.getSjzcList() != null) {
                for (AssetSj items : assetCurrent.getSjzcList()) {
                    items.setAssetId(assetCurrent.getId());
                }
                //新增数据资产
                assetAssetSjService.saveBatch(assetCurrent.getSjzcList());
            }
            // 单位有进行中的任务时，管理端新增该单位下的资产则需同步至当前进行中的任务中。
            //获取新增资产id
            Long id = assetCurrent.getId();
            Integer i = unitService.selectTaskId(assetCurrent.getDwmc(), "0");
            if (i != null) {
                //新增资产复制主表
                AssetCurrentCpPo assetCurrentCpPo = new AssetCurrentCpPo();
                BeanUtil.copyProperties(assetCurrent, assetCurrentCpPo);
                assetCurrentCpPo.setTaskId(i);
                assetCurrentCpPo.setXzType(1);
                assetCurrentCpService.save(assetCurrentCpPo);
                //新增新监管业务形态
                //根据资产id查询新监管业务形态主表id
                if (assetCurrent.getXjgywxt() != null) {
                    assetCurrentCpPo.getXjgywxt().setAssetId(id);
                    assetCurrentCpPo.getXjgywxt().setTaskId(i);
                    assetBusinessFormCpService.save(assetCurrentCpPo.getXjgywxt());
                }
                if (assetCurrent.getGylxxList() != null) {
                    for (AssetSupplyChainCpPo items : assetCurrentCpPo.getGylxxList()) {
                        items.setAssetId(id);
                        items.setTaskId(i);
                    }
                    //新增供应链
                    assetSupplyChainCpService.saveBatch(assetCurrentCpPo.getGylxxList());
                }
                if (assetCurrent.getJcwlList() != null) {
                    for (AssetBasicNetworkCpPo items : assetCurrentCpPo.getJcwlList()) {
                        items.setAssetId(assetCurrent.getId());
                        items.setTaskId(i);
                    }
                    //新增基础网络
                    assetBasicNetworkCpService.saveBatch(assetCurrentCpPo.getJcwlList());
                }
                if (assetCurrent.getOtherConcat() != null) {
                    for (UnitOtherConcatCpPo items : assetCurrentCpPo.getOtherConcat()) {
                        items.setAssetId(assetCurrent.getId());
                        items.setTaskId(i);
                    }
                    //新增其他联系人
                    unitOtherConcatCpService.saveBatch(assetCurrentCpPo.getOtherConcat());
                }

                if (assetCurrent.getSjzcList() != null) {
                    for (AssetSjCpPo items : assetCurrentCpPo.getSjzcList()) {
                        items.setAssetId(assetCurrent.getId());
                        items.setTaskId(i);
                    }
                    //新增数据资产
                    assetAssetSjCpService.saveBatch(assetCurrentCpPo.getSjzcList());
                }
            }
        } else {

            //单位端新增
            StringBuilder a = new StringBuilder();
            if (assetCurrent.getGlymList() != null) {
                assetCurrent.getGlymList().forEach(x -> {
                    if (!Objects.equals(x.getKey(), "") && x.getKey() != null) {
                        a.append(x.getKey());
                        a.append(",");
                    }
                });
            }
            assetCurrent.setGlym(a.toString());
            List<Acomma> a2 = new ArrayList<>();
            if (assetCurrent.getGlIpList() != null) {
                if (assetCurrent.getGlIp() != null && !assetCurrent.getGlIp().isEmpty()) {
                    for (Object o : JSONArray.parseArray(assetCurrent.getGlIp())) {
                        Acomma acomma = new Acomma();
                        JSONObject jsonObject = JSONObject.parseObject(o.toString());
                        if (BeanUtil.isNotEmpty(jsonObject.get("key"))) {
                            acomma.setKey(jsonObject.get("key").toString());
                        } else {
                            acomma.setKey("");
                        }
                        if (BeanUtil.isNotEmpty(jsonObject.get("ipType"))) {
                            acomma.setIpType(jsonObject.get("ipType").toString());
                        } else {
                            acomma.setIpType("");
                        }
                        Object portValue = jsonObject.get("port");
                        if (portValue != null && !portValue.toString().isEmpty()) {
                            acomma.setPort(portValue.toString());
                        } else {
                            acomma.setPort("");
                        }
                        a2.add(acomma);
                    }
                    assetCurrent.setGlIpList(a2);
                }

            } else {
                assetCurrent.setGlIpList(new ArrayList<>());
            }
            AssetCurrentZztbPo assetCurrentZztbPo = new AssetCurrentZztbPo();

            BeanUtils.copyProperties(assetCurrent, assetCurrentZztbPo);
            assetCurrentZztbPo.setAuditState("1");
            assetCurrentZztbPo.setAuditYy(null);

            assetCurrentZztbService.save(assetCurrentZztbPo);

            //新增新监管业务形态
            if (assetCurrent.getXjgywxt() != null) {
                AssetBusinessForm assetBusinessForm = assetCurrent.getXjgywxt();
                AssetBusinessFormZztbPo assetBusinessFormZztbPo = new AssetBusinessFormZztbPo();
                BeanUtils.copyProperties(assetBusinessForm, assetBusinessFormZztbPo);
                assetBusinessFormZztbPo.setAssetId(assetCurrentZztbPo.getCurrentId());
                assetBusinessFormZztbService.save(assetBusinessFormZztbPo);
            }
            if (assetCurrent.getGylxxList() != null) {
                List<AssetSupplyChainZztbPo> supplyChainZztbPos = assetCurrent.getGylxxList().stream().map(cpPo -> {
                    AssetSupplyChainZztbPo assetBasicNetworkZztbPo = new AssetSupplyChainZztbPo();
                    BeanUtils.copyProperties(cpPo, assetBasicNetworkZztbPo); // 复制属性
                    assetBasicNetworkZztbPo.setSupplyId(null);
                    assetBasicNetworkZztbPo.setAssetId(assetCurrentZztbPo.getCurrentId());
                    return assetBasicNetworkZztbPo; // 返回新对象
                }).collect(Collectors.toList());

                // 新增供应链
                boolean savedSuccessfully = assetSupplyChainZztbService.saveBatch(supplyChainZztbPos);
                if (!savedSuccessfully) {
                    // 处理保存失败的情况
                    System.err.println("保存供应链数据失败");
                }
            }
            if (assetCurrent.getJcwlList() != null) {
                List<AssetBasicNetworkZztbPo> networksCpPoList = assetCurrent.getJcwlList().stream().map(cpPo -> {
                    AssetBasicNetworkZztbPo assetBasicNetworkZztbPo = new AssetBasicNetworkZztbPo();
                    BeanUtils.copyProperties(cpPo, assetBasicNetworkZztbPo); // 复制属性
                    assetBasicNetworkZztbPo.setNetworkId(null);
                    assetBasicNetworkZztbPo.setAssetId(assetCurrentZztbPo.getCurrentId());
                    return assetBasicNetworkZztbPo; // 返回新对象
                }).collect(Collectors.toList());

                //新增基础网络
                assetBasicNetworkZztbService.saveBatch(networksCpPoList);
            }
            if (assetCurrent.getOtherConcat() != null) {
                List<UnitOtherConcatZztbPo> unitOtherConcatZztbPos = assetCurrent.getOtherConcat().stream().map(cpPo -> {
                    UnitOtherConcatZztbPo unitOtherConcatZztbPo = new UnitOtherConcatZztbPo();
                    BeanUtils.copyProperties(cpPo, unitOtherConcatZztbPo); // 复制属性
                    unitOtherConcatZztbPo.setUnitId(null);
                    unitOtherConcatZztbPo.setAssetId(assetCurrentZztbPo.getCurrentId());
                    return unitOtherConcatZztbPo; // 返回新对象
                }).collect(Collectors.toList());

                //新增其他联系人
                unitOtherConcatZztbservice.saveBatch(unitOtherConcatZztbPos);
            }

            if (assetCurrent.getSjzcList() != null) {
                List<AssetSjZztbPo> assetSjZztbPoList = assetCurrent.getSjzcList().stream().map(cpPo -> {
                    AssetSjZztbPo assetSjZztbPo = new AssetSjZztbPo();
                    BeanUtils.copyProperties(cpPo, assetSjZztbPo); // 复制属性
                    assetSjZztbPo.setSjId(null);
                    assetSjZztbPo.setAssetId(assetCurrentZztbPo.getCurrentId());
                    return assetSjZztbPo; // 返回新对象
                }).collect(Collectors.toList());

                //新增数据资产
                assetAssetSjZztbService.saveBatch(assetSjZztbPoList);
            }


        }


        return success();

    }
    //=================================================

    /**
     * 单位自编辑进行校验
     */
    @ApiOperation(value = "单位自编辑进行校验")
    @PreAuthorize("@ss.hasAnyRoles('unit')")
    @PostMapping("/unitEdit")
    public AjaxResult unitEdit(@RequestBody @Valid AssetCurrentZztbPo assetCurrentZztbPo) {
        List<Unit> list = unitService.lambdaQuery().eq(Unit::getNickName, assetCurrentZztbPo.getDwmc()).eq(Unit::getDelFlag, 0).list();
        if (list == null || list.isEmpty()) {
            throw new ServiceException("请选择已有单位!");
        }

        AssetCurrentZztbPo one = assetCurrentZztbService.lambdaQuery().eq(AssetCurrentZztbPo::getXtmc, assetCurrentZztbPo.getXtmc()).eq(AssetCurrentZztbPo::getDwmc, assetCurrentZztbPo.getDwmc()).isNull(AssetCurrentZztbPo::getTaskId).one();
        assetCurrentZztbPo.setAuditState("1");
        assetCurrentZztbPo.setAuditYy(null);
        if (one != null) {
            //编辑
            assetCurrentZztbPo.setCurrentId(one.getCurrentId());
            assetCurrentZztbService.updateById(assetCurrentZztbPo);
            QueryWrapper<AssetSupplyChainZztbPo> queryWrapper2 = new QueryWrapper<>();
            queryWrapper2.eq("asset_id", assetCurrentZztbPo.getId());
            queryWrapper2.isNull("task_id");
            assetSupplyChainZztbService.remove(queryWrapper2);

            QueryWrapper<AssetBasicNetworkZztbPo> queryWrapper3 = new QueryWrapper<>();
            queryWrapper3.eq("asset_id", assetCurrentZztbPo.getId());
            queryWrapper3.isNull("task_id");
            assetBasicNetworkZztbService.remove(queryWrapper3);

            QueryWrapper<AssetBusinessFormZztbPo> queryWrapper4 = new QueryWrapper<>();
            queryWrapper4.eq("asset_id", assetCurrentZztbPo.getId());
            queryWrapper4.isNull("task_id");
            assetBusinessFormZztbService.remove(queryWrapper4);
            QueryWrapper<UnitOtherConcatZztbPo> queryWrapper5 = new QueryWrapper<>();
            queryWrapper5.isNull("task_id");
            queryWrapper5.eq("asset_id", assetCurrentZztbPo.getId());
            unitOtherConcatZztbservice.remove(queryWrapper5);
            QueryWrapper<AssetSjZztbPo> queryWrapper6 = new QueryWrapper<>();
            queryWrapper6.isNull("task_id");
            queryWrapper6.eq("asset_id", assetCurrentZztbPo.getId());
            assetAssetSjZztbService.remove(queryWrapper6);

            if (assetCurrentZztbPo.getXjgywxt() != null) {

                AssetBusinessForm assetBusinessForm = assetCurrentZztbPo.getXjgywxt();
                AssetBusinessFormZztbPo assetBusinessFormZztbPo = new AssetBusinessFormZztbPo();
                BeanUtils.copyProperties(assetBusinessForm, assetBusinessFormZztbPo);
                assetBusinessFormZztbPo.setAssetId(assetCurrentZztbPo.getId());
                assetBusinessFormZztbService.save(assetBusinessFormZztbPo);
            }
            if (assetCurrentZztbPo.getGylxxList() != null) {
                for (AssetSupplyChainZztbPo items : assetCurrentZztbPo.getGylxxList()) {
                    items.setAssetId(assetCurrentZztbPo.getId());
                }
                //新增供应链
                assetSupplyChainZztbService.saveBatch(assetCurrentZztbPo.getGylxxList());
            }
            if (assetCurrentZztbPo.getJcwlList() != null) {
                for (AssetBasicNetworkZztbPo items : assetCurrentZztbPo.getJcwlList()) {
                    items.setAssetId(assetCurrentZztbPo.getId());
                }
                //新增基础网络
                assetBasicNetworkZztbService.saveBatch(assetCurrentZztbPo.getJcwlList());
            }
            if (assetCurrentZztbPo.getOtherConcat() != null) {
                for (UnitOtherConcatZztbPo items : assetCurrentZztbPo.getOtherConcat()) {
                    items.setAssetId(assetCurrentZztbPo.getId());
                }
                //新增其他联系人
                unitOtherConcatZztbservice.saveBatch(assetCurrentZztbPo.getOtherConcat());
            }

            if (assetCurrentZztbPo.getSjzcList() != null) {
                for (AssetSjZztbPo items : assetCurrentZztbPo.getSjzcList()) {
                    items.setAssetId(assetCurrentZztbPo.getId());
                }
                //新增数据资产
                assetAssetSjZztbService.saveBatch(assetCurrentZztbPo.getSjzcList());
            }

        } else {
            //新增
            assetCurrentZztbService.save(assetCurrentZztbPo);
            if (assetCurrentZztbPo.getXjgywxt() != null) {

                AssetBusinessForm assetBusinessForm = assetCurrentZztbPo.getXjgywxt();
                AssetBusinessFormZztbPo assetBusinessFormZztbPo = new AssetBusinessFormZztbPo();
                BeanUtils.copyProperties(assetBusinessForm, assetBusinessFormZztbPo);
                assetBusinessFormZztbPo.setAssetId(assetCurrentZztbPo.getCurrentId());
                assetBusinessFormZztbService.save(assetBusinessFormZztbPo);
            }
            if (assetCurrentZztbPo.getGylxxList() != null) {
                for (AssetSupplyChainZztbPo items : assetCurrentZztbPo.getGylxxList()) {
                    items.setAssetId(assetCurrentZztbPo.getId());
                }
                //新增供应链
                assetSupplyChainZztbService.saveBatch(assetCurrentZztbPo.getGylxxList());
            }
            if (assetCurrentZztbPo.getJcwlList() != null) {
                for (AssetBasicNetworkZztbPo items : assetCurrentZztbPo.getJcwlList()) {
                    items.setAssetId(assetCurrentZztbPo.getId());
                }
                //新增基础网络
                assetBasicNetworkZztbService.saveBatch(assetCurrentZztbPo.getJcwlList());
            }
            if (assetCurrentZztbPo.getOtherConcat() != null) {
                for (UnitOtherConcatZztbPo items : assetCurrentZztbPo.getOtherConcat()) {
                    items.setAssetId(assetCurrentZztbPo.getId());
                }
                //新增其他联系人
                unitOtherConcatZztbservice.saveBatch(assetCurrentZztbPo.getOtherConcat());
            }

            if (assetCurrentZztbPo.getSjzcList() != null) {
                for (AssetSjZztbPo items : assetCurrentZztbPo.getSjzcList()) {
                    items.setAssetId(assetCurrentZztbPo.getId());
                }
                //新增数据资产
                assetAssetSjZztbService.saveBatch(assetCurrentZztbPo.getSjzcList());
            }
        }

        return success();
    }

    /**
     * 分页查询管理端或者单位端审核列表
     *
     * @param as 查询实体
     * @return 所有数据
     */
    @ApiOperation(value = "分页查询管理端或者单位端审核列表", response = AssetCurrentZztbPo.class)
    @GetMapping("/getAuditList")
    public AjaxResult getAuditList(AssetAuditPageRequest as) {
        Page<AssetCurrentZztbPo> page = new Page<>();
        page.setSize(as.getSize());
        page.setCurrent(as.getCurrent());
        try {
            if (!SecurityUtils.getLoginUser().getUser().isAdmin() && !SecurityUtils.hasRole("common")) {
                as.setDwmc(SecurityUtils.getLoginUser().getUser().getNickName());
            }
        } catch (Exception e) {
            throw new ServiceException("获取用户信息异常");
        }
        return success(assetCurrentZztbService.getAuditList(page, as));
    }

    /**
     * 查看中间数据详情
     */
    @ApiOperation(value = "单位端查看中间数据详情", response = AssetCurrentZztbPo.class)
    @GetMapping("/lookInfo/{id}")
    public AjaxResult lookInfo(@PathVariable Long id) {
        AssetCurrentZztbPo byId = assetCurrentZztbService.getById(id);
        if (byId.getId() == null) {
            //单位段新增查看
            byId.setGylxxList(assetSupplyChainZztbService.lambdaQuery().eq(AssetSupplyChainZztbPo::getAssetId, byId.getCurrentId()).isNull(AssetSupplyChainZztbPo::getTaskId).list());
            byId.setJcwlList(assetBasicNetworkZztbService.lambdaQuery().eq(AssetBasicNetworkZztbPo::getAssetId, byId.getCurrentId()).isNull(AssetBasicNetworkZztbPo::getTaskId).list());
            AssetBusinessFormZztbPo assetBusinessFormZztbPo = assetBusinessFormZztbService.lambdaQuery().eq(AssetBusinessFormZztbPo::getAssetId, byId.getCurrentId()).isNull(AssetBusinessFormZztbPo::getTaskId).one();
            if (assetBusinessFormZztbPo != null) {
                AssetBusinessForm assetBusinessForm = new AssetBusinessForm();
                BeanUtils.copyProperties(assetBusinessFormZztbPo, assetBusinessForm);
                byId.setXjgywxt(assetBusinessForm);
            } else {
                byId.setXjgywxt(null);
            }
            byId.setOtherConcat(unitOtherConcatZztbservice.lambdaQuery().eq(UnitOtherConcatZztbPo::getAssetId, byId.getCurrentId()).isNull(UnitOtherConcatZztbPo::getTaskId).list());
            byId.setSjzcList(assetAssetSjZztbService.lambdaQuery().eq(AssetSjZztbPo::getAssetId, byId.getCurrentId()).isNull(AssetSjZztbPo::getTaskId).list());

        } else {
            //管理端新增查看
            byId.setGylxxList(assetSupplyChainZztbService.lambdaQuery().eq(AssetSupplyChainZztbPo::getAssetId, byId.getId()).isNull(AssetSupplyChainZztbPo::getTaskId).list());
            byId.setJcwlList(assetBasicNetworkZztbService.lambdaQuery().eq(AssetBasicNetworkZztbPo::getAssetId, byId.getId()).isNull(AssetBasicNetworkZztbPo::getTaskId).list());
            AssetBusinessFormZztbPo assetBusinessFormZztbPo = assetBusinessFormZztbService.lambdaQuery().eq(AssetBusinessFormZztbPo::getAssetId, byId.getId()).isNull(AssetBusinessFormZztbPo::getTaskId).one();
            if (assetBusinessFormZztbPo != null) {
                AssetBusinessForm assetBusinessForm = new AssetBusinessForm();
                BeanUtils.copyProperties(assetBusinessFormZztbPo, assetBusinessForm);
                byId.setXjgywxt(assetBusinessForm);
            } else {
                byId.setXjgywxt(null);
            }
            byId.setOtherConcat(unitOtherConcatZztbservice.lambdaQuery().eq(UnitOtherConcatZztbPo::getAssetId, byId.getId()).isNull(UnitOtherConcatZztbPo::getTaskId).list());
            byId.setSjzcList(assetAssetSjZztbService.lambdaQuery().eq(AssetSjZztbPo::getAssetId, byId.getId()).isNull(AssetSjZztbPo::getTaskId).list());

        }

        List<Acomma> a1 = new ArrayList<>();
        if (byId.getGlym() != null) {
            Arrays.asList(byId.getGlym().split(",")).forEach(x -> {
                Acomma acomma = new Acomma();
                acomma.setKey(x);
                a1.add(acomma);
            });
            byId.setGlymList(a1);
        } else {
            byId.setGlymList(new ArrayList<>());
        }
        List<Acomma> a2 = new ArrayList<>();
        if (byId.getGlIp() != null && !byId.getGlIp().isEmpty()) {
            for (Object o : JSONArray.parseArray(byId.getGlIp())) {
                Acomma acomma = new Acomma();
                JSONObject jsonObject = JSONObject.parseObject(o.toString());
                if (BeanUtil.isNotEmpty(jsonObject.get("key"))) {
                    acomma.setKey(jsonObject.get("key").toString());
                } else {
                    acomma.setKey("");
                }
                if (BeanUtil.isNotEmpty(jsonObject.get("ipType"))) {
                    acomma.setIpType(jsonObject.get("ipType").toString());
                } else {
                    acomma.setIpType("");
                }
                Object portValue = jsonObject.get("port");
                if (portValue != null && !portValue.toString().isEmpty()) {
                    acomma.setPort(portValue.toString());
                } else {
                    acomma.setPort("");
                }
                a2.add(acomma);
            }
            byId.setGlIpList(a2);
        } else {
            byId.setGlIpList(new ArrayList<>());
        }

        return success(byId);
    }

    /**
     * 管理端审核
     *
     * @param as 查询实体
     * @return 所有数据
     */
    @PreAuthorize("@ss.hasAnyRoles('admin,common')")
    @ApiOperation(value = "管理端审核")
    @PostMapping("/audit")
    public AjaxResult audit(@Valid @RequestBody AssetAuditRequest as) {
        AssetCurrentZztbPo ass = new AssetCurrentZztbPo();
        BeanUtil.copyProperties(as, ass);
        assetCurrentZztbService.updateById(ass);
        //通过数据同步
        if ("2".equals(as.getAuditState()) && as.getXzType() != 1) {
            AssetCurrentCpPo byId = assetCurrentCpService.getById(as.getCurrentId());
            AssetCurrent assetCurrent = new AssetCurrent();
            BeanUtil.copyProperties(byId, assetCurrent);
            //修改主表
            assetCurrent.setDelFlag("0");
            assetCurrentService.updateById(assetCurrent);
            //删除副表数据然后再添加
            assetSupplyChainService.deleteByAssetIds(assetCurrent.getId());
            assetBasicNetworkService.deleteByAssetIds(assetCurrent.getId());
            assetBusinessFormService.deleteByAssetIds(assetCurrent.getId());
            unitOtherConcatService.deleteByAssetIds(assetCurrent.getId());
            assetAssetSjService.deleteByAssetIds(assetCurrent.getId());
            List<AssetSupplyChainCpPo> list = assetSupplyChainCpService.lambdaQuery().eq(AssetSupplyChainCpPo::getAssetId, byId.getId()).isNull(AssetSupplyChainCpPo::getTaskId).list();
            list.forEach(x -> {
                AssetSupplyChain a1 = new AssetSupplyChain();
                BeanUtil.copyProperties(x, a1);
                assetSupplyChainService.save(a1);
            });

            List<AssetBasicNetworkCpPo> list1 = assetBasicNetworkCpService.lambdaQuery().eq(AssetBasicNetworkCpPo::getAssetId, byId.getId()).isNull(AssetBasicNetworkCpPo::getTaskId).list();
            list1.forEach(x -> {
                AssetBasicNetwork a2 = new AssetBasicNetwork();
                BeanUtil.copyProperties(x, a2);
                assetBasicNetworkService.save(a2);
            });

            List<AssetBusinessFormCpPo> list2 = assetBusinessFormCpService.lambdaQuery().eq(AssetBusinessFormCpPo::getAssetId, byId.getId()).isNull(AssetBusinessFormCpPo::getTaskId).list();
            list2.forEach(x -> {
                AssetBusinessForm a3 = new AssetBusinessForm();
                BeanUtil.copyProperties(x, a3);
                assetBusinessFormService.save(a3);
            });

            List<UnitOtherConcatCpPo> list3 = unitOtherConcatCpService.lambdaQuery().eq(UnitOtherConcatCpPo::getAssetId, byId.getId()).isNull(UnitOtherConcatCpPo::getTaskId).list();
            list3.forEach(x -> {
                UnitOtherConcat a4 = new UnitOtherConcat();
                BeanUtil.copyProperties(x, a4);
                unitOtherConcatService.save(a4);
            });
            //如果有任务也修改任务这边
            AssetCurrentCpPo one = assetCurrentCpService.lambdaQuery().isNotNull(AssetCurrentCpPo::getTaskId).ne(AssetCurrentCpPo::getStatus, 5).
                    eq(AssetCurrentCpPo::getId, byId.getId())
                    .orderByDesc(AssetCurrentCpPo::getCurrentId)
                    .last("LIMIT 1").one();
            if (one != null) {
                //根据任务id查询任务是否关闭
                AssetTask two = assetTaskService.lambdaQuery().eq(AssetTask::getId, one.getTaskId()).eq(AssetTask::getTaskStatus, 0).one();
                if (two == null) {
                    Integer taskId = one.getTaskId();
                    Long appId = one.getCurrentId();
                    Integer status = one.getStatus();
                    BeanUtil.copyProperties(byId, one);
                    one.setCurrentId(appId);
                    one.setTaskId(taskId);
                    one.setAuditState(null);
                    one.setAuditYy(null);
                    one.setStatus(status);
                    assetCurrentCpService.updateById(one);

                    QueryWrapper<AssetSupplyChainCpPo> queryWrapper2 = new QueryWrapper<>();
                    queryWrapper2.eq("asset_id", one.getId());
                    queryWrapper2.eq("task_id", taskId);
                    assetSupplyChainCpService.remove(queryWrapper2);
                    QueryWrapper<AssetBasicNetworkCpPo> queryWrapper3 = new QueryWrapper<>();
                    queryWrapper3.eq("asset_id", one.getId());
                    queryWrapper3.eq("task_id", taskId);
                    assetBasicNetworkCpService.remove(queryWrapper3);
                    QueryWrapper<AssetBusinessFormCpPo> queryWrapper4 = new QueryWrapper<>();
                    queryWrapper4.eq("asset_id", one.getId());
                    queryWrapper4.eq("task_id", taskId);
                    assetBusinessFormCpService.remove(queryWrapper4);
                    QueryWrapper<UnitOtherConcatCpPo> queryWrapper5 = new QueryWrapper<>();
                    queryWrapper5.eq("task_id", taskId);
                    queryWrapper5.eq("asset_id", one.getId());
                    unitOtherConcatCpService.remove(queryWrapper5);
                    list.forEach(x -> {
                        x.setTaskId(taskId);
                        assetSupplyChainCpService.save(x);
                    });
                    list1.forEach(x -> {
                        x.setTaskId(taskId);
                        assetBasicNetworkCpService.save(x);
                    });
                    list2.forEach(x -> {
                        x.setTaskId(taskId);
                        assetBusinessFormCpService.save(x);
                    });
                    list3.forEach(x -> {
                        x.setTaskId(taskId);
                        unitOtherConcatCpService.save(x);
                    });
                }

            }
        } else if ("2".equals(as.getAuditState())) {
            AssetCurrentZztbPo byId = assetCurrentZztbService.getById(as.getCurrentId());
            AssetCurrent aa = new AssetCurrent();
            BeanUtil.copyProperties(byId, aa);
            //根据资产名称和所属单位查询主表是否有数据
            AssetCurrent assetCurrent = assetCurrentService.lambdaQuery().eq(AssetCurrent::getXtmc, byId.getXtmc()).eq(AssetCurrent::getDwmc, byId.getDwmc()).one();
            if (assetCurrent != null) {
                //修改主表
                if (assetCurrent.getXzType() == 0) {
                    BeanUtil.copyProperties(aa, assetCurrent, "id");
                    assetCurrent.setXzType(0);
                    assetCurrent.setDelFlag("0");
                    assetCurrent.setBtgyy(null);
                    assetCurrentService.updateById(assetCurrent);
                } else {
                    BeanUtil.copyProperties(aa, assetCurrent, "id");
                    assetCurrent.setDelFlag("0");
                    assetCurrent.setBtgyy(null);
                    assetCurrentService.updateById(assetCurrent);
                }

                //删除子表数据
                assetSupplyChainService.deleteByAssetIds(assetCurrent.getId());
                assetBasicNetworkService.deleteByAssetIds(assetCurrent.getId());
                assetBusinessFormService.deleteByAssetIds(assetCurrent.getId());
                unitOtherConcatService.deleteByAssetIds(assetCurrent.getId());
                assetAssetSjService.deleteByAssetIds(assetCurrent.getId());
                //供应链
                List<AssetSupplyChainZztbPo> supplyChainZztbPoList = assetSupplyChainZztbService.lambdaQuery().eq(AssetSupplyChainZztbPo::getAssetId, byId.getId()).isNull(AssetSupplyChainZztbPo::getTaskId).list();
                List<AssetSupplyChain> assetSupplyChainList = supplyChainZztbPoList.stream().map(cpPo -> {
                    AssetSupplyChain assetSupplyChain = new AssetSupplyChain();
                    BeanUtils.copyProperties(cpPo, assetSupplyChain); // 复制属性
                    assetSupplyChain.setId(null);
                    assetSupplyChain.setAssetId(aa.getId());
                    return assetSupplyChain; // 返回新对象
                }).collect(Collectors.toList());
                assetSupplyChainService.saveBatch(assetSupplyChainList);

                //newtwork
                List<AssetBasicNetworkZztbPo> networkZztbPoList = assetBasicNetworkZztbService.lambdaQuery().eq(AssetBasicNetworkZztbPo::getAssetId, byId.getId()).isNull(AssetBasicNetworkZztbPo::getTaskId).list();
                List<AssetBasicNetwork> networkList = networkZztbPoList.stream().map(cpPo -> {
                    AssetBasicNetwork assetBasicNetwork = new AssetBasicNetwork();
                    BeanUtils.copyProperties(cpPo, assetBasicNetwork); // 复制属性
                    assetBasicNetwork.setId(null);
                    assetBasicNetwork.setAssetId(aa.getId());
                    return assetBasicNetwork; // 返回新对象
                }).collect(Collectors.toList());
                assetBasicNetworkService.saveBatch(networkList);

                //business
                List<AssetBusinessFormZztbPo> businessFormZztbPoList = assetBusinessFormZztbService.lambdaQuery().eq(AssetBusinessFormZztbPo::getAssetId, byId.getId()).isNull(AssetBusinessFormZztbPo::getTaskId).list();
                List<AssetBusinessForm> businessFormList = businessFormZztbPoList.stream().map(cpPo -> {
                    AssetBusinessForm assetBusinessForm = new AssetBusinessForm();
                    BeanUtils.copyProperties(cpPo, assetBusinessForm); // 复制属性
                    assetBusinessForm.setId(null);
                    assetBusinessForm.setAssetId(aa.getId());
                    return assetBusinessForm; // 返回新对象
                }).collect(Collectors.toList());
                assetBusinessFormService.saveBatch(businessFormList);


                //unitother
                List<UnitOtherConcatZztbPo> unitOtherConcatZztbPoList = unitOtherConcatZztbservice.lambdaQuery().eq(UnitOtherConcatZztbPo::getAssetId, byId.getId()).isNull(UnitOtherConcatZztbPo::getTaskId).list();
                List<UnitOtherConcat> unitOtherConcatList = unitOtherConcatZztbPoList.stream().map(cpPo -> {
                    UnitOtherConcat unitOtherConcat = new UnitOtherConcat();
                    BeanUtils.copyProperties(cpPo, unitOtherConcat); // 复制属性
                    unitOtherConcat.setConcatId(null);
                    unitOtherConcat.setAssetId(aa.getId());
                    return unitOtherConcat; // 返回新对象
                }).collect(Collectors.toList());
                unitOtherConcatService.saveBatch(unitOtherConcatList);

                //数据资产
                List<AssetSjZztbPo> assetSjZztbPoList = assetAssetSjZztbService.lambdaQuery().eq(AssetSjZztbPo::getAssetId, byId.getId()).isNull(AssetSjZztbPo::getTaskId).list();
                List<AssetSj> assetSjList = assetSjZztbPoList.stream().map(cpPo -> {
                    AssetSj assetSj = new AssetSj();
                    BeanUtils.copyProperties(cpPo, assetSj); // 复制属性
                    assetSj.setId(null);
                    assetSj.setAssetId(aa.getId());
                    return assetSj; // 返回新对象
                }).collect(Collectors.toList());
                assetAssetSjService.saveBatch(assetSjList);
                //如果有任务也修改任务这边
                AssetCurrentCpPo one = assetCurrentCpService.lambdaQuery()
                        .isNotNull(AssetCurrentCpPo::getTaskId)
                        .ne(AssetCurrentCpPo::getStatus, 5)
                        .eq(AssetCurrentCpPo::getId, byId.getId())
                        .orderByDesc(AssetCurrentCpPo::getCurrentId)
                        .last("LIMIT 1")
                        .one();

                if (one != null) {
                    //根据任务id查询任务是否关闭
                    AssetTask two = assetTaskService.lambdaQuery().eq(AssetTask::getId, one.getTaskId()).eq(AssetTask::getTaskStatus, 0).one();
                    if (two == null) {
                        Integer taskId = one.getTaskId();
                        Long appId = one.getCurrentId();
                        Integer status = one.getStatus();
                        BeanUtil.copyProperties(byId, one);
                        one.setCurrentId(appId);
                        one.setTaskId(taskId);
                        one.setAuditState(null);
                        one.setAuditYy(null);
                        one.setStatus(status);
                        assetCurrentCpService.updateById(one);
                        //删除子表数据
                        QueryWrapper<AssetSupplyChainCpPo> queryWrapper2 = new QueryWrapper<>();
                        queryWrapper2.eq("asset_id", one.getId());
                        queryWrapper2.eq("task_id", taskId);
                        assetSupplyChainCpService.remove(queryWrapper2);
                        QueryWrapper<AssetBasicNetworkCpPo> queryWrapper3 = new QueryWrapper<>();
                        queryWrapper3.eq("asset_id", one.getId());
                        queryWrapper3.eq("task_id", taskId);
                        assetBasicNetworkCpService.remove(queryWrapper3);
                        QueryWrapper<AssetBusinessFormCpPo> queryWrapper4 = new QueryWrapper<>();
                        queryWrapper4.eq("asset_id", one.getId());
                        queryWrapper4.eq("task_id", taskId);
                        assetBusinessFormCpService.remove(queryWrapper4);
                        QueryWrapper<UnitOtherConcatCpPo> queryWrapper5 = new QueryWrapper<>();
                        queryWrapper5.eq("task_id", taskId);
                        queryWrapper5.eq("asset_id", one.getId());
                        unitOtherConcatCpService.remove(queryWrapper5);
                        QueryWrapper<AssetSjCpPo> queryWrapper6 = new QueryWrapper<>();
                        queryWrapper6.eq("task_id", taskId);
                        queryWrapper6.eq("asset_id", one.getId());
                        assetAssetSjCpService.remove(queryWrapper6);
                        List<AssetSupplyChainZztbPo> list = assetSupplyChainZztbService.lambdaQuery().eq(AssetSupplyChainZztbPo::getAssetId, byId.getId()).isNull(AssetSupplyChainZztbPo::getTaskId).list();
                        list.forEach(x -> {
                            AssetSupplyChainCpPo a1 = new AssetSupplyChainCpPo();
                            BeanUtil.copyProperties(x, a1);
                            a1.setTaskId(taskId);
                            a1.setSupplyId(null);
                            assetSupplyChainCpService.save(a1);
                        });

                        List<AssetBasicNetworkZztbPo> list1 = assetBasicNetworkZztbService.lambdaQuery().eq(AssetBasicNetworkZztbPo::getAssetId, byId.getId()).isNull(AssetBasicNetworkZztbPo::getTaskId).list();
                        list1.forEach(x -> {
                            AssetBasicNetworkCpPo a2 = new AssetBasicNetworkCpPo();
                            BeanUtil.copyProperties(x, a2);
                            a2.setTaskId(taskId);
                            a2.setNetworkId(null);
                            assetBasicNetworkCpService.save(a2);
                        });

                        List<AssetBusinessFormZztbPo> list2 = assetBusinessFormZztbService.lambdaQuery().eq(AssetBusinessFormZztbPo::getAssetId, byId.getId()).isNull(AssetBusinessFormZztbPo::getTaskId).list();
                        list2.forEach(x -> {
                            AssetBusinessFormCpPo a3 = new AssetBusinessFormCpPo();
                            BeanUtil.copyProperties(x, a3);
                            a3.setTaskId(taskId);
                            a3.setBusinessId(null);
                            assetBusinessFormCpService.save(a3);
                        });

                        List<UnitOtherConcatZztbPo> list3 = unitOtherConcatZztbservice.lambdaQuery().eq(UnitOtherConcatZztbPo::getAssetId, byId.getId()).isNull(UnitOtherConcatZztbPo::getTaskId).list();
                        list3.forEach(x -> {
                            UnitOtherConcatCpPo a4 = new UnitOtherConcatCpPo();
                            BeanUtil.copyProperties(x, a4);
                            a4.setTaskId(taskId);
                            a4.setConcatId(null);
                            unitOtherConcatCpService.save(a4);
                        });
                        List<AssetSjZztbPo> list4 = assetAssetSjZztbService.lambdaQuery().eq(AssetSjZztbPo::getAssetId, byId.getId()).isNull(AssetSjZztbPo::getTaskId).list();
                        list4.forEach(x -> {
                            AssetSjCpPo a5 = new AssetSjCpPo();
                            BeanUtil.copyProperties(x, a5);
                            a5.setTaskId(taskId);
                            a5.setSjId(null);
                            assetAssetSjCpService.save(a5);
                        });
                    }

                }

            } else {
                //新增主表
                assetCurrentService.save(aa);
                //供应链
                List<AssetSupplyChainZztbPo> assetSupplyChainZztbPoList = assetSupplyChainZztbService.lambdaQuery().eq(AssetSupplyChainZztbPo::getAssetId, byId.getCurrentId()).isNull(AssetSupplyChainZztbPo::getTaskId).list();
                List<AssetSupplyChain> assetSupplyChainList1 = assetSupplyChainZztbPoList.stream().map(cpPo -> {
                    AssetSupplyChain assetSupplyChain = new AssetSupplyChain();
                    BeanUtils.copyProperties(cpPo, assetSupplyChain); // 复制属性
                    assetSupplyChain.setId(null);
                    assetSupplyChain.setAssetId(aa.getId());
                    return assetSupplyChain; // 返回新对象
                }).collect(Collectors.toList());
                assetSupplyChainService.saveBatch(assetSupplyChainList1);

                //newtwork
                List<AssetBasicNetworkZztbPo> networkZztbPoList1 = assetBasicNetworkZztbService.lambdaQuery().eq(AssetBasicNetworkZztbPo::getAssetId, byId.getCurrentId()).isNull(AssetBasicNetworkZztbPo::getTaskId).list();
                List<AssetBasicNetwork> networkList1 = networkZztbPoList1.stream().map(cpPo -> {
                    AssetBasicNetwork assetBasicNetwork = new AssetBasicNetwork();
                    BeanUtils.copyProperties(cpPo, assetBasicNetwork); // 复制属性
                    assetBasicNetwork.setId(null);
                    assetBasicNetwork.setAssetId(aa.getId());
                    return assetBasicNetwork; // 返回新对象
                }).collect(Collectors.toList());
                assetBasicNetworkService.saveBatch(networkList1);

                //business
                List<AssetBusinessFormZztbPo> businessFormZztbPoList1 = assetBusinessFormZztbService.lambdaQuery().eq(AssetBusinessFormZztbPo::getAssetId, byId.getCurrentId()).isNull(AssetBusinessFormZztbPo::getTaskId).list();
                List<AssetBusinessForm> businessFormList1 = businessFormZztbPoList1.stream().map(cpPo -> {
                    AssetBusinessForm assetBusinessForm = new AssetBusinessForm();
                    BeanUtils.copyProperties(cpPo, assetBusinessForm); // 复制属性
                    assetBusinessForm.setId(null);
                    assetBusinessForm.setAssetId(aa.getId());
                    return assetBusinessForm; // 返回新对象
                }).collect(Collectors.toList());
                assetBusinessFormService.saveBatch(businessFormList1);


                //unitother
                List<UnitOtherConcatZztbPo> unitOtherConcatZztbPoList1 = unitOtherConcatZztbservice.lambdaQuery().eq(UnitOtherConcatZztbPo::getAssetId, byId.getCurrentId()).isNull(UnitOtherConcatZztbPo::getTaskId).list();
                List<UnitOtherConcat> unitOtherConcatList1 = unitOtherConcatZztbPoList1.stream().map(cpPo -> {
                    UnitOtherConcat unitOtherConcat = new UnitOtherConcat();
                    BeanUtils.copyProperties(cpPo, unitOtherConcat); // 复制属性
                    unitOtherConcat.setConcatId(null);
                    unitOtherConcat.setAssetId(aa.getId());
                    return unitOtherConcat; // 返回新对象
                }).collect(Collectors.toList());
                unitOtherConcatService.saveBatch(unitOtherConcatList1);

                //数据资产
                List<AssetSjZztbPo> assetSjZztbPoList1 = assetAssetSjZztbService.lambdaQuery().eq(AssetSjZztbPo::getAssetId, byId.getCurrentId()).isNull(AssetSjZztbPo::getTaskId).list();
                List<AssetSj> assetSjList1 = assetSjZztbPoList1.stream().map(cpPo -> {
                    AssetSj assetSj = new AssetSj();
                    BeanUtils.copyProperties(cpPo, assetSj); // 复制属性
                    assetSj.setId(null);
                    assetSj.setAssetId(aa.getId());
                    return assetSj; // 返回新对象
                }).collect(Collectors.toList());
                assetAssetSjService.saveBatch(assetSjList1);

                //查询改单位下是否有进行中的任务
                AssetTask task = assetTaskService.lambdaQuery().like(AssetTask::getDwmc, aa.getDwmc()).like(AssetTask::getType, "1").eq(AssetTask::getTaskStatus, 1).one();
                if (task != null) {
                    AssetCurrentCpPo bb = new AssetCurrentCpPo();
                    BeanUtil.copyProperties(byId, bb);
                    bb.setId(aa.getId());
                    bb.setTaskId(task.getId());
                    bb.setCurrentId(null);
                    assetCurrentCpService.save(bb);

                    //供应链
                    List<AssetSupplyChainCpPo> assetSupplyChainCpPos = assetSupplyChainZztbPoList.stream().map(cpPo -> {
                        AssetSupplyChainCpPo assetSupplyChainCpPo = new AssetSupplyChainCpPo();
                        BeanUtils.copyProperties(cpPo, assetSupplyChainCpPo); // 复制属性
                        assetSupplyChainCpPo.setSupplyId(null);
                        assetSupplyChainCpPo.setAssetId(aa.getId());
                        assetSupplyChainCpPo.setTaskId(task.getId());
                        return assetSupplyChainCpPo; // 返回新对象
                    }).collect(Collectors.toList());
                    assetSupplyChainCpService.saveBatch(assetSupplyChainCpPos);
                    //netWork
                    List<AssetBasicNetworkCpPo> networkCpPos = networkZztbPoList1.stream().map(cpPo -> {
                        AssetBasicNetworkCpPo assetBasicNetworkCpPo = new AssetBasicNetworkCpPo();
                        BeanUtils.copyProperties(cpPo, assetBasicNetworkCpPo); // 复制属性
                        assetBasicNetworkCpPo.setNetworkId(null);
                        assetBasicNetworkCpPo.setAssetId(aa.getId());
                        assetBasicNetworkCpPo.setTaskId(task.getId());
                        return assetBasicNetworkCpPo; // 返回新对象
                    }).collect(Collectors.toList());
                    assetBasicNetworkCpService.saveBatch(networkCpPos);

                    //bussiness
                    List<AssetBusinessFormCpPo> businessFormCpPos = businessFormZztbPoList1.stream().map(cpPo -> {
                        AssetBusinessFormCpPo assetBusinessFormCpPo = new AssetBusinessFormCpPo();
                        BeanUtils.copyProperties(cpPo, assetBusinessFormCpPo); // 复制属性
                        assetBusinessFormCpPo.setBusinessId(null);
                        assetBusinessFormCpPo.setAssetId(aa.getId());
                        assetBusinessFormCpPo.setTaskId(task.getId());
                        return assetBusinessFormCpPo; // 返回新对象
                    }).collect(Collectors.toList());
                    assetBusinessFormCpService.saveBatch(businessFormCpPos);

                    //unitother
                    List<UnitOtherConcatCpPo> unitOtherConcatCpPos = unitOtherConcatZztbPoList1.stream().map(cpPo -> {
                        UnitOtherConcatCpPo unitOtherConcatCpPo = new UnitOtherConcatCpPo();
                        BeanUtils.copyProperties(cpPo, unitOtherConcatCpPo); // 复制属性
                        unitOtherConcatCpPo.setConcatId(null);
                        unitOtherConcatCpPo.setAssetId(aa.getId());
                        unitOtherConcatCpPo.setTaskId(task.getId());
                        return unitOtherConcatCpPo; // 返回新对象
                    }).collect(Collectors.toList());
                    unitOtherConcatCpService.saveBatch(unitOtherConcatCpPos);

                    //数据资产
                    List<AssetSjCpPo> assetSjCpPos = assetSjZztbPoList1.stream().map(cpPo -> {
                        AssetSjCpPo assetSjCpPo = new AssetSjCpPo();
                        BeanUtils.copyProperties(cpPo, assetSjCpPo); // 复制属性
                        assetSjCpPo.setSjId(null);
                        assetSjCpPo.setTaskId(task.getId());
                        assetSjCpPo.setAssetId(aa.getId());
                        return assetSjCpPo; // 返回新对象
                    }).collect(Collectors.toList());
                    assetAssetSjCpService.saveBatch(assetSjCpPos);
                }
            }


        } else if ("3".equals(as.getAuditState())) {
            //审核不通过
            AssetCurrentZztbPo byId = assetCurrentZztbService.getById(as.getCurrentId());
            AssetCurrent aa = new AssetCurrent();
            BeanUtil.copyProperties(byId, aa);
            //根据资产名称和所属单位查询主表是否有数据
            AssetCurrent assetCurrent = assetCurrentService.lambdaQuery().eq(AssetCurrent::getXtmc, byId.getXtmc()).eq(AssetCurrent::getDwmc, byId.getDwmc()).one();
            if (assetCurrent != null) {
                //修改主表
                if (assetCurrent.getXzType() == 0) {
                    BeanUtil.copyProperties(aa, assetCurrent, "id");
                    assetCurrent.setXzType(0);
                    assetCurrent.setDelFlag("1");
                    assetCurrentService.updateById(assetCurrent);
                } else {
                    BeanUtil.copyProperties(aa, assetCurrent, "id");
                    assetCurrent.setDelFlag("1");
                    assetCurrentService.updateById(assetCurrent);
                }
            }
        }
        return success();
    }


    /**
     * 修改数据
     *
     * @param assetCurrent 实体对象
     * @return 修改结果
     */
    @ApiOperation(value = "修改数据")
    @PreAuthorize("@ss.hasAnyRoles('admin,common')")
    @PutMapping
    public AjaxResult update(@RequestBody @Valid AssetCurrent assetCurrent) {

        List<Unit> list = unitService.lambdaQuery().eq(Unit::getNickName, assetCurrent.getDwmc()).eq(Unit::getDelFlag, 0).list();
        if (list == null || list.isEmpty()) {
            throw new ServiceException("请选择已有单位!");
        }
        //保存未修改之前的单位名称
//        AssetCurrent byId = assetCurrentService.getById(assetCurrent.getId());
        StringBuilder a = new StringBuilder();
        if (assetCurrent.getGlymList() != null) {
            assetCurrent.getGlymList().forEach(x -> {
                if (!Objects.equals(x.getKey(), "") && x.getKey() != null) {
                    a.append(x.getKey());
                    a.append(",");
                }
            });
        }
        assetCurrent.setGlym(a.toString());
        List<Acomma> a2 = new ArrayList<>();
        if (assetCurrent.getGlIpList() != null) {
            if (assetCurrent.getGlIp() != null && !assetCurrent.getGlIp().isEmpty()) {
                for (Object o : JSONArray.parseArray(assetCurrent.getGlIp())) {
                    Acomma acomma = new Acomma();
                    JSONObject jsonObject = JSONObject.parseObject(o.toString());
                    if (BeanUtil.isNotEmpty(jsonObject.get("key"))) {
                        acomma.setKey(jsonObject.get("key").toString());
                    } else {
                        acomma.setKey("");
                    }
                    if (BeanUtil.isNotEmpty(jsonObject.get("ipType"))) {
                        acomma.setIpType(jsonObject.get("ipType").toString());
                    } else {
                        acomma.setIpType("");
                    }
                    Object portValue = jsonObject.get("port");
                    if (portValue != null && !portValue.toString().isEmpty()) {
                        acomma.setPort(portValue.toString());
                    } else {
                        acomma.setPort("");
                    }
                    a2.add(acomma);
                }
                assetCurrent.setGlIpList(a2);
            }

        } else {
            assetCurrent.setGlIpList(new ArrayList<>());
        }

        if (!assetCurrent.getXtzt().equals("7")) {
            assetCurrent.setBtgyy(null);
        }

        assetCurrentService.updateById(assetCurrent);

        assetSupplyChainService.deleteByAssetIds(assetCurrent.getId());
        assetBasicNetworkService.deleteByAssetIds(assetCurrent.getId());
        assetBusinessFormService.deleteByAssetIds(assetCurrent.getId());
        unitOtherConcatService.deleteByAssetIds(assetCurrent.getId());
        assetAssetSjService.deleteByAssetIds(assetCurrent.getId());
        if (assetCurrent.getXjgywxt() != null) {
            assetCurrent.getXjgywxt().setAssetId(assetCurrent.getId());
            assetCurrent.getXjgywxt().setId(null);
            assetBusinessFormService.save(assetCurrent.getXjgywxt());
        }
        if (assetCurrent.getGylxxList() != null) {
            for (AssetSupplyChain items : assetCurrent.getGylxxList()) {
                items.setAssetId(assetCurrent.getId());
                items.setId(null);
            }
            //新增供应链
            assetSupplyChainService.saveBatch(assetCurrent.getGylxxList());
        }
        if (assetCurrent.getJcwlList() != null) {
            for (AssetBasicNetwork items : assetCurrent.getJcwlList()) {
                items.setAssetId(assetCurrent.getId());
                items.setId(null);
            }
            //新增基础网络
            assetBasicNetworkService.saveBatch(assetCurrent.getJcwlList());
        }
        if (assetCurrent.getOtherConcat() != null) {
            for (UnitOtherConcat items : assetCurrent.getOtherConcat()) {
                items.setAssetId(assetCurrent.getId());
                items.setConcatId(null);
            }
            //新增其他联系人
            unitOtherConcatService.saveBatch(assetCurrent.getOtherConcat());
        }


        if (assetCurrent.getSjzcList() != null) {
            for (AssetSj items : assetCurrent.getSjzcList()) {
                items.setAssetId(assetCurrent.getId());
                items.setId(null);
            }
            //新增数据资产
            assetAssetSjService.saveBatch(assetCurrent.getSjzcList());
        }

        //================================

        //根据未修改之前的单位名称去寻找正在进行中的任务,报废的任务,单位自编辑的任务
        List<AssetCurrentCpPo> list1 = assetCurrentCpService.lambdaQuery().eq(AssetCurrentCpPo::getId, assetCurrent.getId()).list();
        list1.forEach(x -> {
            Integer taskId = x.getTaskId();
            Long currentId = x.getCurrentId();
            Integer status = x.getStatus();
            String auditState = x.getAuditState();
            String auditYy = x.getAuditYy();
            AssetCurrentCpPo assetCurrentCpPo = new AssetCurrentCpPo();
            BeanUtil.copyProperties(assetCurrent, assetCurrentCpPo);
            assetCurrentCpPo.setTaskId(taskId);
            assetCurrentCpPo.setCurrentId(currentId);
            assetCurrentCpPo.setStatus(status);
            assetCurrentCpPo.setAuditState(auditState);
            assetCurrentCpPo.setAuditYy(auditYy);
            assetCurrentCpService.updateById(assetCurrentCpPo);

            QueryWrapper<AssetSupplyChainCpPo> queryWrapper2 = new QueryWrapper<>();
            queryWrapper2.eq("asset_id", assetCurrent.getId());
            if (taskId == null) {
                queryWrapper2.isNull("task_id");
            } else {
                queryWrapper2.eq("task_id", taskId);
            }
            assetSupplyChainCpService.remove(queryWrapper2);
            QueryWrapper<AssetBasicNetworkCpPo> queryWrapper3 = new QueryWrapper<>();
            if (taskId == null) {
                queryWrapper3.isNull("task_id");
            } else {
                queryWrapper3.eq("task_id", taskId);
            }
            queryWrapper3.eq("asset_id", assetCurrent.getId());
            assetBasicNetworkCpService.remove(queryWrapper3);
            QueryWrapper<AssetBusinessFormCpPo> queryWrapper4 = new QueryWrapper<>();
            if (taskId == null) {
                queryWrapper4.isNull("task_id");
            } else {
                queryWrapper4.eq("task_id", taskId);
            }
            queryWrapper4.eq("asset_id", assetCurrent.getId());
            assetBusinessFormCpService.remove(queryWrapper4);
            QueryWrapper<UnitOtherConcatCpPo> queryWrapper5 = new QueryWrapper<>();
            queryWrapper5.eq("asset_id", assetCurrent.getId());
            if (taskId == null) {
                queryWrapper5.isNull("task_id");
            } else {
                queryWrapper5.eq("task_id", taskId);
            }
            unitOtherConcatCpService.remove(queryWrapper5);


            QueryWrapper<AssetSjCpPo> queryWrapper6 = new QueryWrapper<>();
            queryWrapper5.eq("asset_id", assetCurrent.getId());
            if (taskId == null) {
                queryWrapper5.isNull("task_id");
            } else {
                queryWrapper5.eq("task_id", taskId);
            }
            assetAssetSjCpService.remove(queryWrapper6);

            if (assetCurrent.getXjgywxt() != null) {
                assetCurrentCpPo.getXjgywxt().setAssetId(assetCurrent.getId());
                assetCurrentCpPo.getXjgywxt().setTaskId(taskId);
                assetBusinessFormCpService.save(assetCurrentCpPo.getXjgywxt());
            }
            if (assetCurrent.getGylxxList() != null) {
                for (AssetSupplyChainCpPo items : assetCurrentCpPo.getGylxxList()) {
                    items.setAssetId(assetCurrent.getId());
                    items.setTaskId(taskId);
                }
                //新增供应链
                assetSupplyChainCpService.saveBatch(assetCurrentCpPo.getGylxxList());
            }
            if (assetCurrent.getJcwlList() != null) {
                for (AssetBasicNetworkCpPo items : assetCurrentCpPo.getJcwlList()) {
                    items.setAssetId(assetCurrent.getId());
                    items.setTaskId(taskId);
                }
                //新增基础网络
                assetBasicNetworkCpService.saveBatch(assetCurrentCpPo.getJcwlList());
            }
            if (assetCurrent.getOtherConcat() != null) {
                for (UnitOtherConcatCpPo items : assetCurrentCpPo.getOtherConcat()) {
                    items.setAssetId(assetCurrent.getId());
                    items.setTaskId(taskId);
                }
                //新增其他联系人
                unitOtherConcatCpService.saveBatch(assetCurrentCpPo.getOtherConcat());
            }

            if (assetCurrent.getSjzcList() != null) {
                for (AssetSjCpPo items : assetCurrentCpPo.getSjzcList()) {
                    items.setAssetId(assetCurrent.getId());
                    items.setTaskId(taskId);
                }
                //新增其他联系人
                assetAssetSjCpService.saveBatch(assetCurrentCpPo.getSjzcList());
            }
        });
        //根据资产id查询资产子表,判断是否有此资产进行中的任务,如果资产状态是已关停与修改的数据不符，则修改任务中的资产状态
        List<AssetCurrentCpPo> currentCpPo = assetCurrentCpService.findDwmc(assetCurrent.getId());
        if (currentCpPo != null) {
            for (AssetCurrentCpPo s : currentCpPo) {
                //查询任务是否为进行中
                AssetTask assetTask = assetTaskService.findByTaskId(s.getTaskId());
                if (assetTask != null) {
                    if (assetTask.getTaskStatus().equals(1)) {
                        //修改任务中资产状态
                        s.setStatus(0);
                        s.setBfyy(null);
                        s.setBtgyy(null);
                        assetTask.setTaskStatus(1);
                        assetTaskService.update(assetTask);
                        s.setCurrentId(s.getCurrentId());
                        s.setUpdateTime(null);
                        assetCurrentCpService.updateById(s);

                    }
                }

            }

        }

        return success();
    }

    private void delete(AssetCurrent assetCurrent) {
        assetCurrentCpService.deletByAssetId(assetCurrent.getId());
        assetBasicNetworkCpService.deletByAssetId(assetCurrent.getId());
        assetSupplyChainCpService.deletByAssetId(assetCurrent.getId());
        unitOtherConcatCpService.deletByAssetId(assetCurrent.getId());
        assetBusinessFormCpService.deletByAssetId(assetCurrent.getId());
    }

    /**
     * 删除数据
     *
     * @param id 主键
     * @return 删除结果
     */
    @PreAuthorize("@ss.hasAnyRoles('admin,common')")
    @ApiOperation(value = "删除数据")
    @DeleteMapping("/{id}")
    public AjaxResult delete(@PathVariable Long id) {
        assetSupplyChainService.deleteByAssetIds(id);
        assetBasicNetworkService.deleteByAssetIds(id);
        assetBusinessFormService.deleteByAssetIds(id);
        unitOtherConcatService.deleteByAssetIds(id);
        assetCurrentService.deleteByUnitIds(id);
        assetAssetSjService.deleteByAssetIds(id);
        QueryWrapper<AssetCurrentCpPo> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.eq("id", id);
        assetCurrentCpService.remove(queryWrapper1);
        QueryWrapper<AssetSupplyChainCpPo> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.eq("asset_id", id);
        assetSupplyChainCpService.remove(queryWrapper2);
        QueryWrapper<AssetBasicNetworkCpPo> queryWrapper3 = new QueryWrapper<>();
        queryWrapper3.eq("asset_id", id);
        assetBasicNetworkCpService.remove(queryWrapper3);
        QueryWrapper<AssetBusinessFormCpPo> queryWrapper4 = new QueryWrapper<>();
        queryWrapper4.eq("asset_id", id);
        assetBusinessFormCpService.remove(queryWrapper4);
        QueryWrapper<UnitOtherConcatCpPo> queryWrapper5 = new QueryWrapper<>();
        queryWrapper5.eq("asset_id", id);
        unitOtherConcatCpService.remove(queryWrapper5);
        QueryWrapper<AssetSjCpPo> queryWrapper6 = new QueryWrapper<>();
        queryWrapper6.eq("asset_id", id);
        assetAssetSjCpService.remove(queryWrapper6);

        return success();
    }

    /**
     * 下载资产导入模板
     */
    @ApiOperation(value = "下载资产导入模板")
    @PostMapping("/importTemplate")
    public void importTemplate(HttpServletResponse response) {
        ExcelUtil<AssetExport> util = new ExcelUtil<>(AssetExport.class);
        util.importTemplateExcel(response, "资产导入模板");
    }


    /**
     * 导出现有资产
     */
    @ApiOperation(value = "导出现有资产")
    @PostMapping("/export")
    public void exportProject(HttpServletResponse response, AssetCurrentPageRequest as) {
        try {
            if (!SecurityUtils.getLoginUser().getUser().isAdmin() && !SecurityUtils.hasRole("common")) {
                as.setDwmc(SecurityUtils.getLoginUser().getUser().getNickName());
            }
        } catch (Exception e) {
            throw new ServiceException("获取用户信息异常");
        }
        List<AssetExport> list = assetCurrentService.page1(as);
        ExcelUtil<AssetExport> util = new ExcelUtil<>(AssetExport.class);
        util.exportExcel(response, list, "现有资产记录");
    }

    /**
     * 导入现有资产
     */
    @Transactional(rollbackFor = Exception.class)
    @PreAuthorize("@ss.hasAnyRoles('admin,common')")
    @ApiOperation(value = "导入现有资产")
    @PostMapping(value = "/import", consumes = "multipart/form-data")
    public AjaxResult export(@RequestPart("file") MultipartFile file) throws Exception {
        //读取所有的字段
        ExcelUtil<AssetExport> util = new ExcelUtil<>(AssetExport.class);
        List<AssetExport> proList = util.importExcel(file.getInputStream());
        int j = 0;
        for (AssetExport items : proList) {
            j++;
            AssetCurrent as = new AssetCurrent();
            //copy新增到新的现有资产表里面
            BeanUtil.copyProperties(items, as);
            AssetCurrent one = assetCurrentService.lambdaQuery().eq(AssetCurrent::getXtmc, as.getXtmc()).eq(AssetCurrent::getDwmc, as.getDwmc()).one();
            if (one != null) {
                as.setId(one.getId());
                assetCurrentService.updateById(as);
                List<Long> a1 = new ArrayList<>();
                a1.add(one.getId());
                assetSupplyChainService.deleteIdList(a1);
                assetBasicNetworkService.deleteIdList(a1);
            } else {
                List<Unit> list = unitService.lambdaQuery().eq(Unit::getNickName, items.getDwmc()).eq(Unit::getDelFlag, 0).list();
                if (list == null || list.isEmpty()) {
                    throw new ServiceException(j + "行单位未入库!");
                }
                assetCurrentService.save(as);
            }

            //新增系统建设单位
            AssetSupplyChain s1 = new AssetSupplyChain();
            BeanUtil.copyProperties(items, s1);
            s1.setType(5);
            s1.setAssetId(as.getId());
            assetSupplyChainService.save(s1);
            //新增系统运营单位
            AssetSupplyChain b6 = new AssetSupplyChain();
            b6.setGyszcdz(items.getGyszcdz1());
            b6.setLxr(items.getLxr1());
            b6.setLxdh(items.getLxdh1());
            b6.setSfwtc(items.getSfwtc1());
            b6.setName(items.getName1());
            b6.setTyshxydm(items.getTyshxydm1());
            b6.setType(7);
            b6.setAssetId(as.getId());
            assetSupplyChainService.save(b6);
            //新增服务器信息
            AssetBasicNetwork a1 = new AssetBasicNetwork();
            BeanUtil.copyProperties(items, a1);
            a1.setType(1);
            a1.setAssetId(as.getId());
            assetBasicNetworkService.save(a1);
            //新增网络设备
            AssetBasicNetwork a2 = new AssetBasicNetwork();
            a2.setSblx(items.getWlsblx());
            a2.setPp(items.getWlpp());
            a2.setSbIp(items.getWlsbIp());
            a2.setYjxh(items.getWlyjxh());
            a2.setYjxlh(items.getWlyjxlh());
            a2.setYjbbxx(items.getWlyjbbxx());
            a2.setYjyt(items.getWlyjyt());
            a2.setYjbsxx(items.getWlyjbsxx());
            a2.setType(2);
            a2.setAssetId(as.getId());
            assetBasicNetworkService.save(a2);
            //新增安全设备
            AssetBasicNetwork a3 = new AssetBasicNetwork();
            a3.setSblx(items.getAqwlsblx());
            a3.setPp(items.getAqwlpp());
            a3.setSbIp(items.getAqwlsbIp());

            a3.setYjxh(items.getAqyjxh());
            a3.setYjxlh(items.getAqyjxlh());
            a3.setYjbbxx(items.getAqyjbbxx());
            a3.setYjyt(items.getAqyjyt());
            a3.setYjbsxx(items.getAqyjbswz());


            a3.setType(3);
            a3.setAssetId(as.getId());
            assetBasicNetworkService.save(a3);

            //=============
            Long id = as.getId();
            Integer i = unitService.selectTaskId(as.getDwmc(), "0");
            if (i != null) {
                //新增资产复制主表
                AssetCurrentCpPo assetCurrentCpPo = new AssetCurrentCpPo();
                BeanUtil.copyProperties(as, assetCurrentCpPo);
                assetCurrentCpPo.setTaskId(i);
                assetCurrentCpPo.setStatus(0);
                AssetCurrentCpPo two = assetCurrentCpService.lambdaQuery().eq(AssetCurrentCpPo::getXtmc, as.getXtmc()).eq(AssetCurrentCpPo::getDwmc, as.getDwmc()).isNotNull(AssetCurrentCpPo::getTaskId).one();
                if (two != null) {
                    assetCurrentCpPo.setId(two.getId());
                    assetCurrentCpService.updateById(assetCurrentCpPo);
                    assetSupplyChainCpService.deletByAssetIdandTaskId(id, i);
                    assetBasicNetworkCpService.deletByAssetIdandTaskId(id, i);
                } else {
                    assetCurrentCpService.save(assetCurrentCpPo);
                }
                //新增系统建设单位
                AssetSupplyChainCpPo co1 = new AssetSupplyChainCpPo();
                BeanUtil.copyProperties(items, co1);
                co1.setType(5);
                co1.setAssetId(id);
                co1.setTaskId(i);
                assetSupplyChainCpService.save(co1);

                //新增系统运营单位
                AssetSupplyChainCpPo co2 = new AssetSupplyChainCpPo();
                co2.setGyszcdz(items.getGyszcdz1());
                co2.setLxr(items.getLxr1());
                co2.setLxdh(items.getLxdh1());
                co2.setSfwtc(items.getSfwtc1());
                co2.setName(items.getName1());
                co2.setTyshxydm(items.getTyshxydm1());
                co2.setType(7);
                co2.setAssetId(as.getId());
                co2.setTaskId(i);
                assetSupplyChainCpService.save(co2);

                //新增服务器信息
                AssetBasicNetworkCpPo co3 = new AssetBasicNetworkCpPo();
                BeanUtil.copyProperties(items, co3);
                co3.setType(1);
                co3.setAssetId(id);
                co3.setTaskId(i);
                assetBasicNetworkCpService.save(co3);

                //新增网络设备
                AssetBasicNetworkCpPo co4 = new AssetBasicNetworkCpPo();
                co4.setSblx(items.getWlsblx());
                co4.setPp(items.getWlpp());
                co4.setSbIp(items.getWlsbIp());
                co4.setYjxh(items.getWlyjxh());
                co4.setYjxlh(items.getWlyjxlh());
                co4.setYjbbxx(items.getWlyjbbxx());
                co4.setYjyt(items.getWlyjyt());
                co4.setYjbsxx(items.getWlyjbsxx());
                co4.setType(2);
                co4.setAssetId(id);
                co4.setTaskId(i);
                assetBasicNetworkCpService.save(co4);
                //新增安全设备
                AssetBasicNetworkCpPo co5 = new AssetBasicNetworkCpPo();
                co5.setYjxh(items.getAqyjxh());
                co5.setYjxlh(items.getAqyjxlh());
                co5.setYjbbxx(items.getAqyjbbxx());
                co5.setYjyt(items.getAqyjyt());
                co5.setYjbsxx(items.getAqyjbswz());
                co5.setSblx(items.getAqwlsblx());
                co5.setPp(items.getAqwlpp());
                co5.setSbIp(items.getAqwlsbIp());
                co5.setType(3);
                co5.setAssetId(id);
                co5.setTaskId(i);
                assetBasicNetworkCpService.save(co5);

            }
        }
        return AjaxResult.success();
    }

}

