diff --git a/src/main/java/com/realtime/protection/configuration/entity/rule/dynamicrule/DynamicRuleObject.java b/src/main/java/com/realtime/protection/configuration/entity/rule/dynamicrule/DynamicRuleObject.java index 40719b8..e48a9ea 100644 --- a/src/main/java/com/realtime/protection/configuration/entity/rule/dynamicrule/DynamicRuleObject.java +++ b/src/main/java/com/realtime/protection/configuration/entity/rule/dynamicrule/DynamicRuleObject.java @@ -1,4 +1,61 @@ package com.realtime.protection.configuration.entity.rule.dynamicrule; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.realtime.protection.configuration.entity.defense.object.ProtectObject; +import jakarta.validation.constraints.NotNull; +import lombok.Data; + +import java.time.LocalDateTime; +import java.util.List; + +@Data public class DynamicRuleObject { + + @JsonProperty("dynamic_rule_id") + private Integer dynamicRuleId; + + @NotNull + @JsonProperty("dynamic_rule_name") + private String dynamicRuleName; + + @JsonProperty("dynamic_rule_create_time") + private LocalDateTime dynamicRuleCreateTime; + @JsonProperty("dynamic_rule_modify_time") + private LocalDateTime dynamicRuleModifyTime; + + @JsonProperty("dynamic_rule_create_username") + private String dynamicRuleCreateUsername; + +// @JsonProperty("dynamic_rule_audit_status") +// private Integer dynamicRuleAuditStatus; + @JsonProperty("dynamic_rule_create_depart") + private String dynamicRuleCreateDepart; + + //动态规则选择的防护对象ids？ + @JsonProperty("protect_object_ids") + private List protectObjectIds; + @JsonProperty("protect_objects") + private List protectObjects; + + + //还没有建立外键 + @JsonProperty("dynamic_rule_create_user_id") + private Integer dynamicRuleCreateUserId; + @JsonProperty("dynamic_rule_used_task_id") + private Integer dynamicRuleUsedTaskId; + + @JsonProperty("dynamic_rule_source_system") + private Integer dynamicRuleSourceSystem; + @JsonProperty("dynamic_rule_event_type") + private Integer dynamicRuleEventType; + @JsonProperty("dynamic_rule_protect_level") + private Integer dynamicRuleProtectLevel; + + @JsonProperty("dynamic_rule_priority") + private Integer dynamicRulePriority; + @JsonProperty("dynamic_rule_range") + private String dynamicRuleRange; + @JsonProperty("dynamic_rule_frequency") + private Integer dynamicRuleFrequency; + } diff --git a/src/main/java/com/realtime/protection/configuration/entity/rule/staticrule/StaticRuleObject.java b/src/main/java/com/realtime/protection/configuration/entity/rule/staticrule/StaticRuleObject.java index d374eac..febfab9 100644 --- a/src/main/java/com/realtime/protection/configuration/entity/rule/staticrule/StaticRuleObject.java +++ b/src/main/java/com/realtime/protection/configuration/entity/rule/staticrule/StaticRuleObject.java @@ -1,5 +1,7 @@ package com.realtime.protection.configuration.entity.rule.staticrule; +import com.alibaba.excel.annotation.ExcelIgnore; +import com.alibaba.excel.annotation.ExcelProperty; import com.fasterxml.jackson.annotation.JsonProperty; import jakarta.validation.constraints.NotNull; import lombok.AllArgsConstructor; @@ -15,59 +17,82 @@ import java.time.LocalDateTime; @AllArgsConstructor public class StaticRuleObject { @JsonProperty("static_rule_id") + @ExcelIgnore private Integer staticRuleId; @NotNull @JsonProperty("static_rule_name") + @ExcelProperty("名称") private String staticRuleName; @JsonProperty("static_rule_create_time") + @ExcelIgnore private LocalDateTime staticRuleCreateTime; @JsonProperty("static_rule_modify_time") + @ExcelIgnore private LocalDateTime staticRuleModifyTime; @JsonProperty("static_rule_create_username") + @ExcelIgnore private String staticRuleCreateUsername; @JsonProperty("static_rule_audit_status") + @ExcelIgnore private Integer staticRuleAuditStatus; @JsonProperty("static_rule_create_depart") + @ExcelIgnore private String staticRuleCreateDepart; @JsonProperty("static_rule_create_user_id") + @ExcelIgnore private Integer staticRuleCreateUserId; @JsonProperty("static_rule_used_task_id") + @ExcelIgnore private Integer staticRuleUsedTaskId; @JsonProperty("static_rule_sip") + @ExcelProperty("源IP地址") private String staticRuleSip; @JsonProperty("static_rule_msip") + @ExcelProperty("源IP地址掩码") private String staticRuleMsip; @JsonProperty("static_rule_sport") + @ExcelProperty("源端口") private Integer staticRuleSport; @JsonProperty("static_rule_msport") + @ExcelProperty("源端口掩码") private Integer staticRuleMsport; @JsonProperty("static_rule_dip") + @ExcelProperty("目的IP地址") private String staticRuleDip; @JsonProperty("static_rule_mdip") + @ExcelProperty("目的IP地址掩码") private String staticRuleMdip; @JsonProperty("static_rule_dport") + @ExcelProperty("目的端口") private Integer staticRuleDport; @JsonProperty("static_rule_mdport") + @ExcelProperty("目的端口掩码") private Integer staticRuleMdport; @JsonProperty("static_rule_protocol") + @ExcelProperty("协议") private String staticRuleProtocol; @JsonProperty("static_rule_mprotocol") + @ExcelProperty("协议掩码") private String staticRuleMprotocol; @JsonProperty("static_rule_dns") + @ExcelProperty("DNS") private String staticRuleDns; @JsonProperty("static_rule_url") + @ExcelProperty("URL") private String staticRuleURL; @JsonProperty("static_rule_priority") + @ExcelProperty("优先级") private Integer staticRulePriority; @JsonProperty("static_rule_range") + @ExcelProperty("范围") private String staticRuleRange; @JsonProperty("static_rule_frequency") + @ExcelProperty("频率") private Integer staticRuleFrequency; - @JsonProperty("static_rule_protect_level") - private Integer staticRuleProtectLevel; + } diff --git a/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleController.java b/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleController.java new file mode 100644 index 0000000..1fc6404 --- /dev/null +++ b/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleController.java @@ -0,0 +1,104 @@ +package com.realtime.protection.server.rule.dynamicrule; + +import com.alibaba.excel.EasyExcel; +import com.realtime.protection.configuration.entity.rule.dynamicrule.DynamicRuleObject; +import com.realtime.protection.configuration.response.ResponseResult; +import jakarta.validation.Valid; +import lombok.extern.slf4j.Slf4j; +import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; + +import java.io.IOException; +import java.util.List; + +@RestController +@RequestMapping("dynamicrule") +@Slf4j +public class DynamicRuleController { + + private final DynamicRuleService dynamicRuleService; + + public DynamicRuleController(DynamicRuleService dynamicRuleService) { + this.dynamicRuleService = dynamicRuleService; + } + + // 新增 要关联防护对象！！！！ + @RequestMapping("/new") + public ResponseResult newDynamicRuleObject(@RequestBody @Valid DynamicRuleObject dynamicRuleObject) { + log.info("新增动态规则: {}", dynamicRuleObject); + //调用service新增 + Integer dynamicRuleObjectId = dynamicRuleService.newDynamicRuleObject(dynamicRuleObject); + return ResponseResult.ok(). + setData("dynamic_rule_id", dynamicRuleObjectId) + .setData("dynamic_rule_name", dynamicRuleObject.getDynamicRuleName()) + .setData("success", true); + } + + //以excel文件方式批量导入,但动态规则没有这个需求 + @PostMapping("/upload") + public ResponseResult uploadFile(MultipartFile uploadFile) throws IOException { + EasyExcel.read(uploadFile.getInputStream(), DynamicRuleObject.class, + new DynamicRuleDataListener(dynamicRuleService)).sheet().doRead(); + return ResponseResult.ok(); + } + + + + + //id删除 + @RequestMapping("/{dynamicRuleId}/delete") + public ResponseResult deleteDynamicRuleObject(@PathVariable Integer dynamicRuleId ) { + log.info("删除动态规则: {}", dynamicRuleId); + //调用service删除 + dynamicRuleService.deleteDynamicRuleObject(dynamicRuleId); + + return ResponseResult.ok(); + } + + //批量删除 + @RequestMapping("/delete") + public ResponseResult deleteDynamicRuleObjects(@RequestBody List dynamicRuleIds) { + log.info("批量删除动态规则: {}", dynamicRuleIds); + //调用service删除 + + return ResponseResult.ok() + .setData("success",dynamicRuleService.deleteDynamicRuleObjects(dynamicRuleIds)); + } + + //修改 + @RequestMapping("/{dynamicRuleId}/update") + public ResponseResult updateDynamicRuleObject(@PathVariable Integer dynamicRuleId, + @RequestBody @Valid DynamicRuleObject dynamicRuleObject) { + log.info("修改动态规则: {}:{}", + dynamicRuleId, dynamicRuleObject.getDynamicRuleName()); + + dynamicRuleService.updateDynamicRuleObject(dynamicRuleId, dynamicRuleObject); + + return ResponseResult.ok() + .setData("dynamic_rule_id", dynamicRuleId) + .setData("success", true); + } + + //id查询 + @RequestMapping("/{dynamicRuleId}/query") + public ResponseResult queryDynamicRuleObjectById(@PathVariable Integer dynamicRuleId) { + log.info("查询动态规则: {}", dynamicRuleId); + //调用service查询 + return ResponseResult.ok() + .setData("dynamic_rule", dynamicRuleService.queryDynamicRuleById(dynamicRuleId)); + } + + //分页查询 + @RequestMapping("/query") + public ResponseResult queryDynamicRuleObject(@RequestParam(value = "dynamic_rule_name", required = false) String dynamicRuleName, + @RequestParam(value = "dynamic_rule_id", required = false) Integer dynamicRuleId, + @RequestParam(value = "page", defaultValue = "1") Integer page, + @RequestParam(value = "page_size", defaultValue = "10") Integer pageSize) { + log.info("分页查询动态规则: {}:{}:{}:{}", dynamicRuleName, dynamicRuleId, page, pageSize); + //调用service查询 + return ResponseResult.ok() + .setData("dynamic_rule_list", dynamicRuleService.queryDynamicRuleObject(dynamicRuleName, dynamicRuleId, page, pageSize)); + } + + //详情查看？？ 查看什么 +} diff --git a/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleDataListener.java b/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleDataListener.java new file mode 100644 index 0000000..97fd63c --- /dev/null +++ b/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleDataListener.java @@ -0,0 +1,51 @@ +package com.realtime.protection.server.rule.dynamicrule; + +import com.alibaba.excel.context.AnalysisContext; +import com.alibaba.excel.read.listener.ReadListener; +import com.alibaba.excel.util.ListUtils; +import com.realtime.protection.configuration.entity.rule.dynamicrule.DynamicRuleObject; + +import lombok.extern.slf4j.Slf4j; + +import java.util.List; + +@Slf4j +public class DynamicRuleDataListener implements ReadListener { + private static final int batchCount = 100; + private final List cachedDataList + = ListUtils.newArrayListWithExpectedSize(batchCount); + + private final DynamicRuleService dynamicRuleService; + + public DynamicRuleDataListener(DynamicRuleService dynamicRuleService) { + this.dynamicRuleService = dynamicRuleService; + } + + @Override + public void invoke(DynamicRuleObject object, AnalysisContext analysisContext) { + log.info("解析到一条数据:{}", object.toString()); + cachedDataList.add(object); + if (cachedDataList.size() > batchCount) { + saveData(); + cachedDataList.clear(); + } + + } + + @Override + public void doAfterAllAnalysed(AnalysisContext analysisContext) { + saveData(); + } + + /** + * 加上存储数据库 + */ + private void saveData() { + log.info("{}条数据，开始存储数据库！", cachedDataList.size()); + Boolean success = dynamicRuleService.newDynamicRuleObjects(cachedDataList); + log.info("存储数据库成功！"); + if (!success) { + throw new RuntimeException("Error reading data in /proobj/new"); + } + } +} diff --git a/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleMapper.java b/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleMapper.java new file mode 100644 index 0000000..4b3138d --- /dev/null +++ b/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleMapper.java @@ -0,0 +1,34 @@ +package com.realtime.protection.server.rule.dynamicrule; + +import com.realtime.protection.configuration.entity.defense.object.ProtectObject; +import com.realtime.protection.configuration.entity.rule.dynamicrule.DynamicRuleObject; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; + +import java.util.List; + +@Mapper +public interface DynamicRuleMapper { + + //新建动态规则 + void newDynamicRule(@Param("object") DynamicRuleObject dynamicRuleObject); + + //新建动态规则与保护对象关联 + void newDynamicRulProtectObjectConcat(long dynamicRuleId, Integer protectObjectId); + + void deleteDynamicRuleObject( Integer dynamicRuleId); + + DynamicRuleObject queryDynamicRuleById(Integer dynamicRuleId); + + List queryProtectObjectByRuleId(Integer dynamicRuleId); + + void updateDynamicRuleObject(@Param("dynamicRuleId") Integer dynamicRuleId,@Param("object") DynamicRuleObject dynamicRuleObject); + + void newDynamicRules(List dynamicRuleObjects); + + void deleteDynamicRules(List dynamicRuleIds); + + List queryDynamicRuleObject(String dynamicRuleName, Integer dynamicRuleId, Integer page, Integer pageSize); + + void deleteDynamicRuleProtectObjectConcat(Integer dynamicRuleId); +} diff --git a/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleService.java b/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleService.java new file mode 100644 index 0000000..2da2cac --- /dev/null +++ b/src/main/java/com/realtime/protection/server/rule/dynamicrule/DynamicRuleService.java @@ -0,0 +1,132 @@ +package com.realtime.protection.server.rule.dynamicrule; + +import com.alibaba.excel.util.ListUtils; +import com.realtime.protection.configuration.entity.rule.dynamicrule.DynamicRuleObject; +import com.realtime.protection.configuration.utils.SqlSessionWrapper; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.function.Function; + +@Service +public class DynamicRuleService { + private final DynamicRuleMapper dynamicRuleMapper; + private final SqlSessionWrapper sqlSessionWrapper; + + public DynamicRuleService(DynamicRuleMapper dynamicRuleMapper, SqlSessionWrapper sqlSessionWrapper) { + + this.sqlSessionWrapper = sqlSessionWrapper; + this.dynamicRuleMapper = dynamicRuleMapper; + } + + @Transactional + public Integer newDynamicRuleObject(DynamicRuleObject dynamicRule) { + dynamicRuleMapper.newDynamicRule(dynamicRule); + + Integer dynamicRuleId = dynamicRule.getDynamicRuleId(); + + dynamicRule.getProtectObjectIds().forEach( + protectObjectId -> dynamicRuleMapper.newDynamicRulProtectObjectConcat(dynamicRuleId, protectObjectId)); + + + return dynamicRuleId; + } + + //批量新建多个动态规则 + public Boolean newDynamicRuleObjects(List DynamicRuleList) { + Function, Boolean>> newDynamicRuleFunction = + mapper -> list -> { + if (list == null || list.isEmpty()) { + return false; + } + + List DynamicRuleIdBatch = ListUtils.newArrayListWithExpectedSize(100); + for (DynamicRuleObject dynamicRule : DynamicRuleList) { + dynamicRule.setDynamicRuleCreateTime(LocalDateTime.now()); + DynamicRuleIdBatch.add(dynamicRule); + if (DynamicRuleIdBatch.size() < 100) { + continue; + } + //mapper指的就是外层函数输入的参数，也就是WhiteListMapper + mapper.newDynamicRules(DynamicRuleIdBatch); + DynamicRuleIdBatch.clear(); + } + if (!DynamicRuleIdBatch.isEmpty()) { + mapper.newDynamicRules(DynamicRuleIdBatch); + } + return true; + }; + //实现事务操作 + return sqlSessionWrapper.startBatchSession(DynamicRuleMapper.class, newDynamicRuleFunction, DynamicRuleList); + } + + + public void deleteDynamicRuleObject(Integer dynamicRuleId) { + //不需要使用 join + //在数据库中设置了级联删除 ON DELETE CASCADE，在删除在从父表中删除数据时自动删除子表中的数据 + dynamicRuleMapper.deleteDynamicRuleObject(dynamicRuleId); + + } + + @Transactional + public DynamicRuleObject queryDynamicRuleById(Integer dynamicRuleId) { + + //查询DynamicRule + DynamicRuleObject dynamicRuleObject = dynamicRuleMapper.queryDynamicRuleById(dynamicRuleId); + //查询DynamicRule关联的ProtectObject + dynamicRuleObject.setProtectObjects(dynamicRuleMapper.queryProtectObjectByRuleId(dynamicRuleId)); + + return dynamicRuleObject; + } + + @Transactional + public void updateDynamicRuleObject(Integer dynamicRuleId, DynamicRuleObject dynamicRuleObject) { + //更新DynamicRule + dynamicRuleObject.setDynamicRuleModifyTime(LocalDateTime.now()); + dynamicRuleMapper.updateDynamicRuleObject(dynamicRuleId, dynamicRuleObject); + if (dynamicRuleObject.getProtectObjectIds() == null || dynamicRuleObject.getProtectObjectIds().isEmpty()) { + return; + } + //删除DynamicRule关联的ProtectObject + dynamicRuleMapper.deleteDynamicRuleProtectObjectConcat(dynamicRuleId); + //新增DynamicRule关联的ProtectObject + dynamicRuleObject.getProtectObjectIds().forEach( + protectObjectId -> dynamicRuleMapper.newDynamicRulProtectObjectConcat(dynamicRuleId, protectObjectId)); + } + + // 批量删除 + public Boolean deleteDynamicRuleObjects(List dynamicRuleIds) { + Function, Boolean>> deleteDynamicRuleFunction = + mapper -> list -> { + if (list == null || list.isEmpty()) { + return false; + } + + List DynamicRuleIdBatch = ListUtils.newArrayListWithExpectedSize(100); + for (Integer dynamicRuleId : dynamicRuleIds) { + DynamicRuleIdBatch.add(dynamicRuleId); + if (DynamicRuleIdBatch.size() < 100) { + continue; + } + //mapper指的就是外层函数输入的参数，也就是WhiteListMapper + mapper.deleteDynamicRules(DynamicRuleIdBatch); + DynamicRuleIdBatch.clear(); + } + if (!DynamicRuleIdBatch.isEmpty()) { + mapper.deleteDynamicRules(DynamicRuleIdBatch); + } + return true; + }; + //实现事务操作 + return sqlSessionWrapper.startBatchSession(DynamicRuleMapper.class, deleteDynamicRuleFunction, dynamicRuleIds); + + } + + + //分页查询基础的动态规则，暂时不返回关联的保护对象 + public List queryDynamicRuleObject(String dynamicRuleName, Integer dynamicRuleId, Integer page, Integer pageSize) { + return dynamicRuleMapper.queryDynamicRuleObject(dynamicRuleName, dynamicRuleId, page, pageSize); + } +} diff --git a/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleController.java b/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleController.java index 4afbfa5..1db6fdb 100644 --- a/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleController.java +++ b/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleController.java @@ -1,12 +1,18 @@ package com.realtime.protection.server.rule.staticrule; +import com.alibaba.excel.EasyExcel; import com.realtime.protection.configuration.entity.rule.staticrule.StaticRuleObject; import com.realtime.protection.configuration.response.ResponseResult; +import jakarta.servlet.http.HttpServletResponse; import jakarta.validation.Valid; import org.springframework.web.bind.annotation.*; import lombok.extern.slf4j.Slf4j; +import org.springframework.web.multipart.MultipartFile; +import java.io.IOException; +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; import java.util.List; @@ -31,22 +37,37 @@ public class StaticRuleController { return ResponseResult.ok().setData("static_rule_name",object.getStaticRuleName()); } + //以Excel方式批量导入静态规则 + @PostMapping("/upload") + public ResponseResult uploadFile(MultipartFile uploadFile) throws IOException { + EasyExcel.read(uploadFile.getInputStream(), StaticRuleObject.class, + new StaticRuleDataListener(staticRuleService)).sheet().doRead(); + return ResponseResult.ok(); + } + //下载模板文件 + @GetMapping("/download") + public void downloadTemplate(HttpServletResponse response) throws IOException { + response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"); + response.setCharacterEncoding("utf-8"); + String fileName = URLEncoder.encode("静态规则", StandardCharsets.UTF_8).replaceAll("\\+", "%20"); + response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx"); + + EasyExcel.write(response.getOutputStream(), StaticRuleObject.class) + .sheet("静态规则") + .doWrite(List.of()); + } + + /** - * 删除静态规则 + * 删除静态规则（有的删了，有的没删，也返回false） */ @DeleteMapping("/{ids}") public ResponseResult delete(@PathVariable List ids){ log.info("根据id删除静态规则:{}",ids); - //调用service删除 -// if(staticRuleService.deleteStaticRule(ids) == false){ -// return ResponseResult.error() -// .setData("static_rule_id",ids) -// .setData("success",false); -// //有的删了，有的没删，也返回false -// } + // return ResponseResult.ok() .setData("static_rule_id",ids) - .setData("success",true); + .setData("success",staticRuleService.deleteStaticRules(ids)); } /** diff --git a/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleDataListener.java b/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleDataListener.java new file mode 100644 index 0000000..ddea14d --- /dev/null +++ b/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleDataListener.java @@ -0,0 +1,51 @@ +package com.realtime.protection.server.rule.staticrule; + +import com.alibaba.excel.context.AnalysisContext; +import com.alibaba.excel.read.listener.ReadListener; +import com.alibaba.excel.util.ListUtils; +import com.realtime.protection.configuration.entity.rule.staticrule.StaticRuleObject; +import lombok.extern.slf4j.Slf4j; + + +import java.util.List; + +@Slf4j +public class StaticRuleDataListener implements ReadListener { + private static final int batchCount = 100; + private final List cachedDataList + = ListUtils.newArrayListWithExpectedSize(batchCount); + + private final StaticRuleService staticRuleService; + + public StaticRuleDataListener(StaticRuleService staticRuleService) { + this.staticRuleService = staticRuleService; + } + + @Override + public void invoke(StaticRuleObject object, AnalysisContext analysisContext) { + log.info("解析到一条数据:{}", object.toString()); + cachedDataList.add(object); + if (cachedDataList.size() > batchCount) { + saveData(); + cachedDataList.clear(); + } + + } + + @Override + public void doAfterAllAnalysed(AnalysisContext analysisContext) { + saveData(); + } + + /** + * 加上存储数据库 + */ + private void saveData() { + log.info("{}条数据，开始存储数据库！", cachedDataList.size()); + Boolean success = staticRuleService.newStaticRuleObjects(cachedDataList); + log.info("存储数据库成功！"); + if (!success) { + throw new RuntimeException("Error reading data in /proobj/new"); + } + } +} diff --git a/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleMapper.java b/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleMapper.java index 1b6b61f..48b46bd 100644 --- a/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleMapper.java +++ b/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleMapper.java @@ -15,7 +15,10 @@ public interface StaticRuleMapper { //根据主键删除静态规则 @Delete("delete from t_static_rule where static_rule_id = #{id}") - Boolean deleteStaticRule(Integer id); + Boolean deleteStaticRuleById(Integer id); + + + //修改静态规则 void updateStaticRule(StaticRuleObject object); @@ -29,4 +32,7 @@ public interface StaticRuleMapper { Integer page, Integer pageSize); + void deleteStaticRules(@Param("whiteListIds") List staticRuleBatch); + + void newStaticRules(List staticRuleBatch); } diff --git a/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleService.java b/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleService.java index 8438597..c8e1722 100644 --- a/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleService.java +++ b/src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleService.java @@ -1,19 +1,25 @@ package com.realtime.protection.server.rule.staticrule; +import com.alibaba.excel.util.ListUtils; import com.realtime.protection.configuration.entity.rule.staticrule.StaticRuleObject; + import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Transactional; +import com.realtime.protection.configuration.utils.SqlSessionWrapper; import java.time.LocalDateTime; import java.util.List; +import java.util.function.Function; @Service public class StaticRuleService { private final StaticRuleMapper staticRuleMapper; + private final SqlSessionWrapper sqlSessionWrapper; + + public StaticRuleService(StaticRuleMapper staticRuleMapper, SqlSessionWrapper sqlSessionWrapper) { - public StaticRuleService(StaticRuleMapper staticRuleMapper) { this.staticRuleMapper = staticRuleMapper; + this.sqlSessionWrapper = sqlSessionWrapper; } @@ -32,17 +38,36 @@ public class StaticRuleService { return object.getStaticRuleId(); } - @Transactional - public Boolean deleteStaticRule(List staticRuleIds) { + public Object deleteStaticRules(List staticRuleIds) { //判断当前静态规则是否能够删除---是否存在任务选择的静态规则？？ //删除静态规则 // for (Integer id : staticRuleIds) { // staticRuleMapper.deleteStaticRule(id); // } - return staticRuleIds.stream().allMatch(staticRuleMapper::deleteStaticRule); - + Function, Boolean>> deleteStaticRulesFunction = + mapper -> list -> { + if (list == null || list.isEmpty()) { + return false; + } + List staticRuleBatch = ListUtils.newArrayListWithExpectedSize(100); + for (Integer staticRuleId : list) { + staticRuleBatch.add(staticRuleId); + if (staticRuleBatch.size() < 100) { + continue; + } + //mapper指的就是外层函数输入的参数，也就是WhiteListMapper + mapper.deleteStaticRules(staticRuleBatch); + staticRuleBatch.clear(); + } + if (!staticRuleBatch.isEmpty()) { + mapper.deleteStaticRules(staticRuleBatch); + } + return true; + }; + //实现事务操作 + return sqlSessionWrapper.startBatchSession(StaticRuleMapper.class, deleteStaticRulesFunction, staticRuleIds); } public void updateStaticRule(StaticRuleObject object) { @@ -66,4 +91,32 @@ public class StaticRuleService { return staticRuleMapper.queryStaticRule(static_rule_name,static_rule_id,page,pageSize); } + public Boolean newStaticRuleObjects(List staticRuleList) { + Function, Boolean>> newStaticRuleFunction = + mapper -> list -> { + if (list == null || list.isEmpty()) { + return false; + } + + List StaticRuleBatch = ListUtils.newArrayListWithExpectedSize(100); + for (StaticRuleObject staticRule : staticRuleList) { + staticRule.setStaticRuleCreateTime(LocalDateTime.now()); + StaticRuleBatch.add(staticRule); + if (StaticRuleBatch.size() < 100) { + continue; + } + //mapper指的就是外层函数输入的参数，也就是WhiteListMapper + mapper.newStaticRules(StaticRuleBatch); + StaticRuleBatch.clear(); + } + if (!StaticRuleBatch.isEmpty()) { + mapper.newStaticRules(StaticRuleBatch); + } + return true; + }; + //实现事务操作 + return sqlSessionWrapper.startBatchSession(StaticRuleMapper.class, newStaticRuleFunction, staticRuleList); + + + } } diff --git a/src/main/java/com/realtime/protection/server/whitelist/WhiteListController.java b/src/main/java/com/realtime/protection/server/whitelist/WhiteListController.java index daf8883..9796ff3 100644 --- a/src/main/java/com/realtime/protection/server/whitelist/WhiteListController.java +++ b/src/main/java/com/realtime/protection/server/whitelist/WhiteListController.java @@ -3,11 +3,14 @@ package com.realtime.protection.server.whitelist; import com.alibaba.excel.EasyExcel; import com.realtime.protection.configuration.entity.whitelist.WhiteListObject; import com.realtime.protection.configuration.response.ResponseResult; +import jakarta.servlet.http.HttpServletResponse; import org.springframework.web.bind.annotation.*; import org.springframework.web.multipart.MultipartFile; import java.io.IOException; +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; import java.util.List; @RestController @@ -37,6 +40,18 @@ public class WhiteListController { new WhiteListDataListener(whiteListService)).sheet().doRead(); return ResponseResult.ok(); } + //下载模板文件 + @GetMapping("/download") + public void downloadTemplate(HttpServletResponse response) throws IOException { + response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"); + response.setCharacterEncoding("utf-8"); + String fileName = URLEncoder.encode("白名单", StandardCharsets.UTF_8).replaceAll("\\+", "%20"); + response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx"); + + EasyExcel.write(response.getOutputStream(), WhiteListObject.class) + .sheet("白名单") + .doWrite(List.of()); + } @RequestMapping("/query") public ResponseResult queryWhiteListObject(@RequestParam(value = "whiteobj_name", required = false)String whiteListName, @@ -87,7 +102,6 @@ public class WhiteListController { //还要return 白名单名称吗,还要在查表看他的名称 } - @PostMapping("/delete") public ResponseResult deleteWhiteListObjects( @RequestBody List whiteListObjIds) { //Post不支持body为json。。。 body只能是[9,10] @@ -126,17 +140,17 @@ public class WhiteListController { } //修改审核状态 - @RequestMapping("/{id}/audit/{status}") + @RequestMapping("/{id}/audit/{auditStatus}") public ResponseResult updateWhiteListObjectAuditStatus(@PathVariable Integer id, - @PathVariable Integer status) { - if (id <= 0 || status < 0 || status > 2) { + @PathVariable Integer auditStatus) { + if (id <= 0 || auditStatus < 0 || auditStatus > 2) { return new ResponseResult(400, "id or status is invalid") .setData("whiteobj_id", id) .setData("success", false); } return ResponseResult.ok() - .setDataMap(whiteListService.updateWhiteListObjectAuditStatus(id, status)) + .setDataMap(whiteListService.updateWhiteListObjectAuditStatus(id, auditStatus)) .setData("whiteobj_id", id); } diff --git a/src/main/resources/mappers/DynamicRuleMapper.xml b/src/main/resources/mappers/DynamicRuleMapper.xml new file mode 100644 index 0000000..d7fc004 --- /dev/null +++ b/src/main/resources/mappers/DynamicRuleMapper.xml @@ -0,0 +1,158 @@ + + + + + + + + + insert into t_dynamic_rule + (dynamic_rule_name, + create_time, modify_time, dynamic_rule_create_username, + dynamic_rule_create_depart, dynamic_rule_source_system, + dynamic_rule_event_type, dynamic_rule_protec_level, + dynamic_rule_priority, dynamic_rule_range, + dynamic_rule_frequency, dynamic_rule_create_user_id) + values + (#{object.dynamicRuleName}, + #{object.dynamicRuleCreateTime},#{object.dynamicRuleModifyTime}, + #{object.dynamicRuleCreateUsername},#{object.dynamicRuleCreateDepart}, + #{object.dynamicRuleSourceSystem}, + #{object.dynamicRuleEventType}, #{object.dynamicRuleProtectLevel}, + #{object.dynamicRulePriority}, #{object.dynamicRuleRange}, + #{object.dynamicRuleFrequency}, + #{object.dynamicRuleCreateUserId}) + + + + + insert into + t_protect_object_dynamic_rule_conn(dynamic_rule_id, protect_object_id) + values (#{dynamicRuleId}, #{protectObjectId}) + + + insert into t_dynamic_rule + (dynamic_rule_name, + create_time, modify_time, dynamic_rule_create_username, + dynamic_rule_create_depart, dynamic_rule_source_system, + dynamic_rule_event_type, dynamic_rule_protec_level, + dynamic_rule_priority, dynamic_rule_range, + dynamic_rule_frequency, dynamic_rule_create_user_id + ) + values + + (#{object.dynamicRuleName}, + #{object.dynamicRuleCreateTime},#{object.dynamicRuleModifyTime}, + #{object.dynamicRuleCreateUsername},#{object.dynamicRuleCreateDepart}, + #{object.dynamicRuleSourceSystem}, + #{object.dynamicRuleEventType}, #{object.dynamicRuleProtectLevel}, + #{object.dynamicRulePriority}, #{object.dynamicRuleRange}, + #{object.dynamicRuleFrequency}, + #{object.dynamicRuleCreateUserId}) + + + + + + + + + + + + delete from t_dynamic_rule + where dynamic_rule_id = #{dynamicRuleId} + + + + delete from t_protect_object_dynamic_rule_conn + where dynamic_rule_id = #{dynamicRuleId} + + + + delete from t_dynamic_rule + where dynamic_rule_id in + + #{id} + + + + + + update t_dynamic_rule + set + dynamic_rule_name = #{object.dynamicRuleName}, + modify_time = #{object.dynamicRuleModifyTime}, + dynamic_rule_source_system = #{object.dynamicRuleSourceSystem}, + dynamic_rule_event_type = #{object.dynamicRuleEventType}, + dynamic_rule_protec_level = #{object.dynamicRuleProtectLevel}, + dynamic_rule_priority = #{object.dynamicRulePriority}, + dynamic_rule_range = #{object.dynamicRuleRange}, + dynamic_rule_frequency = #{object.dynamicRuleFrequency} + where + dynamic_rule_id = #{dynamicRuleId} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/main/resources/mappers/StaticRuleMapper.xml b/src/main/resources/mappers/StaticRuleMapper.xml index dbc2e04..26947db 100644 --- a/src/main/resources/mappers/StaticRuleMapper.xml +++ b/src/main/resources/mappers/StaticRuleMapper.xml @@ -14,17 +14,37 @@ static_rule_dip, static_rule_mdip, static_rule_dport, static_rule_mdport, static_rule_protocol, static_rule_mprotocol, static_rule_dns, static_rule_url, static_rule_priority, static_rule_range, - static_rule_frequency, static_rule_protect_level, static_rule_audit_status) + static_rule_frequency, static_rule_audit_status) values (#{object.staticRuleName}, #{object.staticRuleCreateTime}, #{object.staticRuleCreateUsername}, #{object.staticRuleCreateDepart}, #{object.staticRuleCreateUserId}, INET_ATON(#{object.staticRuleSip}), INET_ATON(#{object.staticRuleMsip}), #{object.staticRuleSport}, #{object.staticRuleMsport}, INET_ATON(#{object.staticRuleDip}), INET_ATON(#{object.staticRuleMdip}), #{object.staticRuleDport}, #{object.staticRuleMdport}, #{object.staticRuleProtocol}, #{object.staticRuleMprotocol}, #{object.staticRuleDns}, #{object.staticRuleURL}, #{object.staticRulePriority}, - #{object.staticRuleRange}, #{object.staticRuleFrequency}, #{object.staticRuleProtectLevel}, + #{object.staticRuleRange}, #{object.staticRuleFrequency}, #{object.staticRuleAuditStatus}) - + + insert into t_static_rule(static_rule_name, static_rule_create_time, + static_rule_create_username, static_rule_create_depart, + static_rule_create_user_id, static_rule_sip, static_rule_msip, + static_rule_sport, static_rule_msport, + static_rule_dip, static_rule_mdip, static_rule_dport, static_rule_mdport, + static_rule_protocol, static_rule_mprotocol, static_rule_dns, + static_rule_url, static_rule_priority, static_rule_range, + static_rule_frequency, static_rule_audit_status) + values + + (#{object.staticRuleName}, #{object.staticRuleCreateTime}, #{object.staticRuleCreateUsername}, + #{object.staticRuleCreateDepart}, #{object.staticRuleCreateUserId}, INET_ATON(#{object.staticRuleSip}), + INET_ATON(#{object.staticRuleMsip}), #{object.staticRuleSport}, #{object.staticRuleMsport}, + INET_ATON(#{object.staticRuleDip}), INET_ATON(#{object.staticRuleMdip}), #{object.staticRuleDport}, + #{object.staticRuleMdport}, #{object.staticRuleProtocol}, #{object.staticRuleMprotocol}, + #{object.staticRuleDns}, #{object.staticRuleURL}, #{object.staticRulePriority}, + #{object.staticRuleRange}, #{object.staticRuleFrequency}, + 0) + + @@ -54,12 +74,13 @@ static_rule_frequency = #{staticRuleFrequency}, - - static_rule_protect_level = #{staticRuleProtectLevel}, - + where static_rule_id = #{staticRuleId} + + + diff --git a/src/test/java/com/realtime/protection/server/rule/dynamic/DynamicRuleServiceTest.java b/src/test/java/com/realtime/protection/server/rule/dynamic/DynamicRuleServiceTest.java new file mode 100644 index 0000000..de3f81e --- /dev/null +++ b/src/test/java/com/realtime/protection/server/rule/dynamic/DynamicRuleServiceTest.java @@ -0,0 +1,69 @@ +package com.realtime.protection.server.rule.dynamic; + +import com.realtime.protection.configuration.entity.rule.dynamicrule.DynamicRuleObject; +import com.realtime.protection.server.rule.dynamicrule.DynamicRuleService; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +@SpringBootTest +public class DynamicRuleServiceTest { + private final DynamicRuleService dynamicRuleService; + @Autowired + public DynamicRuleServiceTest(DynamicRuleService dynamicRuleService) { + this.dynamicRuleService = dynamicRuleService; + } + + @Test + void testNewDynamicRule() { + DynamicRuleObject object = new DynamicRuleObject(); + object.setDynamicRuleName("UpdateDynamicRule2"); + object.setDynamicRuleEventType(1); + object.setDynamicRuleFrequency(1); + object.setDynamicRulePriority(1); + object.setDynamicRuleRange("北京"); + object.setDynamicRuleProtectLevel(2); + object.setDynamicRuleSourceSystem(1); + object.setProtectObjectIds(List.of(new Integer[]{5521, 5520})); + + + Integer objectId = dynamicRuleService.newDynamicRuleObject(object); + assertTrue(objectId > 0); + } + + @Test + void testDeleteDynamicRule() { + dynamicRuleService.deleteDynamicRuleObject(8); + } + + @Test + void testQueryDynamicRule() { + DynamicRuleObject object = dynamicRuleService.queryDynamicRuleById(9); + System.out.println(object); + } + + @Test + void testUpdateDynamicRule() { + DynamicRuleObject object = new DynamicRuleObject(); + object.setDynamicRuleName("UpdateDynamicRule2"); + object.setDynamicRuleEventType(1); + object.setDynamicRuleFrequency(1); + object.setDynamicRulePriority(1); + object.setDynamicRuleRange("北京"); + object.setDynamicRuleProtectLevel(2); + object.setDynamicRuleSourceSystem(1); + object.setProtectObjectIds(List.of(new Integer[]{5521, 5520})); + + dynamicRuleService.updateDynamicRuleObject(9, object); + } + + @Test + void testQueryDynamicRuleObject() { + List objects = dynamicRuleService.queryDynamicRuleObject( null,null,1, 10); + System.out.println(objects); + } +} diff --git a/src/test/java/com/realtime/protection/server/rule/staticrule/StaticRuleServiceTest.java b/src/test/java/com/realtime/protection/server/rule/staticrule/StaticRuleServiceTest.java index 7b44288..3b9ab36 100644 --- a/src/test/java/com/realtime/protection/server/rule/staticrule/StaticRuleServiceTest.java +++ b/src/test/java/com/realtime/protection/server/rule/staticrule/StaticRuleServiceTest.java @@ -1,6 +1,7 @@ package com.realtime.protection.server.rule.staticrule; import com.realtime.protection.configuration.entity.rule.staticrule.StaticRuleObject; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; @@ -13,8 +14,31 @@ import static org.junit.jupiter.api.Assertions.*; @SpringBootTest public class StaticRuleServiceTest { + private final StaticRuleService staticRuleService; + private StaticRuleObject staticRuleTest; @Autowired - private StaticRuleService staticRuleService; + public StaticRuleServiceTest(StaticRuleService staticRuleService) { + this.staticRuleService = staticRuleService; + } + + @BeforeEach + void setUp() { + staticRuleTest = new StaticRuleObject(); + staticRuleTest.setStaticRuleName("test_staticrule"); + staticRuleTest.setStaticRuleCreateTime(LocalDateTime.now()); + staticRuleTest.setStaticRuleCreateUsername("mh"); + staticRuleTest.setStaticRuleCreateDepart("mmeess"); + staticRuleTest.setStaticRuleCreateUserId(2); + staticRuleTest.setStaticRuleAuditStatus(0); + + staticRuleTest.setStaticRuleSip("1.1.2.3"); + staticRuleTest.setStaticRuleSport(80); + + staticRuleTest.setStaticRulePriority(1); + staticRuleTest.setStaticRuleFrequency(1); + staticRuleTest.setStaticRuleRange("北京"); + + } @Test void testNewStaticRule(){ @@ -34,12 +58,21 @@ public class StaticRuleServiceTest { object.setStaticRulePriority(2); object.setStaticRuleFrequency(1); object.setStaticRuleRange("北京"); - object.setStaticRuleProtectLevel(2); +// object.setStaticRuleProtectLevel(2); Integer id = staticRuleService.newStaticRuleObject(object); } //assertTrue(id>0); } + @Test + void testNewStaticRules(){ + List staticRuleObjects = new ArrayList<>(); + for (int i = 0; i < 100; i++) { + staticRuleObjects.add(staticRuleTest); + } + Boolean success = staticRuleService.newStaticRuleObjects(staticRuleObjects); + assertTrue(success); + } @Test void testDeleteStaticRule(){ @@ -48,7 +81,7 @@ public class StaticRuleServiceTest { list.add(1); while(i<2) { i++; - staticRuleService.deleteStaticRule(list); + staticRuleService.deleteStaticRules(list); } } @Test @@ -68,7 +101,7 @@ public class StaticRuleServiceTest { object.setStaticRulePriority(2); object.setStaticRuleFrequency(1); object.setStaticRuleRange("北京"); - object.setStaticRuleProtectLevel(2); +// object.setStaticRuleProtectLevel(2); staticRuleService.updateStaticRule(object); }