import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
private PatientICPStage_StatusChangeVo prepareStageToRemoveFromScope(PatientICPStage_StatusChangeVo stage, MemberOfStaffLiteVo mos)
{
	// Create stage status
	PatientICPStageStatusVo stageStatus = new PatientICPStageStatusVo();
	// Populate values to status
	stageStatus.setStatusDate(new DateTime());
	stageStatus.setChangedBy(mos.getIMosName());
	stageStatus.setStatus(ICPStageStatus.NOTINSCOPE);
	
	// Set status to stage
	stage.setCurrentStatus(stageStatus);
	stage.getStatusHistory().add(stageStatus);
	
	// Iterate stage phases
	for (PatientICPPhase_StatusChangeVo phase : stage.getStagePhases())
	{
		// If phase is in SCOPE then remove it
		if (ICPPhaseStatus.INPROGRESS.equals(phase.getCurrentStatus().getStatus()))
		{
			phase = preparePhaseToRemoveFromScope(phase, mos);
		}
	}
	
	return stage;
}
 

import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
private PatientICPPhase_StatusChangeVo preparePhaseToRemoveFromScope(PatientICPPhase_StatusChangeVo phase, MemberOfStaffLiteVo mos)
{
	// Create a new phase status
	PatientICPPhaseStatusVo phaseStatus = new PatientICPPhaseStatusVo();
	// Populate values to status
	phaseStatus.setStatusDate(new DateTime());
	phaseStatus.setChangedBy(mos.getIMosName());
	phaseStatus.setStatus(ICPPhaseStatus.NOTINSCOPE);
	
	// Set status to phase
	phase.setCurrentStatus(phaseStatus);
	phase.getStatusHistory().add(phaseStatus);
	
	// Iterate phase actions
	for (PatientICPAction_StatusChangeVo action : phase.getPhaseActions())
	{
		action = prepareActionToRemoveFromScope(action, mos);
	}
	
	return phase;
}
 

import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
private void populatePatientICPPhase(PatientICPPhase_StatusChangeVo phase)
{
	// Check phase parameter
	if (phase == null)
		return;
	
	// Get node from tree
	TreeNode phaseNode = form.treICP().getNodeByValue(phase.getPhase());
	
	if (phaseNode == null)
		throw new CodingRuntimeException("Error");
	
	// Update node identifier
	phaseNode.setIdentifier(phase);
	
	
	// Determine if the node should still be selectable
	if (engine.getFormName().equals(form.getForms().ICP.BringPhaseIntoScope))
	{
		if (ICPPhaseStatus.INPROGRESS.equals(phase.getCurrentStatus().getStatus()))
		{
			phaseNode.setCheckBoxVisible(false);
		}
	}
	
	// Populate Patient ICP Actions
	for (PatientICPAction_StatusChangeVo action : phase.getPhaseActions())
	{
		populatePatientICPAction(action);
	}
}
 

import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void markPhaseAsInProgress(PatientICPPhase phase)
{
	if (phase == null)
		return;
	
	// Create a Phase status VO
	PatientICPPhaseStatusVo status = new PatientICPPhaseStatusVo();
	status.setChangedBy("");
	status.setStatus(ICPPhaseStatus.INPROGRESS);
	status.setStatusDate(new DateTime());
	
	DomainFactory factory = getDomainFactory();
	
	// Extract the BO from status VO
	PatientICPPhaseStatus statusDOM = PatientICPPhaseStatusVoAssembler.extractPatientICPPhaseStatus(factory, status);
	
	// Set phase status to status BO
	phase.setCurrentStatus(statusDOM);
	// Add status BO to status history 
	phase.getStatusHistory().add(statusDOM);
	
	// Mark phase actions as OUTSTANDING
	if (phase.getPhaseActions() != null)
	{
		Iterator<PatientICPAction> iteratorActions = phase.getPhaseActions().iterator();
		
		while (iteratorActions.hasNext())
		{
			PatientICPAction action = iteratorActions.next();
			
			markActionAsOutstanding(action);
		}
	}
}
 

import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
/**
 * Function used to populate a Patient ICP Phase to a row
 */
protected void populateICPPhase(PatientICPPhase_PresentationVo phase, HcpDisType discipline, DynamicGridRow stageRow)
{
	// Check if phase not to be outside of scope
	if (phase == null || ICPPhaseStatus.NOTINSCOPE.equals(phase.getCurrentStatus().getStatus()))
		return;
	
	// Create phase row
	DynamicGridRow phaseRow = stageRow.getRows().newRow();
	
	// Set row attributes
	phaseRow.setSelectable(true);
	
	phaseRow.setCollapsedImage(form.getImages().ICP.Phase);
	phaseRow.setExpandedImage(form.getImages().ICP.Phase);
	
	// Fill in row cells
	DynamicGridCell cell = phaseRow.getCells().newCell(form.dyngrdICP().getColumns().getByIdentifier(COL_PRESENTATION), DynamicCellType.STRING);
	cell.setValue(phase.getPhase().getName());
	cell.setWidth(300);
	cell.setReadOnly(true);
	
   		// If phase has goals defined then display them as a tooltip
   		if (phase.getPhase().getGoalsIsNotNull() && phase.getPhase().getGoals().size() > 0)
   		{
   			cell.setTooltip(buildPhaseGoalsString(phase));
   		}
	
	if (phase.getPhase().getHelpURLIsNotNull() && phase.getPhase().getHelpURL().length() > 0)
	{
		cell = phaseRow.getCells().newCell(form.dyngrdICP().getColumns().getByIdentifier(COL_HELP), DynamicCellType.IMAGEBUTTON);
		cell.setValue(form.getImages().Core.InfoEnabled16);
		cell.setTooltip(phase.getPhase().getHelpURL());
		cell.setWidth(25);
		cell.setAutoPostBack(true);
	}
	
	// Set row value
	phaseRow.setValue(phase);
	
	
	if (phase.getActions() == null)
		return;
	
	phase.getActions().sort(new ActionsComparator());
	
	// Populate phase's Patient ICP Actions
	for (PatientICPAction_PresentationVo action : phase.getActions())
	{
		populateICPAction(action, discipline, phaseRow);
	}
	
	// Expand phase row
	phaseRow.setExpanded(true);
}
 

import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
private void updatePatientICPPhase(grdActionsRow row, PatientICPPhasesLiteVo phase)
	{
		// Check row
		if (row == null)
			throw new CodingRuntimeException("Major Logical Error - Can not populate null row (in function updatePatientICPPhase");
		
		// Check phase
		if (phase == null)
			return;
		
		// Update phase name
		row.setColAction(phase.getPhaseIsNotNull() ? phase.getPhase().getName() : "");
		
		// Update row value
		row.setValue(phase);
		
		// Update images
		row.setExpandedImage(form.getImages().ICP.Phase);
		row.setCollapsedImage(form.getImages().ICP.Phase);
		
		// Update row as selectable, read-only
		row.setReadOnly(true);
		row.setSelectable(ICPPhaseStatus.NOTINSCOPE.equals(phase.getCurrentStatusIsNotNull() ? phase.getCurrentStatus().getStatus() : null) 
//				&& !PreActiveActiveInactiveStatus.INACTIVE.equals(phase.getPhaseIsNotNull() ? phase.getPhase().getStatus() : null) 
				&& "P".equalsIgnoreCase(form.getGlobalContext().ICP.getTypeToSelect()));
		
		// Update colors
		row.setBackColor(null);
		row.setTextColor(PreActiveActiveInactiveStatus.INACTIVE.equals(phase.getPhaseIsNotNull() ? phase.getPhase().getStatus() : null) ? Color.Gray : Color.Black);
		
		// Test the actions
		if (phase.getPhaseActionsIsNotNull())
		{
			// Sort the actions
			phase.getPhaseActions().sort(new ActionComparator());
			
			// Iterate actions
			for (PatientICPActionLiteVo action : phase.getPhaseActions())
			{
				if (action == null)
					continue;
				
				// Update action row
				grdActionsRow actionRow = form.grdActions().getRowByValue(action.getAction());
				
				if (actionRow == null)
				{
					actionRow = row.getRows().newRow();
				}
				
				updatePatientICPAction(actionRow, action);
			}
		}
	}
 

import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
private PatientICPPhase_CreationVo createPatientICPPhase(ICPPhaseConfiguration_CreateVo phaseConfig, PatientICP_CreationVo patientICP, PatientICPStage_CreationVo parentStage, HcpLiteVo hcp)
{
	// Check mandatory parameters
	if (phaseConfig == null)
		throw new CodingRuntimeException("A configuration ICP Phase must be provided for creating a Patient ICP Phase record.");
	
	if (patientICP == null)
		throw new CodingRuntimeException("Patient ICP is a mandatory parameter in creation process for a Patient ICP Phase record.");
	
	if (parentStage == null)
		throw new CodingRuntimeException("Parent Stage is a mandatory parameter in creation process for a Patient ICP Phase record.");
		
	if (hcp == null)
		throw new CodingRuntimeException("HCP is a mandatory parameter in creation process for a Patient ICP Phase record.");
	
	
	// Create Patient ICP Phase record
	PatientICPPhase_CreationVo patientPhase = new PatientICPPhase_CreationVo();
	
	// Set values into Patient ICP Phase record
	patientPhase.setPatient(patientICP.getPatient());
	patientPhase.setCareContext(patientICP.getCareContext());
	patientPhase.setICP(patientICP);
	patientPhase.setParentStage(parentStage);
	patientPhase.setPhase(phaseConfig);
	
	
	// Create & set Patient ICP Phase status & status history
	PatientICPPhaseStatusVo status = new PatientICPPhaseStatusVo();
	
	status.setStatusDate(new DateTime());
	status.setChangedBy(hcp.getIHcpName());
	
	if (Boolean.TRUE.equals(phaseConfig.getIsActivatedOnInitiation()) && ICPStageStatus.OUTSTANDING.equals(parentStage.getCurrentStatus().getStatus()))
	{
		status.setStatus(ICPPhaseStatus.INPROGRESS);
	}
	else
	{
		status.setStatus(ICPPhaseStatus.NOTINSCOPE);
	}
	
	patientPhase.setCurrentStatus(status);
	patientPhase.setStatusHistory(new PatientICPPhaseStatusVoCollection());
	patientPhase.getStatusHistory().add(status);
	
	
	// Start actions creation process
	if (phaseConfig.getActionsIsNotNull())
	{
		patientPhase.setPhaseActions(new PatientICPAction_CreationVoCollection());
		
		for (ICPActionConfiguration_CreateVo action : phaseConfig.getActions())
		{
			if (PreActiveActiveInactiveStatus.ACTIVE.equals(action.getStatus()))
			{
				patientPhase.getPhaseActions().add(createPatientICPAction(action, patientICP, patientPhase, parentStage, hcp));
			}
		}
	}
	
	// Return Patient ICP Phase
	return patientPhase;
}
 

import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
private PatientICPAction_CreationVo createPatientICPAction(ICPActionConfiguration_CreateVo actionConfig, PatientICP_CreationVo patientICP, PatientICPPhase_CreationVo parentPhase, PatientICPStage_CreationVo parentStage, HcpLiteVo hcp)
{
	// Check mandatory parameters
	if (actionConfig == null)
		throw new CodingRuntimeException("A configuration ICP Action must be provided for creating a Patient ICP Action record.");
	
	if (patientICP == null)
		throw new CodingRuntimeException("Patient ICP is a mandatory parameter in creation process for a Patient ICP Action record.");
	
	if (parentPhase == null)
		throw new CodingRuntimeException("Parent Phase is a mandatory parameter in creation process for a Patient ICP Action record.");
	
	if (hcp == null)
		throw new CodingRuntimeException("HCP is a mandatory parameter in creation process for a Patient ICP Action record.");

	
	// Create Patient ICP Action record
	PatientICPAction_CreationVo patientAction = new PatientICPAction_CreationVo();
	
	// Set values into Patient ICP Action record
	patientAction.setPatient(patientICP.getPatient());
	patientAction.setCareContext(patientICP.getCareContext());
	patientAction.setICP(patientICP);
	patientAction.setParentPhase(parentPhase);
	
	patientAction.setAction(actionConfig);
	
	// Create & set Patient ICP Action status & history
	PatientICPActionStatusVo status = new PatientICPActionStatusVo();
	
	status.setStatusDate(new DateTime());
	status.setChangedBy(hcp.getMos());
	
	if (ICPStageStatus.OUTSTANDING.equals(parentStage.getCurrentStatus().getStatus()) && ICPPhaseStatus.INPROGRESS.equals(parentPhase.getCurrentStatus().getStatus()))
	{
		status.setStatus(ICPActionStatus.OUTSTANDING);
	}
	else
	{
		status.setStatus(ICPActionStatus.NOTINSCOPE);
	}
	
		
	patientAction.setCurrentStatus(status);
	patientAction.setStatusHistory(new PatientICPActionStatusVoCollection());
	patientAction.getStatusHistory().add(status);
	
	
	// Update outstanding disciplines in Patient ICP
	if (actionConfig.getDisciplineIsNotNull() && ICPActionStatus.OUTSTANDING.equals(status.getStatus()))
	{
		if (actionConfig.getDiscipline().contains(HcpDisType.OTHER))
			patientICP.setHasOutstandingAdminActions(Boolean.TRUE);
		
		if (actionConfig.getDiscipline().contains(HcpDisType.MEDICAL))
			patientICP.setHasOutstandingClinicalActions(Boolean.TRUE);
		
		if (actionConfig.getDiscipline().contains(HcpDisType.NURSING))
			patientICP.setHasOutstandingNursingActions(Boolean.TRUE);
		
		if (actionConfig.getDiscipline().contains(HcpDisType.THERAPY))
			patientICP.setHasOutstandingPhysioActions(Boolean.TRUE);
	}
	
	// Return Patient ICP Action
	return patientAction;
}
 

import ims.icp.vo.lookups.ICPPhaseStatus; //导入依赖的package包/类
/**
 * Function used to update the Outstanding Disciplines
 */
private void updatePatientICPOutstandingDisciplines(PatientICP_PresentationVo patientICP, PatientICPStageRefVo stage, PatientICPPhaseRefVo phase) throws StaleObjectException
{
	patientICP.setHasOutstandingAdminActions(Boolean.FALSE);
	patientICP.setHasOutstandingClinicalActions(Boolean.FALSE);
	patientICP.setHasOutstandingNursingActions(Boolean.FALSE);
	patientICP.setHasOutstandingPhysioActions(Boolean.FALSE);
	
	
	for (PatientICPStage_PresentationVo patientStage : patientICP.getStages())
	{
		if (stage != null && patientStage.getID_PatientICPStage().equals(stage.getID_PatientICPStage()))
			continue;
		
		if (ICPStageStatus.OUTSTANDING.equals(patientStage.getCurrentStatus().getStatus()))
		{
			for (PatientICPPhase_PresentationVo patientPhase : patientStage.getPhases())
			{
				if (phase != null && patientPhase.getID_PatientICPPhase().equals(phase.getID_PatientICPPhase()))
					continue;
				
				if (ICPPhaseStatus.INPROGRESS.equals(patientPhase.getCurrentStatus().getStatus()))
				{
					for (PatientICPAction_PresentationVo action : patientPhase.getActions())
					{
						if (ICPActionStatus.OUTSTANDING.equals(action.getCurrentStatus().getStatus()))
						{
							if (action.getAction().getDiscipline().contains(HcpDisType.MEDICAL))
								patientICP.setHasOutstandingClinicalActions(Boolean.TRUE);
							
							if (action.getAction().getDiscipline().contains(HcpDisType.NURSING))
								patientICP.setHasOutstandingNursingActions(Boolean.TRUE);
							
							if (action.getAction().getDiscipline().contains(HcpDisType.THERAPY))
								patientICP.setHasOutstandingPhysioActions(Boolean.TRUE);
							
							if (action.getAction().getDiscipline().contains(HcpDisType.OTHER))
								patientICP.setHasOutstandingAdminActions(Boolean.TRUE);
						}
					}
				}
			}
		}
	}
	
	getDomainFactory().save(PatientICP_PresentationVoAssembler.extractPatientICP(getDomainFactory(), patientICP));
}