Index: ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml =================================================================== diff -u -r37397 -r37454 --- ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml (.../applicationContext-disinfectsystem-service.xml) (revision 37397) +++ ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml (.../applicationContext-disinfectsystem-service.xml) (revision 37454) @@ -2998,4 +2998,15 @@ + + + + + + + + + \ No newline at end of file Index: ssts-wash/src/main/java/com/forgon/disinfectsystem/washanddisinfectmanager/washanddisinfectrecord/dwr/table/WashAndDisinfectRecordTableManager.java =================================================================== diff -u -r36990 -r37454 --- ssts-wash/src/main/java/com/forgon/disinfectsystem/washanddisinfectmanager/washanddisinfectrecord/dwr/table/WashAndDisinfectRecordTableManager.java (.../WashAndDisinfectRecordTableManager.java) (revision 36990) +++ ssts-wash/src/main/java/com/forgon/disinfectsystem/washanddisinfectmanager/washanddisinfectrecord/dwr/table/WashAndDisinfectRecordTableManager.java (.../WashAndDisinfectRecordTableManager.java) (revision 37454) @@ -12,6 +12,7 @@ import org.json.JSONArray; import org.json.JSONObject; +import com.forgon.Constants; import com.forgon.component.grid.GridManager; import com.forgon.databaseadapter.service.DateQueryAdapter; import com.forgon.directory.acegi.tools.AcegiHelper; @@ -24,10 +25,13 @@ import com.forgon.disinfectsystem.entity.basedatamanager.cleanmethod.CleanMethod; import com.forgon.disinfectsystem.entity.basedatamanager.cleanmethod.CleanMethodConsumptionVolume; import com.forgon.disinfectsystem.entity.basedatamanager.rinser.Rinser; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.RinserGroup; import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseDefinition; import com.forgon.disinfectsystem.entity.washanddisinfectmanager.washanddisinfectrecord.WashAndDisinfectRecord; import com.forgon.disinfectsystem.washanddisinfectmanager.washanddisinfectrecord.service.WashAndDisinfectRecordManager; +import com.forgon.tools.db.DatabaseUtil; import com.forgon.tools.string.StringTools; +import com.forgon.tools.util.ConfigUtils; /** * @author WangYi 2012-2-24 @@ -147,6 +151,21 @@ WashAndDisinfectRecord.class.getSimpleName(), tousseNameSql); } + + //增加“清洗机分组定义”功能ZJYY-135 + boolean enableRinserGroupFunction = ConfigUtils.getSystemSetConfigByNameBool("enableRinserGroupFunction"); + if(enableRinserGroupFunction){ + String rinserGroupId = sqlWhereParamMap.get("rinserGroupId"); + if(DatabaseUtil.isPoIdValid(rinserGroupId)){ + sql += String.format(" and (po.rinserId in (select id from %s where rinserGroupId = %s) or exists (select 1 from %s where id = %s and belongToAllOrgUnit = '%s'))", + Rinser.class.getSimpleName(), + rinserGroupId, + RinserGroup.class.getSimpleName(), + rinserGroupId, + Constants.STR_YES); + } + } + String result = gridManager.renderGrid(parameterMap, WashAndDisinfectRecord.class .getSimpleName(), sql, new String[] {"classifyBaskets","washAndDisinfectMaterials","washAndDisinfectPictures"}); return resultBackHandler(result); Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/service/RinserGroupManagerImpl.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/service/RinserGroupManagerImpl.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/service/RinserGroupManagerImpl.java (revision 37454) @@ -0,0 +1,321 @@ +package com.forgon.disinfectsystem.basedatamanager.rinsergroup.service; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.map.HashedMap; +import org.apache.commons.lang.StringUtils; + +import com.forgon.Constants; +import com.forgon.directory.model.OrgUnit; +import com.forgon.disinfectsystem.basedatamanager.supplyroomconfig.service.SupplyRoomConfigManager; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.Rinser; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.RinserGroup; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.RinserGroupOrgUnit; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.hibernate.BasePoManagerImpl; +import com.forgon.tools.string.StringTools; +import com.forgon.tools.util.SqlUtils; + +/** + * 清洗机分组ZJYY-135 + */ +public class RinserGroupManagerImpl extends BasePoManagerImpl implements RinserGroupManager{ + + private SupplyRoomConfigManager supplyRoomConfigManager; + + public void setSupplyRoomConfigManager(SupplyRoomConfigManager supplyRoomConfigManager) { + this.supplyRoomConfigManager = supplyRoomConfigManager; + } + + @Override + public void saveOrUpdateRinserGroup(RinserGroup rinserGroup, RinserGroup originalRinserGroup) { + //名称不能为空 + if(StringUtils.isBlank(rinserGroup.getName())){ + throw new RuntimeException("分组名称不能为空！"); + } + //名称不能重复 + String nameSql = String.format("select count(1) from %s po where po.name = '%s' ", + RinserGroup.class.getSimpleName(), + rinserGroup.getName()); + if(DatabaseUtil.isPoIdValid(rinserGroup.getId())){ + nameSql += " and po.id <> " + rinserGroup.getId(); + } + if(objectDao.countBySql(nameSql) > 0){ + throw new RuntimeException("分组名称不能重复！"); + } + + //设置顺序号 + if(!DatabaseUtil.isPoIdValid(rinserGroup.getId())){ + Long maxSequence = getMaxSequence(); + rinserGroup.setSequence(maxSequence+1); + } + if(rinserGroup.getSequence() == null){ + throw new RuntimeException("分组顺序无效！"); + } + + objectDao.saveOrUpdate(rinserGroup); + //保存或者修改所属科室 + saveOrUpdateRinserGroupOrgUnit(rinserGroup, originalRinserGroup); + + } + + /** + * 查询最大顺序号 + * @return + */ + private Long getMaxSequence() { + Long max = null; + String sql = " select max(po.sequence) seq from RinserGroup po "; + ResultSet rs = objectDao.executeSql(sql); + try { + while(rs.next()){ + max = rs.getLong("seq"); + } + } catch (SQLException e) { + e.printStackTrace(); + }finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + if(max == null){ + max = 0l; + } + return max ; + } + + /** + * 保存或者修改所属科室 + * @param rinserGroup + * @param originalRinserGroup + */ + private void saveOrUpdateRinserGroupOrgUnit(RinserGroup rinserGroup, RinserGroup originalRinserGroup) { + if(rinserGroup == null || !DatabaseUtil.isPoIdValid(rinserGroup.getId())){ + return; + } + + //删除旧的所属科室 + if(DatabaseUtil.isPoIdValid(rinserGroup.getId())){ + String deleteSql = String.format("delete from %s where rinserGroupId = %s", + RinserGroupOrgUnit.class.getSimpleName(), + rinserGroup.getId()); + objectDao.excuteSQL(deleteSql); + } + + //属于所有供应室 + if(StringUtils.equals(rinserGroup.getBelongToAllOrgUnit(), Constants.STR_YES)){ + return; + } + + //所属科室不能为空 + if(StringUtils.isBlank(rinserGroup.getBelogToOrgUnitIds())){ + throw new RuntimeException("所属科室不能为空！"); + } + + //所属科室必须是一二级供应室 + Map supplyRoomOrgUnitIDMap = new HashedMap(); + List supplyRoomOrgUnitList = supplyRoomConfigManager.getSupplyRoomOrgUnitList(); + if(CollectionUtils.isNotEmpty(supplyRoomOrgUnitList)){ + for (OrgUnit orgUnit : supplyRoomOrgUnitList) { + supplyRoomOrgUnitIDMap.put(orgUnit.getId(), orgUnit); + } + } + + String belogToOrgUnitIds = rinserGroup.getBelogToOrgUnitIds(); + Collection belogToOrgUnitIdColl = StringTools.parseToLongs(belogToOrgUnitIds, ","); + if(CollectionUtils.isEmpty(belogToOrgUnitIdColl)){ + throw new RuntimeException("所属科室不能为空！"); + } + + // 已经绑定了某个所属科室的清洗机，则不能再删除该所属科室 + if(DatabaseUtil.isPoIdValid(rinserGroup.getId()) && originalRinserGroup != null){ + String originalBelogToOrgUnitIds = originalRinserGroup.getBelogToOrgUnitIds(); + if(StringUtils.isNotBlank(originalBelogToOrgUnitIds)){ + Collection originalBelogToOrgUnitIdColl = StringTools.parseToLongs(originalBelogToOrgUnitIds, ","); + if(CollectionUtils.isNotEmpty(originalBelogToOrgUnitIdColl)){ + //被移除的所属科室ID + List removeBelogToOrgUnitIdList = new ArrayList(); + for (Long belogToOrgUnitId : originalBelogToOrgUnitIdColl) { + if(!belogToOrgUnitIdColl.contains(belogToOrgUnitId)){ + removeBelogToOrgUnitIdList.add(belogToOrgUnitId); + } + } + if(CollectionUtils.isNotEmpty(removeBelogToOrgUnitIdList)){ + //清洗机所属科室关联科室编码 + String sql = String.format("select count(*) from %s r where r.rinserGroupId = %s and r.orgUnitCoding in(select orgUnitCoding from %s where %s)", + Rinser.class.getSimpleName(), + rinserGroup.getId(), + OrgUnit.class.getSimpleName(), + SqlUtils.getStringFieldInLargeCollectionsPredicate("id", removeBelogToOrgUnitIdList)); + if(objectDao.countBySql(sql) > 0){ + throw new RuntimeException("已经绑定清洗机，不能删除所属科室！"); + } + } + } + } + } + for (Long belogToOrgUnitId : belogToOrgUnitIdColl) { + if(!supplyRoomOrgUnitIDMap.containsKey(belogToOrgUnitId)){ + throw new RuntimeException("所属科室无效！"); + } + RinserGroupOrgUnit rgo = new RinserGroupOrgUnit(); + rgo.setOrgUnitId(belogToOrgUnitId); + rgo.setRinserGroupId(rinserGroup.getId()); + objectDao.save(rgo); + } + + } + + @Override + public void batchDeleteRinserGroup(String ids) { + if(StringUtils.isBlank(ids)){ + return; + } + List rinserGroupList = this.getCollection(ids, ","); + if(CollectionUtils.isNotEmpty(rinserGroupList)){ + String sql = String.format("select count(*) from %s r where r.rinserGroupId in (%s)", + Rinser.class.getSimpleName(), + ids); + if(objectDao.countBySql(sql) > 0){ + throw new RuntimeException("已经绑定清洗机，不能删除！"); + } + for (RinserGroup rinserGroup : rinserGroupList) { + objectDao.delete(rinserGroup); + String deleteSql = String.format("delete from %s where rinserGroupId = %s", + RinserGroupOrgUnit.class.getSimpleName(), + rinserGroup.getId()); + objectDao.excuteSQL(deleteSql); + } + } + } + + @SuppressWarnings("unchecked") + @Override + public Map> loadRinserGroupBelogToOrgUnit(Collection rinserGroupIds) { + Map> belongToOrgUnitMap = new HashedMap>(); + if(CollectionUtils.isEmpty(rinserGroupIds)){ + return belongToOrgUnitMap; + } + List groupList = this.getCollection(rinserGroupIds); + if(CollectionUtils.isEmpty(groupList)){ + return belongToOrgUnitMap; + } + String hql = String.format("select rgo, po from %s po, %s rgo where %s and po.id = rgo.orgUnitId ", + OrgUnit.class.getSimpleName(), + RinserGroupOrgUnit.class.getSimpleName(), + SqlUtils.getNonStringFieldInLargeCollectionsPredicate("rgo.rinserGroupId", rinserGroupIds)); + List resultList = objectDao.findByHql(hql); + if(CollectionUtils.isNotEmpty(resultList)){ + for (int i=0; i belogToOrgUnitList = belongToOrgUnitMap.get(rinserGroupId); + if(belogToOrgUnitList == null){ + belogToOrgUnitList = new ArrayList(); + } + belogToOrgUnitList.add(orgUnit); + belongToOrgUnitMap.put(rinserGroupId, belogToOrgUnitList); + } + } + if(belongToOrgUnitMap.size() == rinserGroupIds.size()){ + return belongToOrgUnitMap; + } + //没有所属科室，可能所属科室为全部 + List supplyRoomOrgUnitList = supplyRoomConfigManager.getSupplyRoomOrgUnitList(); + if(CollectionUtils.isNotEmpty(supplyRoomOrgUnitList)){ + for (RinserGroup group : groupList) { + List orgUnitList = belongToOrgUnitMap.get(group.getId()); + if(CollectionUtils.isEmpty(orgUnitList) + && StringUtils.equals(group.getBelongToAllOrgUnit(), Constants.STR_YES)){ + //属于全部一二级供应室 + belongToOrgUnitMap.put(group.getId(), supplyRoomOrgUnitList); + } + } + } + return belongToOrgUnitMap; + } + + @Override + public RinserGroup getByIdWithBelongToOrgUnit(String id) { + if(!DatabaseUtil.isPoIdValid(id)){ + return null; + } + RinserGroup rinserGroup = this.get(id); + if(rinserGroup != null){ + List rinserGroupIds = new ArrayList(); + rinserGroupIds.add(rinserGroup.getId()); + Map> belogToOrgUnitMap = this.loadRinserGroupBelogToOrgUnit(rinserGroupIds); + List orgUnitList = belogToOrgUnitMap.get(rinserGroup.getId()); + List belogToOrgUnitIds = new ArrayList(); + List belogToOrgUnitNames = new ArrayList(); + if(CollectionUtils.isNotEmpty(orgUnitList)){ + for (OrgUnit orgUnit : orgUnitList) { + belogToOrgUnitIds.add(orgUnit.getId()); + belogToOrgUnitNames.add(orgUnit.getName()); + } + } + rinserGroup.setBelogToOrgUnitIds(StringTools.join(belogToOrgUnitIds, ",")); + rinserGroup.setBelogToOrgUnitNames(StringTools.join(belogToOrgUnitNames, ",")); + } + return rinserGroup; + } + + @Override + public void sortRinserGroup(RinserGroup rinserGroup, String orderType) { + if(rinserGroup == null || !DatabaseUtil.isPoIdValid(rinserGroup.getId())){ + return; + } + + RinserGroup nextRinserGroup = getNextSortRinserGroup(rinserGroup, orderType); + if(nextRinserGroup == null){ + return; + } + Long tempSequence = rinserGroup.getSequence(); + rinserGroup.setSequence(nextRinserGroup.getSequence()); + nextRinserGroup.setSequence(tempSequence); + + objectDao.saveOrUpdate(nextRinserGroup); + objectDao.saveOrUpdate(rinserGroup); + } + + @SuppressWarnings("unchecked") + private RinserGroup getNextSortRinserGroup(RinserGroup rinserGroup, String orderType) { + if (rinserGroup == null || !DatabaseUtil.isPoIdValid(rinserGroup.getId())) { + return null; + } + + if (!(orderType.equalsIgnoreCase("up") || orderType + .equalsIgnoreCase("down"))) { + return null; + } + + String sql = "Where 1=1 "; + + String orderField = " sequence DESC"; + if (orderType.equalsIgnoreCase("up")) + sql += "and (po.sequence < " + + rinserGroup.getSequence() + ")"; + else { + sql += "and (po.sequence > " + + rinserGroup.getSequence() + ")"; + orderField = " sequence asc"; + } + List list = objectDao.findBySql(RinserGroup.class.getSimpleName(), sql, 0, 1, orderField); + + if (list == null || list.size() == 0) { + return null; + } + return list.get(0); + } + + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/Rinser.java =================================================================== diff -u -r35560 -r37454 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/Rinser.java (.../Rinser.java) (revision 35560) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/Rinser.java (.../Rinser.java) (revision 37454) @@ -47,7 +47,8 @@ @Entity @DynamicInsert(false) @DynamicUpdate(true) -@Table(name = "Rinser",indexes={@Index(columnList="container_id",name="rinser_ctid_index")}) +@Table(name = "Rinser",indexes={@Index(columnList="container_id",name="rinser_ctid_index") +, @Index(columnList="rinserGroupId",name="rinser_rgid_index")}) @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) public class Rinser extends BarcodeDevice { @@ -167,6 +168,11 @@ */ private String isPackingAfterWashTimeEnd = Constants.STR_NO; + /** + * 清洗机分组ID + */ + private Long rinserGroupId; + public String getUseStatus() { return useStatus; } @@ -483,5 +489,13 @@ public void setIsPackingAfterWashTimeEnd(String isPackingAfterWashTimeEnd) { this.isPackingAfterWashTimeEnd = isPackingAfterWashTimeEnd; } + + public Long getRinserGroupId() { + return rinserGroupId; + } + + public void setRinserGroupId(Long rinserGroupId) { + this.rinserGroupId = rinserGroupId; + } } Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/RinserGroup.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/RinserGroup.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/RinserGroup.java (revision 37454) @@ -0,0 +1,107 @@ +package com.forgon.disinfectsystem.entity.basedatamanager.rinser; + +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +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; + +/** + * 清洗机分组ZJYY-135 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +public class RinserGroup { + + /** + * ID + */ + private Long id; + + /** + * 清洗机分组名称 + */ + private String name; + + /** + * 序号 + */ + public Long sequence; + + /** + * 所属科室为全部 + */ + public String belongToAllOrgUnit = Constants.STR_NO; + + /** + * 所属科室ID，不保存到数据库，如果所属科室为全部，则返回所有一二级供应室的科室ID + */ + private String belogToOrgUnitIds; + + /** + * 所属科室名称，不保存到数据库，如果所属科室为全部，则返回所有一二级供应室的科室名称 + */ + private String belogToOrgUnitNames; + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Long getSequence() { + return sequence; + } + + public void setSequence(Long sequence) { + this.sequence = sequence; + } + + public String getBelongToAllOrgUnit() { + return belongToAllOrgUnit; + } + + public void setBelongToAllOrgUnit(String belongToAllOrgUnit) { + this.belongToAllOrgUnit = belongToAllOrgUnit; + } + + @Transient + public String getBelogToOrgUnitIds() { + return belogToOrgUnitIds; + } + + public void setBelogToOrgUnitIds(String belogToOrgUnitIds) { + this.belogToOrgUnitIds = belogToOrgUnitIds; + } + + @Transient + public String getBelogToOrgUnitNames() { + return belogToOrgUnitNames; + } + + public void setBelogToOrgUnitNames(String belogToOrgUnitNames) { + this.belogToOrgUnitNames = belogToOrgUnitNames; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/service/RinserManagerImpl.java =================================================================== diff -u -r36864 -r37454 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/service/RinserManagerImpl.java (.../RinserManagerImpl.java) (revision 36864) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/service/RinserManagerImpl.java (.../RinserManagerImpl.java) (revision 37454) @@ -4,6 +4,7 @@ import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.Map; import java.util.Set; @@ -16,20 +17,27 @@ import org.apache.commons.lang.StringUtils; import com.forgon.directory.model.BarcodeDevice; +import com.forgon.directory.model.OrgUnit; +import com.forgon.directory.service.OrgUnitManager; import com.forgon.disinfectsystem.basedatamanager.cleanmethod.service.CleanMethodManager; +import com.forgon.disinfectsystem.basedatamanager.rinsergroup.service.RinserGroupManager; import com.forgon.disinfectsystem.basedatamanager.sterilizer.service.SterilizerManager; import com.forgon.disinfectsystem.basedatamanager.supplier.service.SupplierManager; import com.forgon.disinfectsystem.entity.basedatamanager.cleanmethod.CleanMethod; import com.forgon.disinfectsystem.entity.basedatamanager.deviceinterface.DeviceInterface; import com.forgon.disinfectsystem.entity.basedatamanager.deviceinterface.JiangHanDatFileDetail; import com.forgon.disinfectsystem.entity.basedatamanager.rinser.Rinser; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.RinserGroup; import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.ConsumptiveConfig; import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.DetectionItem; import com.forgon.disinfectsystem.entity.basedatamanager.supplier.Supplier; +import com.forgon.exception.SystemException; import com.forgon.serialnumber.model.SerialNum; import com.forgon.serialnumber.service.SerialNumManager; import com.forgon.tools.db.DatabaseUtil; import com.forgon.tools.hibernate.BasePoManagerImpl; +import com.forgon.tools.string.StringTools; +import com.forgon.tools.util.ConfigUtils; /** * @author WangYi @@ -45,7 +53,19 @@ private SerialNumManager serialNumManager; private SterilizerManager sterilizerManager; + + private RinserGroupManager rinserGroupManager; + + private OrgUnitManager orgUnitManager; + public void setOrgUnitManager(OrgUnitManager orgUnitManager) { + this.orgUnitManager = orgUnitManager; + } + + public void setRinserGroupManager(RinserGroupManager rinserGroupManager) { + this.rinserGroupManager = rinserGroupManager; + } + public void setSupplierManager(SupplierManager supplierManager) { this.supplierManager = supplierManager; } @@ -241,6 +261,35 @@ } } extraInfo.add(barcode); + + //清洗机信息”新增字段“清洗机分组”ZJYY-135 + Long rinserGroupId = rinser.getRinserGroupId(); + if(DatabaseUtil.isPoIdValid(rinserGroupId)){ + //清洗机所属科室编码 + String orgUnitCode = rinser.getOrgUnitCoding(); + if(StringUtils.isBlank(orgUnitCode)){ + throw new RuntimeException("所属科室无效"); + } + OrgUnit orgUnit = orgUnitManager.getByCode(orgUnitCode); + if(orgUnit == null){ + throw new RuntimeException("所属科室无效"); + } + RinserGroup rinserGroup = rinserGroupManager.getByIdWithBelongToOrgUnit(rinserGroupId+""); + if(rinserGroup == null){ + throw new RuntimeException("清洗机分组无效"); + } + String belogToOrgUnitIdsStr = rinserGroup.getBelogToOrgUnitIds(); + if(StringUtils.isBlank(belogToOrgUnitIdsStr)){ + throw new RuntimeException("清洗机分组所属科室异常"); + } + Collection belogToOrgUnitIdList = StringTools.parseToLongs(belogToOrgUnitIdsStr, ","); + if(CollectionUtils.isEmpty(belogToOrgUnitIdList)){ + throw new RuntimeException("清洗机分组所属科室异常"); + } + if(!belogToOrgUnitIdList.contains(orgUnit.getId())){ + throw new RuntimeException("清洗机分组所属科室不包含“" + orgUnit.getName() + "”"); + } + } } } @Override @@ -278,13 +327,24 @@ } } + @SuppressWarnings("unchecked") @Override - public List getRinserByDepartCoding(String departCoding, String useStatus) { - if(StringUtils.isBlank(useStatus)){ - return this.getRinserByDepartCoding(departCoding); - } - String hql = String.format("select po from %s po where po.orgUnitCoding = '%s' and po.useStatus = '%s' order by po.sequence ", + public List getRinserByDepartCoding(String departCoding, String useStatus, Long rinserGroupId) { + String hql = String.format("select po from %s po where po.orgUnitCoding = '%s' and po.useStatus = '%s' ", Rinser.class.getSimpleName(), departCoding, useStatus); + if(StringUtils.isNotBlank(useStatus)){ + hql += String.format(" and po.useStatus = '%s' ", useStatus); + } + //只有开启了配置项才根据清洗机分组过滤 + boolean enableRinserGroupFunction = + ConfigUtils.getSystemSetConfigByNameBool("enableRinserGroupFunction"); + if(enableRinserGroupFunction){ + if(!DatabaseUtil.isPoIdValid(rinserGroupId)){ + throw new SystemException("清洗机分组不能为空！"); + } + hql += String.format(" and po.rinserGroupId = %s ", rinserGroupId); + } + hql += " order by po.sequence "; return objectDao.findByHql(hql); } } Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/RinserGroupOrgUnit.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/RinserGroupOrgUnit.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/basedatamanager/rinser/RinserGroupOrgUnit.java (revision 37454) @@ -0,0 +1,67 @@ +package com.forgon.disinfectsystem.entity.basedatamanager.rinser; + +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; + +/** + * 清洗机分组所属科室ZJYY-135 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Table(name = "RinserGroupOrgUnit",indexes={@Index(columnList="rinserGroupId",name="rg_r_id_index") +,@Index(columnList="orgUnitId",name="rg_org_id_index")}) +@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +public class RinserGroupOrgUnit { + + /** + * ID + */ + private Long id; + + /** + * 清洗机分组ID + */ + private Long rinserGroupId; + + /** + * 所属科室ID + */ + private Long orgUnitId; + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getRinserGroupId() { + return rinserGroupId; + } + + public void setRinserGroupId(Long rinserGroupId) { + this.rinserGroupId = rinserGroupId; + } + + public Long getOrgUnitId() { + return orgUnitId; + } + + public void setOrgUnitId(Long orgUnitId) { + this.orgUnitId = orgUnitId; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/supplyroomconfig/service/SupplyRoomConfigManager.java =================================================================== diff -u -r35133 -r37454 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/supplyroomconfig/service/SupplyRoomConfigManager.java (.../SupplyRoomConfigManager.java) (revision 35133) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/supplyroomconfig/service/SupplyRoomConfigManager.java (.../SupplyRoomConfigManager.java) (revision 37454) @@ -315,5 +315,11 @@ * @return */ public String getDefaultSettleAccountDepartName(String orgUnitCode); + + /** + * 查询一二级供应室的科室 + * @return + */ + public List getSupplyRoomOrgUnitList(); } Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/service/RinserGroupManager.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/service/RinserGroupManager.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/service/RinserGroupManager.java (revision 37454) @@ -0,0 +1,49 @@ +package com.forgon.disinfectsystem.basedatamanager.rinsergroup.service; + +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import com.forgon.directory.model.OrgUnit; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.RinserGroup; +import com.forgon.tools.hibernate.BasePoManager; + +/** + * 清洗机分组ZJYY-135 + */ +public interface RinserGroupManager extends BasePoManager{ + + /** + * 保存清洗机分组 + * @param rinserGroup 清洗机分组 + */ + public void saveOrUpdateRinserGroup(RinserGroup rinserGroup, RinserGroup originalRinserGroup); + + /** + * 批量删除清洗机分组 + * @param ids 清洗机分组id,例如：1,2,3 + */ + public void batchDeleteRinserGroup(String ids); + + /** + * 查询清洗机分组所属科室的名称 + * @param rinserGroupIds 清洗机分组id + * @return + */ + public Map> loadRinserGroupBelogToOrgUnit(Collection rinserGroupIds); + + /** + * 根据ID查询清洗机分组，同时查询所属科室 + * @param id + * @return + */ + public RinserGroup getByIdWithBelongToOrgUnit(String id); + + /** + * 排序 + * @param rinserGroup 清洗机分组 + * @param orderType 排序类型：up/down + */ + public void sortRinserGroup(RinserGroup rinserGroup, String orderType); + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/dwr/table/RinserTableManager.java =================================================================== diff -u -r12331 -r37454 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/dwr/table/RinserTableManager.java (.../RinserTableManager.java) (revision 12331) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/dwr/table/RinserTableManager.java (.../RinserTableManager.java) (revision 37454) @@ -1,10 +1,21 @@ package com.forgon.disinfectsystem.basedatamanager.rinser.dwr.table; +import java.util.ArrayList; import java.util.List; import java.util.Map; +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.collections4.map.HashedMap; +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.basedatamanager.rinsergroup.service.RinserGroupManager; import com.forgon.disinfectsystem.entity.basedatamanager.rinser.Rinser; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.RinserGroup; +import com.forgon.tools.util.ConfigUtils; /** * @author WangYi @@ -15,15 +26,91 @@ public class RinserTableManager { private GridManager gridManager; + + private RinserGroupManager rinserGroupManager; + public void setRinserGroupManager(RinserGroupManager rinserGroupManager) { + this.rinserGroupManager = rinserGroupManager; + } + public void setGridManager(GridManager gridManager) { this.gridManager = gridManager; } public String findRinserTableList(Map> parameterMap) { - return gridManager.renderGrid(parameterMap, + String json = gridManager.renderGrid(parameterMap, Rinser.class.getSimpleName(), "where 1=1 ", new String[] { "cleanMethods", "consumptives", "detectionItems" }); + //关联查询清洗机分组ZJYY-135 + json = searchRinserGroup(json); + return json; } + /** + * 关联查询清洗机分组ZJYY-135 + * @param json + * @return + */ + private String searchRinserGroup(String json) { + //不开启配置项不需要查询清洗机分组 + boolean enableRinserGroupFunction = + ConfigUtils.getSystemSetConfigByNameBool("enableRinserGroupFunction"); + if(!enableRinserGroupFunction){ + return json; + } + + if(StringUtils.isBlank(json)){ + return 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 rinserGroupIdList = new ArrayList(); + for (int i = 0; i < jsonArray.size(); i++) { + JSONObject obj = jsonArray.optJSONObject(i); + if (obj == null) { + continue; + } + Long rinserGroupId = obj.optLong("rinserGroupId"); + if(rinserGroupId != null){ + rinserGroupIdList.add(rinserGroupId); + } + } + if(CollectionUtils.isEmpty(rinserGroupIdList)){ + return json; + } + + List rinserGroupList = rinserGroupManager.getCollection(rinserGroupIdList); + if(CollectionUtils.isEmpty(rinserGroupList)){ + return json; + } + Map rinserGroupMap = new HashedMap(); + for (RinserGroup rinserGroup : rinserGroupList) { + rinserGroupMap.put(rinserGroup.getId(), rinserGroup); + } + + for (int i = 0; i < jsonArray.size(); i++) { + JSONObject obj = jsonArray.optJSONObject(i); + if (obj == null) { + continue; + } + Long rinserGroupId = obj.optLong("rinserGroupId"); + if(rinserGroupId != null){ + RinserGroup rinserGroup = rinserGroupMap.get(rinserGroupId); + if(rinserGroup != null){ + obj.put("rinserGroup", rinserGroup.getName()); + } + } + } + jsonObject.put("rows", jsonArray); + + return jsonObject.toString(); + } + } Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/service/RinserManager.java =================================================================== diff -u -r31472 -r37454 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/service/RinserManager.java (.../RinserManager.java) (revision 31472) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/service/RinserManager.java (.../RinserManager.java) (revision 37454) @@ -44,9 +44,10 @@ /** * 根据使用状态获取清洗机 - * @param departCoding - * @param useStatus + * @param departCoding 科室编码 + * @param useStatus 使用状态 + * @param rinserGroupId 清洗机分组ID * @return */ - public List getRinserByDepartCoding(String departCoding, String useStatus); + public List getRinserByDepartCoding(String departCoding, String useStatus, Long rinserGroupId); } Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/action/RinserGroupAction.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/action/RinserGroupAction.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinsergroup/action/RinserGroupAction.java (revision 37454) @@ -0,0 +1,206 @@ +package com.forgon.disinfectsystem.basedatamanager.rinsergroup.action; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +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.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.directory.model.OrgUnit; +import com.forgon.directory.service.OrgUnitManager; +import com.forgon.disinfectsystem.basedatamanager.rinsergroup.service.RinserGroupManager; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.RinserGroup; +import com.forgon.disinfectsystem.entity.basedatamanager.rinser.RinserGroupOrgUnit; +import com.forgon.tools.StrutsParamUtils; +import com.forgon.tools.StrutsResponseUtils; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.json.JSONUtil; +import com.forgon.tools.string.StringTools; +import com.opensymphony.xwork2.ModelDriven; +import com.opensymphony.xwork2.Preparable; + +/** + * 清洗机分组ZJYY-135 + */ +@ParentPackage(value = "default") +@Namespace(value = "/disinfectSystem/baseData") +@Action(value = "rinserGroupAction") +public class RinserGroupAction implements ModelDriven, Preparable { + + private RinserGroup rinserGroup = new RinserGroup(); + + /** + * 修改前的清洗机分组 + */ + private RinserGroup originalRinserGroup; + + private RinserGroupManager rinserGroupManager; + + private OrgUnitManager orgUnitManager; + + public void setOrgUnitManager(OrgUnitManager orgUnitManager) { + this.orgUnitManager = orgUnitManager; + } + + public void setRinserGroupManager(RinserGroupManager rinserGroupManager) { + this.rinserGroupManager = rinserGroupManager; + } + + /** + * 保存清洗机分组 + */ + public void saveRinserGroup(){ + JSONObject result = JSONUtil.buildJsonObject(true, "保存成功"); + try { + rinserGroupManager.saveOrUpdateRinserGroup(rinserGroup, originalRinserGroup); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "保存失败：" + e.getMessage()); + } + StrutsResponseUtils.output(result); + } + + /** + * 删除清洗机分组 + */ + public void deleteRinserGroup(){ + JSONObject result = JSONUtil.buildJsonObject(true, "删除成功"); + try { + String ids = StrutsParamUtils.getPraramValue("ids", null); + rinserGroupManager.batchDeleteRinserGroup(ids); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "删除失败：" + e.getMessage()); + } + StrutsResponseUtils.output(result); + } + + /** + * 根据id查看清洗机分组 + */ + public void loadRinserGroup(){ + JSONObject result = JSONUtil.buildJsonObject(true); + try { + String id = StrutsParamUtils.getPraramValue("id", ""); + if (DatabaseUtil.isPoIdValid(id)) { + rinserGroup = rinserGroupManager.getByIdWithBelongToOrgUnit(id); + result = JSONUtil.buildJsonObject(true, JSONObject.fromObject(rinserGroup)); + } + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "查询失败：" + e.getMessage()); + } + StrutsResponseUtils.output(result); + } + + /** + * 排序 + */ + public void sort(){ + JSONObject result = JSONUtil.buildJsonObject(true); + //up/down + String orderType = StrutsParamUtils.getPraramValue("orderType", null); + try { + Long id = StrutsParamUtils.getPraramLongValue("id", null); + if(DatabaseUtil.isPoIdValid(id)){ + RinserGroup rinserGroup = rinserGroupManager.get(id); + rinserGroupManager.sortRinserGroup(rinserGroup, orderType); + } + } catch (Exception e) { + result = JSONUtil.buildJsonObject(false, "操作失败：" + e.getMessage()); + } + StrutsResponseUtils.output(result); + } + + /** + * 加载清洗机分组列表 + */ + public void loadRinserGroupList(){ + JSONObject result = JSONUtil.buildJsonObject(true); + try { + String sql = " 1=1 "; + String spell = StrutsParamUtils.getPraramValue("spell", ""); + //根据科室编码获取清洗机分组 + String orgUnitCode = StrutsParamUtils.getPraramValue("orgUnitCode", ""); + if(StringUtils.isNotBlank(spell)){ + sql += " and name like '%" + spell + "%'"; + } + if(StringUtils.isNotBlank(orgUnitCode)){ + OrgUnit orgUnit = orgUnitManager.getByCode(orgUnitCode); + if(orgUnit != null){ + sql += String.format(" and (belongToAllOrgUnit = '%s' or id in (select rinserGroupId from %s where orgUnitId = %s))", + Constants.STR_YES, + RinserGroupOrgUnit.class.getSimpleName(), + orgUnit.getId()); + }else{ + sql += " and 1=0 "; + } + } + sql += " order by sequence "; + List rinserGroupList = rinserGroupManager.getByHql(sql); + if(CollectionUtils.isNotEmpty(rinserGroupList)){ + List rinserGroupIds = new ArrayList(); + for (RinserGroup group : rinserGroupList) { + rinserGroupIds.add(group.getId()); + } + Map> belogToOrgUnitMap = rinserGroupManager.loadRinserGroupBelogToOrgUnit(rinserGroupIds); + if(MapUtils.isNotEmpty(belogToOrgUnitMap)){ + for (RinserGroup group : rinserGroupList) { + List belogToOrgUnitList = belogToOrgUnitMap.get(group.getId()); + if(CollectionUtils.isNotEmpty(belogToOrgUnitList)){ + List belogToOrgUnitIds = new ArrayList(); + List belogToOrgUnitNames = new ArrayList(); + for (OrgUnit belogToOrgUnit : belogToOrgUnitList) { + belogToOrgUnitIds.add(belogToOrgUnit.getId()); + belogToOrgUnitNames.add(belogToOrgUnit.getName()); + } + group.setBelogToOrgUnitIds(StringTools.join(belogToOrgUnitIds, ",")); + group.setBelogToOrgUnitNames(StringTools.join(belogToOrgUnitNames, ",")); + } + } + } + JSONArray data = JSONArray.fromObject(rinserGroupList); + result = JSONUtil.buildJsonObject(true, data); + } + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "查询失败：" + e.getMessage()); + } + StrutsResponseUtils.output(result); + } + + @Override + public void prepare() throws Exception { + try { + String id = StrutsParamUtils.getPraramValue("id", ""); + if (DatabaseUtil.isPoIdValid(id)) { + rinserGroup = rinserGroupManager.getByIdWithBelongToOrgUnit(id); + if(rinserGroup != null){ + originalRinserGroup = new RinserGroup(); + originalRinserGroup.setBelogToOrgUnitIds(rinserGroup.getBelogToOrgUnitIds()); + originalRinserGroup.setBelogToOrgUnitNames(rinserGroup.getBelogToOrgUnitNames()); + } + } + if(rinserGroup == null) { + rinserGroup = new RinserGroup(); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Override + public RinserGroup getModel() { + return rinserGroup; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/action/RinserAction.java =================================================================== diff -u -r34065 -r37454 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/action/RinserAction.java (.../RinserAction.java) (revision 34065) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/rinser/action/RinserAction.java (.../RinserAction.java) (revision 37454) @@ -114,7 +114,7 @@ /** * 保存Sterilizer */ - public String saveRinser() { + public void saveRinser() { JSONObject outputJson = JSONUtil.buildJsonObject(true,"保存成功!"); try { if (rinser != null) { @@ -125,15 +125,15 @@ rinserManager.saveRinser(rinser, cleanMethodIDs, consumablesStr, detectionItemsStr, extraInfo); JSONUtil.addProperty(outputJson, "barcode", extraInfo.get(0)); - StrutsResponseUtils.output(outputJson); + } } catch (Exception e) { e.printStackTrace(); JSONUtil.addSuccess(outputJson, false); JSONUtil.addMessage(outputJson,e.getMessage()); StrutsResponseUtils.output(outputJson); } - return null; + StrutsResponseUtils.output(outputJson); } @SuppressWarnings("unchecked") @@ -349,22 +349,28 @@ public void getAllRinserListData(){ String departCoding = StrutsParamUtils.getPraramValue("departCoding", null); String useStatus = StrutsParamUtils.getPraramValue("useStatus", null); + //清洗机分组IDZJYY-135 + Long rinserGroupId = StrutsParamUtils.getPraramLongValue("rinserGroupId", null); if(StringUtils.isBlank(departCoding)){ departCoding = AcegiHelper.getLoginUser().getCurrentOrgUnitCode(); } - List list = rinserManager.getRinserByDepartCoding(departCoding, useStatus); StringBuffer buff = new StringBuffer("["); - if (list != null && list.size() > 0) { - for (int i = 0; i < list.size(); i++) { - Rinser rinser = list.get(i); - if(buff.length()>1){ - buff.append(","); + try { + List list = rinserManager.getRinserByDepartCoding(departCoding, useStatus, rinserGroupId); + if (list != null && list.size() > 0) { + for (int i = 0; i < list.size(); i++) { + Rinser rinser = list.get(i); + if(buff.length()>1){ + buff.append(","); + } + buff.append("['").append(rinser.getName()).append("','") + .append(rinser.getConCurrent()).append("','") + .append(rinser.getBarcode()).append("','") + .append(getCleanMethodsJsonData(rinser)).append("']"); } - buff.append("['").append(rinser.getName()).append("','") - .append(rinser.getConCurrent()).append("','") - .append(rinser.getBarcode()).append("','") - .append(getCleanMethodsJsonData(rinser)).append("']"); } + } catch (Exception e) { + e.printStackTrace(); } buff.append("]"); Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/supplyroomconfig/service/SupplyRoomConfigManagerImpl.java =================================================================== diff -u -r36512 -r37454 --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/supplyroomconfig/service/SupplyRoomConfigManagerImpl.java (.../SupplyRoomConfigManagerImpl.java) (revision 36512) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/basedatamanager/supplyroomconfig/service/SupplyRoomConfigManagerImpl.java (.../SupplyRoomConfigManagerImpl.java) (revision 37454) @@ -1138,4 +1138,15 @@ JSONObject orgJson = getApplyDepartDefaultSettleDepartJSON(orgUnitCode); return orgJson.optString("name"); } + + @Override + public List getSupplyRoomOrgUnitList() { + String hql = String.format("select po from %s po " + + " where po.orgUnitCoding in (select src.orgUnitCoding from %s src where src.supplyRoomType in (%s,%s))", + OrgUnit.class.getSimpleName(), + SupplyRoomConfig.class.getSimpleName(), + SupplyRoomConfig.SUPPLYROOM_TYPE_FIRST_SUPPLYROOM, + SupplyRoomConfig.SUPPLYROOM_TYPE_SECOND_SUPPLYROOM); + return objectDao.findByHql(hql); + } }