//public ChangeVerifyCodeData ChangeVerifyCode(ChangeVerifyCodeData changeVerifyCodeData)
//{
// if (this.broker != null)
// {
// XusCvcCommand cvcCommand = new XusCvcCommand(this.broker, changeVerifyCodeData.OriginalVerifyCode, changeVerifyCodeData.NewVerifyCode, changeVerifyCodeData.ConfirmVerifyCode);
// cvcCommand.Execute();
// if (cvcCommand.Response.Status == ResponseStatus.Success)
// changeVerifyCodeData.SetLastOperation(true, cvcCommand.Response.InformationalMessage);
// else
// changeVerifyCodeData.SetLastOperation(false, cvcCommand.Response.InformationalMessage);
// }
// else
// changeVerifyCodeData.SetLastOperation(false, "No valid connection");
// return changeVerifyCodeData;
//}
public BrokerOperationResult ChangeVerifyCode(ChangeVerifyCode changeVerifyCodeData)
{
BrokerOperationResult returnResult = new BrokerOperationResult();
if (this.broker != null)
{
XusCvcCommand cvcCommand = new XusCvcCommand(this.broker);
// *** Make sure everything is upper case ***
changeVerifyCodeData.OriginalVerifyCode = changeVerifyCodeData.OriginalVerifyCode.ToUpper().Trim();
changeVerifyCodeData.NewVerifyCode = changeVerifyCodeData.NewVerifyCode.ToUpper().Trim();
changeVerifyCodeData.ConfirmVerifyCode = changeVerifyCodeData.ConfirmVerifyCode.ToUpper().Trim();
cvcCommand.AddCommandArguments(changeVerifyCodeData.OriginalVerifyCode, changeVerifyCodeData.NewVerifyCode, changeVerifyCodeData.ConfirmVerifyCode);
RpcResponse response = cvcCommand.Execute();
if (response.Status == RpcResponseStatus.Success)
{
returnResult.SetResult(true, cvcCommand.Response.InformationalMessage);
}
else
{
string message = string.IsNullOrWhiteSpace(cvcCommand.Response.InformationalMessage) ? "An unspecified error has occurred" : cvcCommand.Response.InformationalMessage;
returnResult.SetResult(false, message);
}
}
else
{
returnResult.SetResult(false, "No valid connection");
}
return(returnResult);
}
public static BrokerOperationResult UpdateNextDates(IDashboardRepository repo, string patientDfn, string pregnancyIen)
{
BrokerOperationResult result = new BrokerOperationResult();
// *** First get the pregnancy ***
PregnancyListResult pregResult = repo.Pregnancy.GetPregnancies(patientDfn, pregnancyIen);
result.SetResult(pregResult.Success, pregResult.Message);
if (pregResult.Success)
{
if (pregResult.Pregnancies != null)
{
if (pregResult.Pregnancies.Count > 0)
{
// *** Get the checklist items ***
PregnancyChecklistItemsResult getResult = GetSortedPregnancyChecklist(repo, patientDfn, pregResult.Pregnancies[0], DsioChecklistCompletionStatus.NotComplete);
result.SetResult(getResult.Success, getResult.Message);
if (result.Success)
{
if (getResult.Items != null)
{
if (getResult.Items.Count > 0)
{
// *** Find the next due ***
DateTime nextChecklistDue = getResult.Items[0].DueDate;
// *** Save next checklist observation ***
result = repo.Observations.UpdateNextChecklistDue(patientDfn, nextChecklistDue);
if (result.Success)
{
// *** Find next contact due ***
DateTime nextContactDue = DateTime.MinValue;
foreach (PregnancyChecklistItem item in getResult.Items)
{
if (item.ItemType == DsioChecklistItemType.MccCall)
{
nextContactDue = item.DueDate;
break;
}
}
result = repo.Observations.UpdateNextContactDue(patientDfn, nextContactDue);
}
}
}
}
}
}
}
return(result);
}
public static BrokerOperationResult CompleteEducationItem(IDashboardRepository repo, string patientDfn, string educationItemIen, string checklistItemIen)
{
BrokerOperationResult returnResult = new BrokerOperationResult();
// *** Two-step process:
// *** (1) Create completed patient education item
// *** (2) Complete the checklist item
PatientEducationItem patItem = new PatientEducationItem()
{
PatientDfn = patientDfn,
EducationItemIen = educationItemIen,
CompletedOn = DateTime.Now
};
IenResult saveResult = repo.Education.SavePatientItem(patItem);
returnResult.SetResult(saveResult.Success, saveResult.Message);
if (saveResult.Success)
{
PregnancyChecklistItemsResult result = repo.Checklist.GetPregnancyItems(patientDfn, "", checklistItemIen);
returnResult.SetResult(result.Success, result.Message);
if (result.Success)
{
if (result.Items != null)
{
if (result.Items.Count > 0)
{
PregnancyChecklistItem checkItem = result.Items[0];
checkItem.CompletionStatus = DsioChecklistCompletionStatus.Complete;
checkItem.CompletionLink = saveResult.Ien;
IenResult ienResult = repo.Checklist.SavePregnancyItem(checkItem);
returnResult.SetResult(ienResult.Success, ienResult.Message);
if (returnResult.Success)
{
returnResult = UpdateNextDates(repo, patientDfn, checkItem.PregnancyIen);
if (returnResult.Success)
{
returnResult.Message = "Education item completed";
}
}
}
}
}
}
return(returnResult);
}
public BrokerOperationResult TestServerConnection(string serverName, string serverPort)
{
BrokerOperationResult returnResult = new BrokerOperationResult();
int port = 0;
if (int.TryParse(serverPort, out port))
{
//using (RpcBroker broker = new RpcBroker(serverName, port))
ServerConfig config = new ServerConfig()
{
ServerName = serverName, ListenerPort = port
};
IRpcBroker broker = RpcBrokerUtility.GetNewConnectedRpcBroker(config);
if (broker != null)
{
returnResult.SetResult(true, "");
broker.Disconnect();
}
}
return(returnResult);
}
public BrokerOperationResult LoadDefaultChecklist()
{
BrokerOperationResult returnResult = new BrokerOperationResult();
// *** Create a serializer ***
XmlSerializer serializer = new XmlSerializer(typeof(List <DsioChecklistItem>));
// *** Get the full name of the source file ***
string fullName = Path.Combine(this.ContentPath, this.DefaultChecklistFileName);
// *** Create a reader ***
using (XmlReader reader = XmlReader.Create(fullName))
{
// *** Deserialize It ***
var list = serializer.Deserialize(reader);
// *** Get list ***
List <DsioChecklistItem> checklistItems = (List <DsioChecklistItem>)list;
// *** Process if we have any ***
if (checklistItems.Count > 0)
{
// *** Create the command ***
DsioSaveMccChecklistCommand command = new DsioSaveMccChecklistCommand(this.broker);
// *** Declare response ***
RpcResponse response = null;
// *** Loop ***
foreach (DsioChecklistItem item in checklistItems)
{
// *** Don't re-use IEN ***
item.Ien = "";
// *** Add the arguments ***
command.AddCommandArguments(item);
// *** Execute ***
response = command.Execute();
// *** If not successful, stop ***
if (response.Status != RpcResponseStatus.Success)
{
break;
}
}
// *** Add result ***
if (response != null)
{
returnResult.SetResult(response.Status == RpcResponseStatus.Success, response.InformationalMessage);
}
}
}
return(returnResult);
}
public BrokerOperationResult SetServerData(ServerConfig serverConfig)
{
BrokerOperationResult returnResult = new BrokerOperationResult();
ConfigurationManager.AppSettings["vistaServer"] = serverConfig.ServerName;
ConfigurationManager.AppSettings["vistaListenerPort"] = serverConfig.ListenerPort.ToString();
returnResult.SetResult(true, "");
return(returnResult);
}
public BrokerOperationResult Select(string divId)
{
BrokerOperationResult returnVal = new BrokerOperationResult();
if (this.broker != null)
{
XusDivisionSetCommand command = new XusDivisionSetCommand(this.broker, divId);
command.Execute();
returnVal.SetResult((command.Response.Status == RpcResponseStatus.Success), "");
}
return(returnVal);
}
/// <summary>
/// Keeps connection to VistA active
/// </summary>
/// <returns></returns>
public BrokerOperationResult ImHere()
{
BrokerOperationResult result = new BrokerOperationResult();
// *** Create the command ***
XwbImHereCommand command = new XwbImHereCommand(this.broker);
// *** Execute ***
RpcResponse response = command.Execute();
// *** Put the comamnd response into the result ***
result.SetResult(response.Status == RpcResponseStatus.Success, response.InformationalMessage);
return(result);
}
public BrokerOperationResult DeleteEducationItem(string ien)
{
BrokerOperationResult result = new BrokerOperationResult();
if (this.broker != null)
{
DsioDeleteEducationItemCommand command = new DsioDeleteEducationItemCommand(this.broker);
command.AddCommandArguments(ien);
RpcResponse response = command.Execute();
result.SetResult(response.Status == RpcResponseStatus.Success, response.InformationalMessage);
}
return(result);
}
private BrokerOperationResult CallSaveRpc(string dfn, Dictionary <string, string> newValues)
{
BrokerOperationResult returnResult = new BrokerOperationResult();
DsioSetPatientInformationCommand command = new DsioSetPatientInformationCommand(this.broker);
foreach (string key in newValues.Keys)
{
command.AddCommandArguments(dfn, key, newValues[key]);
RpcResponse response = command.Execute();
returnResult.SetResult(response.Status == RpcResponseStatus.Success, response.InformationalMessage);
if (!returnResult.Success)
{
break;
}
}
return(returnResult);
}
public BrokerOperationResult AddDefaultPregnancyItems(string dfn, string pregIen)
{
BrokerOperationResult result = new BrokerOperationResult();
ChecklistItemsResult getResult = this.GetItems("", 1, 1000);
if (string.IsNullOrWhiteSpace(dfn))
{
result.Message = "The patient could not be identified";
}
else
{
if (string.IsNullOrWhiteSpace(pregIen))
{
result.Message = "The pregnancy could not be identified";
}
else
{
if (!getResult.Success)
{
result.SetResult(getResult.Success, getResult.Message);
}
else
{
if (getResult.Items != null)
{
if (getResult.Items.Count == 0)
{
result.SetResult(false, "There are no default checklist items to add");
}
else
{
foreach (ChecklistItem item in getResult.Items)
{
PregnancyChecklistItem patItem = new PregnancyChecklistItem(item);
patItem.PatientDfn = dfn;
patItem.PregnancyIen = pregIen;
patItem.CompletionStatus = DsioChecklistCompletionStatus.NotComplete;
patItem.Ien = "";
if (item.DueCalculationType == DsioChecklistCalculationType.Initial)
{
patItem.SpecificDueDate = DateTime.Now;
}
IenResult saveResult = this.SavePregnancyItem(patItem);
if (!saveResult.Success)
{
result.SetResult(saveResult.Success, saveResult.Message);
break;
}
else
{
result.SetResult(saveResult.Success, saveResult.Message);
}
}
}
}
}
}
}
return(result);
}
