Index: ssts-web/src/main/webapp/disinfectsystem/scheduleExpeditedOfUseRecord/scheduleExpeditedOfUseRecordForm.js =================================================================== diff -u -r38749 -r38750 --- ssts-web/src/main/webapp/disinfectsystem/scheduleExpeditedOfUseRecord/scheduleExpeditedOfUseRecordForm.js (.../scheduleExpeditedOfUseRecordForm.js) (revision 38749) +++ ssts-web/src/main/webapp/disinfectsystem/scheduleExpeditedOfUseRecord/scheduleExpeditedOfUseRecordForm.js (.../scheduleExpeditedOfUseRecordForm.js) (revision 38750) @@ -325,7 +325,7 @@ break; } children.push({ - id: urgentInfoId || '', + urgentInfoId: urgentInfoId || '', reservationUrgentAmount: reservationUrgentAmount, urgentLevelId: urgentLevelId, sequence: k Index: ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/UrgentReservationTousseVo.java =================================================================== diff -u --- ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/UrgentReservationTousseVo.java (revision 0) +++ ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/UrgentReservationTousseVo.java (revision 38750) @@ -0,0 +1,100 @@ +package com.forgon.disinfectsystem.useRecord.urgentreservation.vo; + +import java.util.ArrayList; +import java.util.List; + +/** + * 预约加急物品VOGDSRMYY-617 + */ +public class UrgentReservationTousseVo { + + /** + * 记录id + */ + private Long id; + + /** + * 预约加急记录的id + */ + private Long useRecordUrgentReservationId; + + /** + * 器械包定义的ID + */ + private Long tousseDefinitionId; + + /** + * 器械包名称 + */ + private String tousseName; + + /** + * 备注 + */ + private String remark; + + + private boolean checked = false; + + /** + * 物品预约加急明细,加急等级、加急数量 + */ + private List children = new ArrayList(); + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getUseRecordUrgentReservationId() { + return useRecordUrgentReservationId; + } + + public void setUseRecordUrgentReservationId(Long useRecordUrgentReservationId) { + this.useRecordUrgentReservationId = useRecordUrgentReservationId; + } + + public Long getTousseDefinitionId() { + return tousseDefinitionId; + } + + public void setTousseDefinitionId(Long tousseDefinitionId) { + this.tousseDefinitionId = tousseDefinitionId; + } + + public String getTousseName() { + return tousseName; + } + + public void setTousseName(String tousseName) { + this.tousseName = tousseName; + } + + public String getRemark() { + return remark; + } + + public void setRemark(String remark) { + this.remark = remark; + } + + public List getChildren() { + return children; + } + + public void setChildren(List children) { + this.children = children; + } + + public boolean isChecked() { + return checked; + } + + public void setChecked(boolean checked) { + this.checked = checked; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/TousseReservationUrgentInfo.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/TousseReservationUrgentInfo.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/TousseReservationUrgentInfo.java (revision 38750) @@ -0,0 +1,93 @@ +package com.forgon.disinfectsystem.entity.useRecord.urgentreservation; + +import javax.persistence.Column; +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; + +/** + * 物品预约加急明细表GDSRMYY-617 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Table(indexes={@Index(columnList="urgentLevelId",name="truf_ulid_index") +,@Index(columnList="urgentTousseId",name="truf_utid_index") +}) +@Cache(usage=CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +public class TousseReservationUrgentInfo { + + private Long id; + + /** + * 加急等级ID + */ + private Long urgentLevelId; + + /** + * 预约加急数量 + */ + private Integer reservationUrgentAmount; + + /** + * 已经加急数量 + */ + private Integer urgentAmount = 0; + + /** + * 顺序号 + */ + private Integer sequence; + + @Id + @GeneratedValue(strategy=GenerationType.AUTO) + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getUrgentLevelId() { + return urgentLevelId; + } + + public void setUrgentLevelId(Long urgentLevelId) { + this.urgentLevelId = urgentLevelId; + } + + public Integer getReservationUrgentAmount() { + return reservationUrgentAmount; + } + + public void setReservationUrgentAmount(Integer reservationUrgentAmount) { + this.reservationUrgentAmount = reservationUrgentAmount; + } + + @Column(columnDefinition = "int default 0 not null ") + public Integer getUrgentAmount() { + return urgentAmount; + } + + public void setUrgentAmount(Integer urgentAmount) { + this.urgentAmount = urgentAmount; + } + + public Integer getSequence() { + return sequence; + } + + public void setSequence(Integer sequence) { + this.sequence = sequence; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/TousseReserveUrgentRecord.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/TousseReserveUrgentRecord.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/TousseReserveUrgentRecord.java (revision 38750) @@ -0,0 +1,76 @@ +package com.forgon.disinfectsystem.entity.useRecord.urgentreservation; + +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; + +/** + * 使用记录转换申请单时的预约加急记录GDSRMYY-617 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Table(indexes={@Index(columnList="urgentInfoId",name="trur_uriid_index")}) +@Cache(usage=CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +public class TousseReserveUrgentRecord { + + private Long id; + + /** + * 器械包实例ID + */ + private Long tousseInstanceId; + + /** + * 物品预约加急明细表ID + */ + private Long urgentInfoId; + + /** + * 使用记录ID + */ + private Long useRecordId; + + @Id + @GeneratedValue(strategy=GenerationType.AUTO) + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getTousseInstanceId() { + return tousseInstanceId; + } + + public void setTousseInstanceId(Long tousseInstanceId) { + this.tousseInstanceId = tousseInstanceId; + } + + public Long getUrgentInfoId() { + return urgentInfoId; + } + + public void setUrgentInfoId(Long urgentInfoId) { + this.urgentInfoId = urgentInfoId; + } + + public Long getUseRecordId() { + return useRecordId; + } + + public void setUseRecordId(Long useRecordId) { + this.useRecordId = useRecordId; + } + +} Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/UseRecordUrgentReservation.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/UseRecordUrgentReservation.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/UseRecordUrgentReservation.java (revision 38750) @@ -0,0 +1,135 @@ +package com.forgon.disinfectsystem.entity.useRecord.urgentreservation; + +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Index; +import javax.persistence.JoinColumn; +import javax.persistence.OneToMany; +import javax.persistence.Table; + +import org.hibernate.annotations.Cache; +import org.hibernate.annotations.CacheConcurrencyStrategy; +import org.hibernate.annotations.Cascade; +import org.hibernate.annotations.CascadeType; +import org.hibernate.annotations.DynamicInsert; +import org.hibernate.annotations.DynamicUpdate; + +/** + * 使用记录加急预约表GDSRMYY-617 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Table(indexes={ +@Index(columnList="reservationOrgUnitId",name="urur_ouid_index") +}) +@Cache(usage=CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +public class UseRecordUrgentReservation { + + private Long id; + + /** + * 预约科室ID + */ + private Long reservationOrgUnitId; + + /** + * 预约日期(yyyy-MM-dd) + */ + private Date reservationDate; + + /** + * 操作人ID + */ + private Long operatorId; + + /** + * 操作时间 + */ + private Date operateTime; + + /** + * 完成状态：未完成(未开始、进行中)、部分完成、已完成 + */ + private String finishStatus = FINISH_STATUS_UNFINISHED; + + public static final String FINISH_STATUS_UNFINISHED = "未完成"; + + public static final String FINISH_STATUS_PART_FINISHED = "部分完成"; + + public static final String FINISH_STATUS_FINISHED = "已完成"; + + /** + * 预约加急物品 + */ + private List urgentReservationTousseList = new ArrayList(); + + @Id + @GeneratedValue(strategy=GenerationType.AUTO) + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getReservationOrgUnitId() { + return reservationOrgUnitId; + } + + public void setReservationOrgUnitId(Long reservationOrgUnitId) { + this.reservationOrgUnitId = reservationOrgUnitId; + } + + public Date getReservationDate() { + return reservationDate; + } + + public void setReservationDate(Date reservationDate) { + this.reservationDate = reservationDate; + } + + public Long getOperatorId() { + return operatorId; + } + + public void setOperatorId(Long operatorId) { + this.operatorId = operatorId; + } + + public Date getOperateTime() { + return operateTime; + } + + public void setOperateTime(Date operateTime) { + this.operateTime = operateTime; + } + + public String getFinishStatus() { + return finishStatus; + } + + public void setFinishStatus(String finishStatus) { + this.finishStatus = finishStatus; + } + + @OneToMany(fetch = FetchType.LAZY) + @Cascade(value = { CascadeType.ALL }) + @JoinColumn(name = "reservation_id") + public List getUrgentReservationTousseList() { + return urgentReservationTousseList; + } + + public void setUrgentReservationTousseList(List urgentReservationTousseList) { + this.urgentReservationTousseList = urgentReservationTousseList; + } + +} Index: ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/service/UseRecordUrgentReservationManager.java =================================================================== diff -u --- ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/service/UseRecordUrgentReservationManager.java (revision 0) +++ ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/service/UseRecordUrgentReservationManager.java (revision 38750) @@ -0,0 +1,87 @@ +package com.forgon.disinfectsystem.useRecord.urgentreservation.service; + +import java.util.List; +import java.util.Map; + +import com.forgon.disinfectsystem.entity.useRecord.UseRecord; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.TousseReserveUrgentRecord; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.UrgentReservationTousse; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.UseRecordUrgentReservation; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.TousseReserveUrgentRecordVo; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.UrgentReservationTousseVo; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.UseRecordUrgentReservationVo; +import com.forgon.entity.PageEntity; +import com.forgon.tools.hibernate.BasePoManager; + +/** + * “预约加急管理”GDSRMYY-617 + */ +public interface UseRecordUrgentReservationManager extends BasePoManager{ + + /** + * 保存或修改“预约加急管理”记录的基本信息(不修改加急物品) + * @param vo + */ + public UseRecordUrgentReservation saveOrUpdateUseRecordUrgentReservation(UseRecordUrgentReservationVo vo); + + /** + * 保存或者修改预约加急器械包 + * @param vo + */ + public void saveUrgentReservationTousse(UrgentReservationTousseVo vo); + + /** + * 删除预约加急器械包 + * @param ids + */ + public void deleteUrgentReservationTousse(String ids); + + /** + * 加载当前登录科室今天之后的预约记录id及日期 + * @return + */ + public List loadCurrentLoginOrgUnitUrgentReservationDateAfterToday(); + + public void loadCurrentLoginOrgUnitHistoryUrgentReservation(PageEntity page); + + /** + * 查看预约加急记录明细接口 + * @param id + * @return + */ + public List loadUseRecordUrgentReservationDetail(Long id); + + /** + * 查看预约加急物品的加急记录明细接口 + * @param useRecordUrgentReservationId + * @param tousseReservationUrgentInfoId + * @return + */ + public List loadUseRecordUrgentDetail(Long useRecordUrgentReservationId, Long tousseReservationUrgentInfoId); + + /** + * 删除预约加急记录 + * @param id + */ + public void deleteUseRecordUrgentReservation(Long id); + + /** + * 使用记录录入科室对应的加急预约设置map + * @return + */ + public Map getTodayUseRecordUrgentReservationMap(List useRecordList); + + /** + * 重新计算加急预约设置的完成状态： + * @param urgentReservationTousse + * @param tousseList + */ + public void resetUseRecordUrgentReservationFinishStatus(UseRecordUrgentReservation useRecordUrgentReservation, List tousseList); + + /** + * 批量保存使用记录转换申请单时，根据加急预约设置自动加急的记录 + * @param tousseReserveUrgentRecordList + */ + public void batchSaveTousseReserveUrgentRecord(List tousseReserveUrgentRecordList); + +} Index: ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/service/UseRecordManagerImpl.java =================================================================== diff -u -r38725 -r38750 --- ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/service/UseRecordManagerImpl.java (.../UseRecordManagerImpl.java) (revision 38725) +++ ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/service/UseRecordManagerImpl.java (.../UseRecordManagerImpl.java) (revision 38750) @@ -129,6 +129,10 @@ import com.forgon.disinfectsystem.entity.useRecord.UseRecordToRecycleApplication; import com.forgon.disinfectsystem.entity.useRecord.UseRecordUploadItem; import com.forgon.disinfectsystem.entity.useRecord.UseRecordUploadRecord; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.TousseReservationUrgentInfo; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.TousseReserveUrgentRecord; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.UrgentReservationTousse; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.UseRecordUrgentReservation; import com.forgon.disinfectsystem.expensiveGoods.service.ExpensiveGoodsInstanceManager; import com.forgon.disinfectsystem.expensiveGoods.service.ExpensiveGoodsStockManager; import com.forgon.disinfectsystem.foreigntousseapplication.service.ForeignTousseApplicationManager; @@ -145,6 +149,7 @@ import com.forgon.disinfectsystem.tousseitem.service.TousseItemManager; import com.forgon.disinfectsystem.toussetransition.service.TousseTransitionPlanItemManager; import com.forgon.disinfectsystem.toussetransition.service.TousseTransitionPlanManager; +import com.forgon.disinfectsystem.useRecord.urgentreservation.service.UseRecordUrgentReservationManager; import com.forgon.disinfectsystem.useRecord.util.UseRecordUtil; import com.forgon.disinfectsystem.useRecord.vo.UseRecordPrintData; import com.forgon.disinfectsystem.useRecord.vo.UseRecordPrintItem; @@ -251,7 +256,13 @@ private FindPatientSurgicalStatusDao findPatientSurgicalStatusDao; private PackingManager packingManager; + + private UseRecordUrgentReservationManager useRecordUrgentReservationManager; + public void setUseRecordUrgentReservationManager(UseRecordUrgentReservationManager useRecordUrgentReservationManager) { + this.useRecordUrgentReservationManager = useRecordUrgentReservationManager; + } + public void setPackingManager(PackingManager packingManager) { this.packingManager = packingManager; } @@ -4368,6 +4379,7 @@ } List removeTousseNameList = new ArrayList(); for (String settleAccountDeptCode : settleAccountDeptCodeTousseMap.keySet()) { + Map> sterilizationModeToTousseNameToAmountMapLoop = new HashMap>(); Map applyTousseMap1 = settleAccountDeptCodeTousseMap.get(settleAccountDeptCode); String settleAccountDept = settleAccountDeptMap.get(settleAccountDeptCode); lowTempSterilizationModesJSONArray.stream().forEach(lowTempSterilizationMode -> { @@ -4376,14 +4388,21 @@ tousseNameToSterilingModeMap.entrySet().forEach(entry -> { String tousseName = entry.getKey(); String sterilizationMode = entry.getValue(); - if(StringUtils.equals(sterilizationMode, lowTempSterilizationModeLoop)){ + if(StringUtils.equals(sterilizationMode, lowTempSterilizationModeLoop) && applyTousseMap1.get(tousseName) != null){ Map applyTousseMapOfLowTempSterilizationMode = sterilizationModeToTousseNameToAmountMap.get(sterilizationMode); if(applyTousseMapOfLowTempSterilizationMode == null){ applyTousseMapOfLowTempSterilizationMode = new HashMap(); } applyTousseMapOfLowTempSterilizationMode.put(tousseName, applyTousseMap1.get(tousseName)); sterilizationModeToTousseNameToAmountMap.put(sterilizationMode, applyTousseMapOfLowTempSterilizationMode); + Map applyTousseMapOfLowTempSterilizationModeLoop = sterilizationModeToTousseNameToAmountMapLoop.get(sterilizationMode); + if(applyTousseMapOfLowTempSterilizationModeLoop == null){ + applyTousseMapOfLowTempSterilizationModeLoop = new HashMap(); + } + applyTousseMapOfLowTempSterilizationModeLoop.put(tousseName, applyTousseMap1.get(tousseName)); + sterilizationModeToTousseNameToAmountMapLoop.put(sterilizationMode, applyTousseMapOfLowTempSterilizationModeLoop); + applyTousseMap1.remove(tousseName); applyUrgentTousseMap.remove(tousseName); settleAccountDeptCodeTousseMap.put(settleAccountDeptCode, applyTousseMap1); @@ -4393,7 +4412,7 @@ tousseBarcodeToSterilingModeMap.entrySet().forEach(entry -> { String tousseBarcode = entry.getKey(); String sterilizationMode = entry.getValue(); - if(StringUtils.equals(sterilizationMode, lowTempSterilizationModeLoop)){ + if(StringUtils.equals(sterilizationMode, lowTempSterilizationModeLoop) && tousseBarcodeMap.get(tousseBarcode) != null){ Map tousseBarcodeToTdIdMapOfLowTempSterilizationMode = sterilizationModeToTousseBarcodeToTdIdMap.get(sterilizationMode); if(tousseBarcodeToTdIdMapOfLowTempSterilizationMode == null){ tousseBarcodeToTdIdMapOfLowTempSterilizationMode = new HashMap(); @@ -4414,7 +4433,7 @@ //灭菌方式-包名称-包实例列表的map Map>> sterilizationModeToTousseNameToTousseInstanceMap = buildSterilizationModeToTousseNameToTousseInstanceMap(tousseInstanceWillBeConvertedTousseItemList, sterilisationToSterilizationModeMap); //最后对符合配置的灭菌方式的包按配置的合并规则进行转换 - lowTempSterilizationModesTousseConvertRecyclingApplication(useRecordList,sterilizationModeToTousseNameToAmountMap,sterilizationModeToTousseBarcodeToTdIdMap, + lowTempSterilizationModesTousseConvertRecyclingApplication(useRecordList,sterilizationModeToTousseNameToAmountMapLoop,sterilizationModeToTousseBarcodeToTdIdMap, sterilizationModeToTousseNameToUrgentAmountMap,sterilizationModeToTousseNameToUrgentLevelMap, sterilizationModeToTousseNameToTousseInstanceMap, tousseNameToIsInvoiceMap,tousseNameToBelongToUseRecordListMap, lowTempMergeRegular,operationRoom, allowUseReordToApplicationMergeWhenOperationRoomIsBlank, needInvoiceForUseRecordOfDepart,departCoding, settleAccountDeptCode, settleAccountDept, departCanMerge, applicant, depart, applicationCreateDate, dpf, urgentStatus); @@ -7600,6 +7619,8 @@ SupplyRoomConfig config = supplyRoomConfigManager .getSystemParamsObj(); String returnMsg = "保存成功"; + //使用记录转换申请单时，器械包实例根据加急预约信息自动加急GDSRMYY-617 + autoUrgentTousseInstanceByUrgentReservation(ids); // 获取使用记录参数 Map useRecordsMap = checkedUseRecords(ids); String patientName = ""; @@ -7731,6 +7752,11 @@ new Thread(new Runnable() { @Override public void run() { + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } for (UseRecord useRecord : useRecordList) { useRecordPushDao.pushUseRecordAfterConvertApplication(useRecord); } @@ -7741,10 +7767,193 @@ } /** + * 根据“预约加急管理”设置，使用记录的器械包实例自动加急 + * @param useRecordList + */ + private void autoUrgentTousseInstanceByUrgentReservation(Collection ids) { + boolean enableScheduleExpeditedOfUseRecord = ConfigUtils.getSystemSetConfigByNameBool("enableScheduleExpeditedOfUseRecord"); + if(!enableScheduleExpeditedOfUseRecord){ + return; + } + List useRecordList = this.getCollection(ids); + if(CollectionUtils.isEmpty(useRecordList)){ + return; + } + //使用记录录入科室编码对应的加急预约设置的map + Map orgUnitCodeUseRecordUrgentReservationMap = useRecordUrgentReservationManager.getTodayUseRecordUrgentReservationMap(useRecordList); + if(MapUtils.isEmpty(orgUnitCodeUseRecordUrgentReservationMap)){ + return; + } + //器械包实例的预约加急等级 + Map useRecordReservationUrgentLevelMap = getUseRecordReservationUrgentLevelMap(orgUnitCodeUseRecordUrgentReservationMap); + if(MapUtils.isEmpty(useRecordReservationUrgentLevelMap)){ + return; + } + List tousseReserveUrgentRecordList = new ArrayList(); + for (UseRecord useRecord : useRecordList) { + UseRecordUrgentReservation useRecordUrgentReservation = orgUnitCodeUseRecordUrgentReservationMap.get(useRecord.getDepartCoding()); + if(useRecordUrgentReservation == null || StringUtils.equals(useRecordUrgentReservation.getFinishStatus(), UseRecordUrgentReservation.FINISH_STATUS_FINISHED)){ + continue; + } + List urgentReservationTousseList = useRecordUrgentReservation.getUrgentReservationTousseList(); + if(CollectionUtils.isEmpty(urgentReservationTousseList)){ + continue; + } + List tousseInstanceList = useRecord.getTousseInstanceList(objectDao); + if(CollectionUtils.isEmpty(tousseInstanceList)){ + continue; + } + for (TousseInstance tousseInstance : tousseInstanceList) { + TousseDefinition tousseDefinition = tousseInstance.getTousseDefinition(); + if(!tousseDefinition.isInsideTousse() + && !tousseDefinition.isDressing() + && !tousseDefinition.isDisinfection() + && !tousseDefinition.isForeignTousse()){ + continue; + } + //物品预约加急明细 + TousseReservationUrgentInfo urgentInfo = getTousseInstanceTousseReservationUrgentInfo(urgentReservationTousseList, tousseInstance); + if(urgentInfo == null){ + continue; + } + UrgentLevel reservationUrgentLevel = useRecordReservationUrgentLevelMap.get(urgentInfo.getUrgentLevelId()); + if(reservationUrgentLevel == null){ + continue; + } + //器械包实例加急 + setTousseInstanceUrgentLevelForUseRecord(tousseInstance, reservationUrgentLevel); + urgentInfo.setUrgentAmount(urgentInfo.getUrgentAmount() + 1); + objectDao.saveOrUpdate(urgentInfo); + //保存预约加急记录 + TousseReserveUrgentRecord tousseReserveUrgentRecord = new TousseReserveUrgentRecord(); + tousseReserveUrgentRecord.setTousseInstanceId(tousseInstance.getId()); + tousseReserveUrgentRecord.setUrgentInfoId(urgentInfo.getId()); + tousseReserveUrgentRecord.setUseRecordId(useRecord.getId()); + tousseReserveUrgentRecordList.add(tousseReserveUrgentRecord); + } + //重新计算加急预约设置的完成状态 + useRecordUrgentReservationManager.resetUseRecordUrgentReservationFinishStatus(useRecordUrgentReservation, urgentReservationTousseList); + } + useRecordUrgentReservationManager.batchSaveTousseReserveUrgentRecord(tousseReserveUrgentRecordList); + } + + /** + * 匹配预约加急信息 + * @param urgentReservationTousseList + * @param tousseInstance + * @return + */ + private TousseReservationUrgentInfo getTousseInstanceTousseReservationUrgentInfo(List urgentReservationTousseList, + TousseInstance tousseInstance) { + if(CollectionUtils.isEmpty(urgentReservationTousseList)){ + return null; + } + Long ancestorId = tousseInstance.getTousseDefinitionAncestorID(); + if(ancestorId == null){ + return null; + } + UrgentReservationTousse targetUrgentTousse = null; + for (UrgentReservationTousse urgentTousse : urgentReservationTousseList) { + if(StringUtils.equals(urgentTousse.getFinishStatus(), UseRecordUrgentReservation.FINISH_STATUS_FINISHED)){ + continue; + } + Long tousseDefinitionId = urgentTousse.getTousseDefinitionId(); + if(tousseDefinitionId == null){ + continue; + } + if(tousseDefinitionId.longValue() == ancestorId.longValue()){ + targetUrgentTousse = urgentTousse; + break; + } + } + if(targetUrgentTousse == null){ + return null; + } + List urgentInfos = targetUrgentTousse.getUrgentInfos(); + if(CollectionUtils.isEmpty(urgentInfos)){ + return null; + } + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + if(urgentInfo.getReservationUrgentAmount() != null + && MathTools.sub(urgentInfo.getReservationUrgentAmount(), urgentInfo.getUrgentAmount()).intValue() > 0){ + return urgentInfo; + } + } + return null; + } + + /** + * 设置加急等级 + * @param tousseInstance + * @param reservationUrgentLevel + */ + private void setTousseInstanceUrgentLevelForUseRecord(TousseInstance tousseInstance, UrgentLevel reservationUrgentLevel) { + if(StringUtils.equals(reservationUrgentLevel.getAdditionalInfo(), Constants.STR_YES)){ + throw new SystemException("加急等级“"+reservationUrgentLevel.getName()+"”需要填写加急额外信息，不支持自动加急"); + } + UrgentLevel urgentLevelForUseRecord = tousseInstance.getUrgentLevelForUseRecord(); + if(urgentLevelForUseRecord != null && + StringUtils.equals(urgentLevelForUseRecord.getAdditionalInfo(), Constants.STR_YES)){ + throw new SystemException("加急等级“"+urgentLevelForUseRecord.getName()+"”需要填写加急额外信息，不支持自动替换加急等级"); + } + tousseInstance.setUrgentLevelForUseRecord(reservationUrgentLevel); + } + + /** + * 根据“预约加急管理”设置，查询使用记录录入的器械包实例的预约加急等级 + * @param orgUnitCodeUseRecordUrgentReservationMap + * @return + */ + private Map getUseRecordReservationUrgentLevelMap(Map orgUnitCodeUseRecordUrgentReservationMap) { + Map useRecordReservationUrgentLevelMap = new HashMap(); + if(MapUtils.isEmpty(orgUnitCodeUseRecordUrgentReservationMap)){ + return useRecordReservationUrgentLevelMap; + } + Set urgentLevelIdSet = new HashSet(); + for (UseRecordUrgentReservation urgentReservation : orgUnitCodeUseRecordUrgentReservationMap.values()) { + if(StringUtils.equals(urgentReservation.getFinishStatus(), UseRecordUrgentReservation.FINISH_STATUS_FINISHED)){ + continue; + } + List urgentReservationTousseList = urgentReservation.getUrgentReservationTousseList(); + if(CollectionUtils.isEmpty(urgentReservationTousseList)){ + continue; + } + for (UrgentReservationTousse urgentTousse : urgentReservationTousseList) { + if(StringUtils.equals(urgentTousse.getFinishStatus(), UseRecordUrgentReservation.FINISH_STATUS_FINISHED)){ + continue; + } + List urgentInfos = urgentTousse.getUrgentInfos(); + if(CollectionUtils.isEmpty(urgentInfos)){ + continue; + } + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + Integer reservationUrgentAmount = urgentInfo.getReservationUrgentAmount(); + Integer urgentAmount = urgentInfo.getUrgentAmount(); + if(reservationUrgentAmount == null || reservationUrgentAmount.intValue() <= 0 + || MathTools.sub(reservationUrgentAmount, urgentAmount).intValue() <= 0){ + continue; + } + urgentLevelIdSet.add(urgentInfo.getUrgentLevelId()); + } + } + } + if(CollectionUtils.isEmpty(urgentLevelIdSet)){ + return useRecordReservationUrgentLevelMap; + } + List urgentLevelList = urgentLevelManager.getCollection(urgentLevelIdSet); + if(CollectionUtils.isEmpty(urgentLevelList)){ + return useRecordReservationUrgentLevelMap; + } + for (UrgentLevel urgentLevel : urgentLevelList) { + useRecordReservationUrgentLevelMap.put(urgentLevel.getId(), urgentLevel); + } + return useRecordReservationUrgentLevelMap; + } + + /** * 使用记录合成申请单(原中六的方法直接移植) * */ - @SuppressWarnings("unchecked") @Override public void createRecyclingApplicationByUseRecords(String userRecordIds, String applicant, String depart, String departCoding) throws Exception { Index: ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/TousseReservationUrgentInfoVo.java =================================================================== diff -u --- ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/TousseReservationUrgentInfoVo.java (revision 0) +++ ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/TousseReservationUrgentInfoVo.java (revision 38750) @@ -0,0 +1,96 @@ +package com.forgon.disinfectsystem.useRecord.urgentreservation.vo; + +/** + * 物品预约加急明细Vo GDSRMYY-617 + */ +public class TousseReservationUrgentInfoVo { + + private Long urgentInfoId; + + /** + * 加急等级ID + */ + private Long urgentLevelId; + + /** + * 加急等级名称 + */ + private String urgentLevelName; + + /** + * 预约加急数量 + */ + private Integer reservationUrgentAmount; + + /** + * 已经加急数量 + */ + private Integer urgentAmount; + + /** + * 顺序号 + */ + private Integer sequence; + + /** + * 是否叶子节点 + */ + private boolean leaf = true; + + public Long getUrgentInfoId() { + return urgentInfoId; + } + + public void setUrgentInfoId(Long urgentInfoId) { + this.urgentInfoId = urgentInfoId; + } + + public Long getUrgentLevelId() { + return urgentLevelId; + } + + public void setUrgentLevelId(Long urgentLevelId) { + this.urgentLevelId = urgentLevelId; + } + + public String getUrgentLevelName() { + return urgentLevelName; + } + + public void setUrgentLevelName(String urgentLevelName) { + this.urgentLevelName = urgentLevelName; + } + + public Integer getReservationUrgentAmount() { + return reservationUrgentAmount; + } + + public void setReservationUrgentAmount(Integer reservationUrgentAmount) { + this.reservationUrgentAmount = reservationUrgentAmount; + } + + public Integer getUrgentAmount() { + return urgentAmount; + } + + public void setUrgentAmount(Integer urgentAmount) { + this.urgentAmount = urgentAmount; + } + + public Integer getSequence() { + return sequence; + } + + public void setSequence(Integer sequence) { + this.sequence = sequence; + } + + public boolean isLeaf() { + return leaf; + } + + public void setLeaf(boolean leaf) { + this.leaf = leaf; + } + +} Index: ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/TousseReserveUrgentRecordVo.java =================================================================== diff -u --- ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/TousseReserveUrgentRecordVo.java (revision 0) +++ ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/TousseReserveUrgentRecordVo.java (revision 38750) @@ -0,0 +1,99 @@ +package com.forgon.disinfectsystem.useRecord.urgentreservation.vo; + +/** + * 预约加急物品的加急记录vo + */ +public class TousseReserveUrgentRecordVo { + + /** + * 预约加急记录的id + */ + private Long useRecordUrgentReservationId; + + /** + * 预约加急物品记录的id + */ + private Long urgentReservationTousseId; + + /** + * 加急物品名称 + */ + private String tousseName; + + /** + * 加急器械包实例条码 + */ + private String tousseInstanceBarcode; + + /** + * 使用记录ID + */ + private Long useRecordId; + + /** + * 加急等级名称 + */ + private String urgentLevelName; + + /** + * 申请单流水号 + */ + private String invoicePlanSerialNumber; + + public Long getUseRecordUrgentReservationId() { + return useRecordUrgentReservationId; + } + + public void setUseRecordUrgentReservationId(Long useRecordUrgentReservationId) { + this.useRecordUrgentReservationId = useRecordUrgentReservationId; + } + + public Long getUrgentReservationTousseId() { + return urgentReservationTousseId; + } + + public void setUrgentReservationTousseId(Long urgentReservationTousseId) { + this.urgentReservationTousseId = urgentReservationTousseId; + } + + public String getTousseName() { + return tousseName; + } + + public void setTousseName(String tousseName) { + this.tousseName = tousseName; + } + + public String getTousseInstanceBarcode() { + return tousseInstanceBarcode; + } + + public void setTousseInstanceBarcode(String tousseInstanceBarcode) { + this.tousseInstanceBarcode = tousseInstanceBarcode; + } + + public Long getUseRecordId() { + return useRecordId; + } + + public void setUseRecordId(Long useRecordId) { + this.useRecordId = useRecordId; + } + + public String getUrgentLevelName() { + return urgentLevelName; + } + + public void setUrgentLevelName(String urgentLevelName) { + this.urgentLevelName = urgentLevelName; + } + + public String getInvoicePlanSerialNumber() { + return invoicePlanSerialNumber; + } + + public void setInvoicePlanSerialNumber(String invoicePlanSerialNumber) { + this.invoicePlanSerialNumber = invoicePlanSerialNumber; + } + +} Index: ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/controller/UseRecordUrgentReservationController.java =================================================================== diff -u --- ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/controller/UseRecordUrgentReservationController.java (revision 0) +++ ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/controller/UseRecordUrgentReservationController.java (revision 38750) @@ -0,0 +1,191 @@ +package com.forgon.disinfectsystem.useRecord.urgentreservation.controller; + +import java.util.List; + +import net.sf.json.JSONArray; +import net.sf.json.JSONObject; + +import org.apache.commons.collections4.CollectionUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.UseRecordUrgentReservation; +import com.forgon.disinfectsystem.useRecord.urgentreservation.service.UseRecordUrgentReservationManager; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.TousseReserveUrgentRecordVo; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.UrgentReservationTousseVo; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.UseRecordUrgentReservationVo; +import com.forgon.entity.PageEntity; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.json.JSONUtil; + +/** + * “预约加急管理”GDSRMYY-617 + */ +@RestController +@RequestMapping(value = "/disinfectSystem/baseData/useRecord/useRecordUrgentReservationController", produces = "application/json;charset=UTF-8") +public class UseRecordUrgentReservationController { + + @Autowired + private UseRecordUrgentReservationManager useRecordUrgentReservationManager; + + /** + * 保存预约加急记录，只保存预约加急信息，不保存或者修改器械包 + * @return + */ + @RequestMapping("/saveUseRecordUrgentReservation") + public String saveUseRecordUrgentReservation(UseRecordUrgentReservationVo vo){ + JSONObject result = JSONUtil.buildJsonObject(true, "保存成功"); + try { + UseRecordUrgentReservation useRecordUrgentReservation = useRecordUrgentReservationManager.saveOrUpdateUseRecordUrgentReservation(vo); + int index = getUseRecordUrgentReservationIndex(useRecordUrgentReservation); + result.put("index", index); + result.put("id", useRecordUrgentReservation.getId()); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "保存失败：" + e.getMessage()); + } + return result.toString(); + } + + /** + * 查询当前加急预约设置在预约加急记录的日期列表中的顺序号 + * @param useRecordUrgentReservation + * @return + */ + private int getUseRecordUrgentReservationIndex(UseRecordUrgentReservation useRecordUrgentReservation) { + int index = 0; + if(useRecordUrgentReservation != null && DatabaseUtil.isPoIdValid(useRecordUrgentReservation.getId())){ + List voList = useRecordUrgentReservationManager.loadCurrentLoginOrgUnitUrgentReservationDateAfterToday(); + if(CollectionUtils.isNotEmpty(voList)){ + for (UseRecordUrgentReservationVo reservationVo : voList) { + Long voId = reservationVo.getId(); + Long recordId = useRecordUrgentReservation.getId(); + if(voId != null && recordId != null && voId.longValue() == recordId.longValue()){ + break; + } + index++; + } + } + } + return index; + } + + /** + * 保存或者修改预约加急器械包 + * @return + */ + @RequestMapping("/saveUrgentReservationTousse") + public String saveUrgentReservationTousse(@RequestBody UrgentReservationTousseVo vo){ + JSONObject result = JSONUtil.buildJsonObject(true, "保存成功"); + try { + useRecordUrgentReservationManager.saveUrgentReservationTousse(vo); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "保存失败：" + e.getMessage()); + } + return result.toString(); + } + + /** + * 删除预约加急器械包 + * @return + */ + @RequestMapping("/deleteUrgentReservationTousse") + public String deleteUrgentReservationTousse(String ids){ + JSONObject result = JSONUtil.buildJsonObject(true, "删除成功"); + try { + useRecordUrgentReservationManager.deleteUrgentReservationTousse(ids); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "删除失败：" + e.getMessage()); + } + return result.toString(); + } + + /** + * 删除预约加急记录 + * @return + */ + @RequestMapping("/deleteUseRecordUrgentReservation") + public String deleteUseRecordUrgentReservation(Long id){ + JSONObject result = JSONUtil.buildJsonObject(true, "删除成功"); + try { + useRecordUrgentReservationManager.deleteUseRecordUrgentReservation(id); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "删除失败：" + e.getMessage()); + } + return result.toString(); + } + + /** + * 加载当前登录科室，未来预约加急记录的日期列表接口 + * @return + */ + @RequestMapping("/loadCurrentLoginOrgUnitUrgentReservationDateAfterToday") + public String loadCurrentLoginOrgUnitUrgentReservationDateAfterToday(){ + JSONObject result = JSONUtil.buildJsonObject(true); + try { + List voList = useRecordUrgentReservationManager.loadCurrentLoginOrgUnitUrgentReservationDateAfterToday(); + result = JSONUtil.buildJsonObject(true, JSONArray.fromObject(voList)); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "查询失败：" + e.getMessage()); + } + return result.toString(); + } + + /** + * 分页加载当前登录科室，历史预约加急记录 + * @return + */ + @RequestMapping("/loadCurrentLoginOrgUnitHistoryUrgentReservation") + public String loadCurrentLoginOrgUnitHistoryUrgentReservation(PageEntity page){ + JSONObject result = JSONUtil.buildJsonObject(true); + try { + useRecordUrgentReservationManager.loadCurrentLoginOrgUnitHistoryUrgentReservation(page); + result = JSONUtil.buildJsonObject(true, JSONObject.fromObject(page)); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "查询失败：" + e.getMessage()); + } + return result.toString(); + } + + /** + * 查看预约加急记录明细接口 + * @return + */ + @RequestMapping("/loadUseRecordUrgentReservationDetail") + public String loadUseRecordUrgentReservationDetail(Long useRecordUrgentReservationId){ + String result = "[]"; + try { + List urgentReservationTousseVoList = useRecordUrgentReservationManager.loadUseRecordUrgentReservationDetail(useRecordUrgentReservationId); + return JSONArray.fromObject(urgentReservationTousseVoList).toString(); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "查询失败：" + e.getMessage()).toString(); + } + return result; + } + + /** + * 查看预约加急物品的加急记录明细接口 + * @return + */ + @RequestMapping("/loadUseRecordUrgentDetail") + public String loadUseRecordUrgentDetail(Long useRecordUrgentReservationId, Long tousseReservationUrgentInfoId){ + JSONObject result = JSONUtil.buildJsonObject(true); + try { + List urgentReservationTousseVoList = useRecordUrgentReservationManager.loadUseRecordUrgentDetail(useRecordUrgentReservationId, tousseReservationUrgentInfoId); + result = JSONUtil.buildJsonObject(true, JSONArray.fromObject(urgentReservationTousseVoList)); + } catch (Exception e) { + e.printStackTrace(); + result = JSONUtil.buildJsonObject(false, "查询失败：" + e.getMessage()); + } + return result.toString(); + } + +} Index: ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/service/UseRecordUrgentReservationManagerImpl.java =================================================================== diff -u --- ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/service/UseRecordUrgentReservationManagerImpl.java (revision 0) +++ ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/service/UseRecordUrgentReservationManagerImpl.java (revision 38750) @@ -0,0 +1,1268 @@ +package com.forgon.disinfectsystem.useRecord.urgentreservation.service; + +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Calendar; +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 org.apache.commons.collections.MapUtils; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.StringUtils; +import org.springframework.jdbc.core.BatchPreparedStatementSetter; +import org.springframework.jdbc.core.JdbcTemplate; + +import com.forgon.databaseadapter.service.DateQueryAdapter; +import com.forgon.directory.acegi.tools.AcegiHelper; +import com.forgon.directory.model.BarcodeDevice; +import com.forgon.directory.model.OrgUnit; +import com.forgon.directory.service.OrgUnitManager; +import com.forgon.disinfectsystem.basedatamanager.supplyroomconfig.service.SupplyRoomConfigManager; +import com.forgon.disinfectsystem.basedatamanager.urgent.service.UrgentLevelManager; +import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseDefinition; +import com.forgon.disinfectsystem.entity.invoicemanager.InvoicePlan; +import com.forgon.disinfectsystem.entity.urgent.UrgentLevel; +import com.forgon.disinfectsystem.entity.useRecord.UseRecord; +import com.forgon.disinfectsystem.entity.useRecord.UseRecordToRecycleApplication; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.TousseReservationUrgentInfo; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.TousseReserveUrgentRecord; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.UrgentReservationTousse; +import com.forgon.disinfectsystem.entity.useRecord.urgentreservation.UseRecordUrgentReservation; +import com.forgon.disinfectsystem.tousse.toussedefinition.service.TousseDefinitionManager; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.TousseReservationUrgentInfoVo; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.TousseReserveUrgentRecordVo; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.UrgentReservationTousseVo; +import com.forgon.disinfectsystem.useRecord.urgentreservation.vo.UseRecordUrgentReservationVo; +import com.forgon.disinfectsystem.vo.RecyclingApplicationVo; +import com.forgon.entity.PageEntity; +import com.forgon.exception.SystemException; +import com.forgon.log.model.Log; +import com.forgon.log.service.LogManager; +import com.forgon.security.service.UserManager; +import com.forgon.tools.MathTools; +import com.forgon.tools.date.DateTools; +import com.forgon.tools.db.DatabaseUtil; +import com.forgon.tools.db.InitDbConnection; +import com.forgon.tools.hibernate.BasePoManagerImpl; +import com.forgon.tools.string.StringTools; +import com.forgon.tools.util.SqlUtils; + +public class UseRecordUrgentReservationManagerImpl extends BasePoManagerImpl implements UseRecordUrgentReservationManager { + + private OrgUnitManager orgUnitManager; + + private DateQueryAdapter dateQueryAdapter; + + private TousseDefinitionManager tousseDefinitionManager; + + private UrgentLevelManager urgentLevelManager; + + private SupplyRoomConfigManager supplyRoomConfigManager; + + private InitDbConnection dbConnection; + + private UserManager userManager; + + private JdbcTemplate jdbcTemplate; + + private LogManager appLogManager; + + public void setAppLogManager(LogManager appLogManager) { + this.appLogManager = appLogManager; + } + + public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { + this.jdbcTemplate = jdbcTemplate; + } + + public void setUserManager(UserManager userManager) { + this.userManager = userManager; + } + + public void setDbConnection(InitDbConnection dbConnection) { + this.dbConnection = dbConnection; + } + + public void setSupplyRoomConfigManager(SupplyRoomConfigManager supplyRoomConfigManager) { + this.supplyRoomConfigManager = supplyRoomConfigManager; + } + + public void setUrgentLevelManager(UrgentLevelManager urgentLevelManager) { + this.urgentLevelManager = urgentLevelManager; + } + + public void setTousseDefinitionManager(TousseDefinitionManager tousseDefinitionManager) { + this.tousseDefinitionManager = tousseDefinitionManager; + } + + public void setDateQueryAdapter(DateQueryAdapter dateQueryAdapter) { + this.dateQueryAdapter = dateQueryAdapter; + } + + public void setOrgUnitManager(OrgUnitManager orgUnitManager) { + this.orgUnitManager = orgUnitManager; + } + + @Override + public UseRecordUrgentReservation saveOrUpdateUseRecordUrgentReservation(UseRecordUrgentReservationVo vo) { + if(vo == null){ + throw new RuntimeException("参数异常"); + } + UseRecordUrgentReservation useRecordUrgentReservation = null; + if(DatabaseUtil.isPoIdValid(vo.getId())){ + useRecordUrgentReservation = this.get(vo.getId()); + if(useRecordUrgentReservation == null){ + throw new RuntimeException(String.format("不存在id=%s的记录", vo.getId())); + } + } + if(useRecordUrgentReservation == null){ + useRecordUrgentReservation = new UseRecordUrgentReservation(); + useRecordUrgentReservation.setOperatorId(vo.getOperatorId()); + useRecordUrgentReservation.setReservationOrgUnitId(vo.getReservationOrgUnitId()); + if(!DatabaseUtil.isPoIdValid(useRecordUrgentReservation.getOperatorId())){ + //当前登录用户 + useRecordUrgentReservation.setOperatorId(AcegiHelper.getLoginUser().getUserId()); + } + if(!DatabaseUtil.isPoIdValid(useRecordUrgentReservation.getReservationOrgUnitId())){ + //当前登录科室 + OrgUnit orgUnit = orgUnitManager.getByCode(AcegiHelper.getCurrentOrgUnitCode()); + if(orgUnit != null){ + useRecordUrgentReservation.setReservationOrgUnitId(orgUnit.getId()); + } + } + } + if(StringUtils.isNotBlank(vo.getReservationDate())){ + Date reservationDate = DateTools.coverStrToDate(vo.getReservationDate(), DateTools.COMMON_DATE_ONLY); + useRecordUrgentReservation.setReservationDate(reservationDate); + } + useRecordUrgentReservation.setOperateTime(new Date()); + //校验 + validateUseRecordUrgentReservation(useRecordUrgentReservation); + this.save(useRecordUrgentReservation); + //保存日志记录：操作人：admin，操作时间：2024-9-14 09:09，预约日期：2024-9-15； + String description = String.format("操作人：%s，操作时间：%s，预约日期：%s", AcegiHelper.getLoginUserFullName(), + DateTools.getFormatDateStr(useRecordUrgentReservation.getOperateTime(), DateTools.COMMON_DATE_HM), + DateTools.getFormatDateStr(useRecordUrgentReservation.getReservationDate(), DateTools.COMMON_DATE_ONLY)); + appLogManager.saveLog(AcegiHelper.getLoginUser(), Log.MODEL_USERECORD, + "新增预约记录", description); + return useRecordUrgentReservation; + } + + /** + * 校验“预约加急管理”记录 + * @param useRecordUrgentReservation + */ + private void validateUseRecordUrgentReservation(UseRecordUrgentReservation useRecordUrgentReservation) { + if(!DatabaseUtil.isPoIdValid(useRecordUrgentReservation.getOperatorId()) + || userManager.get(useRecordUrgentReservation.getOperatorId()) == null){ + throw new RuntimeException("操作人不能为空！"); + } + if(!DatabaseUtil.isPoIdValid(useRecordUrgentReservation.getReservationOrgUnitId()) + || orgUnitManager.get(useRecordUrgentReservation.getReservationOrgUnitId()) == null){ + throw new RuntimeException("预约科室不能为空！"); + } + if(useRecordUrgentReservation.getOperateTime() == null){ + throw new RuntimeException("操作时间不能为空！"); + } + if(useRecordUrgentReservation.getReservationDate() == null){ + throw new RuntimeException("“预约日期”为必填项，请填写后再保存。"); + } + //“无法预约今日之前的日期，请修改后再操作” + if(useRecordUrgentReservation.getReservationDate().before(DateTools.startOfDate(new Date()))){ + throw new RuntimeException("无法预约今日之前的日期，请修改后再操作"); + } + //“已经存在“2024-9-6”的记录，请修改后再保存；” + String countSql = String.format("select count(1) from %s where reservationDate = %s and reservationOrgUnitId = %s ", + UseRecordUrgentReservation.class.getSimpleName(), + dateQueryAdapter.dateAdapter(useRecordUrgentReservation.getReservationDate()), + useRecordUrgentReservation.getReservationOrgUnitId()); + if(DatabaseUtil.isPoIdValid(useRecordUrgentReservation.getId())){ + countSql += " and id <> " + useRecordUrgentReservation.getId(); + } + if(objectDao.countBySql(countSql) > 0){ + throw new RuntimeException(String.format("已经存在“%s”的记录，请修改后再保存", + DateTools.getFormatDateStr(useRecordUrgentReservation.getReservationDate(), DateTools.COMMON_DATE_ONLY))); + } + } + + @Override + public void saveUrgentReservationTousse(UrgentReservationTousseVo vo) { + if(!DatabaseUtil.isPoIdValid(vo.getUseRecordUrgentReservationId())){ + throw new RuntimeException("使用记录预约加急设置id无效！"); + } + UseRecordUrgentReservation useRecordUrgentReservation = this.get(vo.getUseRecordUrgentReservationId()); + if(useRecordUrgentReservation == null){ + throw new RuntimeException("使用记录预约加急设置id无效！"); + } + Map idUrgentReservationTousseMap = new HashMap(); + Map tousseDefinitionIdUrgentReservationTousseMap = new HashMap(); + List urgentReservationTousseList = useRecordUrgentReservation.getUrgentReservationTousseList(); + if(CollectionUtils.isNotEmpty(urgentReservationTousseList)){ + for (UrgentReservationTousse urgentReservationTousse : urgentReservationTousseList) { + idUrgentReservationTousseMap.put(urgentReservationTousse.getId(), urgentReservationTousse); + tousseDefinitionIdUrgentReservationTousseMap.put(urgentReservationTousse.getTousseDefinitionId(), urgentReservationTousse); + } + } + + //判断是否修改物品 + UrgentReservationTousse urgentReservationTousse = idUrgentReservationTousseMap.get(vo.getId()); + if(urgentReservationTousse == null){ + urgentReservationTousse = buildUrgentReservationTousse(vo, tousseDefinitionIdUrgentReservationTousseMap); + urgentReservationTousse.setUseRecordUrgentReservation(useRecordUrgentReservation); + urgentReservationTousseList.add(urgentReservationTousse); + }else{ + //修改物品名称 + if(vo.getTousseDefinitionId() != null && urgentReservationTousse.getTousseDefinitionId() != null + && !vo.getTousseDefinitionId().equals(urgentReservationTousse.getTousseDefinitionId())){ + //修改了物品名称时，需要删除原来的记录，再添加新物品 + this.deleteUrgentReservationTousse(urgentReservationTousse); + urgentReservationTousse = buildUrgentReservationTousse(vo, tousseDefinitionIdUrgentReservationTousseMap); + urgentReservationTousse.setUseRecordUrgentReservation(useRecordUrgentReservation); + urgentReservationTousseList.add(urgentReservationTousse); + } + } + //设置加急信息 + setTousseReservationUrgentInfo(urgentReservationTousse, vo); + //校验 + validateUrgentReservationTousse(urgentReservationTousse); + //重新计算加急预约设置的完成状态： + resetUseRecordUrgentReservationFinishStatus(useRecordUrgentReservation, urgentReservationTousseList); + //保存使用记录加急预约记录 + this.save(useRecordUrgentReservation); + //保存日志记录：操作人：admin，操作时间：2024-9-14 09:09；物品名称1，加急数量1，加急等级1；物品名称2，加急数量2，加急等级2；... + String urgentReservationInfo = buildUrgentReservationLogInfo(urgentReservationTousse); + String description = String.format("操作人：%s，操作时间：%s，%s", AcegiHelper.getLoginUserFullName(), + DateTools.getFormatDateStr(new Date(), DateTools.COMMON_DATE_HM), + urgentReservationInfo); + appLogManager.saveLog(AcegiHelper.getLoginUser(), Log.MODEL_USERECORD, + "修改预约记录", description); + + } + + /** + * 构建加急物品的日志 + * @param urgentReservationTousse + * @return + */ + private String buildUrgentReservationLogInfo(UrgentReservationTousse urgentReservationTousse) { + //物品名称1，加急数量1，加急等级1；物品名称2，加急数量2，加急等级2；... + StringBuffer logBuffer = new StringBuffer(); + TousseDefinition tousseDefinition = tousseDefinitionManager.get(urgentReservationTousse.getTousseDefinitionId()); + if(tousseDefinition == null){ + return logBuffer.toString(); + } + Set urgentLevelIdSet = new HashSet(); + Map urgentAmountMap = new HashMap(); + List urgentInfos = urgentReservationTousse.getUrgentInfos(); + if(CollectionUtils.isEmpty(urgentInfos)){ + return logBuffer.toString(); + } + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + urgentLevelIdSet.add(urgentInfo.getUrgentLevelId()); + urgentAmountMap.put(urgentInfo.getUrgentLevelId(), urgentInfo.getReservationUrgentAmount()); + } + if(CollectionUtils.isEmpty(urgentLevelIdSet)){ + return logBuffer.toString(); + } + List urgentLevelList = urgentLevelManager.getCollection(urgentLevelIdSet); + if(CollectionUtils.isEmpty(urgentLevelList)){ + return logBuffer.toString(); + } + Map urgentLevelMap = new HashMap(); + for (UrgentLevel urgentLevel : urgentLevelList) { + urgentLevelMap.put(urgentLevel.getId(), urgentLevel); + } + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + //物品名称1， + logBuffer.append(tousseDefinition.getName() + ","); + //加急数量1，加急等级1； + logBuffer.append("加急数量" + urgentInfo.getReservationUrgentAmount() + ","); + UrgentLevel urgentLevel = urgentLevelMap.get(urgentInfo.getUrgentLevelId()); + logBuffer.append(urgentLevel.getName() + ";"); + } + return logBuffer.toString(); + } + + /** + * 新建加急物品 + * @param vo + * @param tousseDefinitionIdUrgentReservationTousseMap + * @return + */ + private UrgentReservationTousse buildUrgentReservationTousse(UrgentReservationTousseVo vo, Map tousseDefinitionIdUrgentReservationTousseMap) { + if(tousseDefinitionIdUrgentReservationTousseMap.containsKey(vo.getTousseDefinitionId())){ + throw new RuntimeException("物品不能重复"); + } + UrgentReservationTousse urgentReservationTousse = new UrgentReservationTousse(); + urgentReservationTousse.setFinishStatus(UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED); + urgentReservationTousse.setTousseDefinitionId(vo.getTousseDefinitionId()); + return urgentReservationTousse; + } + + /** + * 校验预约加急物品 + * @param urgentReservationTousse + */ + private void validateUrgentReservationTousse(UrgentReservationTousse urgentReservationTousse) { + TousseDefinition tousseDefinition =tousseDefinitionManager.get(urgentReservationTousse.getTousseDefinitionId()); + if(urgentReservationTousse.getTousseDefinitionId() == null + || tousseDefinition == null){ + throw new RuntimeException("物品不能为空"); + } + //器械包、敷料包、消毒物品、外部代理灭菌 + if(!tousseDefinition.isInsideTousse() + && !tousseDefinition.isDressing() + && !tousseDefinition.isDisinfection() + && !tousseDefinition.isForeignTousse()){ + throw new RuntimeException(tousseDefinition.getTousseType() + "不支持预约加急"); + } + List urgentInfos = urgentReservationTousse.getUrgentInfos(); + if(CollectionUtils.isEmpty(urgentInfos)){ + return; + } + List urgentLevelIdList = new ArrayList(); + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + Long urgentLevelId = urgentInfo.getUrgentLevelId(); + if(!DatabaseUtil.isPoIdValid(urgentLevelId)){ + throw new RuntimeException("加急等级不能为空"); + } + if(urgentLevelIdList.contains(urgentLevelId)){ + throw new RuntimeException("加急等级不能重复设置"); + } + Integer reservationUrgentAmount = urgentInfo.getReservationUrgentAmount(); + //预约加急数量允许大于等于0 + if(reservationUrgentAmount == null){ + throw new RuntimeException("加急数量不允许为空"); + } + //预约加急数量不允许小于已加急数量 + Integer urgentAmount = urgentInfo.getUrgentAmount(); + if(urgentAmount == null || urgentAmount.intValue() <= 0){ + if(reservationUrgentAmount.intValue() < 0){ + //没有已加急数量时，预约加急数量必须大于0 + throw new RuntimeException("加急数量必须大于等于0"); + } + }else{ + if(reservationUrgentAmount.intValue() < urgentAmount.intValue()){ + throw new RuntimeException("加急数量必须大于已加急数量"); + } + } + urgentLevelIdList.add(urgentLevelId); + } + + List urgentLevelList = urgentLevelManager.getCollection(urgentLevelIdList); + if(CollectionUtils.isEmpty(urgentLevelList)){ + throw new RuntimeException("加急等级不能为空"); + } + Map urgentLevelMap = new HashMap(); + for (UrgentLevel urgentLevel : urgentLevelList) { + urgentLevelMap.put(urgentLevel.getId(), urgentLevel); + } + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + Long urgentLevelId = urgentInfo.getUrgentLevelId(); + if(!urgentLevelMap.containsKey(urgentLevelId)){ + throw new RuntimeException("加急等级不能为空"); + } + } + } + + /** + * 设置物品预约加急明细 + * @param urgentReservationTousse + * @param vo + */ + private void setTousseReservationUrgentInfo(UrgentReservationTousse urgentReservationTousse, UrgentReservationTousseVo vo) { + Map idUrgentInfoMap = new HashMap(); + Map urgentLevelIdUrgentInfoMap = new HashMap(); + List dbUrgentInfos = urgentReservationTousse.getUrgentInfos(); + if(CollectionUtils.isNotEmpty(dbUrgentInfos)){ + for (TousseReservationUrgentInfo urgentInfo : dbUrgentInfos) { + idUrgentInfoMap.put(urgentInfo.getId(), urgentInfo); + urgentLevelIdUrgentInfoMap.put(urgentInfo.getUrgentLevelId(), urgentInfo); + } + } + //新增的加急等级 + List newTousseReservationUrgentInfoList = new ArrayList(); + //删除的加急等级 + List deleteTousseReservationUrgentInfoList = new ArrayList(); + if(CollectionUtils.isNotEmpty(dbUrgentInfos)){ + deleteTousseReservationUrgentInfoList.addAll(dbUrgentInfos); + } + List urgentInfoVos = vo.getChildren(); + if(CollectionUtils.isNotEmpty(urgentInfoVos)){ + for (TousseReservationUrgentInfoVo urgentInfoVo : urgentInfoVos) { + TousseReservationUrgentInfo dbTousseReservationUrgentInfo = idUrgentInfoMap.get(urgentInfoVo.getUrgentInfoId()); + if(dbTousseReservationUrgentInfo == null){ + //新增加急等级 + /*if(urgentLevelIdUrgentInfoMap.containsKey(urgentInfoVo.getUrgentLevelId())){ + throw new RuntimeException("加急等级不能重复设置"); + }*/ + TousseReservationUrgentInfo newTousseReservationUrgentInfo = new TousseReservationUrgentInfo(); + newTousseReservationUrgentInfo.setUrgentLevelId(urgentInfoVo.getUrgentLevelId()); + newTousseReservationUrgentInfo.setReservationUrgentAmount(urgentInfoVo.getReservationUrgentAmount()); + newTousseReservationUrgentInfo.setSequence(urgentInfoVo.getSequence()); + newTousseReservationUrgentInfoList.add(newTousseReservationUrgentInfo); + }else{ + //修改加急等级 + Integer urgentAmount = dbTousseReservationUrgentInfo.getUrgentAmount(); + //已加急数量大于0时，不允许修改加急等级、加急数量必须大于已加急数量 + if(urgentAmount != null && urgentAmount.intValue() > 0){ + //不允许修改加急等级 + if(!MathTools.equals(urgentInfoVo.getUrgentLevelId(), dbTousseReservationUrgentInfo.getUrgentLevelId())){ + throw new RuntimeException("已加急数量大于0，不允许修改加急等级！"); + } + //预约加急数量大于等于0 + if(urgentInfoVo.getReservationUrgentAmount() == null || urgentInfoVo.getReservationUrgentAmount() < 0){ + throw new RuntimeException("加急数量必须大于0！"); + } + //预约加急数量不能小于已经加急数量 + if(MathTools.sub(urgentInfoVo.getReservationUrgentAmount(), urgentAmount).intValue() < 0){ + throw new RuntimeException("加急数量必须大于等于已加急数量！"); + } + } + dbTousseReservationUrgentInfo.setUrgentLevelId(urgentInfoVo.getUrgentLevelId()); + dbTousseReservationUrgentInfo.setReservationUrgentAmount(urgentInfoVo.getReservationUrgentAmount()); + dbTousseReservationUrgentInfo.setSequence(urgentInfoVo.getSequence()); + deleteTousseReservationUrgentInfoList.remove(dbTousseReservationUrgentInfo); + } + } + } + + if(CollectionUtils.isNotEmpty(dbUrgentInfos)){ + if(CollectionUtils.isNotEmpty(deleteTousseReservationUrgentInfoList)){ + dbUrgentInfos.removeAll(deleteTousseReservationUrgentInfoList); + for (TousseReservationUrgentInfo tousseReservationUrgentInfo : deleteTousseReservationUrgentInfoList) { + if(tousseReservationUrgentInfo.getUrgentAmount().intValue() > 0){ + throw new SystemException("加急数量大于0的记录不允许删除"); + } + } + objectDao.deleteAll(deleteTousseReservationUrgentInfoList); + } + } + if(CollectionUtils.isNotEmpty(newTousseReservationUrgentInfoList)){ + dbUrgentInfos.addAll(newTousseReservationUrgentInfoList); + } + urgentReservationTousse.setUrgentInfos(dbUrgentInfos); + + } + + @SuppressWarnings("unchecked") + @Override + public void deleteUrgentReservationTousse(String ids) { + if(StringUtils.isBlank(ids)){ + throw new RuntimeException("id无效"); + } + Collection idCol = StringTools.parseToLongs(ids, ";"); + if(CollectionUtils.isEmpty(idCol)){ + throw new RuntimeException("id无效"); + } + List idList = new ArrayList(); + idList.addAll(idCol); + List urgentReservationTousseList = objectDao.findByIds(UrgentReservationTousse.class.getSimpleName(), idList); + if(CollectionUtils.isEmpty(urgentReservationTousseList)){ + throw new RuntimeException("id无效"); + } + for (UrgentReservationTousse urgentReservationTousse : urgentReservationTousseList) { + deleteUrgentReservationTousse(urgentReservationTousse); + } + } + + /** + * 删除预约加急物品 + * @param urgentReservationTousse + */ + private void deleteUrgentReservationTousse(UrgentReservationTousse urgentReservationTousse) { + //已加急数量大于0的记录不允许删除 + canDeleteUrgentReservationTousse(urgentReservationTousse); + //加急预约设置移除预约加急物品 + urgentReservationRemoveUrgentReservationTousse(urgentReservationTousse); + //删除预约加急物品 + objectDao.delete(urgentReservationTousse); + } + + /** + * 加急预约设置移除预约加急物品 + * @param urgentReservationTousse + */ + private void urgentReservationRemoveUrgentReservationTousse(UrgentReservationTousse urgentReservationTousse) { + UseRecordUrgentReservation useRecordUrgentReservation = urgentReservationTousse.getUseRecordUrgentReservation(); + if(useRecordUrgentReservation == null){ + throw new RuntimeException("数据异常，当前没有关联的预约加急设置"); + } + List tousseList = useRecordUrgentReservation.getUrgentReservationTousseList(); + if(CollectionUtils.isNotEmpty(tousseList)){ + tousseList.remove(urgentReservationTousse); + } + urgentReservationTousse.setUseRecordUrgentReservation(null); + //重新计算加急预约设置的完成状态： + resetUseRecordUrgentReservationFinishStatus(useRecordUrgentReservation, tousseList); + } + + @Override + public void resetUseRecordUrgentReservationFinishStatus(UseRecordUrgentReservation useRecordUrgentReservation, List tousseList) { + if(CollectionUtils.isEmpty(tousseList)){ + useRecordUrgentReservation.setFinishStatus(UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED); + return; + } + for (UrgentReservationTousse urgentReservationTousse : tousseList) { + List urgentInfos = urgentReservationTousse.getUrgentInfos(); + String finishStatus = getUrgentReservationTousseFinishStatus(urgentInfos); + urgentReservationTousse.setFinishStatus(finishStatus); + } + List unFinishTousseList = new ArrayList(); + List partFinishTousseList = new ArrayList(); + List finishTousseList = new ArrayList(); + for (UrgentReservationTousse tousse : tousseList) { + String finishStatus = tousse.getFinishStatus(); + if(StringUtils.equals(finishStatus, UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED)){ + unFinishTousseList.add(tousse); + }else if(StringUtils.equals(finishStatus, UseRecordUrgentReservation.FINISH_STATUS_PART_FINISHED)){ + partFinishTousseList.add(tousse); + }else if(StringUtils.equals(finishStatus, UseRecordUrgentReservation.FINISH_STATUS_FINISHED)){ + finishTousseList.add(tousse); + }else{ + throw new RuntimeException("数据异常，预约加急设置预约加急状态不能为：" + finishStatus); + } + } + String finishStatus = getUseRecordUrgentReservationFinishStatus(tousseList, unFinishTousseList, partFinishTousseList, finishTousseList); + useRecordUrgentReservation.setFinishStatus(finishStatus); + } + + /** + * 计算预约加急物品的完成状态 + * @param urgentInfos + * @return + */ + private String getUrgentReservationTousseFinishStatus(List urgentInfos) { + if(CollectionUtils.isEmpty(urgentInfos)){ + return UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED; + } + List unFinishUrgentInfoList = new ArrayList(); + List partFinishUrgentInfoList = new ArrayList(); + List finishedUrgentInfoList = new ArrayList(); + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + Integer reservationUrgentAmount = urgentInfo.getReservationUrgentAmount(); + Integer urgentAmount =urgentInfo.getUrgentAmount(); + if(urgentAmount > 0){ + if(reservationUrgentAmount <= urgentAmount){ + finishedUrgentInfoList.add(urgentInfo); + }else{ + partFinishUrgentInfoList.add(urgentInfo); + } + }else{ + unFinishUrgentInfoList.add(urgentInfo); + } + } + return getUrgentReservationTousseFinishStatus(urgentInfos, unFinishUrgentInfoList, partFinishUrgentInfoList, finishedUrgentInfoList); + } + + /** + * 计算预约加急物品的完成状态 + * @param urgentInfos + * @param unFinishUrgentInfoList + * @param partFinishUrgentInfoList + * @param finishedUrgentInfoList + * @return + */ + private String getUrgentReservationTousseFinishStatus(List urgentInfos, + List unFinishUrgentInfoList, + List partFinishUrgentInfoList, + List finishedUrgentInfoList) { + if(CollectionUtils.isEmpty(urgentInfos)){ + return UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED; + } + if(CollectionUtils.isNotEmpty(finishedUrgentInfoList)){ + if(urgentInfos.size() == finishedUrgentInfoList.size()){ + return UseRecordUrgentReservation.FINISH_STATUS_FINISHED; + }else if(urgentInfos.size() > finishedUrgentInfoList.size()){ + return UseRecordUrgentReservation.FINISH_STATUS_PART_FINISHED; + }else{ + throw new RuntimeException("已经加急数量不能大于预约加急数量"); + } + }else if(CollectionUtils.isNotEmpty(partFinishUrgentInfoList)){ + return UseRecordUrgentReservation.FINISH_STATUS_PART_FINISHED; + } + return UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED; + } + + /** + * 计算预约加急设置的完成状态 + * @param tousseList + * @param unFinishTousseList + * @param partFinishTousseList + * @param finishTousseList + * @return + */ + private String getUseRecordUrgentReservationFinishStatus(List tousseList, + List unFinishTousseList, + List partFinishTousseList, + List finishTousseList) { + if(CollectionUtils.isEmpty(tousseList)){ + return UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED; + } + if(CollectionUtils.isNotEmpty(finishTousseList)){ + if(tousseList.size() == finishTousseList.size()){ + return UseRecordUrgentReservation.FINISH_STATUS_FINISHED; + }else if(tousseList.size() > finishTousseList.size()){ + return UseRecordUrgentReservation.FINISH_STATUS_PART_FINISHED; + }else{ + throw new RuntimeException("已经加急数量不能大于预约加急数量"); + } + }else if(CollectionUtils.isNotEmpty(partFinishTousseList)){ + return UseRecordUrgentReservation.FINISH_STATUS_PART_FINISHED; + } + return UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED; + } + + /** + * 判断是否可以删除加急物品 + * @param urgentReservationTousse + */ + private void canDeleteUrgentReservationTousse(UrgentReservationTousse urgentReservationTousse) { + List urgentInfos = urgentReservationTousse.getUrgentInfos(); + if(CollectionUtils.isEmpty(urgentInfos)){ + return; + } + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + Integer urgentAmount = urgentInfo.getUrgentAmount(); + if(urgentAmount != null && urgentAmount.intValue() > 0){ + throw new RuntimeException("已加急数量大于0，不允许删除！"); + } + + } + } + + @Override + public List loadCurrentLoginOrgUnitUrgentReservationDateAfterToday() { + return loadUrgentReservationDateAfterToday(AcegiHelper.getCurrentOrgUnitCode()); + } + + /** + * 查询未来预约加急记录的日期列表 + * @param currentOrgUnitCode + * @return + */ + private List loadUrgentReservationDateAfterToday(String currentOrgUnitCode) { + OrgUnit orgUnit = orgUnitManager.getByCode(currentOrgUnitCode); + if(orgUnit == null){ + throw new RuntimeException(String.format("不存在科室编码为%s的科室", currentOrgUnitCode)); + } + String todaySql = getTodayStartTimeSql(); + List voList = new ArrayList(); + StringBuffer sqlBuffer = new StringBuffer(); + sqlBuffer.append("select po.id, po.reservationDate from "); + sqlBuffer.append(UseRecordUrgentReservation.class.getSimpleName()); + sqlBuffer.append(" po where po.reservationOrgUnitId = "); + sqlBuffer.append(orgUnit.getId()); + sqlBuffer.append(" and po.reservationDate >= "); + sqlBuffer.append(todaySql); + sqlBuffer.append(" order by po.reservationDate "); + + ResultSet rs = null; + try { + rs = objectDao.executeSql(sqlBuffer.toString()); + while(rs.next()){ + Long id = rs.getLong("id"); + Date reservationDate = rs.getTimestamp("reservationDate"); + UseRecordUrgentReservationVo vo = new UseRecordUrgentReservationVo(); + vo.setId(id); + vo.setReservationDate(DateTools.getFormatDateStr(reservationDate, DateTools.COMMON_DATE_ONLY)); + voList.add(vo); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + + } + + return voList; + } + + /** + * 今天开始时间 + * @return + */ + private String getTodayStartTimeSql() { + Date out_beginTime = getToday(); + return dateQueryAdapter.dateAdapter(out_beginTime); + } + + private Date getToday(){ + Date out_beginTime = new Date(); + Date out_endTime = new Date(); + int hour = 0; + int minute = 0; + try { + String[] hourAndMinute = StringUtils.split(supplyRoomConfigManager.getDayStartTime(), ':'); + hour = Integer.parseInt(hourAndMinute[0]); + minute = Integer.parseInt(hourAndMinute[1]); + } catch (Exception ex) { + hour = 0; + minute = 0; + } + + Calendar now = Calendar.getInstance(); + Calendar time1 = (Calendar)now.clone(); + time1.set(Calendar.HOUR_OF_DAY, hour); + time1.set(Calendar.MINUTE, minute); + time1.set(Calendar.SECOND, 0); + + if(now.before(time1)){ + Calendar time2 = (Calendar)time1.clone(); + time2.add(Calendar.DATE, -1); + + DateTools.setStart(time2); + out_beginTime.setTime(time2.getTime().getTime()); + DateTools.setStart(time1); + out_endTime.setTime(time1.getTime().getTime()); + } else { + Calendar time2 = (Calendar)time1.clone(); + time2.add(Calendar.DATE, 1); + + DateTools.setStart(time1); + out_beginTime.setTime(time1.getTime().getTime()); + DateTools.setStart(time2); + out_endTime.setTime(time2.getTime().getTime()); + } + return out_beginTime; + } + + @Override + public void loadCurrentLoginOrgUnitHistoryUrgentReservation(PageEntity page) { + String currentOrgUnitCode = AcegiHelper.getCurrentOrgUnitCode(); + OrgUnit orgUnit = orgUnitManager.getByCode(currentOrgUnitCode); + if(orgUnit == null){ + throw new RuntimeException(String.format("不存在科室编码为%s的科室", currentOrgUnitCode)); + } + //String todaySql = getTodayStartTimeSql(); + StringBuffer fromSqlBuffer = new StringBuffer(); + fromSqlBuffer.append(" from "); + fromSqlBuffer.append(UseRecordUrgentReservation.class.getSimpleName()); + fromSqlBuffer.append(" po join SS_USERS u on u.id = po.operatorId "); + fromSqlBuffer.append(" where po.reservationOrgUnitId = "); + fromSqlBuffer.append(orgUnit.getId()); + //fromSqlBuffer.append(" and po.reservationDate < "); + //fromSqlBuffer.append(todaySql); + + int count = objectDao.countBySql("select count(1) " + fromSqlBuffer.toString()); + if(count == 0){ + return; + } + + page.setCount(count); + int firstIndex = 0; + int maxResults = 0; + if(page != null){ + firstIndex = page.getStart(); + maxResults = page.getLimit(); + } + if(firstIndex <= 0){ + firstIndex = 0; + } + if(maxResults <= 0){ + maxResults = 20; + } + + StringBuffer querySql = new StringBuffer(); + querySql.append("select po.id, po.reservationDate, po.operatorId, u.fullName operator, po.operateTime, po.finishStatus "); + querySql.append(fromSqlBuffer.toString()); + + String sql = ""; + if(dbConnection.isSqlServer()){ + sql = getSqlServerQuerySqlByPage(querySql.toString(), firstIndex, maxResults, "id", " order by id "); + }else if(dbConnection.isOracle()){ + sql = SqlUtils.getOracleQuerySqlByPage(querySql.toString(), firstIndex, maxResults); + }else if(dbConnection.isMySQLOrTiDB()){ + sql += String.format(" order by id limit %s, %s", firstIndex, maxResults); + }else{ + return; + } + + List voList = new ArrayList(); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sql); + while(rs.next()){ + UseRecordUrgentReservationVo vo = new UseRecordUrgentReservationVo(); + vo.setId(rs.getLong("id")); + Date reservationDate = rs.getTimestamp("reservationDate"); + if(reservationDate != null){ + vo.setReservationDateObj(reservationDate); + vo.setReservationDate(DateTools.getFormatDateStr(reservationDate, DateTools.COMMON_DATE_ONLY)); + } + vo.setOperatorId(rs.getLong("operatorId")); + vo.setOperator(rs.getString("operator")); + Date operateTime = rs.getTimestamp("operateTime"); + if(operateTime != null){ + vo.setOperateTime(DateTools.getFormatDateStr(reservationDate, DateTools.COMMON_DATE_HM)); + } + vo.setFinishStatus(rs.getString("finishStatus")); + voList.add(vo); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + + //设置当天记录的完成状态 + setTodayFinishStatus(voList); + + page.setList(voList); + } + + /** + * 未开始 若预约日期在当前日期之后时，固定显示此状态值 + * 进行中 若当前日期为预约日期时，固定显示此状态值 + * @param voList + */ + private void setTodayFinishStatus(List voList) { + if(CollectionUtils.isEmpty(voList)){ + return; + } + Date today = getToday(); + for (UseRecordUrgentReservationVo vo : voList) { + Date reservationDate = vo.getReservationDateObj(); + if(reservationDate == null){ + continue; + } + if(reservationDate.after(today)){ + //未开始 若预约日期在当前日期之后时，固定显示此状态值 + vo.setFinishStatus("未开始"); + }else if(reservationDate.compareTo(today) == 0){ + //进行中 若当前日期为预约日期时，固定显示此状态值 + vo.setFinishStatus("进行中"); + } + } + } + + + /** + * 根据sql语句拼接分页查询语句 + * @param sql 原查询语句(可包含查询条件、排序等) + * @param start 开始记录,即从第多少开始 + * @param limit 查询偏移量,即查询多少个 + * @param pageColumnName + * @return + */ + public String getSqlServerQuerySqlByPage(String querySql, int start, int limit, String pageColumnName, String orderSql){ + StringBuffer querySqlByPage = new StringBuffer(); + if(start == 0){ + querySqlByPage.append("select top "+ limit +" * from ("+ querySql +") t"); + }else{ + querySqlByPage.append("select top "+ limit +" * from ("+ querySql +") t "); + querySqlByPage.append("where "+ pageColumnName +" not in (select top "+ (start) +" "+ pageColumnName +" from ("+ querySql +") t0 " + orderSql + " )"); + } + querySqlByPage.append(orderSql); + return querySqlByPage.toString(); + } + + @Override + public List loadUseRecordUrgentReservationDetail(Long id) { + if(!DatabaseUtil.isPoIdValid(id)){ + throw new SystemException("id无效"); + } + UseRecordUrgentReservation useRecordUrgentReservation = this.get(id); + if(useRecordUrgentReservation == null){ + throw new SystemException("id无效"); + } + List urgentReservationTousseVos = buildUrgentReservationTousseVo(useRecordUrgentReservation); + return urgentReservationTousseVos; + } + + /** + * 返回预约加急物品vo集合 + * @param useRecordUrgentReservation + * @return + */ + private List buildUrgentReservationTousseVo(UseRecordUrgentReservation useRecordUrgentReservation) { + List urgentReservationTousseVos = new ArrayList(); + if(useRecordUrgentReservation == null){ + return urgentReservationTousseVos; + } + List urgentReservationTousseList = useRecordUrgentReservation.getUrgentReservationTousseList(); + if(CollectionUtils.isEmpty(urgentReservationTousseList)){ + //没有设置预约加急物品 + return urgentReservationTousseVos; + } + //预约加急器械包定义map + Map tousseDefinitionMap = getUrgentReservationTousseDefinitionMap(urgentReservationTousseList); + if(MapUtils.isEmpty(tousseDefinitionMap)){ + return urgentReservationTousseVos; + } + //预约加急器械包加急等级map + Map urgentLevelMap = getUrgentReservationUrgentLevelMap(urgentReservationTousseList); + if(MapUtils.isEmpty(urgentLevelMap)){ + return urgentReservationTousseVos; + } + + for (UrgentReservationTousse urgentReservationTousse : urgentReservationTousseList) { + UrgentReservationTousseVo vo = buildUrgentReservationTousseVo(useRecordUrgentReservation, urgentReservationTousse, tousseDefinitionMap, urgentLevelMap); + urgentReservationTousseVos.add(vo); + } + + return urgentReservationTousseVos; + } + + /** + * 构建vo + * @param urgentReservationTousse + * @param tousseDefinitionMap + * @param urgentLevelMap + * @return + */ + private UrgentReservationTousseVo buildUrgentReservationTousseVo(UseRecordUrgentReservation useRecordUrgentReservation, UrgentReservationTousse urgentReservationTousse, + Map tousseDefinitionMap, + Map urgentLevelMap) { + UrgentReservationTousseVo vo = new UrgentReservationTousseVo(); + vo.setId(urgentReservationTousse.getId()); + vo.setUseRecordUrgentReservationId(useRecordUrgentReservation.getId()); + vo.setRemark(urgentReservationTousse.getRemark()); + if(!DatabaseUtil.isPoIdValid(urgentReservationTousse.getTousseDefinitionId())){ + throw new SystemException("数据异常，预约加急物品的器械包定义id不允许为空"); + } + TousseDefinition tousseDefinition = tousseDefinitionMap.get(urgentReservationTousse.getTousseDefinitionId()); + if(tousseDefinition == null){ + throw new SystemException("数据异常，不存在id=" + urgentReservationTousse.getTousseDefinitionId() + "的器械包定义"); + } + vo.setTousseDefinitionId(tousseDefinition.getId()); + vo.setTousseName(tousseDefinition.getName()); + List urgentInfos = urgentReservationTousse.getUrgentInfos(); + if(CollectionUtils.isNotEmpty(urgentInfos)){ + List urgentInfoVos = new ArrayList(); + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + TousseReservationUrgentInfoVo urgentInfoVo = new TousseReservationUrgentInfoVo(); + urgentInfoVo.setUrgentInfoId(urgentInfo.getId()); + urgentInfoVo.setReservationUrgentAmount(urgentInfo.getReservationUrgentAmount()); + urgentInfoVo.setUrgentAmount(urgentInfo.getUrgentAmount()); + urgentInfoVo.setSequence(urgentInfo.getSequence()); + if(!DatabaseUtil.isPoIdValid(urgentInfo.getUrgentLevelId())){ + throw new SystemException("数据异常，预约加急等级id不允许为空"); + } + UrgentLevel urgentLevel = urgentLevelMap.get(urgentInfo.getUrgentLevelId()); + if(urgentLevel == null){ + throw new SystemException("数据异常，不存在id=" + urgentInfo.getUrgentLevelId() + "的加急等级"); + } + urgentInfoVo.setUrgentLevelId(urgentLevel.getId()); + urgentInfoVo.setUrgentLevelName(urgentLevel.getName()); + urgentInfoVos.add(urgentInfoVo); + } + vo.setChildren(urgentInfoVos); + } + return vo; + } + + /** + * 查询预约加急物品设置的加急等级 + * @param urgentReservationTousseList + * @return + */ + private Map getUrgentReservationUrgentLevelMap(List urgentReservationTousseList) { + Map urgentLevelMap = new HashMap(); + if(CollectionUtils.isEmpty(urgentReservationTousseList)){ + return urgentLevelMap; + } + Set urgentLevelIdSet = new HashSet(); + for (UrgentReservationTousse urgentReservationTousse : urgentReservationTousseList) { + List urgentInfos = urgentReservationTousse.getUrgentInfos(); + if(CollectionUtils.isEmpty(urgentInfos)){ + continue; + } + for (TousseReservationUrgentInfo urgentInfo : urgentInfos) { + Long urgentLevelId = urgentInfo.getUrgentLevelId(); + if(DatabaseUtil.isPoIdValid(urgentLevelId)){ + urgentLevelIdSet.add(urgentLevelId); + } + } + } + if(CollectionUtils.isEmpty(urgentLevelIdSet)){ + return urgentLevelMap; + } + List urgentLevelList = urgentLevelManager.getCollection(urgentLevelIdSet); + if(CollectionUtils.isEmpty(urgentLevelList)){ + return urgentLevelMap; + } + for (UrgentLevel urgentLevel : urgentLevelList) { + urgentLevelMap.put(urgentLevel.getId(), urgentLevel); + } + return urgentLevelMap; + } + + /** + * 查询预约加急物品器械包定义 + * @param urgentReservationTousseList + * @return + */ + private Map getUrgentReservationTousseDefinitionMap(List urgentReservationTousseList) { + Map tousseDefinitionMap = new HashMap(); + if(CollectionUtils.isEmpty(urgentReservationTousseList)){ + return tousseDefinitionMap; + } + Set tousseDefinitionIdSet = new HashSet(); + for (UrgentReservationTousse urgentReservationTousse : urgentReservationTousseList) { + Long tousseDefinitionId = urgentReservationTousse.getTousseDefinitionId(); + if(DatabaseUtil.isPoIdValid(tousseDefinitionId)){ + tousseDefinitionIdSet.add(tousseDefinitionId); + } + } + + if(CollectionUtils.isEmpty(tousseDefinitionIdSet)){ + return tousseDefinitionMap; + } + + List tousseDefinitionList = tousseDefinitionManager.getCollection(tousseDefinitionIdSet); + if(CollectionUtils.isNotEmpty(tousseDefinitionList)){ + for (TousseDefinition tousseDefinition : tousseDefinitionList) { + tousseDefinitionMap.put(tousseDefinition.getId(), tousseDefinition); + } + } + + return tousseDefinitionMap; + } + + @Override + public List loadUseRecordUrgentDetail(Long useRecordUrgentReservationId, Long tousseReservationUrgentInfoId) { + List voList = new ArrayList(); + if(!DatabaseUtil.isPoIdValid(useRecordUrgentReservationId) && !DatabaseUtil.isPoIdValid(tousseReservationUrgentInfoId)){ + return voList; + } + + StringBuffer sqlBuffer = new StringBuffer(); + //1、查询加急预约记录 + sqlBuffer.append("select tur.tousseInstanceId, tur.useRecordId, ur.name urgentLevelName, bd.barcode tousseInstanceBarcode, td.name tousseName from "); + sqlBuffer.append(TousseReserveUrgentRecord.class.getSimpleName()); + sqlBuffer.append(" tur join "); + sqlBuffer.append(TousseReservationUrgentInfo.class.getSimpleName()); + sqlBuffer.append(" uInfo on uInfo.id = tur.urgentInfoId join "); + sqlBuffer.append(UrgentReservationTousse.class.getSimpleName()); + sqlBuffer.append(" urt on urt.id = uInfo.urgentTousseId join "); + sqlBuffer.append(UrgentLevel.class.getSimpleName()); + sqlBuffer.append(" ur on ur.id = uInfo.urgentLevelId join "); + sqlBuffer.append(BarcodeDevice.class.getSimpleName()); + sqlBuffer.append(" bd on bd.id = tur.tousseInstanceId join "); + sqlBuffer.append(TousseDefinition.class.getSimpleName()); + sqlBuffer.append(" td on td.id = urt.tousseDefinitionId where 1=1 "); + if(DatabaseUtil.isPoIdValid(tousseReservationUrgentInfoId)){ + sqlBuffer.append(" and uInfo.id = " + tousseReservationUrgentInfoId); + }else if(DatabaseUtil.isPoIdValid(useRecordUrgentReservationId)){ + sqlBuffer.append(" and urt.reservation_id = " + useRecordUrgentReservationId); + } + + ResultSet rs1 = null; + try { + rs1 = objectDao.executeSql(sqlBuffer.toString()); + while(rs1.next()){ + Long useRecordId = rs1.getLong("useRecordId"); + String urgentLevelName = rs1.getString("urgentLevelName"); + String tousseInstanceBarcode = rs1.getString("tousseInstanceBarcode"); + String tousseName = rs1.getString("tousseName"); + + TousseReserveUrgentRecordVo vo = new TousseReserveUrgentRecordVo(); + vo.setTousseInstanceBarcode(tousseInstanceBarcode); + vo.setTousseName(tousseName); + vo.setUseRecordId(useRecordId); + vo.setUrgentLevelName(urgentLevelName); + + voList.add(vo); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs1); + } + + if(CollectionUtils.isEmpty(voList)){ + return voList; + } + + //2、关联查询使用记录转换的申请单流水号 + setUseRecordToRecycleApplication(voList); + + return voList; + } + + /** + * 关联查询使用记录转换的申请单流水号 + * @param voList + */ + private void setUseRecordToRecycleApplication(List voList) { + if(CollectionUtils.isEmpty(voList)){ + return; + } + Set useRecordIdSet = new HashSet(); + for (TousseReserveUrgentRecordVo vo : voList) { + if(DatabaseUtil.isPoIdValid(vo.getUseRecordId())){ + useRecordIdSet.add(vo.getUseRecordId()); + } + } + if(CollectionUtils.isEmpty(useRecordIdSet)){ + return; + } + StringBuffer sqlBuffer = new StringBuffer(); + sqlBuffer.append("select ip.serialNumber, ip.tousseBarcodes, uta.useRecordId from "); + sqlBuffer.append(UseRecordToRecycleApplication.class.getSimpleName()); + sqlBuffer.append(" uta join "); + sqlBuffer.append(InvoicePlan.class.getSimpleName()); + sqlBuffer.append(" ip on ip.id = uta.invoicePlanId where "); + sqlBuffer.append(SqlUtils.getNonStringFieldInLargeCollectionsPredicate("uta.useRecordId", useRecordIdSet)); + + Map> useRecordIdRecyclingApplicationVoMap = new HashMap>(); + ResultSet rs = null; + try { + rs = objectDao.executeSql(sqlBuffer.toString()); + while(rs.next()){ + String serialNumber = rs.getString("serialNumber"); + String tousseBarcodes = rs.getString("tousseBarcodes"); + Long useRecordId = rs.getLong("useRecordId"); + RecyclingApplicationVo vo = new RecyclingApplicationVo(); + vo.setSerialNumber(serialNumber); + vo.setTousseBarcodes(tousseBarcodes); + + List ipVoList = useRecordIdRecyclingApplicationVoMap.get(useRecordId); + if(ipVoList == null){ + ipVoList = new ArrayList(); + } + ipVoList.add(vo); + useRecordIdRecyclingApplicationVoMap.put(useRecordId, ipVoList); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + DatabaseUtil.closeResultSetAndStatement(rs); + } + + if(MapUtils.isEmpty(useRecordIdRecyclingApplicationVoMap)){ + return; + } + + for (TousseReserveUrgentRecordVo vo : voList) { + Long useRecordId = vo.getUseRecordId(); + String tousseInstanceBarcode = vo.getTousseInstanceBarcode(); + List ipVoList = useRecordIdRecyclingApplicationVoMap.get(useRecordId); + if(CollectionUtils.isEmpty(ipVoList)){ + continue; + } + for (RecyclingApplicationVo ipVo : ipVoList) { + String tousseBarcodes = ipVo.getTousseBarcodes(); + if(StringUtils.contains(tousseBarcodes, ";" + tousseInstanceBarcode + ";")){ + vo.setInvoicePlanSerialNumber(ipVo.getSerialNumber()); + break; + } + } + } + + } + + @Override + public void deleteUseRecordUrgentReservation(Long id) { + if(!DatabaseUtil.isPoIdValid(id)){ + throw new SystemException("id无效"); + } + UseRecordUrgentReservation useRecordUrgentReservation = this.get(id); + if(useRecordUrgentReservation == null){ + throw new SystemException("id无效"); + } + canDeleteUseRecordUrgentReservation(useRecordUrgentReservation); + this.delete(useRecordUrgentReservation); + //保存日志记录：操作人：admin，操作时间：2024-9-14 09:09，预约日期：2024-9-15； + String description = String.format("操作人：%s，操作时间：%s，预约日期：%s", AcegiHelper.getLoginUserFullName(), + DateTools.getFormatDateStr(new Date(), DateTools.COMMON_DATE_HM), + DateTools.getFormatDateStr(useRecordUrgentReservation.getReservationDate(), DateTools.COMMON_DATE_ONLY)); + appLogManager.saveLog(AcegiHelper.getLoginUser(), Log.MODEL_USERECORD, + "删除预约记录", description); + } + + /** + * 判断是否允许删除加急预约记录，已加急数量大于0，不允许删除 + * @param useRecordUrgentReservation + */ + private void canDeleteUseRecordUrgentReservation(UseRecordUrgentReservation useRecordUrgentReservation) { + List urgentReservationTousseList = useRecordUrgentReservation.getUrgentReservationTousseList(); + if(CollectionUtils.isEmpty(urgentReservationTousseList)){ + return; + } + for (UrgentReservationTousse urgentReservationTousse : urgentReservationTousseList) { + canDeleteUrgentReservationTousse(urgentReservationTousse); + } + } + + @SuppressWarnings("unchecked") + @Override + public Map getTodayUseRecordUrgentReservationMap(List useRecordList) { + Map useRecordUrgentReservationMap = new HashMap(); + if(CollectionUtils.isEmpty(useRecordList)){ + return useRecordUrgentReservationMap; + } + Set orgUnitCodeSet =new HashSet(); + for (UseRecord useRecord : useRecordList) { + orgUnitCodeSet.add(useRecord.getDepartCoding()); + } + List orgUnitList = orgUnitManager.getByCodes(orgUnitCodeSet); + if(CollectionUtils.isEmpty(orgUnitList)){ + return useRecordUrgentReservationMap; + } + Map orgUnitCodeMap = new HashMap(); + List orgUnitIdList = new ArrayList(); + for (OrgUnit orgUnit : orgUnitList) { + orgUnitIdList.add(orgUnit.getId()); + orgUnitCodeMap.put(orgUnit.getId(), orgUnit.getOrgUnitCoding()); + } + String todaySql = getTodayStartTimeSql(); + StringBuffer sqlBuffer = new StringBuffer(); + sqlBuffer.append("select po from "); + sqlBuffer.append(UseRecordUrgentReservation.class.getSimpleName()); + sqlBuffer.append(" po where "); + sqlBuffer.append(SqlUtils.getNonStringFieldInLargeCollectionsPredicate("po.reservationOrgUnitId", orgUnitIdList)); + sqlBuffer.append(" and po.reservationDate = " + todaySql); + sqlBuffer.append(" and po.finishStatus in ('" + UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED + "','" + UseRecordUrgentReservation.FINISH_STATUS_PART_FINISHED + "')"); + List reservationList = objectDao.findByHql(sqlBuffer.toString()); + if(CollectionUtils.isEmpty(reservationList)){ + return useRecordUrgentReservationMap; + } + + for (UseRecordUrgentReservation reservation : reservationList) { + String orgUnitCode = orgUnitCodeMap.get(reservation.getReservationOrgUnitId()); + useRecordUrgentReservationMap.put(orgUnitCode, reservation); + } + + return useRecordUrgentReservationMap; + } + + @Override + public void batchSaveTousseReserveUrgentRecord(List tousseReserveUrgentRecordList) { + if(CollectionUtils.isEmpty(tousseReserveUrgentRecordList)){ + return; + } + String idColumnName = ""; + String idColumnValue = ""; + if(DatabaseUtil.isOracle(dbConnection.getDatabase())){ + idColumnName = "id,"; + idColumnValue = "hibernate_sequence.nextval,"; + } + String insertSql = String.format("insert into %s (%s tousseInstanceId, urgentInfoId, useRecordId) values (%s ?, ?, ?)", + TousseReserveUrgentRecord.class.getSimpleName(), idColumnName, idColumnValue); + jdbcTemplate.batchUpdate(insertSql, new BatchPreparedStatementSetter() { + + @Override + public void setValues(PreparedStatement ps, int i) throws SQLException { + TousseReserveUrgentRecord record = tousseReserveUrgentRecordList.get(i); + ps.setLong(1, record.getTousseInstanceId()); + ps.setLong(2, record.getUrgentInfoId()); + ps.setLong(3, record.getUseRecordId()); + } + + @Override + public int getBatchSize() { + return tousseReserveUrgentRecordList.size(); + } + }); + } + + +} Index: ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml =================================================================== diff -u -r38528 -r38750 --- ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml (.../applicationContext-disinfectsystem-service.xml) (revision 38528) +++ ssts-web/src/main/webapp/WEB-INF/spring/applicationContext-disinfectsystem-service.xml (.../applicationContext-disinfectsystem-service.xml) (revision 38750) @@ -3132,4 +3132,15 @@ + + + + + + + + + \ No newline at end of file Index: ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/UrgentReservationTousse.java =================================================================== diff -u --- ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/UrgentReservationTousse.java (revision 0) +++ ssts-basedata/src/main/java/com/forgon/disinfectsystem/entity/useRecord/urgentreservation/UrgentReservationTousse.java (revision 38750) @@ -0,0 +1,123 @@ +package com.forgon.disinfectsystem.entity.useRecord.urgentreservation; + +import java.util.ArrayList; +import java.util.List; + +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.Index; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; +import javax.persistence.OrderBy; +import javax.persistence.Table; + +import org.hibernate.annotations.Cache; +import org.hibernate.annotations.CacheConcurrencyStrategy; +import org.hibernate.annotations.Cascade; +import org.hibernate.annotations.CascadeType; +import org.hibernate.annotations.DynamicInsert; +import org.hibernate.annotations.DynamicUpdate; + +/** + * 预约加急物品表GDSRMYY-617 + */ +@Entity +@DynamicInsert(false) +@DynamicUpdate(true) +@Table(indexes={@Index(columnList="reservation_id",name="urut_rid_index") +,@Index(columnList="tousseDefinitionId",name="urur_tdid_index") +}) +@Cache(usage=CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) +public class UrgentReservationTousse { + + private Long id; + + /** + * 预约加急的器械包定义祖先包id + */ + private Long tousseDefinitionId; + + /** + * 完成状态：未完成(未开始、进行中)、部分完成、已完成 + */ + private String finishStatus = UseRecordUrgentReservation.FINISH_STATUS_UNFINISHED; + + /** + * 备注 + */ + private String remark; + + /** + * 关联的使用记录预约设置 + */ + private UseRecordUrgentReservation useRecordUrgentReservation; + + /** + * 加急明细 + */ + private List urgentInfos = new ArrayList(); + + @Id + @GeneratedValue(strategy=GenerationType.AUTO) + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getTousseDefinitionId() { + return tousseDefinitionId; + } + + public void setTousseDefinitionId(Long tousseDefinitionId) { + this.tousseDefinitionId = tousseDefinitionId; + } + + public String getFinishStatus() { + return finishStatus; + } + + public void setFinishStatus(String finishStatus) { + this.finishStatus = finishStatus; + } + + public String getRemark() { + return remark; + } + + public void setRemark(String remark) { + this.remark = remark; + } + + @ManyToOne(fetch = FetchType.EAGER) + @Cascade(value = { CascadeType.SAVE_UPDATE }) + @JoinColumn(name = "reservation_id") + public UseRecordUrgentReservation getUseRecordUrgentReservation() { + return useRecordUrgentReservation; + } + + public void setUseRecordUrgentReservation( + UseRecordUrgentReservation useRecordUrgentReservation) { + this.useRecordUrgentReservation = useRecordUrgentReservation; + } + + @OneToMany(fetch = FetchType.LAZY) + @Cascade(value = { CascadeType.ALL }) + @JoinColumn(name = "urgentTousseId") + @OrderBy("sequence asc") + public List getUrgentInfos() { + return urgentInfos; + } + + public void setUrgentInfos(List urgentInfos) { + this.urgentInfos = urgentInfos; + } + + +} Index: ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/UseRecordUrgentReservationVo.java =================================================================== diff -u --- ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/UseRecordUrgentReservationVo.java (revision 0) +++ ssts-userecord/src/main/java/com/forgon/disinfectsystem/useRecord/urgentreservation/vo/UseRecordUrgentReservationVo.java (revision 38750) @@ -0,0 +1,137 @@ +package com.forgon.disinfectsystem.useRecord.urgentreservation.vo; + +import java.util.Date; + +/** + * “预约加急管理”的vo + */ +public class UseRecordUrgentReservationVo { + + private Long id; + + /** + * 操作人ID + */ + private Long operatorId; + + /** + * 操作人姓名 + */ + private String operator; + + /** + * 操作时间 + */ + private String operateTime; + + /** + * 预约科室ID + */ + private Long reservationOrgUnitId; + + /** + * 预约科室编码 + */ + private String reservationOrgUnitCode; + + /** + * 预约科室名称 + */ + private String reservationOrgUnitName; + + /** + * 预约加急时间 + */ + private String reservationDate; + + /** + * 预约加急时间 + */ + private Date reservationDateObj; + + /** + * 完成状态：未完成(未开始、进行中(根据预约时间和当天开始时间判断))、部分完成、已完成 + */ + private String finishStatus; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getOperatorId() { + return operatorId; + } + + public void setOperatorId(Long operatorId) { + this.operatorId = operatorId; + } + + public String getOperator() { + return operator; + } + + public void setOperator(String operator) { + this.operator = operator; + } + + public String getOperateTime() { + return operateTime; + } + + public void setOperateTime(String operateTime) { + this.operateTime = operateTime; + } + + public Long getReservationOrgUnitId() { + return reservationOrgUnitId; + } + + public void setReservationOrgUnitId(Long reservationOrgUnitId) { + this.reservationOrgUnitId = reservationOrgUnitId; + } + + public String getReservationOrgUnitCode() { + return reservationOrgUnitCode; + } + + public void setReservationOrgUnitCode(String reservationOrgUnitCode) { + this.reservationOrgUnitCode = reservationOrgUnitCode; + } + + public String getReservationOrgUnitName() { + return reservationOrgUnitName; + } + + public void setReservationOrgUnitName(String reservationOrgUnitName) { + this.reservationOrgUnitName = reservationOrgUnitName; + } + + public String getReservationDate() { + return reservationDate; + } + + public void setReservationDate(String reservationDate) { + this.reservationDate = reservationDate; + } + + public Date getReservationDateObj() { + return reservationDateObj; + } + + public void setReservationDateObj(Date reservationDateObj) { + this.reservationDateObj = reservationDateObj; + } + + public String getFinishStatus() { + return finishStatus; + } + + public void setFinishStatus(String finishStatus) { + this.finishStatus = finishStatus; + } + +}