diff --git a/.beagle.yml b/.beagle.yml new file mode 100644 index 0000000000000000000000000000000000000000..16f9e735301cbe0e7c7d6f116820ede7f528eb54 --- /dev/null +++ b/.beagle.yml @@ -0,0 +1,135 @@ +kind: pipeline +name: dev + +trigger: + branch: + - dev + +clone: + disable: true + +volumes: + - name: docker-sock + host: + path: /var/run/docker.sock + +##--------------------------------流水线⬇-------------------------------## + +steps: + - name: fetch + image: registry.cn-qingdao.aliyuncs.com/wod/devops-git:1.0 + + - name: s3-cache + image: registry.cn-qingdao.aliyuncs.com/wod/devops-s3-cache:1.0 + settings: + restore: true + mount: + - .repository + endpoint: http://cache.wodcloud.com + access_key: + from_secret: ACCESS_KEY_MINIO + secret_key: + from_secret: SECRET_KEY_MINIO + + - name: build + image: hub.wodcloud.com/xinchuang/mvn3.8-jdk8:v2.0 + commands: + - mvn clean install -Dmaven.test.skip=true + + - name: s3-cache-build + image: registry.cn-qingdao.aliyuncs.com/wod/devops-s3-cache:1.0 + settings: + rebuild: true + hash: pom.xml + mount: + - .repository + endpoint: http://cache.wodcloud.com + access_key: + from_secret: ACCESS_KEY_MINIO + secret_key: + from_secret: SECRET_KEY_MINIO + + - name: docker-amd64 + image: registry.cn-qingdao.aliyuncs.com/wod/devops-docker:1.0 + volumes: + - name: docker-sock + path: /var/run/docker.sock + settings: + base: hub.wodcloud.com/base/jdk:8-amd64 + dockerfile: .beagle/dockerfile + repo: haidian/sdk-golden-api + version: "v1.0.0" + channel: amd64 + args: "TARGETOS=linux,TARGETARCH=amd64" + registry: hub.wodcloud.com + registry_user: + from_secret: REGISTRY_USER + registry_password: + from_secret: REGISTRY_PASSWORD + + - name: docker-arm64 + image: registry.cn-qingdao.aliyuncs.com/wod/devops-docker:1.0 + volumes: + - name: docker-sock + path: /var/run/docker.sock + settings: + base: hub.wodcloud.com/xinchuang/sdt-cryptohi-mmj:v1.0.0-arm64 + dockerfile: .beagle/dockerfile + repo: haidian/sdk-golden-api + version: "v1.0.0" + channel: arm64 + args: "TARGETOS=linux,TARGETARCH=arm64" + registry: hub.wodcloud.com + registry_user: + from_secret: REGISTRY_USER + registry_password: + from_secret: REGISTRY_PASSWORD + + - name: docker-arch + image: registry.cn-qingdao.aliyuncs.com/wod/devops-docker-manifest:v1.2.3 + settings: + platforms: linux/amd64,linux/arm64 + template: hub.wodcloud.com/haidian/sdk-golden-api:v1.0.0-ARCH + target: hub.wodcloud.com/haidian/sdk-golden-api:v1.0.0 + username: + from_secret: REGISTRY_USER + password: + from_secret: REGISTRY_PASSWORD + +--- +kind: secret +name: REGISTRY_USER +get: + name: REGISTRY_USER + path: devops-secrets +--- +kind: secret +name: REGISTRY_PASSWORD +get: + name: REGISTRY_PASSWORD + path: devops-secrets +--- +kind: secret +name: KUBERNETES_SERVER +get: + name: KUBERNETES_SERVER + path: devops-secrets +--- +kind: secret +name: KUBERNETES_TOKEN +get: + name: KUBERNETES_TOKEN + path: devops-secrets +--- +kind: secret +name: ACCESS_KEY_MINIO +get: + name: ACCESS_KEY_MINIO + path: devops-secrets + +--- +kind: secret +name: SECRET_KEY_MINIO +get: + name: SECRET_KEY_MINIO + path: devops-secrets \ No newline at end of file diff --git a/.beagle/dockerfile b/.beagle/dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..951573bdb5f2d01e1f53171a2824a786013fee29 --- /dev/null +++ b/.beagle/dockerfile @@ -0,0 +1,9 @@ +ARG BASE +FROM ${BASE} +ARG AUTHOR +ARG VERSION + +LABEL maintainer=${AUTHOR} version=${VERSION} +RUN echo "Asia/Shanghai" > /etc/timezone +COPY ./target/sdt-kangdun-api-1.0.0.jar /app/sdt-kangdun-api-1.0.0.jar +ENTRYPOINT ["java","-jar","/app/sdt-kangdun-api-1.0.0.jar"] diff --git a/conf/rtdb-javasdk-config.properties b/conf/rtdb-javasdk-config.properties new file mode 100644 index 0000000000000000000000000000000000000000..8b49a49ce57cd765072e2f1ae3272c3f470fd7b9 --- /dev/null +++ b/conf/rtdb-javasdk-config.properties @@ -0,0 +1,2 @@ +# 断网重连超时时间，单位毫秒 +rtdb.connect.retry.timeout=5000 diff --git a/doc/yaml/beagle-extends-sdk-golden-api-config.yaml b/doc/yaml/beagle-extends-sdk-golden-api-config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7abf6e285eca3a86f261b72c7f2e66b3cec2ad3d --- /dev/null +++ b/doc/yaml/beagle-extends-sdk-golden-api-config.yaml @@ -0,0 +1,11 @@ +--- +kind: ConfigMap +apiVersion: v1 +metadata: + name: extends-sdk-golden-api-config +data: + GOLDEN_IP: '10.253.1.97' + GOLDEN_PORT: '6327' + GOLDEN_USER: 'sa' + GOLDEN_PASSWORD: 'golden' + diff --git a/doc/yaml/beagle-extends-sdk-golden-api.yaml b/doc/yaml/beagle-extends-sdk-golden-api.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c12f43714cac107231fdc7bb433f59d3d59da614 --- /dev/null +++ b/doc/yaml/beagle-extends-sdk-golden-api.yaml @@ -0,0 +1,71 @@ +--- +kind: Deployment +apiVersion: apps/v1 +metadata: + name: beagle-extends-sdk-golden-api + labels: + app: beagle-extends-sdk-golden-api +spec: + replicas: 1 + selector: + matchLabels: + app: beagle-extends-sdk-golden-api + template: + metadata: + labels: + app: beagle-extends-sdk-golden-api + spec: + containers: + - name: beagle-extends-sdk-golden-api + image: hub.wodcloud.com/xinchuang/sdt-cryptohi-api:v1.0.0-amd64 + imagePullPolicy: Always + resources: + limits: + cpu: 1 + memory: 2Gi + requests: + cpu: 0.1 + memory: 256Mi + ports: + - containerPort: 8080 + name: http + volumeMounts: + - name: localtime + mountPath: /etc/localtime + envFrom: + - configMapRef: + name: xc-sdt-cryptohi-api-config-dev + volumes: + - name: localtime + hostPath: + path: /etc/localtime + +--- +kind: Service +apiVersion: v1 +metadata: + name: beagle-extends-sdk-golden-api +spec: + selector: + app: beagle-extends-sdk-golden-api + ports: + - name: beagle-extends-sdk-golden-api + port: 80 + targetPort: 8080 + +--- +kind: IngressRoute +apiVersion: bcc.bd-apaas.com/v1alpha1 +metadata: + name: beagle-extends-sdk-golden-api +spec: + entryPoints: + - websecure + routes: + - kind: Rule + match: Host(`xc-cloud.dev.wodcloud.com`) && PathPrefix(`/sdk/golden/api`) + services: + - name: beagle-extends-sdk-golden-api + port: 80 + tls: + certResolver: default \ No newline at end of file diff --git a/lib/log4j-1.2.17.jar b/lib/log4j-1.2.17.jar new file mode 100644 index 0000000000000000000000000000000000000000..1d425cf7d7e25f81be64d32c406ff66cfb6c4766 Binary files /dev/null and b/lib/log4j-1.2.17.jar differ diff --git a/lib/rtdb-java-sdk-3.0.48.jar b/lib/rtdb-java-sdk-3.0.48.jar new file mode 100644 index 0000000000000000000000000000000000000000..69d6a637f8c4085d921c2756a4fe3f0d30aad530 Binary files /dev/null and b/lib/rtdb-java-sdk-3.0.48.jar differ diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000000000000000000000000000000000000..a5438921c21f9334cbc08fc227762c242bde53a1 --- /dev/null +++ b/pom.xml @@ -0,0 +1,150 @@ + + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 2.7.0 + + + com.beagle.sdt.kangdun + sdt-kangdun-api + 1.0.0 + jar + sdt-kangdun-api + + 8 + 2.0.40 + 3.0.3 + + + + + net.java.dev.jna + jna + 4.5.2 + ${pom.basedir}/lib/rtdb-java-sdk-3.0.48.jar + system + + + + + org.springframework.boot + spring-boot-starter-log4j2 + + + + org.springframework.boot + spring-boot-starter-web + + + org.springframework.boot + spring-boot-starter-logging + + + + + + org.springframework.boot + spring-boot-starter-aop + + + + org.springframework.boot + spring-boot-configuration-processor + true + + + + + org.springframework.boot + spring-boot-starter-validation + + + + + + com.alibaba.fastjson2 + fastjson2 + ${alibaba.fastjson.version} + + + + + com.github.xiaoymin + knife4j-spring-boot-starter + ${knife4j.version} + + + + org.springframework.boot + spring-boot-devtools + runtime + true + + + + org.projectlombok + lombok + + + + cn.hutool + hutool-all + 5.8.15 + + + + + junit + junit + + + org.springframework.boot + spring-boot-test + 2.7.0 + + + org.springframework + spring-test + + + + + + org.springframework.boot + spring-boot-maven-plugin + + true + + + + + + src/main/resources + + **/*.yml + **/*.yaml + **/*.properties + **/*.xml + **/*.xlsx + + false + + + ${project.basedir}/lib + BOOT-INF/lib/ + + **/*.jar + + + + + diff --git a/src/main/java/com/beagle/base/BaseApplication.java b/src/main/java/com/beagle/base/BaseApplication.java new file mode 100644 index 0000000000000000000000000000000000000000..13f3c604e1bcd820907a0635f4048630e202f56b --- /dev/null +++ b/src/main/java/com/beagle/base/BaseApplication.java @@ -0,0 +1,20 @@ +package com.beagle.base; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration; +import org.springframework.scheduling.annotation.EnableScheduling; + +/** + * @author wuwanli + */ +@SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class}) +@EnableScheduling +public class BaseApplication { + + public static void main(String[] args) { + SpringApplication.run(BaseApplication.class, args); + } + +} diff --git a/src/main/java/com/beagle/base/BasePointsPropertiesNewParam.java b/src/main/java/com/beagle/base/BasePointsPropertiesNewParam.java new file mode 100644 index 0000000000000000000000000000000000000000..49dbe5690c311969d04e96905444a5b6e0849819 --- /dev/null +++ b/src/main/java/com/beagle/base/BasePointsPropertiesNewParam.java @@ -0,0 +1,8 @@ +package com.beagle.base; + +import lombok.Data; + +@Data +public class BasePointsPropertiesNewParam { + private String [] tagName; +} diff --git a/src/main/java/com/beagle/base/UserVo.java b/src/main/java/com/beagle/base/UserVo.java new file mode 100644 index 0000000000000000000000000000000000000000..e67f1edbbc73d520a413560f958b995fe1aa1b83 --- /dev/null +++ b/src/main/java/com/beagle/base/UserVo.java @@ -0,0 +1,12 @@ +package com.beagle.base; + +import lombok.Data; + +@Data +public class UserVo { + private String userId; + private String userType; + private String userName; + private String phone; + private String email; +} diff --git a/src/main/java/com/beagle/base/bean/vo/BasePointsPropertiesParam.java b/src/main/java/com/beagle/base/bean/vo/BasePointsPropertiesParam.java new file mode 100644 index 0000000000000000000000000000000000000000..0da797c30fc97958f0a05e240680d44faf2fd19e --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/BasePointsPropertiesParam.java @@ -0,0 +1,11 @@ +package com.beagle.base.bean.vo; + +import lombok.Data; + +import javax.validation.constraints.NotNull; + +@Data +public class BasePointsPropertiesParam { + @NotNull(message = "id集合不能为空") + private int[] ids; +} diff --git a/src/main/java/com/beagle/base/bean/vo/BaseSearchParam.java b/src/main/java/com/beagle/base/bean/vo/BaseSearchParam.java new file mode 100644 index 0000000000000000000000000000000000000000..9ad715a2f9edd5020f3a8de3d776ae947e9686c4 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/BaseSearchParam.java @@ -0,0 +1,17 @@ +package com.beagle.base.bean.vo; + +import com.rtdb.enums.DataSort; +import com.rtdb.model.SearchCondition; +import lombok.Data; + +import javax.validation.constraints.NotNull; + +@Data +public class BaseSearchParam { + @NotNull(message = "搜索条件不能为空") + private SearchCondition condition; + @NotNull(message = "请求次数不能为空") + private Integer count; + @NotNull(message = "排序规则不能为空") + private DataSort sort; +} diff --git a/src/main/java/com/beagle/base/bean/vo/BaseSearchPointCountParam.java b/src/main/java/com/beagle/base/bean/vo/BaseSearchPointCountParam.java new file mode 100644 index 0000000000000000000000000000000000000000..527b18262fbb01c9a246332fc7c72d0aa5bca912 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/BaseSearchPointCountParam.java @@ -0,0 +1,11 @@ +package com.beagle.base.bean.vo; + +import com.rtdb.enums.DataSort; +import com.rtdb.model.SearchConditionTotal; +import lombok.Data; + +@Data +public class BaseSearchPointCountParam { + private SearchConditionTotal condition; + private DataSort sort; +} diff --git a/src/main/java/com/beagle/base/bean/vo/BaseTableTagNamesParam.java b/src/main/java/com/beagle/base/bean/vo/BaseTableTagNamesParam.java new file mode 100644 index 0000000000000000000000000000000000000000..e879b3addad5ee2c2654cad095cf7a1118605878 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/BaseTableTagNamesParam.java @@ -0,0 +1,9 @@ +package com.beagle.base.bean.vo; + +import lombok.Data; + +@Data +public class BaseTableTagNamesParam { + private int[] ids; + +} diff --git a/src/main/java/com/beagle/base/bean/vo/HistorianDoubleArchivedValuesParam.java b/src/main/java/com/beagle/base/bean/vo/HistorianDoubleArchivedValuesParam.java new file mode 100644 index 0000000000000000000000000000000000000000..50b858ecc75a96e46d698eb7015ecb6a1a8cca2a --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/HistorianDoubleArchivedValuesParam.java @@ -0,0 +1,26 @@ +package com.beagle.base.bean.vo; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import javax.validation.constraints.NotNull; +import java.util.Date; + +@Data +public class HistorianDoubleArchivedValuesParam { + + @NotNull(message = "id不能为空") + private Integer id; + @NotNull(message = "过滤条件不能为空") + + private Integer count; + @NotNull(message = "请求开始时间不能为空") + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date startTime; + @NotNull(message = "请求结束时间不能为空") + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date endTime; +} diff --git a/src/main/java/com/beagle/base/bean/vo/HistorianFloatArchivedValuesFiltParam.java b/src/main/java/com/beagle/base/bean/vo/HistorianFloatArchivedValuesFiltParam.java new file mode 100644 index 0000000000000000000000000000000000000000..78eff3bb0989893b74ba5008bc8afb350b232ac5 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/HistorianFloatArchivedValuesFiltParam.java @@ -0,0 +1,26 @@ +package com.beagle.base.bean.vo; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import javax.validation.constraints.NotNull; +import java.util.Date; + +@Data +public class HistorianFloatArchivedValuesFiltParam { + @NotNull(message = "id不能为空") + private Integer id; + @NotNull(message = "过滤条件不能为空") + private String filter; + @NotNull(message = "请求次数不能为空") + private Integer count; + @NotNull(message = "请求开始时间不能为空") + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date startTime; + @NotNull(message = "请求结束时间不能为空") + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date endTime; +} diff --git a/src/main/java/com/beagle/base/bean/vo/HistorianFloatInterpoValuesParam.java b/src/main/java/com/beagle/base/bean/vo/HistorianFloatInterpoValuesParam.java new file mode 100644 index 0000000000000000000000000000000000000000..75bf36bdf07240c158e03556d7c44b7fdfaa750d --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/HistorianFloatInterpoValuesParam.java @@ -0,0 +1,30 @@ +package com.beagle.base.bean.vo; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import javax.validation.constraints.NotNull; +import java.util.Date; + +@Data +public class HistorianFloatInterpoValuesParam { + @NotNull(message = "id不能为空") + private Integer id; + @NotNull(message = "请求次数不能为空") + private Integer count; + + // Date dateStart = DateUtil.stringToDate("2017-11-16 18:05:55"); +// Date dateEnd = DateUtil.stringToDate("2017-11-16 20:00:55"); + //纳秒版本时间的传入方式 + //DateTimeNS dateStart = new DateTimeNS(dateDateUtil.stringToDate("2017-11-16 18:05:55"), 0); + //DateTimeNS dateEnd = new DateTimeNS(DateUtil.stringToDate("2017-11-16 20:00:55"), 0); + @NotNull(message = "请求开始时间不能为空") + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date startTime; + @NotNull(message = "请求结束时间不能为空") + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date endTime; +} diff --git a/src/main/java/com/beagle/base/bean/vo/HistorianFloatIntervalValuesParam.java b/src/main/java/com/beagle/base/bean/vo/HistorianFloatIntervalValuesParam.java new file mode 100644 index 0000000000000000000000000000000000000000..4ca9a74a32503453e2c2aece54122f4d0bcabb89 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/HistorianFloatIntervalValuesParam.java @@ -0,0 +1,22 @@ +package com.beagle.base.bean.vo; + +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; +import org.springframework.format.annotation.DateTimeFormat; + +import javax.validation.constraints.NotNull; +import java.util.Date; + +@Data +public class HistorianFloatIntervalValuesParam { + @NotNull(message = "id不能为空") + private Integer id; + @NotNull(message = "请求次数不能为空") + private Integer count; + @NotNull(message = "请求频率不能为空") + private Long interval; + @NotNull(message = "请求时间不能为空") + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private Date dateTime; +} diff --git a/src/main/java/com/beagle/base/bean/vo/SnapshotBlobParam.java b/src/main/java/com/beagle/base/bean/vo/SnapshotBlobParam.java new file mode 100644 index 0000000000000000000000000000000000000000..63fd7c63074766504f219df41424b947f9b56659 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/SnapshotBlobParam.java @@ -0,0 +1,9 @@ +package com.beagle.base.bean.vo; + +import lombok.Data; + +@Data +public class SnapshotBlobParam { + private int[] ids; + +} diff --git a/src/main/java/com/beagle/base/bean/vo/SnapshotCoorParam.java b/src/main/java/com/beagle/base/bean/vo/SnapshotCoorParam.java new file mode 100644 index 0000000000000000000000000000000000000000..32abbcd03fd80310b88034af5a95ec18c4c88819 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/SnapshotCoorParam.java @@ -0,0 +1,8 @@ +package com.beagle.base.bean.vo; + +import lombok.Data; + +@Data +public class SnapshotCoorParam { + private int[] ids; +} diff --git a/src/main/java/com/beagle/base/bean/vo/SnapshotDoubleParam.java b/src/main/java/com/beagle/base/bean/vo/SnapshotDoubleParam.java new file mode 100644 index 0000000000000000000000000000000000000000..73ac48a8029defd49f9edc3d54853551278d2d65 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/SnapshotDoubleParam.java @@ -0,0 +1,8 @@ +package com.beagle.base.bean.vo; + +import lombok.Data; + +@Data +public class SnapshotDoubleParam { + private int[] ids; +} diff --git a/src/main/java/com/beagle/base/bean/vo/SnapshotIntParam.java b/src/main/java/com/beagle/base/bean/vo/SnapshotIntParam.java new file mode 100644 index 0000000000000000000000000000000000000000..d2743d0efb984cf7bae5d53e90d91d1b4c432690 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/SnapshotIntParam.java @@ -0,0 +1,8 @@ +package com.beagle.base.bean.vo; + +import lombok.Data; + +@Data +public class SnapshotIntParam { + private int[] ids; +} diff --git a/src/main/java/com/beagle/base/bean/vo/resp/BaseResponse.java b/src/main/java/com/beagle/base/bean/vo/resp/BaseResponse.java new file mode 100644 index 0000000000000000000000000000000000000000..3230efd7e4afb418aa19ade0248225751fa31c9c --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/resp/BaseResponse.java @@ -0,0 +1,63 @@ +package com.beagle.base.bean.vo.resp; + +import com.beagle.base.common.contant.CodeEnum; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; +import lombok.ToString; + +import java.io.Serializable; + +/** + * @author wuwanli + */ +@Data +@ToString +@ApiModel +public class BaseResponse implements Serializable { + /** + * 返回码 + */ + @ApiModelProperty("返回码") + private String code; + /** + * 返回描述 + */ + @ApiModelProperty("返回描述") + private String desc; + + public static BaseResponse success() { + BaseResponse baseResponse = new BaseResponse(); + baseResponse.setCode(CodeEnum.SUCCESS.getCode()); + baseResponse.setDesc(CodeEnum.SUCCESS.getDesc()); + return baseResponse; + } + + public static BaseResponse fail() { + BaseResponse baseResponse = new BaseResponse(); + baseResponse.setCode(CodeEnum.UNKNOWN.getCode()); + baseResponse.setDesc(CodeEnum.UNKNOWN.getDesc()); + return baseResponse; + } + + public static BaseResponse fail(CodeEnum codeEnum) { + BaseResponse baseResponse = new BaseResponse(); + baseResponse.setCode(codeEnum.getCode()); + baseResponse.setDesc(codeEnum.getDesc()); + return baseResponse; + } + + public static BaseResponse fail(String code, String desc) { + BaseResponse baseResponse = new BaseResponse(); + baseResponse.setCode(code); + baseResponse.setDesc(desc); + return baseResponse; + } + + public static BaseResponse fail(String desc) { + BaseResponse baseResponse = new BaseResponse(); + baseResponse.setCode(CodeEnum.UNKNOWN.getCode()); + baseResponse.setDesc(desc); + return baseResponse; + } +} diff --git a/src/main/java/com/beagle/base/bean/vo/resp/ExtBaseResponse.java b/src/main/java/com/beagle/base/bean/vo/resp/ExtBaseResponse.java new file mode 100644 index 0000000000000000000000000000000000000000..63972d3561cb76546b7bfc8c139189e68fc26aed --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/resp/ExtBaseResponse.java @@ -0,0 +1,63 @@ +package com.beagle.base.bean.vo.resp; + +import com.beagle.base.common.contant.CodeEnum; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; +import lombok.ToString; + +import java.io.Serializable; + +/** + * @author wuwanli + */ +@Data +@ToString +@ApiModel +public class ExtBaseResponse implements Serializable { + /** + * 返回码 + */ + @ApiModelProperty("返回码") + private String code; + /** + * 返回描述 + */ + @ApiModelProperty("返回描述") + private String msg; + + public static ExtBaseResponse success() { + ExtBaseResponse baseResponse = new ExtBaseResponse(); + baseResponse.setCode(CodeEnum.SUCCESS.getCode()); + baseResponse.setMsg(CodeEnum.SUCCESS.getDesc()); + return baseResponse; + } + + public static ExtBaseResponse fail() { + ExtBaseResponse baseResponse = new ExtBaseResponse(); + baseResponse.setCode(CodeEnum.UNKNOWN.getCode()); + baseResponse.setMsg(CodeEnum.UNKNOWN.getDesc()); + return baseResponse; + } + + public static ExtBaseResponse fail(CodeEnum codeEnum) { + ExtBaseResponse baseResponse = new ExtBaseResponse(); + baseResponse.setCode(codeEnum.getCode()); + baseResponse.setMsg(codeEnum.getDesc()); + return baseResponse; + } + + public static ExtBaseResponse fail(String code, String desc) { + ExtBaseResponse baseResponse = new ExtBaseResponse(); + baseResponse.setCode(code); + baseResponse.setMsg(desc); + return baseResponse; + } + + public static ExtBaseResponse fail(String desc) { + ExtBaseResponse baseResponse = new ExtBaseResponse(); + baseResponse.setCode(CodeEnum.UNKNOWN.getCode()); + baseResponse.setMsg(desc); + return baseResponse; + } +} diff --git a/src/main/java/com/beagle/base/bean/vo/resp/ExtResponse.java b/src/main/java/com/beagle/base/bean/vo/resp/ExtResponse.java new file mode 100644 index 0000000000000000000000000000000000000000..d9aeb5ca376b3912400f2a70e8c4dac9c703759c --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/resp/ExtResponse.java @@ -0,0 +1,34 @@ +package com.beagle.base.bean.vo.resp; + +import com.beagle.base.common.contant.CodeEnum; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; + +/** + * @author wuwanli + */ +@Data +@ApiModel +@NoArgsConstructor +@EqualsAndHashCode(callSuper = true) +public class ExtResponse extends ExtBaseResponse { + /** + * 封装的返回对象 + */ + @ApiModelProperty("返回对象") + private T data; + + public ExtResponse(T data) { + this.setCode(CodeEnum.SUCCESS.getCode()); + this.setMsg(CodeEnum.SUCCESS.getDesc()); + this.data = data; + } + + public ExtResponse(CodeEnum codeEnum) { + this.setCode(codeEnum.getCode()); + this.setMsg(codeEnum.getCode()); + } +} diff --git a/src/main/java/com/beagle/base/bean/vo/resp/Response.java b/src/main/java/com/beagle/base/bean/vo/resp/Response.java new file mode 100644 index 0000000000000000000000000000000000000000..3632325af94f9937f9461b9e14c7c97311cc5035 --- /dev/null +++ b/src/main/java/com/beagle/base/bean/vo/resp/Response.java @@ -0,0 +1,33 @@ +package com.beagle.base.bean.vo.resp; + +import com.beagle.base.common.contant.CodeEnum; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +/** + * @author wuwanli + */ +@Data +@ApiModel +@NoArgsConstructor +@EqualsAndHashCode(callSuper = true) +public class Response extends BaseResponse { + /** + * 封装的返回对象 + */ + @ApiModelProperty("返回对象") + private T data; + + public Response(T data) { + this.setCode(CodeEnum.SUCCESS.getCode()); + this.setDesc(CodeEnum.SUCCESS.getDesc()); + this.data = data; + } + + public Response(CodeEnum codeEnum) { + this.setCode(codeEnum.getCode()); + this.setDesc(codeEnum.getCode()); + } +} diff --git a/src/main/java/com/beagle/base/common/aspect/InterfaceLogAspect.java b/src/main/java/com/beagle/base/common/aspect/InterfaceLogAspect.java new file mode 100644 index 0000000000000000000000000000000000000000..2d8e19dfddaad5006a251874bb892bbae29a82f0 --- /dev/null +++ b/src/main/java/com/beagle/base/common/aspect/InterfaceLogAspect.java @@ -0,0 +1,63 @@ +package com.beagle.base.common.aspect; + +import java.util.HashMap; +import java.util.Map; + +import com.alibaba.fastjson2.JSONObject; +import org.aspectj.lang.JoinPoint; +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.annotation.Around; +import org.aspectj.lang.annotation.Aspect; +import org.aspectj.lang.annotation.Before; +import org.aspectj.lang.reflect.MethodSignature; +import org.springframework.context.annotation.Description; +import org.springframework.core.annotation.Order; +import org.springframework.stereotype.Component; +import org.springframework.web.context.request.RequestContextHolder; +import org.springframework.web.context.request.ServletRequestAttributes; + + +import lombok.extern.slf4j.Slf4j; + +/** + * @author wuwanli + */ +@Order(1) +@Slf4j +@Aspect +@Component +public class InterfaceLogAspect { + @Description("打印接口请求报文") + @Before("execution(* com.beagle.base.controller..*.*(..))") + public void before(JoinPoint joinPoint) { + try { + ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes(); + MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature(); + String[] parameterNames = methodSignature.getParameterNames(); + Map paramMap = new HashMap<>(10); + Object[] args = joinPoint.getArgs(); + if (parameterNames.length <= args.length) { + for (int i = 0; i < parameterNames.length; i++) { + paramMap.put(parameterNames[i], args[i]); + } + } + log.info( + "interface url : " + (attributes != null ? attributes.getRequest().getRequestURL() : null)); + log.info("interface className : " + joinPoint.getTarget().getClass().getName()); + log.info("interface methodName : " + joinPoint.getSignature().getName()); + log.info("interface requestBody : " + JSONObject.toJSONString(paramMap)); + } catch (Exception exception) { + log.error("InterfaceLogAspect.logInterfaceRequest Exception", exception); + } + } + + @Description("打印接口响应报文") + @Around("execution(* com.beagle.base.controller..*.*(..))") + public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { + long startTime = System.currentTimeMillis(); + Object result = proceedingJoinPoint.proceed(); + log.info("interface responseBody : " + (result != null ? JSONObject.toJSONString(result) : null)); + log.info("interface time-consuming :{}", System.currentTimeMillis() - startTime); + return result; + } +} diff --git a/src/main/java/com/beagle/base/common/component/ApplicationContextUtil.java b/src/main/java/com/beagle/base/common/component/ApplicationContextUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..669f63fde9831827d2b24bd68ce12297fca1d804 --- /dev/null +++ b/src/main/java/com/beagle/base/common/component/ApplicationContextUtil.java @@ -0,0 +1,28 @@ +package com.beagle.base.common.component; + +import org.springframework.beans.BeansException; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationContextAware; +import org.springframework.stereotype.Component; + +/** + * @author wuwanli + */ +@Component +public class ApplicationContextUtil implements ApplicationContextAware { + + private static ApplicationContext applicationContext; + + @Override + public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { + ApplicationContextUtil.applicationContext = applicationContext; + } + + public static T getBean(Class clazz) throws BeansException { + return applicationContext.getBean(clazz); + } + + public static T getBean(String name, Class clazz) throws BeansException { + return applicationContext.getBean(name, clazz); + } +} diff --git a/src/main/java/com/beagle/base/common/config/CommonConfig.java b/src/main/java/com/beagle/base/common/config/CommonConfig.java new file mode 100644 index 0000000000000000000000000000000000000000..4c4affb215bceaf84e1b2b94176c0f12befdda22 --- /dev/null +++ b/src/main/java/com/beagle/base/common/config/CommonConfig.java @@ -0,0 +1,22 @@ +package com.beagle.base.common.config; + +import lombok.Getter; +import lombok.Setter; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.context.annotation.Configuration; + +@Getter +@Setter +@Configuration +@ConfigurationProperties(prefix = "beagle.xc.crypt") +public class CommonConfig { + /** + * 实例ID + */ + private String instanceId; + + /** + * XC-Core平台地址 + */ + private String xcCoreHost; +} diff --git a/src/main/java/com/beagle/base/common/config/FilterConfig.java b/src/main/java/com/beagle/base/common/config/FilterConfig.java new file mode 100644 index 0000000000000000000000000000000000000000..b5f979eb7782f058d57cc1aff89f6bda2592a2da --- /dev/null +++ b/src/main/java/com/beagle/base/common/config/FilterConfig.java @@ -0,0 +1,35 @@ +package com.beagle.base.common.config; + +import com.beagle.base.common.filter.AuthenticationFilter; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.web.servlet.FilterRegistrationBean; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.core.Ordered; + +import com.beagle.base.common.filter.LogbackFilter; +/** + * @author wuwanli + */ +@Configuration +public class FilterConfig { + @Value("${server.servlet.context-path}") + private String consoleUrl; + @Bean + public FilterRegistrationBean getLogbackFilter() { + FilterRegistrationBean logbackFilter = new FilterRegistrationBean<>(new LogbackFilter()); + logbackFilter.addUrlPatterns("/*"); + logbackFilter.setOrder(Ordered.HIGHEST_PRECEDENCE); + return logbackFilter; + } +// 暂时去掉用户授权，验证主流程是否正确 +// @Bean + public FilterRegistrationBean authenticationFilterRegistration() { + FilterRegistrationBean registration = + new FilterRegistrationBean<>(new AuthenticationFilter(consoleUrl)); + registration.addUrlPatterns("/*"); + registration.setName("authenticationFilter"); + registration.setOrder(1); + return registration; + } +} diff --git a/src/main/java/com/beagle/base/common/config/Knife4jConfiguration.java b/src/main/java/com/beagle/base/common/config/Knife4jConfiguration.java new file mode 100644 index 0000000000000000000000000000000000000000..dab3e15afbd0b85563afca0dea5b364100792121 --- /dev/null +++ b/src/main/java/com/beagle/base/common/config/Knife4jConfiguration.java @@ -0,0 +1,28 @@ +package com.beagle.base.common.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +import springfox.documentation.builders.ApiInfoBuilder; +import springfox.documentation.builders.PathSelectors; +import springfox.documentation.builders.RequestHandlerSelectors; +import springfox.documentation.spi.DocumentationType; +import springfox.documentation.spring.web.plugins.Docket; +import springfox.documentation.swagger2.annotations.EnableSwagger2; +/** + * @author wuwanli + */ +@EnableSwagger2 +@Configuration +public class Knife4jConfiguration { + @Bean(value = "defaultApi2") + public Docket defaultApi2() { + return new Docket(DocumentationType.SWAGGER_2) + .apiInfo(new ApiInfoBuilder().description("APIs").termsOfServiceUrl("http://localhost:8080/base") + .version("1.0").build()) + // 分组名称 + .groupName("base").select() + // 这里指定Controller扫描包路径 + .apis(RequestHandlerSelectors.basePackage("com.beagle.base.controller")).paths(PathSelectors.any()).build(); + } +} diff --git a/src/main/java/com/beagle/base/common/config/RestTemplateConfig.java b/src/main/java/com/beagle/base/common/config/RestTemplateConfig.java new file mode 100644 index 0000000000000000000000000000000000000000..e4467fb6138af39f02930014b073acec03702961 --- /dev/null +++ b/src/main/java/com/beagle/base/common/config/RestTemplateConfig.java @@ -0,0 +1,28 @@ +package com.beagle.base.common.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.http.client.ClientHttpRequestFactory; +import org.springframework.web.client.RestTemplate; + +/** + * @author wuwanli + */ +@Configuration +public class RestTemplateConfig { + + @Bean + public RestTemplate restTemplate(ClientHttpRequestFactory factory) { + return new RestTemplate(factory); + } + + @Bean + public ClientHttpRequestFactory simpleClientHttpRequestFactory() { + SkipSslVerificationHttpRequestFactory factory = new SkipSslVerificationHttpRequestFactory(); + // 将响应超时时间设置大点 + factory.setReadTimeout(30000); + factory.setConnectTimeout(15000); + return factory; + } + +} diff --git a/src/main/java/com/beagle/base/common/config/SkipSslVerificationHttpRequestFactory.java b/src/main/java/com/beagle/base/common/config/SkipSslVerificationHttpRequestFactory.java new file mode 100644 index 0000000000000000000000000000000000000000..29f136364262deae8abf2821b668182eb95a5f81 --- /dev/null +++ b/src/main/java/com/beagle/base/common/config/SkipSslVerificationHttpRequestFactory.java @@ -0,0 +1,68 @@ +package com.beagle.base.common.config; + +import java.io.IOException; +import java.net.HttpURLConnection; +import java.security.SecureRandom; +import java.security.cert.X509Certificate; + +import javax.net.ssl.*; + +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.client.SimpleClientHttpRequestFactory; +/** + * @author wuwanli + */ +@Slf4j +public class SkipSslVerificationHttpRequestFactory extends SimpleClientHttpRequestFactory { + public SkipSslVerificationHttpRequestFactory() {} + + @Override + protected void prepareConnection(HttpURLConnection connection, String httpMethod) throws IOException { + if (connection instanceof HttpsURLConnection) { + this.prepareHttpsConnection((HttpsURLConnection)connection); + } + + super.prepareConnection(connection, httpMethod); + } + + private void prepareHttpsConnection(HttpsURLConnection connection) { + connection.setHostnameVerifier(new SkipHostnameVerifier()); + + try { + connection.setSSLSocketFactory(this.createSslSocketFactory()); + } catch (Exception var3) { + log.error("prepareHttpsConnection Exception", var3); + } + + } + + private SSLSocketFactory createSslSocketFactory() throws Exception { + SSLContext context = SSLContext.getInstance("TLS"); + context.init(null, new TrustManager[] {new SkipX509TrustManager()}, new SecureRandom()); + return context.getSocketFactory(); + } + + private static class SkipX509TrustManager implements X509TrustManager { + private SkipX509TrustManager() {} + + @Override + public X509Certificate[] getAcceptedIssuers() { + return new X509Certificate[0]; + } + + @Override + public void checkClientTrusted(X509Certificate[] chain, String authType) {} + + @Override + public void checkServerTrusted(X509Certificate[] chain, String authType) {} + } + + private static class SkipHostnameVerifier implements HostnameVerifier { + private SkipHostnameVerifier() {} + + @Override + public boolean verify(String s, SSLSession sslSession) { + return true; + } + } +} diff --git a/src/main/java/com/beagle/base/common/contant/CodeEnum.java b/src/main/java/com/beagle/base/common/contant/CodeEnum.java new file mode 100644 index 0000000000000000000000000000000000000000..1ac5d9ec7de32044ab8829e4713f6ef2aa48832c --- /dev/null +++ b/src/main/java/com/beagle/base/common/contant/CodeEnum.java @@ -0,0 +1,95 @@ +package com.beagle.base.common.contant; + +import lombok.Getter; +/** + * @author wuwanli + */ +public enum CodeEnum { + /** + * 处理成功 + */ + SUCCESS("200", "成功"), + /** + * 不支持 HTTP 方法 + */ + HTTP_METHOD_NOT_SUPPORTED("4000001", "不支持 HTTP 方法"), + /** + * 参数校验失败 + */ + ARGUMENT_VALID_ERROR("4000003", "参数校验失败"), + /** + * 参数类型错误 + */ + ARGUMENT_TYPE_ERROR("4000002", "参数类型错误"), + /** + * 必填参数为空 + */ + REQUIRED_PARAMETER_EMPTY("4001002", "必填参数为空"), + /** + * 未登录 + */ + NOT_LOGIN("4001003", "用户未登录"), + /** + * 处理成功 + */ + UNKNOWN("5000001", "系统异常"), + + /** + * SQL改写规则不存在 + */ + SQL_REWRITE_NOT_EXITS("5000002", "SQL改写规则不存在"), + /** + * SQL转换规则不存在 + */ + SQL_CONVERT_NOT_EXITS("5000003", "SQL转换规则不存在"), + /** + * SQL转换规则不存在 + */ + SOUTH_DATABASE_NOT_EXITS("5000004", "南向数据库不存在"), + /** + * SQL转换规则不存在 + */ + NORTH_DATABASE_NOT_EXITS("5000005", "北向数据库不存在"), + /** + * 文件格式不正确 + */ + FORMAT_MISMATCH_EXITS("5000005", "文件格式不正确"), + /** + * 实例端点地址不存在 + */ + ENDPOINT_NOT_EXITS("5000006", "实例端点地址不存在"), + /** + * 数据库驱动地址为空 + */ + DRIVER_JAR_URL_NOT_EXITS("5000007", "数据库驱动地址为空"), + INSTANCE_DATA_NOT_EXISTS("5000008", "实例规则管理数据为空"), + + INSTANCE_INDEX_DATA_NOT_EXISTS("5000009", "实例对应的es索引数据为空"), + OVER_INDEX_OF_ES("5000010", "查询数据量过大, 建议缩小查询范围"), + INSTANCE_NOT_AUTH("5000011", "实例未授权"), + EXCEED_FILE_MAX("5000012", "单文件大小超过5M限制"), + EXCEED_TOTAL_FILE_MAX("5000013", "总文件大小超过5M限制"), + UPLOAD_FILE_NAME_EMPTY("5000014", "上传文件格式为空"), + UPLOAD_FILE_NAME_ERROR("5000015", "上传文件格式错误"), + EXCEPTION_OPEN_SEARCH("5000016", "OPENSEARCH服务异常"), + UNAUTHORIZED_OPEN_SEARCH("5000017", "OPENSEARCH未授权"), + CRYPT_CHECK_FAILED("5000018", "内容防篡改验证失败"), + ; + + /** + * 构造函数 + * + * @param code 响应码 + * @param desc 响应描述 + */ + CodeEnum(String code, String desc) { + this.code = code; + this.desc = desc; + } + + @Getter + private final String code; + @Getter + private final String desc; + +} \ No newline at end of file diff --git a/src/main/java/com/beagle/base/common/contant/LoginConstants.java b/src/main/java/com/beagle/base/common/contant/LoginConstants.java new file mode 100644 index 0000000000000000000000000000000000000000..0fd8e43615428dd6e921a24917a5ca3fd6a103cf --- /dev/null +++ b/src/main/java/com/beagle/base/common/contant/LoginConstants.java @@ -0,0 +1,42 @@ +package com.beagle.base.common.contant; + +/** + * 业务常量 + * + * @author wuwanli + * @version 1.0 + * @date 2021/8/4 + */ +public interface LoginConstants { + /** + * 用户ID + */ + String AWE_TOKEN_PREFIX = "aweToken="; + /** + * 用户ID + */ + String USER_ID = "userId"; + /** + * 用户名称 + */ + String USER_NAME="userName"; + /** + * 用户类型，1：超管；其他 + */ + String USER_TYPE = "userType"; + + /** + * 用户类型，1：超管；其他 + */ + String USER_TYPE_ADMIN = "1"; + /** + * cookie中token的name + */ + String COOKIE_TOKEN_NAME = "aweToken"; + + /** + * cookie的name + */ + String COOKIE_NAME = "tokenCookie"; + +} diff --git a/src/main/java/com/beagle/base/common/exception/BeagleException.java b/src/main/java/com/beagle/base/common/exception/BeagleException.java new file mode 100644 index 0000000000000000000000000000000000000000..c43d9b9fe09b2fb964a8fe5979e3defdddc8e5e9 --- /dev/null +++ b/src/main/java/com/beagle/base/common/exception/BeagleException.java @@ -0,0 +1,51 @@ +package com.beagle.base.common.exception; + +import com.beagle.base.common.contant.CodeEnum; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; + +/** + * @author wuwanli + */ +@Data +@NoArgsConstructor +@EqualsAndHashCode(callSuper = true) +public class BeagleException extends RuntimeException { + /** + * 错误码 + */ + protected String errorCode; + /** + * 错误信息 + */ + protected String errorMsg; + + public BeagleException(String errorMsg) { + super(errorMsg); + this.errorMsg = errorMsg; + } + + public BeagleException(String errorCode, String errorMsg) { + super(errorMsg); + this.errorCode = errorCode; + this.errorMsg = errorMsg; + } + + public BeagleException(CodeEnum codeEnum) { + super(codeEnum.getDesc()); + this.errorCode = codeEnum.getCode(); + this.errorMsg = codeEnum.getDesc(); + } + + public BeagleException(String errorMsg, Throwable cause) { + super(errorMsg, cause); + } + + public BeagleException(String errorCode, String errorMsg, Throwable cause) { + super(errorCode, cause); + this.errorCode = errorCode; + this.errorMsg = errorMsg; + } +} diff --git a/src/main/java/com/beagle/base/common/exception/GlobalExceptionHandler.java b/src/main/java/com/beagle/base/common/exception/GlobalExceptionHandler.java new file mode 100644 index 0000000000000000000000000000000000000000..34f3aacde77a844c61d288c61bd07e75999e74e0 --- /dev/null +++ b/src/main/java/com/beagle/base/common/exception/GlobalExceptionHandler.java @@ -0,0 +1,103 @@ +package com.beagle.base.common.exception; + +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.apache.tomcat.util.http.fileupload.impl.FileSizeLimitExceededException; +import org.apache.tomcat.util.http.fileupload.impl.SizeLimitExceededException; +import org.springframework.validation.BindingResult; +import org.springframework.validation.ObjectError; +import org.springframework.web.HttpRequestMethodNotSupportedException; +import org.springframework.web.bind.MethodArgumentNotValidException; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RestControllerAdvice; +import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException; + +import com.beagle.base.bean.vo.resp.BaseResponse; +import com.beagle.base.common.contant.CodeEnum; +import org.springframework.web.multipart.MaxUploadSizeExceededException; +import org.springframework.web.multipart.MultipartException; + +import java.util.stream.Collectors; +/** + * @author wuwanli + */ +@Slf4j +@RestControllerAdvice +public class GlobalExceptionHandler { + /** + * @param exception 自定义异常 + * @return BaseResponse + */ + @ExceptionHandler(value = BeagleException.class) + public BaseResponse beagleExceptionHandler(BeagleException exception) { + log.error("GlobalExceptionHandler.beagleExceptionHandler", exception); + BaseResponse baseResponse = BaseResponse.fail(); + if (!StringUtils.isBlank(exception.getErrorCode())) { + baseResponse.setCode(exception.getErrorCode()); + baseResponse.setDesc(exception.getErrorMsg()); + } + return baseResponse; + } + @ExceptionHandler(value = MultipartException.class) + public BaseResponse MultipartExceptionHandler(MaxUploadSizeExceededException exception) { + log.error("GlobalExceptionHandler.MultipartException", exception); + String msg = ""; + BaseResponse baseResponse = BaseResponse.fail(); + if (exception.getCause().getCause() instanceof FileSizeLimitExceededException) { + log.error(exception.getMessage()); + baseResponse = BaseResponse.fail(CodeEnum.EXCEED_FILE_MAX); + }else if (exception.getCause().getCause() instanceof SizeLimitExceededException) { + log.error(exception.getMessage()); + baseResponse = BaseResponse.fail(CodeEnum.EXCEED_TOTAL_FILE_MAX); + } + return baseResponse; + } + + + + /** + * @param exception 系统异常 + * @return BaseResponse + */ + @ExceptionHandler(value = Exception.class) + public BaseResponse exceptionHandler(Exception exception) { + log.error("GlobalExceptionHandler.exceptionHandler", exception); + return BaseResponse.fail(); + } + + /** + * @param exception 不支持 HTTP 方法 + * @return BaseResponse + */ + @ExceptionHandler(value = HttpRequestMethodNotSupportedException.class) + public BaseResponse httpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException exception) { + log.error("GlobalExceptionHandler.httpRequestMethodNotSupportedException", exception); + return BaseResponse.fail(CodeEnum.HTTP_METHOD_NOT_SUPPORTED); + } + + /** + * @param exception 参数校验失败 + * @return BaseResponse + */ + @ExceptionHandler(value = MethodArgumentNotValidException.class) + public BaseResponse methodArgumentNotValidException(MethodArgumentNotValidException exception) { + log.error("GlobalExceptionHandler.methodArgumentNotValidException", exception); + BindingResult bindingResult = exception.getBindingResult(); + if (bindingResult.hasErrors()) { + String errorInfo = bindingResult.getAllErrors().stream().map(ObjectError::getDefaultMessage) + .collect(Collectors.joining(";")); + return BaseResponse.fail(CodeEnum.ARGUMENT_VALID_ERROR.getCode(), errorInfo); + } + return BaseResponse.fail(CodeEnum.ARGUMENT_VALID_ERROR); + } + + /** + * @param exception 参数类型错误 + * @return BaseResponse + */ + @ExceptionHandler(value = MethodArgumentTypeMismatchException.class) + public BaseResponse methodArgumentTypeMismatchException(MethodArgumentTypeMismatchException exception) { + log.error("GlobalExceptionHandler.methodArgumentTypeMismatchException", exception); + return BaseResponse.fail(CodeEnum.ARGUMENT_TYPE_ERROR); + } +} diff --git a/src/main/java/com/beagle/base/common/filter/AuthenticationFilter.java b/src/main/java/com/beagle/base/common/filter/AuthenticationFilter.java new file mode 100644 index 0000000000000000000000000000000000000000..69eb621ec01c34d96ffb7ee4f29b64a841b82895 --- /dev/null +++ b/src/main/java/com/beagle/base/common/filter/AuthenticationFilter.java @@ -0,0 +1,122 @@ +package com.beagle.base.common.filter; + +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.Cookie; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import com.alibaba.fastjson2.JSONObject; +import com.beagle.base.UserVo; +import com.beagle.base.common.component.ApplicationContextUtil; +import com.beagle.base.common.config.CommonConfig; +import com.beagle.base.common.contant.CodeEnum; +import com.beagle.base.common.contant.LoginConstants; +import com.beagle.base.common.util.ResponseUtil; +import lombok.Getter; +import lombok.Setter; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import org.springframework.http.*; +import org.springframework.web.client.RestTemplate; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + + +/** + * @author wuwanli + */ +@Slf4j +@Getter +@Setter +public class AuthenticationFilter implements Filter { + public static final String USER_INFO_API_URL = "/xc/core/api/auth/userinfo"; + private static String[] whiteList ; + public AuthenticationFilter(String consoleUrl) { + whiteList = new String[]{ + consoleUrl + "/doc.html","/swagger-resources","/api-docs",".html",".css",".js", consoleUrl + "/index" + }; + } + @Override + public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) { + HttpServletRequest request = (HttpServletRequest) servletRequest; + HttpServletResponse response = (HttpServletResponse) servletResponse; + try { + + // 设置白名单 + for (String whiteUrl : whiteList) { + if (request.getRequestURI().startsWith(whiteUrl) + || request.getRequestURI().endsWith(whiteUrl)) { + filterChain.doFilter(request, response); + return; + } + } + + Cookie[] cookies = request.getCookies(); + if (cookies == null || cookies.length == 0) { + ResponseUtil.returnBaseResponse(response, CodeEnum.NOT_LOGIN); + return; + } + List cookieList = Arrays.stream(cookies) + .map(obj -> obj.getName() + "=" + obj.getValue()) + .collect(Collectors.toList()); + cookieList.forEach(item -> { + log.info("Cookie:{}",item); + }); + JSONObject userJson = getUserInfo(cookieList); + UserVo userVo = new UserVo(); + userVo.setUserId(userJson.getString("user_id")); + userVo.setUserType(userJson.getString("user_type")); + userVo.setUserName(userJson.getString("user_name")); + userVo.setPhone(userJson.getString("phone")); + userVo.setEmail(userJson.getString("email")); + String userId = userVo.getUserId(); + if (StringUtils.isBlank(userId)) { + ResponseUtil.returnBaseResponse(response, CodeEnum.NOT_LOGIN); + return; + } + String userName = userVo.getUserName(); + // 用户类型；1：超管 + String userType = userVo.getUserType(); + request.setAttribute(LoginConstants.COOKIE_NAME, cookieList); + request.setAttribute(LoginConstants.USER_ID, userId); + request.setAttribute(LoginConstants.USER_NAME, userName); + request.setAttribute(LoginConstants.USER_TYPE, userType); + log.info("----------------鉴权结束------------------------"); + filterChain.doFilter(request, response); + } catch (Exception ex) { + log.error("authenticationFilter Exception: ", ex); + ResponseUtil.returnBaseResponse(response, CodeEnum.NOT_LOGIN); + } + } + + /** + * 获取用户登录接口 + * @param cookieList cookie数据 + * @return 用户数据 + */ + private JSONObject getUserInfo(List cookieList){ + JSONObject userJson = new JSONObject(); + HttpHeaders headers = new HttpHeaders(); + headers.put(HttpHeaders.COOKIE, cookieList); + RestTemplate restTemplate = ApplicationContextUtil.getBean(RestTemplate.class); + CommonConfig config = ApplicationContextUtil.getBean(CommonConfig.class); + String url = config.getXcCoreHost() + USER_INFO_API_URL; + log.info("调用xc-core用户登录接口地址：{}", url); + ResponseEntity responseEntity = restTemplate.exchange(url, HttpMethod.GET,new HttpEntity<>(headers),JSONObject.class); + log.info("调用xc-core用户登录接口返回结果为：{},{}", responseEntity.getBody(), responseEntity.getStatusCodeValue()); + if(HttpStatus.OK.value() == responseEntity.getStatusCodeValue()){ + JSONObject resultJson = responseEntity.getBody(); + if (resultJson == null) { + return userJson; + } + userJson = resultJson.getJSONObject("data"); + log.debug("----------- userJson -> {}", userJson); + } + return userJson; + } +} diff --git a/src/main/java/com/beagle/base/common/filter/LogbackFilter.java b/src/main/java/com/beagle/base/common/filter/LogbackFilter.java new file mode 100644 index 0000000000000000000000000000000000000000..ec361128d644c6ec8f3ffd61ad1d3e7f8e3cd58b --- /dev/null +++ b/src/main/java/com/beagle/base/common/filter/LogbackFilter.java @@ -0,0 +1,51 @@ +package com.beagle.base.common.filter; + +import java.io.IOException; +import java.util.UUID; + +import javax.servlet.*; +import javax.servlet.annotation.WebFilter; + +import org.slf4j.MDC; +import org.springframework.core.Ordered; +import org.springframework.core.annotation.Order; + +/** + * @author wuwanli + */ +public class LogbackFilter implements Filter { + + private static final String TRACE_ID = "traceId"; + + @Override + public void init(FilterConfig filterConfig) throws ServletException { + Filter.super.init(filterConfig); + } + + @Override + public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) + throws IOException, ServletException { + boolean result = this.insertMdc(); + try { + filterChain.doFilter(servletRequest, servletResponse); + } finally { + if (result) { + MDC.remove(TRACE_ID); + } + } + } + + private boolean insertMdc() { + try { + MDC.put(TRACE_ID, UUID.randomUUID().toString().replace("-", "")); + return true; + } catch (Exception exception) { + return false; + } + } + + @Override + public void destroy() { + Filter.super.destroy(); + } +} diff --git a/src/main/java/com/beagle/base/common/util/BaseUtil.java b/src/main/java/com/beagle/base/common/util/BaseUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..f53774da118ac8f9a5aa1d099952d4bd674963a2 --- /dev/null +++ b/src/main/java/com/beagle/base/common/util/BaseUtil.java @@ -0,0 +1,84 @@ +package com.beagle.base.common.util; + +import cn.hutool.core.collection.CollUtil; +import com.beagle.base.BasePointsPropertiesNewParam; +import com.beagle.base.bean.vo.BasePointsPropertiesParam; +import com.beagle.base.bean.vo.BaseSearchParam; +import com.beagle.base.bean.vo.BaseSearchPointCountParam; +import com.beagle.base.bean.vo.BaseTableTagNamesParam; +import com.rtdb.model.Entity; +import com.rtdb.model.FullPoint; +import com.rtdb.model.MinPoint; + +import java.util.ArrayList; +import java.util.List; + +public class BaseUtil { + + public static int[] search(BaseSearchParam param) { + int [] res = null; + try { + res = CommonUtil.getBaseImpl().search(param.getCondition(), param.getCount(), param.getSort()); + if (res != null) { + return res; + } + return new int[]{}; + }catch (Exception e) { + e.printStackTrace(); + return new int[]{}; + } + } + + // 获取测点全属性 + public static List getPointsProperties(BasePointsPropertiesParam param) { + List res = new ArrayList<>(); + try { + Entity entity = null; + entity = CommonUtil.getBaseImpl().getPointsProperties(param.getIds()); + if (entity != null & CollUtil.isNotEmpty(entity.getList())) { + res = entity.getList(); + } + return res; + }catch (Exception e){ + e.printStackTrace(); + return res; + } + } + + public static Integer searchPointCount(BaseSearchPointCountParam param) { + int res = 0; + try { + res = CommonUtil.getBaseImpl().searchPointCount(param.getCondition(), param.getSort()); + }catch (Exception e){ + e.printStackTrace(); + return res; + } + return res; + } + + public static String[] getTableTagNames(BaseTableTagNamesParam param) { + String [] res = null; + try { + res = CommonUtil.getBaseImpl().getTableTagNames(param.getIds()); + }catch (Exception e){ + e.printStackTrace(); + res = new String[0]; + return res; + } + return res; + } + + public static List getPointsPropertiesTags(BasePointsPropertiesNewParam param) { + List res = new ArrayList<>();; + try { + Entity pointsProperties = CommonUtil.getBaseImpl().getPointsProperties(param.getTagName()); + if (pointsProperties != null && CollUtil.isNotEmpty(pointsProperties.getList())) { + res = pointsProperties.getList(); + } + }catch (Exception e){ + e.printStackTrace(); + return res; + } + return res; + } +} diff --git a/src/main/java/com/beagle/base/common/util/BeanUtil.java b/src/main/java/com/beagle/base/common/util/BeanUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..6a1d179fb4c36f958852a82e94a4d90c5a70df1a --- /dev/null +++ b/src/main/java/com/beagle/base/common/util/BeanUtil.java @@ -0,0 +1,153 @@ +package com.beagle.base.common.util; + +import com.beagle.base.common.contant.CodeEnum; +import com.beagle.base.common.exception.BeagleException; +import org.apache.commons.lang3.StringUtils; +import org.springframework.beans.BeansException; +import org.springframework.util.CollectionUtils; + +import java.beans.PropertyDescriptor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.*; + +/** + * @author SmileCircle + */ +public final class BeanUtil extends org.springframework.beans.BeanUtils { + private BeanUtil() { + } + + public interface Callback { + + /** + * 回调方法 + * + * @param source + * @param targetClass + * @return + */ + void doCallback(T source, R targetClass); + + } + + public static R convert(T source, Class targetClass, Callback + callback, String... ignoreProperties) { + if (source == null) { + return null; + } else { + R target = null; + + try { + target = targetClass.newInstance(); + } catch (IllegalAccessException | InstantiationException var4) { + throw new BeagleException(CodeEnum.UNKNOWN); + } + + copyProperties(source, target, ignoreProperties); + + if (callback != null) { + callback.doCallback(source, target); + } + + return target; + } + } + + public static R convert(T source, Class targetClass, Callback callback) { + return convert(source, targetClass, callback, (String[]) null); + } + + public static R convert(T source, Class targetClass, String... ignoreProperties) { + return convert(source, targetClass, null, ignoreProperties); + } + + public static R convert(T source, Class targetClass) { + return convert(source, targetClass, null, (String[]) null); + } + + public static List convertList(Collection collection, Class targetType, Callback callback, String... ignoreProperties) { + if (CollectionUtils.isEmpty(collection)) { + return new ArrayList<>(); + } else { + List newList = new ArrayList(collection.size()); + collection.forEach(item -> newList.add(convert(item, targetType, callback, ignoreProperties))); + return newList; + } + } + + public static List convertList(Collection collection, Class targetType, String... ignoreProperties) { + return convertList(collection, targetType, null, ignoreProperties); + } + + public static List convertList(Collection collection, Class targetType, Callback callback) { + return convertList(collection, targetType, callback, (String[]) null); + } + + public static List convertList(Collection collection, Class targetType) { + return convertList(collection, targetType, null, (String[]) null); + } + + + public static Set convertSet(Collection collection, Class targetType, Callback callback, String... ignoreProperties) { + if (CollectionUtils.isEmpty(collection)) { + return new HashSet<>(); + } else { + Set newSet = new HashSet(collection.size()); + collection.forEach(item -> newSet.add(convert(item, targetType, callback, ignoreProperties))); + return newSet; + } + } + + public static Set convertSet(Collection collection, Class targetType, String... ignoreProperties) { + return convertSet(collection, targetType, null, ignoreProperties); + } + + public static Set convertSet(Collection collection, Class targetType, Callback callback) { + return convertSet(collection, targetType, callback, (String[]) null); + } + + public static Set convertSet(Collection collection, Class targetType) { + return convertSet(collection, targetType, null, (String[]) null); + } + + public static void copyPropertiesIgnoreEmpty(Object source, Object target) throws BeansException { + PropertyDescriptor[] propertyDescriptors = getPropertyDescriptors(source.getClass()); + List ignoreProperties = new ArrayList<>(); + for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { + Method readMethod = propertyDescriptor.getReadMethod(); + try { + Object value = readMethod.invoke(source); + String propertiesName = null; + if(value instanceof Collection) { + if(CollectionUtils.isEmpty((Collection) value)) { + propertiesName = readMethod.getName(); + } + } else if (value instanceof String) { + if (StringUtils.isEmpty((CharSequence) value)) { + propertiesName = readMethod.getName(); + } + } else { + if (Objects.isNull(value)) { + propertiesName = readMethod.getName(); + } + } + if(StringUtils.isNotEmpty(propertiesName)) { + if(StringUtils.startsWith(propertiesName, "get")) { + propertiesName = propertiesName.substring(3); + } else if (StringUtils.startsWith(propertiesName, "is")) { + propertiesName = propertiesName.substring(2); + } + String firstName = propertiesName.substring(0, 1); + String otherName = propertiesName.substring(1); + propertiesName = firstName.toLowerCase(Locale.ROOT) + otherName; + ignoreProperties.add(propertiesName); + } + } catch (IllegalAccessException | InvocationTargetException e) { + throw new BeagleException(CodeEnum.UNKNOWN); + } + } + copyProperties(source, target, ignoreProperties.toArray(new String[0])); + } +} + diff --git a/src/main/java/com/beagle/base/common/util/CommonUtil.java b/src/main/java/com/beagle/base/common/util/CommonUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..2acc6357eaa927b33b307fbf0914567721fd2bbc --- /dev/null +++ b/src/main/java/com/beagle/base/common/util/CommonUtil.java @@ -0,0 +1,45 @@ +package com.beagle.base.common.util; + +import cn.hutool.core.text.CharSequenceUtil; +import com.rtdb.service.impl.*; +import com.rtdb.service.inter.Base; +import com.rtdb.service.inter.Historian; +import com.rtdb.service.inter.Snapshot; + +public class CommonUtil { + private static final String IP = CharSequenceUtil.blankToDefault(System.getenv("GOLDEN_IP"), "10.253.1.97"); + private static final Integer PORT = Integer.parseInt(CharSequenceUtil.blankToDefault(System.getenv("GOLDEN_PORT"), "6327")); + private static final String USER = CharSequenceUtil.blankToDefault(System.getenv("GOLDEN_USER"), "sa"); + private static final String PASSWORD = CharSequenceUtil.blankToDefault(System.getenv("GOLDEN_PASSWORD"), "golden") ; + private static Historian his; + private static Base base; + private static Snapshot snap; + + private static ServerImpl server; + + private static ServerImplPool pool; + + static { + try { + pool = new ServerImplPool(IP, PORT, USER, PASSWORD, 5, 10); + server = pool.getServerImpl(); + his = new HistorianImpl(server); + base = new BaseImpl(server); + snap = new SnapshotImpl(server); + }catch (Exception e) { + e.printStackTrace(); + } + } + + public static Historian getHisImpl() { + return his; + } + + public static Base getBaseImpl() { + return base; + } + + public static Snapshot getSnapshotImpl() { + return snap; + } +} diff --git a/src/main/java/com/beagle/base/common/util/HistorianUtil.java b/src/main/java/com/beagle/base/common/util/HistorianUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..019d940e63e2fb73da819ae03d2e33e822497b85 --- /dev/null +++ b/src/main/java/com/beagle/base/common/util/HistorianUtil.java @@ -0,0 +1,71 @@ +package com.beagle.base.common.util; + +import cn.hutool.core.collection.CollUtil; +import com.beagle.base.bean.vo.HistorianDoubleArchivedValuesParam; +import com.beagle.base.bean.vo.HistorianFloatArchivedValuesFiltParam; +import com.beagle.base.bean.vo.HistorianFloatInterpoValuesParam; +import com.beagle.base.bean.vo.HistorianFloatIntervalValuesParam; +import com.rtdb.model.DoubleData; + +import java.util.ArrayList; +import java.util.List; + +public class HistorianUtil { + + public static List getFloatIntervalValues(HistorianFloatIntervalValuesParam param ) { + List res; + try { + res = CommonUtil.getHisImpl().getFloatIntervalValues(param.getId(), param.getInterval(), param.getCount(), param.getDateTime()); + if (CollUtil.isNotEmpty(res)) { + return res; + } + return new ArrayList<>(); + }catch (Exception e) { + e.printStackTrace(); + return new ArrayList<>(); + } + } + + + public static List getFloatInterpoValues(HistorianFloatInterpoValuesParam param) { + List res; + try { + res = CommonUtil.getHisImpl().getFloatInterpoValues(param.getId(), param.getCount(), param.getStartTime(), param.getEndTime()); + if (CollUtil.isNotEmpty(res)) { + return res; + } + return new ArrayList<>(); + }catch (Exception e) { + e.printStackTrace(); + return new ArrayList<>(); + } + } + + public static List getFloatArchivedValuesFilt(HistorianFloatArchivedValuesFiltParam param) { + List res; + try { + res = CommonUtil.getHisImpl().getFloatArchivedValuesFilt(param.getId(), param.getFilter(), param.getCount(), param.getStartTime(), param.getEndTime()); + if (CollUtil.isNotEmpty(res)) { + return res; + } + return new ArrayList<>(); + }catch (Exception e) { + e.printStackTrace(); + return new ArrayList<>(); + } + } + + public static List getDoubleArchivedValues(HistorianDoubleArchivedValuesParam param) { + List res; + try { + res = CommonUtil.getHisImpl().getDoubleArchivedValues(param.getId(), param.getCount(), param.getStartTime(), param.getEndTime()); + if (CollUtil.isNotEmpty(res)) { + return res; + } + return new ArrayList<>(); + }catch (Exception e) { + e.printStackTrace(); + return new ArrayList<>(); + } + } +} diff --git a/src/main/java/com/beagle/base/common/util/ResponseUtil.java b/src/main/java/com/beagle/base/common/util/ResponseUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..1afe6995c85ffcd9d17f021754eec564cd60bf47 --- /dev/null +++ b/src/main/java/com/beagle/base/common/util/ResponseUtil.java @@ -0,0 +1,46 @@ +package com.beagle.base.common.util; + +import java.io.IOException; +import java.io.PrintWriter; +import java.util.HashMap; +import java.util.Map; + +import javax.servlet.http.HttpServletResponse; + +import com.alibaba.fastjson2.JSONObject; +import com.beagle.base.common.contant.CodeEnum; + +import lombok.extern.slf4j.Slf4j; + +/** + * @author wuwanli + */ +@Slf4j +public class ResponseUtil { + + /** + * 封装返回报文 + * + * @param response + * 返回对象 + */ + public static void returnBaseResponse(HttpServletResponse response, CodeEnum codeEnum) { + PrintWriter writer = null; + try { + Map baseResponse = new HashMap<>(10); + baseResponse.put("code", codeEnum.getCode()); + baseResponse.put("desc", codeEnum.getDesc()); + + response.setCharacterEncoding("UTF-8"); + response.setContentType("application/json; charset=utf-8"); + writer = response.getWriter(); + writer.print(JSONObject.toJSONString(baseResponse)); + } catch (IOException ex) { + log.error("returnBaseResponse Fail：", ex); + } finally { + if (writer != null) { + writer.close(); + } + } + } +} diff --git a/src/main/java/com/beagle/base/common/util/SnapshotUtil.java b/src/main/java/com/beagle/base/common/util/SnapshotUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..aca65567fe01cb54d08e0ff10cdde6c12a982711 --- /dev/null +++ b/src/main/java/com/beagle/base/common/util/SnapshotUtil.java @@ -0,0 +1,70 @@ +package com.beagle.base.common.util; + +import cn.hutool.core.collection.CollUtil; +import com.beagle.base.bean.vo.SnapshotBlobParam; +import com.beagle.base.bean.vo.SnapshotCoorParam; +import com.beagle.base.bean.vo.SnapshotDoubleParam; +import com.beagle.base.bean.vo.SnapshotIntParam; +import com.rtdb.model.*; + +import java.util.ArrayList; +import java.util.List; + +public class SnapshotUtil { + + public static List getDoubleSnapshots(SnapshotDoubleParam param) { + List res = new ArrayList<>(); + try { + Entity d = CommonUtil.getSnapshotImpl().getDoubleSnapshots(param.getIds()); + if (d != null && CollUtil.isNotEmpty(d.getList())) { + res = d.getList(); + } + return res; + }catch (Exception e) { + e.printStackTrace(); + return res; + } + } + + public static List getIntSnapshots(SnapshotIntParam param) { + List res = new ArrayList<>(); + try { + Entity intSnapshots = CommonUtil.getSnapshotImpl().getIntSnapshots(param.getIds()); + if (intSnapshots != null && CollUtil.isNotEmpty(intSnapshots.getList())) { + res = intSnapshots.getList(); + } + return res; + }catch (Exception e) { + e.printStackTrace(); + return res; + } + } + + public static List getBlobSnapshots(SnapshotBlobParam param) { + List res = new ArrayList<>(); + try { + Entity blobSnapshots = CommonUtil.getSnapshotImpl().getBlobSnapshots(param.getIds()); + if (blobSnapshots != null && CollUtil.isNotEmpty(blobSnapshots.getList())) { + res = blobSnapshots.getList(); + } + return res; + }catch (Exception e) { + e.printStackTrace(); + return res; + } + } + + public static List getCoorSnapshots(SnapshotCoorParam param) { + List res = new ArrayList<>(); + try { + Entity coorSnapshots = CommonUtil.getSnapshotImpl().getCoorSnapshots(param.getIds()); + if (coorSnapshots != null && CollUtil.isNotEmpty(coorSnapshots.getList())) { + res = coorSnapshots.getList(); + } + return res; + }catch (Exception e) { + e.printStackTrace(); + return res; + } + } +} diff --git a/src/main/java/com/beagle/base/common/util/StringUtils.java b/src/main/java/com/beagle/base/common/util/StringUtils.java new file mode 100644 index 0000000000000000000000000000000000000000..1f688c9c3d9655376ec21763cdc4a523518b8538 --- /dev/null +++ b/src/main/java/com/beagle/base/common/util/StringUtils.java @@ -0,0 +1,44 @@ +package com.beagle.base.common.util; + +import java.util.Iterator; +import java.util.Map; + +/** + * @author wuwanli + */ +public class StringUtils { + public static String strip(String str) { + return org.apache.commons.lang3.StringUtils.strip(str); + } + + public static String trim(String str) { + return org.apache.commons.lang3.StringUtils.trim(str); + } + + public static boolean isNotBlank(CharSequence cs) { + return org.apache.commons.lang3.StringUtils.isNotBlank(cs); + } + + public static boolean isBlank(CharSequence cs) { + return org.apache.commons.lang3.StringUtils.isBlank(cs); + } + + public static String getRestUrlByMap(String url, Map paramMap){ + StringBuffer stringBuffer = new StringBuffer(url); + Iterator iterator = paramMap.entrySet().iterator(); + if (iterator.hasNext()) { + stringBuffer.append("?"); + Object element; + while (iterator.hasNext()) { + element = iterator.next(); + Map.Entry entry = (Map.Entry) element; + //过滤value为null，value为null时进行拼接字符串会变成 "null"字符串 + if (entry.getValue() != null) { + stringBuffer.append(element).append("&"); + } + url = stringBuffer.substring(0, stringBuffer.length() - 1); + } + } + return url; + } +} diff --git a/src/main/java/com/beagle/base/controller/BaseController.java b/src/main/java/com/beagle/base/controller/BaseController.java new file mode 100644 index 0000000000000000000000000000000000000000..36661e04e71bad470a1b62a2461c4cea4ff8667f --- /dev/null +++ b/src/main/java/com/beagle/base/controller/BaseController.java @@ -0,0 +1,67 @@ +package com.beagle.base.controller; + +import com.beagle.base.BasePointsPropertiesNewParam; +import com.beagle.base.bean.vo.BasePointsPropertiesParam; +import com.beagle.base.bean.vo.BaseSearchParam; +import com.beagle.base.bean.vo.BaseSearchPointCountParam; +import com.beagle.base.bean.vo.BaseTableTagNamesParam; +import com.beagle.base.bean.vo.resp.Response; +import com.beagle.base.service.BaseService; +import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport; +import com.rtdb.model.FullPoint; +import com.rtdb.model.MinPoint; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.Resource; +import java.util.List; + +/** + * 数据库字段加密、防篡改接口 + * + * @author lzz + */ +@Api(tags = "基本信息点服务实现类") +@RestController +@RequestMapping("/v1/base") +public class BaseController { + @Resource + private BaseService baseService; + + @ApiOperationSupport(order = 1) + @ApiOperation(value = "在表中搜索符合条件的标签点，使用标签点名时支持通配符") + @PostMapping("/search") + public Response search(@RequestBody @ApiParam(value = "入参") @Validated BaseSearchParam param) { + return new Response<>(baseService.search(param)); + } + + @ApiOperationSupport(order = 2) + @ApiOperation(value = "根据ids批量获取标签点属性") + @PostMapping("/getPointsProperties") + public Response> getPointsProperties(@RequestBody @ApiParam(value = "入参") @Validated BasePointsPropertiesParam param) { + return new Response<>(baseService.getPointsProperties(param)); + } + + @ApiOperationSupport(order = 3) + @ApiOperation(value = "根据ids批量获取标签点属性") + @PostMapping("/searchPointCount") + public Response searchPointCount(@RequestBody @ApiParam(value = "入参") @Validated BaseSearchPointCountParam param) { + return new Response<>(baseService.searchPointCount(param)); + } + @ApiOperationSupport(order = 4) + @ApiOperation(value = "根据标签点ids获取测点全名称") + @PostMapping("/getTableTagNames") + public Response getTableTagNames(@RequestBody @ApiParam(value = "入参") @Validated BaseTableTagNamesParam param) { + return new Response<>(baseService.getTableTagNames(param)); + } + + @ApiOperationSupport(order = 5) + @ApiOperation(value = "根据标签点ids获取测点全名称") + @PostMapping("/getPointsProperties/tags") + public Response> getPointsPropertiesTags(@RequestBody @ApiParam(value = "入参") @Validated BasePointsPropertiesNewParam param) { + return new Response<>(baseService.getPointsPropertiesTags(param)); + } +} diff --git a/src/main/java/com/beagle/base/controller/HistorianController.java b/src/main/java/com/beagle/base/controller/HistorianController.java new file mode 100644 index 0000000000000000000000000000000000000000..85a2505188da4b1555d6292b69ec9729488ba015 --- /dev/null +++ b/src/main/java/com/beagle/base/controller/HistorianController.java @@ -0,0 +1,62 @@ +package com.beagle.base.controller; + +import com.beagle.base.bean.vo.HistorianDoubleArchivedValuesParam; +import com.beagle.base.bean.vo.HistorianFloatArchivedValuesFiltParam; +import com.beagle.base.bean.vo.HistorianFloatInterpoValuesParam; +import com.beagle.base.bean.vo.HistorianFloatIntervalValuesParam; +import com.beagle.base.bean.vo.resp.Response; +import com.beagle.base.service.HistorianService; +import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport; +import com.rtdb.model.DoubleData; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.Nonnull; +import javax.annotation.Resource; +import javax.validation.constraints.NotBlank; +import java.util.List; +import java.util.Map; + +/** + * 数据库字段加密、防篡改接口 + * + * @author lzz + */ +@Api(tags = "历史服务接口实现类") +@RestController +@RequestMapping("/v1/historian") +public class HistorianController { + @Resource + private HistorianService historianService; + + @ApiOperationSupport(order = 1) + @ApiOperation(value = "读取单个标签点某个时刻之后一定数量的等间隔内插值替换的历史数值") + @PostMapping("/getFloatIntervalValues") + public Response> getFloatIntervalValues(@RequestBody @ApiParam(value = "入参") @Validated HistorianFloatIntervalValuesParam param) { + return new Response<>(historianService.getFloatIntervalValues(param)); + } + + @ApiOperationSupport(order = 2) + @ApiOperation(value = "获取单个浮点类型标签点一段时间内等间隔历史插值") + @PostMapping("/getFloatInterpoValues") + public Response> getFloatInterpoValues(@RequestBody @ApiParam(value = "入参") @Validated HistorianFloatInterpoValuesParam param) { + return new Response<>(historianService.getFloatInterpoValues(param)); + } + + @ApiOperationSupport(order = 3) + @ApiOperation(value = "读取单个浮点类型标签点在一段时间内经复杂条件筛选后的历史储存值") + @PostMapping("/getFloatArchivedValuesFilt") + public Response> getFloatArchivedValuesFilt(@RequestBody @ApiParam(value = "入参") @Validated HistorianFloatArchivedValuesFiltParam param) { + return new Response<>(historianService.getFloatArchivedValuesFilt(param)); + } + + @ApiOperationSupport(order = 4) + @ApiOperation(value = "读取单个浮点类型标签点一段时间内的储存数据") + @PostMapping("/getDoubleArchivedValues") + public Response> getDoubleArchivedValues(@RequestBody @ApiParam(value = "入参") @Validated HistorianDoubleArchivedValuesParam param) { + return new Response<>(historianService.getDoubleArchivedValues(param)); + } +} diff --git a/src/main/java/com/beagle/base/controller/IndexController.java b/src/main/java/com/beagle/base/controller/IndexController.java new file mode 100644 index 0000000000000000000000000000000000000000..475f3208c846a4629268001311367864ff9c88cb --- /dev/null +++ b/src/main/java/com/beagle/base/controller/IndexController.java @@ -0,0 +1,20 @@ +package com.beagle.base.controller; + +import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@Api(tags = "服务心跳探针接口") +@RequestMapping("/index") +public class IndexController { + @GetMapping("/index") + @ApiOperationSupport(order = 1) + @ApiOperation(value = "服务心跳探针接口") + public String index() { + return "ok"; + } +} diff --git a/src/main/java/com/beagle/base/controller/SnapshotController.java b/src/main/java/com/beagle/base/controller/SnapshotController.java new file mode 100644 index 0000000000000000000000000000000000000000..b57e0dc78e1a863959c6cbc7b5e8fdd74e7f4f6d --- /dev/null +++ b/src/main/java/com/beagle/base/controller/SnapshotController.java @@ -0,0 +1,60 @@ +package com.beagle.base.controller; + +import com.beagle.base.bean.vo.*; +import com.beagle.base.bean.vo.resp.Response; +import com.beagle.base.service.SnapshotService; +import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport; +import com.rtdb.model.BlobData; +import com.rtdb.model.CoorData; +import com.rtdb.model.DoubleData; +import com.rtdb.model.IntData; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.Resource; +import java.util.List; + +/** + * 数据库字段加密、防篡改接口 + * + * @author lzz + */ +@Api(tags = "快照服务接口方法实现") +@RestController +@RequestMapping("/v1/snapshot") +public class SnapshotController { + @Resource + private SnapshotService snapshotService; + + @ApiOperationSupport(order = 1) + @ApiOperation(value = "批量获取标签点类型为双精度浮点型的快照值(纳秒标签点)") + @PostMapping("/getDoubleSnapshots") + public Response> getDoubleSnapshots(@RequestBody @ApiParam(value = "入参") @Validated SnapshotDoubleParam param) { + return new Response<>(snapshotService.getDoubleSnapshots(param)); + } + + @ApiOperationSupport(order = 2) + @ApiOperation(value = "批量读取开关量、模拟量快照数值") + @PostMapping("/getIntSnapshots") + public Response> getIntSnapshots(@RequestBody @ApiParam(value = "入参") @Validated SnapshotIntParam param) { + return new Response<>(snapshotService.getIntSnapshots(param)); + } + + @ApiOperationSupport(order = 3) + @ApiOperation(value = "批量获取标签点类型为Blob/String型的快照值") + @PostMapping("/getBlobSnapshots") + public Response> getBlobSnapshots(@RequestBody @ApiParam(value = "入参") @Validated SnapshotBlobParam param) { + return new Response<>(snapshotService.getBlobSnapshots(param)); + } + + @ApiOperationSupport(order = 4) + @ApiOperation(value = "批量获取标签点类型为坐标类型的快照值") + @PostMapping("/getCoorSnapshots") + public Response> getCoorSnapshots(@RequestBody @ApiParam(value = "入参") @Validated SnapshotCoorParam param) { + return new Response<>(snapshotService.getCoorSnapshots(param)); + } + +} diff --git a/src/main/java/com/beagle/base/service/BaseService.java b/src/main/java/com/beagle/base/service/BaseService.java new file mode 100644 index 0000000000000000000000000000000000000000..3c6716613eb645055bd4396881ef1cb3753c0c59 --- /dev/null +++ b/src/main/java/com/beagle/base/service/BaseService.java @@ -0,0 +1,27 @@ +package com.beagle.base.service; + +import com.beagle.base.BasePointsPropertiesNewParam; +import com.beagle.base.bean.vo.BasePointsPropertiesParam; +import com.beagle.base.bean.vo.BaseSearchParam; +import com.beagle.base.bean.vo.BaseSearchPointCountParam; +import com.beagle.base.bean.vo.BaseTableTagNamesParam; +import com.rtdb.model.FullPoint; +import com.rtdb.model.MinPoint; + +import java.util.List; + +/** + * @author lzz + */ +public interface BaseService { + + int[] search(BaseSearchParam param); + + List getPointsProperties(BasePointsPropertiesParam param); + + Integer searchPointCount(BaseSearchPointCountParam param); + + String[] getTableTagNames(BaseTableTagNamesParam param); + + List getPointsPropertiesTags(BasePointsPropertiesNewParam param); +} diff --git a/src/main/java/com/beagle/base/service/HistorianService.java b/src/main/java/com/beagle/base/service/HistorianService.java new file mode 100644 index 0000000000000000000000000000000000000000..fc59a4ff96d005060c01be639131d64972c22f6f --- /dev/null +++ b/src/main/java/com/beagle/base/service/HistorianService.java @@ -0,0 +1,25 @@ +package com.beagle.base.service; + +import com.beagle.base.bean.vo.HistorianDoubleArchivedValuesParam; +import com.beagle.base.bean.vo.HistorianFloatArchivedValuesFiltParam; +import com.beagle.base.bean.vo.HistorianFloatInterpoValuesParam; +import com.beagle.base.bean.vo.HistorianFloatIntervalValuesParam; +import com.rtdb.model.DoubleData; + +import java.util.List; +import java.util.Map; + +/** + * @author lzz + */ +public interface HistorianService { + + + List getFloatIntervalValues(HistorianFloatIntervalValuesParam param); + + List getFloatInterpoValues(HistorianFloatInterpoValuesParam param); + + List getFloatArchivedValuesFilt(HistorianFloatArchivedValuesFiltParam param); + + List getDoubleArchivedValues(HistorianDoubleArchivedValuesParam param); +} diff --git a/src/main/java/com/beagle/base/service/SnapshotService.java b/src/main/java/com/beagle/base/service/SnapshotService.java new file mode 100644 index 0000000000000000000000000000000000000000..5fbcb997a0a22a9cc0b189edc39d2b6e46b490d2 --- /dev/null +++ b/src/main/java/com/beagle/base/service/SnapshotService.java @@ -0,0 +1,26 @@ +package com.beagle.base.service; + +import com.beagle.base.bean.vo.SnapshotBlobParam; +import com.beagle.base.bean.vo.SnapshotCoorParam; +import com.beagle.base.bean.vo.SnapshotDoubleParam; +import com.beagle.base.bean.vo.SnapshotIntParam; +import com.rtdb.model.BlobData; +import com.rtdb.model.CoorData; +import com.rtdb.model.DoubleData; +import com.rtdb.model.IntData; + +import java.util.List; + +/** + * @author lzz + */ +public interface SnapshotService { + + List getDoubleSnapshots(SnapshotDoubleParam param); + + List getIntSnapshots(SnapshotIntParam param); + + List getBlobSnapshots(SnapshotBlobParam param); + + List getCoorSnapshots(SnapshotCoorParam param); +} diff --git a/src/main/java/com/beagle/base/service/impl/BaseServiceImpl.java b/src/main/java/com/beagle/base/service/impl/BaseServiceImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..afeae0b9e9e0659c2ee0c2d7fce4ba43a62ad8d5 --- /dev/null +++ b/src/main/java/com/beagle/base/service/impl/BaseServiceImpl.java @@ -0,0 +1,50 @@ +package com.beagle.base.service.impl; + + +import com.beagle.base.BasePointsPropertiesNewParam; +import com.beagle.base.bean.vo.BasePointsPropertiesParam; +import com.beagle.base.bean.vo.BaseSearchParam; +import com.beagle.base.bean.vo.BaseSearchPointCountParam; +import com.beagle.base.bean.vo.BaseTableTagNamesParam; +import com.beagle.base.common.util.BaseUtil; +import com.beagle.base.service.BaseService; +import com.rtdb.model.FullPoint; +import com.rtdb.model.MinPoint; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; + +import java.util.List; + + +/** + * @author lzz + */ +@Service +@Slf4j +public class BaseServiceImpl implements BaseService { + + @Override + public int[] search(BaseSearchParam param) { + return BaseUtil.search(param); + } + + @Override + public List getPointsProperties(BasePointsPropertiesParam param) { + return BaseUtil.getPointsProperties(param); + } + + @Override + public Integer searchPointCount(BaseSearchPointCountParam param) { + return BaseUtil.searchPointCount(param); + } + + @Override + public String[] getTableTagNames(BaseTableTagNamesParam param) { + return BaseUtil.getTableTagNames(param); + } + + @Override + public List getPointsPropertiesTags(BasePointsPropertiesNewParam param) { + return BaseUtil.getPointsPropertiesTags(param); + } +} diff --git a/src/main/java/com/beagle/base/service/impl/HistorianServiceImpl.java b/src/main/java/com/beagle/base/service/impl/HistorianServiceImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..16253bddbd931c7623f34edea97a6a90e3724112 --- /dev/null +++ b/src/main/java/com/beagle/base/service/impl/HistorianServiceImpl.java @@ -0,0 +1,42 @@ +package com.beagle.base.service.impl; + + +import com.beagle.base.bean.vo.HistorianDoubleArchivedValuesParam; +import com.beagle.base.bean.vo.HistorianFloatArchivedValuesFiltParam; +import com.beagle.base.bean.vo.HistorianFloatInterpoValuesParam; +import com.beagle.base.bean.vo.HistorianFloatIntervalValuesParam; +import com.beagle.base.common.util.HistorianUtil; +import com.beagle.base.service.HistorianService; +import com.rtdb.model.DoubleData; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; + +import java.util.*; + +/** + * @author lzz + */ +@Service +@Slf4j +public class HistorianServiceImpl implements HistorianService { + + @Override + public List getFloatIntervalValues(HistorianFloatIntervalValuesParam param) { + return HistorianUtil.getFloatIntervalValues(param); + } + + @Override + public List getFloatInterpoValues(HistorianFloatInterpoValuesParam param) { + return HistorianUtil.getFloatInterpoValues(param); + } + + @Override + public List getFloatArchivedValuesFilt(HistorianFloatArchivedValuesFiltParam param) { + return HistorianUtil.getFloatArchivedValuesFilt(param); + } + + @Override + public List getDoubleArchivedValues(HistorianDoubleArchivedValuesParam param) { + return HistorianUtil.getDoubleArchivedValues(param); + } +} diff --git a/src/main/java/com/beagle/base/service/impl/SnapshotServiceImpl.java b/src/main/java/com/beagle/base/service/impl/SnapshotServiceImpl.java new file mode 100644 index 0000000000000000000000000000000000000000..30219f90f4119493bdf1b29ef3bc5cbc78ee8f75 --- /dev/null +++ b/src/main/java/com/beagle/base/service/impl/SnapshotServiceImpl.java @@ -0,0 +1,46 @@ +package com.beagle.base.service.impl; + + +import com.beagle.base.bean.vo.SnapshotBlobParam; +import com.beagle.base.bean.vo.SnapshotCoorParam; +import com.beagle.base.bean.vo.SnapshotDoubleParam; +import com.beagle.base.bean.vo.SnapshotIntParam; +import com.beagle.base.common.util.SnapshotUtil; +import com.beagle.base.service.SnapshotService; +import com.rtdb.model.BlobData; +import com.rtdb.model.CoorData; +import com.rtdb.model.DoubleData; +import com.rtdb.model.IntData; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; + +import java.util.List; + +/** + * @author lzz + */ +@Service +@Slf4j +public class SnapshotServiceImpl implements SnapshotService { + + @Override + public List getDoubleSnapshots(SnapshotDoubleParam param) { + return SnapshotUtil.getDoubleSnapshots(param); + } + + @Override + public List getIntSnapshots(SnapshotIntParam param) { + return SnapshotUtil.getIntSnapshots(param); + } + + @Override + public List getBlobSnapshots(SnapshotBlobParam param) { + return SnapshotUtil.getBlobSnapshots(param); + } + + @Override + public List getCoorSnapshots(SnapshotCoorParam param) { + return SnapshotUtil.getCoorSnapshots(param); + + } +} diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e902254a9d80e84416a73ce0fdfbfaf39f4beb69 --- /dev/null +++ b/src/main/resources/application.yaml @@ -0,0 +1,29 @@ +server: + port: 8080 + servlet: + context-path: ${DATA_COMPUTING_ROUTE_PREFIX:/sdk/golden/api} +spring: + servlet: + multipart: + max-request-size: 5MB + max-file-size: 5MB + # max-file-size 用于限制单个文件的最大上传大小，而 max-request-size 用于限制整个请求体的大小，包括所有文件和其他表单字段的大小。 + mvc: + pathmatch: + #Springfox 使用的路径匹配是基于AntPathMatcher的，而Spring Boot 2.6.X使用的是PathPatternMatcher + matching-strategy: ant_path_matcher + +logging: + config: classpath:log4j2.xml + +# 接口文档配置 +knife4j: + enable: true + basic: + enable: true + username: admin + password: Aa123456 + + + + diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml new file mode 100644 index 0000000000000000000000000000000000000000..21719eb941014d79566b92e2eef6b607bcb759df --- /dev/null +++ b/src/main/resources/log4j2.xml @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/main/test/Test.java b/src/main/test/Test.java new file mode 100644 index 0000000000000000000000000000000000000000..653ffe08e8465688e14b809a3e0f7b764b21908d --- /dev/null +++ b/src/main/test/Test.java @@ -0,0 +1,108 @@ +import com.alibaba.fastjson2.JSON; +import com.beagle.base.BasePointsPropertiesNewParam; +import com.beagle.base.bean.vo.BaseSearchPointCountParam; +import com.beagle.base.bean.vo.resp.Response; +import com.rtdb.api.enums.SearchMask; +import com.rtdb.enums.DataSort; +import com.rtdb.enums.Quality; +import com.rtdb.enums.TagType; +import com.rtdb.enums.ValueType; +import com.rtdb.model.*; + +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.List; + +public class Test { + public static void main(String[] args) { + testMinPoint(); + } + private static void testDoubleData() { + List list = new ArrayList<>(); + DoubleData doubleData = new DoubleData(); + doubleData.setId(1); + doubleData.setError(11); + doubleData.setNanosecond(1111111); + doubleData.setQuality(Short.parseShort("1")); + doubleData.setValue(Double.parseDouble("12.3")); + doubleData.setDateTime(Calendar.getInstance().getTime()); + list.add(doubleData); + System.out.println(JSON.toJSONString(new Response<>(list))); + } + + private static void testBlobData() { + List list = new ArrayList<>(); + BlobData doubleData = new BlobData(); + doubleData.setId(1); + doubleData.setError(11); + doubleData.setNanosecond(1111111); + doubleData.setQuality(Quality.BAD); + doubleData.setBlob("测试".getBytes(StandardCharsets.UTF_8)); + doubleData.setDatetime(Calendar.getInstance().getTime()); + doubleData.setLen(1); + list.add(doubleData); + System.out.println(JSON.toJSONString(new Response<>(list))); + } + + private static void testCoorData() { + List list = new ArrayList<>(); + CoorData doubleData = new CoorData(); + doubleData.setId(1); + doubleData.setError(11); + doubleData.setNanosecond(1111111); + doubleData.setQuality(Short.parseShort("1")); + doubleData.setX(Float.parseFloat("1.2")); + doubleData.setY(Float.parseFloat("1.4")); + doubleData.setDateTime(Calendar.getInstance().getTime()); + list.add(doubleData); + System.out.println(JSON.toJSONString(new Response<>(list))); + } + + private static void testBaseSearchPointCountParam() { + SearchConditionTotal searchConditionTotal = new SearchConditionTotal(); + searchConditionTotal.set_SearchCondition(SearchMask.SEARCH_ARCHIVE); + searchConditionTotal.set_TimeAccuracy(1); + searchConditionTotal.set_PointType(PointType.ALARM); + searchConditionTotal.setSearchMaskValue("test"); + searchConditionTotal.set_ValueTypeString("test"); + BaseSearchPointCountParam baseSearchPointCountParam = new BaseSearchPointCountParam(); + baseSearchPointCountParam.setCondition(searchConditionTotal); + baseSearchPointCountParam.setSort(DataSort.SORT_BY_ID); + System.out.println(JSON.toJSONString(baseSearchPointCountParam)); + } + + + private static void testSearchPointCount() { + + System.out.println(JSON.toJSONString(new Response<>(1))); + } + + private static void testGetTableTagNames() { + String[] tag = {"1"}; + System.out.println(JSON.toJSONString(new Response<>(tag))); + } + + private static void testGetPointsProperties_tags() { + String[] tag = {"1"}; + BasePointsPropertiesNewParam basePointsPropertiesNewParam = new BasePointsPropertiesNewParam(); + basePointsPropertiesNewParam.setTagName(tag); + + System.out.println(JSON.toJSONString(basePointsPropertiesNewParam)); + } + + public static void testMinPoint() { + List list = new ArrayList<>(); + MinPoint minPoint = new MinPoint(); + minPoint.setId(1); + minPoint.setDesc("desc"); + minPoint.setTagName("tag name"); + minPoint.setTableId(1); + minPoint.setTagType(TagType.ALARM); + minPoint.setValueType(ValueType.RTDB_BLOB); + minPoint.setUseMs(1); + + list.add(minPoint); + System.out.println(JSON.toJSONString(new Response<>(list))); + } +}