更新

MrShi

2025-03-12 69a1b3bf45738f048361ee4ccb6bdc64fce35720

 server/visits/dmvisit_admin/src/main/java/com/doumee/cloud/admin/HkSyncCloudController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,305 @@
package com.doumee.cloud.admin;

import com.alibaba.fastjson.JSONObject;
import com.doumee.api.BaseController;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.config.annotation.CloudRequiredPermission;
import com.doumee.config.annotation.LoginNoRequired;
import com.doumee.config.jwt.JwtProperties;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.haikang.model.param.BaseResponse;
import com.doumee.core.haikang.model.param.request.*;
import com.doumee.core.haikang.model.param.request.event.acs.EventAcsRequest;
import com.doumee.core.haikang.model.param.request.event.parks.EventParkRequest;
import com.doumee.core.haikang.model.param.request.event.parks.EventPlatformCarsRequest;
import com.doumee.core.haikang.model.param.request.event.parks.EventPlatformRequest;
import com.doumee.core.haikang.model.param.request.event.visit.EventVisitIccmRequest;
import com.doumee.core.haikang.model.param.request.event.visit.EventVisitRequest;
import com.doumee.core.haikang.service.HKService;
import com.doumee.service.business.third.model.ApiResponse;
import com.doumee.service.business.third.model.LoginUserInfo;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.DESUtil;
import com.doumee.dao.business.model.Device;
import com.doumee.service.business.DeviceService;
import com.doumee.service.business.impl.hksync.*;
import com.doumee.service.business.impl.hksync.ferp.HkSyncOrgUserToHKServiceImpl;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author æ±Ÿè¹„蹄
 * @date 2023/11/30 15:33
 */
@Api(tags = "海康数据同步接口")
@RestController
@Slf4j
@RequestMapping(Constants.CLOUD_SERVICE_URL_INDEX+"/business/hksync")
public class HkSyncCloudController extends BaseController {

    @Autowired
    private HkSyncPlatformsServiceImpl hkSyncPlatformsService;
    @Autowired
    private HkSyncDeviceServiceImpl hkSyncDeviceService;
    @Autowired
    private HkSyncParkServiceImpl hkSyncParkService;
    @Autowired
    private HkSyncPrivilegeServiceImpl hkSyncPrivilegeService;
    @Autowired
    private HkSyncPushServiceImpl hkSyncPushService;
    @Autowired
    private HkSyncOrgUserToHKServiceImpl hkSyncOrgUserToHKService;
    @Autowired
    private HkSyncNoticeServiceImpl hkSyncNoticeService;
    @Autowired
    private HkSyncLoginAuthServiceImpl hkSyncLoginAuthService;

    @Autowired
    private SystemDictDataBiz systemDictDataBiz;
    @Autowired
    private DeviceService deviceService;

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    @Autowired
    private JwtProperties jwtProperties;

    @PreventRepeat
    @ApiOperation("【海康】全量同步月台信息接口")
    @PostMapping("/syncPlatforms")
    @CloudRequiredPermission("business:hksync:platforms")
    public ApiResponse syncPlatforms(@RequestBody PlatformsListRequest param) {
        String result = hkSyncPlatformsService.syncPlatforms(param);
        return ApiResponse.success(result);
    }
    @PreventRepeat
    @ApiOperation("【海康】全量同步月台状态信息接口")
    @PostMapping("/syncPlatformStatus")
    @CloudRequiredPermission("business:hksync:platforms")
    public ApiResponse syncPlatformStatus(@RequestBody PlatformStatusRequest param) {
        String result = hkSyncPlatformsService.getPlatformStatus(param);
        return ApiResponse.success(result);
    }
    @PreventRepeat
    @ApiOperation("【海康】全量同步门禁设备接口")
    @PostMapping("/syncDevices")
    @CloudRequiredPermission("business:hksync:device")
    public ApiResponse syncHkDevices(@RequestBody Device param, @RequestHeader(Constants.HEADER_USER_TOKEN) String token){
        String result = null;
        if(Constants.equalsInteger(param.getType(),Constants.ZERO)){
             result = hkSyncDeviceService.syncHkDevices(param);
        }else if(Constants.equalsInteger(param.getType(),Constants.TWO)){
            //同步LED
            result = hkSyncDeviceService.syncHkLed(param);
        }else if(Constants.equalsInteger(param.getType(),Constants.THREE)){
            //同步广播
            result = hkSyncDeviceService.syncHkBroadcast(param);
        }
        return ApiResponse.success(result);
    }
    @PreventRepeat
    @ApiOperation("【海康】保存海康用户绑定openid")
    @PostMapping("/saveHkUserOpenid")
    public ApiResponse syncHkUserOpenid( @RequestHeader(Constants.HEADER_USER_TOKEN) String token){
        String result     = hkSyncOrgUserToHKService.syncHkUserOpenid(this.getLoginUser(token).getId());
        return ApiResponse.success(result);
    }
    @PreventRepeat
    @ApiOperation("【海康】清空海康用户绑定openid")
    @PostMapping("/delHkUserOpenid")
    @LoginNoRequired
    public ApiResponse delHkUserOpenid( @RequestBody UserOpenidSaveRequest param){
        String result     = hkSyncOrgUserToHKService.delHkUserOpenid(param);
        return ApiResponse.success(result);
    }
    @PreventRepeat
    @ApiOperation("【海康】获取组件授权登录地址接口")
    @PostMapping("/getServiceUrl")
    public ApiResponse getServiceUrl(@RequestBody HKGetServiceLoginUrlRequest param,@RequestHeader(Constants.HEADER_USER_TOKEN) String token){
        param.setUsername(this.getLoginUser(token).getUsername());
        String result = hkSyncLoginAuthService.getServiceUrl(param);
        return ApiResponse.success(result);
    }
    @PreventRepeat
    @ApiOperation("【海康】全量同步停车库接口")
    @PostMapping("/syncParks")
    @CloudRequiredPermission("business:hksync:park")
    public ApiResponse syncHkParks(@RequestBody ParkListRequest param,@RequestHeader(Constants.HEADER_USER_TOKEN) String token){
        String result = hkSyncParkService.syncHkParks(param);
        return ApiResponse.success(result);
    }
    @PreventRepeat
    @ApiOperation("【海康】全量同步访客权限组接口")
    @PostMapping("/syncPrivilege")
    @CloudRequiredPermission("business:hksync:privilege")
    public ApiResponse syncPrivilege(@RequestBody PrivilegeGroupRequest param,@RequestHeader(Constants.HEADER_USER_TOKEN) String token){
        String result = hkSyncPrivilegeService.syncPrivilege(param);
        return ApiResponse.success(result);
    }
//    @PreventRepeat
    @ApiOperation("【海康】门禁事件订阅推送对接处理接口")
    @PostMapping("/push/acs")
    @LoginNoRequired
    public ApiResponse pushAcs(  HttpServletRequest request,@RequestBody EventAcsRequest param, HttpServletResponse response ){
        String result = hkSyncPushService.dealAcsEvent(param,response);
        return ApiResponse.success(result);
    }
//    @PreventRepeat
    @ApiOperation("【海康】访客事件订阅推送对接处理接口")
    @PostMapping("/push/visit")
    @LoginNoRequired
    public ApiResponse pushVisit(@RequestBody EventVisitRequest param, HttpServletResponse response){
        String result = hkSyncPushService.dealVisitEvent(param,response);
        return ApiResponse.success(result);
    }
    @ApiOperation("【海康】访客ICCM事件订阅推送对接处理接口")
    @PostMapping("/push/visitIccm")
    @LoginNoRequired
    public ApiResponse pushVisitIccm(@RequestBody EventVisitIccmRequest param, HttpServletResponse response) {
        String result = hkSyncPushService.dealVisitEventIccm(param,response);
        return ApiResponse.success(result);
    }
    @ApiOperation("【海康】测试LED显示屏")
    @PostMapping("/testLed")
    @LoginNoRequired
    public ApiResponse<BaseResponse> testLed(@RequestBody TransparentChannelBodyRequest request, HttpServletResponse response) {
        TransparentChannelHeadRequest head = new TransparentChannelHeadRequest();
        head.setAbility("cld");//固定值
        head.setTreatyType("haixuan_led_net");//固定值
        head.setDeviceIndexCode("6a5498e9df924befbb9530e467e5e809");
        return ApiResponse.success(HKService.transparentchannel(head,request));
    }
    @ApiOperation("【海康】测试广播播报")
    @PostMapping("/testBroadcast")
    @LoginNoRequired
    public ApiResponse<BaseResponse> testBroadcast(@RequestBody CustomBroadcastRequest request, HttpServletResponse response) {
        return ApiResponse.success(  HKService.customBroadcast(request));
    }
//    @PreventRepeat
    @ApiOperation("【海康】停车场事件订阅推送对接处理接口")
    @PostMapping("/push/parks")
    @LoginNoRequired
    public ApiResponse pushParks(@RequestBody EventParkRequest param, HttpServletResponse response ){
        String result = hkSyncPushService.dealParkEvent(param,response);
        return ApiResponse.success(result);
    }
    @ApiOperation("【海康】月台工作状态事件订阅推送对接处理接口")
    @PostMapping("/push/platform/workstatus")
    @LoginNoRequired
    public ApiResponse pushPlatformStatus(@RequestBody EventPlatformRequest param, HttpServletResponse response ){
        String result = hkSyncPushService.dealPlatformStatusEvent(param,response);
        return ApiResponse.success(result);
    }
    @ApiOperation("【海康】月台车辆状态事件订阅推送对接处理接口")
    @PostMapping("/push/platform/carstatus")
    @LoginNoRequired
    public ApiResponse pushPlatformCarStatus(@RequestBody EventPlatformCarsRequest param, HttpServletResponse response ){
        String result = hkSyncPushService.dealPlatformCarsEvent(param,response);
        return ApiResponse.success(result);
    }
    @ApiOperation("【海康test】月台车辆状态事件订阅推送对接处理接口")
    @PostMapping("/push/platform/carstatusTest")
    @LoginNoRequired
    public ApiResponse pushPlatformCarStatus(HttpServletRequest request, HttpServletResponse response ){
        doPringParam(request,"【海康test】月台车辆状态事件订阅推送对接处理接口:\n");
         return ApiResponse.success(null);
    }
    public   void doPringParam(HttpServletRequest request,String name) {
        try {
            StringBuilder data =new StringBuilder();
            String line;
            BufferedReader reader =request.getReader();
            while(null !=(line = reader.readLine())) {
                data.append(line);
            }
            if(StringUtils.isNotBlank( data.toString())){
                log.info(name+"=================参数："+ data.toString());
            }else {
                log.info(name+"=================：参数为空");
            }
        }catch (Exception e){

            log.info(name+"================= å‚数异常："+e.getMessage());
        }
    }
    @PreventRepeat
    @ApiOperation("【海康】取消订阅事件")
    @PostMapping("/cancelEventSub")
    @LoginNoRequired
    public ApiResponse cancelEventSub(@RequestBody EventSubRequest param, HttpServletResponse response){
         hkSyncPushService.cancelEventSub();
        return ApiResponse.success(null);
    }

    /**
     * èŽ·å–安防平台系统免密菜单调整地址
     * @return
     */
    @ApiOperation(value = "获取安防平台系统免密菜单调整地址" )
    @PostMapping("/getHkMenuLink/{type}")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", dataType = "Integer", name = "type",example = "0",value = "菜单类型", required = true),
    })
    public ApiResponse<String> getHkMenuLink(@PathVariable Integer type,@RequestHeader(Constants.HEADER_USER_TOKEN) String token){
        LoginUserInfo loginUserInfo = this.getLoginUser(token);
        String hkToken = DESUtil.generateTokenToHk(loginUserInfo.getUsername(),Integer.valueOf(
          systemDictDataBiz.queryByCode(Constants.HK_PARAM,Constants.HK_TOKEN_VALIDITY).getCode()
        ),redisTemplate);
        String url = systemDictDataBiz.queryByCode(Constants.HK_PARAM,Constants.HK_HTTPS).getCode() +
        systemDictDataBiz.queryByCode(Constants.HK_PARAM,Constants.HK_HOST).getCode()
                 + HKService.getMenuUrl(type,hkToken);
        try {
            if(redisTemplate!=null&& jwtProperties!=null){
                loginUserInfo.setHkMenuToken(hkToken);
                redisTemplate.opsForValue().set(Constants.REDIS_TOKEN_KEY+token, JSONObject.toJSONString(loginUserInfo),jwtProperties.getExpiration(), TimeUnit.MILLISECONDS);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return ApiResponse.success( url);
    }

    @ApiOperation(value = "获取安防平台系统免密菜单配置" )
    @GetMapping("/getHkMenuConfig")
    public ApiResponse<List<Integer>> getHkMenuConfig(@RequestHeader(Constants.HEADER_USER_TOKEN) String token){
        LoginUserInfo loginUserInfo = getLoginUser(token);
        List<Integer> menuConfigList = new ArrayList<>();
        if(Objects.nonNull(loginUserInfo) && StringUtils.isNotBlank(loginUserInfo.getUsername())){
            menuConfigList = hkSyncPlatformsService.getMenuConfig(loginUserInfo.getUsername());
        }
        return ApiResponse.success(menuConfigList);
    }


    @ApiOperation("【海康】代办消息数据集合对接处理接口")
    @PostMapping("/notice/getList")
    public ApiResponse getNoticeList( HttpServletResponse response,@RequestHeader(Constants.HEADER_USER_TOKEN) String token ){
        String result = hkSyncNoticeService.syncHkNotices(this.getLoginUser(token).getUsername());
        return ApiResponse.success(result);
    }



    @ApiOperation("【海康】设置LED屏文案")
    @PostMapping("/setLedContent")
    public ApiResponse<List<Map<String,Object>>> setLedContent(@RequestBody TransparentChannelSingleRequest body  , HttpServletResponse response) {
        deviceService.setLedContent(body);
        return ApiResponse.success(null);
    }

}