修改文件上传类型限制

mitao

2025-05-20 179c4d64313c9b7572778da4aaaf6c6584fe457d

 springcloud_k8s_panzhihuazhihuishequ/service_api/src/main/java/com/panzhihua/serviceapi/biz/impl/LcApiServiceImpl.java

@@ -1,30 +1,5 @@
package com.panzhihua.serviceapi.biz.impl;

import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSONArray;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.panzhihua.common.api.LangchaoApiConstants;
import com.panzhihua.common.constants.TokenConstant;
import com.panzhihua.common.enums.LocalEventToLangChaoEventTypeEnum;
import com.panzhihua.common.model.dtos.api.EventFile;
import com.panzhihua.common.model.dtos.api.EventInfo;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.grid.EventDetailsVO;
import com.panzhihua.common.model.vos.grid.EventGridDataDetailsVO;
import com.panzhihua.common.model.vos.grid.EventResourceVO;
import com.panzhihua.common.service.grid.GridService;
import com.panzhihua.serviceapi.biz.LcApiService;
import com.panzhihua.serviceapi.model.dto.LcGridData;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
@@ -35,16 +10,54 @@
import java.util.Map;
import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.panzhihua.common.api.*;
import com.panzhihua.common.constants.TokenConstant;
import com.panzhihua.common.enums.LocalEventToLangChaoEventTypeEnum;
import com.panzhihua.common.model.dtos.api.EventFile;
import com.panzhihua.common.model.dtos.api.EventInfo;
import com.panzhihua.common.model.dtos.grid.LcEventVisitingTasksListDTO;
import com.panzhihua.common.model.vos.BcDictionaryItemVO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.ComMngPopulationVO;
import com.panzhihua.common.model.vos.grid.EventDetailsVO;
import com.panzhihua.common.model.vos.grid.EventGridDataDetailsVO;
import com.panzhihua.common.model.vos.grid.EventResourceVO;
import com.panzhihua.common.service.community.CommunityService;
import com.panzhihua.common.service.grid.GridService;
import com.panzhihua.common.utlis.CopyUtil;
import com.panzhihua.common.utlis.DateUtils;
import com.panzhihua.common.utlis.StringUtils;
import com.panzhihua.serviceapi.biz.LcApiService;
import com.panzhihua.serviceapi.model.dto.*;

import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import lombok.extern.slf4j.Slf4j;

/**
 * program 攀枝花智慧社区项目
 * description 第三方浪潮市平台对接接口管理API
 * program 攀枝花智慧社区项目 description 第三方浪潮市平台对接接口管理API
 *
 * @author manailin
 * Date 2021-01-22 15:30
 * @author manailin Date 2021-01-22 15:30
 **/
@Slf4j
@Service
public class LcApiServiceImpl implements LcApiService {

    @Value("${langchao.url}")
    private String host;

    @Resource
    private GridService gridService;
@@ -52,168 +65,13 @@
    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 从redis获取token
     *
     * @return String 浪潮对接的token
     */
    private String getAuthToken() {
        ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
        if(valueOperations.get(LangchaoApiConstants.LANG_CHAO_TOKEN) ==null){
            saveTokenFromRemoteRequest("18080799023", "123456");
        }
        return valueOperations.get(LangchaoApiConstants.LANG_CHAO_TOKEN);
    }

    @Override
    public String saveTokenFromRemoteRequest(String name, String password) {
        if (redisTemplate.hasKey(LangchaoApiConstants.LANG_CHAO_TOKEN)) {
            //如果redis存在token,直接返回redis存储的token
            ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
            return valueOperations.get(LangchaoApiConstants.LANG_CHAO_TOKEN);
        } else {
            //如果第一次请求浪潮的token请求,请求完成后，保存对于的token到数据库中。便于12小时内重复调用
            HttpRequest request = HttpUtil.createPost(LangchaoApiConstants.GRID_GET_TOKEN_URL.replace("#username", name).replace("#password", password));
            HttpResponse result = request.execute();
            ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
            valueOperations.set(LangchaoApiConstants.LANG_CHAO_TOKEN, result.body(), TokenConstant.EXPIRETIME, TimeUnit.MINUTES);
            return result.toString();
        }
    }

    @Override
    public String getAllEventTypeList() {
        HttpRequest request = HttpUtil.createPost(LangchaoApiConstants.GRID_EVENT_CATEGORY_URL);
        request.auth(getAuthToken());
        HttpResponse result = request.execute();
        return result.body();
    }

    @Override
    public String submitEventRegister(EventInfo eventInfo) {
        HttpRequest request = HttpUtil.createPost(LangchaoApiConstants.GRID_REGIST_EVENT_URL);
        request.auth(getAuthToken());
        ObjectMapper mapper = new ObjectMapper();
        try {
            //对象转map
            Map m = mapper.readValue(mapper.writeValueAsString(eventInfo), Map.class);
            request.form(m);
        } catch (JsonProcessingException e) {
            log.info("方法submitEventRegister发生错误：{}",e.getMessage());
        }
        HttpResponse result = request.execute();
        log.info(result.body());
        return result.body();
    }

    @Override
    public R submitEventRelationFile(EventFile eventFile) {
        HttpRequest request = HttpUtil.createPost(LangchaoApiConstants.GRID_EVENT_FILE_UPLOAD_URL);
        request.auth(getAuthToken());
        try {
            HttpURLConnection httpUrl = (HttpURLConnection) new URL(eventFile.getFiles()).openConnection();
            httpUrl.connect();
            File file = inputStreamToFile(httpUrl.getInputStream(), eventFile.getFileName());
            request.form("files", file);
            httpUrl.disconnect();
            request.form("dataId", eventFile.getDataId());
            request.form("type", eventFile.getType());
            request.form("module", eventFile.getModule());
            HttpResponse result = request.execute();
            file.delete();
            return R.ok(result.body());
        } catch (Exception e) {
            log.info("方法submitEventRelationFile发生错误：{}",e.getMessage());
        }
        return R.fail();
    }

    @Override
    public String getEventInfoById(String eventId) {
        HttpRequest request = HttpUtil.createPost(LangchaoApiConstants.GRID_APP_EVENT_INFO_DETAIL_URL);
        request.auth(getAuthToken());
        request.form("eventId", eventId);
        HttpResponse result = request.execute();
        return result.body();
    }

    @Override
    public List<LcGridData> getGridListByAreaId(String areaId) {
        HttpRequest request = HttpUtil.createPost(LangchaoApiConstants.GRID_GET_EVENT_INFO_AREA_ID_URL);
        request.auth(getAuthToken());
        request.form("areaId", areaId);
        HttpResponse result = request.execute();
        return JSONArray.parseArray(result.body(), LcGridData.class);
    }

    @Override
    public String getGridMemberListByAreaIdOrName(String areaId) {
        HttpRequest request = HttpUtil.createPost(LangchaoApiConstants.GRID_GET_getAll_Search_Page_URL);
        request.auth(getAuthToken());
        request.form("areaId", areaId);
        HttpResponse result = request.execute();
        return result.body();
    }

    @Override
    public void automationUploadEventAndFile() {
        List<EventDetailsVO> unUploadEventList = gridService.getUnUploadEvent();
        unUploadEventList.forEach(eventInfoVo -> {
            log.info("定时向浪潮服务器提交网格事件登记开始");
            EventInfo eventInfo = new EventInfo();
            String lcGrid = gridService.getLcGridIdByLocal(eventInfoVo.getGridId());
            String lcGridUserId = gridService.getLcUserIdByLocalUserId(eventInfoVo.getGridMemberId().toString());
            eventInfo.setGridId(lcGrid);
            R grid = gridService.eventGridDataDetails(eventInfoVo.getGridId());
            EventGridDataDetailsVO gridData = (EventGridDataDetailsVO) grid.getData();
            eventInfo.setGridName(gridData.getGridName());
            eventInfo.setCaseTypeCode(LocalEventToLangChaoEventTypeEnum.getCodeByName(eventInfoVo.getEventType()));
            eventInfo.setCaseTypeName(LocalEventToLangChaoEventTypeEnum.getEventNameByCode(eventInfoVo.getEventType()));
            eventInfo.setHappenTime(String.valueOf(eventInfoVo.getHappenTime().getTime()));
            eventInfo.setHappenAddress(eventInfoVo.getHappenAddress());
            String[] data = eventInfoVo.getHappentLatLng().split(",");
            eventInfo.setLongitude(data[0]);
            eventInfo.setLatitude(data[1]);
            eventInfo.setCaseDescription(eventInfoVo.getEventDes());
            eventInfo.setCaseRecordTime(String.valueOf(eventInfoVo.getCreateAt().getTime()));
            eventInfo.setHandleType("REPORT");
            eventInfo.setHandleDescription(eventInfoVo.getProcessDesc());
            eventInfo.setDataId(eventInfoVo.getId().toString());
            //获取系统网格员映射的浪潮网格员对于的用户ID
            eventInfo.setUserId(lcGridUserId);
            eventInfo.setHandleTime(String.valueOf(eventInfoVo.getHappenTime().getTime()));
            eventInfo.setCaseName(eventInfoVo.getEventTitle());
            submitEventRegister(eventInfo);
            log.info("定时向浪潮服务器提交网格事件登记结束");
            log.info("开始上传附件信息");
            List<EventResourceVO> picsList = eventInfoVo.getPics();
            uploadLcApiEventFile(eventInfoVo, picsList, "png");
            List<EventResourceVO> audiosList = eventInfoVo.getAudios();
            uploadLcApiEventFile(eventInfoVo, audiosList, "mp3");
            List<EventResourceVO> videoList = eventInfoVo.getVideos();
            uploadLcApiEventFile(eventInfoVo, videoList, "mp4");
            log.info("结束上传附件信息");
            gridService.updateLcUploadFlag(eventInfoVo.getId());
        });
    }

    private void uploadLcApiEventFile(EventDetailsVO eventInfoVo, List<EventResourceVO> picsList, String type) {
        picsList.forEach(eventResourceVO -> {
            EventFile eventFile = new EventFile();
            eventFile.setDataId(eventInfoVo.getId().toString());
            eventFile.setFiles(eventResourceVO.getUrl());
            eventFile.setType(type);
            eventFile.setModule("event");
            eventFile.setFileName(eventResourceVO.getResourceName());
            submitEventRelationFile(eventFile);
        });
    }
    @Resource
    private CommunityService communityService;

    /**
     * 工具方法
     * inputStream 转 File
     * 工具方法 inputStream 转 File
     */
    public static File inputStreamToFile(InputStream ins, String name) throws Exception {
    private static File inputStreamToFile(InputStream ins, String name) throws Exception {
        File file = new File(System.getProperty("java.io.tmpdir") + File.separator + name);
        log.info(System.getProperty("java.io.tmpdir") + File.separator + name);
        if (file.exists()) {
@@ -230,4 +88,409 @@
        ins.close();
        return file;
    }

    /**
     * 从redis获取token
     *
     * @return String 浪潮对接的token
     */
    private String getAuthToken() {
        ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
        if (valueOperations.get(LcApiConstants.LANG_CHAO_TOKEN) == null) {
            saveTokenFromRemoteRequest(LcApiConstants.LC_UPLOAD_NAME, LcApiConstants.LC_UPLOAD_PASSWORD);
        }
        return valueOperations.get(LcApiConstants.LANG_CHAO_TOKEN);
    }

    @Override
    public String saveTokenFromRemoteRequest(String name, String password) {
        Boolean authToken = redisTemplate.hasKey(LcApiConstants.LANG_CHAO_TOKEN);
        if (authToken != null) {
            // 如果redis存在token,直接返回redis存储的token
            ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
            return valueOperations.get(LcApiConstants.LANG_CHAO_TOKEN);
        } else {
            // 如果第一次请求浪潮的token请求,请求完成后，保存对于的token到数据库中。便于12小时内重复调用
            HttpRequest request = HttpUtil.createPost(
                host +
                LcApiConstants.GRID_GET_TOKEN_URL.replace("#username", name).replace("#password", password));
            HttpResponse result = request.execute();
            ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
            valueOperations.set(LcApiConstants.LANG_CHAO_TOKEN, result.body(), TokenConstant.EXPIRETIME,
                TimeUnit.MINUTES);
            return result.toString();
        }
    }

    @Override
    public String getAllEventTypeList() {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.GRID_EVENT_CATEGORY_URL);
        request.auth(getAuthToken());
        HttpResponse result = request.execute();
        return result.body();
    }

    @Override
    public String submitEventRegister(EventInfo eventInfo) {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.GRID_REGIST_EVENT_URL);
        request.auth(getAuthToken());
        ObjectMapper mapper = new ObjectMapper();
        try {
            // 对象转map
            Map m = mapper.readValue(mapper.writeValueAsString(eventInfo), Map.class);
            request.form(m);
        } catch (JsonProcessingException e) {
            log.info("方法submitEventRegister发生错误：{}", e.getMessage());
        }
        HttpResponse result = request.execute();
        log.info("submitEventRegister上传浪潮事件信息：{}", result.body());
        return result.body();
    }

    @Override
    public R submitEventOrVisitRecordRelationFile(EventFile eventFile) {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.GRID_EVENT_FILE_UPLOAD_URL);
        request.auth(getAuthToken());
        try {
            HttpURLConnection httpUrl = (HttpURLConnection)new URL(eventFile.getFiles()).openConnection();
            httpUrl.connect();
            File file = inputStreamToFile(httpUrl.getInputStream(), eventFile.getFileName());
            request.form("files", file);
            httpUrl.disconnect();
            request.form("dataId", eventFile.getDataId());
            request.form("type", eventFile.getType());
            request.form("module", eventFile.getModule());
            HttpResponse result = request.execute();
            file.delete();
            return R.ok(result.body());
        } catch (Exception e) {
            log.info("方法submitEventOrVisitRecordRelationFile发生错误：{}", e.getMessage());
        }
        return R.fail();
    }

    @Override
    public String getEventInfoById(String eventId) {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.GRID_APP_EVENT_INFO_DETAIL_URL);
        request.auth(getAuthToken());
        request.form("eventId", eventId);
        HttpResponse result = request.execute();
        return result.body();
    }

    @Override
    public List<LcGridData> getGridTreeByAreaId(String areaId) {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.GRID_GET_EVENT_INFO_AREA_ID_URL);
        request.auth(getAuthToken());
        request.form("areaId", areaId);
        request.form("level", 4);
        HttpResponse result = request.execute();
        return JSONArray.parseArray(result.body(), LcGridData.class);
    }

    @Override
    public List<LcGridData> getGridDataListByAreaId(String areaId) {
        log.info("浪潮请求url");
        log.info(host + LcApiConstants.GRID_GET_GRID_DATA_AREA_ID_URL);
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.GRID_GET_GRID_DATA_AREA_ID_URL);
        request.auth(getAuthToken());
        request.form("areaId", areaId);
        HttpResponse result = request.execute();
        return JSONArray.parseArray(result.body(), LcGridData.class);
    }

    @Override
    public List<GridMemberPageListDTO> getGridMemberListByAreaIdOrName(String areaId, String param, Long pageNum,
        Long pageSize) {
        HttpRequest request = HttpUtil.createGet(host + LcApiConstants.GRID_GET_GETALL_SEARCH_PAGE_URL);
        request.auth(getAuthToken());
        request.form("areaId", areaId);
        request.form("limit", pageSize);
        request.form("page", pageNum);
        if (StringUtils.isNotEmpty(param)) {
            request.form("param", param);
        }
        HttpResponse result = request.execute();
        LcReturnObject returenData = JSONObject.parseObject(result.body(), LcReturnObject.class);
        return JSONArray.parseArray(returenData.getData(), GridMemberPageListDTO.class);
    }

    @Override
    public void automationUploadEventAndFile() {
        List<EventDetailsVO> unUploadEventList = gridService.getUnUploadEvent();
        unUploadEventList.forEach(eventInfoVo -> {
            log.info("定时向浪潮服务器提交网格事件登记开始");
            EventInfo eventInfo = new EventInfo();
            String lcGrid = gridService.getLcGridIdByLocal(eventInfoVo.getGridId());
            String lcGridUserId = gridService.getLcUserIdByLocalUserId(eventInfoVo.getGridMemberId().toString());
            eventInfo.setGridId(lcGrid);
            R grid = gridService.eventGridDataDetails(eventInfoVo.getGridId());
            EventGridDataDetailsVO gridData = (EventGridDataDetailsVO)grid.getData();
            eventInfo.setGridName(gridData.getGridName());
            eventInfo.setCaseTypeCode(LocalEventToLangChaoEventTypeEnum.getCodeByName(eventInfoVo.getEventType()));
            String caseTypeName = LocalEventToLangChaoEventTypeEnum.getEventNameByCode(eventInfoVo.getEventType());
            eventInfo.setCaseTypeName(caseTypeName);
            if (eventInfoVo.getEventCategory() != 1L) {
                eventInfo.setHappenTime(String.valueOf(eventInfoVo.getPropagandaTime().getTime()));
            } else {
                eventInfo.setHappenTime(String.valueOf(eventInfoVo.getHappenTime().getTime()));
            }
            eventInfo.setHappenAddress(eventInfoVo.getHappenAddress());
            String[] data = eventInfoVo.getHappentLatLng().split(",");
            eventInfo.setLongitude(data[0]);
            eventInfo.setLatitude(data[1]);
            eventInfo.setCaseDescription(eventInfoVo.getEventDes());
            eventInfo.setCaseRecordTime(String.valueOf(eventInfoVo.getCreateAt().getTime()));
            eventInfo.setHandleType("REPORT");
            eventInfo.setHandleDescription(eventInfoVo.getProcessDesc());
            eventInfo.setDataId(eventInfoVo.getId().toString());
            // 获取系统网格员映射的浪潮网格员对于的用户ID
            eventInfo.setUserId(lcGridUserId);
            eventInfo.setHandleTime(DateUtils.getCurrentDateTimeStamp().toString());
            eventInfo.setCaseName(gridData.getGridName().concat(caseTypeName));
            log.info("事件请求数据：{}", JSONObject.toJSONString(eventInfo));
            String remoteData = submitEventRegister(eventInfo);
            LcReturnObject lcReturnObject = JSONObject.parseObject(remoteData, LcReturnObject.class);
            log.info("提交浪潮服务器，接口返回结果为：{}", remoteData);
            if (lcReturnObject.getSuccess()) {
                log.info("定时向浪潮服务器提交网格事件登记结束");
                log.info("开始上传附件信息");
                List<EventResourceVO> picsList = eventInfoVo.getPics();
                uploadLcApiEventFile(eventInfoVo, picsList, "png");
                List<EventResourceVO> audiosList = eventInfoVo.getAudios();
                uploadLcApiEventFile(eventInfoVo, audiosList, "mp3");
                List<EventResourceVO> videoList = eventInfoVo.getVideos();
                uploadLcApiEventFile(eventInfoVo, videoList, "mp4");
                log.info("结束上传附件信息");
                gridService.updateLcUploadFlag(eventInfoVo.getId());
            }
        });
    }

    @Override
    public String getFlowPersonVisitRecordDetailById(String recordId) {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.VISIT_RECORD_FLOW_PERSON_DETAIL_URL);
        request.auth(getAuthToken());
        request.form("id", recordId);
        HttpResponse result = request.execute();
        return result.body();
    }

    @Override
    public String getFlowPersonVisitRecordPage(LcKeyPersonVisitRecordQueryDTO personVisitRecordQueryDTO,
        Long loginUserId) {
        HttpResponse result = getHttpResponse(personVisitRecordQueryDTO, loginUserId,
            host +
            LcApiConstants.VISIT_RECORD_FLOW_PERSON_PAGE_URL, "flowPeopleId");
        return result.body();
    }

    @Override
    public String uploadFlowPersonVisitRecord(LcFlowPersonVisitRecordDTO lcFlowPersonVisitRecordDTO) {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.VISIT_RECORD_FLOW_PERSON_SAVE_URL);
        request.auth(getAuthToken());
        ObjectMapper mapper = new ObjectMapper();
        try {
            // 对象转map
            Map m = mapper.readValue(mapper.writeValueAsString(lcFlowPersonVisitRecordDTO), Map.class);
            request.form(m);
        } catch (JsonProcessingException e) {
            log.info("方法uploadFlowPersonVisitRecord发生错误：{}", e.getMessage());
        }
        HttpResponse result = request.execute();
        log.info("uploadFlowPersonVisitRecord上传浪潮事件信息：{}", result.body());
        return result.body();
    }

    @Override
    public String uploadKeyPersonVisitRecord(LcKeyPersonVisitRecordDTO lcKeyPersonVisitRecordDTO) {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.VISIT_RECORD_KEY_PERSON_SAVE_REMOTE_URL);
        request.auth(getAuthToken());
        ObjectMapper mapper = new ObjectMapper();
        try {
            // 对象转map
            Map m = mapper.readValue(mapper.writeValueAsString(lcKeyPersonVisitRecordDTO), Map.class);
            request.form(m);
        } catch (JsonProcessingException e) {
            log.info("方法uploadKeyPersonVisitRecord发生错误：{}", e.getMessage());
        }
        HttpResponse result = request.execute();
        log.info("uploadKeyPersonVisitRecord上传浪潮事件信息：{}", result.body());
        return result.body();
    }

    @Override
    public String getKeyPersonVisitRecordDetailById(String recordId) {
        HttpRequest request = HttpUtil.createPost(host + LcApiConstants.VISIT_RECORD_KEY_PERSON_DETAIL_URL);
        request.auth(getAuthToken());
        request.form("id", recordId);
        HttpResponse result = request.execute();
        return result.body();
    }

    @Override
    public String getKeyPersonVisitRecordPage(LcKeyPersonVisitRecordQueryDTO personVisitRecordQueryDTO,
        Long loginUserId) {
        HttpResponse result = getHttpResponse(personVisitRecordQueryDTO, loginUserId,
            host +
            LcApiConstants.VISIT_RECORD_KEY_PERSON_PAGE_URL, "keyPersonId");
        return result.body();
    }

    @Override
    public void automationUploadVisitRecord() {
        List<LcEventVisitingTasksListDTO> unUploadTaskList = gridService.getUnUploadVisitingTask();
        unUploadTaskList.forEach(lcEventVisitingTasksListDTO -> {
            String lcGrid = gridService.getLcGridIdByLocal(lcEventVisitingTasksListDTO.getGridId());
            String lcGridUserId =
                gridService.getLcUserIdByLocalUserId(lcEventVisitingTasksListDTO.getGridMember().toString());
            R populationDetail = communityService.detailPopulation(lcEventVisitingTasksListDTO.getVisiterId(), null);
            ComMngPopulationVO comMngPopulationVO = (ComMngPopulationVO)populationDetail.getData();
            BcDictionaryItemVO diction = communityService.getByCode(DictionItemConstants.LC_CULTURE_LEVEL,
                comMngPopulationVO.getCultureLevel().toString());
            ComMngPopulationDTO comMngPopulationDTO =
                CopyUtil.copyProperties(comMngPopulationVO, ComMngPopulationDTO.class);
            if (diction != null) {
                comMngPopulationDTO.setCultureLevel(diction.getDictItemName());
            }
            R grid = gridService.eventGridDataDetails(lcEventVisitingTasksListDTO.getGridId());
            EventGridDataDetailsVO gridData = (EventGridDataDetailsVO)grid.getData();
            String[] data = lcEventVisitingTasksListDTO.getHappentLatLng().split(",");
            if (lcEventVisitingTasksListDTO.getVisiterType() != null) {
                log.info("上传数据导重点人口走访记录表");
                LcReturnObject lcReturnObject = requestLcKeyPersonVisitRecord(lcEventVisitingTasksListDTO, lcGrid,
                    lcGridUserId, comMngPopulationDTO, gridData.getGridName(), data);
                if (LcRequestEnum.SUCCESS.getCode().equals(lcReturnObject.getCode())) {
                    uploadVisitRecord(lcEventVisitingTasksListDTO);
                    gridService.updateLcUploadFlagVisitingTask(lcEventVisitingTasksListDTO.getId());
                }
            } else {
                log.info("上传数据导流动人口走访记录表");
                LcReturnObject lcReturnObject = requestLcFlowPersonVisitRecord(lcEventVisitingTasksListDTO, lcGrid,
                    lcGridUserId, comMngPopulationDTO, gridData.getGridName(), data);
                if (LcRequestEnum.SUCCESS.getCode().equals(lcReturnObject.getCode())) {
                    uploadVisitRecord(lcEventVisitingTasksListDTO);
                    gridService.updateLcUploadFlagVisitingTask(lcEventVisitingTasksListDTO.getId());
                }
            }
        });
    }

    private void uploadVisitRecord(LcEventVisitingTasksListDTO lcEventVisitingTasksListDTO) {
        log.info("开始上传走访任务附件文件");
        List<EventResourceVO> picsList = lcEventVisitingTasksListDTO.getPics();
        uploadVisitRecordFile(lcEventVisitingTasksListDTO, picsList, "IMAGE");
        List<EventResourceVO> audiosList = lcEventVisitingTasksListDTO.getAudios();
        uploadVisitRecordFile(lcEventVisitingTasksListDTO, audiosList, "AUDIO");
        List<EventResourceVO> videoList = lcEventVisitingTasksListDTO.getVideos();
        uploadVisitRecordFile(lcEventVisitingTasksListDTO, videoList, "VIDEO");
        log.info("结束上传走访任务附件文件");
    }

    private void uploadVisitRecordFile(LcEventVisitingTasksListDTO lcEventVisitingTasksListDTO,
        List<EventResourceVO> picsList, String type) {
        picsList.forEach(eventResourceVO -> {
            EventFile eventFile = new EventFile();
            eventFile.setDataId(lcEventVisitingTasksListDTO.getId().toString());
            eventFile.setFiles(eventResourceVO.getUrl());
            eventFile.setType(type);
            eventFile.setModule("key_person");
            eventFile.setFileName(eventResourceVO.getResourceName());
            submitEventOrVisitRecordRelationFile(eventFile);
        });
    }

    @Override
    public LcReturnObject requestLcFlowPersonVisitRecord(LcEventVisitingTasksListDTO lcEventVisitingTasksListDTO,
        String lcGrid, String lcGridUserId, Object populationDetail, String gridName, String[] data) {
        // 如果是流动人口走访
        LcFlowPersonVisitRecordDTO lcFlowPersonVisitRecordDTO = new LcFlowPersonVisitRecordDTO();
        lcFlowPersonVisitRecordDTO.setId(lcEventVisitingTasksListDTO.getId().toString());
        lcFlowPersonVisitRecordDTO.setUserId(lcGridUserId);
        lcFlowPersonVisitRecordDTO.setGridPersonName(lcEventVisitingTasksListDTO.getGridMemberName());
        lcFlowPersonVisitRecordDTO.setGridPersonPhone(lcEventVisitingTasksListDTO.getGridMenberTele());
        JSONObject population = (JSONObject)JSONObject.toJSON(populationDetail);
        lcFlowPersonVisitRecordDTO.setComMngPopulation(population.toJSONString());
        lcFlowPersonVisitRecordDTO.setGridId(lcGrid);
        lcFlowPersonVisitRecordDTO.setGridName(gridName);
        lcFlowPersonVisitRecordDTO.setWorkWithPoliceMan("0");
        lcFlowPersonVisitRecordDTO.setPoliceManName(null);
        lcFlowPersonVisitRecordDTO.setPoliceManPhone(null);
        lcFlowPersonVisitRecordDTO.setPoliceManWorkContent(null);
        lcFlowPersonVisitRecordDTO.setVisitTime(lcEventVisitingTasksListDTO.getHappenTime().getTime());
        lcFlowPersonVisitRecordDTO.setVisitAddress(lcEventVisitingTasksListDTO.getHappentAddress());
        lcFlowPersonVisitRecordDTO.setLongitude(Double.valueOf(data[0]));
        lcFlowPersonVisitRecordDTO.setLatitude(Double.valueOf(data[1]));
        lcFlowPersonVisitRecordDTO.setHouseType(null);
        lcFlowPersonVisitRecordDTO.setHouseAddress(lcEventVisitingTasksListDTO.getHappentAddress());
        lcFlowPersonVisitRecordDTO.setIsReportInfo(null);
        lcFlowPersonVisitRecordDTO.setHaveCertificate("0");
        lcFlowPersonVisitRecordDTO.setCertificateType("身份证");
        lcFlowPersonVisitRecordDTO.setCertificateNumber(population.getString("cardNo"));
        lcFlowPersonVisitRecordDTO.setCertificateDeadTime("0");
        lcFlowPersonVisitRecordDTO.setIsPropaganda("1");
        lcFlowPersonVisitRecordDTO.setIsCheckReview("1");
        lcFlowPersonVisitRecordDTO.setIsAbnormal(lcEventVisitingTasksListDTO.getException().toString());
        lcFlowPersonVisitRecordDTO.setAbnormalSituation(lcEventVisitingTasksListDTO.getTableContentJson());
        lcFlowPersonVisitRecordDTO.setRemark(lcEventVisitingTasksListDTO.getEventDes());
        log.info("requestLcFlowPersonVisitRecord事件请求数据：{}", JSONObject.toJSONString(lcFlowPersonVisitRecordDTO));
        String flowPersonData = uploadFlowPersonVisitRecord(lcFlowPersonVisitRecordDTO);
        LcReturnObject lcReturnObject = JSONObject.parseObject(flowPersonData, LcReturnObject.class);
        log.info("requestLcFlowPersonVisitRecord提交浪潮服务器，接口返回结果为：{}", lcReturnObject);
        return lcReturnObject;
    }

    @Override
    public LcReturnObject requestLcKeyPersonVisitRecord(LcEventVisitingTasksListDTO lcEventVisitingTasksListDTO,
        String lcGrid, String lcGridUserId, Object populationDetail, String gridName, String[] data) {
        LcKeyPersonVisitRecordDTO keyPersonVisitRecordDTO = new LcKeyPersonVisitRecordDTO();
        keyPersonVisitRecordDTO.setId(lcEventVisitingTasksListDTO.getId().toString());
        keyPersonVisitRecordDTO.setUserId(lcGridUserId);
        keyPersonVisitRecordDTO.setGridPersonName(lcEventVisitingTasksListDTO.getGridMemberName());
        keyPersonVisitRecordDTO.setGridPersonPhone(lcEventVisitingTasksListDTO.getGridMenberTele());
        keyPersonVisitRecordDTO.setComMngPopulation(JSONObject.toJSONString(populationDetail));
        keyPersonVisitRecordDTO.setGridId(lcGrid);
        keyPersonVisitRecordDTO.setGridName(gridName);
        keyPersonVisitRecordDTO.setVisitTime(lcEventVisitingTasksListDTO.getHappenTime().getTime());
        keyPersonVisitRecordDTO.setVisitAddress(lcEventVisitingTasksListDTO.getHappentAddress());
        keyPersonVisitRecordDTO.setLongitude(Double.valueOf(data[0]));
        keyPersonVisitRecordDTO.setLatitude(Double.valueOf(data[1]));
        keyPersonVisitRecordDTO.setFamilyMemberContact(lcEventVisitingTasksListDTO.getFamilyPhone());
        keyPersonVisitRecordDTO.setHowLive(lcEventVisitingTasksListDTO.getFamilySource());
        keyPersonVisitRecordDTO.setIsAbnormal(lcEventVisitingTasksListDTO.getException().toString());
        keyPersonVisitRecordDTO.setAbnormalSituation(null);
        keyPersonVisitRecordDTO.setAbnormalDes(lcEventVisitingTasksListDTO.getTableContentJson());
        keyPersonVisitRecordDTO.setRemark(lcEventVisitingTasksListDTO.getEventDes());
        keyPersonVisitRecordDTO
            .setType(LcVisitRecordKeyPersonLabelEnum.getCnDescByName(lcEventVisitingTasksListDTO.getVisiterType()));
        log.info("requestLcKeyPersonVisitRecord事件请求数据：{}", JSONObject.toJSONString(keyPersonVisitRecordDTO));
        String remoteData = uploadKeyPersonVisitRecord(keyPersonVisitRecordDTO);
        LcReturnObject lcReturnObject = JSONObject.parseObject(remoteData, LcReturnObject.class);
        log.info("requestLcKeyPersonVisitRecord提交浪潮服务器，接口返回结果为：{}", remoteData);
        return lcReturnObject;
    }

    private HttpResponse getHttpResponse(LcKeyPersonVisitRecordQueryDTO personVisitRecordQueryDTO, Long loginUserId,
        String requestUrl, String flowPeopleId) {
        HttpRequest request = HttpUtil.createPost(requestUrl);
        request.auth(getAuthToken());
        request.form("userId", loginUserId);
        request.form("gridId", personVisitRecordQueryDTO.getGridId());
        request.form("limit", personVisitRecordQueryDTO.getLimit());
        request.form("startNumber", personVisitRecordQueryDTO.getStartNumber());
        request.form(flowPeopleId, personVisitRecordQueryDTO.getPersonId());
        return request.execute();
    }

    private void uploadLcApiEventFile(EventDetailsVO eventInfoVo, List<EventResourceVO> picsList, String type) {
        picsList.forEach(eventResourceVO -> {
            EventFile eventFile = new EventFile();
            eventFile.setDataId(eventInfoVo.getId().toString());
            eventFile.setFiles(eventResourceVO.getUrl());
            eventFile.setType(type);
            eventFile.setModule("event");
            eventFile.setFileName(eventResourceVO.getResourceName());
            submitEventOrVisitRecordRelationFile(eventFile);
        });
    }
}