package com.persagy.proxy.object.controller;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.persagy.dmp.basic.dto.RequestData;
import com.persagy.dmp.basic.model.QueryCriteria;
import com.persagy.dmp.common.model.entity.BaseEntity;
import com.persagy.dmp.common.model.response.CommonResult;
import com.persagy.dmp.define.client.DigitalDefineFacade;
import com.persagy.dmp.define.entity.ObjectTypeDefine;
import com.persagy.dmp.digital.client.DigitalObjectFacade;
import com.persagy.dmp.digital.client.DigitalRelationFacade;
import com.persagy.dmp.digital.entity.ObjectRelation;
import com.persagy.dmp.simple.client.DigitalObjectSimpleFacade;
import com.persagy.proxy.adm.request.AdmCreateRequest;
import com.persagy.proxy.adm.request.AdmQueryCriteria;
import com.persagy.proxy.adm.request.AdmResponse;
import com.persagy.proxy.adm.service.IAdmRelationService;
import com.persagy.proxy.adm.utils.AdmContextUtil;
import com.persagy.proxy.adm.utils.AdmEntityTransferUtil;
import com.persagy.proxy.adm.utils.AdmQueryCriteriaHelper;
import com.persagy.proxy.adm.utils.ObjectNameUtil;
import com.persagy.proxy.common.entity.DmpResult;
import com.persagy.proxy.common.entity.RelationDTO;
import com.persagy.proxy.object.model.*;
import com.persagy.proxy.object.service.IAdmBuildingService;
import com.persagy.proxy.object.service.IAdmFloorService;
import com.persagy.proxy.object.service.IAdmSystemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.json.JsonObject;
import javax.validation.constraints.NotNull;
import javax.ws.rs.QueryParam;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * Adm 系统 API
 * @author lvxy
 * @date 2021/8/16
 */

@RestController
@RequestMapping("/object/general-system")
public class AdmSystemController {
    @Autowired
    private IAdmSystemService service;
    @Autowired
    private IAdmBuildingService buildingService;
    @Autowired
    private IAdmFloorService floorService;
    @Autowired
    private IAdmRelationService relationService;

    /**
     * 统计

     * @param request
     * @return
     * @throws Exception
     */
    @PostMapping("/count")
    public AdmResponse count(@RequestBody AdmQueryCriteria request) throws Exception {
        request.setName(AdmSystem.OBJ_TYPE);
        request.setOnlyCount(true);
        return service.doQuery(AdmContextUtil.toDmpContext(), request, AdmSystem.class);
    }

    /**
     * 创建
     * @param createRequest
     * @return
     * @throws Exception
     */
    @PostMapping("/create")
    public AdmResponse create(@RequestBody AdmCreateRequest<AdmSystem> createRequest, @QueryParam("projectId") String projectId) throws Exception {
        List<AdmSystem> vos = CollUtil.newArrayList(createRequest.getContent());
        vos = service.doInsert(AdmContextUtil.toDmpContext(), AdmSystem.class, vos);
        return AdmResponse.success(vos);
    }

    /**
     * 创建系统信息-处理建筑楼层
     * @param createRequest
     * @return
     * @throws Exception
     */
    @PostMapping("/create-bd-fl")
    public AdmResponse createBdFl(@RequestBody AdmCreateRequest<AdmSystem> createRequest) throws Exception {
        List<AdmSystem> vos = CollUtil.newArrayList(createRequest.getContent());

        Map<String, AdmSystem> admSystemMap = CollUtil.fieldValueMap(vos, "classCode");
        QueryCriteria defineCriteria = new QueryCriteria();
        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
        ArrayNode array = criteria.putObject("code").putArray("$in");
        admSystemMap.keySet().stream().forEach(classCode -> array.add(classCode));
        defineCriteria.setCriteria(criteria);
        List<ObjectTypeDefine> defineList = DigitalDefineFacade.queryObjectType(AdmContextUtil.toDmpContext().getGroupCode(),AdmContextUtil.toDmpContext().getProjectId(),AdmContextUtil.toDmpContext().getAppId(),null,defineCriteria);
        Map<String, ObjectTypeDefine> defineMap = CollUtil.fieldValueMap(defineList, "code");
        vos.stream().forEach(admSystem -> {
            if(StrUtil.isEmpty(admSystem.getName())){
                if(CollUtil.isNotEmpty(defineList) && defineMap.containsKey(admSystem.getClassCode())){
                    admSystem.setName(ObjectNameUtil.objectName(defineMap.get(admSystem.getClassCode()).getName()+"系统-"));
                }else {
                    admSystem.setName(ObjectNameUtil.objectName("系统-"));
                }
            }
        });
        List<AdmSystem> unRelationSys = new ArrayList<>();
        List<AdmSystem> admSystemList = new ArrayList<>(vos.size());
        List<RelationDTO> relationDTOS = new ArrayList<>(vos.size());
        vos.stream().forEach(admSystem -> {
            if(CollUtil.isNotEmpty(admSystem.getBuildingFloorInfoList())){
                List<AdmSystem> admSystems = service.doInsert(AdmContextUtil.toDmpContext(), AdmSystem.class, CollUtil.newArrayList(admSystem));
                //添加关系
                String systemId = admSystems.get(0).getId();
                admSystem.getBuildingFloorInfoList().forEach(info -> {
                    String floorId = info.get("FloorID") == null ? null : info.get("FloorID").textValue();
                    String buildID = info.get("BuildID") == null ? null : info.get("BuildID").textValue();
                    if(StrUtil.isNotEmpty(floorId)){
                        relationDTOS.add(new RelationDTO(null, "MechInArch", "Sy2Fl", null, systemId , floorId));
                    }
                    if(StrUtil.isNotEmpty(buildID)){
                        relationDTOS.add(new RelationDTO(null, "MechInArch", "Sy2Bd", null, systemId , buildID));
                    }
                });
                admSystemList.addAll(admSystems);
            }else{
                unRelationSys.add(admSystem);
            }
        });
        if(CollUtil.isNotEmpty(relationDTOS)){
            relationService.doSave(AdmContextUtil.toDmpContext(), relationDTOS);
        }
        if(CollUtil.isNotEmpty(unRelationSys)){
            List<AdmSystem> systemList = service.doInsert(AdmContextUtil.toDmpContext(), AdmSystem.class, unRelationSys);
            admSystemList.addAll(systemList);
        }
        return AdmResponse.success(admSystemList);
    }

    /**
     * 根据ID删除
     * @param vos
     * @return
     * @throws Exception
     */
    @PostMapping("/delete")
    public AdmResponse delete( @RequestBody List<AdmSystem> vos) throws Exception {
        service.doDelete(AdmContextUtil.toDmpContext(), vos);
        return AdmResponse.success();
    }

    /**
     * 更新
     * @param createRequest
     * @return
     * @throws Exception
     */
    @PostMapping("/update")
    public AdmResponse update(@RequestBody AdmCreateRequest<AdmSystem> createRequest, @QueryParam("projectId") String projectId) throws Exception {
        List<AdmSystem> vos = CollUtil.newArrayList(createRequest.getContent());
        vos = service.doUpdate(AdmContextUtil.toDmpContext(), AdmSystem.class, vos);
        return AdmResponse.success(vos);
    }

    /**
     * 系统绑定的动态信息点或静态信息点
     * type: static(静态)，iot (动态)

     * @param request
     * @return
     * @throws Exception
     */
    @GetMapping("/export")
    public AdmResponse exportInfos(@RequestBody AdmQueryCriteria request) {
        request.setName(AdmSystem.OBJ_TYPE);
        return service.doQuery(AdmContextUtil.toDmpContext(), request, AdmSystem.class);
    }

    /**
     * 创建系统下的设备关系
     * @param createRequest
     * @return
     * @throws Exception
     */
    @PostMapping("/link-equip")
    public AdmResponse createRelateEquip(@RequestBody JsonObject createRequest, @QueryParam("projectId") String projectId) throws Exception {
        String sysId = createRequest.get("sysId").toString();
        List<String> equipIdList = (List<String>)createRequest.get("equipIdList");
        List<ObjectNode> relations = new ArrayList<>(equipIdList.size());
        equipIdList.stream().forEach(euipId -> {
            ObjectNode objectNode = JsonNodeFactory.instance.objectNode();
            objectNode.put("relCode", "Sy2Eq");
            objectNode.put("graphCode","MechSubset");
            objectNode.put("objFrom", sysId);
            objectNode.put("objTo", euipId);
        });
        List<ObjectRelation> list = DigitalRelationFacade.create(AdmContextUtil.toDmpContext().getGroupCode(),AdmContextUtil.toDmpContext().getProjectId(), AdmContextUtil.toDmpContext().getAppId(), null, relations);
        return AdmResponse.success(list);
    }

    /**
     * 查询
     * @param request
     * @return
     * @throws Exception
     */
    @PostMapping("/query")
    public AdmResponse query(@RequestBody AdmQueryCriteria request) {
        request.setName(AdmSystem.OBJ_TYPE);

        if(CollUtil.isNotEmpty(request.getProjection()) && request.getDistinct() && !request.getProjection().contains(BaseEntity.PROP_ID)){
            RequestData requestData = new RequestData();
            requestData.setProjection(request.getProjection());
            requestData.setObjType(AdmSystem.OBJ_TYPE);
            requestData.setPage(request.getPageNumber().longValue());
            requestData.setSize(request.getPageSize().longValue());
            CommonResult<List<ObjectNode>> result = DigitalObjectSimpleFacade.querySystemListByConditions(AdmContextUtil.toDmpContext().getGroupCode(),AdmContextUtil.toDmpContext().getProjectId(), AdmContextUtil.toDmpContext().getAppId(), null, requestData);
            if(result == null || CollUtil.isEmpty(result.getData())){
                return AdmResponse.success();
            }
            List<AdmSystem> admSystemList = JSONUtil.toList(result.getData().toString(), AdmSystem.class);
            service.ensureSpecialValues(AdmContextUtil.toDmpContext(), admSystemList);
            AdmResponse response = AdmResponse.success(admSystemList);
            Long total = result.getCount() == null ? null : result.getCount().longValue();
            if(request.isOnlyCount()){
                response.setTotal(null);
                response.setCount(total);
            }else {
                response.setTotal(total);
            }
            response.setPageNumber(request.getPageNumber());
            response.setPageSize(request.getPageSize());
            return response;
        }else {
            return service.doQuery(AdmContextUtil.toDmpContext(), request, AdmSystem.class);
        }
    }


    /**
     * 查询系统信息-系统建筑楼层一对多
     * MajorName 专业名称 ,级联查询 系统分类名（categoryNames），系统下的设备（equipmentList），系统下的竖井（shaftList），业务空间（zoneSpaceBaseTableList）
     *
     * 明确建筑楼层的 adm级联 查询获取建筑楼层信息  使用正常接口 先查询楼层 再根据楼层信息拼接建筑
     * 未明确建筑/未明确楼层 中台定制接口
     *
     * 这个参见中心代码，
     * @param buildingId buildingId=1,未明确建筑
     * @param floorId   floorId=1,未明确楼层
     * @param request
     * @return
     * @throws Exception
     */
    @PostMapping("/query-new")
    public AdmResponse queryNew(@QueryParam("buildingId") String buildingId,
                                @QueryParam("floorId") String floorId, @RequestBody AdmQueryCriteria request) throws Exception {
        request.setName(AdmSystem.OBJ_TYPE);
        AdmResponse syses = new AdmResponse();
        List<AdmSystem> admSystemList = new ArrayList<>();
        if(StrUtil.isAllEmpty(buildingId,floorId)){
            //case one 查询全部系统，级联建筑,建筑级联楼层

            AdmQueryCriteria admQueryCriteriaFl = new AdmQueryCriteria();
            admQueryCriteriaFl.setName("floorList");
            List<AdmQueryCriteria> cascadeFlBd = new ArrayList<>(1);
            AdmQueryCriteria admQueryCriteriaBdFl = new AdmQueryCriteria();
            admQueryCriteriaBdFl.setName("building");
            cascadeFlBd.add(admQueryCriteriaBdFl);
            admQueryCriteriaFl.setCascade(cascadeFlBd);

            List<AdmQueryCriteria> cascade = new ArrayList<>(1);
            cascade.add(admQueryCriteriaFl);
            request.setCascade(cascade);
            syses = service.doQuery(AdmContextUtil.toDmpContext(),request,AdmSystem.class);
            //处理数据 BuildingFloorInfo
            if(CollUtil.isNotEmpty(syses.getContent())){
                admSystemList = (List<AdmSystem>) syses.getContent();
                admSystemList.stream().forEach(admSystem -> {
                    List<ObjectNode> buildingFloorInfoList = new ArrayList<>();
                    List<AdmFloor> admFloorList = admSystem.getFloorList();
                    if(CollUtil.isNotEmpty(admFloorList)){
                        admFloorList.stream().forEach(admFloor -> {
                            ObjectNode infobd = JsonNodeFactory.instance.objectNode();
                            infobd.put("BuildID",admFloor.getBuildingId());
                            infobd.put("BuildName",admFloor.getBuilding() != null ? admFloor.getBuilding().getLocalName() : "");
                            if(!buildingFloorInfoList.contains(infobd)){
                                buildingFloorInfoList.add(infobd);
                            }
                            ObjectNode infobd1 = infobd.deepCopy();
                            infobd1.put("FloorID",admFloor.getId());
                            infobd1.put("FloorName",admFloor.getLocalName());
                            buildingFloorInfoList.add(infobd1);
                        });
                    }
                    admSystem.setFloorList(null);
                    admSystem.setBuildingFloorInfoList(buildingFloorInfoList);
                });
                syses.setContent(CollUtil.isEmpty(admSystemList) ? new ArrayList<>(1) : admSystemList);
            }
        }else{
            QueryCriteria rwdQueryCriteria = AdmQueryCriteriaHelper.toDmpCriteria(request);
            ObjectNode criteria = rwdQueryCriteria.getCriteria();
            if(JSONUtil.isNull(criteria)){
                return AdmResponse.failure("请求参数错误");
            }
            if (StrUtil.isNotEmpty(floorId)) {
                if(!"1".equals(floorId)){
                    //case two 明确建筑、明确楼层的 系统
                    JSONObject relationFrom = new JSONObject();
                    relationFrom.put("relCode", "Sy2Fl");
                    relationFrom.put("graphCode", "MechInArch");
                    relationFrom.put("objTo", floorId);
                    criteria.putPOJO("relationFrom",relationFrom);
                    rwdQueryCriteria.setCriteria(criteria);
                    syses = service.doQuery(AdmContextUtil.toDmpContext(), rwdQueryCriteria, AdmSystem.class);
                    if (CollUtil.isNotEmpty(syses.getContent())) {
                        admSystemList = (List<AdmSystem>) syses.getContent();
                    }

                }else if("1".equals(floorId)){
                    //case three 明确建筑 不明确楼层
                    syses = queryNotSureObj(buildingId, rwdQueryCriteria);
                    if(null != syses && CollUtil.isNotEmpty(syses.getContent())){
                        admSystemList = (List<AdmSystem>) syses.getContent();
                    }
                }
                if(CollUtil.isNotEmpty(admSystemList)){
                    //处理数据 BuildingFloorInfo
                    admSystemList = dealBdFlInfo(floorId,buildingId,admSystemList);
                    syses.setContent(admSystemList);
                }
            }else if(StrUtil.isEmpty(floorId) && StrUtil.isNotEmpty(buildingId)){
                if(!"1".equals(buildingId)){
                    //case two 明确建筑、明确楼层的 系统
                    JSONObject relationFrom = new JSONObject();
                    relationFrom.put("relCode", "Sy2Bd");
                    relationFrom.put("graphCode", "MechInArch");
                    relationFrom.put("objTo", buildingId);
                    criteria.putPOJO("relationFrom",relationFrom);
                    rwdQueryCriteria.setCriteria(criteria);
                    syses = service.doQuery(AdmContextUtil.toDmpContext(), rwdQueryCriteria, AdmSystem.class);
                }else if("1".equals(buildingId)){
                    syses = queryNotSureObj(null, rwdQueryCriteria);
                }
                admSystemList = (List<AdmSystem>) syses.getContent();
                if(CollUtil.isNotEmpty(admSystemList)){
                    //处理数据 BuildingFloorInfo
                    admSystemList = dealBdFlInfo(floorId,buildingId,admSystemList);
                    syses.setContent(admSystemList);
                }
            }else{
                //处理通用返回结果
                if(StrUtil.isNotEmpty(buildingId) && buildingId.equals("1")){
                    //case four 未明确建筑
                    syses = queryNotSureObj(null, rwdQueryCriteria);
                    admSystemList = (List<AdmSystem>) syses.getContent();
                    if(CollUtil.isNotEmpty(admSystemList)){
                        //处理数据 BuildingFloorInfo
                        admSystemList = dealBdFlInfo(null,null, admSystemList);
                    }
                }
            }
            if(CollUtil.isNotEmpty(admSystemList))
                syses.setTotal(admSystemList.size()*1l);

        }
        if(CollUtil.isNotEmpty(admSystemList)){
            syses.setContent(admSystemList);
        }else{
            syses.setContent(new ArrayList<>(1));
        }
        return syses;
    }

    /**
     * 查询不确定建筑/楼层的系统
     * @param buildingId
     * @param rwdQueryCriteria
     * @return
     */
    private AdmResponse queryNotSureObj(String buildingId, QueryCriteria rwdQueryCriteria){
        RequestData requestData = new RequestData();
        String classCode = rwdQueryCriteria.getCriteria().get("classCode").textValue();
        if(StrUtil.isNotEmpty(classCode)){
            requestData.setClassCode(classCode);
        }
        if(StrUtil.isNotEmpty(buildingId)){
            requestData.setBuildingId(buildingId);
        }
        requestData.setProjectId(AdmContextUtil.toDmpContext().getProjectId());
        requestData.setGraphCode(AdmContextUtil.toDmpContext().getGroupCode());
        requestData.setObjType(AdmSystem.OBJ_TYPE);
        requestData.setPage(rwdQueryCriteria.getPage());
        requestData.setSize(rwdQueryCriteria.getSize());
        Page<Map<String,Object>> result = DigitalObjectSimpleFacade.queryNotSureSystem(AdmContextUtil.toDmpContext().getGroupCode(), AdmContextUtil.toDmpContext().getProjectId(), AdmContextUtil.toDmpContext().getAppId(),null, requestData);
        if(CollUtil.isNotEmpty(result.getRecords())){
            AdmResponse response = new AdmResponse();
            response.setPageSize(Integer.parseInt(String.valueOf(result.getSize())));
            response.setPageNumber(Integer.parseInt(String.valueOf(result.getCurrent())));
            response.setResult(DmpResult.SUCCESS);
            response.setContent(AdmEntityTransferUtil.toAdmMultiEntity(result.getRecords(),null,AdmSystem.class));
            response.setTotal(result.getTotal());
            return response;
        }else{
            return AdmResponse.success();
        }
    }

    /**
     * 处理建筑楼层信息 建筑确定，楼层可为空
     * @param floorId
     * @param buildingId
     * @param admSystemList
     * @return
     */
    private List<AdmSystem> dealBdFlInfo(String floorId, String buildingId, List<AdmSystem> admSystemList){
        if(CollUtil.isEmpty(admSystemList)){
            return null;
        }
        if(StrUtil.isEmpty(buildingId)){//处理成adm目标格式
            List<ObjectNode> nullList = new ArrayList<>(0);
            admSystemList.stream().forEach(admSystem -> {
                admSystem.setBuildingFloorInfoList(nullList);
            });
            return admSystemList;
        }
        AdmResponse buildings = null;
        if(StrUtil.isNotEmpty(buildingId)){
            AdmQueryCriteria admQueryCriteria = getAdmQueryCriteria(AdmBuilding.OBJ_TYPE, buildingId);
            buildings = buildingService.doQuery(AdmContextUtil.toDmpContext(), admQueryCriteria, AdmBuilding.class);
        }
        AdmResponse floors = null;
        if(StrUtil.isNotEmpty(floorId)){
            AdmQueryCriteria admQueryCriteria = getAdmQueryCriteria(AdmFloor.OBJ_TYPE, floorId);
            floors = floorService.doQuery(AdmContextUtil.toDmpContext(), admQueryCriteria, AdmFloor.class);
        }

        ObjectNode buildingFloorInfo = JsonNodeFactory.instance.objectNode();
        if (CollUtil.isNotEmpty(buildings.getContent())) {
            AdmBuilding admBuilding = (AdmBuilding) buildings.getContent().get(0);
            buildingFloorInfo.put("BuildID",admBuilding.getId());
            buildingFloorInfo.put("BuildName",admBuilding.getLocalName());
        }
        if (null!=floors && CollUtil.isNotEmpty(floors.getContent())) {
            ObjectNode buildingFloorInfoFl = JsonNodeFactory.instance.objectNode();
            buildingFloorInfoFl = buildingFloorInfo.deepCopy();
            AdmFloor floor = (AdmFloor) floors.getContent().get(0);
            buildingFloorInfoFl.put("FloorID",floor.getId());
            buildingFloorInfoFl.put("FloorName",floor.getLocalName());
        }
        if(JSONUtil.isNull(buildingFloorInfo) || buildingFloorInfo.isNull() || !buildingFloorInfo.fieldNames().hasNext()){
            admSystemList.stream().forEach(admSystem -> {
                admSystem.setBuildingFloorInfoList(new ArrayList<>(1));
            });
            return admSystemList;
        }
        admSystemList.stream().forEach(admSystem -> {
            admSystem.setBuildingFloorInfoList(Arrays.asList(buildingFloorInfo));
        });
        return admSystemList;
    }

    private AdmQueryCriteria getAdmQueryCriteria(String objType, String Id){
        AdmQueryCriteria admQueryCriteria = new AdmQueryCriteria();
        admQueryCriteria.setName(objType);
        admQueryCriteria.setFilters("id = " + Id);
        return  admQueryCriteria;
    }

    /**
     * 查询系统信息-试图级联建筑楼层 暂未使用

     * @param request
     * @return
     * @throws Exception
     */
    @PostMapping("/query-bdfl")
    public AdmResponse queryUnBdFl(@RequestBody AdmQueryCriteria request) throws Exception {
        request.setName(AdmSystem.OBJ_TYPE);
        return service.doQuery(AdmContextUtil.toDmpContext(), request, AdmSystem.class);
    }

    /**
     * 查询没有和当前系统关联的设备
     * id 为系统id

     * @param request
     * @return
     * @throws Exception
     */
    @PostMapping("/un-sys-equip")
    public AdmResponse queryUnEquip( @NotNull @QueryParam("sysId") String sysId,
                                     @RequestBody AdmQueryCriteria request) throws Exception {
        //AdmResponse admResponse = queryObjectByType(sysId,request,"Sy2Eq","MechSubset", AdmEquipment.OBJ_TYPE);
        ObjectNode relationTo = JsonNodeFactory.instance.objectNode();
        relationTo.put("objFrom", sysId);
        relationTo.put("relCode", "Sy2Eq");
        relationTo.put("graphCode", "MechSubset");
        relationTo.put("$bindFlag", false);
        request.setRelationTo(relationTo);
        request.setName(AdmEquipment.OBJ_TYPE);
        QueryCriteria queryCriteriaObj = AdmQueryCriteriaHelper.toDmpCriteria(request);
        List<ObjectNode> obj = DigitalObjectFacade.query(AdmContextUtil.toDmpContext().getGroupCode(),AdmContextUtil.toDmpContext().getProjectId(), AdmContextUtil.toDmpContext().getAppId(), null, queryCriteriaObj);
        return AdmResponse.success(obj);
    }


    /**
     * 查询没有和当前系统关联的竖井
     *  id 为系统id

     * @param request
     * @return
     * @throws Exception
     */
    @PostMapping("/un-sys-shaft")
    public AdmResponse queryUnSh( @NotNull @QueryParam("sysId") String sysId,
                                  @RequestBody AdmQueryCriteria request) throws Exception {
        //AdmResponse admResponse = queryObjectByType(sysId,request,"Sy2Sh",null, AdmShaft.OBJ_TYPE);
        ObjectNode relationTo = JsonNodeFactory.instance.objectNode();
        relationTo.put("objFrom", sysId);
        relationTo.put("relCode", "Sy2Sh");
        relationTo.put("$bindFlag", false);
        request.setRelationTo(relationTo);
        request.setName(AdmShaft.OBJ_TYPE);
        QueryCriteria queryCriteriaObj = AdmQueryCriteriaHelper.toDmpCriteria(request);
        List<ObjectNode> obj = DigitalObjectFacade.query(AdmContextUtil.toDmpContext().getGroupCode(),AdmContextUtil.toDmpContext().getProjectId(), AdmContextUtil.toDmpContext().getAppId(), null, queryCriteriaObj);
        return AdmResponse.success(obj);
    }


    /**
     * 查询没有和当前系统关联的业务空间
     * id 为系统id
     * @param request
     * @return
     * @throws Exception
     */
    @PostMapping("/un-sys-zoneSpaceBaseTable")
    public AdmResponse queryUnZoneSp(@NotNull @QueryParam("sysId") String sysId,
                                     @RequestBody AdmQueryCriteria request) throws Exception {
       // AdmResponse admResponse = queryObjectByType(sysId,request,"Sy2Sp",null, AdmSpace.OBJ_TYPE);
        ObjectNode relationTo = JsonNodeFactory.instance.objectNode();
        relationTo.put("objFrom", sysId);
        relationTo.put("relCode", "Sy2Sp");
        relationTo.put("$bindFlag", false);
        request.setRelationTo(relationTo);
        request.setName(AdmSpace.OBJ_TYPE);
        QueryCriteria queryCriteriaObj = AdmQueryCriteriaHelper.toDmpCriteria(request);
        List<ObjectNode> obj = DigitalObjectFacade.query(AdmContextUtil.toDmpContext().getGroupCode(),AdmContextUtil.toDmpContext().getProjectId(), AdmContextUtil.toDmpContext().getAppId(), null, queryCriteriaObj);
        return AdmResponse.success(obj);
    }


    /**
     * 查询没有和当前空间绑定的系统
     * 例如：prijectId=Pj4201050001,type=AirConditioningZone spaceId=Sp4201050001df2091cdf719443b80bb737aeabf0525 spaceId 为当前空间id type为当前空间类型
     * @param request
     * @return
     * @throws Exception
     */
    @PostMapping("/unspace-sys")
    public AdmResponse queryUnSpSy(  @QueryParam("type") String type, @QueryParam("spaceId") String spaceId,
                                     @RequestBody AdmQueryCriteria request) throws Exception {
        if(StrUtil.isNotEmpty(type)){
            if(StrUtil.isBlank(request.getFilters())){
                request.setFilters("classCode = '"+type+"'");
            }else{
                request.setFilters(request.getFilters()+";classCode = '"+type+"'");
            }
        }
        //AdmResponse admResponse = queryObjectByType(spaceId, request,"Sy2Sp",null, AdmSystem.OBJ_TYPE);

        ObjectNode relationFrom = JsonNodeFactory.instance.objectNode();
        relationFrom.put("objTo", spaceId);
        relationFrom.put("relCode", "Sy2Sp");
        relationFrom.put("$bindFlag", false);
        request.setRelationFrom(relationFrom);
        request.setName(AdmSystem.OBJ_TYPE);
        QueryCriteria queryCriteriaObj = AdmQueryCriteriaHelper.toDmpCriteria(request);
        List<ObjectNode> obj = DigitalObjectFacade.query(AdmContextUtil.toDmpContext().getGroupCode(),AdmContextUtil.toDmpContext().getProjectId(), AdmContextUtil.toDmpContext().getAppId(), null, queryCriteriaObj);
        return AdmResponse.success(obj);
    }

}