Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplWithYearTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplWithYearTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplWithYearTest.java	(revision 41361)
@@ -0,0 +1,106 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+import java.sql.Date;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+/**
+ * HolidayConfigManagerImpl#withYear 单元测试类
+ */
+public class HolidayConfigManagerImplWithYearTest {
+    // 被测试的服务实例
+    @InjectMocks
+    @Spy
+    private HolidayConfigManagerImpl holidayConfigManager;
+    private AutoCloseable autoCloseable;
+    @Before
+    public void setUp() {
+        autoCloseable = MockitoAnnotations.openMocks(this);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        autoCloseable.close();
+    }
+
+    /**
+     * 测试正常年份查询
+     */
+    @Test
+    public void testWithYear_NormalYear_ReturnsHolidayConfigs() {
+        int year = 2024;
+
+        List<HolidayConfig> expectedList = Arrays.asList(
+                createHolidayConfig(11L, "2024-01-01", 1, "元旦"),
+                createHolidayConfig(12L, "2024-10-08", 2, "国庆节"));
+        doReturn(expectedList).when(holidayConfigManager).getByHql(anyString());
+
+        List<HolidayConfig> result = holidayConfigManager.withYear(year);
+
+        assertNotNull(result);
+        assertEquals(2, result.size());
+        assertEquals("2024-01-01", result.get(0).getDate().toString());
+        assertEquals("2024-10-08", result.get(1).getDate().toString());
+
+        String sql = "date between '2024-01-01' and '2024-12-31' order by date desc";
+        verify(holidayConfigManager).getByHql(sql);
+    }
+
+    /**
+     * 测试查询不存在数据的年份
+     */
+    @Test
+    public void testWithYear_NoDataForYear_ReturnsEmptyList() {
+        int year = 2099;
+
+        doReturn(Collections.emptyList()).when(holidayConfigManager).getByHql(anyString());
+
+        List<HolidayConfig> result = holidayConfigManager.withYear(year);
+
+        assertNotNull(result);
+        assertTrue(result.isEmpty());
+
+        verify(holidayConfigManager).getByHql(anyString());
+    }
+
+    /**
+     * 测试边界年份（如 0）的情况
+     */
+    @Test
+    public void testWithYear_BoundaryYear_ConstructsCorrectQuery() {
+        int year = 0;
+
+        doReturn(Collections.emptyList()).when(holidayConfigManager).getByHql(anyString());
+
+        List<HolidayConfig> result = holidayConfigManager.withYear(year);
+
+        assertNotNull(result);
+        assertTrue(result.isEmpty());
+
+        verify(holidayConfigManager).getByHql(argThat(sql ->
+                sql.contains("'0-01-01'") && sql.contains("'0-12-31'")
+        ));
+    }
+
+    private HolidayConfig createHolidayConfig(Long id, String date, Integer type, String remark) {
+        HolidayConfig config = new HolidayConfig();
+        config.setId(id);
+        config.setDate(Date.valueOf(date));
+        config.setType(type);
+        config.setRemark(remark);
+        return config;
+    }
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImpl.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImpl.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImpl.java	(revision 41361)
@@ -0,0 +1,156 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.disinfectsystem.basedatamanager.holiday.param.HolidayConfigParam;
+import com.forgon.disinfectsystem.common.params.PagerParam;
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import com.forgon.response.PagedDataResponse;
+import com.forgon.tools.hibernate.BasePoManagerImpl;
+import com.forgon.tools.util.ForgonDateUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.Calendar;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static com.forgon.tools.util.ForgonDateUtils.DATE_FORMAT_YYYYMMDD;
+
+@Service
+public class HolidayConfigManagerImpl extends BasePoManagerImpl<HolidayConfig> implements HolidayConfigManager {
+
+    @Override
+    public void save(HolidayConfigParam holidayConfig) {
+        validateParam(holidayConfig);
+        HolidayConfig entity = getFirst("date", holidayConfig.getDate());
+        if(entity != null) {
+            throw new RuntimeException("该日期已存在");
+        }
+        entity = new HolidayConfig(holidayConfig.getDate(), holidayConfig.getType(), holidayConfig.getRemark());
+        save(entity);
+    }
+
+    @Override
+    public void update(Long id, HolidayConfigParam holidayConfig) {
+        validateParam(holidayConfig);
+        HolidayConfig entity = get(id);
+        if (entity == null) {
+            throw new RuntimeException("该记录不存在");
+        }
+        entity.setDate(holidayConfig.getDate());
+        entity.setType(holidayConfig.getType());
+        entity.setRemark(holidayConfig.getRemark());
+        update(entity);
+    }
+
+    @Override
+    public List<HolidayConfig> withYear(int year) {
+        String condition = "date between '" + year + "-01-01' and '" + year + "-12-31' order by date desc";
+        return getByHql(condition);
+    }
+
+    @Override
+    public PagedDataResponse<HolidayConfig> list(PagerParam param, Integer year) {
+        String condition = "1=1";
+        if(year != null){
+            condition = "date between '" + year + "-01-01' and '" + year + "-12-31'";
+        }
+        int total = count(condition);
+        List<HolidayConfig> rows = getByHql(condition, param.getStart(), param.getLimit(), "date desc");
+        return new PagedDataResponse<>(total, rows);
+    }
+
+    @Override
+    public HolidayType holidayTypeOfToday() {
+        return holidayTypeOfDate(new java.util.Date());
+    }
+
+    @Override
+    public HolidayType holidayTypeOfDate(java.util.Date date) {
+        List<HolidayConfig> list = queryDateRange(date, 3);
+        if(CollectionUtils.isEmpty(list)){
+            return HolidayType.Normal;
+        }
+        Map<String, Integer> map = list.stream().collect(Collectors.toMap(config->date2Str(config.getDate()),
+                HolidayConfig::getType, (existing, replacement)->existing));
+        boolean prevHoliday = checkContinuousHoliday(date, map, -1, 3);
+        if(prevHoliday){
+            // 前面有3天假期，那就是3天假期之后的第1天
+            return HolidayType.LongAfter;
+        }
+        boolean nextHoliday = checkContinuousHoliday(date, map, 1, 3);
+        if(nextHoliday){
+            // 后面有3天假期，那就是3天假期之前的第1天
+            return HolidayType.LongBefore;
+        }
+        prevHoliday = checkContinuousHoliday(date, map, -1, 1);
+        if(prevHoliday){
+            // 只要前一天是假期，那无论再前天是不是假期，都是短假后的第1天。
+            return HolidayType.ShortAfter;
+        }
+        nextHoliday = checkContinuousHoliday(date, map, 1, 1);
+        if(nextHoliday){
+            return HolidayType.ShortBefore;
+        }
+        return HolidayType.Normal;
+    }
+
+    /**
+     * 查询某天前后指定天数范围内的假期配置
+     * @param date 查询的日期
+     * @param days 天数范围
+     * @return 假期配置列表
+     */
+    List<HolidayConfig> queryDateRange(java.util.Date date, int days) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(date);
+        cal.add(Calendar.DAY_OF_MONTH, -days);
+        String begin = ForgonDateUtils.safelyFormatDate(cal.getTime(), DATE_FORMAT_YYYYMMDD, "");
+        cal.add(Calendar.DAY_OF_MONTH, days*2);
+        String end = ForgonDateUtils.safelyFormatDate(cal.getTime(), DATE_FORMAT_YYYYMMDD, "");
+        return getByHql("date between '" + begin + "' and '" + end + "' order by date");
+    }
+
+    /**
+     * 检查指定方向的天数是否连续都是假期
+     * @param targetDate 目标日期
+     * @param holidayMap 节假日配置Map。key为日期，yyyy-MM-dd格式，value为type
+     * @param direction 方向：-1表示向前检查，1表示向后检查
+     * @param days 要检查的天数
+     * @return 如果连续都是假期返回true，否则返回false
+     */
+    private boolean checkContinuousHoliday(java.util.Date targetDate, Map<String, Integer> holidayMap,
+                                                  int direction, int days) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(targetDate);
+
+        for (int i = 1; i <= days; i++) {
+            calendar.add(Calendar.DAY_OF_MONTH, direction);
+            String checkDate = date2Str(calendar.getTime());
+
+            // 检查该日期是否是假期（type=1）
+            Integer type = holidayMap.get(checkDate);
+            if (type == null || type != 1) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private String date2Str(java.util.Date date) {
+        return ForgonDateUtils.safelyFormatDate(date, DATE_FORMAT_YYYYMMDD, "");
+    }
+
+    void validateParam(HolidayConfigParam param) {
+        if(param.getDate() == null) {
+            throw new RuntimeException("日期不能为空");
+        }
+        if(param.getType() == null) {
+            throw new RuntimeException("类型不能为空");
+        }
+        if(param.getType() < 0 || param.getType() > 2) {
+            throw new RuntimeException("类型错误");
+        }
+    }
+}
Fisheye: Tag 41361 refers to a dead (removed) revision in file `ssts-sterile/src/test/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/model/MonitoringPackageScanRuleTest.java'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: ssts-web/src/main/webapp/homepage/menuconfigure.js
===================================================================
diff -u -r41267 -r41361
--- ssts-web/src/main/webapp/homepage/menuconfigure.js	(.../menuconfigure.js)	(revision 41267)
+++ ssts-web/src/main/webapp/homepage/menuconfigure.js	(.../menuconfigure.js)	(revision 41361)
@@ -1152,6 +1152,7 @@
             {hidden :SSTS_Bioreader,text:"生物阅读器管理",href:WWWROOT+'/disinfectsystem/basedatamanager/bioreader/bioreaderView.jsp?editMode=true',hrefTarget:linkTarget,leaf:true},
             {hidden :(!sstsConfig.hasOwnProperty('disableDeviceInterface')) || sstsConfig.disableDeviceInterface,text:"设备接口管理",href:WWWROOT+'/disinfectsystem/basedatamanager/deviceInterface/deviceInterfaceView.jsp?editMode=true',hrefTarget:linkTarget,leaf:true},
             {hidden :SSTS_Expiration,text:"物品失效期管理",href:WWWROOT+'/disinfectsystem/basedatamanager/expirationDateInfo/expirationDateInfoView.jsp?editMode=true',hrefTarget:linkTarget,leaf:true},
+			{hidden :false,text:"假期及调休配置",href:WWWROOT+'/disinfectsystem/basedatamanager/holiday/holidayListView.jsp?editMode=true',hrefTarget:linkTarget,leaf:true},
             {hidden :SSTS_SupplyRoomType_manager,text:"PDA参数设置",href:WWWROOT+'/personalSetting/modifyExitLoginTime.jsp',hrefTarget:linkTarget,leaf:true},
             {hidden :SSTS_TechnicalDifficulty_manager,text:"技术难度管理",href:WWWROOT+'/disinfectsystem/basedatamanager/technicalDifficulty/technicalDifficultyView.jsp?editMode=true',hrefTarget:linkTarget,leaf:true},
             {hidden :SSTS_SupplyRoomType_manager,text:"仓库管理",href:WWWROOT+'/disinfectsystem/basedatamanager/warehouse/wareHouseView.jsp?editMode=true',hrefTarget:linkTarget,leaf:true},
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/HolidayConfigControllerTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/HolidayConfigControllerTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/HolidayConfigControllerTest.java	(revision 41361)
@@ -0,0 +1,92 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.controller;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.forgon.disinfectsystem.basedatamanager.holiday.param.HolidayConfigParam;
+import com.forgon.disinfectsystem.basedatamanager.holiday.service.HolidayConfigManager;
+import com.forgon.disinfectsystem.common.controller.GlobalControllerAdvice;
+import com.forgon.disinfectsystem.common.params.PagerParam;
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import com.forgon.response.OperatorResponse;
+import com.forgon.response.PagedDataResponse;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.MediaType;
+import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import java.sql.Date;
+import java.util.Collections;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = {ControllerTestConfig.class, HolidayConfigController.class, GlobalControllerAdvice.class})
+@WebAppConfiguration
+@Configuration
+public class HolidayConfigControllerTest {
+    @Autowired
+    private HolidayConfigController controller;
+    @Autowired
+    private HolidayConfigManager holidayConfigManager;
+    private final ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
+    private MockMvc mockMvc;
+
+    @Before
+    public void setup() {
+        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
+    }
+    @Test
+    public void testSave() throws Exception {
+        String res = mockMvc.perform(post("/disinfectSystem/baseData/holidayconfig")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("{\"date\": \"2025-10-05\", \"remark\": \"国庆节\", \"type\": 1}"))
+                .andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+        OperatorResponse or = objectMapper.readValue(res, OperatorResponse.class);
+        Assert.assertTrue(or.success());
+        verify(holidayConfigManager).save(new HolidayConfigParam(Date.valueOf("2025-10-05"), 1, "国庆节"));
+    }
+
+    @Test
+    public void testUpdate() throws Exception {
+        String res = mockMvc.perform(put("/disinfectSystem/baseData/holidayconfig/12")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("{\"id\": 1, \"date\": \"2025-10-05\", \"remark\": \"国庆节\", \"type\": 1}"))
+                .andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+        OperatorResponse or = objectMapper.readValue(res, OperatorResponse.class);
+        Assert.assertTrue(or.success());
+        verify(holidayConfigManager).update(12L, new HolidayConfigParam(Date.valueOf("2025-10-05"), 1, "国庆节"));
+    }
+
+    @Test
+    public void testDelete() throws Exception {
+        String res = mockMvc.perform(delete("/disinfectSystem/baseData/holidayconfig/22"))
+                .andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+        OperatorResponse or = objectMapper.readValue(res, OperatorResponse.class);
+        Assert.assertTrue(or.success());
+        verify(holidayConfigManager).delete(22L);
+    }
+
+    @Test
+    public void testLoadList() throws Exception {
+        PagedDataResponse<HolidayConfig> vo = new PagedDataResponse<>(21, Collections.singletonList(new HolidayConfig(14L, Date.valueOf("2025-10-05"), 1, "国庆节")));
+        doReturn(vo).when(holidayConfigManager).list(new PagerParam(10, 20), 2025);
+        String res = mockMvc.perform(get("/disinfectSystem/baseData/holidayconfig?start=10&limit=20&year=2025"))
+                .andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+        PagedDataResponse<HolidayConfig> or = objectMapper.readValue(res, new TypeReference<PagedDataResponse<HolidayConfig>>() {});
+        Assert.assertTrue(or.success());
+        Assert.assertEquals(vo, or);
+        verify(holidayConfigManager).list(new PagerParam(10, 20), 2025);
+    }
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/MonitoringPackageScanRuleParser.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/MonitoringPackageScanRuleParser.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/MonitoringPackageScanRuleParser.java	(revision 41361)
@@ -0,0 +1,57 @@
+package com.forgon.disinfectsystem.basedatamanager.sterilizer.service;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.forgon.disinfectsystem.basedatamanager.sterilizer.model.MonitoringPackageScanRule;
+import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer;
+import com.forgon.tools.json.JacksonUtil;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer.MONITORTOUSSEDISPLAY_IMPLANT;
+
+public class MonitoringPackageScanRuleParser {
+    public static List<MonitoringPackageScanRule> transformConfig(String config) {
+        try{
+            if(!StringUtils.hasText(config)){
+                return Collections.emptyList();
+            }
+            return JacksonUtil.objectMapper().readValue(config, new TypeReference<List<MonitoringPackageScanRule>>() {});
+        } catch (JsonProcessingException e) {
+            // 可能是旧配置，使用旧配置解析
+            List<MonitoringPackageScanRule> result = new ArrayList<>();
+            String[] monitorTousseDisplayArray = config.split(";");
+            for (String item : monitorTousseDisplayArray) {
+                MonitoringPackageScanRule cfg = parseConfigItem(item);
+                result.add(cfg);
+            }
+            return result;
+        }
+    }
+    /**
+     * 针对旧配置的解析
+     * @param oldConfig 旧的配置项，结构如：每炉(第1炉除外)_生物_化学，生物和化学的位置可能互换，如：每炉(第1炉除外)_化学_生物
+     * @return 对象化配置项
+     */
+    private static MonitoringPackageScanRule parseConfigItem(String oldConfig) {
+        MonitoringPackageScanRule cfg = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_EVERY_DAY, 1, oldConfig.contains("化学"), oldConfig.contains("生物"));
+        if(oldConfig.contains(Sterilizer.MONITORTOUSSEDISPLAY_EVERYTHING)){
+            cfg.setFrequency(-2);
+        }
+        if(oldConfig.contains(Sterilizer.MONITORTOUSSEDISPLAY_FIRST)){
+            cfg.setFrequency(1);
+        }
+        if(oldConfig.contains(MONITORTOUSSEDISPLAY_IMPLANT)){
+            cfg.setFrequency(-1);
+            cfg.setTrigger(MonitoringPackageScanRule.TRIGGER_IMPLANT);
+        }
+        if(oldConfig.contains(Sterilizer.MONITORTOUSSEDISPLAY_FOREIGN_TOUSSE)){
+            cfg.setFrequency(-1);
+            cfg.setTrigger(MonitoringPackageScanRule.TRIGGER_FOREIGN_TOUSSE);
+        }
+        return cfg;
+    }
+}
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplHolidayTypeOfDateTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplHolidayTypeOfDateTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplHolidayTypeOfDateTest.java	(revision 41361)
@@ -0,0 +1,229 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import com.forgon.tools.hibernate.ObjectDao;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.sql.Date;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+/**
+ * HolidayConfigManagerImpl#holidayTypeOfToday 单元测试类
+ */
+public class HolidayConfigManagerImplHolidayTypeOfDateTest {
+
+    @InjectMocks
+    private HolidayConfigManagerImpl holidayConfigManager;
+    @Mock
+    private ObjectDao objectDao;
+
+    private AutoCloseable autoCloseable;
+
+    @Before
+    public void setUp() {
+        autoCloseable = MockitoAnnotations.openMocks(this);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        autoCloseable.close();
+    }
+
+    /**
+     * 测试当查询结果为空时，返回 Normal
+     */
+    @Test
+    public void testHolidayTypeOfDate_EmptyList_ReturnsNormal() {
+        doReturn(Collections.emptyList()).when(objectDao).findByHql(anyString());
+        HolidayType result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2024-01-01"));
+        assertEquals(HolidayType.Normal, result);
+        verify(objectDao).findByHql("from HolidayConfig po where date between '2023-12-29' and '2024-01-04' order by date");
+    }
+
+    /**
+     * 测试前面连续3天是假期时，返回 LongAfter
+     */
+    @Test
+    public void testHolidayTypeOfDate_ThreeDaysBeforeHoliday_ReturnsLongAfter() {
+        List<HolidayConfig> configs = Arrays.asList(
+                createHolidayConfig("2024-01-01", 1),
+                createHolidayConfig("2024-01-02", 1),
+                createHolidayConfig("2024-01-03", 1)
+        );
+        doReturn(configs).when(objectDao).findByHql(anyString());
+
+        HolidayType result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2024-01-04"));
+        assertEquals(HolidayType.LongAfter, result);
+        verify(objectDao).findByHql("from HolidayConfig po where date between '2024-01-01' and '2024-01-07' order by date");
+    }
+
+    /**
+     * 测试后面连续3天是假期时，返回 LongBefore
+     */
+    @Test
+    public void testHolidayTypeOfDate_ThreeDaysAfterHoliday_ReturnsLongBefore() {
+        List<HolidayConfig> configs = Arrays.asList(
+                createHolidayConfig("2024-01-02", 1),
+                createHolidayConfig("2024-01-03", 1),
+                createHolidayConfig("2024-01-04", 1)
+        );
+        doReturn(configs).when(objectDao).findByHql(anyString());
+
+        HolidayType result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2024-01-01"));
+        assertEquals(HolidayType.LongBefore, result);
+        verify(objectDao).findByHql("from HolidayConfig po where date between '2023-12-29' and '2024-01-04' order by date");
+    }
+
+    /**
+     * 测试日期前连续1天是假期时，返回 ShortAfter
+     */
+    @Test
+    public void testHolidayTypeOfDate_OneDayBeforeHoliday_ReturnsShortAfter() {
+        List<HolidayConfig> configs = Collections.singletonList(
+                createHolidayConfig("2024-01-01", 1)
+        );
+        doReturn(configs).when(objectDao).findByHql(anyString());
+
+        HolidayType result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2024-01-02"));
+        assertEquals(HolidayType.ShortAfter, result);
+    }
+
+    /**
+     * 测试日期后连续1天是假期时，返回 ShortBefore
+     */
+    @Test
+    public void testHolidayTypeOfDate_OneDayAfterHoliday_ReturnsShortBefore() {
+        List<HolidayConfig> configs = Collections.singletonList(
+                createHolidayConfig("2024-01-02", 1)
+        );
+        doReturn(configs).when(objectDao).findByHql(anyString());
+
+        HolidayType result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2024-01-01"));
+        assertEquals(HolidayType.ShortBefore, result);
+    }
+
+    /**
+     * 测试当没有符合条件的假期时，返回 Normal
+     */
+    @Test
+    public void testHolidayTypeOfDate_NoMatchingHoliday_ReturnsNormal() {
+        List<HolidayConfig> configs = Arrays.asList(
+                createHolidayConfig("2024-01-03", 1),
+                createHolidayConfig("2024-01-05", 1)
+        );
+        doReturn(configs).when(objectDao).findByHql(anyString());
+
+        HolidayType result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2024-01-01"));
+        assertEquals(HolidayType.Normal, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2024-01-07"));
+        assertEquals(HolidayType.Normal, result);
+    }
+
+    /**
+     * 测试2026年元旦
+     */
+    @Test
+    public void testHolidayTypeOfDate_yuandan() {
+        List<HolidayConfig> configs = Arrays.asList(
+                createHolidayConfig("2026-01-01", 1),
+                createHolidayConfig("2026-01-02", 1),
+                createHolidayConfig("2026-01-03", 1),
+                createHolidayConfig("2026-01-04", 2)
+        );
+        doReturn(configs).when(objectDao).findByHql(anyString());
+
+        HolidayType result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2025-12-30"));
+        assertEquals(HolidayType.Normal, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2025-12-31"));
+        assertEquals(HolidayType.LongBefore, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-01-01"));
+        assertEquals(HolidayType.ShortBefore, result);   // 假期当天开炉，这不知道结果，按算法应该是后面2天假期，那就是短假前1天
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-01-02"));
+        assertEquals(HolidayType.ShortAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-01-03"));
+        assertEquals(HolidayType.ShortAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-01-04"));
+        assertEquals(HolidayType.LongAfter, result);
+    }
+
+    /**
+     * 测试春节场景
+     */
+    @Test
+    public void testHolidayTypeOfDate_SpringFestival() {
+        List<HolidayConfig> configs = Arrays.asList(
+                createHolidayConfig("2026-02-14", 2),
+                createHolidayConfig("2026-02-15", 1),
+                createHolidayConfig("2026-02-16", 1),
+                createHolidayConfig("2026-02-17", 1),
+                createHolidayConfig("2026-02-18", 1),
+                createHolidayConfig("2026-02-19", 1),
+                createHolidayConfig("2026-02-20", 1),
+                createHolidayConfig("2026-02-21", 1),
+                createHolidayConfig("2026-02-22", 1),
+                createHolidayConfig("2026-02-23", 1),
+                createHolidayConfig("2026-02-28", 2)
+        );
+        doReturn(configs).when(objectDao).findByHql(anyString());
+
+        HolidayType result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-13"));
+        assertEquals(HolidayType.Normal, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-14"));
+        assertEquals(HolidayType.LongBefore, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-15"));
+        assertEquals(HolidayType.LongBefore, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-16"));
+        assertEquals(HolidayType.LongBefore, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-17"));
+        assertEquals(HolidayType.LongBefore, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-18"));
+        assertEquals(HolidayType.LongAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-19"));
+        assertEquals(HolidayType.LongAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-20"));
+        assertEquals(HolidayType.LongAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-21"));
+        assertEquals(HolidayType.LongAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-22"));
+        assertEquals(HolidayType.LongAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-23"));
+        assertEquals(HolidayType.LongAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-24"));
+        assertEquals(HolidayType.LongAfter, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-25"));
+        assertEquals(HolidayType.Normal, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-26"));
+        assertEquals(HolidayType.Normal, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-27"));
+        assertEquals(HolidayType.Normal, result);
+        result = holidayConfigManager.holidayTypeOfDate(Date.valueOf("2026-02-28"));
+        assertEquals(HolidayType.Normal, result);
+    }
+
+    /**
+     * 创建 HolidayConfig 对象辅助测试
+     *
+     * @param dateStr 日期字符串（格式 yyyy-MM-dd）
+     * @param type    类型（1 表示假期）
+     * @return HolidayConfig 实例
+     */
+    private HolidayConfig createHolidayConfig(String dateStr, Integer type) {
+        HolidayConfig config = new HolidayConfig();
+        config.setDate(Date.valueOf(dateStr));
+        config.setType(type);
+        return config;
+    }
+}
Index: ssts-web/src/main/webapp/forgon4/forgonGrid4.js
===================================================================
diff -u -r22013 -r41361
--- ssts-web/src/main/webapp/forgon4/forgonGrid4.js	(.../forgonGrid4.js)	(revision 22013)
+++ ssts-web/src/main/webapp/forgon4/forgonGrid4.js	(.../forgonGrid4.js)	(revision 41361)
@@ -29,17 +29,18 @@
     extend: 'Ext.ux.GridPanel',
     constructor: function (opts) {
         opts = opts || {};
+        var disableSearching = opts.hasOwnProperty('enableSearching') && !opts.enableSearching;
         // opts = Ext.apply({}, opts);
         var me = this;
         opts = Ext4.apply(opts, {
             region: 'center',
             dataUrl: opts.dataUrl,
-            features: Ext4.create('Ext.ux.grid.feature.Searching', {
+            features: !disableSearching ? Ext4.create('Ext.ux.grid.feature.Searching', {
                 width: 150,
                 //禁止那些列参与查询
                 disableIndexes: opts.disableIndexes || []
                 // disableIndexes: []
-            }),
+            }) : null,
             fields: opts.fields,
             showPaging: opts.showPaging || true,
             //暂时屏蔽在toolbar上的导出excel按钮
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/model/MonitoringPackageScanRule.java
===================================================================
diff -u -r41351 -r41361
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/model/MonitoringPackageScanRule.java	(.../ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/model/MonitoringPackageScanRule.java)	(revision 41351)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/model/MonitoringPackageScanRule.java	(.../ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/model/MonitoringPackageScanRule.java)	(revision 41361)
@@ -1,18 +1,34 @@
-package com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model;
+package com.forgon.disinfectsystem.basedatamanager.sterilizer.model;
 
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+
 import java.util.Objects;
 
-import static com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer.MONITORTOUSSEDISPLAY_FOREIGN_TOUSSE;
-import static com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer.MONITORTOUSSEDISPLAY_IMPLANT;
-
 /**
  * 监测包扫描提示的配置
  */
 public class MonitoringPackageScanRule {
+    public static final Integer TRIGGER_EVERY_DAY = 1;
+    public static final Integer TRIGGER_WEEK_START = 2;
+    public static final Integer TRIGGER_WEEK_END = 8;
+    public static final Integer TRIGGER_SHORT_HOLIDAY_BEFORE = 9;
+    public static final Integer TRIGGER_SHORT_HOLIDAY_AFTER = 10;
+    public static final Integer TRIGGER_LONG_HOLIDAY_BEFORE = 11;
+    public static final Integer TRIGGER_LONG_HOLIDAY_AFTER = 12;
+    public static final Integer TRIGGER_IMPLANT = 101;
+    public static final Integer TRIGGER_FOREIGN_TOUSSE = 201;
     /**
-     * 触发条件
+     * 触发条件。这里触发条件没有优先级。当有多条配置时，只要计算得到生物监测和化学监测都需要扫描，则后续条件不再判断，因为已经得到最终结果了。
+     * 1-每天
+     * 2-8：每周日到周六提醒。如2是每周日提醒，8是每周六提醒，跟日历上的顺序一致
+     * 9-短假前第1天提醒
+     * 10-短假后第1天提醒
+     * 11-长假前第1天提醒
+     * 12-长假后第1天提醒
+     * 101: 有植入物时
+     * 201: 有外来器械包时
      */
-    private String trigger;
+    private Integer trigger;
     /**
      * 炉次。-1为全部，-2为第1炉除外。其他正值为对应的炉次。为0的话，应该当成无效值
      */
@@ -25,7 +41,7 @@
     public MonitoringPackageScanRule() {
     }
 
-    public MonitoringPackageScanRule(String trigger, Integer frequency, boolean chemicalPackageEnabled, boolean biologicalPackageEnabled) {
+    public MonitoringPackageScanRule(Integer trigger, Integer frequency, boolean chemicalPackageEnabled, boolean biologicalPackageEnabled) {
         this.trigger = trigger;
         this.frequency = frequency;
         int packageType = 0;
@@ -38,11 +54,11 @@
         this.packageType = packageType;
     }
 
-    public String getTrigger() {
+    public Integer getTrigger() {
         return trigger;
     }
 
-    public void setTrigger(String trigger) {
+    public void setTrigger(Integer trigger) {
         this.trigger = trigger;
     }
 
@@ -78,11 +94,11 @@
         return frequency == null ? 0 : frequency;
     }
 
-    public boolean isChemicalPackageEnabled() {
+    public boolean chemicalPackageEnabled() {
         return (packageTypeInt() & 1) == 1;
     }
 
-    public boolean isBiologicalPackageEnabled() {
+    public boolean biologicalPackageEnabled() {
         return (packageTypeInt() & 2) == 2;
     }
 
@@ -91,21 +107,59 @@
      * @return 是有植入物时触发返回true,否则返回false
      */
     public boolean triggerOfImplant() {
-        return MONITORTOUSSEDISPLAY_IMPLANT.equals(trigger);
+        return TRIGGER_IMPLANT.equals(trigger);
     }
 
     /**
      * 有外来器械包时触发
      * @return 是有外来器械包时触发返回true,否则返回false
      */
     public boolean triggerOfForeignTousse() {
-        return MONITORTOUSSEDISPLAY_FOREIGN_TOUSSE.equals(trigger);
+        return TRIGGER_FOREIGN_TOUSSE.equals(trigger);
     }
 
+    public boolean triggerOfEveryDay() {
+        return TRIGGER_EVERY_DAY.equals(trigger);
+    }
+
+    public boolean triggerOfWeekRange() {
+        int trg = triggerInt();
+        return TRIGGER_WEEK_START <= trg && trg <= TRIGGER_WEEK_END;
+    }
+
+    /**
+     * 触发条件为每周X
+     * @param week 周几,1到7，分别是周日到周六，跟日历一致
+     * @return 是每周X触发返回true,否则返回false
+     */
+    public boolean triggerOfWeek(int week) {
+        int trg = triggerInt();
+        return trg == (week - 1) + TRIGGER_WEEK_START;
+    }
+
+    public boolean triggerOfHolidayRange() {
+        int trg = triggerInt();
+        return TRIGGER_SHORT_HOLIDAY_BEFORE <= trg && trg <= TRIGGER_LONG_HOLIDAY_AFTER;
+    }
+
+    public boolean triggerOfHoliday(HolidayType holidayType) {
+        if(!triggerOfHolidayRange()) {
+            return false;
+        }
+        int holidayTypeStart = HolidayType.ShortBefore.ordinal();
+        int holidayTriggerStart = TRIGGER_SHORT_HOLIDAY_BEFORE;
+        int diff = holidayTypeStart - holidayTriggerStart;
+        return holidayType.ordinal() - diff == trigger;
+    }
+
     private int packageTypeInt() {
         return packageType == null ? 0 : packageType;
     }
 
+    private int triggerInt() {
+        return trigger == null ? 0 : trigger;
+    }
+
     @Override
     public boolean equals(Object object) {
         if (this == object) return true;
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplSaveTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplSaveTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplSaveTest.java	(revision 41361)
@@ -0,0 +1,82 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.param.HolidayConfigParam;
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+import java.sql.Date;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * HolidayConfigManagerImpl#save 单元测试类
+ */
+public class HolidayConfigManagerImplSaveTest {
+
+    // 被测试的服务实例
+    @InjectMocks
+    @Spy
+    private HolidayConfigManagerImpl holidayConfigManager;
+
+    private AutoCloseable autoCloseable;
+
+    @Before
+    public void setUp() {
+        autoCloseable = MockitoAnnotations.openMocks(this);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        autoCloseable.close();
+    }
+
+    /**
+     * TC01: 正常流程 —— 参数合法，日期不存在，成功保存
+     */
+    @Test
+    public void testSave_ValidParams_NoDuplicateDate_Success() {
+        HolidayConfigParam param = new HolidayConfigParam();
+        param.setDate(Date.valueOf("2025-01-01"));
+        param.setType(1);
+        param.setRemark("元旦");
+
+        // 模拟没有找到重复日期
+        doReturn(null).when(holidayConfigManager).getFirst(anyString(), any(Date.class));
+
+        // 模拟 save 方法不报错
+        doNothing().when(holidayConfigManager).save(any(HolidayConfig.class));
+
+        assertDoesNotThrow(() -> holidayConfigManager.save(param));
+        verify(holidayConfigManager).save(new HolidayConfig(Date.valueOf("2025-01-01"), 1, "元旦"));
+        verify(holidayConfigManager).validateParam(param);
+        verify(holidayConfigManager).getFirst("date", Date.valueOf("2025-01-01"));
+    }
+
+    /**
+     * TC02: 存在相同日期时应抛出异常
+     */
+    @Test
+    public void testSave_DuplicateDateExists_ThrowsException() {
+        HolidayConfigParam param = new HolidayConfigParam();
+        param.setDate(Date.valueOf("2025-01-01"));
+        param.setType(1);
+        param.setRemark("元旦");
+
+        // 模拟已经存在相同日期
+        HolidayConfig existingEntity = new HolidayConfig();
+        doReturn(existingEntity).when(holidayConfigManager).getFirst(anyString(), any(Date.class));
+
+        RuntimeException exception = assertThrows(RuntimeException.class, () -> holidayConfigManager.save(param));
+        assertEquals("该日期已存在", exception.getMessage());
+
+        // 确保不会继续执行 save 操作
+        verify(holidayConfigManager, never()).save(any(HolidayConfig.class));
+        verify(holidayConfigManager).validateParam(param);
+    }
+}
Index: ssts-sterile/src/test/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManagerImplIsHavedoneNeedNoticeSterilisationTest.java
===================================================================
diff -u -r41338 -r41361
--- ssts-sterile/src/test/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManagerImplIsHavedoneNeedNoticeSterilisationTest.java	(.../SterilizationRecordManagerImplIsHavedoneNeedNoticeSterilisationTest.java)	(revision 41338)
+++ ssts-sterile/src/test/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManagerImplIsHavedoneNeedNoticeSterilisationTest.java	(.../SterilizationRecordManagerImplIsHavedoneNeedNoticeSterilisationTest.java)	(revision 41361)
@@ -1,22 +1,29 @@
 package com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.service;
 
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.disinfectsystem.basedatamanager.holiday.service.HolidayConfigManager;
 import com.forgon.disinfectsystem.entity.basedatamanager.sterilisation.Sterilisation;
 import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.SterilizationFrequecyRemind;
 import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer;
 import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model.SterilisationNotice;
 import com.forgon.tools.hibernate.ObjectDao;
 import com.forgon.tools.json.JSONUtil;
+import com.forgon.tools.json.JacksonUtil;
+import com.forgon.tools.util.ForgonDateUtils;
 import net.sf.json.JSONObject;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import org.mockito.MockitoAnnotations;
 
 import java.util.ArrayList;
+import java.util.Calendar;
 import java.util.List;
 
+import static com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.SterilizationFrequecyRemind.*;
 import static com.forgon.tools.json.JacksonUtil.trans2JSONObject;
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
@@ -27,10 +34,12 @@
 public class SterilizationRecordManagerImplIsHavedoneNeedNoticeSterilisationTest {
 
     @InjectMocks
-    private SterilizationRecordManagerImpl sterilizationRecordManager;
+    private SterilisationNoticeCheckerImpl sterilisationNoticeChecker;
 
     @Mock
     private ObjectDao objectDao;
+    @Mock
+    private HolidayConfigManager holidayConfigManager;
 
     private AutoCloseable closeable;
 
@@ -54,7 +63,7 @@
         when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), eq(sterilizerName))).thenReturn(null);
 
         // Act
-        SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation(sterilizerName, "anyType", "1");
+        SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation(sterilizerName, "anyType", "1");
         JSONObject result = JSONObject.fromObject(notice);
         // Assert
         assertFalse(result.getBoolean("success"));
@@ -74,7 +83,7 @@
         when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), anyString())).thenReturn(sterilizer);
 
         // Act
-        SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation("valid", "anyType", "1");
+        SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "anyType", "1");
         JSONObject result = JSONObject.fromObject(notice);
 
         // Assert
@@ -102,7 +111,7 @@
         when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), anyString())).thenReturn(sterilizer);
 
         // Act
-        SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation("valid", "sameType", "1");
+        SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "sameType", "1");
         JSONObject result = JSONObject.fromObject(notice);
 
         // Assert
@@ -120,7 +129,7 @@
         SterilizationFrequecyRemind remind = new SterilizationFrequecyRemind();
         remind.setFrequency(1);
         remind.setSterilisation(sterilisation);
-        remind.setRemindMode(SterilizationFrequecyRemind.REMINDMODE_MANDATORY);
+        remind.setRemindMode(REMINDMODE_MANDATORY);
         when(sterilisation.getSterilisation()).thenReturn("correctType");
 
         List<SterilizationFrequecyRemind> reminds = new ArrayList<>();
@@ -130,16 +139,11 @@
         when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), anyString())).thenReturn(sterilizer);
 
         // Act
-        SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
+        SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
         JSONObject result = JSONObject.fromObject(notice);
 
         // Assert
-        assertFalse(result.getBoolean("success"));
-        assertEquals(SterilizationFrequecyRemind.REMINDMODE_MANDATORY, result.getString("remindMode"));
-        assertEquals("correctType", result.getString("sterilisation"));
-        assertEquals(1, result.getInt("frequency"));
-        assertTrue(result.containsKey("confirmMessage"));
-        assertTrue(result.getString("confirmMessage").contains("必须是"));
+        validateFalse(result, REMINDMODE_MANDATORY, "correctType", 1,"必须是");
     }
 
     /**
@@ -164,16 +168,72 @@
         when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), anyString())).thenReturn(sterilizer);
 
         // Act
-        SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
+        SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
         JSONObject result = JSONObject.fromObject(notice);
 
         // Assert
+        validateFalse(result, SterilizationFrequecyRemind.REMINDMODE_NONMANDATORY, "correctType", 1,"应该是");
+    }
+
+    @Test
+    public void testWithMultiReminder() {
+        Sterilizer sterilizer = mock(Sterilizer.class);
+        List<SterilizationFrequecyRemind> reminds = new ArrayList<>();
+        when(sterilizer.getSterilizationFrequecyReminds()).thenReturn(reminds);
+        SterilizationFrequecyRemind remind = buildReminder(REMINDMODE_MANDATORY, DATE_TYPE_EVERYDAY, 4, "P04");
+        reminds.add(remind);
+        remind = buildReminder(REMINDMODE_NONMANDATORY, DATE_TYPE_LONG_HOLIDAY_BEFORE, 4, "P02");
+        reminds.add(remind);
+        remind = buildReminder(REMINDMODE_NONMANDATORY, DATE_TYPE_WEEK_START+1, 1, "P11");
+        reminds.add(remind);
+        remind = buildReminder(REMINDMODE_MANDATORY, DATE_TYPE_LONG_HOLIDAY_BEFORE, 1, "P01");
+        reminds.add(remind);
+        remind = buildReminder(REMINDMODE_MANDATORY, DATE_TYPE_LONG_HOLIDAY_AFTER, 1, "D01");
+        reminds.add(remind);
+        remind = buildReminder(REMINDMODE_MANDATORY, DATE_TYPE_WEEK_START + 2, 1, "P21");
+        reminds.add(remind);
+
+        when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), anyString())).thenReturn(sterilizer);
+        when(holidayConfigManager.holidayTypeOfToday()).thenReturn(HolidayType.Normal);
+
+        try(MockedStatic<ForgonDateUtils> forgonDateUtils = mockStatic(ForgonDateUtils.class)){
+            forgonDateUtils.when(ForgonDateUtils::getDayWeekOfToday).thenReturn(Calendar.MONDAY);
+
+            // Act
+            SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
+            JSONObject result = JacksonUtil.trans2JSONObject(notice);
+
+            // Assert
+            validateFalse(result, SterilizationFrequecyRemind.REMINDMODE_NONMANDATORY, "P11", 1,"应该是");
+
+            when(holidayConfigManager.holidayTypeOfToday()).thenReturn(HolidayType.LongAfter);
+            notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
+            result = JacksonUtil.trans2JSONObject(notice);
+            validateFalse(result, SterilizationFrequecyRemind.REMINDMODE_MANDATORY, "D01", 1,"必须是");
+
+            when(holidayConfigManager.holidayTypeOfToday()).thenReturn(HolidayType.LongBefore);
+            notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
+            result = JacksonUtil.trans2JSONObject(notice);
+            validateFalse(result, SterilizationFrequecyRemind.REMINDMODE_MANDATORY, "P01", 1,"必须是");
+
+            notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "4");
+            result = JacksonUtil.trans2JSONObject(notice);
+            validateFalse(result, SterilizationFrequecyRemind.REMINDMODE_MANDATORY, "P04", 4,"必须是");
+
+            notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "3");
+            result = JacksonUtil.trans2JSONObject(notice);
+            assertTrue(result.getBoolean("success"));
+            assertFalse(result.containsKey("confirmMessage"));
+        }
+    }
+
+    private static void validateFalse(JSONObject result, String remindMode, String sterilisation, int frequency, String msgKey) {
         assertFalse(result.getBoolean("success"));
-        assertEquals(SterilizationFrequecyRemind.REMINDMODE_NONMANDATORY, result.getString("remindMode"));
-        assertEquals("correctType", result.getString("sterilisation"));
-        assertEquals(1, result.getInt("frequency"));
+        assertEquals(remindMode, result.getString("remindMode"));
+        assertEquals(sterilisation, result.getString("sterilisation"));
+        assertEquals(frequency, result.getInt("frequency"));
         assertTrue(result.containsKey("confirmMessage"));
-        assertTrue(result.getString("confirmMessage").contains("应该是"));
+        assertTrue(result.getString("confirmMessage").contains(msgKey));
     }
 
     /**
@@ -193,7 +253,7 @@
         reminds.add(remind);
         when(sterilizer.getSterilizationFrequecyReminds()).thenReturn(reminds);
         when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), anyString())).thenReturn(sterilizer);
-        SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
+        SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
         JSONObject result = trans2JSONObject(notice);
         assertTrue(result.getBoolean("success"));
         assertFalse(result.containsKey("confirmMessage"));
@@ -216,7 +276,7 @@
         reminds.add(remind);
         when(sterilizer.getSterilizationFrequecyReminds()).thenReturn(reminds);
         when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), anyString())).thenReturn(sterilizer);
-        SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
+        SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
         JSONObject result = trans2JSONObject(notice);
         assertTrue(result.getBoolean("success"));
         assertFalse(result.containsKey("confirmMessage"));
@@ -240,9 +300,20 @@
         reminds.add(remind);
         when(sterilizer.getSterilizationFrequecyReminds()).thenReturn(reminds);
         when(objectDao.getByProperty(eq("Sterilizer"), eq("name"), anyString())).thenReturn(sterilizer);
-        SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
+        SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation("valid", "wrongType", "1");
         JSONObject result = trans2JSONObject(notice);
         assertTrue(result.getBoolean("success"));
         assertFalse(result.containsKey("confirmMessage"));
     }
+
+    private SterilizationFrequecyRemind buildReminder(String remindMode, int dateType, int frequency, String sterilisation) {
+        Sterilisation ss = new Sterilisation();
+        ss.setSterilisation(sterilisation);
+        SterilizationFrequecyRemind remind = new SterilizationFrequecyRemind();
+        remind.setFrequency(frequency);
+        remind.setSterilisation(ss);
+        remind.setRemindMode(remindMode);
+        remind.setDateType(dateType);
+        return remind;
+    }
 }
Index: ssts-webservice/src/main/java/com/forgon/disinfectsystem/webservice/service/ServiceManagerImpl.java
===================================================================
diff -u -r41338 -r41361
--- ssts-webservice/src/main/java/com/forgon/disinfectsystem/webservice/service/ServiceManagerImpl.java	(.../ServiceManagerImpl.java)	(revision 41338)
+++ ssts-webservice/src/main/java/com/forgon/disinfectsystem/webservice/service/ServiceManagerImpl.java	(.../ServiceManagerImpl.java)	(revision 41361)
@@ -26,6 +26,7 @@
 import java.util.stream.Collectors;
 
 import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model.SterilisationNotice;
+import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.service.SterilisationNoticeChecker;
 import com.forgon.tools.json.*;
 import net.sf.json.JSONArray;
 import net.sf.json.JSONException;
@@ -338,6 +339,8 @@
 	@Autowired
 	private SterilizationRecordManager sterilizationRecordManager;
 	@Autowired
+	private SterilisationNoticeChecker sterilisationNoticeChecker;
+	@Autowired
 	private SterilisationManager sterilisationManager;
 	@Autowired
 	private OperationDefineDao operationDefineDao;
@@ -3104,7 +3107,7 @@
 			// 灭菌程序
 			JSONObject json = JSONUtil.buildJsonObject(true, sterileMethodToJson(sterilisation));
 			if(StringUtils.isNotBlank(sterilizerName) && StringUtils.isNotBlank(frequency)){
-				SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation(sterilizerName, barcodeName, frequency);
+				SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation(sterilizerName, barcodeName, frequency);
 				json = JacksonUtil.trans2JSONObject(notice);
 			}
 			json.put("data", sterileMethodToJson(sterilisation));
@@ -8379,7 +8382,7 @@
 		String sterilingType = params.optString("sterilingType");
 		String frequency = params.optString("frequency");
 		if(StringUtils.isNotBlank(sterilizerName) && StringUtils.isNotBlank(sterilingType) && StringUtils.isNotBlank(frequency)){
-			SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation(sterilizerName, sterilingType, frequency);
+			SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation(sterilizerName, sterilingType, frequency);
 			JSONUtil.addDataProperty(result, JacksonUtil.trans2JSONObject(notice));
 		}
 		return result.toString();
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManager.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManager.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManager.java	(revision 41361)
@@ -0,0 +1,51 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.disinfectsystem.basedatamanager.holiday.param.HolidayConfigParam;
+import com.forgon.disinfectsystem.common.params.PagerParam;
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import com.forgon.response.PagedDataResponse;
+import com.forgon.tools.hibernate.BasePoManager;
+
+import java.util.List;
+
+public interface HolidayConfigManager extends BasePoManager<HolidayConfig> {
+    /**
+     * 保存一个假期配置
+     * @param holidayConfig 假期配置
+     */
+    void save(HolidayConfigParam holidayConfig);
+    /**
+     * 更新一个假期配置
+     * @param id 假期配置id
+     * @param holidayConfig 假期配置
+     */
+    void update(Long id, HolidayConfigParam holidayConfig);
+    /**
+     * 查询一个年度的假期安装
+     * @param year 年份，比如2025年，值就是2025
+     * @return 对应年份的假期配置
+     */
+    List<HolidayConfig> withYear(int year);
+
+    /**
+     * 假期配置列表查询。分页查询
+     * @param param 分页参数
+     * @param year 年份，为空则查询所有年份
+     * @return 列表
+     */
+    PagedDataResponse<HolidayConfig> list(PagerParam param, Integer year);
+
+    /**
+     * 判断当天的假期类型。最多判断当天前3天和后3天，所以总共最多判断7天的日期就能得出结果
+     * @return 假期类型
+     */
+    HolidayType holidayTypeOfToday();
+
+    /**
+     * 判断指定日期的假期类型
+     * @param date 日期
+     * @return 假期类型
+     */
+    HolidayType holidayTypeOfDate(java.util.Date date);
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/HolidayConfigController.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/HolidayConfigController.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/HolidayConfigController.java	(revision 41361)
@@ -0,0 +1,44 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.controller;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.param.HolidayConfigParam;
+import com.forgon.disinfectsystem.basedatamanager.holiday.service.HolidayConfigManager;
+import com.forgon.disinfectsystem.common.params.PagerParam;
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import com.forgon.response.OperatorResponse;
+import com.forgon.response.PagedDataResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/disinfectSystem/baseData/holidayconfig")
+public class HolidayConfigController {
+    private final HolidayConfigManager holidayConfigManager;
+
+    @Autowired
+    public HolidayConfigController(HolidayConfigManager holidayConfigManager) {
+        this.holidayConfigManager = holidayConfigManager;
+    }
+
+    @RequestMapping(method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public OperatorResponse save(@RequestBody HolidayConfigParam holidayConfig) {
+        holidayConfigManager.save(holidayConfig);
+        return new OperatorResponse();
+    }
+
+    @RequestMapping(value = "/{id}", method = RequestMethod.PUT, produces = "application/json; charset=UTF-8")
+    public OperatorResponse update(@PathVariable Long id, @RequestBody HolidayConfigParam holidayConfig) {
+        holidayConfigManager.update(id, holidayConfig);
+        return new OperatorResponse();
+    }
+
+    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE, produces = "application/json; charset=UTF-8")
+    public OperatorResponse delete(@PathVariable Long id) {
+        holidayConfigManager.delete(id);
+        return new OperatorResponse();
+    }
+
+    @RequestMapping(method = RequestMethod.GET, produces = "application/json; charset=UTF-8")
+    public PagedDataResponse<HolidayConfig> loadList(PagerParam param, Integer year) {
+        return holidayConfigManager.list(param, year);
+    }
+}
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplListTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplListTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplListTest.java	(revision 41361)
@@ -0,0 +1,111 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.common.params.PagerParam;
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import com.forgon.response.PagedDataResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+import java.sql.Date;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+/**
+ * HolidayConfigManagerImpl#list 单元测试类
+ */
+public class HolidayConfigManagerImplListTest {
+
+    // 被测试的服务实例
+    @InjectMocks
+    @Spy
+    private HolidayConfigManagerImpl holidayConfigManager;
+
+    private AutoCloseable autoCloseable;
+
+    @Before
+    public void setUp() {
+        autoCloseable = MockitoAnnotations.openMocks(this);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        autoCloseable.close();
+    }
+
+    /**
+     * 测试当 year 为 null 时，构造条件为 "1=1" 的情况
+     */
+    @Test
+    public void testList_YearIsNull_CallsGetByHqlWithDefaultCondition() {
+        PagerParam param = new PagerParam(0, 10); // start=0, limit=10
+
+        List<HolidayConfig> expectedList = Collections.singletonList(createHolidayConfig(1L, "2024-01-01", 1, "元旦"));
+        doReturn(expectedList).when(holidayConfigManager).getByHql(eq("1=1"), anyInt(), anyInt(), anyString());
+        doReturn(11).when(holidayConfigManager).count("1=1");
+
+        PagedDataResponse<HolidayConfig> result = holidayConfigManager.list(param, null);
+
+        assertNotNull(result);
+        assertEquals(11, result.getTotal());
+        assertEquals(1, result.getRows().size());
+        assertEquals("2024-01-01", result.getRows().get(0).getDate().toString());
+
+        verify(holidayConfigManager).getByHql("1=1", 0, 10, "date desc");
+    }
+
+    /**
+     * 测试当 year 不为 null 时，构造具体年份范围的条件
+     */
+    @Test
+    public void testList_YearIsNotNull_CallsGetByHqlWithYearRangeCondition() {
+        PagerParam param = new PagerParam(5, 20); // start=5, limit=20
+        Integer year = 2024;
+
+        List<HolidayConfig> expectedList = Arrays.asList(
+                createHolidayConfig(11L, "2024-01-01", 1, "元旦"),
+                createHolidayConfig(12L, "2024-10-08", 2, "国庆节")
+        );
+        doReturn(expectedList).when(holidayConfigManager).getByHql(
+                eq("date between '2024-01-01' and '2024-12-31'"), anyInt(), anyInt(), anyString());
+        doReturn(2).when(holidayConfigManager).count("date between '2024-01-01' and '2024-12-31'");
+
+        PagedDataResponse<HolidayConfig> result = holidayConfigManager.list(param, year);
+
+        assertNotNull(result);
+        assertEquals(2, result.getTotal());
+        assertEquals(2, result.getRows().size());
+        assertEquals("2024-01-01", result.getRows().get(0).getDate().toString());
+        assertEquals("2024-10-08", result.getRows().get(1).getDate().toString());
+
+        verify(holidayConfigManager).getByHql("date between '2024-01-01' and '2024-12-31'", 5, 20, "date desc");
+    }
+
+    /**
+     * 创建一个 HolidayConfig 对象辅助测试
+     *
+     * @param id     ID
+     * @param date   日期字符串（格式 yyyy-MM-dd）
+     * @param type   类型
+     * @param remark 备注
+     * @return HolidayConfig 实例
+     */
+    private HolidayConfig createHolidayConfig(Long id, String date, Integer type, String remark) {
+        HolidayConfig config = new HolidayConfig();
+        config.setId(id);
+        config.setDate(Date.valueOf(date));
+        config.setType(type);
+        config.setRemark(remark);
+        return config;
+    }
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/action/SterilizerAction.java
===================================================================
diff -u -r36314 -r41361
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/action/SterilizerAction.java	(.../SterilizerAction.java)	(revision 36314)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/action/SterilizerAction.java	(.../SterilizerAction.java)	(revision 41361)
@@ -49,6 +49,8 @@
 import com.opensymphony.xwork2.ModelDriven;
 import com.opensymphony.xwork2.Preparable;
 
+import static com.forgon.disinfectsystem.basedatamanager.sterilizer.service.MonitoringPackageScanRuleParser.transformConfig;
+
 /**
  * @author WangYi 2012-2-15 下午04:55:28
  */
@@ -401,7 +403,7 @@
 	 */
 	public void loadSterilizer() {
 		JsonConfig config = new JsonConfig();
-		PropertyFilter propertyFilter = new JsonPropertyFilter(new String[] {});
+		PropertyFilter propertyFilter = new JsonPropertyFilter(new String[] {"monitorTousseDisplay"});
 		config.setJsonPropertyFilter(propertyFilter);
 		config.registerDefaultValueProcessor(Double.class,
 				new DefaultValueProcessor() {
@@ -426,6 +428,7 @@
 		map.put("sterilisationJsonData", getsterilisationJsonData());
 		map.put("consumptiveJsonData", getConsumptiveJsonData());
 		map.put("detectionJsonData", getDetectionJsonData());
+		map.put("monitoringPackageRules", transformConfig(sterilizer.getMonitorTousseDisplay()));
 		JSONObject jsonObject = JSONObject.fromObject(map, config);
 		StrutsResponseUtils.output(jsonObject);
 	}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManager.java
===================================================================
diff -u -r33037 -r41361
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManager.java	(.../SterilizerManager.java)	(revision 33037)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManager.java	(.../SterilizerManager.java)	(revision 41361)
@@ -58,8 +58,8 @@
 	
 	/**
 	 * 保存
-	 * @param sterilizer
-	 * @param cleanMethodIDs
+	 * @param sterilizer  灭菌炉
+	 * @param cleanMethodIDs 灭菌程序ID列表，以英文逗号分隔
 	 * @param consumablesStr
 	 * @param detectionItemsStr
 	 * @param extraInfo
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplUpdateTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplUpdateTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplUpdateTest.java	(revision 41361)
@@ -0,0 +1,129 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.param.HolidayConfigParam;
+import com.forgon.disinfectsystem.entity.basedatamanager.holiday.HolidayConfig;
+import com.forgon.tools.hibernate.ObjectDao;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.mockito.stubbing.Answer;
+
+import java.sql.Date;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.*;
+
+/**
+ * HolidayConfigManagerImpl#update 单元测试类
+ */
+public class HolidayConfigManagerImplUpdateTest {
+
+    @InjectMocks
+    @Spy
+    private HolidayConfigManagerImpl holidayConfigManager;
+
+    @Mock
+    private ObjectDao objectDao;
+
+    private AutoCloseable autoCloseable;
+
+    @Before
+    public void setUp() {
+        autoCloseable = MockitoAnnotations.openMocks(this);
+        // 注入mock的dao
+        holidayConfigManager.setObjectDao(objectDao);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        autoCloseable.close();
+    }
+
+    /**
+     * 测试：当id为null时，应抛出RuntimeException("该记录不存在")
+     */
+    @Test
+    public void testUpdate_IdIsNull_ThrowsRecordNotFound() {
+        HolidayConfigParam param = createValidHolidayConfigParam();
+        doReturn(null).when(holidayConfigManager).get((Long) null);
+
+        RuntimeException exception = assertThrows(RuntimeException.class,
+                () -> holidayConfigManager.update(null, param));
+
+        assertEquals("该记录不存在", exception.getMessage());
+    }
+
+    /**
+     * 测试：当id为-1时，应抛出RuntimeException("该记录不存在")
+     */
+    @Test
+    public void testUpdate_IdInvalid_ThrowsRecordNotFound() {
+        HolidayConfigParam param = createValidHolidayConfigParam();
+        doReturn(null).when(holidayConfigManager).get(anyLong());
+
+        RuntimeException exception = assertThrows(RuntimeException.class,
+                () -> holidayConfigManager.update(-1L, param));
+
+        assertEquals("该记录不存在", exception.getMessage());
+    }
+
+    /**
+     * 测试：当根据id找不到HolidayConfig实体时，抛出异常："该记录不存在"
+     */
+    @Test
+    public void testUpdate_EntityNotFound_ThrowsRecordNotFound() {
+        HolidayConfigParam param = createValidHolidayConfigParam();
+        doReturn(null).when(holidayConfigManager).get(anyLong());
+
+        RuntimeException exception = assertThrows(RuntimeException.class,
+                () -> holidayConfigManager.update(new Random().nextLong(), param));
+
+        assertEquals("该记录不存在", exception.getMessage());
+    }
+
+    /**
+     * 测试：正常情况下，能够正确更新HolidayConfig实体
+     */
+    @Test
+    public void testUpdate_ValidParams_SuccessfullyUpdatesEntity() {
+        HolidayConfigParam param = createValidHolidayConfigParam();
+        HolidayConfig existingEntity = new HolidayConfig();
+        existingEntity.setId(1L);
+        existingEntity.setDate(Date.valueOf("2023-01-01"));
+        existingEntity.setType(2);
+        existingEntity.setRemark("old remark");
+
+        doReturn(existingEntity).when(holidayConfigManager).get(1L);
+
+        doAnswer((Answer<Void>) invocation -> {
+            HolidayConfig updated = invocation.getArgument(0);
+            assertEquals(1L, updated.getId());
+            assertEquals(param.getDate(), updated.getDate());
+            assertEquals(param.getType(), updated.getType());
+            assertEquals(param.getRemark(), updated.getRemark());
+            return null;
+        }).when(holidayConfigManager).update(any(HolidayConfig.class));
+
+        holidayConfigManager.update(1L, param);
+
+        verify(holidayConfigManager).update(any(HolidayConfig.class));
+        verify(holidayConfigManager).validateParam(param);
+    }
+
+    // 辅助方法：创建合法的HolidayConfigParam对象
+    private HolidayConfigParam createValidHolidayConfigParam() {
+        HolidayConfigParam param = new HolidayConfigParam();
+        param.setDate(Date.valueOf("2024-01-01"));
+        param.setType(1);
+        param.setRemark("new remark");
+        return param;
+    }
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/param/SterilizationFrequencyRemindParam.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/param/SterilizationFrequencyRemindParam.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/param/SterilizationFrequencyRemindParam.java	(revision 41361)
@@ -0,0 +1,92 @@
+package com.forgon.disinfectsystem.basedatamanager.sterilizer.param;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.Objects;
+
+/**
+ * 按炉次提醒的灭菌程序参数
+ */
+public class SterilizationFrequencyRemindParam {
+    /**
+     * 提醒的日期类型。同时满足的情况下，优先级以长短假最高，星期次之，每天最低
+     * 1-每天
+     * 2-8：每周日到周六提醒。如2是每周日提醒，8是每周六提醒，跟日历上的顺序一致
+     * 9-短假前第1天提醒
+     * 10-短假后第1天提醒
+     * 11-长假前第1天提醒
+     * 12-长假后第1天提醒
+     */
+    private Integer dateType = 0;
+
+    /**
+     * 炉次。-1：全部炉次；-2：第1炉除外
+     */
+    private Integer frequency = 0;
+    /**
+     * 提醒方式
+     * 强制提醒和非强制提醒，默认为非强制提醒
+     */
+    private String remindMode = "";
+    /**
+     * 灭菌程序id
+     */
+    @JsonProperty("sterilisation_id")
+    private Long sterilisationId;
+
+    public Integer getDateType() {
+        return dateType;
+    }
+
+    public void setDateType(Integer dateType) {
+        this.dateType = dateType;
+    }
+
+    public Integer getFrequency() {
+        return frequency;
+    }
+
+    public void setFrequency(Integer frequency) {
+        this.frequency = frequency;
+    }
+
+    public String getRemindMode() {
+        return remindMode;
+    }
+
+    public void setRemindMode(String remindMode) {
+        this.remindMode = remindMode;
+    }
+
+    public Long getSterilisationId() {
+        return sterilisationId;
+    }
+
+    public void setSterilisationId(Long sterilisationId) {
+        this.sterilisationId = sterilisationId;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) return true;
+        if (!(object instanceof SterilizationFrequencyRemindParam)) return false;
+        SterilizationFrequencyRemindParam that = (SterilizationFrequencyRemindParam) object;
+        return Objects.equals(dateType, that.dateType) && Objects.equals(frequency, that.frequency)
+                && Objects.equals(remindMode, that.remindMode) && Objects.equals(sterilisationId, that.sterilisationId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(dateType, frequency, remindMode, sterilisationId);
+    }
+
+    @Override
+    public String toString() {
+        return "SterilizationFrequencyRemindParam{" +
+                "dateType=" + dateType +
+                ", frequency=" + frequency +
+                ", remindMode='" + remindMode + '\'' +
+                ", sterilisationId=" + sterilisationId +
+                '}';
+    }
+}
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManagerImplParseSterilizationFrequencyRemindsTest.java
===================================================================
diff -u -r41339 -r41361
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManagerImplParseSterilizationFrequencyRemindsTest.java	(.../SterilizerManagerImplParseSterilizationFrequencyRemindsTest.java)	(revision 41339)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManagerImplParseSterilizationFrequencyRemindsTest.java	(.../SterilizerManagerImplParseSterilizationFrequencyRemindsTest.java)	(revision 41361)
@@ -10,6 +10,8 @@
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -49,7 +51,8 @@
 
         // 创建 mock 返回的对象
         Sterilisation mockSterilisation = new Sterilisation();
-        when(objectDao.getById(Sterilisation.class.getSimpleName(), 10L)).thenReturn(mockSterilisation);
+        mockSterilisation.setId(10L);
+        when(objectDao.findByIds(Sterilisation.class.getSimpleName(), Arrays.asList(10L))).thenReturn(Collections.singletonList(mockSterilisation));
 
         // 执行方法
         List<SterilizationFrequecyRemind> result = sterilizerManager.parseSterilizationFrequencyReminds(inputJson);
@@ -58,12 +61,12 @@
         assertNotNull(result);
         assertEquals(1, result.size());
         SterilizationFrequecyRemind remind = result.get(0);
-//        assertEquals(Integer.valueOf(1), remind.getDateType());
+        assertEquals(Integer.valueOf(1), remind.getDateType());
         assertEquals(Integer.valueOf(2), remind.getFrequency());
         assertEquals("强制提醒", remind.getRemindMode());
         assertSame(mockSterilisation, remind.getSterilisation());
 
-        verify(objectDao).getById(Sterilisation.class.getSimpleName(), 10L);
+        verify(objectDao).findByIds(Sterilisation.class.getSimpleName(), Collections.singletonList(10L));
     }
 
     /**
@@ -88,11 +91,11 @@
         assertNotNull(result);
         assertEquals(1, result.size());
         SterilizationFrequecyRemind remind = result.get(0);
-//        assertEquals(0, remind.getDateType());       // 默认 0
+        assertEquals(0, remind.getDateType());       // 默认 0
         assertEquals(0, remind.getFrequency());      // 默认 0
         assertEquals("", remind.getRemindMode()); // 默认值
         assertNull(remind.getSterilisation());  // 未调用 getById
-        verify(objectDao).getById(Sterilisation.class.getSimpleName(), 0L);
+        verify(objectDao).findByIds(Sterilisation.class.getSimpleName(), Collections.emptyList());
     }
 
     /**
Index: ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilisationNoticeChecker.java
===================================================================
diff -u
--- ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilisationNoticeChecker.java	(revision 0)
+++ ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilisationNoticeChecker.java	(revision 41361)
@@ -0,0 +1,14 @@
+package com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.service;
+
+import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model.SterilisationNotice;
+
+public interface SterilisationNoticeChecker {
+    /**
+     * 验证灭菌炉某一炉次对应的灭菌程序是否正确(灭菌炉的“按炉次提醒的灭菌程序设置”中设置炉次对应的灭菌程序)
+     * @param sterilizerName  灭菌炉名称
+     * @param sterilizationType 灭菌程序
+     * @param frequency 炉次
+     * @return {success:true} or {success:false,message:**}
+     */
+    SterilisationNotice isHavedoneNeedNoticeSterilisation(String sterilizerName, String sterilizationType, String frequency);
+}
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/entity/basedatamanager/sterilizer/SterilizationFrequencyRemindTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/entity/basedatamanager/sterilizer/SterilizationFrequencyRemindTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/entity/basedatamanager/sterilizer/SterilizationFrequencyRemindTest.java	(revision 41361)
@@ -0,0 +1,65 @@
+package com.forgon.disinfectsystem.entity.basedatamanager.sterilizer;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import org.junit.Test;
+
+import java.util.Calendar;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class SterilizationFrequencyRemindTest {
+    @Test
+    public void testDateType() {
+        SterilizationFrequecyRemind remind = new SterilizationFrequecyRemind();
+        assertFalse(remind.dateTypeEveryday());
+        assertFalse(remind.dateTypeWeek());
+        assertFalse(remind.dateTypeShortHoliday());
+        assertFalse(remind.dateTypeLongHoliday());
+        remind.setDateType(1);
+        assertTrue(remind.dateTypeEveryday());
+        assertFalse(remind.dateTypeWeek());
+        assertFalse(remind.dateTypeShortHoliday());
+        assertFalse(remind.dateTypeLongHoliday());
+        for(int i = 2; i <= 8; i++) {
+            remind.setDateType(i);
+            assertFalse(remind.dateTypeEveryday());
+            assertTrue(remind.dateTypeWeek());
+            assertFalse(remind.dateTypeShortHoliday());
+            assertFalse(remind.dateTypeLongHoliday());
+            assertTrue(remind.dateTypeOfWeek(i - 1));
+            assertFalse(remind.dateTypeOfHoliday(HolidayType.ShortBefore));
+        }
+        remind.setDateType(9);
+        assertFalse(remind.dateTypeEveryday());
+        assertFalse(remind.dateTypeWeek());
+        assertTrue(remind.dateTypeShortHoliday());
+        assertFalse(remind.dateTypeLongHoliday());
+        assertTrue(remind.dateTypeOfHoliday(HolidayType.ShortBefore));
+        assertFalse(remind.dateTypeOfWeek(Calendar.SUNDAY));
+        remind.setDateType(10);
+        assertFalse(remind.dateTypeEveryday());
+        assertFalse(remind.dateTypeWeek());
+        assertTrue(remind.dateTypeShortHoliday());
+        assertFalse(remind.dateTypeLongHoliday());
+        assertTrue(remind.dateTypeOfHoliday(HolidayType.ShortAfter));
+        remind.setDateType(11);
+        assertFalse(remind.dateTypeEveryday());
+        assertFalse(remind.dateTypeWeek());
+        assertFalse(remind.dateTypeShortHoliday());
+        assertTrue(remind.dateTypeLongHoliday());
+        assertTrue(remind.dateTypeOfHoliday(HolidayType.LongBefore));
+        remind.setDateType(12);
+        assertFalse(remind.dateTypeEveryday());
+        assertFalse(remind.dateTypeWeek());
+        assertFalse(remind.dateTypeShortHoliday());
+        assertTrue(remind.dateTypeLongHoliday());
+        assertTrue(remind.dateTypeOfHoliday(HolidayType.LongAfter));
+        assertFalse(remind.dateTypeOfHoliday(HolidayType.LongBefore));
+        remind.setDateType(13);
+        assertFalse(remind.dateTypeEveryday());
+        assertFalse(remind.dateTypeWeek());
+        assertFalse(remind.dateTypeShortHoliday());
+        assertFalse(remind.dateTypeLongHoliday());
+    }
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManagerImpl.java
===================================================================
diff -u -r41339 -r41361
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManagerImpl.java	(.../SterilizerManagerImpl.java)	(revision 41339)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/service/SterilizerManagerImpl.java	(.../SterilizerManagerImpl.java)	(revision 41361)
@@ -1,26 +1,10 @@
 package com.forgon.disinfectsystem.basedatamanager.sterilizer.service;
 
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import net.sf.json.JSONArray;
-import net.sf.json.JSONObject;
-
-import org.apache.commons.collections.MapUtils;
-import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.lang.StringUtils;
-import org.hibernate.Query;
-
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.forgon.databaseadapter.service.DateQueryAdapter;
 import com.forgon.directory.model.BarcodeDevice;
 import com.forgon.disinfectsystem.basedatamanager.sterilisation.service.SterilisationManager;
+import com.forgon.disinfectsystem.basedatamanager.sterilizer.param.SterilizationFrequencyRemindParam;
 import com.forgon.disinfectsystem.basedatamanager.supplier.service.SupplierManager;
 import com.forgon.disinfectsystem.entity.basedatamanager.deviceinterface.DeviceInterface;
 import com.forgon.disinfectsystem.entity.basedatamanager.deviceinterface.JiangHanDatFileDetail;
@@ -31,13 +15,25 @@
 import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer;
 import com.forgon.disinfectsystem.entity.basedatamanager.supplier.Supplier;
 import com.forgon.disinfectsystem.entity.basedatamanager.supplyroomconfig.SupplyRoomConfig;
+import com.forgon.disinfectsystem.idpredicate.IDOperators;
 import com.forgon.serialnumber.model.SerialNum;
 import com.forgon.serialnumber.service.SerialNumManager;
 import com.forgon.tools.db.DatabaseUtil;
 import com.forgon.tools.hibernate.ObjectDao;
+import com.forgon.tools.json.JacksonUtil;
 import com.forgon.tools.string.StringTools;
 import com.forgon.tools.util.SqlUtils;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang.StringUtils;
+import org.hibernate.Query;
+import org.springframework.beans.BeanUtils;
 
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
 /**
  * @author WangYi
  */
@@ -312,19 +308,20 @@
 	}
 
 	List<SterilizationFrequecyRemind> parseSterilizationFrequencyReminds(String sterilizationFrequencyReminds) {
-		List<SterilizationFrequecyRemind> sterilizationFrequecyRemindList = new ArrayList<>();
-		JSONArray jsonArr = JSONArray.fromObject(sterilizationFrequencyReminds);
-		for(int i=0;i<jsonArr.size();i++){
-			JSONObject json = jsonArr.optJSONObject(i);
-			SterilizationFrequecyRemind sterilizationFrequecyRemind = new SterilizationFrequecyRemind();
-			sterilizationFrequecyRemind.setFrequency(json.optInt("frequency"));
-			sterilizationFrequecyRemind.setRemindMode(json.optString("remindMode"));
-			Long sterilisation_id = json.optLong("sterilisation_id");
-			Sterilisation sterilisation = (Sterilisation) objectDao.getById(Sterilisation.class.getSimpleName(), sterilisation_id);
-			sterilizationFrequecyRemind.setSterilisation(sterilisation);
-			sterilizationFrequecyRemindList.add(sterilizationFrequecyRemind);
+		List<SterilizationFrequencyRemindParam> list = JacksonUtil.parseObject(sterilizationFrequencyReminds, new TypeReference<List<SterilizationFrequencyRemindParam>>() {});
+		if(org.springframework.util.CollectionUtils.isEmpty(list)){
+			return Collections.emptyList();
 		}
-		return sterilizationFrequecyRemindList;
+		List<Long> sterilisationIdSet = list.stream().map(SterilizationFrequencyRemindParam::getSterilisationId).filter(Objects::nonNull).distinct().collect(Collectors.toList());
+		// 批量查询灭菌程序
+		List<Sterilisation> sterilisationList = objectDao.findByIds(Sterilisation.class.getSimpleName(), sterilisationIdSet);
+		return list.stream().map(item -> {
+			SterilizationFrequecyRemind remind = new SterilizationFrequecyRemind();
+			BeanUtils.copyProperties(item, remind);
+			Sterilisation sterilisation = IDOperators.find(sterilisationList, item.getSterilisationId());
+			remind.setSterilisation(sterilisation);
+			return remind;
+		}).collect(Collectors.toList());
 	}
 
 	@Override
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/ControllerTestConfig.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/ControllerTestConfig.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/controller/ControllerTestConfig.java	(revision 41361)
@@ -0,0 +1,14 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.controller;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.service.HolidayConfigManager;
+import org.mockito.Mockito;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ControllerTestConfig {
+    @Bean
+    public HolidayConfigManager holidayConfigManager() {
+        return Mockito.mock(HolidayConfigManager.class);
+    }
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/holiday/HolidayConfig.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/holiday/HolidayConfig.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/holiday/HolidayConfig.java	(revision 41361)
@@ -0,0 +1,119 @@
+package com.forgon.disinfectsystem.entity.basedatamanager.holiday;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.sql.Date;
+import java.util.Objects;
+
+/**
+ * 节假日配置项
+ */
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "HolidayConfig", indexes = @Index(name = "HolidayConfig_Date_IDX", columnList = "date", unique = true))
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class HolidayConfig {
+    /**
+     * 节假日配置表id
+     */
+    private Long id;
+    /**
+     * 节假日配置的日期
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private Date date;
+    /**
+     * 日期类型：1-节假日，2-假期调休的补班
+     */
+    private Integer type;
+    /**
+     * 假期的备注
+     */
+    private String remark;
+
+    public HolidayConfig() {
+    }
+
+    public HolidayConfig(Date date, Integer type, String remark) {
+        this.date = date;
+        this.type = type;
+        this.remark = remark;
+    }
+
+    public HolidayConfig(Long id, Date date, Integer type, String remark) {
+        this.id = id;
+        this.date = date;
+        this.type = type;
+        this.remark = remark;
+    }
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Date getDate() {
+        return date;
+    }
+
+    public void setDate(Date date) {
+        this.date = date;
+    }
+
+    public Integer getType() {
+        return type;
+    }
+
+    public void setType(Integer type) {
+        this.type = type;
+    }
+
+    public String getRemark() {
+        return remark;
+    }
+
+    public void setRemark(String remark) {
+        this.remark = remark;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) return true;
+        if (!(object instanceof HolidayConfig)) return false;
+        HolidayConfig that = (HolidayConfig) object;
+        return Objects.equals(id, that.id) && equals(date, that.date) && Objects.equals(type, that.type)
+                && Objects.equals(remark, that.remark);
+    }
+
+    private static boolean equals(Date date1, Date date2) {
+        if(date1 == date2) return true;
+        if(date1 == null || date2 == null) return false;
+        return date1.getYear() == date2.getYear() && date1.getMonth() == date2.getMonth() && date1.getDate() == date2.getDate();
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, date, type, remark);
+    }
+
+    @Override
+    public String toString() {
+        return "HolidayConfig{" +
+                "id=" + id +
+                ", date=" + date +
+                ", type=" + type +
+                ", remark='" + remark + '\'' +
+                '}';
+    }
+}
Index: ssts-web/src/main/webapp/disinfectsystem/basedatamanager/holiday/holidayListView.js
===================================================================
diff -u
--- ssts-web/src/main/webapp/disinfectsystem/basedatamanager/holiday/holidayListView.js	(revision 0)
+++ ssts-web/src/main/webapp/disinfectsystem/basedatamanager/holiday/holidayListView.js	(revision 41361)
@@ -0,0 +1,341 @@
+Ext4.onReady(function() {
+	var dt = new Date();
+	var startDayofMonth = dt.getFullYear() + "/" + (dt.getMonth() + 1) + "/01";
+	var formObj;
+	var windowObj;
+	var appGird ;
+	var gridStore;
+
+	function weekOfDay(date) {
+		if (!date) return ''
+		var isStr = Object.prototype.toString.call(date) === '[object String]';
+		var isNum = Object.prototype.toString.call(date) === '[object Number]';
+		if (isStr || isNum) {
+			date = new Date(date);
+		}
+		var isDate = Object.prototype.toString.call(date) === '[object Date]';
+		if (isDate) {
+			var weekdays = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
+			return weekdays[date.getDay()];
+		} else {
+			return '';
+		}
+	}
+
+	var recordFields = [{
+		name : 'id',
+		mapping : 'id'
+	},{
+		name : 'date',
+		mapping : 'date'
+	},{
+		name : 'weekday',
+		mapping : 'weekday'
+	},{
+		name : 'type',
+		mapping : 'type'
+	},{
+		name : 'remark',
+		mapping : 'remark'
+	}];
+
+	var recordColumns = [{
+		header : "日期",
+		dataIndex : 'date',
+		flex: 1,
+		filterable : false,
+		sortable: false
+	},{
+		header : "星期",
+		dataIndex : 'date',
+		flex: 1,
+		filterable : false,
+		sortable: false,
+		renderer: rendererWeekday
+	},{
+		header : "日期类型",
+		dataIndex : 'type',
+		flex: 1,
+		filterable : false,
+		sortable: false,
+		renderer: rendererType
+	},{
+		header : "备注",
+		dataIndex : 'remark',
+		flex: 2,
+		filterable : false,
+		sortable: false
+	}];
+
+	function rendererWeekday(value, metaData, record, rowIndex, colIndex,
+									store, view) {
+		return weekOfDay(value);
+	}
+
+	function rendererType (value) {
+		switch (value) {
+			case 1:
+				return '法定节假日';
+			case 2:
+				return '调休上班日';
+			default:
+				return '';
+		}
+	}
+
+	appGird = Ext4.create('ExtJs.forgon4.Grid',{
+		title: '节假日设置',
+		enableSearching: false,
+		dataUrl : WWWROOT + '/disinfectSystem/baseData/holidayconfig.mhtml',
+		dockedItems: [{
+			xtype: 'toolbar',
+			dock: 'top',
+			items: [{
+				xtype: 'button',
+				text: '添加',
+				iconCls: 'icon-add',
+				handler: function() {
+					showHolidayForm();
+				}
+			}, {
+				xtype: 'button',
+				text: '修改',
+				iconCls: 'icon-edit',
+				handler: function() {
+					var selection = appGird.getSelectionModel().getSelection();
+					if (selection.length === 1) {
+						showHolidayForm(selection[0]);
+					} else {
+						showResult('请选择一条记录进行修改')
+					}
+				}
+			}, {
+				xtype: 'button',
+				text: '删除',
+				iconCls: 'icon-remove',
+				handler: function() {
+					var selection = appGird.getSelectionModel().getSelection();
+					if (selection.length === 1) {
+						Ext4.Msg.confirm('确认', '确定要删除选中的记录吗？', function(btn) {
+							if (btn === 'yes') {
+								deleteHoliday(selection[0]);
+							}
+						});
+					} else {
+						showResult('请选择一条记录进行删除');
+					}
+				}
+			}]
+		}],
+		extraParams : {},  //如果你要自定义参数，这里一定要先给一个空的对象，要不然会报空异常
+		fields : recordFields,
+		columns : recordColumns,
+		listeners: {
+			itemdblclick: function(grid, record) {
+				showHolidayForm(record);
+			}
+		}
+	})
+	var viewport = Ext4.create('Ext4.Viewport', {
+		layout : 'fit',
+		items : appGird
+	});
+
+	gridStore = appGird.getStore();
+
+	// 创建节假日表单窗口
+	var holidayFormWindow = Ext4.create('Ext4.window.Window', {
+		title: '节假日设置',
+		width: 400,
+		height: 300,
+		layout: 'fit',
+		closeAction: 'hide',
+		modal: true,
+		resizable: true,
+		items: [{
+			xtype: 'form',
+			bodyPadding: 15,
+			border: false,
+			defaults: {
+				anchor: '100%',
+				labelWidth: 80,
+				allowBlank: false
+			},
+			items: [{
+				xtype: 'datefield',
+				fieldLabel: '日期',
+				name: 'date',
+				format: 'Y-m-d',
+				value: new Date(),
+				listeners: {
+					change: function(field, newValue) {
+						// 自动填写周几的信息
+						var weekdayField = field.up('form').down('[name=weekday]');
+						if (newValue) {
+							weekdayField.setValue(weekOfDay(newValue));
+						} else {
+							weekdayField.setValue('');
+						}
+					}
+				}
+			}, {
+				xtype: 'textfield',
+				fieldLabel: '星期',
+				name: 'weekday',
+				readOnly: true
+			}, {
+				xtype: 'combo',
+				fieldLabel: '日期类型',
+				name: 'type',
+				store: {
+					fields: ['type', 'name'],
+					data: [{
+						type: 1,
+						name: '法定节假日'
+					}, {
+						type: 2,
+						name: '调休上班日'
+					}]
+				},
+				displayField: 'name',
+				valueField: 'type',
+				queryMode: 'local',
+				value: 1,
+				editable: false
+			}, {
+				xtype: 'textfield',
+				fieldLabel: '备注',
+				name: 'remark',
+				allowBlank: true
+			}]
+		}],
+		buttons: [{
+			text: '保存',
+			iconCls: 'icon-save',
+			handler: function() {
+				saveHoliday();
+			}
+		}, {
+			text: '取消',
+			iconCls: 'icon-cancel',
+			handler: function() {
+				holidayFormWindow.hide();
+			}
+		}]
+	});
+
+	// 显示节假日表单
+	function showHolidayForm(record) {
+		var form = holidayFormWindow.down('form');
+		var weekdayField = form.down('[name=weekday]');
+		if (record) {
+			var weekday = weekOfDay(record.data.date);
+			// 编辑模式
+			form.loadRecord(record)
+			weekdayField.setValue(weekday)
+			holidayFormWindow.setTitle('修改节假日设置');
+			holidayFormWindow.record = record; // 保存当前编辑的记录
+		} else {
+			// 添加模式
+			form.getForm().reset();
+			holidayFormWindow.setTitle('添加节假日设置');
+			holidayFormWindow.record = null; // 清空记录引用
+
+			// 设置默认日期为今天
+			var dateField = form.down('[name=date]');
+			dateField.setValue(new Date());
+			weekdayField.setValue(weekOfDay(dateField.getValue()));
+		}
+
+		holidayFormWindow.show();
+	}
+
+	// 保存节假日（添加/修改）
+	function saveHoliday() {
+		var form = holidayFormWindow.down('form');
+		var values = form.getValues();
+		var record = holidayFormWindow.record;
+
+		if (!form.getForm().isValid()) {
+			showResult('请填写完整信息');
+			return;
+		}
+
+		var url = WWWROOT + '/disinfectSystem/baseData/holidayconfig.mhtml';
+		var method = 'POST';
+		var params = {
+			date: values.date,
+			type: values.type,
+			remark: values.remark
+		};
+
+		// 如果是修改，添加ID参数
+		if (record) {
+			var id = record.get('id');
+			url=WWWROOT + '/disinfectSystem/baseData/holidayconfig/' + id + '.mhtml';
+			method = 'PUT';
+		}
+
+		// 显示加载提示
+		Ext4.Msg.wait('保存中...', '请稍候');
+
+		// 发送请求到后端
+		Ext4.Ajax.request({
+			url: url,
+			method: method,
+			jsonData: params, // 使用jsonData作为请求体
+			headers: {
+				'Content-Type': 'application/json' // 设置Content-Type为JSON
+			},
+			success: function(response) {
+				Ext4.Msg.hide();
+				var result = Ext4.decode(response.responseText);
+
+				if (result.success) {
+					showResult('保存成功');
+					holidayFormWindow.hide();
+					gridStore.load(); // 重新加载数据
+				} else {
+					showResult(result.message || '保存失败');
+				}
+			},
+			failure: function(response) {
+				Ext4.Msg.hide();
+				showResult('网络请求失败，请稍后重试');
+			}
+		});
+	}
+
+	// 删除节假日
+	function deleteHoliday(record) {
+		if (!record) {
+			showResult('请选择要删除的记录');
+			return;
+		}
+
+		var id = record.get('id');
+
+		Ext4.Msg.wait('删除中...', '请稍候');
+
+		// 发送删除请求到后端
+		Ext4.Ajax.request({
+			url: WWWROOT + '/disinfectSystem/baseData/holidayconfig/'+id+'.mhtml',
+			method: 'DELETE',
+			success: function(response) {
+				Ext4.Msg.hide();
+				var result = Ext4.decode(response.responseText);
+
+				if (result.success) {
+					showResult('删除成功');
+					gridStore.load(); // 重新加载数据
+				} else {
+					showResult(result.message || '删除失败');
+				}
+			},
+			failure: function(response) {
+				Ext4.Msg.hide();
+				showResult('网络请求失败，请稍后重试');
+			}
+		});
+	}
+})
\ No newline at end of file
Fisheye: Tag 41361 refers to a dead (removed) revision in file `ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/model/MonitoringPackageScanRule.java'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/model/MonitoringPackageScanRuleTest.java
===================================================================
diff -u -r41351 -r41361
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/model/MonitoringPackageScanRuleTest.java	(.../ssts-sterile/src/test/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/model/MonitoringPackageScanRuleTest.java)	(revision 41351)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/model/MonitoringPackageScanRuleTest.java	(.../ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/sterilizer/model/MonitoringPackageScanRuleTest.java)	(revision 41361)
@@ -1,42 +1,47 @@
-package com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model;
+package com.forgon.disinfectsystem.basedatamanager.sterilizer.model;
 
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
 import org.junit.Test;
 
+import static com.forgon.disinfectsystem.basedatamanager.sterilizer.model.MonitoringPackageScanRule.TRIGGER_LONG_HOLIDAY_AFTER;
 import static org.junit.Assert.*;
 
 public class MonitoringPackageScanRuleTest {
 
     @Test
     public void testAll() {
-        MonitoringPackageScanRule cfg = new MonitoringPackageScanRule("trigger", 1, true, true);
-        assertEquals("trigger", cfg.getTrigger());
+        MonitoringPackageScanRule cfg = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_WEEK_START+1, 1, true, true);
+        assertTrue(cfg.triggerOfWeekRange());
         assertEquals(1, cfg.getFrequency().intValue());
         assertFalse(cfg.frequencyOfAll());
         assertFalse(cfg.frequencyOfExceptFirst());
-        assertTrue(cfg.isChemicalPackageEnabled());
-        assertTrue(cfg.isBiologicalPackageEnabled());
+        assertTrue(cfg.chemicalPackageEnabled());
+        assertTrue(cfg.biologicalPackageEnabled());
 
-        cfg = new MonitoringPackageScanRule("每天", -2, false, false);
-        assertEquals("每天", cfg.getTrigger());
+        cfg = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_EVERY_DAY, -2, false, false);
+        assertTrue(cfg.triggerOfEveryDay());
         assertTrue(cfg.frequencyOfExceptFirst());
         assertFalse(cfg.frequencyOfAll());
-        assertFalse(cfg.isChemicalPackageEnabled());
-        assertFalse(cfg.isBiologicalPackageEnabled());
+        assertFalse(cfg.chemicalPackageEnabled());
+        assertFalse(cfg.biologicalPackageEnabled());
 
-        cfg = new MonitoringPackageScanRule("周日", -1, true, false);
-        assertEquals("周日", cfg.getTrigger());
+        cfg = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_WEEK_START, -1, true, false);
+        assertTrue(cfg.triggerOfWeek(1));
+        assertTrue(cfg.triggerOfWeekRange());
         assertTrue(cfg.frequencyOfAll());
         assertFalse(cfg.frequencyOfExceptFirst());
-        assertTrue(cfg.isChemicalPackageEnabled());
-        assertFalse(cfg.isBiologicalPackageEnabled());
+        assertTrue(cfg.chemicalPackageEnabled());
+        assertFalse(cfg.biologicalPackageEnabled());
         assertFalse(cfg.frequencyOf(1));
 
-        cfg = new MonitoringPackageScanRule("长假后第1天", 2, false, true);
-        assertEquals("长假后第1天", cfg.getTrigger());
+        cfg = new MonitoringPackageScanRule(TRIGGER_LONG_HOLIDAY_AFTER, 2, false, true);
+        assertTrue(cfg.triggerOfHoliday(HolidayType.LongAfter));
+        assertTrue(cfg.triggerOfHolidayRange());
+        assertEquals(TRIGGER_LONG_HOLIDAY_AFTER, cfg.getTrigger());
         assertFalse(cfg.frequencyOfAll());
         assertFalse(cfg.frequencyOfExceptFirst());
         assertTrue(cfg.frequencyOf(2));
-        assertFalse(cfg.isChemicalPackageEnabled());
-        assertTrue(cfg.isBiologicalPackageEnabled());
+        assertFalse(cfg.chemicalPackageEnabled());
+        assertTrue(cfg.biologicalPackageEnabled());
     }
 }
Index: ssts-web/src/main/webapp/disinfectsystem/basedatamanager/sterilizer/sterilizerForm.js
===================================================================
diff -u -r41240 -r41361
--- ssts-web/src/main/webapp/disinfectsystem/basedatamanager/sterilizer/sterilizerForm.js	(.../sterilizerForm.js)	(revision 41240)
+++ ssts-web/src/main/webapp/disinfectsystem/basedatamanager/sterilizer/sterilizerForm.js	(.../sterilizerForm.js)	(revision 41361)
@@ -45,6 +45,7 @@
 			continue;
 		} else {
 			arr[i] = {
+				dateType: data.dateType,
 				frequency: data.frequency,
 				sterilisation_id: data.sterilisation_id,
 				remindMode: data.remindMode
@@ -197,6 +198,7 @@
 
 	var configStore1 = new Ext.data.SimpleStore({
 		fields: [
+			{ name: 'dateType'},
 			{ name: 'frequency' },
 			{ name: 'sterilisation' },
 			{ name: 'sterilisation_id' },
@@ -274,27 +276,112 @@
 		},
 		dataIndex: 'button'
 	}]);
+	// 灭菌程序EditGrid
+	var sterilisationEditGridPanel = new top.Ext.grid.EditorGridPanel({
+		id: 'configGrid',
+		store: configStore,
+		cm: cm,
+		width: 350,
+		height: 200,
+		frame: false,
+		viewConfig: {
+			forceFit: true
+		},
+		bodyStyle: 'border:1px solid #afd7af;margin-bottom:10px',
+		autoExpandColumn: 'cleaningMethodModel',
+		anchor: '100%',
+		clicksToEdit: 1,//设置点击几次才可编辑
+		selModel: new top.Ext.grid.RowSelectionModel({
+			singleSelect: false
+		}),
+		tbar: [{
+			text: '添加灭菌程序',
+			iconCls: 'btn_ext_add',
+			handler: function () {
+				var n = top.Ext.getCmp('configGrid').getStore().getCount();// 获得总行数
+				var p = new sterilisationConfig({
+					id: -1,
+					sterilisation: ''
+				});
+				top.Ext.getCmp('configGrid').stopEditing();// 停止编辑
+				configStore.add(p);// 插入到最后一行
+				top.Ext.getCmp('configGrid').startEditing(n, 0);// 开始编辑0单元格
+			}
+		}]
+	})
 
+	var dateTypeStore = new top.Ext.data.SimpleStore({
+		fields: [{ name: 'type', type: 'int'}, { name: 'text', type: 'string'}],
+		data: [[1, '每天'], [2, '周日'], [3, '周一'], [4, '周二'], [5, '周三'], [6, '周四'], [7, '周五'], [8, '周六'],
+			/*[9, '短假前1天'],  [10, '短假后1天'],*/ [11, '长假前1天'], [12, '长假后1天']]
+	});
+
+	var frequencyStore = new top.Ext.data.SimpleStore({
+		fields: [{ name: 'type', type: 'int'}, { name: 'text', type: 'string'}],
+		data: [/*[-1, '全部'],[-2, '第1炉除外'],*/[1, '1'], [2, '2'], [3, '3']]
+	});
+
 	var cm1 = new top.Ext.grid.ColumnModel([{
 		id: 'sterilisation_id',
 		name: 'sterilisation_id',
 		dataIndex: 'sterilisation_id',
 		hidden: true
+	},{
+		id: 'dateType',
+		name: 'dateType',
+		dataIndex: 'dateType',
+		 header: "日期类型",
+		width: 120,
+		 editor: new top.Ext.form.ComboBox({
+			 xtype: 'combo',
+			 store: dateTypeStore,
+			 valueField: 'type',
+			 displayField: 'text',
+			 mode: 'local',
+			 value: 1,
+			 forceSelection: true,
+			 allowBlank: false,
+			 triggerAction: 'all',
+			 anchor: '97%'
+		 }),
+		 renderer: function(value) {
+			// 根据值找到对应的显示文本
+			var record = dateTypeStore.find('type', value);
+			if (record !== -1) {
+				return dateTypeStore.getAt(record).get('text');
+			}
+			return value; // 如果找不到，返回原始值
+		 }
 	}, {
 		id: 'frequency',
 		name: 'frequency',
 		dataIndex: 'frequency',
 		header: "炉次",
-		editor: new top.Ext.form.NumberField({
-			allowDecimals: false,
-			allowNegative: false,
-			maxValue: 10000,
-			minValue: 1
-		})
+		width: 120,
+		editor: new top.Ext.form.ComboBox({
+			xtype: 'combo',
+			store: frequencyStore,
+			valueField: 'type',
+			 displayField: 'text',
+			 mode: 'local',
+			 value: 1,
+			 forceSelection: true,
+			 allowBlank: false,
+			 triggerAction: 'all',
+			 anchor: '97%'
+		}),
+		renderer: function(value) {
+			// 根据值找到对应的显示文本
+			var record = frequencyStore.find('type', value);
+			if (record !== -1) {
+				return frequencyStore.getAt(record).get('text');
+			}
+			return value; // 如果找不到，返回原始值
+		}
 	}, {
 		id: 'sterilisation',
 		header: "灭菌程序",
-		width: 240,
+		width: 180,
 		dataIndex: 'sterilisation',
 		editor: new top.Ext.form.ComboBox({
 			xtype: 'combo',
@@ -336,7 +423,7 @@
 	}, {
 		id: 'remindMode',
 		header: "提醒方式",
-		width: 240,
+		width: 140,
 		dataIndex: 'remindMode',
 		editor: new top.Ext.form.ComboBox({
 			xtype: 'combo',
@@ -365,7 +452,233 @@
 		},
 		dataIndex: 'button'
 	}]);
+	// 按炉次提醒灭菌程序编辑控件
+	var sterilisationReminderEditGridPanel = new top.Ext.grid.EditorGridPanel({
+		id: 'configGrid1',
+		store: configStore1,
+		cm: cm1,
+		width: 350,
+		height: 140,
+		frame: false,
+		viewConfig: {
+			forceFit: true
+		},
+		bodyStyle: 'border:1px solid #afd7af;margin-bottom:10px',
+		autoExpandColumn: 'cleaningMethodModel',
+		anchor: '100%',
+		clicksToEdit: 1,//设置点击几次才可编辑
+		selModel: new top.Ext.grid.RowSelectionModel({
+			singleSelect: false
+		}),
+		tbar: [{
+			text: '按炉次提醒的灭菌程序',
+			iconCls: 'btn_ext_add',
+			handler: function () {
+				var n = top.Ext.getCmp('configGrid1').getStore().getCount();// 获得总行数
+				var p = new sterilisationConfig({
+					frequency: '',
+					sterilisation: '',
+					sterilisation_id: '',
+					remindMode: '非强制提醒'
+				});
+				// if (n >= 3) {
+				// 	showResult('最多允许添加三个炉次提醒的灭菌程序!');
+				// 	return;
+				// }
+				top.Ext.getCmp('configGrid1').stopEditing();// 停止编辑
+				configStore1.add(p);// 插入到最后一行
+				top.Ext.getCmp('configGrid1').startEditing(n, 0);// 开始编辑0单元格
+			}
+		}]
+	})
 
+	var monitoringPackageTriggerStore = new top.Ext.data.SimpleStore({
+		fields: [{ name: 'type', type: 'int'}, { name: 'text', type: 'string'}],
+		data: [[1, '每天'], [2, '周日'], [3, '周一'], [4, '周二'], [5, '周三'], [6, '周四'], [7, '周五'], [8, '周六'],
+			/*[9, '短假前1天'],  [10, '短假后1天'],*/ [11, '长假前1天'], [12, '长假后1天'], [101, '有植入物时'], [201, '有外来器械包时']]
+	});
+
+	var monitoringPackageFrequencyStore = new top.Ext.data.SimpleStore({
+		fields: [{ name: 'type', type: 'int'}, { name: 'text', type: 'string'}],
+		data: [[-1, '全部'],[-2, '第1炉除外'],[1, '1'], [2, '2'], [3, '3']]
+	});
+
+	var MonitoringPackageGridRecord = Ext.data.Record.create([{
+		name: 'trigger',
+		name: 'frequency',
+		name: 'packageType'
+	}]);
+
+	var monitoringPackageGridStore = new Ext.data.SimpleStore({
+		fields: [
+			{ name: 'trigger'},
+			{ name: 'frequency' },
+			{ name: 'packageType' }
+		]
+	});
+
+	var monitoringPackageColumnModel = new top.Ext.grid.ColumnModel([{
+		dataIndex: 'trigger',
+		header: "触发条件",
+		width: 120,
+		editor: new top.Ext.form.ComboBox({
+			xtype: 'combo',
+			store: monitoringPackageTriggerStore,
+			valueField: 'type',
+			displayField: 'text',
+			mode: 'local',
+			value: 1,
+			forceSelection: true,
+			allowBlank: false,
+			triggerAction: 'all',
+			anchor: '97%'
+		}),
+		renderer: function(value) {
+			// 根据值找到对应的显示文本
+			var record = monitoringPackageTriggerStore.find('type', value);
+			if (record !== -1) {
+				return monitoringPackageTriggerStore.getAt(record).get('text');
+			}
+			return value; // 如果找不到，返回原始值
+		}
+	}, {
+		dataIndex: 'frequency',
+		header: "炉次",
+		width: 120,
+		editor: new top.Ext.form.ComboBox({
+			xtype: 'combo',
+			store: monitoringPackageFrequencyStore,
+			valueField: 'type',
+			displayField: 'text',
+			mode: 'local',
+			value: 1,
+			forceSelection: true,
+			allowBlank: false,
+			triggerAction: 'all',
+			anchor: '97%'
+		}),
+		renderer: function(value) {
+			// 根据值找到对应的显示文本
+			var record = monitoringPackageFrequencyStore.find('type', value);
+			if (record !== -1) {
+				return monitoringPackageFrequencyStore.getAt(record).get('text');
+			}
+			return value; // 如果找不到，返回原始值
+		}
+	}, {
+		header: "监测包类型",
+		width: 180,
+		dataIndex: 'packageType',
+		renderer: function(value, metadata, record, rowIndex) {
+			// 为每个 checkbox 创建独立的容器
+			var id1 = 'monitor-package-column-chemical' + rowIndex;
+			var id2 = 'monitor-package-column-biological' + rowIndex;
+
+			// 延迟创建实际的 Checkbox 组件
+			setTimeout(function () {
+				var cb1 = top.Ext.getCmp(id1);
+				if (cb1) {
+					cb1.destroy();
+				}
+				new top.Ext.form.Checkbox({
+					id: id1,
+					renderTo: id1,
+					cls: 'sterilizerCheckbox',
+					boxLabel: '化学',
+					checked: ((record.get('packageType') || 0) & 1) === 1,
+					listeners: {
+						check: function (cb, checked) {
+							var packageType = (record.get('packageType') || 0)
+							if (checked) {
+								packageType |= 1;
+							} else {
+								packageType &= ~1;
+							}
+							record.set('packageType', packageType);
+						}
+					}
+				});
+				var cb2 = top.Ext.getCmp(id2);
+				if (cb2) {
+					cb2.destroy();
+				}
+				new top.Ext.form.Checkbox({
+					id: id2,
+					renderTo: id2,
+					cls: 'sterilizerCheckbox',
+					boxLabel: '生物',
+					checked: ((record.get('packageType') || 0) & 2) === 2,
+					listeners: {
+						check: function (cb, checked) {
+							var packageType = (record.get('packageType') || 0)
+							if (checked) {
+								packageType |= 2;
+							} else {
+								packageType &= ~2;
+							}
+							record.set('packageType', packageType);
+						}
+					}
+				});
+			}, 0);
+
+			return [
+				'<div style="display: flex; flex-direction: row;align-items: center; gap: 10px; height: 100%;">',
+				'<div id="' + id1 + '" style="display: inline-flex;align-items: center;line-height: normal;"></div>',
+				'<div id="' + id2 + '" style="display: inline-flex;align-items: center;line-height: normal;"></div>',
+				'</div>'
+			].join('');
+		}
+	}, {
+		header: '删除',
+		renderer: function (v, p, record) {
+			var str = "<img src=\"" + WWWROOT + "/images/web/stop.png\" onclick=\"getCurrentTab().removeGridItem('monitoringPackageGrid') \">";
+			return str;
+		},
+		dataIndex: 'button'
+	}]);
+	var enableScanSterilizationMonitoringPackage = false;
+	if(sstsConfig.enableSterilizerConsumptiveMaterialConsumptionFunction){
+		enableScanSterilizationMonitoringPackage = false;
+	}else {
+		enableScanSterilizationMonitoringPackage = sstsConfig.enableScanSterilizationMonitoringPackage;
+	}
+	// 监测包扫描提示默认值编辑控件
+	var monitoringPackageEditGridPanel = new top.Ext.grid.EditorGridPanel({
+		id: 'monitoringPackageGrid',
+		hidden: !enableScanSterilizationMonitoringPackage,
+		store: monitoringPackageGridStore,
+		cm: monitoringPackageColumnModel,
+		width: 350,
+		height: 140,
+		frame: false,
+		viewConfig: {
+			forceFit: true
+		},
+		bodyStyle: 'border:1px solid #afd7af;margin-bottom:10px',
+		autoExpandColumn: 'cleaningMethodModel',
+		anchor: '100%',
+		clicksToEdit: 1,//设置点击几次才可编辑
+		selModel: new top.Ext.grid.RowSelectionModel({
+			singleSelect: false
+		}),
+		tbar: [{
+			text: '监测包扫描提示默认值',
+			iconCls: 'btn_ext_add',
+			handler: function () {
+				var n = top.Ext.getCmp('monitoringPackageGrid').getStore().getCount();// 获得总行数
+				var p = new MonitoringPackageGridRecord({
+					trigger: 1,
+					frequency: -1,
+					packageType: 0
+				});
+				top.Ext.getCmp('monitoringPackageGrid').stopEditing();// 停止编辑
+				monitoringPackageGridStore.add(p);// 插入到最后一行
+				top.Ext.getCmp('monitoringPackageGrid').startEditing(n, 0);// 开始编辑0单元格
+			}
+		}]
+	})
+
 	var consumableCm = new top.Ext.grid.ColumnModel([{
 		id: 'id',
 		name: 'id',
@@ -452,13 +765,6 @@
 		)
 	});
 
-	var enableScanSterilizationMonitoringPackage = false;
-	if(sstsConfig.enableSterilizerConsumptiveMaterialConsumptionFunction){
-		enableScanSterilizationMonitoringPackage = false;
-	}else {
-		enableScanSterilizationMonitoringPackage = sstsConfig.enableScanSterilizationMonitoringPackage;
-	}
-
 	formObj = new top.Ext.FormPanel({
 		id: 'sterilizerForm',
 		frame: true,
@@ -1169,75 +1475,7 @@
 				columnWidth: 0.4,
 				layout: 'form',
 				labelWidth: 70,
-				items: [new top.Ext.grid.EditorGridPanel({
-					id: 'configGrid',
-					store: configStore,
-					cm: cm,
-					width: 350,
-					height: 200,
-					frame: false,
-					viewConfig: {
-						forceFit: true
-					},
-					bodyStyle: 'border:1px solid #afd7af;margin-bottom:10px',
-					autoExpandColumn: 'cleaningMethodModel',
-					anchor: '100%',
-					clicksToEdit: 1,//设置点击几次才可编辑 
-					selModel: new top.Ext.grid.RowSelectionModel({
-						singleSelect: false
-					}),
-					tbar: [{
-						text: '添加灭菌程序',
-						iconCls: 'btn_ext_add',
-						handler: function () {
-							var n = top.Ext.getCmp('configGrid').getStore().getCount();// 获得总行数 
-							var p = new sterilisationConfig({
-								id: -1,
-								sterilisation: ''
-							});
-							top.Ext.getCmp('configGrid').stopEditing();// 停止编辑 
-							configStore.add(p);// 插入到最后一行 
-							top.Ext.getCmp('configGrid').startEditing(n, 0);// 开始编辑0单元格 
-						}
-					}]
-				}), new top.Ext.grid.EditorGridPanel({
-					id: 'configGrid1',
-					store: configStore1,
-					cm: cm1,
-					width: 350,
-					height: 140,
-					frame: false,
-					viewConfig: {
-						forceFit: true
-					},
-					bodyStyle: 'border:1px solid #afd7af;margin-bottom:10px',
-					autoExpandColumn: 'cleaningMethodModel',
-					anchor: '100%',
-					clicksToEdit: 1,//设置点击几次才可编辑 
-					selModel: new top.Ext.grid.RowSelectionModel({
-						singleSelect: false
-					}),
-					tbar: [{
-						text: '按炉次提醒的灭菌程序',
-						iconCls: 'btn_ext_add',
-						handler: function () {
-							var n = top.Ext.getCmp('configGrid1').getStore().getCount();// 获得总行数 
-							var p = new sterilisationConfig({
-								frequency: '',
-								sterilisation: '',
-								sterilisation_id: '',
-								remindMode: '非强制提醒'
-							});
-							if (n >= 3) {
-								showResult('最多允许添加三个炉次提醒的灭菌程序!');
-								return;
-							}
-							top.Ext.getCmp('configGrid1').stopEditing();// 停止编辑 
-							configStore1.add(p);// 插入到最后一行 
-							top.Ext.getCmp('configGrid1').startEditing(n, 0);// 开始编辑0单元格 
-						}
-					}]
-				})]
+				items: [sterilisationEditGridPanel, sterilisationReminderEditGridPanel, monitoringPackageEditGridPanel]
 			}, {
 				columnWidth: 0.49,
 				layout: 'column',
@@ -1338,169 +1576,11 @@
 				columnWidth: 0.49,
 				layout: 'column',
 				xtype: 'fieldset',
-				title: '监测包扫描提示默认值',
+				title: '监测包扫描提示默认值,之前的，目前不用了，这里占位',
 				height: 38,
 				autoHeight: true,
 				bodyStyle: 'margin:10px 0 !important',
-				hidden: enableScanSterilizationMonitoringPackage ? false : true,
-				items: [{
-					layout: 'column',
-					columnWidth: 0.45,
-					items: [{
-						layout: 'form',
-						labelWidth: 70,
-						labelAlign: 'right',
-						items: [{
-							xtype: 'textfield',
-							disable: true,
-							fieldLabel: MONITORTOUSSEDISPLAY_FIRST,
-							labelSeparator: '',
-							cls: 'fieldReadOnlyNoRemove sterilizerCheckbox',
-							width: 0
-						}]
-					}, {
-						layout: 'form',
-						labelWidth: 30,
-						items: [{
-							id: 'biological_1_1',
-							name: 'biological_1_1',
-							fieldLabel: '化学',
-							xtype: 'checkbox',
-							cls: 'sterilizerCheckbox',
-							inputValue: '化学',
-							labelSeparator: ''
-						}]
-					}, {
-						layout: 'form',
-						labelWidth: 30,
-						items: [{
-							id: 'biological_1_2',
-							name: 'biological_1_2',
-							fieldLabel: '生物',
-							xtype: 'checkbox',
-							cls: 'sterilizerCheckbox',
-							inputValue: '生物',
-							labelSeparator: ''
-						}]
-					}]
-				}, {
-					layout: 'column',
-					columnWidth: 0.55,
-					items: [{
-						layout: 'form',
-						labelWidth: 100,
-						items: [{
-							xtype: 'textfield',
-							disable: true,
-							fieldLabel: MONITORTOUSSEDISPLAY_EVERYTHING,
-							labelSeparator: '',
-							cls: 'fieldReadOnlyNoRemove sterilizerCheckbox',
-							width: 0
-						}]
-					}, {
-						layout: 'form',
-						labelWidth: 30,
-						items: [{
-							id: 'biological_2_1',
-							name: 'biological_2_1',
-							fieldLabel: '化学',
-							xtype: 'checkbox',
-							cls: 'sterilizerCheckbox',
-							inputValue: '化学',
-							labelSeparator: ''
-						}]
-					}, {
-						layout: 'form',
-						labelWidth: 30,
-						items: [{
-							id: 'biological_2_2',
-							name: 'biological_2_2',
-							fieldLabel: '生物',
-							xtype: 'checkbox',
-							cls: 'sterilizerCheckbox',
-							inputValue: '生物',
-							labelSeparator: ''
-						}]
-					}]
-				}, {
-					layout: 'column',
-					columnWidth: 0.45,
-					items: [{
-						layout: 'form',
-						labelWidth: 70,
-						items: [{
-							xtype: 'textfield',
-							disable: true,
-							fieldLabel: MONITORTOUSSEDISPLAY_IMPLANT,
-							labelSeparator: '',
-							cls: 'fieldReadOnlyNoRemove sterilizerCheckbox',
-							width: 0
-						}]
-					}, {
-						layout: 'form',
-						labelWidth: 30,
-						items: [{
-							id: 'biological_3_1',
-							name: 'biological_3_1',
-							fieldLabel: '化学',
-							xtype: 'checkbox',
-							inputValue: '化学',
-							cls: 'sterilizerCheckbox',
-							labelSeparator: ''
-						}]
-					}, {
-						layout: 'form',
-						labelWidth: 30,
-						items: [{
-							id: 'biological_3_2',
-							name: 'biological_3_2',
-							fieldLabel: '生物',
-							xtype: 'checkbox',
-							inputValue: '生物',
-							cls: 'sterilizerCheckbox',
-							labelSeparator: ''
-						}]
-					}]
-				}, {
-					layout: 'column',
-					columnWidth: 0.55,
-					items: [{
-						layout: 'form',
-						labelWidth: 100,
-						items: [{
-							xtype: 'textfield',
-							disable: true,
-							fieldLabel: MONITORTOUSSEDISPLAY_FOREIGN_TOUSSE,
-							labelSeparator: '',
-							cls: 'fieldReadOnlyNoRemove sterilizerCheckbox',
-							width: 0
-						}]
-					}, {
-						layout: 'form',
-						labelWidth: 30,
-						items: [{
-							id: 'biological_4_1',
-							name: 'biological_4_1',
-							fieldLabel: '化学',
-							xtype: 'checkbox',
-							cls: 'sterilizerCheckbox',
-							inputValue: '化学',
-							labelSeparator: ''
-						}]
-					}, {
-						layout: 'form',
-						labelWidth: 30,
-						items: [{
-							id: 'biological_4_2',
-							name: 'biological_4_2',
-							fieldLabel: '生物',
-							xtype: 'checkbox',
-							cls: 'sterilizerCheckbox',
-							inputValue: '生物',
-							labelSeparator: ''
-						}]
-					}]
-				}]
+				hidden: true,
 			}, {
 				columnWidth: 0.49,
 				layout: 'column',
@@ -1757,7 +1837,7 @@
 		id: 'sterilizerWin',
 		layout: 'fit',
 		title: '灭菌炉信息',
-		width: 900,
+		width: 1080,
 		border: false,
 		modal: true,
 		plain: true,
@@ -1774,8 +1854,7 @@
 				var sterilizer = action.result.data;  //灭菌炉对象
 				var biologicalMonitoringDisplay = sterilizer.biologicalMonitoringDisplay;
 				var biologicalMonitoringDisplayArray = biologicalMonitoringDisplay.split(';');
-				var monitorTousseDisplay = sterilizer.monitorTousseDisplay;
-				var monitorTousseDisplayArray = monitorTousseDisplay.split(';');
+				var monitoringPackageRules = action.result.monitoringPackageRules || [];
 				top.Ext.getCmp('isRoutineMonitoring').setValue(sterilizer.isRoutineMonitoring);
 				top.Ext.getCmp('waitSterilizedPrompt').setValue(sterilizer.waitSterilizedPrompt);
 				if (sterilizer.bioreader != null) {
@@ -1804,49 +1883,14 @@
 						top.Ext.getCmp('qualified').disable();
 					}
 				}
-				for (var i = 0; i < monitorTousseDisplayArray.length; i++) {
-					var names = monitorTousseDisplayArray[i].split('_');
-					if (names[0] == MONITORTOUSSEDISPLAY_FIRST) {
-						if (names[1] == '化学' || names[2] == '化学') {
-							top.Ext.getCmp('biological_1_1').setValue(true);
-						}
-						if (names[1] == '生物' || names[2] == '生物') {
-							top.Ext.getCmp('biological_1_2').setValue(true);
-						}
-						if (names[1] == undefined) {
-							top.Ext.getCmp('biological_1_2').setValue(true);
-						}
-					} else if (names[0] == MONITORTOUSSEDISPLAY_EVERYTHING) {
-						if (names[1] == '化学' || names[2] == '化学') {
-							top.Ext.getCmp('biological_2_1').setValue(true);
-						}
-						if (names[1] == '生物' || names[2] == '生物') {
-							top.Ext.getCmp('biological_2_2').setValue(true);
-						}
-						if (names[1] == undefined) {
-							top.Ext.getCmp('biological_2_2').setValue(true);
-						}
-					} else if (names[0] == MONITORTOUSSEDISPLAY_IMPLANT) {
-						if (names[1] == '化学' || names[2] == '化学') {
-							top.Ext.getCmp('biological_3_1').setValue(true);
-						}
-						if (names[1] == '生物' || names[2] == '生物') {
-							top.Ext.getCmp('biological_3_2').setValue(true);
-						}
-						if (names[1] == undefined) {
-							top.Ext.getCmp('biological_3_2').setValue(true);
-						}
-					} else {
-						if (names[1] == '化学' || names[2] == '化学') {
-							top.Ext.getCmp('biological_4_1').setValue(true);
-						}
-						if (names[1] == '生物' || names[2] == '生物') {
-							top.Ext.getCmp('biological_4_2').setValue(true);
-						}
-						if (names[1] == undefined) {
-							top.Ext.getCmp('biological_4_2').setValue(true);
-						}
-					}
+				for (var i = 0; i < monitoringPackageRules.length; i++) {
+					var data = monitoringPackageRules[i];
+					var p = new MonitoringPackageGridRecord({
+						trigger: data.trigger,
+						frequency: data.frequency,
+						packageType: data.packageType
+					});
+					monitoringPackageGridStore.add(p);
 				}
 				if (sstsConfig.enableSterilizerSafetyCheckBeforeRunAndSterilizerRunLogSheetRegistrationFunction) {
 					var safetyCheckFormDefinition = sterilizer.safetyCheckFormDefinition;
@@ -1914,6 +1958,7 @@
 						for (var i = 0; i < action.result.data.sterilizationFrequecyReminds.length; i++) {
 							var data = action.result.data.sterilizationFrequecyReminds[i];
 							var p = new sterilisationConfig({
+								dateType: data.dateType,
 								frequency: (data.frequency == 0) ? '' : data.frequency,
 								sterilisation: data.sterilisation ? data.sterilisation.sterilisation : '',
 								sterilisation_id: data.sterilisation ? data.sterilisation.id : '',
@@ -2028,54 +2073,29 @@
 }
 
 function setMonitortousseDisplay() {
-	//第一炉：化学和生物
-	var biological_1_1 = top.Ext.getCmp('biological_1_1').getValue();
-	var biological_1_2 = top.Ext.getCmp('biological_1_2').getValue();
-	//每炉(第1炉除外)：化学和生物
-	var biological_2_1 = top.Ext.getCmp('biological_2_1').getValue();
-	var biological_2_2 = top.Ext.getCmp('biological_2_2').getValue();
-	//有植入物时：化学和生物
-	var biological_3_1 = top.Ext.getCmp('biological_3_1').getValue();
-	var biological_3_2 = top.Ext.getCmp('biological_3_2').getValue();
-	//有外来器械时：化学和生物
-	var biological_4_1 = top.Ext.getCmp('biological_4_1').getValue();
-	var biological_4_2 = top.Ext.getCmp('biological_4_2').getValue();
-
-	var monitorTousseDisplay = '';
-
-	if (biological_1_1 || biological_1_2) {
-		monitorTousseDisplay += MONITORTOUSSEDISPLAY_FIRST;
-		monitorTousseDisplay += (biological_1_1 ? '_' + top.Ext.getCmp('biological_1_1').inputValue : '');
-		monitorTousseDisplay += (biological_1_2 ? '_' + top.Ext.getCmp('biological_1_2').inputValue : '');
-		monitorTousseDisplay += ';';
+	var store = top.Ext.getCmp('monitoringPackageGrid').getStore();
+	var arr = [];
+	var msg = '';
+	for (var i = 0; i < store.getCount(); i++) {
+		var data = store.getAt(i).data;
+		if (!data.frequency || !data.trigger) {
+			msg = '【监测包扫描提示默认值】炉次和触发条件都不能为空';
+			break;
+		} else {
+			arr[i] = {
+				trigger: data.trigger,
+				frequency: data.frequency,
+				packageType: data.packageType
+			}
+		}
 	}
-
-	if (biological_2_1 || biological_2_2) {
-		monitorTousseDisplay += MONITORTOUSSEDISPLAY_EVERYTHING;
-		monitorTousseDisplay += (biological_2_1 ? '_' + top.Ext.getCmp('biological_2_1').inputValue : '');
-		monitorTousseDisplay += (biological_2_2 ? '_' + top.Ext.getCmp('biological_2_2').inputValue : '');
-		monitorTousseDisplay += ';';
+	if (!msg) {
+		top.Ext.getCmp('monitorTousseDisplay').setValue(JSON.stringify(arr));
+		return true;
+	} else {
+		showResult(msg);
+		return false
 	}
-
-	if (biological_3_1 || biological_3_2) {
-		monitorTousseDisplay += MONITORTOUSSEDISPLAY_IMPLANT;
-		monitorTousseDisplay += (biological_3_1 ? '_' + top.Ext.getCmp('biological_3_1').inputValue : '');
-		monitorTousseDisplay += (biological_3_2 ? '_' + top.Ext.getCmp('biological_3_2').inputValue : '');
-		monitorTousseDisplay += ';';
-	}
-
-	if (biological_4_1 || biological_4_2) {
-		monitorTousseDisplay += MONITORTOUSSEDISPLAY_FOREIGN_TOUSSE;
-		monitorTousseDisplay += (biological_4_1 ? '_' + top.Ext.getCmp('biological_4_1').inputValue : '');
-		monitorTousseDisplay += (biological_4_2 ? '_' + top.Ext.getCmp('biological_4_2').inputValue : '');
-		monitorTousseDisplay += ';';
-	}
-
-	if (monitorTousseDisplay) {
-		monitorTousseDisplay = monitorTousseDisplay.substring(0, monitorTousseDisplay.length - 1);
-	}
-
-	top.Ext.getCmp('monitorTousseDisplay').setValue(monitorTousseDisplay);
 }
 
 function validateAndSubmit(print) {
Index: ssts-web/src/main/webapp/disinfectsystem/basedatamanager/holiday/holidayListView.jsp
===================================================================
diff -u
--- ssts-web/src/main/webapp/disinfectsystem/basedatamanager/holiday/holidayListView.jsp	(revision 0)
+++ ssts-web/src/main/webapp/disinfectsystem/basedatamanager/holiday/holidayListView.jsp	(revision 41361)
@@ -0,0 +1,20 @@
+<%@page language="java" contentType="text/html; charset=UTF-8"%>
+<%-- 引入JSP标签 --%>
+<%@include file="/common/taglibs.jsp"%>
+<%-- 引入ExtJs4.2.5框架 --%>
+<%@include file="/common/include_ForgonGrid4.2.5_css.jsp"%>
+<%@include file="/common/include_ForgonGrid4.2.5_Js.jsp"%>
+<%@include file="/common/include_UseForgonGrid4_Js.jsp"%>
+
+<html>
+	<head>
+		<%-- 引入common.js --%>
+		<script type="text/javascript" src="${ctx}/js/common.js?version=${svnRevision}"></script>
+		<%-- 引入语音插件 --%>
+		<script type="text/javascript" src="${ctx}/js/speaker.js?version=${svnRevision}"></script>
+		<script type="text/javascript" src="holidayListView.js?version=${svnRevision}"></script>
+	<title>假期及调休配置</title>
+	</head>
+	<body>
+	</body>
+</html>
\ No newline at end of file
Index: ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilisationNoticeCheckerImpl.java
===================================================================
diff -u
--- ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilisationNoticeCheckerImpl.java	(revision 0)
+++ ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilisationNoticeCheckerImpl.java	(revision 41361)
@@ -0,0 +1,119 @@
+package com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.service;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.disinfectsystem.basedatamanager.holiday.service.HolidayConfigManager;
+import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.SterilizationFrequecyRemind;
+import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer;
+import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model.SterilisationNotice;
+import com.forgon.tools.hibernate.ObjectDao;
+import com.forgon.tools.util.ForgonDateUtils;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service("sterilisationNoticeChecker")
+public class SterilisationNoticeCheckerImpl implements SterilisationNoticeChecker{
+    @Autowired
+    private ObjectDao objectDao;
+    @Autowired
+    private HolidayConfigManager holidayConfigManager;
+    @Override
+    public SterilisationNotice isHavedoneNeedNoticeSterilisation(String sterilizerName, String sterilizationType, String frequency) {
+        Sterilizer sterilizer = (Sterilizer) objectDao.getByProperty(Sterilizer.class.getSimpleName(), "name", sterilizerName);
+        if(sterilizer == null){
+            return new SterilisationNotice(false, "灭菌炉不存在");
+        }
+        SterilisationNotice notice = new SterilisationNotice();
+        List<SterilizationFrequecyRemind> sterilizationFrequecyReminds = sterilizer.getSterilizationFrequecyReminds();
+
+        if(CollectionUtils.isNotEmpty(sterilizationFrequecyReminds)){
+            List<SterilizationFrequecyRemind> list = sterilizationFrequecyReminds.stream().filter(remind->remind.getSterilisation() != null
+                    && remind.getFrequency() != null && remind.getFrequency() >=1).collect(Collectors.toList());
+            if(CollectionUtils.isEmpty(list)){
+                return notice;
+            }
+            HolidayType holidayType = holidayConfigManager.holidayTypeOfToday();
+            // 优先处理强制提醒
+            List<SterilizationFrequecyRemind> mandatoryList = list.stream().filter(SterilizationFrequecyRemind::mandatoryMode).collect(Collectors.toList());
+            if(CollectionUtils.isNotEmpty(mandatoryList)) {
+                notice = checkInSameMode(holidayType, sterilizerName, sterilizationType, frequency, mandatoryList, notice);
+                if(!notice.success()){
+                    return notice;
+                }
+            }
+            List<SterilizationFrequecyRemind> nonMandatoryList = list.stream().filter(remind->!remind.mandatoryMode()).collect(Collectors.toList());
+            notice = checkInSameMode(holidayType, sterilizerName, sterilizationType, frequency, nonMandatoryList, notice);
+            if(!notice.success()){
+                return notice;
+            }
+        }
+        return notice;
+    }
+
+    private SterilisationNotice checkInSameMode(HolidayType todayHolidayType, String sterilizerName, String sterilizationType,
+                                                String frequency, List<SterilizationFrequecyRemind> reminds, SterilisationNotice notice){
+        List<SterilizationFrequecyRemind> holidayList = reminds.stream().filter(remind->remind.dateTypeLongHoliday() || remind.dateTypeShortHoliday()).collect(Collectors.toList());
+        if(CollectionUtils.isNotEmpty(holidayList)){
+            notice = checkInSamePriorityAndMode(todayHolidayType, sterilizerName, sterilizationType, frequency, holidayList, notice);
+            if(!notice.success()){
+                return notice;
+            }
+        }
+        List<SterilizationFrequecyRemind> weekList = reminds.stream().filter(SterilizationFrequecyRemind::dateTypeWeek).collect(Collectors.toList());
+        if(CollectionUtils.isNotEmpty(weekList)){
+            notice = checkInSamePriorityAndMode(todayHolidayType, sterilizerName, sterilizationType, frequency, weekList, notice);
+            if(!notice.success()){
+                return notice;
+            }
+        }
+        List<SterilizationFrequecyRemind> mandatoryEverydayList = reminds.stream().filter(remind -> !holidayList.contains(remind) && !weekList.contains(remind)).collect(Collectors.toList());
+        if(CollectionUtils.isNotEmpty(mandatoryEverydayList)){
+            notice = checkInSamePriorityAndMode(todayHolidayType, sterilizerName, sterilizationType, frequency, mandatoryEverydayList, notice);
+            if(!notice.success()){
+                return notice;
+            }
+        }
+        return notice;
+    }
+
+    private SterilisationNotice checkInSamePriorityAndMode(HolidayType todayHolidayType, String sterilizerName, String sterilizationType, String frequency, List<SterilizationFrequecyRemind> sterilizationFrequecyReminds, SterilisationNotice notice) {
+        int weekDay = ForgonDateUtils.getDayWeekOfToday();
+        for (SterilizationFrequecyRemind remind : sterilizationFrequecyReminds) {
+            // 配置中的炉次或者灭菌程序为空时，不验证
+            if(remind.getFrequency() == null || remind.getFrequency() < 1
+                    || remind.getSterilisation() == null){
+                continue;
+            }
+
+            // 如果日期类型是假期，则判断当天假期是否一致
+            if(remind.dateTypeLongHoliday() || remind.dateTypeShortHoliday()){
+                if(!remind.dateTypeOfHoliday(todayHolidayType)){
+                    continue;
+                }
+            }
+            // 如果是星期，判断与当前星期是否一致
+            if(remind.dateTypeWeek()){
+                if(!remind.dateTypeOfWeek(weekDay)){
+                    continue;
+                }
+            }
+            // 都是假期匹配或者星期匹配或者是每天的，只要炉次匹配就行了
+            if(StringUtils.equals(frequency, remind.getFrequency().toString())
+                    && !StringUtils.equals(sterilizationType, remind.getSterilisation().getSterilisation())){
+                notice = new SterilisationNotice(false, remind.getRemindMode(),
+                        remind.getSterilisation().getSterilisation(), remind.getFrequency());
+                if(StringUtils.equals(remind.getRemindMode(), SterilizationFrequecyRemind.REMINDMODE_MANDATORY)){
+                    notice.setConfirmMessage(sterilizerName + "第" + frequency + "炉的灭菌程序必须是" + remind.getSterilisation().getSterilisation() + "！");
+                }else{
+                    notice.setConfirmMessage(sterilizerName + "第" + frequency + "炉的灭菌程序应该是" + remind.getSterilisation().getSterilisation() + "，不修改灭菌程序继续操作吗？");
+                }
+                break;
+            }
+        }
+        return notice;
+    }
+}
Index: ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/dwr/table/SterilizationRecordTableManager.java
===================================================================
diff -u -r41350 -r41361
--- ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/dwr/table/SterilizationRecordTableManager.java	(.../SterilizationRecordTableManager.java)	(revision 41350)
+++ ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/dwr/table/SterilizationRecordTableManager.java	(.../SterilizationRecordTableManager.java)	(revision 41361)
@@ -13,6 +13,7 @@
 import java.util.Set;
 
 import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model.SterilisationNotice;
+import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.service.SterilisationNoticeChecker;
 import com.forgon.exception.SystemException;
 import net.sf.json.JSONArray;
 import net.sf.json.JSONObject;
@@ -75,6 +76,7 @@
 	private BarcodeManager barcodeManager;
 
 	private SterilizationRecordManager sterilizationRecordManager;
+	private SterilisationNoticeChecker sterilisationNoticeChecker;
 
 	private SterilizerManager sterilizerManager;
 
@@ -138,6 +140,10 @@
 		this.sterilizationRecordManager = sterilizationRecordManager;
 	}
 
+	public void setSterilisationNoticeChecker(SterilisationNoticeChecker sterilisationNoticeChecker) {
+		this.sterilisationNoticeChecker = sterilisationNoticeChecker;
+	}
+
 	public void setBarcodeManager(BarcodeManager barcodeManager) {
 		this.barcodeManager = barcodeManager;
 	}
@@ -530,7 +536,7 @@
 				}
 				Sterilisation sterilisation = (Sterilisation) barcodeDevice;
 				if (inside) {
-					SterilisationNotice notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation(sterilizerName, sterilisation.getSterilisation(), frequency);
+					SterilisationNotice notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation(sterilizerName, sterilisation.getSterilisation(), frequency);
 					if(notice.getSuccess()){
 						result = "success:" + sterilisation.getSterilisation() + ":success";
 					}else{
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/sterilizer/SterilizationFrequecyRemind.java
===================================================================
diff -u -r39259 -r41361
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/sterilizer/SterilizationFrequecyRemind.java	(.../SterilizationFrequecyRemind.java)	(revision 39259)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/sterilizer/SterilizationFrequecyRemind.java	(.../SterilizationFrequecyRemind.java)	(revision 41361)
@@ -1,22 +1,14 @@
 package com.forgon.disinfectsystem.entity.basedatamanager.sterilizer;
 
-import javax.persistence.Entity;
-
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.disinfectsystem.entity.basedatamanager.sterilisation.Sterilisation;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
 import org.hibernate.annotations.DynamicInsert;
 import org.hibernate.annotations.DynamicUpdate;
 
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.persistence.Table;
+import javax.persistence.*;
 
-import org.hibernate.annotations.Cache;
-import org.hibernate.annotations.CacheConcurrencyStrategy;
-
-import com.forgon.disinfectsystem.entity.basedatamanager.sterilisation.Sterilisation;
-
 /**
  * 按炉次提醒的灭菌程序
  * 灭菌炉定义的“按炉次提醒的灭菌程序”
@@ -28,11 +20,27 @@
 @Table(name = "SterilizationFrequecyRemind")
 @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
 public class SterilizationFrequecyRemind {
-
+	public static final Integer DATE_TYPE_EVERYDAY = 1;
+	public static final Integer DATE_TYPE_WEEK_START = 2;
+	public static final Integer DATE_TYPE_WEEK_END = 8;
+	public static final Integer DATE_TYPE_SHORT_HOLIDAY_BEFORE = 9;
+	public static final Integer DATE_TYPE_SHORT_HOLIDAY_AFTER = 10;
+	public static final Integer DATE_TYPE_LONG_HOLIDAY_BEFORE = 11;
+	public static final Integer DATE_TYPE_LONG_HOLIDAY_AFTER = 12;
 	/**
 	 * 按炉次提醒的灭菌程序记录的id
 	 */
 	private Long id;
+	/**
+	 * 提醒的日期类型。同时满足的情况下，优先级以长短假最高，星期次之，每天最低
+	 * 1-每天
+	 * 2-8：每周日到周六提醒。如2是每周日提醒，8是每周六提醒，跟日历上的顺序一致
+	 * 9-短假前第1天提醒
+	 * 10-短假后第1天提醒
+	 * 11-长假前第1天提醒
+	 * 12-长假后第1天提醒
+	 */
+	private Integer dateType;
 	
 	/**
 	 * 炉次
@@ -70,6 +78,15 @@
 		this.id = id;
 	}
 
+	@Column(columnDefinition=" int default 1 not null ")
+	public Integer getDateType() {
+		return dateType;
+	}
+
+	public void setDateType(Integer dateType) {
+		this.dateType = dateType;
+	}
+
 	public Integer getFrequency() {
 		return frequency;
 	}
@@ -95,5 +112,54 @@
 	public void setRemindMode(String remindMode) {
 		this.remindMode = remindMode;
 	}
+
+	public boolean mandatoryMode() {
+		return REMINDMODE_MANDATORY.equals(remindMode);
+	}
+
+	public int dateTypeInt() {
+		return dateType != null ? dateType : 0;
+	}
+
+	public boolean dateTypeEveryday() {
+		return dateTypeInt() == DATE_TYPE_EVERYDAY;
+	}
+
+	public boolean dateTypeWeek() {
+		return dateTypeInt() >= DATE_TYPE_WEEK_START && dateTypeInt() <= DATE_TYPE_WEEK_END;
+	}
+
+	public boolean dateTypeShortHoliday() {
+		return dateTypeInt() >= DATE_TYPE_SHORT_HOLIDAY_BEFORE && dateTypeInt() <= DATE_TYPE_SHORT_HOLIDAY_AFTER;
+	}
+
+	public boolean dateTypeLongHoliday() {
+		return dateTypeInt() >= DATE_TYPE_LONG_HOLIDAY_BEFORE && dateTypeInt() <= DATE_TYPE_LONG_HOLIDAY_AFTER;
+	}
+
+	/**
+	 * 日期类型为每周X
+	 * @param week 周几,1到7，分别是周日到周六，跟日历一致
+	 * @return 是每周X触发返回true,否则返回false
+	 */
+	public boolean dateTypeOfWeek(int week) {
+		int t = dateTypeInt();
+		return t == (week - 1) + DATE_TYPE_WEEK_START;
+	}
+
+	/**
+	 * 判断日期类型是否为指定的假期类型
+	 * @param holidayType 假期类型
+	 * @return 是指定假期类型返回true,否则返回false
+	 */
+	public boolean dateTypeOfHoliday(HolidayType holidayType) {
+		if(!dateTypeLongHoliday() && !dateTypeShortHoliday()) {
+			return false;
+		}
+		int holidayTypeStart = HolidayType.ShortBefore.ordinal();
+		int holidayDateStart = DATE_TYPE_SHORT_HOLIDAY_BEFORE;
+		int diff = holidayTypeStart - holidayDateStart;
+		return holidayType.ordinal() - diff == dateTypeInt();
+	}
 	
 }
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/param/HolidayConfigParam.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/param/HolidayConfigParam.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/param/HolidayConfigParam.java	(revision 41361)
@@ -0,0 +1,77 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.param;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+import java.sql.Date;
+import java.util.Objects;
+
+public class HolidayConfigParam {
+    /**
+     * 节假日配置的日期
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private Date date;
+    /**
+     * 日期类型：1-节假日，2-假期调休的补班
+     */
+    private Integer type;
+    /**
+     * 假期的备注
+     */
+    private String remark;
+
+    public HolidayConfigParam() {
+    }
+
+    public HolidayConfigParam(Date date, Integer type, String remark) {
+        this.date = date;
+        this.type = type;
+        this.remark = remark;
+    }
+
+    public Date getDate() {
+        return date;
+    }
+
+    public void setDate(Date date) {
+        this.date = date;
+    }
+
+    public Integer getType() {
+        return type;
+    }
+
+    public void setType(Integer type) {
+        this.type = type;
+    }
+
+    public String getRemark() {
+        return remark;
+    }
+
+    public void setRemark(String remark) {
+        this.remark = remark;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) return true;
+        if (!(object instanceof HolidayConfigParam)) return false;
+        HolidayConfigParam that = (HolidayConfigParam) object;
+        return Objects.equals(date, that.date) && Objects.equals(type, that.type) && Objects.equals(remark, that.remark);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(date, type, remark);
+    }
+
+    @Override
+    public String toString() {
+        return "HolidayConfigParam{" +
+                "date=" + date +
+                ", type=" + type +
+                ", remark='" + remark + '\'' +
+                '}';
+    }
+}
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplValidateParamTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplValidateParamTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplValidateParamTest.java	(revision 41361)
@@ -0,0 +1,109 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.param.HolidayConfigParam;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+
+import java.sql.Date;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * HolidayConfigManagerImpl#validateParam 单元测试类
+ */
+public class HolidayConfigManagerImplValidateParamTest {
+
+    // 被测试的服务实例
+    @InjectMocks
+    private HolidayConfigManagerImpl holidayConfigManager;
+    private AutoCloseable autoCloseable;
+
+    @Before
+    public void setUp() {
+        autoCloseable = MockitoAnnotations.openMocks(this);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        autoCloseable.close();
+    }
+
+    /**
+     * 测试当 date 为 null 时，应抛出 RuntimeException："日期不能为空"
+     */
+    @Test
+    public void testValidateParam_DateIsNull_ThrowsException() {
+        HolidayConfigParam param = new HolidayConfigParam();
+        param.setType(1);
+        param.setRemark("测试");
+
+        RuntimeException exception = assertThrows(RuntimeException.class,
+                () -> holidayConfigManager.validateParam(param));
+
+        assertEquals("日期不能为空", exception.getMessage());
+    }
+
+    /**
+     * 测试当 type 为 null 时，应抛出 RuntimeException："类型不能为空"
+     */
+    @Test
+    public void testValidateParam_TypeIsNull_ThrowsException() {
+        HolidayConfigParam param = new HolidayConfigParam();
+        param.setDate(Date.valueOf("2024-01-01"));
+        param.setRemark("测试");
+
+        RuntimeException exception = assertThrows(RuntimeException.class,
+                () -> holidayConfigManager.validateParam(param));
+
+        assertEquals("类型不能为空", exception.getMessage());
+    }
+
+    /**
+     * 测试当 type 值小于 0 时，应抛出 RuntimeException："类型错误"
+     */
+    @Test
+    public void testValidateParam_TypeLessThanZero_ThrowsException() {
+        HolidayConfigParam param = new HolidayConfigParam();
+        param.setDate(Date.valueOf("2024-01-01"));
+        param.setType(-1);
+        param.setRemark("测试");
+
+        RuntimeException exception = assertThrows(RuntimeException.class,
+                () -> holidayConfigManager.validateParam(param));
+
+        assertEquals("类型错误", exception.getMessage());
+    }
+
+    /**
+     * 测试当 type 值大于 2 时，应抛出 RuntimeException："类型错误"
+     */
+    @Test
+    public void testValidateParam_TypeGreaterThanTwo_ThrowsException() {
+        HolidayConfigParam param = new HolidayConfigParam();
+        param.setDate(Date.valueOf("2024-01-01"));
+        param.setType(3);
+        param.setRemark("测试");
+
+        RuntimeException exception = assertThrows(RuntimeException.class,
+                () -> holidayConfigManager.validateParam(param));
+
+        assertEquals("类型错误", exception.getMessage());
+    }
+
+    /**
+     * 测试所有参数均符合规范的情况，不应抛出异常
+     */
+    @Test
+    public void testValidateParam_ValidParams_NoExceptionThrown() {
+        HolidayConfigParam param = new HolidayConfigParam();
+        param.setDate(Date.valueOf("2024-01-01"));
+        param.setType(1);
+        param.setRemark("测试");
+
+        // 不应该抛出异常
+        assertDoesNotThrow(() -> holidayConfigManager.validateParam(param));
+    }
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/model/HolidayType.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/model/HolidayType.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/holiday/model/HolidayType.java	(revision 41361)
@@ -0,0 +1,27 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.model;
+
+/**
+ * 假期类型。3天及3天以上假期为长假（法定假期连休基本是长假）。1天或者2天的假期为短假，比如周末
+ */
+public enum HolidayType {
+    /**
+     * 非假期，普通工作日，也就是前后都没有假期，连续上班的中间的日子
+     */
+    Normal,
+    /**
+     * 短假前第一天，也就是放假前最后一天上班的日子。上完这天就Happy了
+     */
+    ShortBefore,
+    /**
+     * 短假后第一天，也就是放假后第一天上班的日子。又开始要当牛马了
+     */
+    ShortAfter,
+    /**
+     * 长假前第一天，也就是放长假前最后一天上班的日子。旅游计划安排上
+     */
+    LongBefore,
+    /**
+     * 长假后第一天，也就是放长假后第一天上班的日子。又开始要当牛马了
+     */
+    LongAfter
+}
Index: ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/action/SterilizationRecordAction.java
===================================================================
diff -u -r41338 -r41361
--- ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/action/SterilizationRecordAction.java	(.../SterilizationRecordAction.java)	(revision 41338)
+++ ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/action/SterilizationRecordAction.java	(.../SterilizationRecordAction.java)	(revision 41361)
@@ -29,6 +29,7 @@
 import javax.servlet.http.HttpServletResponse;
 
 import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model.SterilisationNotice;
+import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.service.SterilisationNoticeChecker;
 import com.forgon.tools.json.JacksonUtil;
 import net.sf.json.JSONArray;
 import net.sf.json.JSONObject;
@@ -123,6 +124,7 @@
 	private SterilizationRecord sterilizationRecord;
 	private SterilizationRecord origineSterilizationRecord;
 	private SterilizationRecordManager sterilizationRecordManager;
+	private SterilisationNoticeChecker sterilisationNoticeChecker;
 
 	private BarcodeManager barcodeManager;
 
@@ -222,6 +224,10 @@
 		this.sterilizationRecordManager = sterilizationRecordManager;
 	}
 
+	public void setSterilisationNoticeChecker(SterilisationNoticeChecker sterilisationNoticeChecker) {
+		this.sterilisationNoticeChecker = sterilisationNoticeChecker;
+	}
+
 	public void setHttpOptionManager(HttpOptionManager httpOptionManager) {
 		this.httpOptionManager = httpOptionManager;
 	}
@@ -2468,7 +2474,7 @@
     	String frequency = StrutsParamUtils.getPraramValue("frequency","");
 		SterilisationNotice notice = null;
     	try{
-    		notice = sterilizationRecordManager.isHavedoneNeedNoticeSterilisation(sterilizerName, sterilizationType, frequency);
+    		notice = sterilisationNoticeChecker.isHavedoneNeedNoticeSterilisation(sterilizerName, sterilizationType, frequency);
     		StrutsResponseUtils.output(JacksonUtil.trans2JSONObject(notice));
     	}catch(Exception e){
     		e.printStackTrace();
Index: ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplHolidayTypeOfTodayTest.java
===================================================================
diff -u
--- ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplHolidayTypeOfTodayTest.java	(revision 0)
+++ ssts-basedata/src/test/java/com/forgon/disinfectsystem/basedatamanager/holiday/service/HolidayConfigManagerImplHolidayTypeOfTodayTest.java	(revision 41361)
@@ -0,0 +1,48 @@
+package com.forgon.disinfectsystem.basedatamanager.holiday.service;
+
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.tools.util.ForgonDateUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+import java.util.Date;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+public class HolidayConfigManagerImplHolidayTypeOfTodayTest {
+    @InjectMocks
+    @Spy
+    private HolidayConfigManagerImpl holidayConfigManager;
+
+    private AutoCloseable autoCloseable;
+
+    @Before
+    public void setUp() {
+        autoCloseable = MockitoAnnotations.openMocks(this);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        autoCloseable.close();
+    }
+
+    @Test
+    public void testHolidayTypeOfToday() {
+        doReturn(HolidayType.LongAfter).when(holidayConfigManager).holidayTypeOfDate(any(Date.class));
+        HolidayType result = holidayConfigManager.holidayTypeOfToday();
+        assertEquals(HolidayType.LongAfter, result);
+        verify(holidayConfigManager, data -> {
+            Date date = (Date) data.getAllInvocations().get(1).getArguments()[0];
+            String now = ForgonDateUtils.safelyFormatDate(new Date(), ForgonDateUtils.DATE_FORMAT_YYYYMMDD, "");
+            String dateStr = ForgonDateUtils.safelyFormatDate(date, ForgonDateUtils.DATE_FORMAT_YYYYMMDD, "");
+            assertEquals(now, dateStr);
+        }).holidayTypeOfDate(any(Date.class));
+    }
+}
Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/common/params/PagerParam.java
===================================================================
diff -u
--- ssts-basedata/src/main/java/com/forgon/disinfectsystem/common/params/PagerParam.java	(revision 0)
+++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/common/params/PagerParam.java	(revision 41361)
@@ -0,0 +1,128 @@
+package com.forgon.disinfectsystem.common.params;
+
+import org.springframework.util.StringUtils;
+
+import java.util.Objects;
+import java.util.regex.Pattern;
+
+/**
+ * 列表的分页参数
+ */
+public class PagerParam {
+    private int start;
+    private int limit;
+    private String orderColumn;
+    private String order;
+
+    public PagerParam() {
+    }
+
+    public PagerParam(int start, int limit) {
+        this.start = start;
+        this.limit = limit;
+    }
+
+    public int getStart() {
+        return start;
+    }
+
+    public void setStart(int start) {
+        this.start = start;
+    }
+
+    public int getLimit() {
+        return limit;
+    }
+
+    public void setLimit(int limit) {
+        this.limit = limit;
+    }
+
+    public String getOrderColumn() {
+        return orderColumn;
+    }
+
+    public void setOrderColumn(String orderColumn) {
+        this.orderColumn = orderColumn;
+    }
+
+    public String getOrder() {
+        return order;
+    }
+
+    public void setOrder(String order) {
+        this.order = order;
+    }
+
+    /**
+     * 获取排序字段。在传入sql中的时候,一定要调用此方法而不是{@link ::getOrderColumn}。因为此方法有验证返回的排序列必须在有效的排序列之中。
+     * 这样避免在order by中的sql注入风险
+     * @param defaultColumn 默认的排序列。如果orderColumn为空则返回此排序列
+     * @param orders 有效的排序列数组.orderColumn及defaultColumn的排序列字段必须在此数组中
+     * @return 有效的排序列字符串
+     */
+    public String orderColumn(String defaultColumn, String[] orders){
+        if(StringUtils.hasText(orderColumn)){
+            if(validOrderColumn(orderColumn, orders)){
+                return orderColumn;
+            }
+        }
+        if(validOrderColumn(defaultColumn, orders)){
+            return defaultColumn;
+        }
+        if(orders == null || orders.length == 0){
+            return "id";
+        }
+        return orders[0];
+    }
+
+    private boolean validOrderColumn(String order, String[] orders) {
+        if(!StringUtils.hasText(order)){
+            return false;
+        }
+        if(orders == null || orders.length == 0){
+            return false;
+        }
+        order = order.trim();
+        for(String str : orders) {
+            if(order.equalsIgnoreCase(str)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public String order() {
+        return "ascending".equalsIgnoreCase(order)?"ASC":"DESC";
+    }
+
+    /**
+     * 获取排序。如果排序字段order为空(null或者空字符串)则返回指定的默认排序
+     * @param def 指定的默认排序。在order字段为null或者空字符串时生效
+     * @return 排序字符串
+     */
+    public String order(String def){
+        if(!StringUtils.hasText(order)){
+            Pattern pattern = Pattern.compile("(asc|desc)", Pattern.CASE_INSENSITIVE);
+            if(pattern.matcher(def).matches()){
+                return def;
+            }
+            return order();
+        }
+        return order();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof PagerParam)) return false;
+        PagerParam that = (PagerParam) o;
+        return start == that.start && limit == that.limit && Objects.equals(orderColumn, that.orderColumn)
+                && Objects.equals(order, that.order);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(start, limit, orderColumn, order);
+    }
+}
Index: ssts-sterile/src/test/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/ScanMonitoringTousseCheckerImplIsNeedScanMonitoringTousseTest.java
===================================================================
diff -u -r41351 -r41361
--- ssts-sterile/src/test/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/ScanMonitoringTousseCheckerImplIsNeedScanMonitoringTousseTest.java	(.../ScanMonitoringTousseCheckerImplIsNeedScanMonitoringTousseTest.java)	(revision 41351)
+++ ssts-sterile/src/test/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/ScanMonitoringTousseCheckerImplIsNeedScanMonitoringTousseTest.java	(.../ScanMonitoringTousseCheckerImplIsNeedScanMonitoringTousseTest.java)	(revision 41361)
@@ -1,6 +1,8 @@
 package com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.service;
 
 import com.forgon.Constants;
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.disinfectsystem.basedatamanager.holiday.service.HolidayConfigManager;
 import com.forgon.disinfectsystem.basedatamanager.sterilisation.service.SterilisationManager;
 import com.forgon.disinfectsystem.basedatamanager.sterilizer.service.SterilizerManager;
 import com.forgon.disinfectsystem.entity.basedatamanager.sterilisation.Sterilisation;
@@ -9,10 +11,13 @@
 import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseInstance;
 import com.forgon.disinfectsystem.entity.packing.ReviewedBasket;
 import com.forgon.disinfectsystem.entity.sterilizationmanager.sterilizationrecord.SterilizationRecord;
+import com.forgon.disinfectsystem.basedatamanager.sterilizer.model.MonitoringPackageScanRule;
 import com.forgon.disinfectsystem.tousse.toussedefinition.service.TousseInstanceManager;
 import com.forgon.exception.UnScanSterilizationMonitoringPackageException;
 import com.forgon.tools.hibernate.ObjectDao;
+import com.forgon.tools.json.JacksonUtil;
 import com.forgon.tools.util.ConfigUtils;
+import com.forgon.tools.util.ForgonDateUtils;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -47,6 +52,8 @@
 
     @Mock
     private TousseInstanceManager tousseInstanceManager;
+    @Mock
+    private HolidayConfigManager holidayConfigManager;
 
     private AutoCloseable autoCloseable;
 
@@ -514,6 +521,78 @@
         scanMonitoringTousseChecker.isNeedScanMonitoringTousse(record, null);
     }
 
+    /**
+     * 测试新的配置格式。json格式的配置。比如每天第3炉做化学和生物监测；周3全部炉次做生物监测；长假后1天第2炉做化学监测；有植入物/外来器械时做生物监测并且不管炉次的配置是多少
+     */
+    @Test
+    public void testIsNeedScanMonitoringTousse_NewConfigFormat() {
+        SterilizationRecord record = new SterilizationRecord();
+        record.setSterilizerName("testSterilizer");
+        record.setFrequency(1);
+        Sterilizer sterilizer = new Sterilizer();
+
+        List<MonitoringPackageScanRule> rules = buildRules();
+        sterilizer.setMonitorTousseDisplay(JacksonUtil.trans2JsonStr(rules));
+        when(sterilizerManager.getSterilizerByName("testSterilizer")).thenReturn(sterilizer);
+
+        when(holidayConfigManager.holidayTypeOfToday()).thenReturn(HolidayType.Normal);
+        // 所有条件都不触发
+        scanMonitoringTousseChecker.isNeedScanMonitoringTousse(record, null);
+        // 假如今天是周三,应该做生物监测
+        try(MockedStatic<ForgonDateUtils> mockedStatic = mockStatic(ForgonDateUtils.class)){
+            when(ForgonDateUtils.getDayWeekOfToday()).thenReturn(Calendar.WEDNESDAY);
+            UnScanSterilizationMonitoringPackageException e = assertThrows(UnScanSterilizationMonitoringPackageException.class,
+                    () -> scanMonitoringTousseChecker.isNeedScanMonitoringTousse(record, null));
+            assertEquals("请扫描生物监测包条码！", e.getMessage());
+            // 假期后第2炉做化学监测,再加上周三所有炉次的生物监测，所以两个都要
+            when(holidayConfigManager.holidayTypeOfToday()).thenReturn(HolidayType.LongAfter);
+            record.setFrequency(2);
+            e = assertThrows(UnScanSterilizationMonitoringPackageException.class,
+                    () -> scanMonitoringTousseChecker.isNeedScanMonitoringTousse(record, null));
+            assertEquals("请扫描化学监测包条码和生物监测包条码！", e.getMessage());
+            // 调整为周四.只剩下化学监测了
+            when(ForgonDateUtils.getDayWeekOfToday()).thenReturn(Calendar.THURSDAY);
+            e = assertThrows(UnScanSterilizationMonitoringPackageException.class,
+                    () -> scanMonitoringTousseChecker.isNeedScanMonitoringTousse(record, null));
+            assertEquals("请扫描化学监测包条码！", e.getMessage());
+            // 炉次修改为第3炉。那鉵发每天第3炉的生物和化学监测
+            record.setFrequency(3);
+            e = assertThrows(UnScanSterilizationMonitoringPackageException.class,
+                    () -> scanMonitoringTousseChecker.isNeedScanMonitoringTousse(record, null));
+            assertEquals("请扫描化学监测包条码和生物监测包条码！", e.getMessage());
+            // 再次测试第2炉，鉵发长假后第二炉的化学监测
+            record.setFrequency(2);
+            e = assertThrows(UnScanSterilizationMonitoringPackageException.class,
+                    () -> scanMonitoringTousseChecker.isNeedScanMonitoringTousse(record, null));
+            assertEquals("请扫描化学监测包条码！", e.getMessage());
+            // 有植入物和外来器械，无论多少炉都触发
+            record.setFrequency(4);
+            e = assertThrows(UnScanSterilizationMonitoringPackageException.class,
+                    () -> scanMonitoringTousseChecker.isNeedScanMonitoringTousse(record, buildMultiTousseInstance()));
+            assertEquals("请扫描化学监测包条码和生物监测包条码！", e.getMessage());
+        }
+    }
+
+    private static List<MonitoringPackageScanRule> buildRules() {
+        List<MonitoringPackageScanRule> rules = new ArrayList<>();
+        MonitoringPackageScanRule rule = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_EVERY_DAY,
+                3, true, true);
+        rules.add(rule);
+        rule = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_WEEK_START+3,
+                -1, false, true);
+        rules.add(rule);
+        rule = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_LONG_HOLIDAY_AFTER,
+                2, true, false);
+        rules.add(rule);
+        rule = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_FOREIGN_TOUSSE, 2,  // 这里配置第2炉也不生效
+                false, true);
+        rules.add(rule);
+        rule = new MonitoringPackageScanRule(MonitoringPackageScanRule.TRIGGER_IMPLANT,
+                -1, true, true);
+        rules.add(rule);
+        return rules;
+    }
+
     private static List<TousseInstance> buildMultiTousseInstance() {
         List<TousseInstance> allTousseInstances = new ArrayList<>();
         TousseInstance tousseInstance = new TousseInstance();
Index: ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/ScanMonitoringTousseCheckerImpl.java
===================================================================
diff -u -r41351 -r41361
--- ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/ScanMonitoringTousseCheckerImpl.java	(.../ScanMonitoringTousseCheckerImpl.java)	(revision 41351)
+++ ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/ScanMonitoringTousseCheckerImpl.java	(.../ScanMonitoringTousseCheckerImpl.java)	(revision 41361)
@@ -1,31 +1,33 @@
 package com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.service;
 
 import com.forgon.Constants;
+import com.forgon.disinfectsystem.basedatamanager.holiday.model.HolidayType;
+import com.forgon.disinfectsystem.basedatamanager.holiday.service.HolidayConfigManager;
 import com.forgon.disinfectsystem.basedatamanager.sterilisation.service.SterilisationManager;
+import com.forgon.disinfectsystem.basedatamanager.sterilizer.model.MonitoringPackageScanRule;
 import com.forgon.disinfectsystem.basedatamanager.sterilizer.service.SterilizerManager;
 import com.forgon.disinfectsystem.entity.basedatamanager.sterilisation.Sterilisation;
 import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer;
 import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseDefinition;
 import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseInstance;
 import com.forgon.disinfectsystem.entity.packing.ReviewedBasket;
 import com.forgon.disinfectsystem.entity.sterilizationmanager.sterilizationrecord.SterilizationRecord;
-import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model.MonitoringPackageScanRule;
 import com.forgon.disinfectsystem.sterilizationmanager.sterilizationrecord.model.ScanMonitoringResult;
 import com.forgon.disinfectsystem.tousse.toussedefinition.service.TousseInstanceManager;
 import com.forgon.exception.UnScanSterilizationMonitoringPackageException;
 import com.forgon.tools.db.DatabaseUtil;
 import com.forgon.tools.hibernate.ObjectDao;
 import com.forgon.tools.util.ConfigUtils;
+import com.forgon.tools.util.ForgonDateUtils;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
-import static com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer.MONITORTOUSSEDISPLAY_IMPLANT;
+import static com.forgon.disinfectsystem.basedatamanager.sterilizer.service.MonitoringPackageScanRuleParser.transformConfig;
 
 @Service("scanMonitoringTousseChecker")
 public class ScanMonitoringTousseCheckerImpl implements ScanMonitoringTousseChecker{
@@ -37,6 +39,8 @@
     private ObjectDao objectDao;
     @Autowired
     private TousseInstanceManager tousseInstanceManager;
+    @Autowired
+    private HolidayConfigManager holidayConfigManager;
 
     @Override
     public void isNeedScanMonitoringTousse(SterilizationRecord sterilizationRecord, Collection<TousseInstance> allTousseInstances) {
@@ -108,19 +112,33 @@
             }
             ScanMonitoringResult result = new ScanMonitoringResult();
             List<MonitoringPackageScanRule> monitorTousseDisplayArray = transformConfig(monitorTousseDisplay);
+            HolidayType holidayType = holidayConfigManager.holidayTypeOfToday();
             for (MonitoringPackageScanRule cfg : monitorTousseDisplayArray) {
                 if(result.isUnScanMonitorPackageBarcode() && result.isUnScanChemistryPackageBarcode()){
                     break;
                 }
 
-                //每炉(第1炉除外)
-                if (cfg.frequencyOfExceptFirst() && frequency != 1) {
-                    if (checkItem(cfg, monitorPackageBarcode, chemistryPackageBarcode, result)) break;
+                // 如果是假期触发并与当天假期类型不匹配，则忽略该配置
+                if (cfg.triggerOfHolidayRange() && !cfg.triggerOfHoliday(holidayType)) {
+                    continue;
                 }
+                // 每周触发并与当前周数不匹配，则忽略该配置
+                if (cfg.triggerOfWeekRange() && !cfg.triggerOfWeek(ForgonDateUtils.getDayWeekOfToday())){
+                    continue;
+                }
 
-                //每天第一炉
-                if (cfg.frequencyOf(1) && frequency == 1) {
-                    if (checkItem(cfg, monitorPackageBarcode, chemistryPackageBarcode, result)) break;
+                //每天/每周/假期触发的情况-之前对周几不匹配和假期不匹配已经做了过滤，这里就不需要再做判断
+                if (cfg.triggerOfEveryDay() || cfg.triggerOfWeekRange() || cfg.triggerOfHolidayRange()) {
+                    // 全部炉次
+                    if (cfg.frequencyOfAll()) {
+                        if (checkItem(cfg, monitorPackageBarcode, chemistryPackageBarcode, result)) break;
+                    }else if(cfg.frequencyOfExceptFirst() && frequency != 1) {
+                        // 第1炉除外
+                        if (checkItem(cfg, monitorPackageBarcode, chemistryPackageBarcode, result)) break;
+                    }else if(cfg.frequencyOf(frequency)) {
+                        // 每天指定炉次
+                        if (checkItem(cfg, monitorPackageBarcode, chemistryPackageBarcode, result)) break;
+                    }
                 }
 
                 //有植入物时
@@ -152,52 +170,18 @@
         }
     }
 
-    private List<MonitoringPackageScanRule> transformConfig(String oldConfig) {
-        List<MonitoringPackageScanRule> result = new ArrayList<>();
-        String[] monitorTousseDisplayArray = oldConfig.split(";");
-        for (String item : monitorTousseDisplayArray) {
-            MonitoringPackageScanRule cfg = parseConfigItem(item);
-            result.add(cfg);
-        }
-        return result;
-    }
-
     private static boolean checkItem(MonitoringPackageScanRule item, String monitorPackageBarcode, String chemistryPackageBarcode, ScanMonitoringResult result) {
-        if (item.isBiologicalPackageEnabled() && item.isChemicalPackageEnabled() && StringUtils.isBlank(monitorPackageBarcode) && StringUtils.isBlank(chemistryPackageBarcode)) {
+        if (item.biologicalPackageEnabled() && item.chemicalPackageEnabled() && StringUtils.isBlank(monitorPackageBarcode) && StringUtils.isBlank(chemistryPackageBarcode)) {
             result.setUnScanMonitorPackageBarcode(true);
             result.setUnScanChemistryPackageBarcode(true);
             return true;
-        } else if (item.isBiologicalPackageEnabled() && StringUtils.isBlank(monitorPackageBarcode)) {
+        } else if (item.biologicalPackageEnabled() && StringUtils.isBlank(monitorPackageBarcode)) {
             result.setUnScanMonitorPackageBarcode(true);
-        } else if (item.isChemicalPackageEnabled() && StringUtils.isBlank(chemistryPackageBarcode)) {
+        } else if (item.chemicalPackageEnabled() && StringUtils.isBlank(chemistryPackageBarcode)) {
             result.setUnScanChemistryPackageBarcode(true);
-        } else if (!item.isBiologicalPackageEnabled() && !item.isChemicalPackageEnabled() && StringUtils.isBlank(monitorPackageBarcode)) {
+        } else if (!item.biologicalPackageEnabled() && !item.chemicalPackageEnabled() && StringUtils.isBlank(monitorPackageBarcode)) {
             result.setUnScanMonitorPackageBarcode(true);
         }
         return false;
     }
-
-    /**
-     * 针对旧配置的解析
-     * @param oldConfig 旧的配置项，结构如：每炉(第1炉除外)_生物_化学，生物和化学的位置可能互换，如：每炉(第1炉除外)_化学_生物
-     * @return 对象化配置项
-     */
-    private MonitoringPackageScanRule parseConfigItem(String oldConfig) {
-        MonitoringPackageScanRule cfg = new MonitoringPackageScanRule("每天", 1, oldConfig.contains("化学"), oldConfig.contains("生物"));
-        if(oldConfig.contains(Sterilizer.MONITORTOUSSEDISPLAY_EVERYTHING)){
-            cfg.setFrequency(-2);
-        }
-        if(oldConfig.contains(Sterilizer.MONITORTOUSSEDISPLAY_FIRST)){
-            cfg.setFrequency(1);
-        }
-        if(oldConfig.contains(MONITORTOUSSEDISPLAY_IMPLANT)){
-            cfg.setFrequency(-1);
-            cfg.setTrigger(MONITORTOUSSEDISPLAY_IMPLANT);
-        }
-        if(oldConfig.contains(Sterilizer.MONITORTOUSSEDISPLAY_FOREIGN_TOUSSE)){
-            cfg.setFrequency(-1);
-            cfg.setTrigger(Sterilizer.MONITORTOUSSEDISPLAY_FOREIGN_TOUSSE);
-        }
-        return cfg;
-    }
 }
Index: ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManager.java
===================================================================
diff -u -r41338 -r41361
--- ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManager.java	(.../SterilizationRecordManager.java)	(revision 41338)
+++ ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManager.java	(.../SterilizationRecordManager.java)	(revision 41361)
@@ -627,15 +627,6 @@
 	public List<SystemWarningVo> promptUploadDeviceParameterPicture();
 
 	/**
-	 * 验证灭菌炉某一炉次对应的灭菌程序是否正确(灭菌炉的“按炉次提醒的灭菌程序设置”中设置炉次对应的灭菌程序)
-	 * @param sterilizerName  灭菌炉名称
-	 * @param sterilizationType 灭菌程序
-	 * @param frequency 炉次
-	 * @return {success:true} or {success:false,message:**}
-	 */
-	SterilisationNotice isHavedoneNeedNoticeSterilisation(String sterilizerName, String sterilizationType, String frequency);
-
-	/**
 	 * 根据灭菌记录id获取灭菌记录图片数量
 	 * @param sterilizationRecordIdList
 	 * @return
Index: ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManagerImpl.java
===================================================================
diff -u -r41351 -r41361
--- ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManagerImpl.java	(.../SterilizationRecordManagerImpl.java)	(revision 41351)
+++ ssts-sterile/src/main/java/com/forgon/disinfectsystem/sterilizationmanager/sterilizationrecord/service/SterilizationRecordManagerImpl.java	(.../SterilizationRecordManagerImpl.java)	(revision 41361)
@@ -9001,40 +9001,6 @@
 	}
 	
 	@Override
-	public SterilisationNotice isHavedoneNeedNoticeSterilisation(String sterilizerName, String sterilizationType, String frequency) {
-		Sterilizer sterilizer = (Sterilizer) objectDao.getByProperty(Sterilizer.class.getSimpleName(), "name", sterilizerName);
-        if(sterilizer == null){
-            return new SterilisationNotice(false, "灭菌炉不存在");
-        }
-        SterilisationNotice notice = new SterilisationNotice();
-		List<SterilizationFrequecyRemind> sterilizationFrequecyReminds = sterilizer.getSterilizationFrequecyReminds();
-		
-		if(CollectionUtils.isNotEmpty(sterilizationFrequecyReminds)){
-			for (SterilizationFrequecyRemind remind : sterilizationFrequecyReminds) {
-				// 配置中的炉次或者灭菌程序为空时，不验证
-				if(remind.getFrequency() == null || remind.getFrequency().intValue() < 1
-						|| remind.getSterilisation() == null){
-					continue;
-				}
-				
-				if(StringUtils.equals(frequency, remind.getFrequency().toString())
-						&& !StringUtils.equals(sterilizationType, remind.getSterilisation().getSterilisation())){
-					notice = new SterilisationNotice(false, remind.getRemindMode(),
-                            remind.getSterilisation().getSterilisation(), remind.getFrequency());
-					if(StringUtils.equals(remind.getRemindMode(), SterilizationFrequecyRemind.REMINDMODE_MANDATORY)){
-                        notice.setConfirmMessage(sterilizerName + "第" + frequency + "炉的灭菌程序必须是" + remind.getSterilisation().getSterilisation() + "！");
-					}else{
-						notice.setConfirmMessage(sterilizerName + "第" + frequency + "炉的灭菌程序应该是" + remind.getSterilisation().getSterilisation() + "，不修改灭菌程序继续操作吗？");
-					}
-					break;
-				}
-			}
-		}
-		return notice;
-	}
-
-	
-	@Override
 	public Map<Long, Integer> getSterilizationRecordPicAmountMap(List<Long> sterilizationRecordIdList) {
 		
 		Map<Long, Integer> result = new HashMap<Long, Integer>();