private void UpdateDependentParameterName(List <StoredQueryParameter> lstStoredQueryParameterRequest, List <StoredQueryParameter> lstStoredQueryParameterDB)
{
List <StoredQueryParameter> lstParamWithDependencyDB = null;
StoredQueryParameter parameterMatchingRequest = null;
lstParamWithDependencyDB = GetAllParametersWithDependency(lstStoredQueryParameterDB);
if ((lstParamWithDependencyDB != null) && (lstParamWithDependencyDB.Count > 0))
{
for (int count = 0; count < lstParamWithDependencyDB.Count; count++)
{
parameterMatchingRequest = lstStoredQueryParameterRequest.Find(
delegate(StoredQueryParameter param)
{
if (param.ParameterName == lstParamWithDependencyDB[count].ParameterName)
{
return(true);
}
return(false);
}
);
if (parameterMatchingRequest != null)
{
parameterMatchingRequest.DependentParameterName = lstParamWithDependencyDB[count].DependentParameterName;
}
}
}
}
protected virtual string GetParameterValue(List <StoredQueryParameter> lstStoredQueryParameter, string parameterName)
{
string paramValue = null;
StoredQueryParameter objQueryParameter = null;
if (lstStoredQueryParameter != null)
{
objQueryParameter = lstStoredQueryParameter.Find(
delegate(StoredQueryParameter objStoredQueryParameter)
{
if (objStoredQueryParameter.ParameterName == parameterName)
{
return(true);
}
return(false);
}
);
if (objQueryParameter != null)
{
paramValue = objQueryParameter.ParameterValue;
}
}
return(paramValue);
}
private bool IsValidDependentParameterValueCount(List <StoredQueryParameter> lstStoredQueryParameterRequest, out string parameterName, out string dependentParameterName)
{
//Validate whether dependent parameter's value count is equal
bool isValid = true;
List <StoredQueryParameter> lstParamWithDependencyRequest = null;
StoredQueryParameter parameterMatchingRequest = null;
string[] arrParamValues = null;
string[] arrDependentParamValues = null;
parameterName = string.Empty;
dependentParameterName = string.Empty;
lstParamWithDependencyRequest = GetAllParametersWithDependency(lstStoredQueryParameterRequest);
if ((lstParamWithDependencyRequest != null) && (lstParamWithDependencyRequest.Count > 0))
{
for (int count = 0; count < lstParamWithDependencyRequest.Count; count++)
{
parameterMatchingRequest = lstStoredQueryParameterRequest.Find(
delegate(StoredQueryParameter param)
{
if (param.ParameterName == lstParamWithDependencyRequest[count].DependentParameterName)
{
return(true);
}
return(false);
}
);
if (parameterMatchingRequest != null)
{
arrParamValues = lstParamWithDependencyRequest[count].ParameterValue.Split(',');
arrDependentParamValues = parameterMatchingRequest.ParameterValue.Split(',');
if (arrParamValues.Length != arrDependentParamValues.Length)
{
isValid = false;
parameterName = lstParamWithDependencyRequest[count].ParameterName;
dependentParameterName = parameterMatchingRequest.ParameterName;
break;
}
}
}
}
return(isValid);
}
private bool IsValidDependentParameterExists(List <StoredQueryParameter> lstStoredQueryParameterRequest, out string parameterName, out string dependentParameterName)
{
//Validate whether dependent parameter exists in the request
bool isValid = true;
List <StoredQueryParameter> lstParamWithDependencyRequest = null;
StoredQueryParameter parameterMatchingRequest = null;
parameterName = string.Empty;
dependentParameterName = string.Empty;
lstParamWithDependencyRequest = GetAllParametersWithDependency(lstStoredQueryParameterRequest);
if ((lstParamWithDependencyRequest != null) && (lstParamWithDependencyRequest.Count > 0))
{
for (int count = 0; count < lstParamWithDependencyRequest.Count; count++)
{
if (!lstStoredQueryParameterRequest.Exists(
delegate(StoredQueryParameter param)
{
if (param.ParameterName == lstParamWithDependencyRequest[count].DependentParameterName)
{
return(true);
}
return(false);
}
))
{
isValid = false;
parameterName = lstParamWithDependencyRequest[count].ParameterName;
dependentParameterName = lstParamWithDependencyRequest[count].DependentParameterName;
break;
}
}
}
return(isValid);
}
private string GetDependentParameterName(List <StoredQueryParameter> lstStoredQueryParameter, string paramName)
{
string dependentParameterName = null;
StoredQueryParameter storedQueryParam = null;
storedQueryParam = lstStoredQueryParameter.Find(
delegate(StoredQueryParameter parameter)
{
if (parameter.ParameterName == paramName)
{
return(true);
}
return(false);
}
);
if (storedQueryParam != null)
{
dependentParameterName = storedQueryParam.DependentParameterName;
}
return(dependentParameterName);
}
public XmlDocument RegistryStoredQuery(XmlDocument xmlDocRequest, out StringDictionary atnaParameterValues)
{
XmlDocument xmlDocResponse = null;
StoredQuery objStoredQueryRequest = null;
StoredQuery objStoredQueryDB = null;
StoredQueryBase objStoredQuery = null;
string parameterName = null;
string dependentParameterName = null;
string eventOutcomeIndicator = "0";
atnaParameterValues = new StringDictionary();
try
{
//Construct the Request Stored Query Object
objStoredQueryRequest = StoredQueryBase.ConstructStoredQuery(xmlDocRequest);
//-------------------------------------------------------------------------------------
//ATNA
StoredQueryParameter queryParamPatientID = objStoredQueryRequest.ParameterList.Find(
delegate(StoredQueryParameter queryParameter)
{
if (queryParameter != null && queryParameter.ParameterName != null && queryParameter.ParameterName == "$XDSDocumentEntryPatientId")
{
return(true);
}
return(false);
}
);
if (queryParamPatientID != null)
{
atnaParameterValues.Add("$XDSPatient$", queryParamPatientID.ParameterValue);
}
XmlNode nodeAdhocQuery = xmlDocRequest.SelectSingleNode(@"//*[local-name()='AdhocQuery']");
if (nodeAdhocQuery != null)
{
atnaParameterValues.Add("$AdhocQuery$", nodeAdhocQuery.OuterXml);
}
//-------------------------------------------------------------------------------------
objStoredQueryDB = GetStoredQueryDetails(objStoredQueryRequest.StoredQueryUniqueID, objStoredQueryRequest.ReturnType);
#region "***********Validations****************"
if (objStoredQueryDB == null)
{
eventOutcomeIndicator = "8";
atnaParameterValues.Add("$EventIdentification.EventOutcomeIndicator$", eventOutcomeIndicator);
//Invalid Query ID
xmlDocResponse = StoredQueryBase.ConstructStoredQueryErrorResponse(GlobalValues.CONST_RESPONSE_STATUS_TYPE_FAILURE, string.Empty, "Invalid query id.", GlobalValues.CONST_REGISTRYERROR_CODE_XDSRegistryError, GlobalValues.CONST_SEVERITY_TYPE_ERROR, string.Empty);
return(xmlDocResponse);
}
//Update the Request Parameters with Dependent Parameters
UpdateDependentParameterName(objStoredQueryRequest.ParameterList, objStoredQueryDB.ParameterList);
//Validate Repeating Parameter
if (IsParameterRepeated(objStoredQueryRequest.ParameterList))
{
eventOutcomeIndicator = "8";
atnaParameterValues.Add("$EventIdentification.EventOutcomeIndicator$", eventOutcomeIndicator);
//Parameter Repeating
xmlDocResponse = StoredQueryBase.ConstructStoredQueryErrorResponse(GlobalValues.CONST_RESPONSE_STATUS_TYPE_FAILURE, string.Empty, "Repeating parameter.", GlobalValues.CONST_REGISTRYERROR_CODE_XDSRegistryError, GlobalValues.CONST_SEVERITY_TYPE_ERROR, string.Empty);
return(xmlDocResponse);
}
//Parameter Validation
if (!IsRequiredQueryParameterExists(objStoredQueryRequest.ParameterList, objStoredQueryDB.ParameterList))
{
eventOutcomeIndicator = "8";
atnaParameterValues.Add("$EventIdentification.EventOutcomeIndicator$", eventOutcomeIndicator);
//Required Parameter Missing
xmlDocResponse = StoredQueryBase.ConstructStoredQueryErrorResponse(GlobalValues.CONST_RESPONSE_STATUS_TYPE_FAILURE, string.Empty, "Required parameter missing.", GlobalValues.CONST_REGISTRYERROR_CODE_XDSRegistryError, GlobalValues.CONST_SEVERITY_TYPE_ERROR, string.Empty);
return(xmlDocResponse);
}
//Validate Dependent Parameter
if (!IsValidDependentParameterExists(objStoredQueryRequest.ParameterList, out parameterName, out dependentParameterName))
{
eventOutcomeIndicator = "8";
atnaParameterValues.Add("$EventIdentification.EventOutcomeIndicator$", eventOutcomeIndicator);
//Required Parameter Missing
xmlDocResponse = StoredQueryBase.ConstructStoredQueryErrorResponse(GlobalValues.CONST_RESPONSE_STATUS_TYPE_FAILURE, string.Empty, string.Format("{0} parameter is specified but corresponding {1} parameter is not specified.", parameterName, dependentParameterName), GlobalValues.CONST_REGISTRYERROR_CODE_XDSRegistryError, GlobalValues.CONST_SEVERITY_TYPE_ERROR, string.Empty);
return(xmlDocResponse);
}
//Validate Dependent Parameter Value Count
if (!IsValidDependentParameterValueCount(objStoredQueryRequest.ParameterList, out parameterName, out dependentParameterName))
{
eventOutcomeIndicator = "8";
atnaParameterValues.Add("$EventIdentification.EventOutcomeIndicator$", eventOutcomeIndicator);
//Required Parameter Missing
xmlDocResponse = StoredQueryBase.ConstructStoredQueryErrorResponse(GlobalValues.CONST_RESPONSE_STATUS_TYPE_FAILURE, string.Empty, string.Format("{0} parameter values does not have equivalent number of values in {1} parameter.", parameterName, dependentParameterName), GlobalValues.CONST_REGISTRYERROR_CODE_XDSRegistryError, GlobalValues.CONST_SEVERITY_TYPE_ERROR, string.Empty);
return(xmlDocResponse);
}
#endregion
//Merge the StoredQuery Request & DB details
//we are left with only one StoredQuery Object with all the params & it's values
objStoredQueryRequest = StoredQueryBase.UpdateParameterValues(objStoredQueryRequest, objStoredQueryDB);
//Create concrete StoredQuery object based on query name
objStoredQuery = StoredQueryBase.GetStoredQueryObject(objStoredQueryRequest.StoredQueryName);
//Process Message & Construct Response Accordingly
xmlDocResponse = objStoredQuery.ProcessQuery(objStoredQueryRequest);
}
catch
{
//Return Error Response
xmlDocResponse = StoredQueryBase.ConstructStoredQueryErrorResponse(GlobalValues.CONST_RESPONSE_STATUS_TYPE_FAILURE, string.Empty, "Unexpected Registry Error.", GlobalValues.CONST_REGISTRYERROR_CODE_XDSRegistryError, GlobalValues.CONST_SEVERITY_TYPE_ERROR, string.Empty);
eventOutcomeIndicator = "8";
}
atnaParameterValues.Add("$EventIdentification.EventOutcomeIndicator$", eventOutcomeIndicator);
return(xmlDocResponse);
}
public static StoredQuery ConstructStoredQuery(XmlDocument xmlDoc)
{
StoredQuery objStoredQuery = new StoredQuery();
StoredQueryParameter objParameter = null;
string returnComposedObjects = null;
//ResponseOption
XmlNode xmlNodeResponseOption = xmlDoc.SelectSingleNode(@"//*[local-name()='ResponseOption']");
//returnComposedObjects
if (xmlNodeResponseOption.Attributes["returnComposedObjects"] != null)
{
returnComposedObjects = xmlNodeResponseOption.Attributes["returnComposedObjects"].Value;
}
if ((!string.IsNullOrEmpty(returnComposedObjects)) && returnComposedObjects == "true")
{
objStoredQuery.ReturnComposedObjects = true;
}
//returnType
objStoredQuery.ReturnType = xmlNodeResponseOption.Attributes["returnType"].Value;
//AdhocQuery
XmlNode xmlNodeAdhocQuery = xmlDoc.SelectSingleNode(@"//*[local-name()='AdhocQuery']");
objStoredQuery.StoredQueryUniqueID = xmlNodeAdhocQuery.Attributes["id"].Value;
//Slot
XmlNodeList xmlNodeListSlot = xmlDoc.SelectNodes(@"//*[local-name()='Slot']");
//Looping through the Slots
for (int iSlotCount = 0; iSlotCount < xmlNodeListSlot.Count; iSlotCount++)
{
objParameter = new StoredQueryParameter();
//name
objParameter.ParameterName = xmlNodeListSlot[iSlotCount].Attributes["name"].Value;
//ValueList
if (xmlNodeListSlot[iSlotCount].HasChildNodes)
{
foreach (XmlNode node in xmlNodeListSlot[iSlotCount].ChildNodes)
{
if ((node.NodeType == XmlNodeType.Element) && (node.LocalName == "ValueList"))
{
//Value
//Only 1 Value will exist at any given point in time
//Although the node is ValueList with multiple possible Value node
//But the request will contain ('some_value','some_value') for multiple values
if (node.ChildNodes.Count > 0)
{
objParameter.ParameterValue = node.ChildNodes[0].InnerText;
}
}
}
}
//Adding Parameter to the collection
objStoredQuery.ParameterList.Add(objParameter);
}
return(objStoredQuery);
}
