init

pom.xml

@@ -0,0 +1,150 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>ruoyi-modules</artifactId>
+        <groupId>com.ruoyi</groupId>
+        <version>3.4.0</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.sooka.onest</groupId>
+    <artifactId>center-monitor-pollingPositionMsg</artifactId>
+
+
+    <dependencies>
+        <!-- SpringCloud Alibaba Nacos -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
+        </dependency>
+
+        <!-- SpringCloud Alibaba Nacos Config -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
+        </dependency>
+
+        <!-- SpringCloud Alibaba Sentinel -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
+        </dependency>
+
+        <!-- Sentinel Datasource Nacos -->
+        <dependency>
+            <groupId>com.alibaba.csp</groupId>
+            <artifactId>sentinel-datasource-nacos</artifactId>
+        </dependency>
+
+        <!-- SpringBoot Actuator -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+
+        <!-- Swagger UI -->
+        <dependency>
+            <groupId>io.springfox</groupId>
+            <artifactId>springfox-swagger-ui</artifactId>
+            <version>${swagger.fox.version}</version>
+        </dependency>
+
+        <!-- Mysql Connector -->
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+        </dependency>
+
+        <!-- RuoYi Common DataSource -->
+        <dependency>
+            <groupId>com.ruoyi</groupId>
+            <artifactId>sooka-sponest-common-datasource</artifactId>
+        </dependency>
+
+        <!-- RuoYi Common DataScope -->
+        <dependency>
+            <groupId>com.ruoyi</groupId>
+            <artifactId>sooka-sponest-common-datascope</artifactId>
+        </dependency>
+
+        <!-- RuoYi Common Log -->
+        <dependency>
+            <groupId>com.ruoyi</groupId>
+            <artifactId>sooka-sponest-common-log</artifactId>
+        </dependency>
+
+        <!-- RuoYi Common Swagger -->
+        <dependency>
+            <groupId>com.ruoyi</groupId>
+            <artifactId>sooka-sponest-common-swagger</artifactId>
+        </dependency>
+
+        <!--海康-->
+        <dependency>
+            <groupId>com.hikvision.ga</groupId>
+            <artifactId>artemis-http-client</artifactId>
+            <version>1.1.3</version>
+        </dependency>
+
+        <!-- ICC鉴权 -->
+        <dependency>
+            <groupId>com.dahuatech.icc</groupId>
+            <artifactId>java-sdk-oauth</artifactId>
+            <version>1.0.9</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>java-sdk-core</artifactId>
+                    <groupId>com.dahuatech.icc</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>com.dahuatech.icc</groupId>
+            <artifactId>java-sdk-core</artifactId>
+            <version>1.0.9</version>
+        </dependency>
+
+        <!-- mp4文件操作jar -->
+        <!-- https://mvnrepository.com/artifact/com.googlecode.mp4parser/isoparser -->
+        <dependency>
+            <groupId>com.googlecode.mp4parser</groupId>
+            <artifactId>isoparser</artifactId>
+            <version>1.1.22</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>${project.artifactId}</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>2.1.5.RELEASE</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <artifactId>maven-resources-plugin</artifactId>
+                <configuration>
+                    <nonFilteredFileExtensions>
+                        <nonFilteredFileExtension>xdb</nonFilteredFileExtension>
+                    </nonFilteredFileExtensions>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+

src/main/java/com/sooka/sponest/monitor/SookaMonitorPollingPositionMsgApplication.java

@@ -0,0 +1,39 @@
+package com.sooka.sponest.monitor;
+
+import com.ruoyi.common.security.annotation.EnableCustomConfig;
+import com.ruoyi.common.security.annotation.EnableRyFeignClients;
+import com.ruoyi.common.swagger.annotation.EnableCustomSwagger2;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.web.servlet.MultipartConfigFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.util.unit.DataSize;
+
+import javax.servlet.MultipartConfigElement;
+
+@EnableAsync
+@EnableCustomConfig
+@EnableCustomSwagger2
+@EnableRyFeignClients
+@SpringBootApplication
+public class SookaMonitorPollingPositionMsgApplication {
+    public static void main(String[] args) {
+        SpringApplication.run(SookaMonitorPollingPositionMsgApplication.class, args);
+        System.out.println("(♥◠‿◠)ﾉﾞ  首佳科技 一体化 对接大华根据组织获取执法记录仪、单兵设备在线状态任务 启动成功   ლ(´ڡ`ლ)ﾞ  \n" +
+                "  __________   ____ |  | _______          ____________   ____   ____   ____   _______/  |_\n" +
+                " /  ___/  _ \\ /  _ \\|  |/ /\\__  \\        /  ___/\\____ \\ /  _ \\ /    \\_/ __ \\ /  ___/\\   __\\\n" +
+                " \\___ (  <_> |  <_> )    <  / __ \\_      \\___ \\ |  |_> >  <_> )   |  \\  ___/ \\___ \\  |  |\n" +
+                "/____  >____/ \\____/|__|_ \\(____  /     /____  >|   __/ \\____/|___|  /\\___  >____  > |__|\n" +
+                "     \\/                  \\/     \\/           \\/ |__|               \\/     \\/     \\/\n"
+        );
+    }
+
+    @Bean
+    public MultipartConfigElement multipartConfigElement() {
+        MultipartConfigFactory factory = new MultipartConfigFactory();
+        factory.setMaxFileSize(DataSize.parse("10240000KB"));
+        factory.setMaxRequestSize(DataSize.parse("10240000KB"));
+        return factory.createMultipartConfig();
+    }
+}

src/main/java/com/sooka/sponest/monitor/base/controller/BaseController.java

@@ -0,0 +1,11 @@
+package com.sooka.sponest.monitor.base.controller;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/BaseController")
+public class BaseController {
+
+
+}

src/main/java/com/sooka/sponest/monitor/base/domain/BaseBusinessEntity.java

@@ -0,0 +1,52 @@
+package com.sooka.sponest.monitor.base.domain;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+@Getter
+@Setter
+public class BaseBusinessEntity {
+
+    /**
+     * 搜索值
+     */
+    String searchValue;
+
+    Long dataDeptId;
+
+    /**
+     * 创建者
+     */
+    Long createBy;
+    /**
+     * 创建者
+     */
+    String remark;
+    /**
+     * 请求参数
+     */
+    Map<String, Object> params = new HashMap();
+    String database_system;
+    String database_event;
+    String database_data;
+    /**
+     * 创建时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private Date createTime = new Date();
+    /**
+     * 更新者
+     */
+    private Long updateBy;
+    /**
+     * 更新时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private Date updateTime;
+
+}

src/main/java/com/sooka/sponest/monitor/base/domain/DataTestVO.java

@@ -0,0 +1,13 @@
+package com.sooka.sponest.monitor.base.domain;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class DataTestVO extends BaseBusinessEntity {
+
+    String name;
+
+
+}

src/main/java/com/sooka/sponest/monitor/base/service/impl/BaseService.java

@@ -0,0 +1,73 @@
+package com.sooka.sponest.monitor.base.service.impl;
+
+import com.ruoyi.common.datascope.base.domain.BaseBusinessEntity;
+import com.ruoyi.common.redis.service.RedisService;
+import com.ruoyi.common.security.service.TokenService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BaseService {
+
+    @Value("${sooka.database.database_system:}")
+    public String database_system;
+    @Value("${sooka.database.database_event:}")
+    public String database_event;
+    @Value("${sooka.database.database_data:}")
+    public String database_data;
+    @Value("${sooka.dahua_video_server.loginIp:}")
+    public String loginIp;
+    @Value("${sooka.dahua_video_server.userName:}")
+    public String userName;
+    @Value("${sooka.dahua_video_server.userPwd:}")
+    public String userPwd;
+    @Value("${sooka.dahua_video_server.loginPort:}")
+    public Integer loginPort;
+    //app
+    @Value("${sooka.dahua_video_server_app.loginIpApp:}")
+    public String loginIpApp;
+    @Value("${sooka.dahua_video_server_app.userNameApp:}")
+    public String userNameApp;
+    @Value("${sooka.dahua_video_server_app.userPwdApp:}")
+    public String userPwdApp;
+    @Value("${sooka.dahua_video_server_app.loginPortApp:}")
+    public Integer loginPortApp;
+    //
+    @Value("${sooka.dahua_dss_server.host:}")
+    public String host;
+    @Value("${sooka.dahua_dss_server.user_name:}")
+    public String user_name;
+    @Value("${sooka.dahua_dss_server.password:}")
+    public String password;
+    @Value("${sooka.dahua_dss_server.client_id:}")
+    public String client_id;
+    @Value("${sooka.dahua_dss_server.client_secret:}")
+    public String client_secret;
+    @Value("${sooka.dahua_dss_server.version:}")
+    public String version;
+    @Value("${sooka.dahua_dss_server.video_download_url_linux:}")
+    public String videoDownloadUrlLinux;
+    @Value("${sooka.dahua_dss_server.video_download_url_win:}")
+    public String videoDownloadUrlWin;
+    @Value("${sooka.haikang_video_server.loginIp:}")
+    public String HkloginIp;
+    @Value("${sooka.haikang_video_server.appkey:}")
+    public String Hkappkey;
+    @Value("${sooka.haikang_video_server.secret:}")
+    public String Hksecret;
+    @Value("${sooka.haikang_video_server.loginPort:}")
+    public String HkloginPort;
+    @Autowired
+    TokenService tokenService;
+    @Autowired
+    private RedisService redisService;
+
+    public void setSookaDataBase(BaseBusinessEntity entity) {
+        entity.setDatabase_system(this.database_system);
+        entity.setDatabase_event(this.database_event);
+        entity.setDatabase_data(this.database_data);
+    }
+
+}
+

src/main/java/com/sooka/sponest/monitor/base/util/database/DynamicDataSource.java

@@ -0,0 +1,19 @@
+package com.sooka.sponest.monitor.base.util.database;
+
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
+
+
+public class DynamicDataSource extends AbstractRoutingDataSource {
+
+    Logger logger = LoggerFactory.getLogger(DynamicDataSource.class);
+
+    @Override
+    protected Object determineCurrentLookupKey() {
+        String datasource = DynamicDataSourceSwitcher.getDataSource();
+        logger.info("------------------当前数据源 {}", DynamicDataSourceSwitcher.getDataSource());
+        return DynamicDataSourceSwitcher.getDataSource();
+    }
+}

src/main/java/com/sooka/sponest/monitor/base/util/database/DynamicDataSourceAspect.java

@@ -0,0 +1,41 @@
+package com.sooka.sponest.monitor.base.util.database;
+
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+
+@Aspect
+@Component
+@Order(1)
+public class DynamicDataSourceAspect {
+    private Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);
+
+    /**
+     * 切入点只对@Service注解的类上的@DataSource方法生效
+     *
+     * @param myDataSource
+     */
+    @Pointcut(value = "(@within(org.springframework.stereotype.Service) ||@within(org.springframework.stereotype.Repository)) && @annotation(myDataSource)")
+    public void dynamicDataSourcePointCut(MyDataSource myDataSource) {
+    }
+
+    @Before(value = "dynamicDataSourcePointCut(myDataSource)")
+    public void switchDataSource(MyDataSource myDataSource) {
+        DynamicDataSourceSwitcher.setDataSource(myDataSource.value());
+    }
+
+    /**
+     * 切点执行完后 切换成主数据库
+     *
+     * @param myDataSource
+     */
+    @After(value = "dynamicDataSourcePointCut(myDataSource)")
+    public void after(MyDataSource myDataSource) {
+        DynamicDataSourceSwitcher.cleanDataSource();
+    }
+}

src/main/java/com/sooka/sponest/monitor/base/util/database/DynamicDataSourceSwitcher.java

@@ -0,0 +1,41 @@
+package com.sooka.sponest.monitor.base.util.database;
+
+import org.apache.commons.lang.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class DynamicDataSourceSwitcher {
+
+    public static final String Master = "master";
+    public static final String dbCenterTtranmanager = "db-center-tranmanager";
+    public static final String dbCenterData = "db-center-data";
+    public static final String dbCenterEvent = "db-center-event";
+    public static final String dbCenterMonitor = "db-center-monitor";
+    public static final String dbCenterTask = "db-center-task";
+    public static final String dbCenterEvaluation = "db-center-evaluation";
+    public static final String dbCenterFire = "db-center-fire";
+    public static final String dbCenterStraw = "db-center-straw";
+    public static final String dbCenterPests = "db-center-pests";
+    public static final String dbCenterComprehensive = "db-center-comprehensive";
+    public static final String dbCenterOnest = "db-center-onest";
+    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
+    static Logger logger = LoggerFactory.getLogger(DynamicDataSourceSwitcher.class);
+
+    public static String getDataSource() {
+        if (StringUtils.isEmpty(contextHolder.get())) {
+            setDataSource(Master);
+        }
+        return contextHolder.get();
+    }
+
+    public static void setDataSource(String name) {
+        logger.info("-------- 设置数据源数据源为 ：{} ", name);
+        contextHolder.set(name);
+    }
+
+    public static void cleanDataSource() {
+        contextHolder.remove();
+    }
+
+}

src/main/java/com/sooka/sponest/monitor/base/util/database/GlobalTransactionalRabbitMQ.java

@@ -0,0 +1,4 @@
+package com.sooka.sponest.monitor.base.util.database;
+
+public @interface GlobalTransactionalRabbitMQ {
+}

src/main/java/com/sooka/sponest/monitor/base/util/database/MultipleDataSourceConfig.java

@@ -0,0 +1,136 @@
+package com.sooka.sponest.monitor.base.util.database;
+
+import com.alibaba.druid.pool.DruidDataSource;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+import javax.sql.DataSource;
+import java.util.HashMap;
+import java.util.Map;
+
+@Configuration
+public class MultipleDataSourceConfig {
+
+    @Bean("master")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master")
+    public DataSource createMasterDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbSystemData")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-system")
+    public DataSource createSystemDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterTranmanager")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-tranmanager")
+    public DataSource createTranmanagerDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterData")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-data")
+    public DataSource createDataDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterEvent")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-event")
+    public DataSource createEventDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterMonitor")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-monitor")
+    public DataSource createMonitorDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterTask")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-task")
+    public DataSource createTaskDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterEvaluation")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-evaluation")
+    public DataSource createEvaluationDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterFire")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-fire")
+    public DataSource createFireDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterStraw")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-straw")
+    public DataSource createStrawDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterPests")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-pests")
+    public DataSource createPestsDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterComprehensive")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-comprehensive")
+    public DataSource createComprehensiveDataSource() {
+        return new DruidDataSource();
+    }
+
+    @Bean("dbCenterOnest")
+    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.db-center-onest")
+    public DataSource createOnestDataSource() {
+        return new DruidDataSource();
+    }
+
+    /**
+     * 设置动态数据源，通过@Primary 来确定主DataSource
+     *
+     * @return
+     */
+    @Bean
+    @Primary
+    public DataSource createDynamicDataSource(@Qualifier("master") DataSource master,
+                                              @Qualifier("dbSystemData") DataSource dbSystemData,
+                                              @Qualifier("dbCenterData") DataSource dbCenterData,
+                                              @Qualifier("dbCenterEvent") DataSource dbCenterEvent,
+                                              @Qualifier("dbCenterMonitor") DataSource dbCenterMonitor,
+                                              @Qualifier("dbCenterTask") DataSource dbCenterTask,
+                                              @Qualifier("dbCenterEvaluation") DataSource dbCenterEvaluation,
+                                              @Qualifier("dbCenterFire") DataSource dbCenterFire,
+                                              @Qualifier("dbCenterStraw") DataSource dbCenterStraw,
+                                              @Qualifier("dbCenterPests") DataSource dbCenterPests,
+                                              @Qualifier("dbCenterComprehensive") DataSource dbCenterComprehensive,
+                                              @Qualifier("dbCenterOnest") DataSource dbCenterOnest,
+                                              @Qualifier("dbCenterTranmanager") DataSource dbCenterTranmanager) {
+        DynamicDataSource dynamicDataSource = new DynamicDataSource();
+        //设置默认数据源
+        dynamicDataSource.setDefaultTargetDataSource(master);
+        //配置多数据源
+        Map<Object, Object> map = new HashMap<>();
+        map.put("master", master);
+        map.put("db-system", dbSystemData);
+        map.put("db-center-tranmanager", dbCenterTranmanager);
+        map.put("db-center-data", dbCenterData);
+        map.put("db-center-event", dbCenterEvent);
+        map.put("db-center-monitor", dbCenterMonitor);
+        map.put("db-center-task", dbCenterTask);
+        map.put("db-center-evaluation", dbCenterEvaluation);
+        map.put("db-center-fire", dbCenterFire);
+        map.put("db-center-straw", dbCenterStraw);
+        map.put("db-center-pests", dbCenterPests);
+        map.put("db-center-comprehensive", dbCenterComprehensive);
+        map.put("db-center-onest", dbCenterOnest);
+        dynamicDataSource.setTargetDataSources(map);
+        return dynamicDataSource;
+    }
+}

src/main/java/com/sooka/sponest/monitor/base/util/database/MyDataSource.java

@@ -0,0 +1,15 @@
+package com.sooka.sponest.monitor.base.util.database;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({
+        ElementType.METHOD
+})
+public @interface MyDataSource {
+    String value() default "";
+}

src/main/java/com/sooka/sponest/monitor/camera/mapper/CentermonitorTCameraMapper.java

@@ -0,0 +1,39 @@
+package com.sooka.sponest.monitor.camera.mapper;
+
+
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 摄像头Mapper接口
+ *
+ * @author ruoyi
+ * @date 2022-06-08
+ */
+@Repository
+public interface CentermonitorTCameraMapper {
+
+    /**
+     * 更新执法仪在离线状态
+     *
+     * @param list
+     */
+    void updateBatchLawEnforcementInstrumentState(List<Map<String, Object>> list);
+
+    /**
+     * 更新摄像头类型为录像机离线状态
+     *
+     * @param list
+     */
+    void updateBatchVideoRecorderOfflineState(List<String> list);
+
+    /**
+     * 更新摄像头类型为录像机在线状态
+     *
+     * @param list
+     */
+    void updateBatchVideoRecorderOnlineState(List<String> list);
+}
+

src/main/java/com/sooka/sponest/monitor/dahua/controller/EquipmentStatusTaskController.java

@@ -0,0 +1,154 @@
+package com.sooka.sponest.monitor.dahua.controller;
+
+
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.nacos.shaded.com.google.gson.Gson;
+import com.ruoyi.common.core.domain.R;
+import com.ruoyi.common.log.annotation.Log;
+import com.ruoyi.common.log.enums.BusinessType;
+import com.sooka.sponest.monitor.camera.mapper.CentermonitorTCameraMapper;
+import com.sooka.sponest.monitor.dahua.utils.HttpEnum;
+import com.sooka.sponest.monitor.dahua.utils.HttpTestUtils;
+import com.sooka.sponest.monitor.remoteapi.service.lawenforcement.RemoteLawenforcementBaseService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static org.springframework.web.bind.annotation.RequestMethod.GET;
+
+
+/**
+ * 对接大华根据组织获取执法记录仪、单兵设备在线状态
+ */
+
+@Slf4j
+@Component
+@Api(tags = "对接大华根据组织获取执法记录仪、单兵设备在线状态定时任务")
+@RestController
+@RequestMapping("/equipmentStatus/quartz")
+public class EquipmentStatusTaskController {
+
+
+    @Resource
+    private CentermonitorTCameraMapper centermonitorTCameraMapper;
+    @Resource
+    private RemoteLawenforcementBaseService remoteLawenforcementBaseService;
+    @Value("${sooka.dahua_interface_server.loginIp}")
+    private String loginIp;
+    @Value("${sooka.dahua_interface_server.loginPort}")
+    private String loginPort;
+    @Value("${sooka.dahua_interface_server.userName}")
+    private String userName;
+    @Value("${sooka.dahua_interface_server.userPwd}")
+    private String userPwd;
+//    private String loginIp = "10.53.0.35";
+//    private String loginPort = "7901";
+//    private String userName = "system";
+//    private String userPwd = "Admin123";
+    //按组织获取设备详细信息
+    public static final String ACTION = "/videoService/devicesManager/devicesInfo";
+    private List<String> orgCodes = Arrays.asList("11033445593778368", "11248668755298496");
+
+
+//    @Scheduled(cron = "0/5 * * * * ?")
+    @Log(title = "对接大华根据组织获取执法记录仪、单兵设备在线状态定时任务", businessType = BusinessType.OTHER)
+    @ApiOperation(value = "对接大华根据组织获取执法记录仪、单兵设备在线状态定时任务", notes = "对接大华根据组织获取执法记录仪、单兵设备在线状态定时任务")
+    @RequestMapping(value = "/getLongPollingPositionMsg", method = GET)
+    public void getLongPollingPositionMsg() throws Exception {
+        log.info("开始执行获取记录仪在离线数据定时任务");
+        R<?> result = HttpTestUtils.getToken(loginIp, Integer.parseInt(loginPort), userName, userPwd);
+        if (result.getCode() != 200) {
+            log.info("获取token失败，请检查配置信息:", JSONObject.parseObject(result.getMsg()));
+        }
+        String token = result.getData().toString();
+        getMessage(loginIp, Integer.parseInt(loginPort), token);
+    }
+
+    /**
+     * 根据组织code编码获取执法仪详情数据
+     *
+     * @param ip
+     * @param port
+     * @param token
+     */
+    private void getMessage(String ip, int port, String token) {
+        Map<String, String> content = new HashMap<>();
+        for (String orgCode : orgCodes) {
+            content.put("orgCode", orgCode);
+            getDevicesInfo(ip, port, token, content, orgCode);
+        }
+    }
+
+    private void getDevicesInfo(String ip, int port, String token, Map<String, String> content, String orgCode) {
+        String response = HttpTestUtils.httpRequest(HttpEnum.POST, ip, port, ACTION, token, new Gson().toJson(content));
+        JSONObject jsonObject = JSONObject.parseObject(response);
+        if (jsonObject.get("devices") == null) {
+            log.info("根据组织code编码获取执法仪response:{}", response);
+            return;
+        }
+        Map<String, Object> rsp = new Gson().fromJson(response, Map.class);
+        List<Map<String, Object>> arr = (List<Map<String, Object>>) rsp.get("devices");
+        log.info("获取记录仪在离线数据 size = {}", arr.size());
+        updateDeviceState(arr, orgCode);
+    }
+
+    /**
+     * 更新执法仪在离线状态
+     *
+     * @param arr
+     */
+    private void updateDeviceState(List<Map<String, Object>> arr, String orgCode) {
+        log.info("根据组织code编码获取执法仪详情数据:{}", arr.size());
+        if (CollectionUtils.isNotEmpty(arr)) {
+            if (orgCode.equals("11248668755298496")) {
+                List<Map<String, Object>> list = (List<Map<String, Object>>) arr.get(0).get("units");
+                for (Map<String, Object> map : list) {
+                    if (map.get("unitType").toString().equals("1")) {
+                        arr = (List<Map<String, Object>>) map.get("channels");
+                        //更新摄像头类型为录像机在离线状态
+                        List<String> channelCodeAllList = arr.stream().map(item -> item.get("channelCode"))
+                                .filter(channelCode -> channelCode != null)
+                                .map(Object::toString)
+                                .collect(Collectors.toList());
+                        //先把摄像头类型为录像机的状态全部改成离线
+                        if (CollectionUtils.isNotEmpty(channelCodeAllList)) {
+                            centermonitorTCameraMapper.updateBatchVideoRecorderOfflineState(channelCodeAllList);
+                        }
+                        //再修改摄像头类型为录像机的在线状态
+                        List<String> channelCodeList = arr.stream()
+                                .filter(item -> "1".equals(item.get("status")))
+                                .map(item -> item.get("channelCode"))
+                                .filter(channelCode -> channelCode != null)
+                                .map(Object::toString)
+                                .collect(Collectors.toList());
+                        if (CollectionUtils.isNotEmpty(channelCodeList)) {
+                            centermonitorTCameraMapper.updateBatchVideoRecorderOnlineState(channelCodeList);
+                        }
+                        break;
+                    }
+                }
+            } else {
+                //向执法中心推送设备状态
+                R result = remoteLawenforcementBaseService.deviceOpenOrClose(arr);
+                if (result.getCode() != 200) {
+                    log.info("向执法中心推送设备状态失败:{}", result.getMsg());
+                }
+                //更新执法仪在离线状态
+                centermonitorTCameraMapper.updateBatchLawEnforcementInstrumentState(arr);
+            }
+        }
+    }
+
+}

src/main/java/com/sooka/sponest/monitor/dahua/login/Login.java

@@ -0,0 +1,67 @@
+package com.sooka.sponest.monitor.dahua.login;//package com.dahuatch.Login;
+
+
+import com.alibaba.nacos.shaded.com.google.gson.Gson;
+import com.ruoyi.common.core.domain.R;
+import com.sooka.sponest.monitor.dahua.login.bean.LoginFirst;
+import com.sooka.sponest.monitor.dahua.login.bean.LoginSecond;
+import com.sooka.sponest.monitor.dahua.utils.HttpEnum;
+import com.sooka.sponest.monitor.dahua.utils.HttpTestUtils;
+
+import java.util.Map;
+
+/**
+ * 创建会话接口
+ */
+public class Login {
+
+    public static final String ACTION = "/videoService/accounts/authorize";
+
+    //第一次登陆，客户端只传用户名，服务端返回realm、readomKey和encryptType信息。
+    private static String firstLogin(String ip, int port, String userName) {
+        LoginFirst loginFirst = new LoginFirst();
+        loginFirst.setClientType("winpc");
+        loginFirst.setUserName(userName);
+        String rsp = HttpTestUtils.httpRequest(HttpEnum.POST, ip, port, ACTION, "", new Gson().toJson(loginFirst));
+        return rsp;
+    }
+
+    //第二次登录，客户端根据返回的信息，按照指定的加密算法计算签名，再带着用户名和签名登陆一次。
+    private static String secondLogin(String ip, int port, String userName, String password, String realm, String randomKey) throws Exception {
+        LoginSecond snd = new LoginSecond();
+        snd.setUserName(userName);
+        snd.setClientType("winpc");
+        snd.setRandomKey(randomKey);
+        snd.setEncryptType("MD5");
+        String signature = snd.calcSignature(password, realm);
+        snd.setSignature(signature);
+        Gson gson = new Gson();
+        String ctx = gson.toJson(snd);
+        String rsp = HttpTestUtils.httpRequest(HttpEnum.POST, ip, port, ACTION, "", ctx);
+        return rsp;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static String login(String ip, int port, String userName, String password) throws Exception {
+        String response = firstLogin(ip, port, userName);
+        Map<String, String> responseMap = new Gson().fromJson(response, Map.class);
+        String random = responseMap.get("randomKey");
+        String realm = responseMap.get("realm");
+        response = secondLogin(ip, port, userName, password, realm, random);
+        return response;
+    }
+
+
+    /**
+     * 调用该登陆方法之前需要修改 baseinfo.properties中ip,port，name，password为当前对接环境
+     * 登录的方法，运行之后即可获取到token，进行登录,登陆完成后，必须调用KeepLogin保活接口，否则，2分钟后会登陆过期
+     */
+    public static void main(String[] args) throws Exception {
+        R<?> result = HttpTestUtils.getToken("10.254.1.20", Integer.valueOf(8320), "system", "Admin123");
+        String token = result.getData().toString();
+        System.out.println("登录成功，token=" + token);
+    }
+}
+
+
+

src/main/java/com/sooka/sponest/monitor/dahua/login/bean/LoginFirst.java

@@ -0,0 +1,36 @@
+package com.sooka.sponest.monitor.dahua.login.bean;//package com.dahuatch.Login;
+
+/**
+ * 第一次登录参数bean
+ */
+public class LoginFirst {
+
+    private String userName;
+    private String clientType;
+    private String ipAddress;
+
+
+    public String getUserName() {
+        return userName;
+    }
+    public void setUserName(String userName) {
+        this.userName = userName;
+    }
+    public String getClientType() {
+        return clientType;
+    }
+    public void setClientType(String clientType) {
+        this.clientType = clientType;
+    }
+    public String getIpAddress() {
+        return ipAddress;
+    }
+    public void setIpAddress(String ipAddress) {
+        this.ipAddress = ipAddress;
+    }
+    @Override
+    public String toString() {
+
+        return "[userName=" + userName + ",clientType=" + clientType + ",ipAddress=" + ipAddress + "]";
+    }
+}

src/main/java/com/sooka/sponest/monitor/dahua/login/bean/LoginSecond.java

@@ -0,0 +1,102 @@
+package com.sooka.sponest.monitor.dahua.login.bean;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * 第二次登录参数bean和方法
+ */
+public class LoginSecond {
+    private String userName;
+    private String clientType;
+    private String ipAddress;
+	private String signature;
+	private String randomKey;
+	private String encryptType;
+
+    public String getUserName() {
+        return userName;
+    }
+    public void setUserName(String userName) {
+        this.userName = userName;
+    }
+    public String getClientType() {
+        return clientType;
+    }
+    public void setClientType(String clientType) {
+        this.clientType = clientType;
+    }
+    public String getIpAddress() {
+        return ipAddress;
+    }
+    public void setIpAddress(String ipAddress) {
+        this.ipAddress = ipAddress;
+    }
+    public String getSignature() {
+        return signature;
+    }
+    public void setSignature(String signature) {
+        this.signature = signature;
+    }
+    public String getRandomKey() {
+        return randomKey;
+    }
+    public void setRandomKey(String randomKey) {
+        this.randomKey = randomKey;
+    }
+    public String getEncryptType() {
+        return encryptType;
+    }
+    public String setEncryptType(String encryptType) {
+        return this.encryptType = encryptType;
+    }
+
+	public static boolean isBlankString(String str) {
+		if (str == null || str == "" || str.length() == 0) {
+			return true;
+		}
+		return false;
+	}
+
+	public static String encrypt(String inputText, String algorithmName) throws Exception {
+		if (isBlankString(inputText)) {
+			throw new IllegalArgumentException("Please enter inputText!");
+		}
+		if (isBlankString(algorithmName)
+				|| algorithmName.toLowerCase().equals("md5")) {
+			algorithmName = "MD5";
+		}
+		try {
+			MessageDigest digest = MessageDigest.getInstance(algorithmName);
+			digest.update(inputText.getBytes("UTF8"));
+			byte encryptted[] = digest.digest();
+			int i;
+			StringBuffer rsp = new StringBuffer();
+			for (int offset = 0; offset < encryptted.length; offset++) {
+				i = encryptted[offset];
+				if (i < 0)
+					i += 256;
+				if (i < 16)
+					rsp.append("0");
+				rsp.append(Integer.toHexString(i));
+			}
+			return rsp.toString();
+		} catch (NoSuchAlgorithmException e) {
+			throw e;
+		} catch (UnsupportedEncodingException e) {
+			throw e;
+		}
+	}
+	//根据第一次登录接口调用返回的参数，计算签名，第二次登录接口调用要使用到，本例采用的是MD5的加密方式，可以根据需要采用别的加密方式
+	public String calcSignature(String password, String realm) throws Exception{
+		String signature = encrypt(password, "MD5");
+		signature = encrypt(this.userName+signature, "MD5");
+		signature = encrypt(signature, "MD5");
+		signature = encrypt(this.userName+":"+realm+":"+signature, "MD5");
+		signature = encrypt(signature+":"+this.randomKey, "MD5");
+		return signature;
+	}
+
+}
+

src/main/java/com/sooka/sponest/monitor/dahua/utils/HttpEnum.java

@@ -0,0 +1,26 @@
+package com.sooka.sponest.monitor.dahua.utils;
+/**
+ * 请求类型枚举
+ */
+public enum HttpEnum {
+    GET(1,"get"),
+    POST(2,"post"),
+    PUT(3,"put"),
+    DELETE(4,"delete");
+    private int num;
+    private String desc;
+
+
+    HttpEnum(int num, String desc) {
+        this.num = num;
+        this.desc = desc;
+    }
+    public int getNum() {
+        return num;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+}

src/main/java/com/sooka/sponest/monitor/dahua/utils/HttpTestUtils.java

@@ -0,0 +1,195 @@
+package com.sooka.sponest.monitor.dahua.utils;
+
+
+import com.alibaba.nacos.shaded.com.google.gson.Gson;
+import com.ruoyi.common.core.domain.R;
+import com.sooka.sponest.monitor.dahua.login.Login;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.http.client.methods.*;
+import org.apache.http.config.Registry;
+import org.apache.http.config.RegistryBuilder;
+import org.apache.http.conn.socket.ConnectionSocketFactory;
+import org.apache.http.conn.socket.PlainConnectionSocketFactory;
+import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
+import org.apache.http.conn.ssl.X509HostnameVerifier;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.apache.http.ssl.SSLContexts;
+import org.apache.http.ssl.TrustStrategy;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
+import java.io.*;
+import java.security.KeyStore;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.Map;
+/**
+ * 远程调用请求工具
+ */
+@Slf4j
+public class HttpTestUtils {
+    public static String httpRequest(HttpEnum method, String ip, int port, String action, String token, String content) {
+        String responJson = null;
+        CloseableHttpClient httpClient = null;
+        CloseableHttpResponse httpResponse = null;
+        InputStream inputStream = null;
+        KeyStore trustStore = null;
+        SSLContext sslcontext = null;
+        try {
+            trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
+            // 设置信任签名
+            sslcontext = SSLContexts.custom().loadTrustMaterial(trustStore, new TrustStrategy() {
+                @Override
+                public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
+                    return true;
+                }
+            }).build();
+            X509HostnameVerifier hostnameVerifier = new X509HostnameVerifier() {
+                @Override
+                public void verify(String s, SSLSocket sslSocket) throws IOException {
+
+                }
+
+                @Override
+                public void verify(String s, X509Certificate x509Certificate) throws SSLException {
+
+                }
+
+                @Override
+                public void verify(String s, String[] strings, String[] strings1) throws SSLException {
+
+                }
+
+                @Override
+                public boolean verify(String s, SSLSession sslSession) {
+                    return true;
+                }
+            };
+            // 设置协议http和https对应的处理socket链接工厂的对象
+            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
+                    .register("http", PlainConnectionSocketFactory.INSTANCE)
+                    .register("https", new SSLConnectionSocketFactory(sslcontext, hostnameVerifier))
+                    .build();
+
+            PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
+
+            httpClient = HttpClientBuilder.create()
+                    .setConnectionManager(connectionManager)
+                    .setRedirectStrategy(new RestRedirectStrategy()).build();
+            String proto = port == 8320 ? "https://" : "http://";
+            String uri = proto + ip + ":" + port + action;
+            HttpRequestBase httpReq = getRequestEntity(method, token, uri, content);
+            httpResponse = httpClient.execute(httpReq);
+            inputStream = httpResponse.getEntity().getContent();
+            responJson = convertToString(inputStream);
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (null != httpResponse) {
+                try {
+                    httpResponse.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            if (null != httpClient) {
+                try {
+                    httpClient.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return responJson;
+    }
+
+    private static HttpRequestBase getRequestEntity(HttpEnum method, String token, String uri, String content) throws UnsupportedEncodingException {
+        switch (method.getNum()) {
+            case 1:
+                HttpGet httpGet = new HttpGet(uri + content);
+                httpGet.addHeader("Content-type", "application/json");
+                httpGet.addHeader("X-Subject-Token", token);
+                return httpGet;
+            case 2:
+                HttpPost httpPost = new HttpPost(uri);
+                httpPost.addHeader("Content-type", "application/json");
+                httpPost.addHeader("X-Subject-Token", token);
+                httpPost.setEntity(new StringEntity(content, "UTF-8"));
+                return httpPost;
+            case 3:
+                HttpPut httpPut = new HttpPut(uri);
+                httpPut.addHeader("Content-type", "application/json");
+                httpPut.addHeader("X-Subject-Token", token);
+                httpPut.setEntity(new StringEntity(content, "UTF-8"));
+                return httpPut;
+            case 4:
+                HttpDelete httpDelete = new HttpDelete(uri + content);
+                httpDelete.addHeader("Content-type", "application/json");
+                httpDelete.addHeader("X-Subject-Token", token);
+                return httpDelete;
+            default:
+                System.out.println("请求方法不对");
+        }
+        return null;
+    }
+
+    private static String convertToString(InputStream is) {
+        if (is == null) {
+            return null;
+        }
+        BufferedReader bf = null;
+        try {
+            StringBuilder sb = new StringBuilder();
+            String temp = "";
+            bf = new BufferedReader(new InputStreamReader(is, "UTF-8"));
+            while ((temp = bf.readLine()) != null) {
+                sb.append(temp);
+            }
+            return sb.toString();
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        } finally {
+            closeStream(bf);
+            closeStream(is);
+        }
+    }
+
+    private static void closeStream(Closeable closeable) {
+        if (null != closeable) {
+            try {
+                closeable.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static R<?> getToken(String ip, int port, String userName, String password) throws Exception {
+        String response = "";
+        String token = "";
+        response = Login.login(ip, port, userName, password);
+        Map<String, Object> rsp = new Gson().fromJson(response, Map.class);
+        String message = (String) rsp.get("message");
+        if (message != null && !"".equals(message)) {
+            System.out.println(message);
+            log.info("获取token信息：{}",message);
+            return R.fail("用户名或密码错误,未获取到token");
+        }
+        token = (String) rsp.get("token");
+        if (token == null || "".equals(token)) {
+            System.out.println("获取到的token为空");
+            log.info("获取token：{}",message);
+            return R.fail("获取到的token为空");
+        }
+        return R.ok(token);
+    }
+
+}

src/main/java/com/sooka/sponest/monitor/dahua/utils/ImgUtils.java

@@ -0,0 +1,25 @@
+package com.sooka.sponest.monitor.dahua.utils;
+
+/******************************
+ *
+ * @author yanhongliang
+ * @date 2022-06-20 10:22 AM
+ ******************************/
+
+public class ImgUtils {
+
+
+    public static String[] getImgUrl(String... path) {
+
+        String[] url = {};
+
+        for (int i = 0; i < path.length; i++) {
+            url[i] =  "https//192.168.100.2:8443/evo-pic/" + path + "?token=" + DSSUtils.getToken();
+        }
+
+        return url;
+
+    }
+
+
+}

src/main/java/com/sooka/sponest/monitor/dahua/utils/RestRedirectStrategy.java

@@ -0,0 +1,70 @@
+package com.sooka.sponest.monitor.dahua.utils;
+
+import org.apache.http.*;
+import org.apache.http.annotation.Contract;
+import org.apache.http.annotation.ThreadingBehavior;
+import org.apache.http.client.methods.*;
+import org.apache.http.impl.client.DefaultRedirectStrategy;
+import org.apache.http.protocol.HttpContext;
+
+import java.net.URI;
+
+/**
+ * 功能简介：重定向策略,GET/POST/PUT/DELTE 都支持重定向
+ * 功能详解：
+ */
+@Contract(threading = ThreadingBehavior.IMMUTABLE)
+public class RestRedirectStrategy extends DefaultRedirectStrategy {
+
+    /**
+     * Redirect methods
+     */
+    private static final String[] REDIRECT_METHODS = new String[]{
+            HttpGet.METHOD_NAME,
+            HttpPut.METHOD_NAME,
+            HttpDelete.METHOD_NAME,
+            HttpPost.METHOD_NAME
+    };
+
+    @Override
+    protected boolean isRedirectable(final String method) {
+        for (final String m : REDIRECT_METHODS) {
+            if (m.equalsIgnoreCase(method)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public HttpUriRequest getRedirect(final HttpRequest request, final HttpResponse response, final HttpContext context) throws ProtocolException {
+        final URI uri = getLocationURI(request, response, context);
+        final String method = request.getRequestLine().getMethod();
+        if (method.equalsIgnoreCase(HttpGet.METHOD_NAME)) {
+            return new HttpGet(uri);
+        } else if (method.equalsIgnoreCase(HttpPost.METHOD_NAME)) {
+            HttpPost post = new HttpPost(uri);
+            if (request instanceof HttpEntityEnclosingRequest) {
+                HttpEntity oldEntity = ((HttpEntityEnclosingRequest) request).getEntity();
+                post.setEntity(oldEntity);
+            }
+            return post;
+        } else if (method.equalsIgnoreCase(HttpPut.METHOD_NAME)) {
+            HttpPut put = new HttpPut(uri);
+            if (request instanceof HttpEntityEnclosingRequest) {
+                HttpEntity oldEntity = ((HttpEntityEnclosingRequest) request).getEntity();
+                put.setEntity(oldEntity);
+            }
+            return put;
+        } else if (method.equalsIgnoreCase(HttpDelete.METHOD_NAME)) {
+            return new HttpDelete(uri);
+        } else {
+            final int status = response.getStatusLine().getStatusCode();
+            if (status == HttpStatus.SC_TEMPORARY_REDIRECT) {
+                return RequestBuilder.copy(request).setUri(uri).build();
+            } else {
+                return new HttpGet(uri);
+            }
+        }
+    }
+}

src/main/java/com/sooka/sponest/monitor/remoteapi/EnableSookaFeignClients.java

@@ -0,0 +1,22 @@
+package com.sooka.sponest.monitor.remoteapi;
+
+import org.springframework.cloud.openfeign.EnableFeignClients;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@EnableFeignClients
+public @interface EnableSookaFeignClients {
+
+    String[] value() default {};
+
+    String[] basePackages() default {"com.ruoyi", "com.sooka" };
+
+    Class<?>[] basePackageClasses() default {};
+
+    Class<?>[] defaultConfiguration() default {};
+
+    Class<?>[] clients() default {};
+}

src/main/java/com/sooka/sponest/monitor/remoteapi/RemoveApiBaseService.java

@@ -0,0 +1,4 @@
+package com.sooka.sponest.monitor.remoteapi;
+
+public interface RemoveApiBaseService {
+}

src/main/java/com/sooka/sponest/monitor/remoteapi/fallback/lawenforcement/RemoteLawenforcementBaseServiceFallbackFactory.java

@@ -0,0 +1,34 @@
+package com.sooka.sponest.monitor.remoteapi.fallback.lawenforcement;
+
+
+import com.ruoyi.common.core.domain.R;
+import com.sooka.sponest.monitor.remoteapi.service.lawenforcement.RemoteLawenforcementBaseService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.cloud.openfeign.FallbackFactory;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class RemoteLawenforcementBaseServiceFallbackFactory implements FallbackFactory<RemoteLawenforcementBaseService> {
+
+    private static final Logger log = LoggerFactory.getLogger(RemoteLawenforcementBaseServiceFallbackFactory.class);
+
+    @Override
+    public RemoteLawenforcementBaseService create(Throwable cause) {
+        log.error("执法中心-服务调用失败:{}", cause.getMessage());
+
+        return new RemoteLawenforcementBaseService() {
+
+            @Override
+            public R deviceOpenOrClose(List<Map<String, Object>> arr) {
+                return null;
+            }
+        };
+
+
+
+    }
+}

src/main/java/com/sooka/sponest/monitor/remoteapi/service/ModulesServiceNameContants.java

@@ -0,0 +1,51 @@
+package com.sooka.sponest.monitor.remoteapi.service;
+
+import com.ruoyi.common.core.constant.ServiceNameConstants;
+
+public class ModulesServiceNameContants extends ServiceNameConstants {
+
+    //综合治理中心中心
+    public static final String CENTER_COMPREHENSIVE = "sooka-sponest-center-comprehensive";
+
+    //数据中心
+    public static final String CENTER_DATA = "sooka-sponest-center-data";
+
+    //测评中心
+    public static final String CENTER_EVALUATION = "sooka-sponest-center-evaluation";
+
+    //事件中心
+    public static final String CENTER_EVENT = "sooka-sponest-center-event";
+
+    //森林防火中心
+    public static final String CENTER_FIRE = "sooka-sponest-center-fire";
+
+    //监控中心
+    public static final String CENTER_MONITOR = "sooka-sponest-center-monitor";
+
+    //一体化平台
+    public static final String CENTER_ONEST = "sooka-sponest-center-onest";
+
+    //病虫灾害中心
+    public static final String CENTER_PESTS = "sooka-sponest-center-pests";
+
+    //秸秆禁烧中心
+    public static final String CENTER_STRAW = "sooka-sponest-center-straw";
+
+    //任务中心
+    public static final String CENTER_TASK = "sooka-sponest-center-task";
+
+    //运管中心
+    public static final String CENTER_TRANMANAGER = "sooka-sponest-center-tranmanager";
+    //文件中心
+    public static final String CENTER_FILE = "sooka-sponest-file";
+    /**
+     * 系统模块的serviceid
+     */
+    public static final String SYSTEM_SERVICE = "sooka-sponest-system";
+
+    public static final String MIDDLE_GROUND_SERVICE = "sooka-middleGround";
+
+    //执法
+    public static final String CENTER_LAWENFORCEMENT = "sooka-sponest-lawenforcement";
+
+}

src/main/java/com/sooka/sponest/monitor/remoteapi/service/lawenforcement/RemoteLawenforcementBaseService.java

@@ -0,0 +1,24 @@
+package com.sooka.sponest.monitor.remoteapi.service.lawenforcement;
+
+
+import com.ruoyi.common.core.domain.R;
+import com.sooka.sponest.monitor.remoteapi.fallback.lawenforcement.RemoteLawenforcementBaseServiceFallbackFactory;
+import com.sooka.sponest.monitor.remoteapi.service.ModulesServiceNameContants;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.PostMapping;
+
+import java.util.List;
+import java.util.Map;
+
+
+@FeignClient(
+        contextId = "RemoteLawenforcementBaseService",
+        value = ModulesServiceNameContants.CENTER_LAWENFORCEMENT,
+        fallbackFactory = RemoteLawenforcementBaseServiceFallbackFactory.class
+)
+public interface RemoteLawenforcementBaseService {
+
+    @PostMapping("/device/deviceOpenOrClose")
+    public R deviceOpenOrClose(List<Map<String, Object>> arr);
+
+}

src/main/java/com/sooka/sponest/monitor/util/BeanUtil.java

@@ -0,0 +1,78 @@
+package com.sooka.sponest.monitor.util;
+
+import com.dahuatech.hutool.json.JSONNull;
+import com.ruoyi.common.core.utils.StringUtils;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.Map;
+
+public class BeanUtil {
+
+    /**
+     * map转对象
+     *
+     * @param map
+     * @param beanClass
+     * @param <T>
+     * @return
+     * @throws Exception
+     */
+    public static <T> T mapToBean(Map map, Class<T> beanClass) throws Exception {
+        T object = beanClass.newInstance();
+        Field[] fields = object.getClass().getDeclaredFields();
+        for (Field field : fields) {
+            int mod = field.getModifiers();
+            if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
+                continue;
+            }
+            field.setAccessible(true);
+            if (map.containsKey(field.getName())) {
+                field.set(object, map.get(field.getName()) instanceof JSONNull ? StringUtils.EMPTY : map.get(field.getName()));
+            }
+        }
+        return object;
+    }
+
+    /**
+     * 实体类转Map
+     *
+     * @param object
+     * @return
+     */
+    public static Map<String, Object> beanToMap(Object object) {
+        Map<String, Object> map = new HashMap();
+        for (Field field : object.getClass().getDeclaredFields()) {
+            try {
+                boolean flag = field.isAccessible();
+                field.setAccessible(true);
+                Object o = field.get(object);
+                map.put(field.getName(), o);
+                field.setAccessible(flag);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return map;
+    }
+
+    public static <T> T arrayToBean(String[] values, Class<T> beanClass) throws Exception {
+        T object = beanClass.newInstance();
+        Field[] fields = object.getClass().getDeclaredFields();
+        for (int i = 0; i < fields.length; i++) {
+            int mod = fields[i].getModifiers();
+            if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
+                continue;
+            }
+            // 检查 values 数组的长度
+            if (i < values.length) {
+                fields[i].setAccessible(true);
+                fields[i].set(object, values[i].split(" ")[0]); // 只取第一个值
+            }
+//            fields[i].setAccessible(true);
+//            fields[i].set(object, values[i].split(" ")[0]);
+        }
+        return object;
+    }
+}

src/main/resources/banner.txt

@@ -0,0 +1,9 @@
+Spring Boot Version: ${spring-boot.version}
+Spring Application Name: ${spring.application.name}
+
+  __________   ____ |  | _______          ____________   ____   ____   ____   _______/  |_
+
+ /  ___/  _ \ /  _ \|  |/ /\__  \        /  ___/\____ \ /  _ \ /    \_/ __ \ /  ___/\   __\
+ \___ (  <_> |  <_> )    <  / __ \_      \___ \ |  |_> >  <_> )   |  \  ___/ \___ \  |  |
+/____  >____/ \____/|__|_ \(____  /     /____  >|   __/ \____/|___|  /\___  >____  > |__|
+     \/                  \/     \/           \/ |__|               \/     \/     \/

src/main/resources/bootstrap.yml

@@ -0,0 +1,26 @@
+# Tomcat
+server:
+  port: 9003
+# Spring
+spring:
+  application:
+    # 应用名称
+    name: sooka-sponest-center-monitor-pollingPositionMsg
+  profiles:
+    # 环境配置
+    active: dev
+  cloud:
+    nacos:
+      discovery:
+        # 服务注册地址
+        server-addr: www.sooka.onest.com:8848
+#         server-addr: 127.0.0.1:8848
+      config:
+        # 配置中心地址
+        server-addr: www.sooka.onest.com:8848
+#        server-addr: 127.0.0.1:8848
+        # 配置文件格式
+        file-extension: yml
+        # 共享配置
+        shared-configs:
+          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}

src/main/resources/mapper/monitor/camera/CentermonitorTCameraMapper.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.sooka.sponest.monitor.camera.mapper.CentermonitorTCameraMapper">
+
+    <update id="updateBatchLawEnforcementInstrumentState">
+        UPDATE centermonitor_t_camera
+        SET working_status = CASE camera_code
+        <foreach collection="list" item="item">
+            WHEN (SELECT channel_code FROM centermonitor_t_camerachannel WHERE device_code = #{item.code} AND
+            channel_type = 2 LIMIT 1) THEN
+            CASE
+            WHEN #{item.status} = '0' THEN '1'
+            ELSE '0'
+            END
+        </foreach>
+        END,
+        offline_reason = ''
+        WHERE camera_code IN (
+        <foreach collection="list" item="item" separator=",">
+            (SELECT channel_code FROM centermonitor_t_camerachannel WHERE device_code = #{item.code} AND channel_type =
+            2 LIMIT 1)
+        </foreach>
+        );
+    </update>
+
+    <update id="updateBatchVideoRecorderOfflineState">
+        UPDATE centermonitor_t_camera
+        SET working_status = 1
+        WHERE camera_code in
+        <foreach collection="list" item="item" separator="," open="(" close=")">
+            #{item}
+        </foreach>
+    </update>
+
+    <update id="updateBatchVideoRecorderOnlineState">
+        UPDATE centermonitor_t_camera
+        SET working_status = 0
+        WHERE camera_code in
+        <foreach collection="list" item="item" separator="," open="(" close=")">
+            #{item}
+        </foreach>
+    </update>
+</mapper>