Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/EquipInspectionRemindUser.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/EquipInspectionRemindUser.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/EquipInspectionRemindUser.java (revision 38054) @@ -0,0 +1,66 @@ +package com.forgon.disinfectsystem.entity.equipmentinspection.definition; + +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Index; +import javax.persistence.Table; + +import org.hibernate.annotations.Cache; +import org.hibernate.annotations.CacheConcurrencyStrategy; +import org.hibernate.annotations.DynamicInsert; +import org.hibernate.annotations.DynamicUpdate; + +/** + * 提醒用户ZSRY-60 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +@Table(indexes = {@Index(columnList = "userId", name = "einspect_userId_index"),@Index(columnList = "equipmentInspectionDefId", name = "einspect_ei_def_Id_index")}) +public class EquipInspectionRemindUser { + + /** + * ID + */ + private Long id; + + /** + * 提醒用户ID + */ + private Long userId; + + /** + * 设备巡检定义ID + */ + private Long equipmentInspectionDefId; + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getUserId() { + return userId; + } + + public void setUserId(Long userId) { + this.userId = userId; + } + + public Long getEquipmentInspectionDefId() { + return equipmentInspectionDefId; + } + + public void setEquipmentInspectionDefId(Long equipmentInspectionDefId) { + this.equipmentInspectionDefId = equipmentInspectionDefId; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/ApplicableEquipment.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/ApplicableEquipment.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/ApplicableEquipment.java (revision 38054) @@ -0,0 +1,83 @@ +package com.forgon.disinfectsystem.entity.equipmentinspection.definition; + +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Index; +import javax.persistence.Table; + +import org.hibernate.annotations.Cache; +import org.hibernate.annotations.CacheConcurrencyStrategy; +import org.hibernate.annotations.DynamicInsert; +import org.hibernate.annotations.DynamicUpdate; + +/** + * 适用设备ZSRY-60 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +@Table(name = "ApplicableEquipment",indexes = {@Index(columnList = "equipmentId", name = "ae_equipment_id_index"), + @Index(columnList = "equipmentInspectionDefId", name = "ae_inspection_def_id_index")}) +public class ApplicableEquipment { + + private Long id; + + /** + * 适用设备ID + */ + private Long equipmentId; + + /** + * 设备巡检定义ID + */ + private Long equipmentInspectionDefId; + + /** + * 设备类型：“清洗机”、“灭菌炉”和“生物阅读器” + */ + private String type; + + public final static String TYPE_RINSER = "清洗机"; + + public final static String TYPE_STERILIZER = "灭菌炉"; + + public final static String TYPE_BIOREADER = "生物阅读器"; + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getEquipmentId() { + return equipmentId; + } + + public void setEquipmentId(Long equipmentId) { + this.equipmentId = equipmentId; + } + + public Long getEquipmentInspectionDefId() { + return equipmentInspectionDefId; + } + + public void setEquipmentInspectionDefId(Long equipmentInspectionDefId) { + this.equipmentInspectionDefId = equipmentInspectionDefId; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + +} Index: ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/dwr/table/EquipmentInspectionDefTableManager.java =================================================================== diff -u --- ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/dwr/table/EquipmentInspectionDefTableManager.java (revision 0) +++ ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/dwr/table/EquipmentInspectionDefTableManager.java (revision 38054) @@ -0,0 +1,170 @@ +package com.forgon.disinfectsystem.equipmentinspection.definition.dwr.table; + +import java.sql.ResultSet; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang.StringUtils; + +import net.sf.json.JSONArray; +import net.sf.json.JSONObject; + +import com.forgon.component.grid.GridManager; +import com.forgon.disinfectsystem.customform.formdefinition.service.FormDefinitionManager; +import com.forgon.disinfectsystem.entity.basedatamanager.bioreader.Bioreader; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.Rinser; +import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer; +import com.forgon.disinfectsystem.entity.customform.formdefinition.FormDefinition; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.ApplicableEquipment; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.EquipmentInspectionDef; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.hibernate.ObjectDao; +import com.forgon.tools.string.StringTools; +import com.forgon.tools.util.SqlUtils; + +/** + * 设备巡检定义ZSRY-60 + */ +public class EquipmentInspectionDefTableManager { + + private GridManager gridManager; + + private ObjectDao objectDao; + + private FormDefinitionManager formDefinitionManager; + + public void setFormDefinitionManager(FormDefinitionManager formDefinitionManager) { + this.formDefinitionManager = formDefinitionManager; + } + + public void setObjectDao(ObjectDao objectDao) { + this.objectDao = objectDao; + } + + public void setGridManager(GridManager gridManager) { + this.gridManager = gridManager; + } + + /** + * 巡检定义列表 + * @param parameterMap + * @return + */ + public String findEquipmentInspectionDefList(Map> parameterMap) { + + String sql = "where 1=1"; + + Map sqlWhereParamMap = gridManager.getParamFromView(parameterMap); + String listType = sqlWhereParamMap.get("listType"); + + sql += " and po.formType = '" + FormDefinition.FOMRTYPE_EQUIPMENTINSPECTION + "'"; + //已部署的定义 + if("deployed".equals(listType)){ + sql += "and po.isDeploy = '" + FormDefinition.ACTION_DEPLOY + "'"; + }else if("lastDefinition".equals(listType)){ + sql += " and po.id in (" + formDefinitionManager.getLastEditFormDefinitionSQL("",FormDefinition.FOMRTYPE_EQUIPMENTINSPECTION) + ") "; + } + + String json = gridManager.renderGrid(parameterMap, + EquipmentInspectionDef.class.getSimpleName(), sql, new String[] {}); + //查询适用设备 + json = searchApplicableEquipment(json); + return json; + } + + /** + * 查询适用设备 + * @param json + * @return + */ + private String searchApplicableEquipment(String json) { + JSONObject jsonObject = JSONObject.fromObject(json); + if(jsonObject == null){ + return json; + } + JSONArray jsonArray = jsonObject.optJSONArray("rows"); + if (jsonArray == null || jsonArray.size() == 0) { + return json; + } + List equipmentInspectionDefIdList = new ArrayList(); + for (int i = 0; i < jsonArray.size(); i++) { + JSONObject obj = jsonArray.optJSONObject(i); + if (obj == null) { + continue; + } + Long id = obj.optLong("id"); + if(!DatabaseUtil.isPoIdValid(id)){ + continue; + } + equipmentInspectionDefIdList.add(id); + } + if(CollectionUtils.isEmpty(equipmentInspectionDefIdList)){ + return json; + } + Map> applicableEquipmentNameMap = new HashMap>(); + String sql = String.format("select ae.equipmentInspectionDefId, ae.id, r.name rinserName, st.name sterilizerName, bio.bioreaderName " + + "from %s ae " + + "left join %s r on ae.equipmentId = r.id and ae.type = '%s' " + + "left join %s st on st.id = ae.equipmentId and ae.type = '%s' " + + "left join %s bio on bio.id = ae.equipmentId and ae.type = '%s' " + + "where %s ", + ApplicableEquipment.class.getSimpleName(), + Rinser.class.getSimpleName(), + ApplicableEquipment.TYPE_RINSER, + Sterilizer.class.getSimpleName(), + ApplicableEquipment.TYPE_STERILIZER, + Bioreader.class.getSimpleName(), + ApplicableEquipment.TYPE_BIOREADER, + SqlUtils.getNonStringFieldInLargeCollectionsPredicate("ae.equipmentInspectionDefId", equipmentInspectionDefIdList)); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sql); + while(rs.next()){ + Long id = rs.getLong("equipmentInspectionDefId"); + String rinserName = rs.getString("rinserName"); + String sterilizerName = rs.getString("sterilizerName"); + String bioreaderName = rs.getString("bioreaderName"); + List applicableEquipmentNameSet = applicableEquipmentNameMap.get(id); + if(applicableEquipmentNameSet == null){ + applicableEquipmentNameSet = new ArrayList(); + } + if(StringUtils.isNotBlank(rinserName)){ + applicableEquipmentNameSet.add(rinserName); + } + if(StringUtils.isNotBlank(sterilizerName)){ + applicableEquipmentNameSet.add(sterilizerName); + } + if(StringUtils.isNotBlank(bioreaderName)){ + applicableEquipmentNameSet.add(bioreaderName); + } + applicableEquipmentNameMap.put(id, applicableEquipmentNameSet); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + + for (int i = 0; i < jsonArray.size(); i++) { + JSONObject obj = jsonArray.optJSONObject(i); + if (obj == null) { + continue; + } + Long id = obj.optLong("id"); + if(!DatabaseUtil.isPoIdValid(id)){ + continue; + } + List applicableEquipmentNameSet = applicableEquipmentNameMap.get(id); + if(CollectionUtils.isNotEmpty(applicableEquipmentNameSet)){ + obj.put("applicableEquipment", StringTools.join(applicableEquipmentNameSet, ";")); + } + } + jsonObject.put("rows", jsonArray); + + return jsonObject.toString(); + } + +} Index: ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/service/EquipmentInspectionDefManagerImpl.java =================================================================== diff -u --- ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/service/EquipmentInspectionDefManagerImpl.java (revision 0) +++ ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/service/EquipmentInspectionDefManagerImpl.java (revision 38054) @@ -0,0 +1,1109 @@ +package com.forgon.disinfectsystem.equipmentinspection.definition.service; + +import java.sql.ResultSet; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.stream.Collectors; +import java.util.Set; + +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.MapUtils; +import org.apache.commons.collections4.map.HashedMap; +import org.apache.commons.lang.StringUtils; + +import com.forgon.Constants; +import com.forgon.directory.model.BarcodeDevice; +import com.forgon.disinfectsystem.basedatamanager.rinser.service.RinserManager; +import com.forgon.disinfectsystem.customform.formdefinition.service.FormDefinitionManager; +import com.forgon.disinfectsystem.entity.basedatamanager.bioreader.Bioreader; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.Rinser; +import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer; +import com.forgon.disinfectsystem.entity.customform.formdefinition.FormDefinition; +import com.forgon.disinfectsystem.entity.customform.forminstance.FormInstance; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.ApplicableEquipment; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.EquipInspectionRemindUser; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.EquipmentInspectionDef; +import com.forgon.disinfectsystem.entity.sterilizationmanager.sterilizationrecord.SterilizationRecord; +import com.forgon.disinfectsystem.entity.washanddisinfectmanager.washanddisinfectrecord.WashAndDisinfectRecord; +import com.forgon.disinfectsystem.sterilizationmanager.bioreader.service.BioreaderManager; +import com.forgon.disinfectsystem.vo.ApplicableEquipmentVo; +import com.forgon.exception.SystemException; +import com.forgon.security.model.User; +import com.forgon.security.service.UserManager; +import com.forgon.tools.date.DateTools; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.hibernate.BasePoManagerImpl; +import com.forgon.tools.string.StringTools; +import com.forgon.tools.util.ConfigUtils; +import com.forgon.tools.util.SqlUtils; + +import net.sf.json.JSONArray; +import net.sf.json.JSONObject; + +public class EquipmentInspectionDefManagerImpl extends BasePoManagerImpl implements EquipmentInspectionDefManager { + + private RinserManager rinserManager; + + private BioreaderManager bioreaderManager; + + private FormDefinitionManager formDefinitionManager; + + private UserManager userManager; + + public void setUserManager(UserManager userManager) { + this.userManager = userManager; + } + + public void setFormDefinitionManager(FormDefinitionManager formDefinitionManager) { + this.formDefinitionManager = formDefinitionManager; + } + + public void setRinserManager(RinserManager rinserManager) { + this.rinserManager = rinserManager; + } + + public void setBioreaderManager(BioreaderManager bioreaderManager) { + this.bioreaderManager = bioreaderManager; + } + + @SuppressWarnings("unchecked") + @Override + public JSONArray loadDeviceInfo() { + JSONArray data = new JSONArray(); + + //清洗机 + List rinserList = rinserManager.getByProperty("useStatus", Rinser.USESTATUS_IN_USE); + if(CollectionUtils.isNotEmpty(rinserList)){ + for (Rinser rinser : rinserList) { + JSONObject json = new JSONObject(); + json.put("id", rinser.getId()); + json.put("name", rinser.getName()); + json.put("type", BarcodeDevice.BARCODE_TYPE_RINSER); + data.add(json); + } + } + //灭菌炉 + String sterilizerHql = String.format(" from %s where useStatus = '%s' ", Sterilizer.class.getSimpleName(), Sterilizer.USESTATUS_IN_USE); + List sterilizerList = objectDao.findByHql(sterilizerHql); + if(CollectionUtils.isNotEmpty(sterilizerList)){ + for (Sterilizer sterilizer : sterilizerList) { + JSONObject json = new JSONObject(); + json.put("id", sterilizer.getId()); + json.put("name", sterilizer.getName()); + json.put("type", BarcodeDevice.BARCODE_TYPE_STERILIZER); + data.add(json); + } + } + //启用生物阅读器 + boolean enableBioreaderInterface = ConfigUtils.getSystemSetConfigByNameBool("enableBioreaderInterface"); + if(enableBioreaderInterface){ + List bioreaderList = bioreaderManager.getByHql("po.isUse = 1"); + if(CollectionUtils.isNotEmpty(bioreaderList)){ + for (Bioreader bioreader : bioreaderList) { + if(bioreader.getIsUse() == 1){ + JSONObject json = new JSONObject(); + json.put("id", bioreader.getId()); + json.put("name", bioreader.getBioreaderName()); + json.put("type", BarcodeDevice.BARCODE_TYPE_BIOREADER); + data.add(json); + } + } + } + } + return data; + } + + @Override + public void saveOrUpdateEquipmentInspectionDef(EquipmentInspectionDef equipmentInspectionDef, JSONArray params, String actionType) { + + //验证参数是否合法 + valideEquipmentInspectionDef(equipmentInspectionDef); + FormDefinition savedDefintion = null; + if(FormDefinition.ACTION_DEPLOY.equals(actionType)){ + savedDefintion = formDefinitionManager.deployFormDefinition(equipmentInspectionDef, params); + }else if(FormDefinition.ACTION_SAVE.equals(actionType)){ + savedDefintion = formDefinitionManager.saveFormDefinition(equipmentInspectionDef, params); + }else { + throw new RuntimeException("actionType参数错误！"); + } + + //保存适用设备 + saveOrUpdateApplicableEquipment((EquipmentInspectionDef)savedDefintion); + //保存提醒用户 + saveOrUpdateEquipInspectionRemindUser((EquipmentInspectionDef)savedDefintion); + //验证触发项是否死循环以及设置触发项值 + if(savedDefintion != null){ + formDefinitionManager.checkAndSetOptionValueTriggerItemIds(savedDefintion); + } + } + + /** + * 保存提醒用户 + * @param equipmentInspectionDef + */ + private void saveOrUpdateEquipInspectionRemindUser(EquipmentInspectionDef equipmentInspectionDef) { + if(equipmentInspectionDef == null || StringUtils.isBlank(equipmentInspectionDef.getRemindUserIds())){ + return; + } + String remindUserIds = equipmentInspectionDef.getRemindUserIds(); + Collection remindUserIdColl = StringTools.parseToLongs(remindUserIds, ";"); + if(CollectionUtils.isEmpty(remindUserIdColl)){ + return; + } + List remindUserIdList = new ArrayList(); + remindUserIdList.addAll(remindUserIdColl); + List userList = userManager.getCollection(remindUserIdList); + if(CollectionUtils.isEmpty(userList)){ + return; + } + objectDao.excuteSQL(String.format("delete from %s where equipmentInspectionDefId = %s ", + EquipInspectionRemindUser.class.getSimpleName(), + equipmentInspectionDef.getId())); + for (User user : userList) { + EquipInspectionRemindUser eru = new EquipInspectionRemindUser(); + eru.setEquipmentInspectionDefId(equipmentInspectionDef.getId()); + eru.setUserId(user.getId()); + objectDao.save(eru); + } + } + + /** + * 保存适用设备 + * @param equipmentInspectionDef + */ + private void saveOrUpdateApplicableEquipment(EquipmentInspectionDef equipmentInspectionDef) { + if(equipmentInspectionDef == null){ + return; + } + if(StringUtils.isBlank(equipmentInspectionDef.getApplicableEquipmentArray())){ + return; + } + + //删除旧设备 + objectDao.excuteSQL("delete from " + ApplicableEquipment.class.getSimpleName() + " where EquipmentInspectionDefId = " + equipmentInspectionDef.getId()); + List applicableEquipmentList = new ArrayList(); + String applicableEquipmentArray = equipmentInspectionDef.getApplicableEquipmentArray(); + JSONArray applicableEquipmentJSONArray = JSONArray.fromObject(applicableEquipmentArray); + for(int i=0;i saveApplicableEquipmentList){ + //已存在适用设备为全部的定义 + String allEquipmentSql = String.format("select count(1) from %s def " + + "join %s fd on fd.id = def.id " + + "where def.allEquipment = '%s' " + + "and (fd.isDisabled is null or fd.isDisabled <> '%s') ", + EquipmentInspectionDef.class.getSimpleName(), + FormDefinition.class.getSimpleName(), + Constants.STR_YES, + Constants.STR_YES); + if(StringUtils.isNotBlank(equipmentInspectionDef.getFormName())){ + allEquipmentSql += String.format(" and fd.id not in (select id from %s where formName = '%s') ", FormDefinition.class.getSimpleName(), equipmentInspectionDef.getFormName()); + } + if(objectDao.countBySql(allEquipmentSql) > 0){ + throw new SystemException("已存在适用设备为全部的定义！"); + } + if(StringUtils.equals(equipmentInspectionDef.getAllEquipment(), Constants.STR_YES)){ + if(StringUtils.equals(equipmentInspectionDef.getRemindMode(), EquipmentInspectionDef.REMIND_MODE_FIXED_TIME_EVERY_DAY)){ + throw new SystemException("适用设备包含生物阅读器时，只允许设置为每天固定时间提醒。"); + } + } + + //检查设备是否存在 + Set typeEquipmentIdKeySet = new HashSet(); + List rinserIdList = new ArrayList(); + List sterilizerIdList = new ArrayList(); + List bioreaderIdList = new ArrayList(); + for (ApplicableEquipment applicableEquipment : saveApplicableEquipmentList) { + Long equipmentId = applicableEquipment.getEquipmentId(); + String type = applicableEquipment.getType(); + if(!DatabaseUtil.isPoIdValid(equipmentId)){ + throw new RuntimeException("设备ID异常"); + } + if(!StringUtils.equals(type, ApplicableEquipment.TYPE_RINSER) + && !StringUtils.equals(type, ApplicableEquipment.TYPE_STERILIZER) + && !StringUtils.equals(type, ApplicableEquipment.TYPE_BIOREADER)){ + throw new RuntimeException("设备类型异常"); + } + + if(StringUtils.equals(type, ApplicableEquipment.TYPE_RINSER)){ + rinserIdList.add(equipmentId); + }else if(StringUtils.equals(type, ApplicableEquipment.TYPE_STERILIZER)){ + sterilizerIdList.add(equipmentId); + }else if(StringUtils.equals(type, ApplicableEquipment.TYPE_BIOREADER)){ + //适用设备包含生物阅读器时，只允许设置为每天固定时间提醒 + if(StringUtils.equals(equipmentInspectionDef.getRemindMode(), EquipmentInspectionDef.REMIND_MODE_DEVICE_RUNNING)){ + throw new RuntimeException("适用设备包含生物阅读器时，只允许设置为每天固定时间提醒"); + } + bioreaderIdList.add(equipmentId); + }else{ + throw new RuntimeException("设备类型异常"); + } + + String key = StringTools.defaultString(type) + "_" + equipmentId; + if(typeEquipmentIdKeySet.contains(key)){ + throw new RuntimeException("设备参数异常"); + } + typeEquipmentIdKeySet.add(key); + } + + if(CollectionUtils.isNotEmpty(rinserIdList)){ + List rinsers = rinserManager.getCollection(rinserIdList); + if(CollectionUtils.isEmpty(rinsers) || rinsers.size() < rinserIdList.size()){ + throw new RuntimeException("设备ID异常"); + } + } + if(CollectionUtils.isNotEmpty(sterilizerIdList)){ + @SuppressWarnings("unchecked") + List sterilizerList = objectDao.getCollection(Sterilizer.class.getSimpleName(), "id", sterilizerIdList); + if(CollectionUtils.isEmpty(sterilizerList) || sterilizerList.size() < sterilizerIdList.size()){ + throw new RuntimeException("设备ID异常"); + } + } + if(CollectionUtils.isNotEmpty(bioreaderIdList)){ + List bioreaderList = bioreaderManager.getCollection(bioreaderIdList); + if(CollectionUtils.isEmpty(bioreaderList) || bioreaderList.size() < bioreaderIdList.size()){ + throw new RuntimeException("设备ID异常"); + } + } + + List errorApplicableEquipmentList = new ArrayList(); + for (ApplicableEquipment applicableEquipment : saveApplicableEquipmentList) { + //同个设备不能在多个定义中设置，如设置的设备已经存在其他正在启用的定义中，则不能保存； + StringBuffer sql = new StringBuffer(); + sql.append("select count(1) from "); + sql.append(ApplicableEquipment.class.getSimpleName()); + sql.append(" ae join "); + sql.append(FormDefinition.class.getSimpleName()); + sql.append(" fd on fd.id = ae.equipmentInspectionDefId "); + sql.append("where fd.formType = '"); + sql.append(FormDefinition.FOMRTYPE_EQUIPMENTINSPECTION); + sql.append("' and (fd.isDisabled is null or fd.isDisabled <> '"); + sql.append(Constants.STR_YES); + sql.append("') and equipmentId = "); + sql.append(applicableEquipment.getEquipmentId()); + sql.append(" and type = '"); + sql.append(applicableEquipment.getType()); + sql.append("' "); + sql.append("and fd.formName <> '"); + sql.append(equipmentInspectionDef.getFormName()); + sql.append("' "); + if(objectDao.countBySql(sql.toString()) > 0){ + errorApplicableEquipmentList.add(applicableEquipment); + continue; + } + } + //如果有异常的适用设备，需要提示 + returnErrorEquipmentNames(errorApplicableEquipmentList); + } + + /** + * 如果有异常的适用设备，需要返回提示信息 + * @param errorApplicableEquipmentList + */ + private void returnErrorEquipmentNames(List errorApplicableEquipmentList) { + List equipmentNames = new ArrayList(); + if(CollectionUtils.isNotEmpty(errorApplicableEquipmentList)){ + List rinserIdList = new ArrayList(); + List sterilizerIdList = new ArrayList(); + List bioreaderIdList = new ArrayList(); + for (ApplicableEquipment applicableEquipment : errorApplicableEquipmentList) { + String type = applicableEquipment.getType(); + Long equipmentId = applicableEquipment.getEquipmentId(); + if(StringUtils.equals(type , ApplicableEquipment.TYPE_RINSER)){ + rinserIdList.add(equipmentId); + }else if(StringUtils.equals(type, ApplicableEquipment.TYPE_STERILIZER)){ + sterilizerIdList.add(equipmentId); + }else if(StringUtils.equals(type, ApplicableEquipment.TYPE_BIOREADER)){ + bioreaderIdList.add(equipmentId); + }else{ + throw new RuntimeException("设备类型异常"); + } + } + if(CollectionUtils.isNotEmpty(rinserIdList)){ + List rinsers = rinserManager.getCollection(rinserIdList); + if(CollectionUtils.isNotEmpty(rinsers)){ + for (Rinser rinser : rinsers) { + equipmentNames.add(rinser.getName()); + } + } + } + if(CollectionUtils.isNotEmpty(sterilizerIdList)){ + @SuppressWarnings("unchecked") + List sterilizerList = objectDao.getCollection(Sterilizer.class.getSimpleName(), "id", sterilizerIdList); + if(CollectionUtils.isNotEmpty(sterilizerList)){ + for (Sterilizer sterilizer : sterilizerList) { + equipmentNames.add(sterilizer.getName()); + } + } + } + if(CollectionUtils.isNotEmpty(bioreaderIdList)){ + List bioreaderList = bioreaderManager.getCollection(bioreaderIdList); + if(CollectionUtils.isNotEmpty(bioreaderList)){ + for (Bioreader bioreader : bioreaderList) { + equipmentNames.add(bioreader.getBioreaderName()); + } + } + } + if(CollectionUtils.isNotEmpty(equipmentNames)){ + throw new SystemException(StringTools.join(equipmentNames, "、") + "已经被设置为其它巡检定义的适用设备。"); + } + } + } + + /** + * 验证参数是否合法 + * @param equipmentInspectionDef + */ + private void valideEquipmentInspectionDef(EquipmentInspectionDef equipmentInspectionDef) { + + if(equipmentInspectionDef == null){ + throw new SystemException("参数异常"); + } + + if(StringUtils.isBlank(equipmentInspectionDef.getFormName())){ + throw new SystemException("定义名称为必填项"); + } + + if(!StringUtils.equals(equipmentInspectionDef.getAllEquipment(), Constants.STR_YES) + && StringUtils.isBlank(equipmentInspectionDef.getApplicableEquipmentArray())){ + throw new SystemException("适用设备为必填项"); + } + + if(!StringUtils.equals(equipmentInspectionDef.getEquipmentInspectionRemind(), Constants.STR_YES) + && !StringUtils.equals(equipmentInspectionDef.getEquipmentInspectionRemind(), Constants.STR_NO)){ + throw new SystemException("是否提醒为必填项"); + } + + //是否提醒为“是”时 + if(StringUtils.equals(equipmentInspectionDef.getEquipmentInspectionRemind(), Constants.STR_YES)){ + if(!StringUtils.equals(equipmentInspectionDef.getRemindMode(), EquipmentInspectionDef.REMIND_MODE_DEVICE_RUNNING) + && !StringUtils.equals(equipmentInspectionDef.getRemindMode(), EquipmentInspectionDef.REMIND_MODE_FIXED_TIME_EVERY_DAY)){ + throw new SystemException("提醒模式为必填项"); + } + if(!StringUtils.equals(equipmentInspectionDef.getRemindAllUsers(), Constants.STR_YES) + && StringUtils.isBlank(equipmentInspectionDef.getRemindUserIds())){ + throw new SystemException("提醒用户为必填项"); + } + if(equipmentInspectionDef.getRemindDuration() == null){ + throw new SystemException("间隔时长(分)为必填项"); + } + if(equipmentInspectionDef.getRemindDuration() <= 0){ + throw new SystemException("间隔时长(分)必须大于0"); + } + + //“提醒模式”设置为“每天固定时间提醒时” + if(StringUtils.equals(equipmentInspectionDef.getRemindMode(), EquipmentInspectionDef.REMIND_MODE_FIXED_TIME_EVERY_DAY)){ + Date remindStartTime = null; + Date remindEndTime = null; + try { + remindStartTime = DateTools.coverStrToDate(equipmentInspectionDef.getRemindStartTime(), "HH:mm"); + remindEndTime = DateTools.coverStrToDate(equipmentInspectionDef.getRemindEndTime(), "HH:mm"); + } catch (Exception e) { + e.printStackTrace(); + } + if(remindStartTime == null){ + throw new SystemException("提醒开始时间为必填项"); + } + if(remindEndTime == null){ + throw new SystemException("提醒结束时间为必填项"); + } + if(remindStartTime.after(remindEndTime)){ + //结束时间不能早于开始时间。 + throw new SystemException("结束时间不能早于或等于开始时间。"); + } + if(remindStartTime.equals(remindEndTime)){ + //结束时间不能等于开始时间。 + throw new SystemException("结束时间不能等于开始时间。"); + } + } + } + + //已存在适用设备为全部的定义 + String allEquipmentSql = String.format("select count(1) from %s def " + + "join %s fd on fd.id = def.id " + + "where def.allEquipment = '%s' " + + "and (fd.isDisabled is null or fd.isDisabled <> '%s') ", + EquipmentInspectionDef.class.getSimpleName(), + FormDefinition.class.getSimpleName(), + Constants.STR_YES, + Constants.STR_YES); + if(StringUtils.isNotBlank(equipmentInspectionDef.getFormName())){ + allEquipmentSql += String.format(" and fd.id not in (select id from %s where formName = '%s') ", FormDefinition.class.getSimpleName(), equipmentInspectionDef.getFormName()); + } + if(objectDao.countBySql(allEquipmentSql) > 0){ + throw new SystemException("已存在适用设备为全部的定义！"); + } + if(StringUtils.equals(equipmentInspectionDef.getAllEquipment(), Constants.STR_YES)){ + if(StringUtils.equals(equipmentInspectionDef.getRemindMode(), EquipmentInspectionDef.REMIND_MODE_FIXED_TIME_EVERY_DAY)){ + throw new SystemException("适用设备包含生物阅读器时，只允许设置为每天固定时间提醒。"); + } + } + } + + @Override + public Map> loadApplicableEquipment(List equipmentInspectionDefIdList) { + + Map> applicableEquipmentVoMap = new HashedMap>(); + String sql = String.format("select ae.id, r.id rinserId, r.name rinserName," + + "st.id sterilizerId, st.name sterilizerName, bio.id bioreaderId, bio.bioreaderName, " + + "ae.equipmentInspectionDefId " + + "from %s ae " + + "left join %s r on ae.equipmentId = r.id and ae.type = '%s' " + + "left join %s st on st.id = ae.equipmentId and ae.type = '%s' " + + "left join %s bio on bio.id = ae.equipmentId and ae.type = '%s' " + + "where %s ", + ApplicableEquipment.class.getSimpleName(), + Rinser.class.getSimpleName(), + ApplicableEquipment.TYPE_RINSER, + Sterilizer.class.getSimpleName(), + ApplicableEquipment.TYPE_STERILIZER, + Bioreader.class.getSimpleName(), + ApplicableEquipment.TYPE_BIOREADER, + SqlUtils.getNonStringFieldInLargeCollectionsPredicate("ae.equipmentInspectionDefId", equipmentInspectionDefIdList)); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sql); + while(rs.next()){ + Long id = rs.getLong("id"); + Long rinserId = rs.getLong("rinserId"); + String rinserName = rs.getString("rinserName"); + Long sterilizerId = rs.getLong("sterilizerId"); + String sterilizerName = rs.getString("sterilizerName"); + Long bioreaderId = rs.getLong("bioreaderId"); + String bioreaderName = rs.getString("bioreaderName"); + Long equipmentInspectionDefId = rs.getLong("equipmentInspectionDefId"); + + List voList = applicableEquipmentVoMap.get(equipmentInspectionDefId); + if(voList == null){ + voList = new ArrayList(); + } + + //清洗机 + if(DatabaseUtil.isPoIdValid(rinserId)){ + ApplicableEquipmentVo vo = new ApplicableEquipmentVo(); + vo.setId(id); + vo.setEquipmentId(rinserId); + vo.setEquipmentInspectionDefId(equipmentInspectionDefId); + vo.setEquipmentName(rinserName); + vo.setType(ApplicableEquipment.TYPE_RINSER); + voList.add(vo); + } + + //灭菌炉 + if(DatabaseUtil.isPoIdValid(sterilizerId)){ + ApplicableEquipmentVo vo = new ApplicableEquipmentVo(); + vo.setId(id); + vo.setEquipmentId(sterilizerId); + vo.setEquipmentInspectionDefId(equipmentInspectionDefId); + vo.setEquipmentName(sterilizerName); + vo.setType(ApplicableEquipment.TYPE_STERILIZER); + voList.add(vo); + } + + //生物阅读器 + if(DatabaseUtil.isPoIdValid(bioreaderId)){ + ApplicableEquipmentVo vo = new ApplicableEquipmentVo(); + vo.setId(id); + vo.setEquipmentId(bioreaderId); + vo.setEquipmentInspectionDefId(equipmentInspectionDefId); + vo.setEquipmentName(bioreaderName); + vo.setType(ApplicableEquipment.TYPE_BIOREADER); + voList.add(vo); + } + + applicableEquipmentVoMap.put(equipmentInspectionDefId, voList); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + return applicableEquipmentVoMap; + } + + @Override + public EquipmentInspectionDef loadEquipmentInspectionDef(Long id) { + if(!DatabaseUtil.isPoIdValid(id)){ + throw new RuntimeException("id无效！"); + } + EquipmentInspectionDef equipmentInspectionDef = this.get(id); + if(equipmentInspectionDef == null){ + return null; + } + //加载适用设备 + List equipmentInspectionDefIdList = new ArrayList(); + equipmentInspectionDefIdList.add(id); + Map> map = this.loadApplicableEquipment(equipmentInspectionDefIdList ); + if(MapUtils.isNotEmpty(map)){ + List voList = map.get(id); + if(CollectionUtils.isNotEmpty(voList)){ + JSONArray applicableEquipmentArray = JSONArray.fromObject(voList); + equipmentInspectionDef.setApplicableEquipmentArray(applicableEquipmentArray.toString()); + } + } + //加载提醒人员姓名 + Map remindUserNameMap = loadRemindUserNameMap(equipmentInspectionDefIdList); + if(MapUtils.isNotEmpty(remindUserNameMap)){ + equipmentInspectionDef.setRemindUserNames(remindUserNameMap.get(id)); + } + + //加载提醒人员ID + Map remindUserIDMap = loadRemindUserIDMap(equipmentInspectionDefIdList); + if(MapUtils.isNotEmpty(remindUserIDMap)){ + equipmentInspectionDef.setRemindUserIds(remindUserIDMap.get(id)); + } + + return equipmentInspectionDef; + } + + /** + * 加载提醒用户的ID + * @param equipmentInspectionDefIdList + * @return + */ + private Map loadRemindUserIDMap(List equipmentInspectionDefIdList) { + Map remindUserNameMap = new HashMap(); + if(CollectionUtils.isEmpty(equipmentInspectionDefIdList)){ + return remindUserNameMap; + } + Map> remindUserMap = loadRemindUserMap(equipmentInspectionDefIdList); + if(MapUtils.isEmpty(remindUserMap)){ + return remindUserNameMap; + } + for (Entry> entry : remindUserMap.entrySet()) { + Long defId = entry.getKey(); + List userList = entry.getValue(); + List userIDList = new ArrayList(); + if(CollectionUtils.isNotEmpty(userList)){ + for (User user : userList) { + userIDList.add(user.getId() + ""); + } + } + remindUserNameMap.put(defId, StringTools.join(userIDList, ";")); + } + return remindUserNameMap; + } + + /** + * 加载提醒用户的名称 + * @param equipmentInspectionDefIdList + * @return + */ + private Map loadRemindUserNameMap(List equipmentInspectionDefIdList) { + Map remindUserNameMap = new HashMap(); + if(CollectionUtils.isEmpty(equipmentInspectionDefIdList)){ + return remindUserNameMap; + } + Map> remindUserMap = loadRemindUserMap(equipmentInspectionDefIdList); + if(MapUtils.isEmpty(remindUserMap)){ + return remindUserNameMap; + } + for (Entry> entry : remindUserMap.entrySet()) { + Long defId = entry.getKey(); + List userList = entry.getValue(); + List userNameList = new ArrayList(); + if(CollectionUtils.isNotEmpty(userList)){ + for (User user : userList) { + userNameList.add(user.getFullName()); + } + } + remindUserNameMap.put(defId, StringTools.join(userNameList, ";")); + } + return remindUserNameMap; + } + + /** + * 加载提醒用户的ID及名称 + * @param equipmentInspectionDefIdList + * @return + */ + private Map> loadRemindUserMap(List equipmentInspectionDefIdList) { + + Map> remindUserMap = new HashMap>(); + if(CollectionUtils.isEmpty(equipmentInspectionDefIdList)){ + return remindUserMap; + } + String sql = String.format("select eu.equipmentInspectionDefId, u.id userId, u.name, u.fullName " + + "from %s eu " + + "join SS_USERS u on eu.userId = u.id " + + "where %s ", + EquipInspectionRemindUser.class.getSimpleName(), + SqlUtils.getNonStringFieldInLargeCollectionsPredicate("eu.equipmentInspectionDefId", equipmentInspectionDefIdList)); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sql); + while(rs.next()){ + Long equipmentInspectionDefId = rs.getLong("equipmentInspectionDefId"); + Long userId = rs.getLong("userId"); + String name = rs.getString("name"); + String fullName = rs.getString("fullName"); + + List userList = remindUserMap.get(equipmentInspectionDefId); + if(userList == null){ + userList = new ArrayList(); + } + User user = new User(); + user.setId(userId); + user.setName(name); + user.setFullName(fullName); + userList.add(user); + remindUserMap.put(equipmentInspectionDefId, userList); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + + return remindUserMap; + } + + @Override + public void deleteFormDefinitionById(String id) { + EquipmentInspectionDef equipmentInspectionDef = this.get(id); + if(equipmentInspectionDef != null){ + int count = objectDao.countObjectBySql(FormInstance.class.getSimpleName(), "where po.formDefinition.id = " + id); + if(count > 0){ + throw new RuntimeException(equipmentInspectionDef.getFormName() + "已登记过信息，不能删除！"); + } + objectDao.delete(equipmentInspectionDef); + //删除旧设备 + objectDao.excuteSQL("delete from " + ApplicableEquipment.class.getSimpleName() + " where EquipmentInspectionDefId = " + equipmentInspectionDef.getId()); + //删除提醒用户 + objectDao.excuteSQL(String.format("delete from %s where equipmentInspectionDefId = %s ", + EquipInspectionRemindUser.class.getSimpleName(), + equipmentInspectionDef.getId())); + } + } + + @Override + public Map> equipmentInspectionRemind() { + Map> userNameWarningEquipmentMap = loadLastDeployWarningInspectionUserNameEquipmentList(); + if(MapUtils.isNotEmpty(userNameWarningEquipmentMap)){ + Map> newUserNameWarningEquipmentMap = new HashMap>(); + for (Entry> entry : userNameWarningEquipmentMap.entrySet()) { + String key = entry.getKey(); + List equipmentList = entry.getValue(); + if(CollectionUtils.isNotEmpty(equipmentList)){ + List newRemindMessageList = new ArrayList(); + for (String warningEquipment : equipmentList) { + newRemindMessageList.add(String.format("设备“%s”需要进行设备巡检登记，请进行登记操作", warningEquipment)); + } + newUserNameWarningEquipmentMap.put(key, newRemindMessageList); + } + } + return newUserNameWarningEquipmentMap; + } + return userNameWarningEquipmentMap; + } + + /** + * 加载需要提醒的设备巡检定义 + * @return + */ + @SuppressWarnings("unchecked") + private Map> loadLastDeployWarningInspectionUserNameEquipmentList() { + + String sql = String.format("where po.id in (%s)", + formDefinitionManager.getDepartCanUseFormDefinition(EquipmentInspectionDef.FOMRTYPE_EQUIPMENTINSPECTION, true)); + sql += " and (po.isDisabled is null or po.isDisabled = '' or po.isDisabled = '" + Constants.STR_NO + "')"; + //查询最新版本的设备巡检定义 + sql += " and po.version = (select max(version) from " + EquipmentInspectionDef.class.getSimpleName() + " where formName = po.formName and formType='" + EquipmentInspectionDef.FOMRTYPE_EQUIPMENTINSPECTION + "' and isDeploy='" + FormDefinition.ACTION_DEPLOY + "')"; + sql += " and po.equipmentInspectionRemind = '" + Constants.STR_YES + "'"; + sql += " order by po.formName "; + //查询最新版本的设备巡检定义 + List lastDeployEquipmentInspectionDefList = objectDao.findBySql(EquipmentInspectionDef.class.getSimpleName(), sql); + if(CollectionUtils.isEmpty(lastDeployEquipmentInspectionDefList)){ + return null; + } + Map> defEquipmentMap = new HashMap>(); + Date nowDateTime = new Date(); + String nowDateStr = DateTools.getFormatDateStr(nowDateTime, DateTools.COMMON_DATE_ONLY); + List allWarnEquipment = new ArrayList(); + for (EquipmentInspectionDef def : lastDeployEquipmentInspectionDefList) { + + //上次提醒时间距离当前时间不超过间隔时长(分) + Integer remindDuration = def.getRemindDuration(); + if(remindDuration == null){ + continue; + } + Date lastRemindDate = def.getLastRemindDate(); + if(lastRemindDate != null){ + lastRemindDate = DateTools.coverStrToDate(DateTools.getFormatDateStr(lastRemindDate, DateTools.COMMON_DATE_HM), DateTools.COMMON_DATE_HM); + Date willRemindDate = DateTools.addMinutes(lastRemindDate, remindDuration); + if(nowDateTime.before(willRemindDate)){ + //上次提醒时间距离当前时间不超过间隔时长(分) + continue; + } + } + + //提醒用户包含当前登录用户 + /*if(StringUtils.equals(def.getRemindAllUsers(), Constants.STR_NO)){ + String userSql = String.format("select count(1) from %s po where po.equipmentInspectionDefId = %s and po.userId = %s", + EquipInspectionRemindUser.class.getSimpleName(), + def.getId(), + loginUser.getId()); + if(objectDao.countBySql(userSql) == 0){ + continue; + } + }*/ + + if(StringUtils.equals(def.getRemindMode(), EquipmentInspectionDef.REMIND_MODE_FIXED_TIME_EVERY_DAY)){ + //提醒模式为“每天固定时间提醒”时，判断当前时间是否在提醒时间范围内； + String remindStartTimeHM = def.getRemindStartTime(); + String remindEndTimeHM = def.getRemindEndTime(); + if(StringUtils.isBlank(remindStartTimeHM) + || StringUtils.isBlank(remindEndTimeHM)){ + continue; + } + Date remindStartTime = DateTools.coverStrToDate(nowDateStr + " " + remindStartTimeHM, DateTools.COMMON_DATE_HM); + Date remindEndTime = DateTools.coverStrToDate(nowDateStr + " " + remindEndTimeHM, DateTools.COMMON_DATE_HM); + if(nowDateTime.after(remindEndTime) || nowDateTime.before(remindStartTime)){ + continue; + } + List allDefEquipment = getEquipmentInspectionDefAllEquipment(def); + if(CollectionUtils.isEmpty(allDefEquipment)){ + continue; + } + allWarnEquipment.addAll(allDefEquipment); + defEquipmentMap.put(def, allDefEquipment); + }else if(StringUtils.equals(def.getRemindMode(), EquipmentInspectionDef.REMIND_MODE_DEVICE_RUNNING)){ + //提醒模式为“设备运行时提醒”时，根据设备类型的运行状态判断是否提醒； + List runningEquipment = getEquipmentInspectionDefRuningEquipment(def); + if(CollectionUtils.isEmpty(runningEquipment)){ + continue; + } + allWarnEquipment.addAll(runningEquipment); + defEquipmentMap.put(def, runningEquipment); + }else{ + throw new SystemException("提醒模式异常！"); + } + + //更新最后一次的提醒时间 + def.setLastRemindDate(nowDateTime); + objectDao.saveOrUpdate(def); + } + + Map> userNameWarningEquipmentMap = returnUserNameWarningEquipmentMap(defEquipmentMap); + return userNameWarningEquipmentMap; + } + + /** + * 返回用户的提示设备名称，例如：{"用户工号":["1号清洗机","2号清洗机","1号灭菌炉"]} + * @param defEquipmentMap + * @return + */ + private Map> returnUserNameWarningEquipmentMap(Map> defEquipmentMap) { + Map> userNameWarningEquipmentMap = new HashMap>(); + if(MapUtils.isEmpty(defEquipmentMap)){ + return userNameWarningEquipmentMap; + } + List equipmentInspectionDefIdList = new ArrayList(); + for (Entry> entry : defEquipmentMap.entrySet()) { + EquipmentInspectionDef def = entry.getKey(); + if(def == null){ + continue; + } + if(StringUtils.equals(def.getRemindAllUsers(), Constants.STR_YES)){ + continue; + } + equipmentInspectionDefIdList.add(def.getId()); + } + Map> remindUserMap = this.loadRemindUserMap(equipmentInspectionDefIdList ); + for (Entry> entry : defEquipmentMap.entrySet()) { + EquipmentInspectionDef def = entry.getKey(); + List equipmentList = entry.getValue(); + if(def == null || CollectionUtils.isEmpty(equipmentList)){ + continue; + } + if(StringUtils.equals(def.getRemindAllUsers(), Constants.STR_YES)){ + userNameWarningEquipmentMap.put("全部", equipmentList); + continue; + } + List userList = remindUserMap.get(def.getId()); + if(CollectionUtils.isEmpty(userList)){ + continue; + } + for (String equipment : equipmentList) { + for (User user : userList) { + List messages = userNameWarningEquipmentMap.get(user.getName()); + if(messages == null){ + messages = new ArrayList(); + } + messages.add(equipment); + userNameWarningEquipmentMap.put(user.getName(), messages); + } + } + } + return userNameWarningEquipmentMap; + } + + + /** + * 查询设备巡检定义的所有适用设备 + * @param def + * @return + */ + private List getEquipmentInspectionDefAllEquipment(EquipmentInspectionDef def) { + List runningEquipment = new ArrayList(); + Set rinserNames = new HashSet(); + List rinserIdList = getApplicableEquipmentId(def, ApplicableEquipment.TYPE_RINSER); + if(CollectionUtils.isNotEmpty(rinserIdList)){ + StringBuffer sqlBuffer = new StringBuffer(); + sqlBuffer.append("select r.name from "); + sqlBuffer.append(Rinser.class.getSimpleName()); + sqlBuffer.append(" r where "); + sqlBuffer.append(SqlUtils.getNonStringFieldInLargeCollectionsPredicate("r.id", rinserIdList)); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sqlBuffer.toString()); + while(rs.next()){ + String name = rs.getString("name"); + rinserNames.add(name); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + } + List sterilizerIdList = getApplicableEquipmentId(def, ApplicableEquipment.TYPE_STERILIZER); + Set sterilizerNames = new HashSet(); + if(CollectionUtils.isNotEmpty(sterilizerIdList)){ + StringBuffer sqlBuffer = new StringBuffer(); + sqlBuffer.append("select s.name from "); + sqlBuffer.append(Sterilizer.class.getSimpleName()); + sqlBuffer.append(" s where "); + sqlBuffer.append(SqlUtils.getNonStringFieldInLargeCollectionsPredicate("s.id", sterilizerIdList)); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sqlBuffer.toString()); + while(rs.next()){ + String name = rs.getString("name"); + sterilizerNames.add(name); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + } + runningEquipment.addAll(rinserNames); + runningEquipment.addAll(sterilizerNames); + return runningEquipment; + } + + /** + * 查询设备巡检定义正在运行中的适用设备 + * @param def + * @return + */ + private List getEquipmentInspectionDefRuningEquipment(EquipmentInspectionDef def) { + List runningEquipment = new ArrayList(); + List rinserIdList = getApplicableEquipmentId(def, ApplicableEquipment.TYPE_RINSER); + Set rinserNameSet = new HashSet(); + if(CollectionUtils.isNotEmpty(rinserIdList)){ + StringBuffer sqlBuffer = new StringBuffer(); + sqlBuffer.append("select r.name from "); + sqlBuffer.append(WashAndDisinfectRecord.class.getSimpleName()); + sqlBuffer.append(" po join "); + sqlBuffer.append(Rinser.class.getSimpleName()); + sqlBuffer.append(" r on r.id = po.rinserId where po.washStatus = '"); + sqlBuffer.append(WashAndDisinfectRecord.STATUS_WASHING); + sqlBuffer.append("' and "); + sqlBuffer.append(SqlUtils.getNonStringFieldInLargeCollectionsPredicate("r.id", rinserIdList)); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sqlBuffer.toString()); + while(rs.next()){ + String name = rs.getString("name"); + rinserNameSet.add(name); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + } + List sterilizerIdList = getApplicableEquipmentId(def, ApplicableEquipment.TYPE_STERILIZER); + Set sterilizerNameSet = new HashSet(); + if(CollectionUtils.isNotEmpty(sterilizerIdList)){ + StringBuffer sqlBuffer = new StringBuffer(); + sqlBuffer.append("select s.name from "); + sqlBuffer.append(SterilizationRecord.class.getSimpleName()); + sqlBuffer.append(" po join "); + sqlBuffer.append(Sterilizer.class.getSimpleName()); + sqlBuffer.append(" s on s.id = po.sterilizer_id "); + sqlBuffer.append("where po.status = '"); + sqlBuffer.append(SterilizationRecord.STERILIZATION_STATUS_BEGIN); + /*sqlBuffer.append("', '"); + sqlBuffer.append(TousseInstance.STATUS_DELAY_CONFIRM);*/ + sqlBuffer.append("' and "); + sqlBuffer.append(SqlUtils.getNonStringFieldInLargeCollectionsPredicate("s.id", sterilizerIdList)); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sqlBuffer.toString()); + while(rs.next()){ + String name = rs.getString("name"); + sterilizerNameSet.add(name); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + } + runningEquipment.addAll(rinserNameSet); + runningEquipment.addAll(sterilizerNameSet); + return runningEquipment; + } + + /** + * 查询设备巡检记录的适用设备id + * @param def 设备巡检定义 + * @param type 适用设备类型 + * @return + */ + @SuppressWarnings("unchecked") + @Override + public List getApplicableEquipmentId(EquipmentInspectionDef def, String type) { + + if(StringUtils.equals(def.getAllEquipment(), Constants.STR_YES)){ + if(StringUtils.equals(type, ApplicableEquipment.TYPE_RINSER)){ + List rinserList = rinserManager.getByProperty("useStatus", Rinser.USESTATUS_IN_USE); + if(CollectionUtils.isNotEmpty(rinserList)){ + List rinserIdList = rinserList.stream().map(r -> r.getId()).collect(Collectors.toList()); + return rinserIdList; + } + }else if(StringUtils.equals(type, ApplicableEquipment.TYPE_STERILIZER)){ + String sterilizerHql = String.format(" from %s where useStatus = '%s' ", Sterilizer.class.getSimpleName(), Sterilizer.USESTATUS_IN_USE); + List sterilizerList = objectDao.findByHql(sterilizerHql); + if(CollectionUtils.isNotEmpty(sterilizerList)){ + List sterilizerIdList = sterilizerList.stream().map(s -> s.getId()).collect(Collectors.toList()); + return sterilizerIdList; + } + }else if(StringUtils.equals(type, ApplicableEquipment.TYPE_BIOREADER)){ + boolean enableBioreaderInterface = ConfigUtils.getSystemSetConfigByNameBool("enableBioreaderInterface"); + if(enableBioreaderInterface){ + List bioreaderList = bioreaderManager.getByHql("po.isUse = 1"); + if(CollectionUtils.isNotEmpty(bioreaderList)){ + List bioreaderIdList = bioreaderList.stream().map(b -> b.getId()).collect(Collectors.toList()); + return bioreaderIdList; + } + } + return null; + }else{ + return null; + } + return null; + } + + StringBuffer hqlBuffer = new StringBuffer(); + hqlBuffer.append("select po from "); + hqlBuffer.append(ApplicableEquipment.class.getSimpleName()); + hqlBuffer.append(" po where po.equipmentInspectionDefId = "); + hqlBuffer.append(def.getId()); + hqlBuffer.append(" and po.type = '"); + hqlBuffer.append(type); + hqlBuffer.append("'"); + List list = objectDao.findByHql(hqlBuffer.toString()); + if(CollectionUtils.isEmpty(list)){ + return null; + } + List equipmentIdList = new ArrayList(); + for (ApplicableEquipment applicableEquipment : list) { + equipmentIdList.add(applicableEquipment.getEquipmentId()); + } + return equipmentIdList; + } + + @SuppressWarnings("unchecked") + @Override + public List loadEquipmentInspectionDefByEquipment(Long equipmentId, String type) { + if(!DatabaseUtil.isPoIdValid(equipmentId) || StringUtils.isBlank(type)){ + throw new SystemException("参数异常"); + } + + String hql = String.format("select po from %s po where (po.id in (select equipmentInspectionDefId from %s where equipmentId = %s and type ='%s') or po.allEquipment = '%s') " + + " and po.id in (%s) " + + " and (po.isDisabled is null or po.isDisabled = '' or po.isDisabled = '%s')" + + " and po.version = (select max(version) from %s where formName = po.formName and formType='%s' and isDeploy='%s')" + //+ " and po.equipmentInspectionRemind = '" + Constants.STR_YES + "'" + + " order by po.formName " + , EquipmentInspectionDef.class.getSimpleName() + , ApplicableEquipment.class.getSimpleName() + , equipmentId + , type + , Constants.STR_YES + , formDefinitionManager.getDepartCanUseFormDefinition(EquipmentInspectionDef.FOMRTYPE_EQUIPMENTINSPECTION, true) + , Constants.STR_NO + , EquipmentInspectionDef.class.getSimpleName() + , EquipmentInspectionDef.FOMRTYPE_EQUIPMENTINSPECTION + , FormDefinition.ACTION_DEPLOY); + return objectDao.findByHql(hql); + } + + @SuppressWarnings("unchecked") + @Override + public void disableOrEnableDefinition(String isDisabled, String ids) { + + if(StringUtils.isBlank(ids)){ + throw new SystemException("id不能为空！"); + } + if(!StringUtils.equals(isDisabled, Constants.STR_YES) + && !StringUtils.equals(isDisabled, Constants.STR_NO)){ + throw new SystemException("isDisabled参数异常！"); + } + String[] str = ids.split(";"); + for (String id : str) { + EquipmentInspectionDef formDefinition = this.get(id); + if(formDefinition != null){ + formDefinition.setIsDisabled(isDisabled); + String hql = String.format("select po from %s po where po.equipmentInspectionDefId = %s", ApplicableEquipment.class.getSimpleName(), + id); + List saveApplicableEquipmentList = objectDao.findByHql(hql ); + //适用设备验证 + if(StringUtils.equals(isDisabled, Constants.STR_NO)){ + validateApplicableEquipment(formDefinition, saveApplicableEquipmentList); + } + objectDao.saveOrUpdate(formDefinition); + } + } + } + +} Index: ssts-customform/src/main/java/com/forgon/disinfectsystem/customform/formdefinition/service/FormDefinitionManagerImpl.java =================================================================== diff -u -r35196 -r38054 --- ssts-customform/src/main/java/com/forgon/disinfectsystem/customform/formdefinition/service/FormDefinitionManagerImpl.java (.../FormDefinitionManagerImpl.java) (revision 35196) +++ ssts-customform/src/main/java/com/forgon/disinfectsystem/customform/formdefinition/service/FormDefinitionManagerImpl.java (.../FormDefinitionManagerImpl.java) (revision 38054) @@ -6,8 +6,10 @@ import java.util.Collection; import java.util.Date; import java.util.HashMap; +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; @@ -26,6 +28,7 @@ import com.forgon.disinfectsystem.entity.customform.formdefinition.FormDefinitionItemOption; import com.forgon.disinfectsystem.entity.customform.forminstance.FormInstance; import com.forgon.disinfectsystem.entity.devicemaintenance.DeviceMaintenanceCusD; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.EquipmentInspectionDef; import com.forgon.disinfectsystem.entity.qualitymonitoringmanager.qualitymonitoringconfig.QualityMonitoringDefinition; import com.forgon.disinfectsystem.entity.qualitymonitoringmanager.qualitymonitoringconfig.QualityMonitoringWarnUser; import com.forgon.exception.SystemException; @@ -315,6 +318,8 @@ definition = new QualityMonitoringDefinition(); }else if(formDefintion instanceof DeviceMaintenanceCusD){ definition = new DeviceMaintenanceCusD(); + }else if(formDefintion instanceof EquipmentInspectionDef){ + definition = new EquipmentInspectionDef(); }else{ definition = new FormDefinition(); } @@ -368,7 +373,8 @@ ReflectUtil.copyProperties(formDefinitionVo, definition, true, notToCopy); } // 复制设备维护定义属性 - if(definition instanceof DeviceMaintenanceCusD){ + if(definition instanceof DeviceMaintenanceCusD + || definition instanceof EquipmentInspectionDef){ List notToCopy = new ArrayList(); notToCopy.add("items"); notToCopy.add("id"); @@ -424,6 +430,7 @@ String isStatisticsItem = optionItem.optString("isStatisticsItem"); Integer optionOrderNumber = optionItem.optInt("orderNumber"); String valueTriggerItemNames = optionItem.optString("valueTriggerItemNames"); + String isDefaultValue = optionItem.optString("isDefaultValue", Constants.STR_NO); FormDefinitionItemOption option = null; if(DatabaseUtil.isPoIdValid(optionId) && FormDefinition.ACTION_SAVE.equals(actionType)){ option = getFormDefintionItemOption(optionId); @@ -438,6 +445,7 @@ option.setIsStatisticsItem(isStatisticsItem); option.setOrderNumber(optionOrderNumber); option.setValueTriggerItemNames(valueTriggerItemNames); + option.setIsDefaultValue(isDefaultValue); options.add(option); } if(toDeleteOptions.size() > 0){ @@ -451,6 +459,8 @@ formDefinitionItem.setName(name); formDefinitionItem.setType(type); formDefinitionItem.setRequirement(requirement); + //元素类型为“单选”，不能设置多个默认值ZSRY-60 + onlyOneDefaultValue(formDefinitionItem, options); formDefinitionItem.setOptions(options); formDefinitionItem.setOrderNumber(orderNumber); formDefinitionItem.setIsReportDisplay(isReportDisplay); @@ -474,6 +484,28 @@ } } + /** + * 元素类型为“单选”，不能设置多个默认值ZSRY-60 + * @param formDefinitionItem + * @param options + */ + private void onlyOneDefaultValue(FormDefinitionItem formDefinitionItem, List options) { + if(formDefinitionItem == null + || StringUtils.equals(formDefinitionItem.getType(), FormDefinitionItem.TYPE_CHECK) + || CollectionUtils.isEmpty(options)){ + return; + } + String isDefaultValue = Constants.STR_NO; + for (FormDefinitionItemOption option : options) { + String tempIsDefaultValue = option.getIsDefaultValue(); + if(StringUtils.equals(tempIsDefaultValue, Constants.STR_YES) + && StringUtils.equals(isDefaultValue, Constants.STR_YES)){ + throw new RuntimeException("单选类型不能设置多个默认值"); + } + isDefaultValue = tempIsDefaultValue; + } + } + private void setFormDefinitionProperty(FormDefinition formDefinition,String actionType){ formDefinition.setIsDeploy(actionType); if(!DatabaseUtil.isPoIdValid(formDefinition.getId())){ Index: ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/action/EquipmentInspectionDefAction.java =================================================================== diff -u --- ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/action/EquipmentInspectionDefAction.java (revision 0) +++ ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/action/EquipmentInspectionDefAction.java (revision 38054) @@ -0,0 +1,163 @@ +package com.forgon.disinfectsystem.equipmentinspection.definition.action; + +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import net.sf.json.JSONArray; +import net.sf.json.JSONObject; + +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang.StringUtils; +import org.apache.struts2.convention.annotation.Action; +import org.apache.struts2.convention.annotation.Namespace; +import org.apache.struts2.convention.annotation.ParentPackage; + +import com.forgon.Constants; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.EquipmentInspectionDef; +import com.forgon.disinfectsystem.equipmentinspection.definition.service.EquipmentInspectionDefManager; +import com.forgon.tools.StrutsParamUtils; +import com.forgon.tools.StrutsResponseUtils; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.json.JSONUtil; +import com.opensymphony.xwork2.ModelDriven; + +/** + * 设备巡检定义接口ZSRY-60 + */ +@ParentPackage(value = "default") +@Namespace(value = "/disinfectSystem") +@Action(value = "equipmentInspectionDefAction") +public class EquipmentInspectionDefAction implements ModelDriven { + + private EquipmentInspectionDef equipmentInspectionDef = new EquipmentInspectionDef(); + + private EquipmentInspectionDefManager equipmentInspectionDefManager; + + public void setEquipmentInspectionDefManager(EquipmentInspectionDefManager equipmentInspectionDefManager) { + this.equipmentInspectionDefManager = equipmentInspectionDefManager; + } + + @Override + public EquipmentInspectionDef getModel() { + return equipmentInspectionDef; + } + + /** + * 设备名称下拉框接口 + */ + public void loadDeviceInfo(){ + JSONObject obj = JSONUtil.buildJsonObject(false); + try { + JSONArray data = equipmentInspectionDefManager.loadDeviceInfo(); + obj = JSONUtil.buildJsonObject(true, data); + } catch (Exception e) { + obj = JSONUtil.buildJsonObject(false, "加载失败：" + e.getMessage()); + } + StrutsResponseUtils.output(obj); + } + + /** + * 保存设备巡检定义 + */ + public void saveEquipmentInspectionDef(){ + JSONObject result = JSONUtil.buildJsonObject(true, "保存成功"); + String items = StrutsParamUtils.getPraramValue("items", ""); + JSONArray params = null; + if (StringUtils.isNotBlank(items)) { + try { + params = JSONArray.fromObject(items); + } catch (Exception e) { + result = JSONUtil.buildJsonObject(false, "参数错误！"); + } + } + if (params != null) { + try { + String actionType = StrutsParamUtils.getPraramValue("actionType", ""); + equipmentInspectionDefManager.saveOrUpdateEquipmentInspectionDef(equipmentInspectionDef, params, actionType); + } catch (Exception e) { + result = JSONUtil.buildJsonObject(false, "保存失败，" + e.getMessage()); + } + } + StrutsResponseUtils.output(result); + } + + /** + * 查看设备巡检定义 + */ + public void loadEquipmentInspectionDef(){ + JSONObject result = JSONUtil.buildJsonObject(false, "加载失败"); + Long id = StrutsParamUtils.getPraramLongValue("id", null); + if(DatabaseUtil.isPoIdValid(id)){ + EquipmentInspectionDef equipmentInspectionDef = equipmentInspectionDefManager.loadEquipmentInspectionDef(id); + if(equipmentInspectionDef != null){ + Map map = new HashMap(); + map.put("success", true); + map.put("data", equipmentInspectionDef); + if(CollectionUtils.isNotEmpty(equipmentInspectionDef.getItems())){ + Collections.sort(equipmentInspectionDef.getItems()); + } + result = JSONObject.fromObject(map); + } + } + StrutsResponseUtils.output(result); + } + + /** + * 根据适用设备查找设备巡检定义 + */ + public void loadEquipmentInspectionDefByEquipment(){ + JSONObject result = JSONUtil.buildJsonObject(true); + try { + Long equipmentId = StrutsParamUtils.getPraramLongValue("equipmentId", null); + String type = StrutsParamUtils.getPraramValue("type", null); + JSONArray data = new JSONArray(); + List equipmentInspectionDefList = equipmentInspectionDefManager.loadEquipmentInspectionDefByEquipment(equipmentId, type); + if(CollectionUtils.isNotEmpty(equipmentInspectionDefList)){ + data = JSONArray.fromObject(equipmentInspectionDefList); + } + result = JSONUtil.buildJsonObject(true, data); + } catch (Exception e) { + result = JSONUtil.buildJsonObject(false, "加载失败，" + e.getMessage()); + } + StrutsResponseUtils.output(result); + } + + /** + * 删除设置巡检定义 + */ + public void deleteFormDefinition() { + //1;2;3 + String idStr = StrutsParamUtils.getPraramValue("ids", ""); + String result = JSONUtil.buildJsonObject(true, "删除成功!").toString(); + try { + if (StringUtils.isNotBlank(idStr)) { + String[] str = idStr.split(";"); + for (String id : str) { + equipmentInspectionDefManager.deleteFormDefinitionById(id); + } + } + } catch (Exception e) { + result = JSONUtil.buildJsonObject(false, e.getMessage()).toString(); + } + StrutsResponseUtils.output(result); + } + + /** + * 禁用启用 + */ + public void disableOrEnableDefinition() { + String ids = StrutsParamUtils.getPraramValue("ids", ""); + String isDisabled = StrutsParamUtils.getPraramValue("isDisabled", null); + String action = StringUtils.equals(isDisabled, Constants.STR_YES) ? "停用" : "启用"; + String result = JSONUtil.buildJsonObject(true, action + "成功!").toString(); + try { + equipmentInspectionDefManager.disableOrEnableDefinition(isDisabled,ids); + } catch (Exception e) { + result = JSONUtil.buildJsonObject(false, action + "失败，" + e.getMessage()).toString(); + } + StrutsResponseUtils.output(result); + } + +} Index: ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/service/EquipmentInspectionInstanceManagerImpl.java =================================================================== diff -u --- ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/service/EquipmentInspectionInstanceManagerImpl.java (revision 0) +++ ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/service/EquipmentInspectionInstanceManagerImpl.java (revision 38054) @@ -0,0 +1,103 @@ +package com.forgon.disinfectsystem.equipmentinspection.instance.service; + +import java.util.List; +import java.util.Map; + +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.MapUtils; +import org.apache.commons.lang3.StringUtils; + +import com.forgon.disinfectsystem.customform.forminstance.service.FormInstanceManager; +import com.forgon.disinfectsystem.entity.basedatamanager.bioreader.Bioreader; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.Rinser; +import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.ApplicableEquipment; +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.EquipmentInspectionDef; +import com.forgon.disinfectsystem.entity.equipmentinspection.instance.EquipmentInspectionInstance; +import com.forgon.disinfectsystem.equipmentinspection.definition.service.EquipmentInspectionDefManager; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.hibernate.BasePoManagerImpl; + +/** + * “设备巡检记录”ZSRY-60 + */ +public class EquipmentInspectionInstanceManagerImpl extends BasePoManagerImpl implements EquipmentInspectionInstanceManager{ + + private FormInstanceManager formInstanceManager; + + private EquipmentInspectionDefManager equipmentInspectionDefManager; + + public void setEquipmentInspectionDefManager(EquipmentInspectionDefManager equipmentInspectionDefManager) { + this.equipmentInspectionDefManager = equipmentInspectionDefManager; + } + + public void setFormInstanceManager(FormInstanceManager formInstanceManager) { + this.formInstanceManager = formInstanceManager; + } + + @Override + public void saveEquipmentInspectionInstance(EquipmentInspectionInstance equipmentInspectionInstance, Map requestParams) { + + if(equipmentInspectionInstance == null + || MapUtils.isEmpty(requestParams)){ + throw new RuntimeException("参数异常！"); + } + String equipmentID = requestParams.get("equipmentID"); + if(!DatabaseUtil.isPoIdValid(equipmentID)){ + throw new RuntimeException("设备ID不能为空！"); + } + String equipmentName = requestParams.get("equipmentName"); + if(StringUtils.isBlank(equipmentName)){ + throw new RuntimeException("设备名称不能为空！"); + } + String equipmentType = requestParams.get("equipmentType"); + if(StringUtils.isBlank(equipmentType)){ + throw new RuntimeException("设备类型不能为空！"); + } + + String dbEquipmentName = null; + if(StringUtils.equals(equipmentType, ApplicableEquipment.TYPE_RINSER)){ + Rinser rinser = (Rinser) objectDao.getById(Rinser.class.getSimpleName(), equipmentID); + if(rinser == null){ + throw new RuntimeException("不存在id为“" + equipmentID + "”的清洗机！"); + } + dbEquipmentName = rinser.getName(); + } else if (StringUtils.equals(equipmentType, ApplicableEquipment.TYPE_STERILIZER)){ + Sterilizer sterilizer = (Sterilizer) objectDao.getById(Sterilizer.class.getSimpleName(), equipmentID); + if(sterilizer == null){ + throw new RuntimeException("不存在id为“" + equipmentID + "”的灭菌炉！"); + } + dbEquipmentName = sterilizer.getName(); + } else if (StringUtils.equals(equipmentType, ApplicableEquipment.TYPE_BIOREADER)){ + Bioreader bioreader = (Bioreader) objectDao.getById(Bioreader.class.getSimpleName(), equipmentID); + if(bioreader == null){ + throw new RuntimeException("不存在id为“" + equipmentID + "”的生物阅读器！"); + } + dbEquipmentName = bioreader.getBioreaderName(); + } else { + throw new RuntimeException("设备类型为“" + equipmentType + "”无效！"); + } + if(!StringUtils.equals(equipmentName, dbEquipmentName)){ + throw new RuntimeException("设备名称异常！"); + } + + //设备巡检定义校验 + String formDefinitionId = requestParams.get("formDefinitionId"); + if(!DatabaseUtil.isPoIdValid(formDefinitionId)){ + throw new RuntimeException("设备巡检定义ID不能为空！"); + } + EquipmentInspectionDef equipmentInspectionDef = equipmentInspectionDefManager.get(formDefinitionId); + if(equipmentInspectionDef == null){ + throw new RuntimeException("设备巡检定义不存在！"); + } + List equipmentIdList = equipmentInspectionDefManager.getApplicableEquipmentId(equipmentInspectionDef, equipmentType); + if(CollectionUtils.isEmpty(equipmentIdList) + || !equipmentIdList.contains(Long.valueOf(equipmentID))){ + throw new RuntimeException(String.format("当前设备不是%s的适用设备！", equipmentInspectionDef.getFormName())); + } + + formInstanceManager.saveFormInstance(equipmentInspectionInstance, requestParams); + + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinitionItem.java =================================================================== diff -u -r33852 -r38054 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinitionItem.java (.../FormDefinitionItem.java) (revision 33852) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinitionItem.java (.../FormDefinitionItem.java) (revision 38054) @@ -198,6 +198,7 @@ obj.put("orderNumber", option.getOrderNumber()); obj.put("valueTriggerItemIds", option.getValueTriggerItemIds()); obj.put("valueTriggerItemNames", option.getValueTriggerItemNames()); + obj.put("isDefaultValue", option.getIsDefaultValue()); array.add(obj); } return array.toString(); Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/EquipmentInspectionDef.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/EquipmentInspectionDef.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/definition/EquipmentInspectionDef.java (revision 38054) @@ -0,0 +1,204 @@ +package com.forgon.disinfectsystem.entity.equipmentinspection.definition; + +import java.util.Date; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Transient; + +import org.hibernate.annotations.Cache; +import org.hibernate.annotations.CacheConcurrencyStrategy; +import org.hibernate.annotations.DynamicInsert; +import org.hibernate.annotations.DynamicUpdate; + +import com.forgon.Constants; +import com.forgon.disinfectsystem.entity.customform.formdefinition.FormDefinition; + +/** + * 设备巡检定义ZSRY-60 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +public class EquipmentInspectionDef extends FormDefinition{ + + /** + * 适用设备ID、类型(不保存到数据库) + */ + private String applicableEquipmentArray; + + /** + * 适用设备名称(不保存到数据库) + */ + private String applicableEquipmentNames; + + /** + * “全部”适用设备 + */ + private String allEquipment = Constants.STR_NO; + + /** + * 是否提醒,默认值为“否” + */ + private String equipmentInspectionRemind = Constants.STR_NO; + + /** + * 提醒模式:选项为“每天固定时间提醒”、“设备运行时提醒”；默认值为“每天固定时间提醒”； + */ + private String remindMode = REMIND_MODE_FIXED_TIME_EVERY_DAY; + + public final static String REMIND_MODE_FIXED_TIME_EVERY_DAY = "每天固定时间提醒"; + + public final static String REMIND_MODE_DEVICE_RUNNING = "设备运行时提醒"; + + /** + * 提醒所有用户 + */ + private String remindAllUsers; + + /** + * 提醒人员Id，不保存到数据库 + */ + private String remindUserIds; + + /** + * 提醒人员姓名，不保存到数据库 + */ + private String remindUserNames; + + /** + * 间隔时长(分) + */ + private Integer remindDuration; + + /** + * “提醒模式”设置为“每天固定时间提醒时”才显示，用于设置每天开始提醒的时间,格式为：18:00 + */ + private String remindStartTime; + + /** + * “提醒模式”设置为“每天固定时间提醒时”才显示，用于设置每天结束提醒的时间,格式为：18:00 + */ + private String remindEndTime; + + /** + * 备注 + */ + private String remark; + + /** + * 上次提醒时间 + */ + private Date lastRemindDate; + + public String getEquipmentInspectionRemind() { + return equipmentInspectionRemind; + } + + public void setEquipmentInspectionRemind(String equipmentInspectionRemind) { + this.equipmentInspectionRemind = equipmentInspectionRemind; + } + + public String getRemindMode() { + return remindMode; + } + + public void setRemindMode(String remindMode) { + this.remindMode = remindMode; + } + + public String getRemindAllUsers() { + return remindAllUsers; + } + + public void setRemindAllUsers(String remindAllUsers) { + this.remindAllUsers = remindAllUsers; + } + + @Transient + public String getRemindUserIds() { + return remindUserIds; + } + + public void setRemindUserIds(String remindUserIds) { + this.remindUserIds = remindUserIds; + } + + @Transient + public String getRemindUserNames() { + return remindUserNames; + } + + public void setRemindUserNames(String remindUserNames) { + this.remindUserNames = remindUserNames; + } + + public Integer getRemindDuration() { + return remindDuration; + } + + public void setRemindDuration(Integer remindDuration) { + this.remindDuration = remindDuration; + } + + public String getRemindStartTime() { + return remindStartTime; + } + + public void setRemindStartTime(String remindStartTime) { + this.remindStartTime = remindStartTime; + } + + public String getRemindEndTime() { + return remindEndTime; + } + + public void setRemindEndTime(String remindEndTime) { + this.remindEndTime = remindEndTime; + } + + @Transient + public String getApplicableEquipmentNames() { + return applicableEquipmentNames; + } + + public void setApplicableEquipmentNames(String applicableEquipmentNames) { + this.applicableEquipmentNames = applicableEquipmentNames; + } + + @Transient + public String getApplicableEquipmentArray() { + return applicableEquipmentArray; + } + + public void setApplicableEquipmentArray(String applicableEquipmentArray) { + this.applicableEquipmentArray = applicableEquipmentArray; + } + + @Column(columnDefinition=" varchar(255) default '" + Constants.STR_NO + "' not null ") + public String getAllEquipment() { + return allEquipment; + } + + public void setAllEquipment(String allEquipment) { + this.allEquipment = allEquipment; + } + + public String getRemark() { + return remark; + } + + public void setRemark(String remark) { + this.remark = remark; + } + + public Date getLastRemindDate() { + return lastRemindDate; + } + + public void setLastRemindDate(Date lastRemindDate) { + this.lastRemindDate = lastRemindDate; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/forminstance/FormInstanceItem.java =================================================================== diff -u -r23492 -r38054 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/forminstance/FormInstanceItem.java (.../FormInstanceItem.java) (revision 23492) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/forminstance/FormInstanceItem.java (.../FormInstanceItem.java) (revision 38054) @@ -108,6 +108,7 @@ obj.put("orderNumber", option.getOrderNumber()); obj.put("valueTriggerItemIds", option.getValueTriggerItemIds()); obj.put("valueTriggerItemNames", option.getValueTriggerItemNames()); + obj.put("isDefaultValue", option.getIsDefaultValue()); showAnswer += "," + obj.toString(); } } Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/instance/EquipmentInspectionInstance.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/instance/EquipmentInspectionInstance.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/equipmentinspection/instance/EquipmentInspectionInstance.java (revision 38054) @@ -0,0 +1,60 @@ +package com.forgon.disinfectsystem.entity.equipmentinspection.instance; + +import javax.persistence.Entity; + +import org.hibernate.annotations.Cache; +import org.hibernate.annotations.CacheConcurrencyStrategy; +import org.hibernate.annotations.DynamicInsert; +import org.hibernate.annotations.DynamicUpdate; + +import com.forgon.disinfectsystem.entity.customform.forminstance.FormInstance; + +/** + * “设备巡检记录”ZSRY-60 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +public class EquipmentInspectionInstance extends FormInstance{ + + /** + * 设备ID + */ + private Long equipmentID; + + /** + * 设备名称 + */ + private String equipmentName; + + /** + * 设备类型：清洗机、灭菌炉、生物阅读器 + */ + private String equipmentType; + + public Long getEquipmentID() { + return equipmentID; + } + + public void setEquipmentID(Long equipmentID) { + this.equipmentID = equipmentID; + } + + public String getEquipmentName() { + return equipmentName; + } + + public void setEquipmentName(String equipmentName) { + this.equipmentName = equipmentName; + } + + public String getEquipmentType() { + return equipmentType; + } + + public void setEquipmentType(String equipmentType) { + this.equipmentType = equipmentType; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinition.java =================================================================== diff -u -r26809 -r38054 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinition.java (.../FormDefinition.java) (revision 26809) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinition.java (.../FormDefinition.java) (revision 38054) @@ -49,6 +49,7 @@ public static final String FOMRTYPE_PERIODICMONITORING = "定期监测"; public static final String FOMRTYPE_DEVICEMAINTENANCE = "设备维护"; public static final String FOMRTYPE_SATISFACTION = "满意度调查"; + public static final String FOMRTYPE_EQUIPMENTINSPECTION = "设备巡检"; /** * 保存动作 Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinitionItemOption.java =================================================================== diff -u -r23492 -r38054 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinitionItemOption.java (.../FormDefinitionItemOption.java) (revision 23492) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/customform/formdefinition/FormDefinitionItemOption.java (.../FormDefinitionItemOption.java) (revision 38054) @@ -1,8 +1,11 @@ package com.forgon.disinfectsystem.entity.customform.formdefinition; import javax.persistence.Entity; + import org.hibernate.annotations.DynamicInsert; import org.hibernate.annotations.DynamicUpdate; + +import javax.persistence.Column; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @@ -12,6 +15,8 @@ import org.hibernate.annotations.Cache; import org.hibernate.annotations.CacheConcurrencyStrategy; +import com.forgon.Constants; + /** * 自定义表单项的配置参数 * @author WangYi @@ -49,6 +54,11 @@ * 参数值触发项names，用逗号分隔 */ private String valueTriggerItemNames; + + /** + * 是否默认值ZSRY-60 + */ + private String isDefaultValue = Constants.STR_NO; @Id @GeneratedValue(strategy = GenerationType.AUTO) @@ -104,5 +114,14 @@ public int compareTo(FormDefinitionItemOption formDefinitionItemOption) { return this.orderNumber - formDefinitionItemOption.getOrderNumber(); } + + @Column(columnDefinition=" varchar(20) default '" + Constants.STR_NO + "' not null ") + public String getIsDefaultValue() { + return isDefaultValue; + } + + public void setIsDefaultValue(String isDefaultValue) { + this.isDefaultValue = isDefaultValue; + } } Index: ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/dwr/table/EquipmentInspectionInstanceTableManger.java =================================================================== diff -u --- ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/dwr/table/EquipmentInspectionInstanceTableManger.java (revision 0) +++ ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/dwr/table/EquipmentInspectionInstanceTableManger.java (revision 38054) @@ -0,0 +1,31 @@ +package com.forgon.disinfectsystem.equipmentinspection.instance.dwr.table; + +import java.util.List; +import java.util.Map; + +import com.forgon.component.grid.GridManager; +import com.forgon.disinfectsystem.entity.equipmentinspection.instance.EquipmentInspectionInstance; +/** + * “设备巡检记录”ZSRY-60 + */ +public class EquipmentInspectionInstanceTableManger { + + private GridManager gridManager; + + public void setGridManager(GridManager gridManager) { + this.gridManager = gridManager; + } + + /** + * 设备巡检记录列表 + * @param parameterMap + * @return + */ + public String findEquipmentInspectionInstanceList(Map> parameterMap) { + String sql = "where 1=1"; + String json = gridManager.renderGrid(parameterMap, + EquipmentInspectionInstance.class.getSimpleName(), sql, new String[] {}); + return json; + } + +} Index: ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/action/EquipmentInspectionInstanceAction.java =================================================================== diff -u --- ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/action/EquipmentInspectionInstanceAction.java (revision 0) +++ ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/action/EquipmentInspectionInstanceAction.java (revision 38054) @@ -0,0 +1,113 @@ +package com.forgon.disinfectsystem.equipmentinspection.instance.action; + +import java.util.HashMap; +import java.util.Map; + +import net.sf.json.JSONObject; + +import org.apache.commons.lang.StringUtils; +import org.apache.struts2.convention.annotation.Action; +import org.apache.struts2.convention.annotation.Namespace; +import org.apache.struts2.convention.annotation.ParentPackage; + +import com.forgon.disinfectsystem.entity.equipmentinspection.instance.EquipmentInspectionInstance; +import com.forgon.disinfectsystem.equipmentinspection.instance.service.EquipmentInspectionInstanceManager; +import com.forgon.tools.StrutsParamUtils; +import com.forgon.tools.StrutsResponseUtils; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.json.JSONUtil; +import com.opensymphony.xwork2.ModelDriven; +import com.opensymphony.xwork2.Preparable; + +/** + * “设备巡检记录”ZSRY-60 + */ +@ParentPackage(value = "default") +@Namespace(value = "/disinfectSystem") +@Action(value = "equipmentInspectionInstanceAction") +public class EquipmentInspectionInstanceAction implements ModelDriven, + Preparable { + + private EquipmentInspectionInstance equipmentInspectionInstance; + + private EquipmentInspectionInstanceManager equipmentInspectionInstanceManager; + + public void setEquipmentInspectionInstance( + EquipmentInspectionInstance equipmentInspectionInstance) { + this.equipmentInspectionInstance = equipmentInspectionInstance; + } + + public void setEquipmentInspectionInstanceManager( + EquipmentInspectionInstanceManager equipmentInspectionInstanceManager) { + this.equipmentInspectionInstanceManager = equipmentInspectionInstanceManager; + } + + @Override + public void prepare() throws Exception { + String id = StrutsParamUtils.getPraramValue("id", ""); + if(DatabaseUtil.isPoIdValid(id)){ + equipmentInspectionInstance = equipmentInspectionInstanceManager.get(id); + } + if(equipmentInspectionInstance == null){ + equipmentInspectionInstance = new EquipmentInspectionInstance(); + } + } + + @Override + public EquipmentInspectionInstance getModel() { + return equipmentInspectionInstance; + } + + /** + * 保存“设备巡检记录” + */ + public void saveEquipmentInspectionInstance(){ + JSONObject result = JSONUtil.buildJsonObject(true, "保存成功"); + try { + Map map = StrutsParamUtils.getParameters(); + equipmentInspectionInstanceManager.saveEquipmentInspectionInstance(equipmentInspectionInstance, map); + result.put("id", equipmentInspectionInstance.getId()); + } catch (Exception e) { + result = JSONUtil.buildJsonObject(false, "保存失败：" + e.getMessage()); + } + StrutsResponseUtils.output(result); + } + + /** + * 删除“设备巡检记录”表单实例 + */ + public void deleteEquipmentInspectionInstance() { + String idStr = StrutsParamUtils.getPraramValue("ids", ""); + String message = JSONUtil.buildJsonObject(true, "删除成功！").toString(); + try { + if (StringUtils.isNotBlank(idStr)) { + String[] str = idStr.split(";"); + for (String id : str) { + EquipmentInspectionInstance eii = equipmentInspectionInstanceManager.get(id); + equipmentInspectionInstanceManager.delete(eii); + } + } + } catch (Exception e) { + message = JSONUtil.buildJsonObject(false, e.getMessage()).toString(); + } + StrutsResponseUtils.output(message); + } + + /** + * 加载“设备巡检记录”表单实例 + */ + public void loadEquipmentInspectionInstance() { + StrutsParamUtils.getResponse().setCharacterEncoding("UTF-8"); + String id = StrutsParamUtils.getPraramValue("id", ""); + EquipmentInspectionInstance eii = null; + if(DatabaseUtil.isPoIdValid(id)){ + eii = equipmentInspectionInstanceManager.get(id); + } + Map map = new HashMap(); + map.put("success", true); + map.put("data", eii); + JSONObject jsonObject = JSONObject.fromObject(map); + StrutsResponseUtils.output(jsonObject); + } + +} Index: ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/service/EquipmentInspectionDefManager.java =================================================================== diff -u --- ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/service/EquipmentInspectionDefManager.java (revision 0) +++ ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/definition/service/EquipmentInspectionDefManager.java (revision 38054) @@ -0,0 +1,80 @@ +package com.forgon.disinfectsystem.equipmentinspection.definition.service; + +import java.util.List; +import java.util.Map; + +import com.forgon.disinfectsystem.entity.equipmentinspection.definition.EquipmentInspectionDef; +import com.forgon.disinfectsystem.vo.ApplicableEquipmentVo; +import com.forgon.tools.hibernate.BasePoManager; + +import net.sf.json.JSONArray; + +/** + * 设备巡检定义的接口ZSRY-60 + */ +public interface EquipmentInspectionDefManager extends BasePoManager { + + /** + * 适用设备接口，查询所有状态为“在用”的清洗机、灭菌炉、生物阅读器管理(开启配置项才会查询) + * @return + */ + public JSONArray loadDeviceInfo(); + + /** + * 保存设备巡检定义 + * @param equipmentInspectionDef + * @param params + * @param actionType + */ + public void saveOrUpdateEquipmentInspectionDef(EquipmentInspectionDef equipmentInspectionDef, JSONArray params, String actionType); + + + /** + * 查询设备巡检定义的适用设备 + * @param equipmentInspectionDefIdList + * @return + */ + public Map> loadApplicableEquipment(List equipmentInspectionDefIdList); + + /** + * 查询设备巡检定义 + * @param id + * @return + */ + public EquipmentInspectionDef loadEquipmentInspectionDef(Long id); + + /** + * 删除设备巡检定义 + * @param id + */ + public void deleteFormDefinitionById(String id); + + /** + * 设备巡检提醒，返回用户的提示信息，例如：[{"用户工号":["消息1","消息2","消息3"]}] + * @return + */ + public Map> equipmentInspectionRemind(); + + /** + * 根据适用设备查找设备巡检定义 + * @param equipmentId 设备ID + * @param type 设备类型 + * @return + */ + public List loadEquipmentInspectionDefByEquipment(Long equipmentId, String type); + + /** + * 启用停用 + * @param isDisabled + * @param ids + */ + public void disableOrEnableDefinition(String isDisabled, String ids); + + /** + * 查询设备巡检记录的适用设备id + * @param def 设备巡检定义 + * @param type 适用设备类型 + * @return + */ + public List getApplicableEquipmentId(EquipmentInspectionDef def, String type); +} Index: ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml =================================================================== diff -u -r38041 -r38054 --- ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml (.../applicationContext-disinfectsystem-service.xml) (revision 38041) +++ ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml (.../applicationContext-disinfectsystem-service.xml) (revision 38054) @@ -3020,4 +3020,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file Index: ssts-web/src/main/webapp/WEB-INF/dwr.xml =================================================================== diff -u -r36204 -r38054 --- ssts-web/src/main/webapp/WEB-INF/dwr.xml (.../dwr.xml) (revision 36204) +++ ssts-web/src/main/webapp/WEB-INF/dwr.xml (.../dwr.xml) (revision 38054) @@ -252,6 +252,13 @@ + + + + + + + Index: ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/service/EquipmentInspectionInstanceManager.java =================================================================== diff -u --- ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/service/EquipmentInspectionInstanceManager.java (revision 0) +++ ssts-web/src/main/java/com/forgon/disinfectsystem/equipmentinspection/instance/service/EquipmentInspectionInstanceManager.java (revision 38054) @@ -0,0 +1,19 @@ +package com.forgon.disinfectsystem.equipmentinspection.instance.service; + +import java.util.Map; + +import com.forgon.disinfectsystem.entity.equipmentinspection.instance.EquipmentInspectionInstance; +import com.forgon.tools.hibernate.BasePoManager; +/** + * “设备巡检记录”manager接口ZSRY-60 + */ +public interface EquipmentInspectionInstanceManager extends BasePoManager { + + /** + * 保存“设备巡检记录” + * @param equipmentInspectionInstance + * @param requestParams + */ + public void saveEquipmentInspectionInstance(EquipmentInspectionInstance equipmentInspectionInstance, Map requestParams); + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/vo/ApplicableEquipmentVo.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/vo/ApplicableEquipmentVo.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/vo/ApplicableEquipmentVo.java (revision 38054) @@ -0,0 +1,83 @@ +package com.forgon.disinfectsystem.vo; + +/** + * 适用设备的vo + */ +public class ApplicableEquipmentVo { + + private Long id; + + /** + * 适用设备ID + */ + private Long equipmentId; + + /** + * 适用设备名称 + */ + private String equipmentName; + + /** + * 设备巡检定义ID + */ + private Long equipmentInspectionDefId; + + /** + * 设备类型：“清洗机”、“灭菌炉”和“生物阅读器” + */ + private String type; + + /** + * 设备运行状态 + */ + private String runingStatus; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getEquipmentId() { + return equipmentId; + } + + public void setEquipmentId(Long equipmentId) { + this.equipmentId = equipmentId; + } + + public String getEquipmentName() { + return equipmentName; + } + + public void setEquipmentName(String equipmentName) { + this.equipmentName = equipmentName; + } + + public Long getEquipmentInspectionDefId() { + return equipmentInspectionDefId; + } + + public void setEquipmentInspectionDefId(Long equipmentInspectionDefId) { + this.equipmentInspectionDefId = equipmentInspectionDefId; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public String getRuningStatus() { + return runingStatus; + } + + public void setRuningStatus(String runingStatus) { + this.runingStatus = runingStatus; + } + +}