diff --git a/virtual-patient-graph/pom.xml b/virtual-patient-graph/pom.xml index c83ff2c7..d87cf2c2 100644 --- a/virtual-patient-graph/pom.xml +++ b/virtual-patient-graph/pom.xml @@ -36,6 +36,42 @@ spring-boot-starter-data-neo4j + + com.github.pagehelper + pagehelper-spring-boot-starter + 1.4.2 + + + org.mybatis + mybatis + + + org.mybatis + mybatis-spring + + + + + + org.springframework.boot + spring-boot-configuration-processor + + + + com.vesoft + client + 3.0.0 + + + + com.fasterxml.jackson.core + jackson-databind + + + com.fasterxml + classmate + + org.projectlombok diff --git a/virtual-patient-graph/src/main/java/com/supervision/VirtualPatientGraphApplication.java b/virtual-patient-graph/src/main/java/com/supervision/VirtualPatientGraphApplication.java index 8437e948..12dadb1b 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/VirtualPatientGraphApplication.java +++ b/virtual-patient-graph/src/main/java/com/supervision/VirtualPatientGraphApplication.java @@ -6,6 +6,7 @@ import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories; import org.springframework.scheduling.annotation.EnableScheduling; +@EnableScheduling @SpringBootApplication @MapperScan(basePackages = {"com.supervision.**.mapper"}) @EnableNeo4jRepositories("com.**.repo") diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/config/NebulaGraphProperties.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/config/NebulaGraphProperties.java new file mode 100644 index 00000000..01bd6de0 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/config/NebulaGraphProperties.java @@ -0,0 +1,35 @@ +package com.supervision.nebula.config; + +import lombok.Data; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.context.annotation.Configuration; + +import java.util.List; + +/** + * @author fulin + */ +@Configuration +@ConfigurationProperties(prefix = "nebula") +@EnableConfigurationProperties(NebulaGraphProperties.class) +@Data +public class NebulaGraphProperties { + + private String userName; + + private String password; + /** + * 格式：ip:prot + */ + private List hostAddresses; + + private int minConnSize; + + private int maxConnSize; + + private int timeout; + + private int idleTime; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/config/NebulaSession.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/config/NebulaSession.java new file mode 100644 index 00000000..e82544d1 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/config/NebulaSession.java @@ -0,0 +1,28 @@ +package com.supervision.nebula.config; + +import com.vesoft.nebula.client.graph.net.Session; +import lombok.RequiredArgsConstructor; +import org.springframework.context.annotation.Bean; +import org.springframework.stereotype.Component; + +/** + * @author fulin + * 配置全局唯一session链接 + **/ +@Component +@RequiredArgsConstructor +public class NebulaSession { + + private final NebulaGraphProperties nebulaGraphProperties; + + @Bean + public Session session() throws Exception { + SessionPool sessionPool = new SessionPool(nebulaGraphProperties.getMaxConnSize(), + nebulaGraphProperties.getMinConnSize(), + nebulaGraphProperties.getHostAddresses().get(0), + nebulaGraphProperties.getUserName(), + nebulaGraphProperties.getPassword()); + return sessionPool.borrow(); + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/config/SessionPool.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/config/SessionPool.java new file mode 100644 index 00000000..7af461c2 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/config/SessionPool.java @@ -0,0 +1,120 @@ +package com.supervision.nebula.config; + +import com.vesoft.nebula.client.graph.NebulaPoolConfig; +import com.vesoft.nebula.client.graph.data.HostAddress; +import com.vesoft.nebula.client.graph.exception.AuthFailedException; +import com.vesoft.nebula.client.graph.exception.ClientServerIncompatibleException; +import com.vesoft.nebula.client.graph.exception.IOErrorException; +import com.vesoft.nebula.client.graph.exception.NotValidConnectionException; +import com.vesoft.nebula.client.graph.net.NebulaPool; +import com.vesoft.nebula.client.graph.net.Session; +import lombok.extern.slf4j.Slf4j; + +import javax.annotation.PreDestroy; +import java.net.UnknownHostException; +import java.util.Arrays; +import java.util.List; +import java.util.Queue; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.stream.Collectors; + +/** + * @author fulin + * SessionPool + */ +@Slf4j +public class SessionPool { + + private final Queue queue; + + private final String userName; + + private final String passWord; + + private final int minCountSession; + + private final int maxCountSession; + + private final NebulaPool pool; + + + /** + * 创建连接池 + * + * @param maxCountSession 默认创建连接数 + * @param minCountSession 最大创建连接数 + * @param hostAndPort 机器端口列表 + * @param userName 用户名 + * @param passWord 密码 + * @throws UnknownHostException + * @throws NotValidConnectionException + * @throws IOErrorException + * @throws AuthFailedException + */ + public SessionPool(int maxCountSession, int minCountSession, String hostAndPort, String userName, String passWord) throws UnknownHostException, NotValidConnectionException, IOErrorException, AuthFailedException, ClientServerIncompatibleException { + this.minCountSession = minCountSession; + this.maxCountSession = maxCountSession; + this.userName = userName; + this.passWord = passWord; + this.queue = new LinkedBlockingQueue<>(minCountSession); + this.pool = this.initGraphClient(hostAndPort, maxCountSession, minCountSession); + initSession(); + } + + public Session borrow() { + Session se = queue.poll(); + if (se != null) { + return se; + } + try { + return this.pool.getSession(userName, passWord, true); + } catch (Exception e) { + log.error("execute borrow session fail, detail: ", e); + throw new RuntimeException(e); + } + } + + @PreDestroy + public void release() { + Queue queue = this.queue; + for (Session se : queue) { + if (se != null) { + boolean success = this.queue.offer(se); + if (!success) { + se.release(); + } + } + } + } + + public void close() { + this.pool.close(); + } + + private void initSession() throws NotValidConnectionException, IOErrorException, AuthFailedException, ClientServerIncompatibleException { + for (int i = 0; i < minCountSession; i++) { + queue.offer(this.pool.getSession(userName, passWord, true)); + } + } + + private NebulaPool initGraphClient(String hostAndPort, int maxConnSize, int minCount) throws UnknownHostException { + List hostAndPorts = getGraphHostPort(hostAndPort); + NebulaPool pool = new NebulaPool(); + NebulaPoolConfig nebulaPoolConfig = new NebulaPoolConfig(); + nebulaPoolConfig = nebulaPoolConfig.setMaxConnSize(maxConnSize); + nebulaPoolConfig = nebulaPoolConfig.setMinConnSize(minCount); + nebulaPoolConfig = nebulaPoolConfig.setIdleTime(1000 * 600); + pool.init(hostAndPorts, nebulaPoolConfig); + return pool; + } + + private List getGraphHostPort(String hostAndPort) { + String[] split = hostAndPort.split(","); + return Arrays.stream(split).map(item -> { + String[] splitList = item.split(":"); + return new HostAddress(splitList[0], Integer.parseInt(splitList[1])); + }).collect(Collectors.toList()); + } + + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/AttributeEnum.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/AttributeEnum.java new file mode 100644 index 00000000..63f77557 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/AttributeEnum.java @@ -0,0 +1,18 @@ +package com.supervision.nebula.constant; + +import lombok.Getter; + +/** + * 属性枚举 + * + * @author fulin + */ +@Getter +public enum AttributeEnum { + // 实体类型 + TAGS, + // 关系类型 + EDGES, + // 空间 + SPACES; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/ConditionEnum.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/ConditionEnum.java new file mode 100644 index 00000000..a2c96056 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/ConditionEnum.java @@ -0,0 +1,32 @@ +package com.supervision.nebula.constant; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +/** + * @author fulin + */ + +@AllArgsConstructor +@Getter +public enum ConditionEnum { + + // 比较判断 + 相等("EQUAL", "=="), + 包含("CONTAINS", "CONTAINS"), + 开始("STARTS", "STARTS WITH"), + 结束("ENDS", "ENDS WITH"); + + private String name; + private String code; + + public static String getCode(String name) { + ConditionEnum[] values = ConditionEnum.values(); + for (ConditionEnum conditionEnum : values) { + if (name.equalsIgnoreCase(conditionEnum.getName())) { + return conditionEnum.getCode(); + } + } + return ""; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/EdgeDirectionEnum.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/EdgeDirectionEnum.java new file mode 100644 index 00000000..a61c686e --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/EdgeDirectionEnum.java @@ -0,0 +1,59 @@ +package com.supervision.nebula.constant; + + +import cn.hutool.core.collection.CollectionUtil; +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.util.List; + +/** + * @author fulin + */ + +@Getter +@AllArgsConstructor +public enum EdgeDirectionEnum { + + // 边方向 + 流出("OUTFLOW", "", ">", "OUT"), + 流入("INFLOW", "<", "", "IN"), + 双向("TWO-WAY", "", "", "BOTH"); + + private String name; + private String left; + private String right; + private String direct; + + + /** + * @return java.util.List + * @Description 获取方向 + * @Param [name] + **/ + public static List getLeftAndRight(String name) { + EdgeDirectionEnum[] values = EdgeDirectionEnum.values(); + List results = CollectionUtil.newArrayList(); + for (EdgeDirectionEnum edgeDirectionEnum : values) { + if (name.equalsIgnoreCase(edgeDirectionEnum.getName())) { + results.add(edgeDirectionEnum.getLeft()); + results.add(edgeDirectionEnum.getRight()); + return results; + } + } + results.add(""); + results.add(""); + return results; + } + + public static String getDirection(String name) { + EdgeDirectionEnum[] values = EdgeDirectionEnum.values(); + for (EdgeDirectionEnum edgeDirectionEnum : values) { + if (name.equalsIgnoreCase(edgeDirectionEnum.getName())) { + return edgeDirectionEnum.getDirect(); + } + } + return "BOTH"; + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/GqlConstant.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/GqlConstant.java new file mode 100644 index 00000000..0574592e --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/constant/GqlConstant.java @@ -0,0 +1,19 @@ +package com.supervision.nebula.constant; + +import com.google.common.base.Joiner; + +/** + * GQL 相关常量 + * + * @author fulin by 2022/3/28 + */ +public class GqlConstant { + public static final String UNKNOWN = "unknown"; + public static final String ID = "id"; + public static final Joiner GQL_UNION_JOINER = Joiner.on(" UNION "); + public static final Joiner GQL_UNION_COMMA = Joiner.on(","); + + private GqlConstant() { + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/AttributeController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/AttributeController.java new file mode 100644 index 00000000..a89b9b47 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/AttributeController.java @@ -0,0 +1,55 @@ +package com.supervision.nebula.controller; + + +import com.github.pagehelper.PageInfo; +import com.supervision.nebula.dto.graph.GraphPageAttribute; +import com.supervision.nebula.dto.graph.GraphShowAttribute; +import com.supervision.nebula.dto.graph.GraphShowInfo; +import com.supervision.nebula.service.AttributeService; +import com.supervision.nebula.service.GraphCommonService; +import com.supervision.nebula.vo.AttributeVo; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@SuppressWarnings("ALL") +@RestController +@RequestMapping("/attribute") +@Api(tags = "属性查询控制器") +@RequiredArgsConstructor +public class AttributeController { + + private final GraphCommonService graphCommonService; + + private final AttributeService attributeService; + + @PostMapping("/list") + @ApiOperation("属性查询(spaces tags edges列表)") + public List showAttribute(@RequestBody GraphShowAttribute graphShowAttribute) { + return attributeService.showAttribute(graphShowAttribute); + } + + @PostMapping("/page") + @ApiOperation("属性分页查询 tags edges 分页列表") + public PageInfo pageListAttribute(@RequestBody GraphPageAttribute graphPageAttribute) { + return attributeService.pageListAttribute(graphPageAttribute); + } + + @PostMapping("/listProperty") + @ApiOperation("属性的子属性列表查询 tag edge 的属性列表查询") + public List showAttributeInfo(@RequestBody GraphShowInfo graphShowInfo) { + return attributeService.showAttributeInfo(graphShowInfo); + } + + @PostMapping("/propertyInfo") + @ApiOperation("属性的详细信息") + public List showCreateAttributeInfo(@RequestBody GraphShowInfo graphShowInfo) { + return attributeService.showCreateAttributeInfo(graphShowInfo); + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/AttributeManageController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/AttributeManageController.java new file mode 100644 index 00000000..130cef2c --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/AttributeManageController.java @@ -0,0 +1,52 @@ +package com.supervision.nebula.controller; + + +import com.supervision.nebula.dto.graph.GraphAddAttribute; +import com.supervision.nebula.dto.graph.GraphDelAttribute; +import com.supervision.nebula.dto.graph.GraphDropAttribute; +import com.supervision.nebula.service.AttributeService; +import com.supervision.nebula.service.GraphCommonService; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.CommonVo; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * @author fulin + */ +@RestController +@RequestMapping("/attribute") +@Api(tags = "属性编辑控制器") +@RequiredArgsConstructor +public class AttributeManageController { + + private final GraphCommonService graphCommonService; + + private final AttributeService attributeService; + + @PostMapping("/dropAttribute") + @ApiOperation("删除属性(删除 space空间 tag标签 edge边类型)") + public List dropAttribute(@RequestBody GraphDropAttribute graphDropAttribute) { + return attributeService.dropAttribute(graphDropAttribute); + } + + @PostMapping("/addAttributeProperty") + @ApiOperation("增加属性的子属性(tag标签的属性 edge边类型的属性)") + public List addAttributeProperty(@RequestBody GraphAddAttribute graphAddAttribute) { + return attributeService.addAttributeProperty(graphAddAttribute); + } + + @PostMapping("/delAttributeProperty") + @ApiOperation("删除属性的子属性(tag标签的属性 edge边类型的属性)") + public List delAttributeProperty(@RequestBody GraphDelAttribute graphDelAttribute) { + return graphCommonService.executeJson(NebulaUtil.delAttributeProperty(graphDelAttribute), CommonVo.class); + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/EdgeController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/EdgeController.java new file mode 100644 index 00000000..5101c751 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/EdgeController.java @@ -0,0 +1,37 @@ +package com.supervision.nebula.controller; + + +import com.supervision.nebula.dto.NebulaVertexJsonResult; +import com.supervision.nebula.dto.graph.GraphSpace; +import com.supervision.nebula.service.GraphCommonService; +import com.supervision.nebula.util.NebulaUtil; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * @author fulin + * @Descriptin: 边控制器 + * @ClassName: VertexController + */ +@RestController +@Api(tags = "边edge查询控制器") +@RequestMapping("/edge") +@RequiredArgsConstructor +public class EdgeController { + + private final GraphCommonService graphCommonService; + + @PostMapping("/listEdge") + @ApiOperation("查询插入的边edge(绑定关系查询)") + public List listEdge(@RequestBody GraphSpace graphSpace) { + return graphCommonService.executeJson(NebulaUtil.listEdge(graphSpace), NebulaVertexJsonResult.class); + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/EdgeManageController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/EdgeManageController.java new file mode 100644 index 00000000..347fada5 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/EdgeManageController.java @@ -0,0 +1,47 @@ +package com.supervision.nebula.controller; + + +import com.supervision.nebula.dto.graph.GraphDeleteEdge; +import com.supervision.nebula.dto.graph.GraphInsertEdge; +import com.supervision.nebula.service.GraphCommonService; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.CommonVo; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * @author fulin + * @Descriptin: 边控制器 + * @ClassName: VertexController + */ +@RestController +@Api(tags = "边edge管理控制器") +@RequestMapping("/edge") +@RequiredArgsConstructor +public class EdgeManageController { + + private final GraphCommonService graphCommonService; + + @PostMapping("/insertEdge") + @ApiOperation("插入边edge(关系编辑-绑定两个点的关系)") + public List insertEdge(@RequestBody GraphInsertEdge graphInsertEdge) { + String vidType = graphCommonService.getVidType(graphInsertEdge.getSpace()); + return graphCommonService.executeJson(NebulaUtil.insertEdge(graphInsertEdge, vidType), CommonVo.class); + } + + @PostMapping("/deleteEdge") + @ApiOperation("删除边edge(解除关系编辑-解除两个点的关系)") + public List deleteEdge(@RequestBody GraphDeleteEdge graphDeleteEdge) { + String vidType = graphCommonService.getVidType(graphDeleteEdge.getSpace()); + return graphCommonService.executeJson(NebulaUtil.deleteEdge(graphDeleteEdge, vidType), CommonVo.class); + } + + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/GraphFileController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/GraphFileController.java new file mode 100644 index 00000000..4812fec1 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/GraphFileController.java @@ -0,0 +1,57 @@ +package com.supervision.nebula.controller; + + +import com.supervision.nebula.dto.ImportBean; +import com.supervision.nebula.entity.GraphFile; +import com.supervision.nebula.service.GraphFileService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.http.MediaType; +import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; + +/** + * (GraphFile)表控制层 + * + * @author makejava + * @since 2022-08-23 09:09:26 + */ +@RestController +@Api(tags = "文件控制器") +@RequestMapping("graphFile") +public class GraphFileController { + + @Resource + private GraphFileService graphFileService; + + /** + * 文件上传 + * + * @param file 文件 + * @return 文件实例对象 + */ + + @ApiOperation("文件上传--可以不做,这里为了预览数据") + @PostMapping(value = "/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE) + public GraphFile uploadFile(@RequestParam("file") MultipartFile file) { + return this.graphFileService.uploadFile(file); + } + + @ApiOperation("文件导入--执行nebula import插件") + @PostMapping("/import") + public Boolean importFile(@RequestBody ImportBean importBean) throws IOException { + return this.graphFileService.importFile(importBean); + } + + @ApiOperation("模板下载,可以填充数据") + @GetMapping("/template") + public void template(@RequestParam String space, HttpServletResponse response) { + graphFileService.template(space, response); + } + +} + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/SpaceController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/SpaceController.java new file mode 100644 index 00000000..ad2d6c28 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/SpaceController.java @@ -0,0 +1,64 @@ +package com.supervision.nebula.controller; + + +import com.supervision.nebula.dto.graph.GraphCreateSpace; +import com.supervision.nebula.dto.graph.GraphShowAttribute; +import com.supervision.nebula.dto.graph.GraphSpace; +import com.supervision.nebula.service.GraphCommonService; +import com.supervision.nebula.service.SpaceService; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.AttributeVo; +import com.supervision.nebula.vo.CommonVo; +import com.supervision.nebula.vo.DetailSpace; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * @author fulin + * space控制器 + */ +@RestController +@Api(tags = "图谱space控制器") +@RequestMapping("/space") +@RequiredArgsConstructor +public class SpaceController { + + private final GraphCommonService graphCommonService; + + private final SpaceService spaceService; + + + @PostMapping("/create") + @ApiOperation("创建图谱") + public List createSpace(@RequestBody GraphCreateSpace graphCreateSpace) { + return spaceService.createSpace(graphCreateSpace); + } + + + @PostMapping("/use") + @ApiOperation("切换图谱") + public List useSpace(@RequestBody GraphCreateSpace graphCreateSpace) { + return graphCommonService.executeJson(NebulaUtil.useSpace(graphCreateSpace.getSpace()), CommonVo.class); + } + + @PostMapping("/list") + @ApiOperation("卡片展示列表(图谱详情)") + public List detailSpace(@RequestBody GraphShowAttribute graphShowAttribute) { + return spaceService.detailSpace(graphShowAttribute); + } + + @PostMapping("/info") + @ApiOperation("查询某个空间的信息") + public List spaceInfo(@RequestBody GraphSpace graphSpace) { + return spaceService.spaceInfo(graphSpace.getSpace()); + } + + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/SubGraphController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/SubGraphController.java new file mode 100644 index 00000000..50582916 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/SubGraphController.java @@ -0,0 +1,31 @@ +package com.supervision.nebula.controller; + + +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.supervision.nebula.service.GraphCommonService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@Api(tags = "子图查询控制器") +@RequestMapping("/subGraph") +@RequiredArgsConstructor +public class SubGraphController { + + private final GraphCommonService graphCommonService; + + @PostMapping("querySubGraph") + @ApiOperation("子图查询") + public JSONObject querySubGraph() { + String subgraphQuery = "use subgraph;GET SUBGRAPH 100 STEPS FROM \"player101\" YIELD VERTICES AS `vertices_`, EDGES AS `edges_`;"; + String s = graphCommonService.executeJson(subgraphQuery); + return JSONUtil.parseObj(s); + } +} + + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/TagEdgeController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/TagEdgeController.java new file mode 100644 index 00000000..e8f5dab2 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/TagEdgeController.java @@ -0,0 +1,43 @@ +package com.supervision.nebula.controller; + + +import com.supervision.nebula.dto.graph.GraphCreateIndex; +import com.supervision.nebula.dto.graph.GraphCreateTagEdge; +import com.supervision.nebula.service.GraphCommonService; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.CommonVo; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * @author fulin + * 点类型标签tag控制器 + */ +@RestController +@Api(tags = "标签tag edge 新增控制器") +@RequestMapping("/tagEdge") +public class TagEdgeController { + + @Autowired + GraphCommonService graphCommonService; + + @PostMapping("/createTagEdge") + @ApiOperation("创建tag 或者 edge") + public List createTagEdge(@RequestBody GraphCreateTagEdge graphCreateTagEdge) { + return graphCommonService.executeJson(NebulaUtil.createTagEdge(graphCreateTagEdge), CommonVo.class); + } + + + @PostMapping("/createIndex") + @ApiOperation("创建索引") + public List createIndex(@RequestBody GraphCreateIndex graphCreateIndex) { + return graphCommonService.executeJson(NebulaUtil.createIndex(graphCreateIndex), CommonVo.class); + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/VertexController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/VertexController.java new file mode 100644 index 00000000..17401c1f --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/VertexController.java @@ -0,0 +1,69 @@ +package com.supervision.nebula.controller; + +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONUtil; +import com.supervision.nebula.dto.NebulaJsonConverter; +import com.supervision.nebula.dto.NebulaVertexJsonResult; +import com.supervision.nebula.dto.graph.*; +import com.supervision.nebula.service.VertexService; +import com.supervision.nebula.vo.AttributeVo; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +/** + * 点控制器 + * + * @author fulin + */ +@RestController +@Api(tags = "点查询(实体)控制器") +@RequestMapping("/vertex") +@RequiredArgsConstructor +public class VertexController { + + private final VertexService vertexService; + + @PostMapping("/vertexList") + @ApiOperation("查询创建的点列表") + public List vertexList(@RequestBody GraphSpace graphSpace) { + return vertexService.vertexList(graphSpace.getSpace()); + } + + @PostMapping("/vertexTagsQuery") + @ApiOperation("根据tag标签查询点") + public List vertexTagsQuery(@RequestBody GraphVertexTatsQuery graphVertexTatsQuery) { + return vertexService.vertexTagsQuery(graphVertexTatsQuery); + } + + @PostMapping("/vertexTagAttributeQuery") + @ApiOperation("根据tag标签属性查询点(先要保证该标签属性已经建立索引)") + public List vertexTagAttributeQuery(@RequestBody GraphVertexTatAttributeQuery graphVertexTatAttributeQuery) { + return vertexService.vertexTagAttributeQuery(graphVertexTatAttributeQuery); + } + + @PostMapping("/expandQuery") + @ApiOperation("根据点以及边信息扩展查询") + public GraphData vertexExpandQuery(@RequestBody GraphExpand graphExpand) { + List data = vertexService.vertexExpandQuery(graphExpand); + JSONArray objects = JSONUtil.parseArray(JSONUtil.toJsonStr(data)); + return NebulaJsonConverter.toGraphDataMain(objects, new ArrayList()); + } + + @PostMapping("/page") + @ApiOperation("查询创建的点分页列表") + public Map vertexPage(@RequestBody GraphVertexTatsQuery graphVertexTatsQuery) { + return vertexService.vertexPage(graphVertexTatsQuery); + } +} + + + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/VertexManageController.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/VertexManageController.java new file mode 100644 index 00000000..6d59afca --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/controller/VertexManageController.java @@ -0,0 +1,44 @@ +package com.supervision.nebula.controller; + + +import com.supervision.nebula.dto.graph.GraphCreateVertex; +import com.supervision.nebula.dto.graph.GraphDeleteVertex; +import com.supervision.nebula.service.GraphCommonService; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.CommonVo; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * @author fulin + * 点控制器 + */ +@RestController +@Api(tags = "点编辑(实体)控制器") +@RequestMapping("/vertex") +@RequiredArgsConstructor +public class VertexManageController { + + private final GraphCommonService graphCommonService; + + @PostMapping("/createVertex") + @ApiOperation("创建点(需要附加标签tag信息)") + public List createVertex(@RequestBody GraphCreateVertex graphCreateVertex) { + String vidType = graphCommonService.getVidType(graphCreateVertex.getSpace()); + return graphCommonService.executeJson(NebulaUtil.createPoint(graphCreateVertex, vidType), CommonVo.class); + } + + @PostMapping("/deleteVertex") + @ApiOperation("删除点(根据点id删除)") + public List deleteVertex(@RequestBody GraphDeleteVertex graphDeleteVertex) { + String vidType = graphCommonService.getVidType(graphDeleteVertex.getSpace()); + return graphCommonService.executeJson(NebulaUtil.deleteVertex(graphDeleteVertex, vidType), CommonVo.class); + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/EdgeCombo.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/EdgeCombo.java new file mode 100644 index 00000000..70d92f12 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/EdgeCombo.java @@ -0,0 +1,15 @@ +package com.supervision.nebula.dto; + +import lombok.Data; + +@Data +public class EdgeCombo { + /** + * 文件id + */ + private Integer fileId; + /** + * 元素属性 + */ + private EdgeElement edgeElement; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/EdgeElement.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/EdgeElement.java new file mode 100644 index 00000000..127f646a --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/EdgeElement.java @@ -0,0 +1,27 @@ +package com.supervision.nebula.dto; + +import lombok.Data; + +import java.util.List; + +@Data +public class EdgeElement { + /** + * 边名称 + */ + private String elementName; + /** + * 起点对应的列号 + */ + private Integer srcId; + /** + * 终点对应的列号 + */ + private Integer dstId; + + private Integer rank; + /** + * 属性集合 + */ + private List properties; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/FailureTroubleshootingVo.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/FailureTroubleshootingVo.java new file mode 100644 index 00000000..b0d875aa --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/FailureTroubleshootingVo.java @@ -0,0 +1,21 @@ +package com.supervision.nebula.dto; + +import lombok.Builder; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.util.Map; + +/** + * 故障图谱归因分析-失效现象解析结果 + * + * @author fulin by 2022/3/29 + */ +@Builder +@Data +@EqualsAndHashCode(of = "id") +public class FailureTroubleshootingVo { + private String id; + private String tag; + private Map properties; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/ImportBean.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/ImportBean.java new file mode 100644 index 00000000..52739402 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/ImportBean.java @@ -0,0 +1,22 @@ +package com.supervision.nebula.dto; + +import lombok.Data; + +import java.util.List; + +@Data +public class ImportBean { + + /** + * 图谱标识 + */ + private String space; + /** + * 点集合 + */ + private List vertices; + /** + * 边集合 + */ + private List edges; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/ImportDto.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/ImportDto.java new file mode 100644 index 00000000..07a3bab8 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/ImportDto.java @@ -0,0 +1,23 @@ +package com.supervision.nebula.dto; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @ClassName: ImportDto + */ +@Data +@ApiModel("数据导入入参") +public class ImportDto { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "attribute可选值: tag标签/edge边类型", example = "tag", required = true) + private String attribute; + + @ApiModelProperty(value = "属性名称", example = "t1", required = true) + private String attributeName; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/NebulaJsonConverter.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/NebulaJsonConverter.java new file mode 100644 index 00000000..4ff5db67 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/NebulaJsonConverter.java @@ -0,0 +1,156 @@ +package com.supervision.nebula.dto; + +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.map.MapUtil; +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONObject; +import com.google.common.collect.Sets; +import com.supervision.nebula.constant.GqlConstant; +import com.supervision.nebula.dto.graph.GraphData; +import com.supervision.nebula.dto.graph.GraphEdge; +import com.supervision.nebula.dto.graph.GraphNode; +import com.supervision.nebula.dto.graph.NodeType; +import com.supervision.nebula.vo.AttributeVo; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * @author fulin by 2022/3/30 + */ +public class NebulaJsonConverter { + + /** + * @param jsonArray + * @param attributeVos + * @return + */ + public static GraphData toGraphDataMain(JSONArray jsonArray, List attributeVos) { + final JSONObject jsonObject = jsonArray.getJSONObject(0); + final JSONArray data = jsonObject.getJSONArray("data"); + if (ObjectUtil.isNull(data)) { + return new GraphData(); + } + final Set nodes = Sets.newHashSet(); + final Set edges = Sets.newHashSet(); + final List nodeTypeList = CollectionUtil.newArrayList(); + final Set tagSet = CollectionUtil.newHashSet(); + + //List dataBeanList = attributeVos.get(0).getData(); + + for (int d = 0; d < data.size(); d++) { + final JSONObject dataJSONObject = data.getJSONObject(d); + + // meta 数据结构: [[]] + final JSONArray meta = dataJSONObject.getJSONArray("meta"); + final JSONArray row = dataJSONObject.getJSONArray("row"); + + for (int i = 0; i < meta.size(); i++) { + final JSONArray metaJSONArray = meta.getJSONArray(i); + final JSONArray rowJSONArray = row.getJSONArray(i); + + for (int i1 = 0; i1 < metaJSONArray.size(); i1++) { + final JSONObject oneMeta = metaJSONArray.getJSONObject(i1); + final JSONObject oneRow = rowJSONArray.getJSONObject(i1); + final String type = oneMeta.getStr("type"); + Object tagInfo = null; + Object edgeInfo = null; + switch (type) { + case "vertex": + String tag = GqlConstant.UNKNOWN; + String name = GqlConstant.UNKNOWN; + String color = "#289D73"; + tagInfo = oneRow.entrySet(); + for (Map.Entry entry : oneRow.entrySet()) { + final String key = entry.getKey(); + if (key.endsWith("name")) { + final Object value = entry.getValue(); + final String[] split = key.split("\\."); + tag = split[0]; + name = value.toString(); + break; + } + } + String nodeTypes = GqlConstant.UNKNOWN; + if (ObjectUtil.notEqual(GqlConstant.UNKNOWN, tag)) { + nodeTypes = tag; + } + nodes.add(GraphNode.builder() + .id(oneMeta.getStr("id")) + .tag(tag) + .label(name) + .nodeTypes(nodeTypes) + .tagInfo(tagInfo) + .build()); + + HashMap colorMap = MapUtil.newHashMap(); + colorMap.put("fill", color); + colorMap.put("size", "50"); + + //for (AttributeVo.DataBean dataBean : dataBeanList) { + // List row1 = dataBean.getRow(); + // if (CollectionUtil.isNotEmpty(row1)) { + // String tagName = row1.get(0); + // if (StrUtil.isNotBlank(tagName)) { + // if (tagName.equalsIgnoreCase(tag) && row1.size() > 1) { + // colorMap.put("fill", row1.get(1)); + // colorMap.put("size", row1.get(2)); + // } + // } + // } + //} + + if (!tagSet.contains(tag)) { + nodeTypeList.add( + NodeType + .builder() + .id(oneMeta.getStr("id")) + .label(tag) + .style(colorMap) + .build() + ); + } + tagSet.add(tag); + break; + case "edge": + final JSONObject id = oneMeta.getJSONObject("id"); + edgeInfo = oneRow.entrySet(); + int typeFX = Integer.parseInt(id.get("type").toString()); + if (typeFX > 0) { + edges.add( + GraphEdge.builder() + .source(id.getStr("src")) + .target(id.getStr("dst")) + .label(id.getStr("name")) + .edgeInfo(edgeInfo) + .build() + ); + } + if (typeFX < 0) { + edges.add( + GraphEdge.builder() + .source(id.getStr("dst")) + .target(id.getStr("src")) + .label(id.getStr("name")) + .edgeInfo(edgeInfo) + .build() + ); + } + break; + default: + throw new RuntimeException("type not found"); + } + } + } + } + return GraphData.builder() + .nodes(nodes) + .edges(edges) + .NodeTypes(nodeTypeList) + .build(); + } +} + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/NebulaVertexJsonResult.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/NebulaVertexJsonResult.java new file mode 100644 index 00000000..7a43aa8c --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/NebulaVertexJsonResult.java @@ -0,0 +1,74 @@ +package com.supervision.nebula.dto; + +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * Nebula-Graph session json 查询返回结果反序列化。 + * 该序列化非通用模式，需要具体分析 json 结果。 + * + * @author fulin by 2022/3/29 + */ +@Data +@ApiModel("返回类") +public class NebulaVertexJsonResult { + @ApiModelProperty(value = "空间名称") + private String spaceName; + @ApiModelProperty(value = "潜伏期") + private int latencyInUs; + @ApiModelProperty(value = "数据集合") + private List data; + @ApiModelProperty(value = "字段") + private List columns; + + public Set toFailureTroubleshootingVos() { + final List data = this.getData(); + final Set r = Sets.newHashSetWithExpectedSize(data.size()); + for (OneData oneData : data) { + final List meta = oneData.getMeta(); + final List> row = oneData.getRow(); + for (int i = 0; i < meta.size(); i++) { + final Map oneRow = row.get(i); + final Map properties = Maps.newHashMapWithExpectedSize(oneRow.size()); + String tag = "unknown"; + for (Map.Entry entry : oneRow.entrySet()) { + final String key = entry.getKey(); + final String[] split = key.split("\\."); + tag = split[0]; + properties.put(split[1], entry.getValue()); + } + r.add(FailureTroubleshootingVo.builder() + .id(meta.get(i).getId()) + .tag(tag) + .properties(properties) + .build()); + } + } + return r; + } + + @Data + public static class OneData { + @ApiModelProperty(value = "元数据") + private List meta; + @ApiModelProperty(value = "属性名称: 属性值") + private List> row; + } + + @Data + public static class OneMeta { + @ApiModelProperty(value = "id") + private String id; + @ApiModelProperty(value = "类型") + private String type; + } +} + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/PageBeanDto.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/PageBeanDto.java new file mode 100644 index 00000000..a394bf0c --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/PageBeanDto.java @@ -0,0 +1,20 @@ +package com.supervision.nebula.dto; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @Descriptin: 分页参数入参 + * @ClassName: PageBeanDto + */ +@ApiModel("分页参数入参") +@Data +public class PageBeanDto { + + @ApiModelProperty(value = "页码:从1开始", example = "1", required = false) + private Integer pageNum = 1; + + @ApiModelProperty(value = "分页条数", example = "10", required = false) + private Integer pageSize = 10; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/Property.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/Property.java new file mode 100644 index 00000000..36f21648 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/Property.java @@ -0,0 +1,19 @@ +package com.supervision.nebula.dto; + +import lombok.Data; + +@Data +public class Property { + /** + * 属性名称 + */ + private String propName; + /** + * 对应CSV文件列号 + */ + private Integer csvIndex; + /** + * 属性类型 + */ + private String type; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/TemplateBean.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/TemplateBean.java new file mode 100644 index 00000000..60003975 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/TemplateBean.java @@ -0,0 +1,115 @@ +package com.supervision.nebula.dto; + +import lombok.Data; + +import java.util.List; + +/** + * @ClassName= TemplateBean + */ +@Data +public class TemplateBean { + + private String version = "v3"; + private String description = "web console import"; + private Boolean removeTempFiles = false; + private ClientSettings clientSettings; + private String logPath; + private List files; + + + @Data + public static class File { + private String path; + private String failDataPath; + private Integer batchSize = 60; + private String limit; + private String inOrder; + private String type = "csv"; + private CSV csv; + private Schema schema; + } + + @Data + public static class CSV { + private Boolean withHeader = true; + private Boolean withLabel = false; + private String delimiter; + } + + @Data + public static class Schema { + private String type = "vertex"; + // private Vertex vertex; + private Edge edge; + } + + @Data + public static class Edge { + private String name = "order"; + private Boolean withRanking = false; +// private List props; +// private SrcDst srcVID; +// private SrcDst dstVID; +// private Integer rank; + } + + +// @Data +// public static class SrcDst { +// private Integer index = 1; +// private String function = ""; +// private String type = "string"; +// private String prefix = ""; +// } + + +// @Data +// public static class Vertex { +// private Vid vid; +// private List tags; +// } + + +// @Data +// public static class Vid { +// private Integer index = 0; +// private String function; +// private String type = "string"; +// private String prefix; +// } + + +// @Data +// public static class Tag { +// private String name = "item"; +// private List props; +// } + +// @Data +// public static class Prop { +// private String name = "id_single_item"; +// private String type = "string"; +// private Integer index = 0; +// } + + + @Data + public static class ClientSettings { + private Integer retry = 3; + private Integer concurrency = 10; + private Integer channelBufferSize = 128; + private String space = "dataImport"; + private String postStart; + private String preStop; + private Connection connection; + } + + @Data + public static class Connection { + private String user = "root"; + private String password = "nebula"; + private String address = "127.0.0.1:9669"; + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/UserDto.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/UserDto.java new file mode 100644 index 00000000..6e421cfb --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/UserDto.java @@ -0,0 +1,24 @@ +package com.supervision.nebula.dto; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * @ClassName: UserDto + */ + +@Data +@ApiModel("用户入参") +@NoArgsConstructor +@AllArgsConstructor +public class UserDto { + + @ApiModelProperty(value = "用户名", required = true, example = "test") + private String username; + + @ApiModelProperty(value = "密码", required = true, example = "test") + private String password; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/VertexCombo.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/VertexCombo.java new file mode 100644 index 00000000..e2f197d8 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/VertexCombo.java @@ -0,0 +1,21 @@ +package com.supervision.nebula.dto; + +import lombok.Data; + +import java.util.List; + +@Data +public class VertexCombo { + /** + * 文件id + */ + private Integer fileId; + /** + * 点对应文件中的列号 + */ + private Integer vertexId; + /** + * 元素属性 + */ + private List vertexElements; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/VertexElement.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/VertexElement.java new file mode 100644 index 00000000..4c0a015d --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/VertexElement.java @@ -0,0 +1,17 @@ +package com.supervision.nebula.dto; + +import lombok.Data; + +import java.util.List; + +@Data +public class VertexElement { + /** + * 元素名称 + */ + private String elementName; + /** + * 属性集合 + */ + private List properties; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/AttributeBean.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/AttributeBean.java new file mode 100644 index 00000000..547cdc7f --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/AttributeBean.java @@ -0,0 +1,44 @@ +package com.supervision.nebula.dto.graph; + +import cn.hutool.core.util.StrUtil; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @Descriptin: + * @ClassName: AttributeBean + */ +@ApiModel("属性入参") +@Data +public class AttributeBean { + + /** + * 属性名称 + **/ + @ApiModelProperty(value = "tag/edge的属性名称", example = "p3", required = true) + private String propertyName; + /** + * 属性类型 (int bool string double .........) + **/ + @ApiModelProperty(value = "索引长度:属性为string 必须有长度,其他类型不可传入 ", example = "30", required = true) + private String indexLength; + + public String getPropertyName() { + return "`" + propertyName + "`" + getIndexLength(); + } + + private String getIndexLength() { + if (StrUtil.isNotBlank(indexLength)) { + return "(" + indexLength + ")"; + } + return ""; + } + + private String getIndexFull() { + if (StrUtil.isNotBlank(indexLength)) { + return "(" + indexLength + ")"; + } + return ""; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphAddAttribute.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphAddAttribute.java new file mode 100644 index 00000000..502680de --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphAddAttribute.java @@ -0,0 +1,60 @@ +package com.supervision.nebula.dto.graph; + +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.util.StrUtil; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("修改属性实体") +public class GraphAddAttribute { + + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "attribute可选值: tag标签/edge边类型", example = "tag", required = true) + private String attribute; + + @ApiModelProperty(value = "属性名称", example = "t1", required = true) + private String attributeName; + + @ApiModelProperty(value = "tag/edge的属性名称", example = "p5") + private String propertyName; + + @ApiModelProperty(value = "属性类型,add 必传该类型 可选值: int bool string double .........", example = "string", required = false) + private String propertyType; + + @ApiModelProperty(value = "是否可为空: NOT NULL 或者 NULL", example = "NULL") + private String isNull; + + @ApiModelProperty(value = "默认值") + private Object defaultValue; + + @ApiModelProperty(value = "描述") + private String common; + + public Object getDefaultValue() { + if (!ObjectUtil.isNull(defaultValue)) { + if (defaultValue instanceof String) { + return "DEFAULT '" + defaultValue + "'"; + } + return "DEFAULT " + defaultValue; + } + return defaultValue; + } + + public String getCommon() { + if (StrUtil.isNotBlank(common)) { + return "COMMENT '" + common + "'"; + } + return common; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateIndex.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateIndex.java new file mode 100644 index 00000000..2e99c463 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateIndex.java @@ -0,0 +1,39 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("创建索引入参") +public class GraphCreateIndex { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "创建类型: tag/edge", example = "tag", required = true) + private String type; + + @ApiModelProperty(value = "索引名称", example = "name_index", required = true) + private String indexName; + + @ApiModelProperty(value = "tag/edge名称", example = "t1", required = true) + private String tagEdgeName; + + @ApiModelProperty(value = "索引描述描述", example = "备注") + private String comment; + + @ApiModelProperty(value = "属性集合") + private List attributeBeanList; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateSpace.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateSpace.java new file mode 100644 index 00000000..e0fa1408 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateSpace.java @@ -0,0 +1,62 @@ +package com.supervision.nebula.dto.graph; + +import cn.hutool.core.util.StrUtil; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("创建空间实体") +public class GraphCreateSpace { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + /** + * 空间中文名称 + **/ + @ApiModelProperty(value = "空间中文名称", example = "付琳测试", required = true) + private String spaceChineseName; + /** + * 分片数量 + **/ + @ApiModelProperty(value = "分片数量", example = "1") + private Integer partitionNum; + + /** + * 分片数量 + **/ + @ApiModelProperty(value = "副本数量", example = "1") + private Integer replicaFactor; + /** + * 类型 + **/ + @ApiModelProperty(value = "点类型:INT64,FIXED_STRING", example = "INT64") + private String fixedType = "INT64"; + /** + * 类型大小 + **/ + @ApiModelProperty(value = "类型长度,FIXED_STRING 此字段必填 如32,64") + private String size = ""; + /** + * 描述 + **/ + @ApiModelProperty(value = "描述") + private String comment; + + public String getSize() { + if (StrUtil.isNotBlank(size)) { + return "(" + size + ")"; + } + return ""; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateTagEdge.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateTagEdge.java new file mode 100644 index 00000000..39cf90db --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateTagEdge.java @@ -0,0 +1,39 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("创建tag edge入参") +public class GraphCreateTagEdge { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi") + private String space; + + @ApiModelProperty(value = "创建类型: tag/edge", example = "tag") + private String type; + + @ApiModelProperty(value = "tag/edge名称", example = "demo") + private String tagEdgeName; + + @ApiModelProperty(value = "tag/edge描述", example = "备注") + private String tagEdgeComment; + + @ApiModelProperty(value = "属性集合") + private List propertyList; + + @ApiModelProperty(value = "颜色") + private String color; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateVertex.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateVertex.java new file mode 100644 index 00000000..c28318a0 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphCreateVertex.java @@ -0,0 +1,38 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("创建点入参") +public class GraphCreateVertex { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "标签tag名称", example = "t1", required = true) + private String tagName; + + @ApiModelProperty(value = "标签tag属性集合", required = false) + private List tagList; + /** + * point的key + **/ + @ApiModelProperty(value = "点的VID", required = true) + private Object pointKey; + + @ApiModelProperty(value = "标签tag的属性值集合", required = false) + private List tagValueList; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphData.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphData.java new file mode 100644 index 00000000..744ac35e --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphData.java @@ -0,0 +1,23 @@ +package com.supervision.nebula.dto.graph; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.Collection; + +/** + * 图可视化展示数据结构 + * + * @author fulin by 2022/3/30 + */ +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class GraphData { + private Collection nodes; + private Collection edges; + private Collection NodeTypes; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDelAttribute.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDelAttribute.java new file mode 100644 index 00000000..4320a0de --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDelAttribute.java @@ -0,0 +1,31 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("删除属性实体") +public class GraphDelAttribute { + + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "attribute可选值: tag标签/edge边类型", example = "tag", required = true) + private String attribute; + + @ApiModelProperty(value = "属性名称", example = "t1", required = true) + private String attributeName; + + @ApiModelProperty(value = "tag/edge的属性名称 支持批量") + private List propertyNameList; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDeleteEdge.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDeleteEdge.java new file mode 100644 index 00000000..2f823019 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDeleteEdge.java @@ -0,0 +1,32 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("删除边入参") +public class GraphDeleteEdge { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "边类型edge名称", example = "e1", required = true) + private String edgeName; + + @ApiModelProperty(value = "点的起始VID", example = "11", required = true) + private Object srcVid; + + @ApiModelProperty(value = "点的目的VID", example = "12", required = true) + private Object dstVid; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDeleteVertex.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDeleteVertex.java new file mode 100644 index 00000000..ffe0af73 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDeleteVertex.java @@ -0,0 +1,26 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("删除点入参") +public class GraphDeleteVertex { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "vertex 点id", required = true) + private Object vid; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDropAttribute.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDropAttribute.java new file mode 100644 index 00000000..ad9dd1f6 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphDropAttribute.java @@ -0,0 +1,26 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("删除属性实体") +public class GraphDropAttribute { + + + @ApiModelProperty(value = "空间名称", example = "flceshi1", required = true) + private String space; + + @ApiModelProperty(value = "属性名称", example = "flceshi1", required = true) + private String attributeName; + + @ApiModelProperty(value = "attribute可选值:space空间/tag标签/edge边类型", example = "space", required = true) + private String attribute; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphEdge.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphEdge.java new file mode 100644 index 00000000..aeead1ae --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphEdge.java @@ -0,0 +1,26 @@ +package com.supervision.nebula.dto.graph; + +import lombok.*; + +/** + * 图可视化-边 + * + * @author fulin by 2022/3/30 + */ +@Data +@Builder +@EqualsAndHashCode(of = {"source", "target"}) +@AllArgsConstructor +@NoArgsConstructor +public class GraphEdge { + private String label; + private String source; + private String target; + private Object edgeInfo; + + public GraphEdge(String edge, String tagStart, String tagEnd) { + this.label = edge; + this.source = tagStart; + this.target = tagEnd; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphExpand.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphExpand.java new file mode 100644 index 00000000..16cc8235 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphExpand.java @@ -0,0 +1,81 @@ +package com.supervision.nebula.dto.graph; + +import cn.hutool.core.util.StrUtil; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.validation.constraints.Max; +import javax.validation.constraints.Min; +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("扩展查询入参实体") +public class GraphExpand { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "边类型集合", required = true) + private List edgeList; + + @ApiModelProperty(value = "方向: OUTFLOW(流出);INFLOW(流入);TWO-WAY(双向);", example = "TWO-WAY", required = true) + private String direction; + + @ApiModelProperty(value = "步数开始(单步/范围的开始)", example = "1", required = true) + private Integer stepStart; + + @ApiModelProperty(value = "步数结束(范围的结束;可无)", example = "2") + @Min(1) + private Integer stepEnd; + + @ApiModelProperty(value = "结果条数", example = "100", required = true) + @Max(Integer.MAX_VALUE) + @Min(1) + private Integer resultSize = Integer.MAX_VALUE; + + @ApiModelProperty(value = "扩展点id集合", required = true) + private List vidList; + + + @ApiModelProperty(value = "条件(可为空)", example = " l.name CONTAINS '1' ", required = false) + private String condition; + + public String getStepEndResult() { + if (stepEnd != null) { + return ".." + stepEnd; + } + return ""; + } + + public String getVidList(String vidType) { + StringBuffer stringBuffer = new StringBuffer(); + for (int i = 0; i < vidList.size(); i++) { + Object vid = vidList.get(i); + + if (vidType.contains("STRING")) { + stringBuffer.append("\"").append(vid).append("\""); + } else { + stringBuffer.append(vid); + } + if (vidList.size() > 1 && (i + 1) != vidList.size()) { + stringBuffer.append(","); + } + } + return stringBuffer.toString(); + } + + // l.degree CONTAINS 1 AND l.min_level == 2 + public String getCondition() { + if (StrUtil.isNotBlank(condition)) { + return " AND ALL(l IN e WHERE " + condition + ")"; + } + return ""; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphInsertEdge.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphInsertEdge.java new file mode 100644 index 00000000..9e03ad64 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphInsertEdge.java @@ -0,0 +1,39 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("插入边入参") +public class GraphInsertEdge { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "边类型edge名称", example = "e1", required = true) + private String edgeName; + + @ApiModelProperty(value = "边类型edge属性集合", required = false) + private List edgeList; + + @ApiModelProperty(value = "点的起始VID", example = "11", required = true) + private String srcVid; + + @ApiModelProperty(value = "点的目的VID", example = "12", required = true) + private String dstVid; + + @ApiModelProperty(value = "边edge的属性值集合", required = false) + private List edgeValueList; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphNode.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphNode.java new file mode 100644 index 00000000..99e9bad8 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphNode.java @@ -0,0 +1,29 @@ +package com.supervision.nebula.dto.graph; + +import lombok.*; + +/** + * 图可视化-节点 + * + * @author fulin by 2022/3/30 + */ +@Data +@Builder +@EqualsAndHashCode(of = "id") +@NoArgsConstructor +@AllArgsConstructor +public class GraphNode { + private String id; + private String tag; + private String label; + private String nodeTypes; + private Object tagInfo; + + public GraphNode(String tag, String tagInfo) { + this.id = tag; + this.tag = tag; + this.label = tag; + this.nodeTypes = tag; + this.tagInfo = tagInfo; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphPageAttribute.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphPageAttribute.java new file mode 100644 index 00000000..5919ecd6 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphPageAttribute.java @@ -0,0 +1,24 @@ +package com.supervision.nebula.dto.graph; + +import com.supervision.nebula.dto.PageBeanDto; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("查询属性分页查询入参") +public class GraphPageAttribute extends PageBeanDto { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "attribute可选值:tags标签/edges边类型", example = "tags", required = true) + private String attribute; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphPageEdge.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphPageEdge.java new file mode 100644 index 00000000..84dde137 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphPageEdge.java @@ -0,0 +1,39 @@ +package com.supervision.nebula.dto.graph; + +import com.supervision.nebula.dto.PageBeanDto; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("查询边分页入参") +public class GraphPageEdge extends PageBeanDto { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "边类型edge", required = false) + private String edge; + + + @ApiModelProperty(value = "起点或者终点ID", required = false) + private String vid; +} + + + + + + + + + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphRelationInsert.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphRelationInsert.java new file mode 100644 index 00000000..dc914021 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphRelationInsert.java @@ -0,0 +1,25 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * 关系绑定入参 + * + * @ClassName: GraphRelationInsert + */ +@Data +public class GraphRelationInsert { + + @ApiModelProperty(value = "空间名称", example = "movies", required = true) + private String space; + + @ApiModelProperty(value = "开始标签", required = true) + private String tagStart; + + @ApiModelProperty(value = "边类型", required = true) + private String edge; + + @ApiModelProperty(value = "结束标签", required = true) + private String tagEnd; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowAttribute.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowAttribute.java new file mode 100644 index 00000000..ad535c7a --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowAttribute.java @@ -0,0 +1,28 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("查询相关属性入参") +public class GraphShowAttribute { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = false) + private String space; + /** + * attributes: spaces/tags/edges + **/ + @ApiModelProperty(value = "attribute可选值:spaces空间/tags标签/edges边类型", example = "spaces", required = true) + private String attribute; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowIndex.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowIndex.java new file mode 100644 index 00000000..267dc8d5 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowIndex.java @@ -0,0 +1,27 @@ +package com.supervision.nebula.dto.graph; + +import com.supervision.nebula.dto.PageBeanDto; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.*; + +@EqualsAndHashCode(callSuper = true) +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("查询索引入参") +public class GraphShowIndex extends PageBeanDto { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + /** + * attribute: tag/edge + **/ + @ApiModelProperty(value = "属性可选: tag/edge/fulltext", example = "tag", required = true) + private String attribute; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowInfo.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowInfo.java new file mode 100644 index 00000000..c74d845c --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphShowInfo.java @@ -0,0 +1,35 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("属性详情查询入参") +public class GraphShowInfo { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi") + private String space; + + /** + * attribute: tag /edge + **/ + @ApiModelProperty(value = "属性类型:tag/edge", example = "tag") + private String attribute; + + /** + * attributeName: tag 名称/edge 名称 + **/ + @ApiModelProperty(value = "属性名称") + private String attributeName; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphSpace.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphSpace.java new file mode 100644 index 00000000..a21cee3e --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphSpace.java @@ -0,0 +1,21 @@ +package com.supervision.nebula.dto.graph; + + +import com.supervision.nebula.dto.PageBeanDto; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("通用入参实体") +public class GraphSpace extends PageBeanDto { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateEdge.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateEdge.java new file mode 100644 index 00000000..201b616d --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateEdge.java @@ -0,0 +1,48 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("修改边入参") +public class GraphUpdateEdge { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "边类型edge名称", example = "e1", required = true) + private String edgeName; + + @ApiModelProperty(value = "边类型edge属性集合", required = false) + private List edgeList; + + @ApiModelProperty(value = "点的起始VID", required = true) + private Object srcVid; + + @ApiModelProperty(value = "点的目的VID", required = true) + private Object dstVid; + + @ApiModelProperty(value = "边edge的属性值集合", required = false) + private List edgeValueList; +} + + + + + + + + + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateSpace.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateSpace.java new file mode 100644 index 00000000..1a12d449 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateSpace.java @@ -0,0 +1,26 @@ +package com.supervision.nebula.dto.graph; + + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("修改空间备注入参实体") +public class GraphUpdateSpace { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "空间中文名称", example = "空间中文名称", required = true) + private String spaceChineseName; + + @ApiModelProperty(value = "空间备注", example = "备注信息", required = true) + private String spaceComment; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateTagColor.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateTagColor.java new file mode 100644 index 00000000..2bf48db9 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateTagColor.java @@ -0,0 +1,31 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("修改tag颜色入参") +public class GraphUpdateTagColor { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi") + private String space; + + @ApiModelProperty(value = "类型: tag/edge", example = "tag") + private String type; + + @ApiModelProperty(value = "tag/edge名称", example = "demo") + private String tagEdgeName; + + @ApiModelProperty(value = "颜色") + private String color; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateVertex.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateVertex.java new file mode 100644 index 00000000..d4c288e3 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphUpdateVertex.java @@ -0,0 +1,38 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("修改点入参") +public class GraphUpdateVertex { + + /** + * 空间名称 + **/ + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "标签tag名称", example = "t1", required = true) + private String tagName; + + @ApiModelProperty(value = "标签tag属性集合", required = true) + private List tagList; + /** + * point的key + **/ + @ApiModelProperty(value = "点的VID", example = "11", required = true) + private Object pointKey; + + @ApiModelProperty(value = "标签tag的属性值集合", required = true) + private List tagValueList; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexAnalysisResult.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexAnalysisResult.java new file mode 100644 index 00000000..34c919dd --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexAnalysisResult.java @@ -0,0 +1,24 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("归因分析查询入参") +public class GraphVertexAnalysisResult { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "查询关键字集合", required = true) + private List wordList; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexAnalysisWord.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexAnalysisWord.java new file mode 100644 index 00000000..f0fc1576 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexAnalysisWord.java @@ -0,0 +1,22 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("解析文字入参") +public class GraphVertexAnalysisWord { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "查询关键字", required = true) + private String word; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexFullQuery.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexFullQuery.java new file mode 100644 index 00000000..699161af --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexFullQuery.java @@ -0,0 +1,30 @@ +package com.supervision.nebula.dto.graph; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("全文检索") +public class GraphVertexFullQuery { + + @ApiModelProperty(value = "空间名称", example = "movies", required = true) + private String space; + + @ApiModelProperty(value = "查询关键字", required = true) + private String word; + + @ApiModelProperty(value = "标签集合", required = false) + private List tagList; + + @ApiModelProperty(value = "查询最大条数", required = true) + private Integer resultSize; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexPathQuery.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexPathQuery.java new file mode 100644 index 00000000..f48a529b --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexPathQuery.java @@ -0,0 +1,65 @@ +package com.supervision.nebula.dto.graph; + +import cn.hutool.core.util.StrUtil; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("路径检索") +public class GraphVertexPathQuery { + + @ApiModelProperty(value = "空间名称", example = "movies", required = true) + private String space; + + @ApiModelProperty(value = "路径查找类型: SHORTEST最短 | ALL所有 | NOLOOP非循环", example = "ALL", required = true) + private String pathType; + + @ApiModelProperty(value = "变类型集合", required = true) + private List edgeList; + + @ApiModelProperty(value = "点的起始VID", required = true) + private List srcVid; + + @ApiModelProperty(value = "点的目的VID", required = true) + private List dstVid; + + @ApiModelProperty(value = "查询方向: REVERSELY反向 | BIDIRECT双向 | 空 正向", example = "BIDIRECT", required = true) + private String direct; + + @ApiModelProperty(value = "最大步数", example = "3", required = true) + private Integer step; + + @ApiModelProperty(value = "查询最大条数", required = true) + private Integer resultSize; + + @ApiModelProperty(value = "筛选条件", required = true) + private String condition; + + public String getEdgeList() { + StringBuffer stringBuffer = new StringBuffer(); + for (int i = 0; i < edgeList.size(); i++) { + String edge = edgeList.get(i); + stringBuffer.append("`").append(edge).append("`"); + if (edgeList.size() > 1 && (i + 1) != edgeList.size()) { + stringBuffer.append(","); + } + } + return stringBuffer.toString(); + } + + public String getCondition() { + if (StrUtil.isNotBlank(condition)) { + return "WHERE " + condition; + } + return ""; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexTatAttributeQuery.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexTatAttributeQuery.java new file mode 100644 index 00000000..674b60ac --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexTatAttributeQuery.java @@ -0,0 +1,42 @@ +package com.supervision.nebula.dto.graph; + +import cn.hutool.core.util.StrUtil; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.validation.constraints.Max; +import javax.validation.constraints.Min; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("根据tag标签查询点入参实体") +public class GraphVertexTatAttributeQuery { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + @ApiModelProperty(value = "标签", example = "t1", required = true) + private String tag; + + @ApiModelProperty(value = "执行条件", required = true) + private String condition; + + @ApiModelProperty(value = "结果条数", example = "100", required = true) + @Max(Integer.MAX_VALUE) + @Min(1) + private Integer resultSize = Integer.MAX_VALUE; + + + public String getCondition() { + if (StrUtil.isNotBlank(condition)) { + return " where " + condition; + } + return ""; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexTatsQuery.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexTatsQuery.java new file mode 100644 index 00000000..bb783fa3 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/GraphVertexTatsQuery.java @@ -0,0 +1,29 @@ +package com.supervision.nebula.dto.graph; + + +import com.supervision.nebula.dto.PageBeanDto; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +@ApiModel("根据tag标签查询点入参实体") +public class GraphVertexTatsQuery extends PageBeanDto { + + @ApiModelProperty(value = "空间名称", example = "flceshi", required = true) + private String space; + + //@ApiModelProperty(value = "标签集合", required = false) + //private List tagList; + @ApiModelProperty(value = "标签", required = false) + private String tag; + + @ApiModelProperty(value = "点id", required = false) + private Object pointKey; +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/NodeType.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/NodeType.java new file mode 100644 index 00000000..a078ddeb --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/NodeType.java @@ -0,0 +1,38 @@ +package com.supervision.nebula.dto.graph; + +import cn.hutool.core.map.MapUtil; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; + +import java.io.Serializable; +import java.util.HashMap; +import java.util.Map; + +/** + * 图可视化-展示样式 + * + * @author fulin + * @since 2022/5/9 15:44 + */ +@Data +@Builder +@AllArgsConstructor +public class NodeType implements Serializable { + private String id; + private String label; + private Map style; + + public NodeType() { + super(); + } + + public NodeType(String tagStart, String color) { + this.id = tagStart; + this.label = tagStart; + HashMap style = MapUtil.newHashMap(); + style.put("size", "50"); + style.put("fill", color); + this.style = style; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/PropertyBean.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/PropertyBean.java new file mode 100644 index 00000000..0aa6e676 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/dto/graph/PropertyBean.java @@ -0,0 +1,53 @@ +package com.supervision.nebula.dto.graph; + +import cn.hutool.core.util.ObjectUtil; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @Descriptin: + * @ClassName: PropertyBean + */ +@ApiModel("属性实体") +@Data +public class PropertyBean { + + /** + * 属性名称 + **/ + @ApiModelProperty(value = "tag/edge属性名称", example = "name", required = true) + private String propertyName; + /** + * 属性类型 (int bool string double .........) + **/ + @ApiModelProperty(value = "tag/edge属性类型可选:int bool string double", example = "string", required = true) + private String propertyType; + /** + * 属性描述 + **/ + @ApiModelProperty(value = "属性描述", example = "名称") + private String propertyComment; + + /** + * 是否可为空 (NOT NULL 或者 NULL) + **/ + @ApiModelProperty(value = "是否可为空: NOT NULL 或者 NULL", example = "NULL") + private String isNull; + + /** + * 默认值 + **/ + @ApiModelProperty(value = "默认值", example = "NULL") + private Object defaultValue; + + public Object getDefaultValue() { + if (!ObjectUtil.isNull(defaultValue)) { + if (defaultValue instanceof String) { + return "DEFAULT '" + defaultValue + "'"; + } + return "DEFAULT " + defaultValue; + } + return defaultValue; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/entity/GraphFile.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/entity/GraphFile.java new file mode 100644 index 00000000..8c69919e --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/entity/GraphFile.java @@ -0,0 +1,48 @@ +package com.supervision.nebula.entity; + +import lombok.Data; + +import java.io.Serializable; +import java.util.Date; + +/** + * (GraphFile)实体类 + * + * @author makejava + * @since 2022-08-23 09:09:27 + */ +@Data +public class GraphFile implements Serializable { + private static final long serialVersionUID = -70939095818612018L; + /** + * 文件id + */ + private Integer id; + /** + * 上传用户id + */ + private Integer userId; + /** + * 文件名称 + */ + private String fileName; + /** + * 文件路径 + */ + private String filePath; + /** + * 创建时间 + */ + private Date createdTime; + /** + * 文件大小 + */ + private String fileSize; + /** + * 保留2 + */ + private String extend; + + +} + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/exception/GraphExecuteException.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/exception/GraphExecuteException.java new file mode 100644 index 00000000..a919bac3 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/exception/GraphExecuteException.java @@ -0,0 +1,26 @@ +package com.supervision.nebula.exception; + +/** + * @author fulin by 2022/3/25 + */ +public class GraphExecuteException extends RuntimeException { + public GraphExecuteException() { + } + + public GraphExecuteException(String message) { + super(message); + } + + public GraphExecuteException(String message, Throwable cause) { + super(message, cause); + } + + public GraphExecuteException(Throwable cause) { + super(cause); + } + + public GraphExecuteException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/service/AttributeService.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/AttributeService.java new file mode 100644 index 00000000..2a63bd7a --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/AttributeService.java @@ -0,0 +1,177 @@ +package com.supervision.nebula.service; + + +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.map.MapUtil; +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.util.StrUtil; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.github.pagehelper.Page; +import com.github.pagehelper.PageInfo; +import com.supervision.nebula.constant.AttributeEnum; +import com.supervision.nebula.dto.graph.*; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.AttributeVo; +import com.supervision.nebula.vo.CommonVo; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.util.HashMap; +import java.util.List; + +/** + * @Descriptin: 属性操作 + * @ClassName: AttributeService + */ +@Service +@RequiredArgsConstructor +public class AttributeService { + + private final GraphCommonService graphCommonService; + + /** + * @return java.util.List + * @Description 属性列表查询增加tag颜色, 增加tag子属性 + * @Param [graphShowAttribute] + **/ + public List showAttribute(GraphShowAttribute graphShowAttribute) { + List list = graphCommonService.executeJson(NebulaUtil.showAttributes(graphShowAttribute), AttributeVo.class); + if (CollUtil.isNotEmpty(list)) { + if (AttributeEnum.TAGS.name().equalsIgnoreCase(graphShowAttribute.getAttribute())) { + list.forEach(attributeVo -> { + attributeVo.getData().forEach(dataBean -> { + String tag = dataBean.getRow().get(0); + GraphShowInfo graphShowInfo = GraphShowInfo.builder().space(graphShowAttribute.getSpace()) + .attribute("tag").attributeName(tag).build(); + List attributeVoList = graphCommonService.executeJson(NebulaUtil.showAttributeInfo(graphShowInfo), AttributeVo.class); + AttributeVo attributeVoSon = attributeVoList.get(0); + dataBean.getRow().add(JSONUtil.toJsonStr(attributeVoSon)); + }); + attributeVo.getColumns().add("sonTagAttributeVo"); + }); + //} + } + if (AttributeEnum.EDGES.name().equalsIgnoreCase(graphShowAttribute.getAttribute())) { + list.forEach(attributeVo -> { + attributeVo.getData().forEach(dataBean -> { + GraphShowInfo graphShowInfo = GraphShowInfo.builder().space(graphShowAttribute.getSpace()) + .attribute("edge").attributeName(dataBean.getRow().get(0)).build(); + List attributeVoList = graphCommonService.executeJson(NebulaUtil.showAttributeInfo(graphShowInfo), AttributeVo.class); + AttributeVo attributeVoSon = attributeVoList.get(0); + dataBean.getRow().add(JSONUtil.toJsonStr(attributeVoSon)); + }); + attributeVo.getColumns().add("sonEdgeAttributeVo"); + }); + } + } + return list; + } + + /** + * @return java.util.List + * @Description 删除属性，如果有索引，将索引也删除 + * @Param [graphDropAttribute] + **/ + public List dropAttribute(GraphDropAttribute graphDropAttribute) { + if (!"space".equalsIgnoreCase(graphDropAttribute.getAttribute())) { + graphCommonService.executeJson(NebulaUtil.dropIndex(graphDropAttribute), CommonVo.class); + } + return graphCommonService.executeJson(NebulaUtil.dropAttribute(graphDropAttribute), CommonVo.class); + } + + /** + * @return com.github.pagehelper.PageInfo + * @Description 属性分页查询 + * @Param [graphPageAttribute] + **/ + public PageInfo pageListAttribute(GraphPageAttribute graphPageAttribute) { + List attributeVoList = graphCommonService.executeJson(NebulaUtil.showAttributes(new GraphShowAttribute(graphPageAttribute.getSpace(), graphPageAttribute.getAttribute())), AttributeVo.class); + AttributeVo attributeVo = attributeVoList.get(0); + + List data = attributeVo.getData(); + if (CollectionUtil.isNotEmpty(data)) { + return startPage(data, graphPageAttribute.getPageNum(), graphPageAttribute.getPageSize()); + } + return new PageInfo<>(); + } + + public PageInfo startPage(List list, Integer pageNum, Integer pageSize) { + //创建Page类 + Page page = new Page<>(pageNum, pageSize); + //为Page类中的total属性赋值 + page.setTotal(list.size()); + //计算当前需要显示的数据下标起始值 + int startIndex = (pageNum - 1) * pageSize; + int endIndex = Math.min(startIndex + pageSize, list.size()); + //从链表中截取需要显示的子链表，并加入到Page + page.addAll(list.subList(startIndex, endIndex)); + //以Page创建PageInfo + return new PageInfo<>(page); + } + + /** + * @return java.util.List + * @Description 增加属性的子属性 + * @Param [graphAddAttribute] + **/ + public List addAttributeProperty(GraphAddAttribute graphAddAttribute) { + return graphCommonService.executeJson(NebulaUtil.addAttributeProperty(graphAddAttribute), CommonVo.class); + } + + /** + * @return java.util.List + * @Description 属性的子属性查询 + * @Param [graphShowInfo] + **/ + public List showAttributeInfo(GraphShowInfo graphShowInfo) { + return graphCommonService.executeJson(NebulaUtil.showAttributeInfo(graphShowInfo), AttributeVo.class); + } + + private void cover(List attributeVoList) { + if (CollectionUtil.isEmpty(attributeVoList)) { + return; + } + AttributeVo attributeVo = attributeVoList.get(0); + if (ObjectUtil.isNull(attributeVo)) { + return; + } + List data = attributeVo.getData(); + List columns = attributeVo.getColumns(); + HashMap> stringListHashMap = MapUtil.newHashMap(); + List valueList = CollectionUtil.newArrayList(); + String key = columns.get(0); + for (AttributeVo.DataBean datum : data) { + String value = datum.getRow().get(0); + valueList.add(value); + } + stringListHashMap.put(key, valueList); + attributeVo.setFieldMap(stringListHashMap); + } + + public List showCreateAttributeInfo(GraphShowInfo graphShowInfo) { + List attributeVoList = graphCommonService.executeJson(NebulaUtil.showCreateAttributeInfo(graphShowInfo), AttributeVo.class); + if (CollUtil.isNotEmpty(attributeVoList)) { + for (AttributeVo attributeVo : attributeVoList) { + for (AttributeVo.DataBean datum : attributeVo.getData()) { + attributeVo.getColumns().add("comment"); + String row = datum.getRow().get(1); + String substring = row.substring(row.lastIndexOf(",") + 1); + if (StrUtil.isNotBlank(substring)) { + String replaceAll = substring.replace("=", ":"); + String result = "{" + replaceAll + "}"; + JSONObject entries = JSONUtil.parseObj(JSONUtil.toJsonStr(result)); + if (entries.containsKey("comment")) { + Object comment = entries.get("comment"); + datum.getRow().add(comment.toString()); + } else { + datum.getRow().add(""); + } + } + } + } + } + return attributeVoList; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/service/GraphCommonService.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/GraphCommonService.java new file mode 100644 index 00000000..e8f80177 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/GraphCommonService.java @@ -0,0 +1,67 @@ +package com.supervision.nebula.service; + +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.supervision.nebula.dto.graph.GraphShowInfo; +import com.supervision.nebula.exception.GraphExecuteException; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.AttributeVo; +import com.vesoft.nebula.client.graph.exception.IOErrorException; +import com.vesoft.nebula.client.graph.net.Session; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; + +import java.util.List; + +/** + * 图数据库语句执行 + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class GraphCommonService { + + private final Session session; + + public List executeJson(String gql, Class voClass) { + try { + log.info("执行 executeJson 方法，gql={}", gql); + final String data = session.executeJson(gql); + final JSONObject jsonObject = JSONUtil.parseObj(data); + // 查询语句异常分析, 根据 json 返回结果解析 error 节点信息 + final JSONObject error0 = jsonObject.getJSONArray("errors").getJSONObject(0); + final Integer code = error0.getInt("code"); + if (code != 0) { + throw new GraphExecuteException("execute gql error, gql: " + gql + + " ,code:" + code + ", message:" + error0.getStr("message")); + } + JSONArray results = JSONUtil.parseArray(jsonObject.get("results")); + log.info("返回结果: {}", results); + return JSONUtil.toList(results, voClass); + } catch (IOErrorException e) { + log.error("executeJson ql[{}] error, msg [{}]", gql, e.getMessage()); + throw new GraphExecuteException("execute gql error, gql: " + gql, e); + } + } + + public String executeJson(String gql) { + try { + log.info("执行 executeJson 方法，gql={}", gql); + return session.executeJson(gql); + } catch (IOErrorException e) { + log.error("executeJson ql[{}] error, msg [{}]", gql, e.getMessage()); + throw new GraphExecuteException("execute gql error, gql: " + gql, e); + } + } + + public String getVidType(String space) { + List spaceList = executeJson(NebulaUtil.showAttributeInfo(GraphShowInfo.builder() + .attribute("space").attributeName(space).space(space).build()), AttributeVo.class); + AttributeVo attributeVo = spaceList.get(0); + AttributeVo.DataBean dataBean = attributeVo.getData().get(0); + return dataBean.getRow().get(6); + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/service/GraphFileService.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/GraphFileService.java new file mode 100644 index 00000000..cf9a704d --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/GraphFileService.java @@ -0,0 +1,35 @@ +package com.supervision.nebula.service; + +import com.supervision.nebula.dto.ImportBean; +import com.supervision.nebula.entity.GraphFile; +import org.springframework.web.multipart.MultipartFile; + +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; + +/** + * (GraphFile)表服务接口 + * + * @author makejava + * @since 2022-08-23 09:09:27 + */ +public interface GraphFileService { + + /** + * 上传文件 + * + * @param multipartFile 文件 + * @return 实例对象 + */ + GraphFile uploadFile(MultipartFile multipartFile); + + boolean importFile(ImportBean importBean) throws IOException; + + /** + * 模板下载 + * + * @return void + * @Param [space] + **/ + void template(String space, HttpServletResponse response); +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/service/SpaceService.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/SpaceService.java new file mode 100644 index 00000000..cbffc328 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/SpaceService.java @@ -0,0 +1,73 @@ +package com.supervision.nebula.service; + +import cn.hutool.core.collection.CollectionUtil; +import com.supervision.nebula.constant.AttributeEnum; +import com.supervision.nebula.dto.graph.GraphCreateSpace; +import com.supervision.nebula.dto.graph.GraphShowAttribute; +import com.supervision.nebula.dto.graph.GraphShowInfo; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.AttributeVo; +import com.supervision.nebula.vo.CommonVo; +import com.supervision.nebula.vo.DetailSpace; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.util.List; + +/** + * @Descriptin: 图空间 + * @ClassName: SpaceService + */ +@Service +@RequiredArgsConstructor +public class SpaceService { + + private final GraphCommonService graphCommonService; + + public List createSpace(GraphCreateSpace graphCreateSpace) { + return graphCommonService.executeJson(NebulaUtil.createSpace(graphCreateSpace), CommonVo.class); + } + + public List detailSpace(GraphShowAttribute graphShowAttribute) { + + // 所有图空间 + List spacesList = graphCommonService.executeJson(NebulaUtil.showAttributes(graphShowAttribute), AttributeVo.class); + AttributeVo attributeVo1 = spacesList.get(0); + + List detailSpaceList = CollectionUtil.newArrayList(); + + DetailSpace detailSpace = null; + for (AttributeVo.DataBean datum : attributeVo1.getData()) { + int tagsNum = 0; + int edgesNum = 0; + detailSpace = new DetailSpace(); + // 查询tags/edges + String spaceName = datum.getRow().get(0); + graphShowAttribute.setSpace(spaceName); + graphShowAttribute.setAttribute(AttributeEnum.TAGS.name()); + List tagsList = graphCommonService.executeJson(NebulaUtil.showAttributes(graphShowAttribute), AttributeVo.class); + + AttributeVo attributeVoTag = tagsList.get(0); + for (AttributeVo.DataBean attributeVoTagDatum : attributeVoTag.getData()) { + tagsNum += attributeVoTagDatum.getRow().size(); + } + graphShowAttribute.setAttribute(AttributeEnum.EDGES.name()); + List edgesList = graphCommonService.executeJson(NebulaUtil.showAttributes(graphShowAttribute), AttributeVo.class); + for (AttributeVo.DataBean dataBean : edgesList.get(0).getData()) { + edgesNum += dataBean.getRow().size(); + } + detailSpace.setSpace(spaceName); + detailSpace.setTagsNum(tagsNum); + detailSpace.setEdgesNum(edgesNum); + detailSpaceList.add(detailSpace); + } + + return detailSpaceList; + } + + public List spaceInfo(String space) { + return graphCommonService.executeJson(NebulaUtil.showAttributeInfo(GraphShowInfo.builder() + .attribute("space").attributeName(space).space(space).build()), AttributeVo.class); + } + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/service/TaskService.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/TaskService.java new file mode 100644 index 00000000..93ae57e6 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/TaskService.java @@ -0,0 +1,31 @@ +package com.supervision.nebula.service; + +import cn.hutool.core.date.DateUtil; +import com.supervision.nebula.vo.AttributeVo; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Component; + +/** + * @author fulin + * @since 2023/1/29 16:14 + */ +@Component +@Slf4j +@RequiredArgsConstructor +public class TaskService { + + private final GraphCommonService graphCommonService; + + /** + * 每天运行一次,保证session不过期 + * + * @author fulin 2023/1/29 16:20 + */ + @Scheduled(cron = "0 0 23 * * ?") + public void nebulaNotExpired() { + graphCommonService.executeJson("SHOW SPACES;", AttributeVo.class); + log.info("延续session不过期:{}", DateUtil.now()); + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/service/VertexService.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/VertexService.java new file mode 100644 index 00000000..d4082830 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/VertexService.java @@ -0,0 +1,94 @@ +package com.supervision.nebula.service; + +import cn.hutool.core.bean.BeanUtil; +import cn.hutool.core.map.MapUtil; +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.util.RandomUtil; +import cn.hutool.core.util.StrUtil; +import com.supervision.nebula.dto.NebulaVertexJsonResult; +import com.supervision.nebula.dto.graph.GraphExpand; +import com.supervision.nebula.dto.graph.GraphSpace; +import com.supervision.nebula.dto.graph.GraphVertexTatAttributeQuery; +import com.supervision.nebula.dto.graph.GraphVertexTatsQuery; +import com.supervision.nebula.util.NebulaUtil; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Map; + +/** + * @Descriptin: 点实现类 + * @ClassName: VertexService + */ +@Service +@Slf4j +@RequiredArgsConstructor +public class VertexService { + + private final GraphCommonService graphCommonService; + + public List vertexList(String space) { + return graphCommonService.executeJson(NebulaUtil.queryMatch(space), NebulaVertexJsonResult.class); + } + + public List vertexExpandQuery(GraphExpand graphExpand) { + String vidType = graphCommonService.getVidType(graphExpand.getSpace()); + return graphCommonService.executeJson(NebulaUtil.expandQuery(graphExpand, vidType), NebulaVertexJsonResult.class); + } + + /** + * tag查询 + */ + public List vertexTagsQuery(GraphVertexTatsQuery graphVertexTatsQuery) { + String vidType = graphCommonService.getVidType(graphVertexTatsQuery.getSpace()); + return graphCommonService.executeJson(NebulaUtil.vertexTagsQuery(graphVertexTatsQuery, vidType), NebulaVertexJsonResult.class); + } + + /** + * tag根据属性查询 + */ + public List vertexTagAttributeQuery(GraphVertexTatAttributeQuery graphVertexTatAttributeQuery) { + return graphCommonService.executeJson(NebulaUtil.vertexTagAttributeQuery(graphVertexTatAttributeQuery), NebulaVertexJsonResult.class); + } + + /** + * 点分页查询 + */ + public Map vertexPage(GraphVertexTatsQuery graphVertexTatsQuery) { + List list; + List countList; + if (StrUtil.isNotBlank(graphVertexTatsQuery.getTag()) || ObjectUtil.isNotNull(graphVertexTatsQuery.getPointKey())) { + String vidType = graphCommonService.getVidType(graphVertexTatsQuery.getSpace()); + list = graphCommonService.executeJson(NebulaUtil.vertexTagsQueryPage(graphVertexTatsQuery, vidType), NebulaVertexJsonResult.class); + countList = graphCommonService.executeJson(NebulaUtil.vertexTagsQuery(graphVertexTatsQuery, vidType), NebulaVertexJsonResult.class); + } else { + GraphSpace graphSpace = new GraphSpace(); + BeanUtil.copyProperties(graphVertexTatsQuery, graphSpace); + list = graphCommonService.executeJson(NebulaUtil.vertexPage(graphSpace), NebulaVertexJsonResult.class); + countList = graphCommonService.executeJson(NebulaUtil.queryMatch(graphVertexTatsQuery.getSpace()), NebulaVertexJsonResult.class); + } + + int size = countList.get(0).getData().size(); + Map result = MapUtil.newHashMap(); + result.put("list", list); + result.put("count", size); + return result; + } + + /** + * 获取随机点列表 + */ + public List randomList(GraphSpace graphSpace) { + + String space = graphSpace.getSpace(); + List list = graphCommonService.executeJson(NebulaUtil.queryMatchLimit(space), NebulaVertexJsonResult.class); + NebulaVertexJsonResult nebulaVertexJsonResult = list.get(0); + List nebulaVertexJsonResultData = nebulaVertexJsonResult.getData(); + + nebulaVertexJsonResultData = RandomUtil.randomEleList(nebulaVertexJsonResultData, 10); + nebulaVertexJsonResult.setData(nebulaVertexJsonResultData); + return list; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/service/impl/GraphFileServiceImpl.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/impl/GraphFileServiceImpl.java new file mode 100644 index 00000000..22179d93 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/service/impl/GraphFileServiceImpl.java @@ -0,0 +1,320 @@ +package com.supervision.nebula.service.impl; + +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.convert.Convert; +import cn.hutool.core.date.DateUtil; +import cn.hutool.core.io.FileUtil; +import cn.hutool.core.map.MapUtil; +import cn.hutool.core.text.csv.*; +import cn.hutool.core.util.CharsetUtil; +import cn.hutool.core.util.RandomUtil; +import cn.hutool.core.util.ZipUtil; +import com.supervision.nebula.constant.AttributeEnum; +import com.supervision.nebula.dto.*; +import com.supervision.nebula.dto.graph.GraphShowAttribute; +import com.supervision.nebula.dto.graph.GraphShowInfo; +import com.supervision.nebula.entity.GraphFile; +import com.supervision.nebula.exception.GraphExecuteException; +import com.supervision.nebula.service.AttributeService; +import com.supervision.nebula.service.GraphCommonService; +import com.supervision.nebula.service.GraphFileService; +import com.supervision.nebula.util.NebulaUtil; +import com.supervision.nebula.vo.AttributeVo; +import lombok.SneakyThrows; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.multipart.MultipartFile; +import org.yaml.snakeyaml.DumperOptions; +import org.yaml.snakeyaml.Yaml; + +import javax.servlet.http.HttpServletResponse; +import java.io.*; +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +/** + * (GraphFile)表服务实现类 + * + * @author makejava + * @since 2022-08-23 09:09:27 + */ +@Service("graphFileService") +@Slf4j +public class GraphFileServiceImpl implements GraphFileService { + + private static final String demoName = "示例导入.zip"; + private static final String VID = ":VID(string)"; + private static final String SRC_VID = ":SRC_VID(string)"; + private static final String DST_VID = ":DST_VID(string)"; + @Autowired + AttributeService attributeService; + @Autowired + GraphCommonService graphCommonService; + @Value("${path.uploadFilePath}") + private String filePath; + @Value("${path.importerPath}") + private String importerPath; + + /** + * 上传文件 + * 仅仅记录文件位置,其中解析仅仅是为了预览数据 + * + * @param multipartFile 文件 + * @return 实例对象 + */ + @Override + @Transactional(rollbackFor = Exception.class) + public GraphFile uploadFile(MultipartFile multipartFile) { + if (multipartFile.isEmpty()) { + throw new GraphExecuteException("文件为空"); + } + + String fileName = multipartFile.getOriginalFilename(); + String suffix = fileName.substring(fileName.lastIndexOf(".") + 1); + if (!"csv".equalsIgnoreCase(suffix)) { + throw new GraphExecuteException("文件格式不支持"); + } + + Integer userId = Integer.parseInt("1"); + String uploadFilePath = filePath + "/" + userId; + //判断路径是否存在，不存在则创建 + makeDir(uploadFilePath); + + File file = new File(uploadFilePath, fileName); + try { + multipartFile.transferTo(file); + } catch (IOException e) { + throw new GraphExecuteException("文件读写异常"); + } + + GraphFile graphFile = new GraphFile(); + graphFile.setUserId(userId); + graphFile.setFileName(fileName); + graphFile.setFilePath(uploadFilePath + "/" + fileName); + graphFile.setFileSize(file.length() + "B"); + graphFile.setCreatedTime(DateUtil.date()); + + //从文件中读取CSV数据 + CsvReader reader = CsvUtil.getReader(); + CsvData data = reader.read(file, StandardCharsets.UTF_8); + List rows = data.getRows(); + return graphFile; + } + + @SneakyThrows + @Override + public boolean importFile(ImportBean importBean) { + + long start = System.currentTimeMillis(); + String randomString = RandomUtil.randomString(6); + String fileName = String.format("%s-%s", importBean.getSpace(), randomString); + //客户端配置 + TemplateBean templateBean = new TemplateBean(); + String logPath = filePath + "/logFile"; + makeDir(logPath); + String logFile = String.format("%s/%s.log", logPath, fileName); + templateBean.setLogPath(logFile); + TemplateBean.ClientSettings clientSettings = new TemplateBean.ClientSettings(); + clientSettings.setConnection(new TemplateBean.Connection()); + clientSettings.setSpace(importBean.getSpace()); + templateBean.setClientSettings(clientSettings); + //文件配置 + List fileList = new ArrayList<>(); + // 点 + getVertex(importBean, fileList); + //边 + getEdge(importBean, fileList); + templateBean.setFiles(fileList); + String yamlFilePath = filePath + "/yamlFile"; + makeDir(yamlFilePath); + DumperOptions dumperOptions = new DumperOptions(); + dumperOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK); + Yaml yaml = new Yaml(dumperOptions); + String yamlFile = String.format("%s/%s.yaml", yamlFilePath, fileName); + yaml.dump(templateBean, new FileWriter(yamlFile)); + Process exec = Runtime.getRuntime().exec("./nebula-importer --config " + yamlFile, null, new File(importerPath)); + + if (exec.waitFor() < 0) {// 等待执行完成 + return false; + } + long end = System.currentTimeMillis(); + + if (!FileUtil.exist(new File(logFile))) { + return false; + } + + // 执行日志内容 + BufferedReader br = new BufferedReader(new InputStreamReader(Files.newInputStream(Paths.get(logFile)), StandardCharsets.UTF_8)); + String line; + StringBuilder content = new StringBuilder(); + while ((line = br.readLine()) != null) { + content.append(line).append("\n"); + } + return true; + } + + /** + * 模板下载 + * + * @return void + * @Param [space] + **/ + @Override + public void template(String space, HttpServletResponse response) { + + Map> tagMap = MapUtil.newHashMap(); + Map> edgeMap = MapUtil.newHashMap(); + + // 查询所有tag edges + GraphShowAttribute graphShowAttribute = new GraphShowAttribute(space, AttributeEnum.TAGS.name()); + List tagList = graphCommonService.executeJson(NebulaUtil.showAttributes(graphShowAttribute), AttributeVo.class); + + graphShowAttribute.setAttribute(AttributeEnum.EDGES.name()); + List edgeList = graphCommonService.executeJson(NebulaUtil.showAttributes(graphShowAttribute), AttributeVo.class); + + if (CollectionUtil.isEmpty(tagList.get(0).getData()) && CollectionUtil.isEmpty(edgeList.get(0).getData())) { + throw new GraphExecuteException("请先添加 模式设计 数据"); + } + + // 查询每个属性的子属性 + tagList.get(0).getData().stream().forEach(attributeVo -> { + attributeVo.getRow().forEach(row -> { + GraphShowInfo graphShowInfo = new GraphShowInfo(); + graphShowInfo.setSpace(space); + graphShowInfo.setAttributeName(row); + graphShowInfo.setAttribute("tag"); + List attributeVoList = graphCommonService.executeJson(NebulaUtil.showAttributeInfo(graphShowInfo), AttributeVo.class); + List rows = CollectionUtil.newArrayList(); + rows.add(VID); + attributeVoList.forEach(attributeVo1 -> attributeVo1.getData().forEach(dataBean -> { + String type = "int64".equalsIgnoreCase(dataBean.getRow().get(1)) ? "int" : dataBean.getRow().get(1); + rows.add(row + "." + dataBean.getRow().get(0) + ":" + type); + })); + tagMap.put(row, rows); + }); + }); + + edgeList.get(0).getData().stream().forEach(attributeVo -> { + attributeVo.getRow().forEach(row -> { + GraphShowInfo graphShowInfo = new GraphShowInfo(); + graphShowInfo.setSpace(space); + graphShowInfo.setAttributeName(row); + graphShowInfo.setAttribute("edge"); + List attributeVoList = graphCommonService.executeJson(NebulaUtil.showAttributeInfo(graphShowInfo), AttributeVo.class); + List rows = CollectionUtil.newArrayList(); + rows.add(SRC_VID); + rows.add(DST_VID); + attributeVoList.forEach(attributeVo1 -> attributeVo1.getData().forEach(dataBean -> { + String type = "int64".equalsIgnoreCase(dataBean.getRow().get(1)) ? "int" : dataBean.getRow().get(1); + rows.add(row + "." + dataBean.getRow().get(0) + ":" + type); + })); + edgeMap.put(row, rows); + }); + }); + + // 生成模板.csv + String randomNumbers = RandomUtil.randomNumbers(6); + String path = filePath + "/zipFile/" + randomNumbers; + tagMap.forEach((key, value) -> { + String fileName = "实体-" + key; + String pathname = path + "/" + fileName + ".csv"; + CsvWriter csvWriter = CsvUtil.getWriter(new File(pathname), CharsetUtil.CHARSET_UTF_8); + csvWriter.write(Convert.toStrArray(value)); + csvWriter.flush(); + csvWriter.close(); + }); + edgeMap.forEach((key, value) -> { + String fileName = "关系-" + key; + String pathname = path + "/" + fileName + ".csv"; + CsvWriter csvWriter = CsvUtil.getWriter(new File(pathname), CharsetUtil.CHARSET_UTF_8); + csvWriter.write(Convert.toStrArray(value)); + csvWriter.flush(); + csvWriter.close(); + }); + + // 压缩包zip + String zipPath = path + demoName; + ZipUtil.zip(path, zipPath, CharsetUtil.CHARSET_UTF_8, false); + FileUtil.del(path);// 删除csv源文件 + + //返回压缩包 + try { + BufferedInputStream bis; + OutputStream out = response.getOutputStream(); + response.setContentType("text/html; charset=UTF-8"); + response.setContentType("application/octet-stream"); + response.setHeader("Content-Disposition", "attachment;filename=".concat(String.valueOf(URLEncoder.encode(randomNumbers + demoName, CharsetUtil.UTF_8)))); + bis = new BufferedInputStream(Files.newInputStream(Paths.get(zipPath))); + //定义byte，长度就是要转成zip文件的byte长度，避免浪费资源 + byte[] buffer = new byte[bis.available()]; + bis.read(buffer); + out.flush(); + out.write(buffer); + } catch (IOException e) { + e.printStackTrace(); + } + + } + + private void makeDir(String logPath) { + File dir = new File(logPath); + if (!dir.exists()) { + dir.mkdirs(); + } + } + + private void getVertex(ImportBean importBean, List fileList) { + for (VertexCombo vertexCombo : importBean.getVertices()) { + TemplateBean.File file = new TemplateBean.File(); + String failDataPath = filePath + "/failDataFile"; + makeDir(failDataPath); + String randomString = RandomUtil.randomString(6); + file.setFailDataPath(String.format("%s/%s-%s", failDataPath, randomString, "DEMO")); + file.setPath("DEMO"); + file.setCsv(new TemplateBean.CSV()); + + TemplateBean.Schema schema = new TemplateBean.Schema(); + schema.setType("vertex"); + file.setSchema(schema); + fileList.add(file); + } + } + + private void getEdge(ImportBean importBean, List fileList) { + for (EdgeCombo edgeCombo : importBean.getEdges()) { + TemplateBean.File file = new TemplateBean.File(); + String failDataPath = filePath + "/failDataFile"; + makeDir(failDataPath); + String randomString = RandomUtil.randomString(6); + file.setFailDataPath(String.format("%s/%s-%s", failDataPath, randomString, "demo")); + file.setPath("demo"); + file.setCsv(new TemplateBean.CSV()); + + TemplateBean.Schema schema = new TemplateBean.Schema(); + schema.setType("edge"); + + TemplateBean.Edge edge = new TemplateBean.Edge(); + EdgeElement edgeElement = edgeCombo.getEdgeElement(); + edge.setName(edgeElement.getElementName()); +// TemplateBean.SrcDst src = new TemplateBean.SrcDst(); +// src.setIndex(edgeElement.getSrcId()); +// edge.setSrcVID(src); +// TemplateBean.SrcDst dst = new TemplateBean.SrcDst(); +// dst.setIndex(edgeElement.getDstId()); +// edge.setDstVID(dst); +// edge.setRank(edgeElement.getRank()); +// edge.setProps(getPropList(edgeElement.getProperties())); + schema.setEdge(edge); + file.setSchema(schema); + fileList.add(file); + } + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/util/NebulaUtil.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/util/NebulaUtil.java new file mode 100644 index 00000000..196f7625 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/util/NebulaUtil.java @@ -0,0 +1,896 @@ +package com.supervision.nebula.util; + + +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.util.RandomUtil; +import cn.hutool.core.util.StrUtil; +import cn.hutool.json.JSONUtil; +import com.github.pagehelper.Page; +import com.github.pagehelper.PageInfo; +import com.google.common.base.Joiner; +import com.supervision.nebula.constant.AttributeEnum; +import com.supervision.nebula.constant.EdgeDirectionEnum; +import com.supervision.nebula.dto.graph.*; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang.StringEscapeUtils; + +import java.util.List; + +@Slf4j +public class NebulaUtil { + + + /** + * @return java.lang.String + * @Description 查询 spaces/tags/edges + * @Param [GraphShowAttribute] + **/ + public static String showAttributes(GraphShowAttribute graphShowAttribute) { + + String showSpaces = ""; + if (AttributeEnum.SPACES.name().equalsIgnoreCase(graphShowAttribute.getAttribute())) { + showSpaces = String.format("SHOW %s;", graphShowAttribute.getAttribute()); + } else { + showSpaces = String.format("USE `%s`;SHOW %s;", graphShowAttribute.getSpace(), graphShowAttribute.getAttribute()); + } + + log.info("查询{}-gql语句:{}", graphShowAttribute.getAttribute(), showSpaces); + return showSpaces; + } + + + /** + * @return java.lang.String + * @Description 查询 tag/edge 索引 + * @Param [GraphShowIndex] + **/ + public static String showIndexes(GraphShowIndex graphShowIndex) { + String showIndexes = String.format("USE `%s`;SHOW %s INDEXES;", graphShowIndex.getSpace(), graphShowIndex.getAttribute()); + log.info("查询{}-gql语句:{}", graphShowIndex.getAttribute(), showIndexes); + return showIndexes; + } + + /** + * @return java.lang.String + * @Description 创建空间 + * @Param [graphCreateSpace] + **/ + public static String createSpace(GraphCreateSpace graphCreateSpace) { + String createSpace = String.format("CREATE SPACE `%s` (partition_num = %s, replica_factor = %s,vid_type = %s %s) COMMENT = '%s'", + graphCreateSpace.getSpace(), graphCreateSpace.getPartitionNum(), graphCreateSpace.getReplicaFactor(), graphCreateSpace.getFixedType(), + graphCreateSpace.getSize(), graphCreateSpace.getComment()); + log.info("创建空间-gql语句:{}", createSpace); + return createSpace; + } + + /** + * @return java.lang.String + * @Description 切换空间 + * @Param [spaceName] + **/ + public static String useSpace(String spaceName) { + String useSpace = String.format("USE `%s`;", spaceName); + log.info("切换空间-gql语句:{}", useSpace); + return useSpace; + } + + /** + * @return java.lang.String + * @Description 空间信息 + * @Param [spaceName] + **/ + public static String spaceInfo(String spaceName) { + String spaceInfo = String.format("DESCRIBE SPACE `%s`;", spaceName); + log.info("空间信息-gql语句:{}", spaceInfo); + return spaceInfo; + } + + + /** + * @return java.lang.String + * @Description 创建tag + * @Param [graphCreateTag] + **/ + public static String createTagEdge(GraphCreateTagEdge graphCreateTagEdge) { + StringBuffer stringBuffer = new StringBuffer(); + List propertyList = graphCreateTagEdge.getPropertyList(); + if (CollectionUtil.isNotEmpty(propertyList)) { + for (int i = 0; i < propertyList.size(); i++) { + + PropertyBean propertyBean = propertyList.get(i); + stringBuffer.append(" `" + propertyBean.getPropertyName() + "` " + propertyBean.getPropertyType() + " " + + "" + propertyBean.getIsNull() + " " + propertyBean.getDefaultValue() + " COMMENT '" + propertyBean.getPropertyComment() + "' "); + if (propertyList.size() > 1 && (i + 1) != propertyList.size()) { + stringBuffer.append(","); + } + } + } + String bufferString = stringBuffer.toString(); + log.info("stringBuffer :{}", bufferString); + + String createTag = "USE `" + graphCreateTagEdge.getSpace() + "`;CREATE " + graphCreateTagEdge.getType() + " `" + graphCreateTagEdge.getTagEdgeName() + "` " + + "( " + bufferString + " ) COMMENT = '" + graphCreateTagEdge.getTagEdgeComment() + "' "; + log.info("创建Tag-gql语句:{}", createTag); + return createTag; + } + + /** + * @return java.lang.String + * @Description 创建点 + * @Param [graphCreateVertex] + **/ + public static String createPoint(GraphCreateVertex graphCreateVertex, String vidType) { + List tagValueList = graphCreateVertex.getTagValueList(); + StringBuffer stringBuffer = getStringBuffer(tagValueList); + String bufferString = stringBuffer.toString(); + log.info("stringBuffer :{}", bufferString); + + StringBuffer stringBufferTagList = new StringBuffer(); + List tagList = graphCreateVertex.getTagList(); + if (CollectionUtil.isNotEmpty(tagList)) { + for (int i = 0; i < tagList.size(); i++) { + String tagPropertyName = tagList.get(i); + stringBufferTagList.append(" `" + tagPropertyName + "` "); + if (tagList.size() > 1 && (i + 1) != tagList.size()) { + stringBufferTagList.append(","); + } + } + } + Object pointKey = graphCreateVertex.getPointKey(); + if (vidType.contains("STRING")) { + pointKey = "'" + StringEscapeUtils.unescapeHtml(pointKey.toString()) + "'"; + } + + String createPoint = String.format("USE `%s`;INSERT VERTEX IF NOT EXISTS `%s`(%s) VALUES %s: (" + bufferString + ");" + , graphCreateVertex.getSpace(), graphCreateVertex.getTagName(), stringBufferTagList, + pointKey); + log.info("创建vertex-gql语句:{}", createPoint); + return createPoint; + } + + /** + * @return java.lang.String + * @Description 删除属性 + * @Param [graphCreatePoint] + **/ + public static String dropAttribute(GraphDropAttribute graphDropAttribute) { + String dropAttribute = String.format("USE `%s`;DROP %s IF EXISTS `%s`;", graphDropAttribute.getSpace(), graphDropAttribute.getAttribute(), graphDropAttribute.getAttributeName()); + log.info("删除属性-gql语句:{}", dropAttribute); + return dropAttribute; + } + + /** + * @return java.lang.String + * @Description 删除索引 + * @Param [graphDropAttribute] + **/ + public static String dropIndex(GraphDropAttribute graphDropAttribute) { + String dropIndex = String.format("USE `%s`;DROP %s INDEX IF EXISTS `%s`;", graphDropAttribute.getSpace(), graphDropAttribute.getAttribute(), graphDropAttribute.getAttributeName()); + log.info("删除索引-gql语句:{}", dropIndex); + return dropIndex; + } + + /** + * @return java.lang.String + * @Description 增加某个属性的 子属性 + * @Param [graphAddAttribute] + **/ + public static String addAttributeProperty(GraphAddAttribute graphAddAttribute) { + String addAttributeProperty = String.format("USE `%s`;ALTER %s `%s` ADD (`%s` %s %s %s %s);" + , graphAddAttribute.getSpace(), graphAddAttribute.getAttribute(), graphAddAttribute.getAttributeName(), + graphAddAttribute.getPropertyName(), graphAddAttribute.getPropertyType(), + graphAddAttribute.getIsNull(), graphAddAttribute.getDefaultValue(), graphAddAttribute.getCommon()); + log.info("增加某个属性的 子属性 -gql语句:{}", addAttributeProperty); + return addAttributeProperty; + } + + + /** + * @return java.lang.String + * @Description 删除某个属性的子属性 + * @Param [graphDelAttribute] + **/ + public static String delAttributeProperty(GraphDelAttribute graphDelAttribute) { + + StringBuffer stringBuffer = new StringBuffer(); + List propertyNameList = graphDelAttribute.getPropertyNameList(); + for (int i = 0; i < propertyNameList.size(); i++) { + String value = propertyNameList.get(i); + stringBuffer.append("`" + value + "`"); + if (propertyNameList.size() > 1 && (i + 1) != propertyNameList.size()) { + stringBuffer.append(","); + } + } + + String delAttributeProperty = String.format("USE `%s`; ALTER %s `%s` DROP (%s);" + , graphDelAttribute.getSpace(), graphDelAttribute.getAttribute(), + graphDelAttribute.getAttributeName(), stringBuffer); + log.info("删除某个属性的 子属性 -gql语句:{}", delAttributeProperty); + return delAttributeProperty; + } + + /** + * @return java.lang.String + * @Description 查询属性的 子属性列表 + * @Param [graphShowInfo] + **/ + public static String showAttributeInfo(GraphShowInfo graphShowInfo) { + String delAttributeProperty = String.format("USE `%s`; DESCRIBE %s `%s`;" + //String delAttributeProperty = String.format("USE `%s`; SHOW CREATE %s `%s`;" + , graphShowInfo.getSpace(), graphShowInfo.getAttribute(), graphShowInfo.getAttributeName()); + log.info("查询属性的 子属性列表 -gql语句:{}", delAttributeProperty); + return delAttributeProperty; + } + + /** + * @return java.lang.String + * @Description 根据某个空间下的tag标签查询所有的vertex点 + * @Param [tagList, space] 标签集合, 空间名称 + **/ + public static String queryMatch(List tagList, String space) { + StringBuffer stringBuffer = new StringBuffer(); + for (int i = 0; i < tagList.size(); i++) { + String tag = tagList.get(i); + stringBuffer.append("MATCH (v:`" + tag + "`) RETURN v limit " + Integer.MAX_VALUE + ""); + if (tagList.size() > 1 && (i + 1) != tagList.size()) { + stringBuffer.append(" UNION "); + } + } + String bufferString = stringBuffer.toString(); + log.info("bufferString: {}", bufferString); + String queryMatch = String.format("USE `%s`; " + bufferString + "", space); + log.info("match查询 -gql语句:{}", queryMatch); + return queryMatch; + } + + public static String queryMatch(String space) { + String queryMatch = String.format("USE `%s`; match (v) return v limit " + Integer.MAX_VALUE + ";", space); + log.info("match查询 -gql语句:{}", queryMatch); + return queryMatch; + } + + public static String queryMatchLimit(String space) { + String queryMatch = String.format("USE `%s`; match (v) return v limit 100 ;", space); + log.info("match查询 -gql语句:{}", queryMatch); + return queryMatch; + } + + + /** + * @return java.lang.String + * @Description 点删除 + * @Param [graphDeleteVertex] + **/ + public static String deleteVertex(GraphDeleteVertex graphDeleteVertex, String vidType) { + + Object vid = graphDeleteVertex.getVid(); + if (vidType.contains("STRING")) { + vid = "'" + vid.toString() + "'"; + } + String deleteVertex = String.format("USE `%s`; DELETE VERTEX %s;", graphDeleteVertex.getSpace(), vid); + log.info("vertex点删除 -gql语句:{}", deleteVertex); + return deleteVertex; + } + + + /** + * @return java.lang.String + * @Description vertex点删除后删除出入边 + * @Param [graphDeleteVertex] + **/ + public static String deleteVertexEdge(GraphDeleteVertex graphDeleteVertex, String vidType) { + Object vid = graphDeleteVertex.getVid(); + if (vidType.contains("STRING")) { + vid = "'" + vid.toString() + "'"; + } + String deleteVertexEdge = String.format("USE `%s`; DELETE VERTEX %s WITH EDGE;", graphDeleteVertex.getSpace(), vid); + log.info("vertex点删除后删除出入边 -gql语句:{}", deleteVertexEdge); + return deleteVertexEdge; + } + + + /** + * @return java.lang.String + * @Description 插入边(绑两点之的关系) + * @Param [graphInsertEdge] + **/ + public static String insertEdge(GraphInsertEdge graphInsertEdge, String vidType) { + List edgeValueList = graphInsertEdge.getEdgeValueList(); + StringBuffer stringBuffer = getStringBuffer(edgeValueList); + String bufferString = stringBuffer.toString(); + log.info("stringBuffer :{}", bufferString); + + Object srcVid = graphInsertEdge.getSrcVid(); + Object dstVid = graphInsertEdge.getDstVid(); + + if (vidType.contains("STRING")) { + srcVid = "'" + srcVid.toString() + "'"; + dstVid = "'" + dstVid.toString() + "'"; + } + + StringBuffer stringBufferEdge = new StringBuffer(); + for (String edge : graphInsertEdge.getEdgeList()) { + stringBufferEdge.append("`").append(edge).append("`").append(","); + } + String str = stringBufferEdge.toString(); + + String insertEdge = String.format("USE `%s`; INSERT EDGE IF NOT EXISTS `%s` (%s) VALUES %s->%s:( %s );" + , graphInsertEdge.getSpace(), graphInsertEdge.getEdgeName(), StrUtil.isNotBlank(str) ? str.substring(0, str.length() - 1) : "", + srcVid, dstVid, bufferString); + log.info("插入边 -gql语句:{}", insertEdge); + return insertEdge; + } + + /** + * @return java.lang.StringBuffer + * @Description 获取一个拼接好的字符串 "n1", 1 + * @Param [edgeValueList] + **/ + private static StringBuffer getStringBuffer(List edgeValueList) { + StringBuffer stringBuffer = new StringBuffer(); + if (CollectionUtil.isNotEmpty(edgeValueList)) { + //stringBuffer.append("("); + for (int i = 0; i < edgeValueList.size(); i++) { + Object value = edgeValueList.get(i); + if (value instanceof String) { + stringBuffer.append("'").append(StringEscapeUtils.unescapeHtml((String) value)).append("'"); + } else { + stringBuffer.append(value); + } + if (edgeValueList.size() > 1 && (i + 1) != edgeValueList.size()) { + stringBuffer.append(","); + } + } + //stringBuffer.append(")"); + } + return stringBuffer; + } + + /** + * @return java.lang.String + * @Description 删除边, 解除点的绑定关系 + * @Param [graphDeleteEdge] + **/ + public static String deleteEdge(GraphDeleteEdge graphDeleteEdge, String vidType) { + + Object srcVid = graphDeleteEdge.getSrcVid(); + Object dstVid = graphDeleteEdge.getDstVid(); + if (vidType.contains("STRING")) { + srcVid = "'" + srcVid.toString() + "'"; + dstVid = "'" + dstVid.toString() + "'"; + } + String deleteEdge = String.format("USE `%s`; DELETE EDGE `%s` %s -> %s @0;" + , graphDeleteEdge.getSpace(), graphDeleteEdge.getEdgeName(), srcVid, dstVid); + log.info("删除边 -gql语句:{}", deleteEdge); + return deleteEdge; + } + + /** + * @return java.lang.String + * @Description 查询创建的边 + * @Param [graphSpace] + **/ + public static String listEdge(GraphSpace graphSpace) { + String listEdge = String.format("USE `%s`;MATCH ()-[e]->()RETURN e LIMIT " + Integer.MAX_VALUE + " ;", graphSpace.getSpace()); + log.info("查询创建的边 -gql语句:{}", listEdge); + return listEdge; + } + + /** + * @return java.lang.String + * @Description 扩展查询 + * @Param [graphExpand] + **/ + public static String expandQuery(GraphExpand graphExpand, String vidType) { + StringBuffer stringBuffer = new StringBuffer(); + List edgeList = graphExpand.getEdgeList(); + for (int i = 0; i < edgeList.size(); i++) { + String edge = edgeList.get(i); + stringBuffer.append(":"); + stringBuffer.append("`").append(edge).append("`"); + if (edgeList.size() > 1 && (i + 1) != edgeList.size()) { + stringBuffer.append("|"); + } + } + String bufferString = stringBuffer.toString(); + log.info("bufferString:{}", bufferString); + + List leftAndRight = EdgeDirectionEnum.getLeftAndRight(graphExpand.getDirection()); + + String expandQuery = String.format("USE `%s`;MATCH p=(v) %s- [e " + bufferString + " * %s %s]-%s (v2) WHERE id(v) IN [%s] %s RETURN p LIMIT " + graphExpand.getResultSize() + ";", + graphExpand.getSpace(), leftAndRight.get(0), graphExpand.getStepStart(), graphExpand.getStepEndResult(), leftAndRight.get(1), graphExpand.getVidList(vidType), StringEscapeUtils.unescapeHtml(graphExpand.getCondition())); + log.info("扩展查询 -gql语句:{}", expandQuery); + return expandQuery; + } + + /** + * @return java.lang.String + * @Description 子图查询 + * @Param [graphExpand] + **/ + public static String subgraphQuery(GraphExpand graphExpand, String vidType) { + String direction = EdgeDirectionEnum.getDirection(graphExpand.getDirection()); + String expandQuery = String.format("USE `%s`;GET SUBGRAPH %s STEPS FROM %s %s %s YIELD VERTICES AS `vertices_`, EDGES AS `edges_`;", + graphExpand.getSpace(), graphExpand.getStepStart(), graphExpand.getVidList(vidType), direction, Joiner.on(",").join(graphExpand.getEdgeList())); + log.info("扩展查询 -gql语句:{}", expandQuery); + return expandQuery; + } + + /** + * @return java.lang.String + * @Description 根据tag标签查询点 + * @Param [graphVertexTatsQuery] + **/ + public static String vertexTagsQuery(GraphVertexTatsQuery graphVertexTatsQuery, String vidType) { + + String tag = ""; + if (StrUtil.isNotBlank(graphVertexTatsQuery.getTag())) { + tag = ":`" + graphVertexTatsQuery.getTag() + "`"; + } + + Object pointKey = graphVertexTatsQuery.getPointKey(); + if (ObjectUtil.isNotNull(pointKey)) { + if (vidType.contains("STRING")) { + pointKey = "WHERE id(v) IN ['" + pointKey.toString() + "']"; + } else { + pointKey = "WHERE id(v) IN [" + pointKey.toString() + "]"; + } + } else { + pointKey = ""; + } + + String vertexTagsQuery = String.format("USE `%s`;MATCH p=(v %s) %s return v limit " + Integer.MAX_VALUE + ";", + graphVertexTatsQuery.getSpace(), tag, pointKey); + log.info("根据tag标签查询点 -gql语句:{}", vertexTagsQuery); + return vertexTagsQuery; + } + + public static String vertexTagsQueryPage(GraphVertexTatsQuery graphVertexTatsQuery, String vidType) { + + int skip = (graphVertexTatsQuery.getPageNum() - 1) * graphVertexTatsQuery.getPageSize(); + String tag = ""; + if (StrUtil.isNotBlank(graphVertexTatsQuery.getTag())) { + tag = ":`" + graphVertexTatsQuery.getTag() + "`"; + } + + Object pointKey = graphVertexTatsQuery.getPointKey(); + if (ObjectUtil.isNotNull(pointKey)) { + if (vidType.contains("STRING")) { + pointKey = "WHERE id(v) IN ['" + pointKey.toString() + "']"; + } else { + pointKey = "WHERE id(v) IN [" + pointKey.toString() + "]"; + } + } else { + pointKey = ""; + } + + String vertexTagsQuery = String.format("USE `%s`;MATCH p=(v %s) %s return v SKIP " + skip + " limit " + graphVertexTatsQuery.getPageSize() + ";", + graphVertexTatsQuery.getSpace(),//Joiner.on(":").join(graphVertexTatsQuery.getTagList())); + tag, pointKey); + log.info("根据tag标签分页查询点 -gql语句:{}", vertexTagsQuery); + return vertexTagsQuery; + } + + /** + * @return java.lang.String + * @Description 根据tag标签属性查询点 + * @Param [graphVertexTatAttributeQuery] + **/ + public static String vertexTagAttributeQuery(GraphVertexTatAttributeQuery graphVertexTatAttributeQuery) { + String vertexTagsQuery = String.format("USE `%s`;match p=(v:`%s`) %s return v limit " + graphVertexTatAttributeQuery.getResultSize() + ";" + , graphVertexTatAttributeQuery.getSpace(), graphVertexTatAttributeQuery.getTag(), graphVertexTatAttributeQuery.getCondition()); + log.info("根据tag标签属性查询点 -gql语句:{}", vertexTagsQuery); + return vertexTagsQuery; + } + + + /** + * @return java.lang.String + * @Description 创建索引 + * @Param [graphCreateIndex] + **/ + public static String createIndex(GraphCreateIndex graphCreateIndex) { + List propertyList = CollectionUtil.newArrayList(); + for (AttributeBean attributeBean : graphCreateIndex.getAttributeBeanList()) { + propertyList.add(attributeBean.getPropertyName()); + } + String vertexTagsQuery = String.format("USE `%s`;CREATE %s INDEX `%s` on `%s`(%s) COMMENT '%s';" + , graphCreateIndex.getSpace(), graphCreateIndex.getType(), graphCreateIndex.getIndexName(), graphCreateIndex.getTagEdgeName(), + Joiner.on(",").join(propertyList), graphCreateIndex.getComment()); + log.info("创建索引 -gql语句:{}", vertexTagsQuery); + return vertexTagsQuery; + } + + public static String createFullIndex(GraphCreateIndex graphCreateIndex) { + List propertyList = CollectionUtil.newArrayList(); + for (AttributeBean attributeBean : graphCreateIndex.getAttributeBeanList()) { + propertyList.add(attributeBean.getPropertyName()); + } + String vertexTagsQuery = String.format("USE `%s`;CREATE FULLTEXT %s INDEX nebula_index_" + RandomUtil.randomNumbers(4) + " ON `%s`(name)" + , graphCreateIndex.getSpace(), graphCreateIndex.getType(), graphCreateIndex.getTagEdgeName()); + log.info("创建全文索引 -gql语句:{}", vertexTagsQuery); + return vertexTagsQuery; + } + + /** + * @return java.lang.String + * @Description 属性详细信息 + * @Param [graphShowInfo] + **/ + public static String showCreateAttributeInfo(GraphShowInfo graphShowInfo) { + String showCreateAttributeInfo = String.format("USE `%s`; SHOW CREATE %s `%s`;" + , graphShowInfo.getSpace(), graphShowInfo.getAttribute(), graphShowInfo.getAttributeName()); + log.info("查询属性的详细信息 -gql语句:{}", showCreateAttributeInfo); + return showCreateAttributeInfo; + } + + public static String showAttributePage(GraphPageAttribute graphPageAttribute) { + + int skip = (graphPageAttribute.getPageNum() - 1) * graphPageAttribute.getPageSize(); + if (AttributeEnum.TAGS.name().equalsIgnoreCase(graphPageAttribute.getAttribute())) { + String showAttributePage = String.format("USE `%s`; MATCH (v) RETURN v SKIP %s LIMIT %s;" + , graphPageAttribute.getSpace(), skip, graphPageAttribute.getPageSize()); + log.info("查询tag分页 -gql语句:{}", showAttributePage); + return showAttributePage; + } + + if (AttributeEnum.EDGES.name().equalsIgnoreCase(graphPageAttribute.getAttribute())) { + String showAttributePage = String.format("USE `%s`;MATCH ()-[e]->() RETURN e SKIP %s LIMIT %s;" + , graphPageAttribute.getSpace(), skip, graphPageAttribute.getPageSize()); + log.info("查询edge分页 -gql语句:{}", showAttributePage); + return showAttributePage; + } + return ""; + } + + public static PageInfo startPage(List list, Integer pageNum, Integer pageSize) { + //创建Page类 + Page page = new Page(pageNum, pageSize); + //为Page类中的total属性赋值 + page.setTotal(list.size()); + //计算当前需要显示的数据下标起始值 + int startIndex = (pageNum - 1) * pageSize; + int endIndex = Math.min(startIndex + pageSize, list.size()); + //从链表中截取需要显示的子链表，并加入到Page + page.addAll(list.subList(startIndex, endIndex)); + //以Page创建PageInfo + PageInfo pageInfo = new PageInfo<>(page); + return pageInfo; + } + + /** + * @return java.lang.String + * @Description 修改点tag标签属性的值 + * @Param [graphUpdateVertex] + **/ + public static String updateVertex(GraphUpdateVertex graphUpdateVertex, String vidType) { + + List tagList = graphUpdateVertex.getTagList(); + List tagValueList = graphUpdateVertex.getTagValueList(); + if (tagList.size() != tagValueList.size()) { + return ""; + } + StringBuffer stringBuffer = new StringBuffer(); + for (int i = 0; i < tagList.size(); i++) { + String tag = tagList.get(i); + Object tagValue = tagValueList.get(i); + stringBuffer.append("`").append(tag).append("`").append(" = "); + if (tagValue instanceof String) { + stringBuffer.append("'").append(tagValue).append("'"); + } else { + stringBuffer.append(tagValue); + } + if (tagList.size() > 1 && (i + 1) != tagList.size()) { + stringBuffer.append(","); + } + } + + Object pointKey = graphUpdateVertex.getPointKey(); + if (vidType.contains("STRING")) { + pointKey = "'" + pointKey.toString() + "'"; + } + + String updateVertex = String.format("USE `%s`; UPDATE VERTEX ON `%s` %s SET %s;" + , graphUpdateVertex.getSpace(), graphUpdateVertex.getTagName(), pointKey, stringBuffer); + log.info("修改点 -gql语句:{}", updateVertex); + return updateVertex; + } + + /** + * @return java.lang.String + * @Description 分页查询创建的边 + * @Param [graphPageEdge] + **/ + public static String edgePage(GraphPageEdge graphPageEdge) { + String edge = ""; + if (StrUtil.isNotBlank(graphPageEdge.getEdge())) { + edge = ":`" + graphPageEdge.getEdge() + "`"; + } + int skip = (graphPageEdge.getPageNum() - 1) * graphPageEdge.getPageSize(); + String edgePage; + if (StrUtil.isBlank(graphPageEdge.getVid())) { + edgePage = String.format("USE `%s`;MATCH ()-[e %s]->()RETURN e SKIP " + skip + + " LIMIT " + graphPageEdge.getPageSize() + " ;", graphPageEdge.getSpace(), edge); + } else { + edgePage = String.format("USE `%s`;MATCH (m)-[e %s]->(n) where id(m)=='%s' RETURN e " + + "UNION MATCH (m)-[e %s]->(n) where id(n)=='%s' RETURN e SKIP " + skip + + " LIMIT " + graphPageEdge.getPageSize() + " ;", graphPageEdge.getSpace(), edge, graphPageEdge.getVid(), edge, graphPageEdge.getVid()); + } + log.info("分页查询创建的边 -gql语句:{}", edgePage); + return edgePage; + } + + + /** + * @return java.lang.String + * @Description 点的分页查询 + * @Param [graphSpace] + **/ + public static String vertexPage(GraphSpace graphSpace) { + int skip = (graphSpace.getPageNum() - 1) * graphSpace.getPageSize(); + String queryMatch = String.format("USE `%s`; match (v) return v skip " + skip + " limit " + graphSpace.getPageSize() + ";", graphSpace.getSpace()); + log.info("点的分页查询 -gql语句:{}", queryMatch); + return queryMatch; + } + + /** + * @return java.lang.String + * @Description 关系编辑 + * @Param [graphUpdateEdge] + **/ + public static String updateEdge(GraphUpdateEdge graphUpdateEdge, String vidType) { + List edgeList = graphUpdateEdge.getEdgeList(); + List edgeValueList = graphUpdateEdge.getEdgeValueList(); + if (edgeList.size() != edgeValueList.size()) { + return ""; + } + StringBuffer stringBuffer = new StringBuffer(); + for (int i = 0; i < edgeList.size(); i++) { + String tag = edgeList.get(i); + Object tagValue = edgeValueList.get(i); + stringBuffer.append("`").append(tag).append("`").append(" = "); + if (tagValue instanceof String) { + stringBuffer.append("'").append(tagValue).append("'"); + } else { + stringBuffer.append(tagValue); + } + if (edgeList.size() > 1 && (i + 1) != edgeList.size()) { + stringBuffer.append(","); + } + } + + Object srcVid = graphUpdateEdge.getSrcVid(); + Object dstVid = graphUpdateEdge.getDstVid(); + + if (vidType.contains("STRING")) { + srcVid = "'" + srcVid.toString() + "'"; + dstVid = "'" + dstVid.toString() + "'"; + } + + String updateVertex = String.format("USE `%s`; UPDATE EDGE ON `%s` %s -> %s@0 SET %s;" + , graphUpdateEdge.getSpace(), graphUpdateEdge.getEdgeName(), srcVid, dstVid + , stringBuffer); + log.info("关系编辑 -gql语句:{}", updateVertex); + return updateVertex; + } + + + /** + * @return java.lang.String + * @Description 根据tag标签属性查询点 + * @Param [graphVertexTatAttributeQuery] + **/ + public static String vertexAskQueryAnalysis(String tagName, String name) { + String vertexTagsQuery = String.format("match p=(v:`%s`)-[e]-(v2) where v.`%s`.`name` CONTAINS '%s' return nodes(p),relationships(p) " + , tagName, tagName, name); + log.info("根据tag标签属性查询点 -gql语句:{}", vertexTagsQuery); + return vertexTagsQuery; + } + //public static String vertexAskQueryAnalysis(String tagName, List ids) { + // String vertexTagsQuery = String.format("match p=(v:`%s`)-[e]-(v2) where id(v2) in %s return nodes(p),relationships(p)" + // , tagName,JSONUtil.toJsonStr(ids),tagName,JSONUtil.toJsonStr(ids)); + // log.info("根据tag标签属性查询点 -gql语句:{}", vertexTagsQuery); + // return vertexTagsQuery; + //} + + public static String vertexAskQuery(String tagName, String name) { + String vertexTagsQuery = String.format("match p=(v:`%s`) where v.`%s`.`name` CONTAINS '%s' return nodes(p),relationships(p) " + , tagName, tagName, name); + log.info("根据tag标签属性查询点 -gql语句:{}", vertexTagsQuery); + return vertexTagsQuery; + } + + /** + * 根据条件查询边 + * + * @return java.lang.String + * @Param [graphPageEdge] + **/ + public static String edgeCondition(GraphPageEdge graphPageEdge) { + String edge = ""; + if (StrUtil.isNotBlank(graphPageEdge.getEdge())) { + edge = ":`" + graphPageEdge.getEdge() + "`"; + } + + String edgeCondition = ""; + if (StrUtil.isBlank(graphPageEdge.getVid())) { + edgeCondition = String.format("USE `%s`;MATCH ()-[e %s]->() RETURN e limit " + Integer.MAX_VALUE + ";", graphPageEdge.getSpace(), edge); + } else { + edgeCondition = String.format("USE `%s`;MATCH (m)-[e %s]->(n) where id(m)=='%s' RETURN e " + + "UNION MATCH (m)-[e %s]->(n) where id(n)=='%s' RETURN e LIMIT " + + Integer.MAX_VALUE + ";", graphPageEdge.getSpace(), edge, graphPageEdge.getVid(), edge, graphPageEdge.getVid()); + } + log.info("根据条件查询边 -gql语句:{}", edgeCondition); + return edgeCondition; + } + + /** + * 查询索引详情 + * + * @return java.lang.String + * @Param [graphShowInfo] + **/ + public static String infoIndex(GraphShowInfo graphShowInfo) { + String infoIndex = String.format("USE `%s`; DESCRIBE %s INDEX `%s`;", graphShowInfo.getSpace() + , graphShowInfo.getAttribute(), graphShowInfo.getAttributeName()); + log.info("查询索引的详细信息 -gql语句:{}", infoIndex); + return infoIndex; + } + + /** + * 重建全文索引 + * + * @return java.lang.String + * @Param [space] + **/ + public static String rebuildFullIndex(String space) { + return "USE `" + space + "`;REBUILD FULLTEXT INDEX;"; + } + + + /** + * 全文索引查询 + * + * @return java.lang.String + * @Param [tag, word] + **/ + public static String fullQuery(String tag, String word) { + String fullQuery = String.format("LOOKUP ON `%s` WHERE WILDCARD(`%s`.name, \"*%s*\") YIELD id(vertex)" + , tag, tag, word); + return fullQuery; + } + + /** + * 根据id集合查询 数据 + * + * @return java.lang.String + * @Param [space, idList] + **/ + public static String queryMatchVertex(String space, List idList) { + String queryMatch = String.format("USE `%s`; match (v) WHERE id(v) IN %s RETURN v;" + , space, JSONUtil.toJsonStr(idList)); + log.info("match查询 -gql语句:{}", queryMatch); + return queryMatch; + } + + + /** + * 路径查询 + * + * @return java.lang.String + * @Param [graphVertexPathQuery, vidType] + **/ + public static String findPath(GraphVertexPathQuery graphVertexPathQuery, String vidType) { + + List srcVidList = graphVertexPathQuery.getSrcVid(); + List dstVidList = graphVertexPathQuery.getDstVid(); + String srcVid = ""; + String dstVid = ""; + if (vidType.contains("STRING")) { + for (Object id : srcVidList) { + srcVid += "\"" + id.toString() + "\"" + ","; + } + for (Object id : dstVidList) { + dstVid += "\"" + id.toString() + "\"" + ","; + } + } + + String queryMatch = String.format("USE `%s`; FIND %s PATH WITH PROP FROM %s TO %s OVER %s %s %s UPTO %s STEPS YIELD path AS p | limit %s;" + , graphVertexPathQuery.getSpace(), graphVertexPathQuery.getPathType(), srcVid.substring(0, srcVid.length() - 1) + , dstVid.substring(0, dstVid.length() - 1) + , graphVertexPathQuery.getEdgeList(), graphVertexPathQuery.getDirect(), StringEscapeUtils.unescapeHtml(graphVertexPathQuery.getCondition()) + , graphVertexPathQuery.getStep(), graphVertexPathQuery.getResultSize()); + log.info("match查询 -gql语句:{}", queryMatch); + return queryMatch; + } + + /** + * 增加监听 + * + * @return java.lang.String + * @Param [graphCreateIndex, listenerHost] + **/ + public static String addListener(GraphCreateIndex graphCreateIndex, String listenerHost) { + String addListener = String.format("USE `%s`; ADD LISTENER ELASTICSEARCH %s;" + , graphCreateIndex.getSpace(), listenerHost); + log.info("增加监听 -gql语句:{}", addListener); + return addListener; + } + + /** + * 获取监听 + * + * @return java.lang.String + * @Param [graphCreateIndex] + **/ + public static String showListener(GraphCreateIndex graphCreateIndex) { + return "USE " + graphCreateIndex.getSpace() + ";SHOW LISTENER;"; + } + + /** + * 获取全文索引 + * + * @return java.lang.String + * @Param [space] + **/ + public static String showFullIndexes(String space) { + return "USE " + space + ";SHOW FULLTEXT INDEXES;"; + } + + /** + * 删除全文索引 + * + * @return java.lang.String + * @Param [graphDropAttribute, fullIndexName] + **/ + public static String dropFullIndex(GraphDropAttribute graphDropAttribute, String fullIndexName) { + String dropFullIndex = String.format("USE `%s`; DROP FULLTEXT INDEX %s;" + , graphDropAttribute.getSpace(), fullIndexName); + log.info("删除全文索引 -gql语句:{}", dropFullIndex); + return dropFullIndex; + } + + /** + * 补充信息 + * + * @return java.lang.String + * @Param [tag, ids] + **/ + public static String vertexAskQueryByTag(String tag, List ids) { + String vertexAskQueryByTag = String.format(" MATCH p=(v:`%s`)-[e]->(v2) WHERE id(v2) IN %s RETURN nodes(p) LIMIT 1000" + , tag, JSONUtil.toJsonStr(ids)); + log.info("补充信息 -gql语句:{}", vertexAskQueryByTag); + return vertexAskQueryByTag; + } + + /** + * 共同邻居 + * + * @return java.lang.String + * @Param [space, ids] + **/ + public static String commonNeighbor(String space, List ids) { + + StringBuffer stringBuffer = new StringBuffer(); + for (int i = 0; i < ids.size(); i++) { + if (i + 1 < ids.size()) { + stringBuffer.append(" UNION GO FROM '" + ids.get(i) + "' OVER * REVERSELY YIELD src(edge) as id) INTERSECT(GO FROM '" + ids.get(i + 1) + "' OVER * YIELD dst(edge) as id "); + } + } + log.info(stringBuffer.toString()); + String commonNeighbor = String.format("USE `%s`; (GO FROM '%s' OVER * YIELD dst(edge) as id %s UNION GO FROM '%s' OVER * REVERSELY YIELD src(edge) as id)", + space, ids.get(0), stringBuffer, ids.get(ids.size() - 1)); + log.info("共同邻居 -gql语句:{}", commonNeighbor); + return commonNeighbor; + } + + public static String findPathList(String space, List row, List ids, String vidType) { + String str = JSONUtil.toJsonStr(row); + String idsStr = JSONUtil.toJsonStr(ids); + String findPathList = String.format("USE `%s`; FIND ALL PATH WITH PROP FROM %s TO %s OVER * BIDIRECT UPTO 1 STEPS YIELD path as p | limit 1000;" + , space, str.substring(1, str.length() - 1), idsStr.substring(1, idsStr.length() - 1)); + log.info("match查询 -gql语句:{}", findPathList); + return findPathList; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/util/R.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/util/R.java new file mode 100644 index 00000000..0d81cecd --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/util/R.java @@ -0,0 +1,53 @@ +package com.supervision.nebula.util; + +import lombok.Data; + +/** + * 通用返回类 + */ +@Data +public class R { + // 返回体 + private Integer code; + private String msg; + private T data; + + /** + * 成功 + **/ + public static R success(Object object) { + R result = new R(); + result.setCode(ResultCode.SUCCESS.getCode()); + result.setMsg(ResultCode.SUCCESS.getMsg()); + result.setData(object); + return result; + } + + public static R data(Object object) { + R result = new R(); + result.setCode(ResultCode.SUCCESS.getCode()); + result.setMsg(ResultCode.SUCCESS.getMsg()); + result.setData(object); + return result; + } + + /** + * 失败 + **/ + public R fail(Object object) { + R result = new R(); + result.setCode(ResultCode.FAIL.getCode()); + result.setMsg(ResultCode.FAIL.getMsg()); + result.setData(object); + return result; + } + + public R result(Integer code, String msg, Object object) { + R result = new R(); + result.setCode(code); + result.setMsg(msg); + result.setData(object); + return result; + } +} + diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/util/ResultCode.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/util/ResultCode.java new file mode 100644 index 00000000..8872c4d3 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/util/ResultCode.java @@ -0,0 +1,32 @@ +package com.supervision.nebula.util; + +/** + * @Descriptin: + * @ClassName: ResultCode + */ + +/** + * 通用返回状态码 + */ +public enum ResultCode { + SUCCESS(10000, "成功"), + FAIL(1, "失败"), + UNKNOWN_ERROR(-1, "未知错误"), + NO_DATA(10001, "暂无数据"); + + private final Integer code; + private final String msg; + + ResultCode(Integer code, String msg) { + this.code = code; + this.msg = msg; + } + + public Integer getCode() { + return code; + } + + public String getMsg() { + return msg; + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/AttributeVo.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/AttributeVo.java new file mode 100644 index 00000000..1e82cdc7 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/AttributeVo.java @@ -0,0 +1,121 @@ +package com.supervision.nebula.vo; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; + +import java.util.List; +import java.util.Map; + +/** + * @Descriptin: 11 + * @ClassName: aaa + */ +@ApiModel("属性查询返回类") +public class AttributeVo { + + /** + * spaceName : flceshi + * latencyInUs : 1986 + * data : [{"meta":[""],"row":["basketballplayer"]},{"meta":[""],"row":["demo_lw"]},{"meta":[""],"row":["flceshi"]},{"meta":[""],"row":["lubrication_faultId_detection"]},{"meta":[""],"row":["lubrication_faultId_detection_sample"]},{"meta":[""],"row":["wentao_teatSpace"]},{"meta":[""],"row":["电影"]}] + * columns : ["Name"] + * errors : {"code":0} + */ + + @ApiModelProperty("空间名称") + private String spaceName; + @ApiModelProperty() + private int latencyInUs; + private ErrorsBean errors; + @ApiModelProperty("查询返回属性集合") + private List data; + @ApiModelProperty("返回字段名集合") + private List columns; + private Map> fieldMap; + + public String getSpaceName() { + return spaceName; + } + + public void setSpaceName(String spaceName) { + this.spaceName = spaceName; + } + + public int getLatencyInUs() { + return latencyInUs; + } + + public void setLatencyInUs(int latencyInUs) { + this.latencyInUs = latencyInUs; + } + + public ErrorsBean getErrors() { + return errors; + } + + public void setErrors(ErrorsBean errors) { + this.errors = errors; + } + + public List getData() { + return data; + } + + public void setData(List data) { + this.data = data; + } + + public List getColumns() { + return columns; + } + + public void setColumns(List columns) { + this.columns = columns; + } + + public Map> getFieldMap() { + return fieldMap; + } + + public void setFieldMap(Map> fieldMap) { + this.fieldMap = fieldMap; + } + + public static class ErrorsBean { + /** + * code : 0 + */ + @ApiModelProperty("错误码0正常") + private int code; + + public int getCode() { + return code; + } + + public void setCode(int code) { + this.code = code; + } + } + + public static class DataBean { + @ApiModelProperty("元数据") + private List meta; + @ApiModelProperty("字段值集合") + private List row; + + public List getMeta() { + return meta; + } + + public void setMeta(List meta) { + this.meta = meta; + } + + public List getRow() { + return row; + } + + public void setRow(List row) { + this.row = row; + } + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/CommonVo.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/CommonVo.java new file mode 100644 index 00000000..e78f0be7 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/CommonVo.java @@ -0,0 +1,64 @@ +package com.supervision.nebula.vo; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; + +/** + * @Descriptin: 通用返回类 + * @ClassName: CommonVo + */ +@ApiModel("操作通用返回类") +public class CommonVo { + + /** + * spaceName : flceshi + * latencyInUs : 2305 + * errors : {"code":0} + */ + + @ApiModelProperty("空间名称") + private String spaceName; + @ApiModelProperty() + private int latencyInUs; + private ErrorsBean errors; + + public String getSpaceName() { + return spaceName; + } + + public void setSpaceName(String spaceName) { + this.spaceName = spaceName; + } + + public int getLatencyInUs() { + return latencyInUs; + } + + public void setLatencyInUs(int latencyInUs) { + this.latencyInUs = latencyInUs; + } + + public ErrorsBean getErrors() { + return errors; + } + + public void setErrors(ErrorsBean errors) { + this.errors = errors; + } + + public static class ErrorsBean { + /** + * code : 0 + */ + @ApiModelProperty("错误码0正常") + private int code; + + public int getCode() { + return code; + } + + public void setCode(int code) { + this.code = code; + } + } +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/DetailSpace.java b/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/DetailSpace.java new file mode 100644 index 00000000..c68d99e2 --- /dev/null +++ b/virtual-patient-graph/src/main/java/com/supervision/nebula/vo/DetailSpace.java @@ -0,0 +1,27 @@ +package com.supervision.nebula.vo; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @Descriptin: 图空间详情 + * @ClassName: DetailSpace + */ +@ApiModel("图空间详情实体") +@Data +public class DetailSpace { + + @ApiModelProperty("空间名称") + private String space; + + @ApiModelProperty("标签个数") + private Integer tagsNum; + + @ApiModelProperty("边类型个数") + private Integer edgesNum; + + //@ApiModelProperty("空间备注") + //private String spaceComment; + +} diff --git a/virtual-patient-graph/src/main/java/com/supervision/config/Neo4jConfig.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/config/Neo4jConfig.java similarity index 90% rename from virtual-patient-graph/src/main/java/com/supervision/config/Neo4jConfig.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/config/Neo4jConfig.java index 93393c5a..63c578cc 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/config/Neo4jConfig.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/config/Neo4jConfig.java @@ -1,10 +1,8 @@ -package com.supervision.config; +package com.supervision.neo4j.config; import org.neo4j.driver.AuthTokens; import org.neo4j.driver.Driver; import org.neo4j.driver.GraphDatabase; - -import org.neo4j.ogm.session.SessionFactory; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; diff --git a/virtual-patient-graph/src/main/java/com/supervision/controller/GraphController.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/controller/GraphController.java similarity index 81% rename from virtual-patient-graph/src/main/java/com/supervision/controller/GraphController.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/controller/GraphController.java index 6cb0fb5a..cea5c179 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/controller/GraphController.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/controller/GraphController.java @@ -1,9 +1,7 @@ -package com.supervision.controller; +package com.supervision.neo4j.controller; -import com.supervision.node.DiseaseNode; -import com.supervision.repo.DiseaseRepository; -import com.supervision.service.GraphService; +import com.supervision.neo4j.service.GraphService; import lombok.RequiredArgsConstructor; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/AncillaryNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/AncillaryNode.java similarity index 93% rename from virtual-patient-graph/src/main/java/com/supervision/node/AncillaryNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/AncillaryNode.java index 72a8c8cb..8fe14ada 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/AncillaryNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/AncillaryNode.java @@ -1,4 +1,4 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; import org.neo4j.ogm.annotation.*; diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/DiseaseNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DiseaseNode.java similarity index 58% rename from virtual-patient-graph/src/main/java/com/supervision/node/DiseaseNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DiseaseNode.java index 3fee9d0a..0409ef61 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/DiseaseNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DiseaseNode.java @@ -1,9 +1,10 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; -import org.neo4j.ogm.annotation.*; - -import java.util.Set; +import org.neo4j.ogm.annotation.GeneratedValue; +import org.neo4j.ogm.annotation.Id; +import org.neo4j.ogm.annotation.NodeEntity; +import org.neo4j.ogm.annotation.Property; @Data @NodeEntity("疾病分类名称") diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/DisposalMethodNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DisposalMethodNode.java similarity index 88% rename from virtual-patient-graph/src/main/java/com/supervision/node/DisposalMethodNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DisposalMethodNode.java index 59330dda..4367b065 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/DisposalMethodNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DisposalMethodNode.java @@ -1,7 +1,6 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; -import org.neo4j.ogm.annotation.NodeEntity; import org.neo4j.ogm.annotation.*; import java.util.HashSet; diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/DrugNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DrugNode.java similarity index 56% rename from virtual-patient-graph/src/main/java/com/supervision/node/DrugNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DrugNode.java index 9f6e5680..3ce567f9 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/DrugNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/DrugNode.java @@ -1,7 +1,10 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; -import org.neo4j.ogm.annotation.*; +import org.neo4j.ogm.annotation.GeneratedValue; +import org.neo4j.ogm.annotation.Id; +import org.neo4j.ogm.annotation.NodeEntity; +import org.neo4j.ogm.annotation.Property; @NodeEntity("药品") diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/KnowledgeBaseNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/KnowledgeBaseNode.java similarity index 58% rename from virtual-patient-graph/src/main/java/com/supervision/node/KnowledgeBaseNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/KnowledgeBaseNode.java index e07ede8a..af6f70a1 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/KnowledgeBaseNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/KnowledgeBaseNode.java @@ -1,7 +1,10 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; -import org.neo4j.ogm.annotation.*; +import org.neo4j.ogm.annotation.GeneratedValue; +import org.neo4j.ogm.annotation.Id; +import org.neo4j.ogm.annotation.NodeEntity; +import org.neo4j.ogm.annotation.Property; @NodeEntity("知识库") @Data diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/PhysicalNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/PhysicalNode.java similarity index 94% rename from virtual-patient-graph/src/main/java/com/supervision/node/PhysicalNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/PhysicalNode.java index 11b52d54..90e5926f 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/PhysicalNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/PhysicalNode.java @@ -1,9 +1,8 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; import org.neo4j.ogm.annotation.*; - import java.util.HashSet; import java.util.Set; diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/PhysicalToolNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/PhysicalToolNode.java similarity index 58% rename from virtual-patient-graph/src/main/java/com/supervision/node/PhysicalToolNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/PhysicalToolNode.java index 0d1439b1..53d37fb5 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/PhysicalToolNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/PhysicalToolNode.java @@ -1,8 +1,10 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; - -import org.neo4j.ogm.annotation.*; +import org.neo4j.ogm.annotation.GeneratedValue; +import org.neo4j.ogm.annotation.Id; +import org.neo4j.ogm.annotation.NodeEntity; +import org.neo4j.ogm.annotation.Property; @Data @NodeEntity("体格检查工具") diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/ProcessNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/ProcessNode.java similarity index 96% rename from virtual-patient-graph/src/main/java/com/supervision/node/ProcessNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/ProcessNode.java index ca325763..54129b6c 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/ProcessNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/ProcessNode.java @@ -1,4 +1,4 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; import org.neo4j.ogm.annotation.*; diff --git a/virtual-patient-graph/src/main/java/com/supervision/node/TreatmentPlanNode.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/TreatmentPlanNode.java similarity index 93% rename from virtual-patient-graph/src/main/java/com/supervision/node/TreatmentPlanNode.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/node/TreatmentPlanNode.java index cc60d76a..e4be63bf 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/node/TreatmentPlanNode.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/node/TreatmentPlanNode.java @@ -1,4 +1,4 @@ -package com.supervision.node; +package com.supervision.neo4j.node; import lombok.Data; import org.neo4j.ogm.annotation.*; diff --git a/virtual-patient-graph/src/main/java/com/supervision/repo/AncillaryRepository.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/AncillaryRepository.java similarity index 71% rename from virtual-patient-graph/src/main/java/com/supervision/repo/AncillaryRepository.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/AncillaryRepository.java index 24acea6e..3ee64fdc 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/repo/AncillaryRepository.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/AncillaryRepository.java @@ -1,6 +1,6 @@ -package com.supervision.repo; +package com.supervision.neo4j.repo; -import com.supervision.node.AncillaryNode; +import com.supervision.neo4j.node.AncillaryNode; import org.springframework.data.neo4j.repository.Neo4jRepository; import org.springframework.stereotype.Repository; diff --git a/virtual-patient-graph/src/main/java/com/supervision/repo/DiseaseRepository.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/DiseaseRepository.java similarity index 72% rename from virtual-patient-graph/src/main/java/com/supervision/repo/DiseaseRepository.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/DiseaseRepository.java index 385493f9..0a7c6ec0 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/repo/DiseaseRepository.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/DiseaseRepository.java @@ -1,6 +1,6 @@ -package com.supervision.repo; +package com.supervision.neo4j.repo; -import com.supervision.node.DiseaseNode; +import com.supervision.neo4j.node.DiseaseNode; import org.springframework.data.neo4j.repository.Neo4jRepository; import org.springframework.stereotype.Repository; diff --git a/virtual-patient-graph/src/main/java/com/supervision/repo/KnowledgeRepository.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/KnowledgeRepository.java similarity index 65% rename from virtual-patient-graph/src/main/java/com/supervision/repo/KnowledgeRepository.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/KnowledgeRepository.java index 784e44b7..a34f5d50 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/repo/KnowledgeRepository.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/KnowledgeRepository.java @@ -1,7 +1,6 @@ -package com.supervision.repo; +package com.supervision.neo4j.repo; -import com.supervision.node.DiseaseNode; -import com.supervision.node.KnowledgeBaseNode; +import com.supervision.neo4j.node.KnowledgeBaseNode; import org.springframework.data.neo4j.repository.Neo4jRepository; import org.springframework.stereotype.Repository; diff --git a/virtual-patient-graph/src/main/java/com/supervision/repo/PhysicalRepository.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/PhysicalRepository.java similarity index 65% rename from virtual-patient-graph/src/main/java/com/supervision/repo/PhysicalRepository.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/PhysicalRepository.java index 3b7e227d..d74a0189 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/repo/PhysicalRepository.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/PhysicalRepository.java @@ -1,7 +1,6 @@ -package com.supervision.repo; +package com.supervision.neo4j.repo; -import com.supervision.node.AncillaryNode; -import com.supervision.node.PhysicalNode; +import com.supervision.neo4j.node.PhysicalNode; import org.springframework.data.neo4j.repository.Neo4jRepository; import org.springframework.stereotype.Repository; diff --git a/virtual-patient-graph/src/main/java/com/supervision/repo/PhysicalToolRepository.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/PhysicalToolRepository.java similarity index 64% rename from virtual-patient-graph/src/main/java/com/supervision/repo/PhysicalToolRepository.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/PhysicalToolRepository.java index dde217de..df15bf87 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/repo/PhysicalToolRepository.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/PhysicalToolRepository.java @@ -1,7 +1,6 @@ -package com.supervision.repo; +package com.supervision.neo4j.repo; -import com.supervision.node.KnowledgeBaseNode; -import com.supervision.node.PhysicalToolNode; +import com.supervision.neo4j.node.PhysicalToolNode; import org.springframework.data.neo4j.repository.Neo4jRepository; import org.springframework.stereotype.Repository; diff --git a/virtual-patient-graph/src/main/java/com/supervision/repo/ProcessRepository.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/ProcessRepository.java similarity index 71% rename from virtual-patient-graph/src/main/java/com/supervision/repo/ProcessRepository.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/ProcessRepository.java index 61c7cdd5..672b89f1 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/repo/ProcessRepository.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/ProcessRepository.java @@ -1,6 +1,6 @@ -package com.supervision.repo; +package com.supervision.neo4j.repo; -import com.supervision.node.ProcessNode; +import com.supervision.neo4j.node.ProcessNode; import org.springframework.data.neo4j.repository.Neo4jRepository; import org.springframework.stereotype.Repository; diff --git a/virtual-patient-graph/src/main/java/com/supervision/repo/TreatmentPlanRepository.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/TreatmentPlanRepository.java similarity index 65% rename from virtual-patient-graph/src/main/java/com/supervision/repo/TreatmentPlanRepository.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/TreatmentPlanRepository.java index f7387c53..6b7a85ee 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/repo/TreatmentPlanRepository.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/repo/TreatmentPlanRepository.java @@ -1,7 +1,6 @@ -package com.supervision.repo; +package com.supervision.neo4j.repo; -import com.supervision.node.ProcessNode; -import com.supervision.node.TreatmentPlanNode; +import com.supervision.neo4j.node.TreatmentPlanNode; import org.springframework.data.neo4j.repository.Neo4jRepository; import org.springframework.stereotype.Repository; diff --git a/virtual-patient-graph/src/main/java/com/supervision/service/GraphService.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/service/GraphService.java similarity index 78% rename from virtual-patient-graph/src/main/java/com/supervision/service/GraphService.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/service/GraphService.java index c2202cb5..c30b221a 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/service/GraphService.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/service/GraphService.java @@ -1,4 +1,4 @@ -package com.supervision.service; +package com.supervision.neo4j.service; public interface GraphService { diff --git a/virtual-patient-graph/src/main/java/com/supervision/service/impl/GraphServiceImpl.java b/virtual-patient-graph/src/main/java/com/supervision/neo4j/service/impl/GraphServiceImpl.java similarity index 98% rename from virtual-patient-graph/src/main/java/com/supervision/service/impl/GraphServiceImpl.java rename to virtual-patient-graph/src/main/java/com/supervision/neo4j/service/impl/GraphServiceImpl.java index 95ddeb2d..0edbed7d 100644 --- a/virtual-patient-graph/src/main/java/com/supervision/service/impl/GraphServiceImpl.java +++ b/virtual-patient-graph/src/main/java/com/supervision/neo4j/service/impl/GraphServiceImpl.java @@ -1,4 +1,4 @@ -package com.supervision.service.impl; +package com.supervision.neo4j.service.impl; import cn.hutool.core.collection.CollUtil; import cn.hutool.core.util.ObjectUtil; @@ -7,8 +7,9 @@ import cn.hutool.json.JSONUtil; import com.supervision.exception.BusinessException; import com.supervision.model.Process; import com.supervision.model.*; -import com.supervision.node.*; -import com.supervision.repo.*; +import com.supervision.neo4j.node.*; +import com.supervision.neo4j.repo.*; +import com.supervision.neo4j.service.GraphService; import com.supervision.service.*; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; diff --git a/virtual-patient-graph/src/main/resources/application-dev.yml b/virtual-patient-graph/src/main/resources/application-dev.yml index 155c61c4..51def9df 100644 --- a/virtual-patient-graph/src/main/resources/application-dev.yml +++ b/virtual-patient-graph/src/main/resources/application-dev.yml @@ -55,6 +55,18 @@ spring: uri: bolt://192.168.10.138:7687 username: neo4j password: 123456 +nebula: + userName: root + password: nebula + hostAddresses: [ 10.0.64.106:9669 ] + minConnSize: 5 + maxConnSize: 10 + timeout: 300000 + idleTime: 180000 +# nebula上传文件使用 +path: + uploadFilePath: /opt/project/java/graphFile + importerPath: /data1/opt mybatis-plus: mapper-locations: classpath*:mapper/**/*.xml diff --git a/virtual-patient-web/pom.xml b/virtual-patient-web/pom.xml index bd7054aa..7a198506 100644 --- a/virtual-patient-web/pom.xml +++ b/virtual-patient-web/pom.xml @@ -84,11 +84,6 @@ provided - - org.springframework.boot - spring-boot-starter-websocket - - org.springframework.boot spring-boot-test diff --git a/virtual-patient-web/src/main/java/com/supervision/VirtualPatientApplication.java b/virtual-patient-web/src/main/java/com/supervision/VirtualPatientApplication.java index f1732f2c..1d74a13b 100644 --- a/virtual-patient-web/src/main/java/com/supervision/VirtualPatientApplication.java +++ b/virtual-patient-web/src/main/java/com/supervision/VirtualPatientApplication.java @@ -3,13 +3,9 @@ package com.supervision; import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; -import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.cloud.client.discovery.EnableDiscoveryClient; import org.springframework.cloud.openfeign.EnableFeignClients; -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.ComponentScans; import org.springframework.scheduling.annotation.EnableScheduling; -import org.springframework.web.socket.config.annotation.EnableWebSocket; @SpringBootApplication @MapperScan(basePackages = {"com.supervision.**.mapper"}) diff --git a/virtual-patient-web/src/main/java/com/supervision/config/WebSocketConfig.java b/virtual-patient-web/src/main/java/com/supervision/config/WebSocketConfig.java deleted file mode 100644 index b2aab455..00000000 --- a/virtual-patient-web/src/main/java/com/supervision/config/WebSocketConfig.java +++ /dev/null @@ -1,29 +0,0 @@ -package com.supervision.config; - -import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Configuration; -import org.springframework.scheduling.TaskScheduler; -import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; -import org.springframework.web.socket.server.standard.ServerEndpointExporter; - -@Configuration -public class WebSocketConfig { - - /** - * 注入一个ServerEndpointExporter,该Bean会自动注册使用@ServerEndpoint注解申明的websocket endpoint - */ - @Bean - public ServerEndpointExporter serverEndpointExporter(){ - return new ServerEndpointExporter(); - } - - @Bean - public TaskScheduler taskScheduler(){ - ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler(); - threadPoolTaskScheduler.setThreadNamePrefix("SockJS-"); - threadPoolTaskScheduler.setPoolSize(Runtime.getRuntime().availableProcessors()); - threadPoolTaskScheduler.setRemoveOnCancelPolicy(true); - return threadPoolTaskScheduler; - } - -}