1.完成静态规则的修改、id查询、分页查询、删除（目前直接在数据库delete）

2.新增@Slf4j进行日志记录
3.修改静态规则的新建

src/main/java/com/realtime/protection/configuration/entity/rule/staticrule/StaticRuleObject.java

@@ -2,38 +2,72 @@ package com.realtime.protection.configuration.entity.rule.staticrule;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.time.LocalDateTime;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class StaticRuleObject {
     @JsonProperty("static_rule_id")
-    private int staticRuleId;
+    private Integer staticRuleId;
 
     @NotNull
     @JsonProperty("static_rule_name")
     private String staticRuleName;
 
+    @JsonProperty("static_rule_create_time")
     private LocalDateTime staticRuleCreateTime;
-    private String StaticRuleCreateUsername;
+    @JsonProperty("static_rule_modify_time")
-    private int StaticRuleAuditStatus;
+    private LocalDateTime staticRuleModifyTime;
-    private String StaticRuleCreateDepart;
+
-    private int StaticRuleCreateUserId;
+    @JsonProperty("static_rule_create_username")
-    private String StaticRuleSip;
+    private String staticRuleCreateUsername;
-    private String StaticRuleMsip;
+    @JsonProperty("static_rule_audit_status")
-    private int StaticRuleSport;
+    private Integer staticRuleAuditStatus;
-    private int StaticRuleMsport;
+    @JsonProperty("static_rule_create_depart")
-    private String StaticRuleDip;
+    private String staticRuleCreateDepart;
-    private String StaticRuleMdip;
+    @JsonProperty("static_rule_create_user_id")
-    private int StaticRuleDport;
+    private Integer staticRuleCreateUserId;
-    private int StaticRuleMdport;
+    @JsonProperty("static_rule_used_task_id")
-    private String StaticRuleProtocol;
+    private Integer staticRuleUsedTaskId;
-    private String StaticRuleMprotocol;
+
-    private String StaticRuleDns;
+    @JsonProperty("static_rule_sip")
-    private String StaticRuleURL;
+    private String staticRuleSip;
-    private int StaticRulePriority;
+    @JsonProperty("static_rule_msip")
-    private String StaticRuleRange;
+    private String staticRuleMsip;
-    private int StaticRuleFrequency;
+    @JsonProperty("static_rule_sport")
-    private int StaticRuleProtectLevel;
+    private Integer staticRuleSport;
+    @JsonProperty("static_rule_msport")
+    private Integer staticRuleMsport;
+    @JsonProperty("static_rule_dip")
+    private String staticRuleDip;
+    @JsonProperty("static_rule_mdip")
+    private String staticRuleMdip;
+    @JsonProperty("static_rule_dport")
+    private Integer staticRuleDport;
+    @JsonProperty("static_rule_mdport")
+    private Integer staticRuleMdport;
+    @JsonProperty("static_rule_protocol")
+    private String staticRuleProtocol;
+    @JsonProperty("static_rule_mprotocol")
+    private String staticRuleMprotocol;
+    @JsonProperty("static_rule_dns")
+    private String staticRuleDns;
+    @JsonProperty("static_rule_url")
+    private String staticRuleURL;
+
+    @JsonProperty("static_rule_priority")
+    private Integer staticRulePriority;
+    @JsonProperty("static_rule_range")
+    private String staticRuleRange;
+    @JsonProperty("static_rule_frequency")
+    private Integer staticRuleFrequency;
+    @JsonProperty("static_rule_protect_level")
+    private Integer staticRuleProtectLevel;
 }

src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleController.java

@@ -3,27 +3,78 @@ package com.realtime.protection.server.rule.staticrule;
 
 import com.realtime.protection.configuration.entity.rule.staticrule.StaticRuleObject;
 import com.realtime.protection.configuration.response.ResponseResult;
-import org.springframework.beans.factory.annotation.Autowired;
+import jakarta.validation.Valid;
-import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.*;
-import org.springframework.web.bind.annotation.RequestMapping;
+import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
 
 @RestController
 @RequestMapping("/staticrule")
+@Slf4j
 public class StaticRuleController {
 
-    @Autowired
+    private final StaticRuleService staticRuleService;
-    private StaticRuleService staticRuleService;
+    public StaticRuleController(StaticRuleService staticRuleService) {
+        this.staticRuleService = staticRuleService;
+    }
 
     /**
      * 新增静态规则
      */
-    @RequestMapping("/new")
+    @PostMapping("/new")
-    public ResponseResult newStaticRuleObject(@RequestBody StaticRuleObject object){
+    public ResponseResult newStaticRuleObject(@RequestBody @Valid StaticRuleObject object){
-//        log.info("新增部门: {}" , dept);
+        log.info("新增静态规则: {}" , object);
         //调用service新增
         staticRuleService.newStaticRuleObject(object);
+        return ResponseResult.ok().setData("static_rule_name",object.getStaticRuleName());
+    }
+
+    /**
+     * 删除静态规则
+     */
+    @DeleteMapping("/{ids}")
+    public ResponseResult delete(@PathVariable List<Integer> ids){
+        log.info("根据id删除静态规则:{}",ids);
+        //调用service删除
+        staticRuleService.deleteStaticRule(ids);
         return ResponseResult.ok();
     }
 
+    /**
+     * 修改静态规则
+     */
+    @PutMapping("/update")
+    public ResponseResult updateStaticRule(@RequestBody @Valid StaticRuleObject object){
+        log.info("修改静态规则: {}" , object);
+        //调用service修改
+        staticRuleService.updateStaticRule(object);
+        return ResponseResult.ok();
+    }
+
+    /**
+     * 根据id查询静态规则
+     * 路径参数：通过请求URL直接传递参数，使用{…}来标识该路径参数，需要使用 @PathVariable 获取路径参数
+     */
+    @RequestMapping("/{id}/query")
+        public ResponseResult queryStaticRuleById(@PathVariable Integer id){
+            log.info("根据id查询静态规则:{}",id);
+            StaticRuleObject object = staticRuleService.queryStaticRuleById(id);
+            return ResponseResult.ok().setData("static_rule",object);
+        }
+
+    /**
+     * 分页查询静态规则
+     */
+    @RequestMapping("/query")
+    public ResponseResult queryStaticRule(String static_rule_name, Integer static_rule_id,
+                                          @RequestParam(defaultValue = "1") Integer page,
+                                          @RequestParam(defaultValue = "10") Integer pageSize
+    ){
+        log.info("多查询静态规则: {},{},{},{}", static_rule_name,static_rule_id,page,pageSize);
+        //调用service新增
+        List<StaticRuleObject> pageResult = staticRuleService.queryStaticRule(static_rule_name,static_rule_id,page,pageSize);
+        return ResponseResult.ok().setData("static_rule_list",pageResult);
+    }
 }

src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleMapper.java

@@ -1,11 +1,30 @@
 package com.realtime.protection.server.rule.staticrule;
 
 import com.realtime.protection.configuration.entity.rule.staticrule.StaticRuleObject;
+import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
+import java.util.List;
+
 @Mapper
 public interface StaticRuleMapper {
-    Integer newStaticRuleObject(@Param("object") StaticRuleObject object);
+    /**
+     * 新建静态规则
+     */
+    void newStaticRuleObject(@Param("object") StaticRuleObject object);
 
+    /**
+     * 根据主键删除菜品数据
+     */
+    @Delete("delete from t_static_rule where static_rule_id = #{id}")
+    void deleteStaticRule(Integer id);
+
+    void updateStaticRule(StaticRuleObject object);
+
+    //@Select("select * from t_static_rule where static_rule_id = #{id}")
+    StaticRuleObject queryStaticRuleById(Integer id);
+
+    List<StaticRuleObject> queryStaticRule(String static_rule_name, Integer static_rule_id,
+                                           Integer page, Integer pageSize);
 }

src/main/java/com/realtime/protection/server/rule/staticrule/StaticRuleService.java

@@ -5,6 +5,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
+import java.util.List;
 
 @Service
 public class StaticRuleService {
@@ -22,9 +23,39 @@ public class StaticRuleService {
         /*
         待开发：设置静态规则对象的创建用户、用户所属部门等属性
          */
-
         staticRuleMapper.newStaticRuleObject(object);
 
         return object.getStaticRuleId();
     }
+
+    public void deleteStaticRule(List<Integer> ids) {
+        //判断当前静态规则是否能够删除---是否存在任务选择的静态规则？？
+
+        //删除静态规则
+        for (Integer id : ids) {
+            staticRuleMapper.deleteStaticRule(id);
+        }
+
+    }
+
+    public void updateStaticRule(StaticRuleObject object) {
+        //判断当前静态规则是否能够修改---是否存在任务选择的静态规则？？
+        //按id查询该静态规则的used_task_id字段，如果不为空，则不能修改
+        object.setStaticRuleModifyTime(LocalDateTime.now());
+        //修改静态规则
+        staticRuleMapper.updateStaticRule(object);
+    }
+
+    public StaticRuleObject queryStaticRuleById(Integer id) {
+        return staticRuleMapper.queryStaticRuleById(id);
+    }
+
+    /*
+    分页查询
+     */
+    public List<StaticRuleObject> queryStaticRule(String static_rule_name, Integer static_rule_id, Integer page, Integer pageSize) {
+
+        return staticRuleMapper.queryStaticRule(static_rule_name,static_rule_id,page,pageSize);
+    }
+
 }

src/main/resources/mappers/StaticRuleMapper.xml

@@ -10,18 +10,89 @@
         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_sport, static_rule_msport,
-                                  static_rule_dip,static_rule_mdip,static_rule_dport,static_rule_mdport,
+                                  static_rule_dip, static_rule_mdip, static_rule_dport, static_rule_mdport,
-                                  static_rule_protocol,static_rule_mprotocol,static_rule_dns,
+                                  static_rule_protocol, static_rule_mprotocol, static_rule_dns,
-                                  static_rule_url,static_rule_priority,static_rule_range,
+                                  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_protect_level, static_rule_audit_status)
-        values (#{object.staticRuleName}, #{object.staticRuleCreateTime},#{object.staticRuleCreateUsername},
+        values (#{object.staticRuleName}, #{object.staticRuleCreateTime}, #{object.staticRuleCreateUsername},
-                #{object.staticRuleCreateDepart},#{object.staticRuleCreateUserId},INET_ATON(#{object.staticRuleSip}),
+                #{object.staticRuleCreateDepart}, #{object.staticRuleCreateUserId}, INET_ATON(#{object.staticRuleSip}),
-                INET_ATON(#{object.staticRuleMsip}),#{object.staticRuleSport},#{object.staticRuleMsport},
+                INET_ATON(#{object.staticRuleMsip}), #{object.staticRuleSport}, #{object.staticRuleMsport},
-                INET_ATON(#{object.staticRuleDip}),INET_ATON(#{object.staticRuleMdip}),#{object.staticRuleDport},
+                INET_ATON(#{object.staticRuleDip}), INET_ATON(#{object.staticRuleMdip}), #{object.staticRuleDport},
-                #{object.staticRuleMdport},#{object.staticRuleProtocol},#{object.staticRuleMprotocol},
+                #{object.staticRuleMdport}, #{object.staticRuleProtocol}, #{object.staticRuleMprotocol},
-                #{object.staticRuleDns},#{object.staticRuleURL},#{object.staticRulePriority},
+                #{object.staticRuleDns}, #{object.staticRuleURL}, #{object.staticRulePriority},
-                #{object.staticRuleRange},#{object.staticRuleFrequency},#{object.staticRuleProtectLevel},
+                #{object.staticRuleRange}, #{object.staticRuleFrequency}, #{object.staticRuleProtectLevel},
-                #{object.staticAuditStatus})
+                #{object.staticRuleAuditStatus})
     </insert>
+
+
+
+    <update id="updateStaticRule">
+        update t_static_rule
+        <set>
+            <if test="staticRuleName != null and staticRuleName != ''">
+                static_rule_name = #{staticRuleName},
+            </if>
+                static_rule_sip = INET_ATON(#{staticRuleSip}),
+                static_rule_msip = INET_ATON(#{staticRuleMsip}),
+                static_rule_sport = #{staticRuleSport},
+                static_rule_msport = #{staticRuleMsport},
+                static_rule_dip = INET_ATON(#{staticRuleDip}),
+                static_rule_mdip = INET_ATON(#{staticRuleMdip}),
+                static_rule_dport = #{staticRuleDport},
+                static_rule_mdport = #{staticRuleMdport},
+                static_rule_protocol = #{staticRuleProtocol},
+                static_rule_mprotocol = #{staticRuleMprotocol},
+                static_rule_dns = #{staticRuleDns},
+                static_rule_url = #{staticRuleURL},
+            <if test="staticRulePriority != null and staticRulePriority != ''">
+                static_rule_priority = #{staticRulePriority},
+            </if>
+            <if test="staticRuleRange != null and staticRuleRange != ''">
+                static_rule_range = #{staticRuleRange},
+            </if>
+            <if test="staticRuleFrequency != null and staticRuleFrequency != ''">
+                static_rule_frequency = #{staticRuleFrequency},
+            </if>
+            <if test="staticRuleProtectLevel != null and staticRuleProtectLevel != ''">
+                static_rule_protect_level = #{staticRuleProtectLevel},
+            </if>
+        </set>
+        where static_rule_id = #{staticRuleId}
+    </update>
+
+    <resultMap id="staticRuleMap" type="com.realtime.protection.configuration.entity.rule.staticrule.StaticRuleObject">
+        <id column="static_rule_id" property="staticRuleId"/>
+        <result column="static_rule_name" property="staticRuleName"/>
+        <result column="static_rule_create_time" property="staticRuleCreateTime"/>
+        <result column="static_rule_create_username" property="staticRuleCreateUsername"/>
+        <result column="static_rule_create_depart" property="staticRuleCreateDepart"/>
+        <result column="static_rule_used_task_id" property="staticRuleUsedTaskId"/>
+
+        <result column="static_rule_sip" property="staticRuleSip"/>
+        <result column="static_rule_sport" property="staticRuleSport"/>
+        <result column="static_rule_dip" property="staticRuleDip"/>
+        <result column="static_rule_mdip" property="staticRuleMdip"/>
+        <result column="static_rule_dport" property="staticRuleDport"/>
+        <result column="static_rule_protocol" property="staticRuleProtocol"/>
+    </resultMap>
+
+    <select id="queryStaticRule"  resultMap="staticRuleMap">
+        SELECT * FROM t_static_rule
+        <where>
+            <if test="static_rule_name != null and static_rule_name != ''">
+                static_rule_name like concat('%', #{static_rule_name}, '%')
+            </if>
+            <if test="static_rule_id != null">
+                AND static_rule_id = #{static_rule_id}
+            </if>
+        </where>
+        LIMIT ${(page - 1) * pageSize}, #{pageSize}
+    </select>
+
+    <select id="queryStaticRuleById" resultMap="staticRuleMap">
+        SELECT * FROM t_static_rule
+        WHERE static_rule_id = #{static_rule_id}
+    </select>
+
 </mapper>

src/test/java/com/realtime/protection/server/rule/staticrule/StaticRuleServiceTest.java

@@ -5,6 +5,8 @@ import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.time.LocalDateTime;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -16,20 +18,73 @@ public class StaticRuleServiceTest {
 
     @Test
     void testNewStaticRule(){
+        Integer i = 0;
+        while(i<20) {
+            i++;
             StaticRuleObject object = new StaticRuleObject();
 
-        object.setStaticRuleName("test_staticrule");
+            object.setStaticRuleName("test_staticrule" + i);
-        object.setStaticRuleCreateTime(LocalDateTime.now());
+            //object.setStaticRuleCreateTime(LocalDateTime.now());
-        object.setStaticRuleCreateUsername("boy");
+            object.setStaticRuleCreateUsername("boy" + i);
-        object.setStaticRuleCreateDepart("1chu");
+            object.setStaticRuleCreateDepart("2chu" + i);
-        object.setStaticRuleCreateUserId(22);
+            object.setStaticRuleCreateUserId(i);
-        object.setStaticRulePriority(1);
+            object.setStaticRuleSip("1.1.1." + i);
+            object.setStaticRuleSport(i);
+            object.setStaticRuleDip("2.2.3." + i);
+            object.setStaticRulePriority(2);
             object.setStaticRuleFrequency(1);
             object.setStaticRuleRange("北京");
             object.setStaticRuleProtectLevel(2);
 
             Integer id = staticRuleService.newStaticRuleObject(object);
-        assertTrue(id>0);
+        }
+        //assertTrue(id>0);
     }
 
+    @Test
+    void testDeleteStaticRule(){
+        int i = 0;
+        List<Integer> list = new ArrayList<>();
+        list.add(1);
+        while(i<2) {
+            i++;
+            staticRuleService.deleteStaticRule(list);
+        }
+    }
+    @Test
+    void testUpdateStaticRule(){
+
+        StaticRuleObject object = new StaticRuleObject();
+
+        object.setStaticRuleId(5);
+        object.setStaticRuleName("update_staticrule");
+        //object.setStaticRuleCreateTime(LocalDateTime.now());
+        //object.setStaticRuleCreateUsername("csy");
+        //object.setStaticRuleCreateDepart("mmeess");
+        //object.setStaticRuleCreateUserId(1);
+        object.setStaticRuleSip(null);
+        object.setStaticRuleSport(null);
+        object.setStaticRuleDip("2.2.3.100");
+        object.setStaticRulePriority(2);
+        object.setStaticRuleFrequency(1);
+        object.setStaticRuleRange("北京");
+        object.setStaticRuleProtectLevel(2);
+
+        staticRuleService.updateStaticRule(object);
+    }
+    @Test
+    void testQueryStaticRule(){
+
+        StaticRuleObject object = staticRuleService.queryStaticRuleById(7);
+        System.out.println(object);
+    }
+
+    @Test
+    void testQueryStaticRuleList(){
+
+        List<StaticRuleObject> objectList = staticRuleService.queryStaticRule(null,null,1,10);
+        System.out.println(objectList);
+    }
+
+
 }