public void Clearinghouses_UpdateOverridesForClinic_UpdateAllDuplicateOverrideRows()
{
string methodName = MethodBase.GetCurrentMethod().Name;
Clinic clinic = ClinicT.CreateClinic(methodName);
//Insert a default clearinghouse that is not associated to any clinics. This will be used as the "HqClearinghouseNum" for creating duplicate overrides later.
Clearinghouse clearinghouseHQ = ClearinghouseT.CreateClearinghouse(methodName);
//Insert two blank Clearinghouse override rows associated to the same clinic into the DB to mimic the real life duplicate row issue.
Clearinghouse clearinghouseOverride1 = ClearinghouseT.CreateClearinghouse(methodName, clinic.ClinicNum, EclaimsCommBridge.ClaimConnect,
ElectronicClaimFormat.x837D_5010_dental, clearinghouseHQ.HqClearinghouseNum, false, "test", "pass");
Clearinghouse clearinghouseOverride2 = ClearinghouseT.CreateClearinghouse(methodName, clinic.ClinicNum, EclaimsCommBridge.ClaimConnect,
ElectronicClaimFormat.x837D_5010_dental, clearinghouseHQ.HqClearinghouseNum, false, "test", "pass");
//Get all override rows from the DB
List <Clearinghouse> listClearinghouseOverrides = Clearinghouses.GetAllNonHq();
//Mimic the user making some changes to one of the overrides which was causing issues prior to the UpdateOverridesForClinic() paradigm.
string passwordNew = "Password1!";
clearinghouseOverride2.Password = passwordNew;
//FormClearinghouseEdit manipulates the clearinghouses in memory first but then calls the following method to "sync" all overrides before calling the clearinghouse sync.
Clearinghouses.SyncOverridesForClinic(ref listClearinghouseOverrides, clearinghouseOverride2);
//Check that both rows had their values updated to the Clearinghouse override's values.
Clearinghouse co1 = listClearinghouseOverrides.First(x => x.ClearinghouseNum == clearinghouseOverride1.ClearinghouseNum);
Clearinghouse co2 = listClearinghouseOverrides.First(x => x.ClearinghouseNum == clearinghouseOverride2.ClearinghouseNum);
Assert.AreEqual(passwordNew, co1.Password);
Assert.AreEqual(passwordNew, co2.Password);
}
public void Clearinghouses_UpdateOverridesForClinic_UpdateOneOfMultiple()
{
string methodName = MethodBase.GetCurrentMethod().Name;
Clinic clinic = ClinicT.CreateClinic(methodName);
//Insert a default clearinghouse that is not associated to any clinics. This will be used as the "HqClearinghouseNum" for creating duplicate overrides later.
Clearinghouse clearinghouseHQClaimConnect = ClearinghouseT.CreateClearinghouse(methodName, commBridge: EclaimsCommBridge.ClaimConnect);
//Insert two blank Clearinghouse override rows associated to the same clinic into the DB to mimic the real life duplicate row issue.
Clearinghouse clearinghouseOverrideClaimConnect1 = ClearinghouseT.CreateClearinghouse(methodName, clinic.ClinicNum, EclaimsCommBridge.ClaimConnect,
ElectronicClaimFormat.x837D_5010_dental, clearinghouseHQClaimConnect.HqClearinghouseNum, false, "test", "pass");
Clearinghouse clearinghouseOverrideClaimConnect2 = ClearinghouseT.CreateClearinghouse(methodName, clinic.ClinicNum, EclaimsCommBridge.ClaimConnect,
ElectronicClaimFormat.x837D_5010_dental, clearinghouseHQClaimConnect.HqClearinghouseNum, false, "test", "pass");
//Make another HQ clearinghouse that is meant for a different eClaims comm bridge to make sure that all overrides associated to this clearinghouse do not change.
Clearinghouse clearinghouseHQAOS = ClearinghouseT.CreateClearinghouse(methodName, commBridge: EclaimsCommBridge.AOS);
//Insert two blank Clearinghouse override rows associated to the same clinic into the DB to mimic the real life duplicate row issue.
Clearinghouse clearinghouseOverrideAOS = ClearinghouseT.CreateClearinghouse(methodName, clinic.ClinicNum, EclaimsCommBridge.AOS,
ElectronicClaimFormat.x837D_5010_dental, clearinghouseHQAOS.HqClearinghouseNum, false, "test", "pass");
//Get all override rows from the DB
List <Clearinghouse> listClearinghouseOverrides = Clearinghouses.GetAllNonHq();
//Mimic the user making some changes to one of the overrides which was causing issues prior to the UpdateOverridesForClinic() paradigm.
string passwordNew = "Password1!";
clearinghouseOverrideClaimConnect2.Password = passwordNew;
//FormClearinghouseEdit manipulates the clearinghouses in memory first but then calls the following method to "sync" all overrides before calling the clearinghouse sync.
Clearinghouses.SyncOverridesForClinic(ref listClearinghouseOverrides, clearinghouseOverrideClaimConnect2);
//Check that both rows had their values updated to the Clearinghouse override's values.
Assert.IsFalse(listClearinghouseOverrides.All(x => x.Password == passwordNew));
}
///<summary></summary>
public static Clearinghouse CreateClearinghouse(string description, long clinicNum = 0, EclaimsCommBridge commBridge = EclaimsCommBridge.None,
ElectronicClaimFormat eFormat = ElectronicClaimFormat.None, long hqClearinghouseNum = 0, bool isAttachmentSendAllowed = false, string loginID = "", string password = "",
string isa05 = "", string isa07 = "", string isa08 = "", string isa15 = "")
{
Clearinghouse clearinghouse = new Clearinghouse()
{
Description = description,
ClinicNum = clinicNum,
CommBridge = commBridge,
Eformat = eFormat,
HqClearinghouseNum = hqClearinghouseNum,
IsAttachmentSendAllowed = isAttachmentSendAllowed,
LoginID = loginID,
Password = password,
ISA05 = isa05,
ISA07 = isa07,
ISA08 = isa08,
ISA15 = isa15
};
Clearinghouses.Insert(clearinghouse); //Automatically sets HqClearinghouseNum.
if (hqClearinghouseNum > 0)
{
clearinghouse.HqClearinghouseNum = hqClearinghouseNum;
Clearinghouses.Update(clearinghouse);
}
Clearinghouses.RefreshCache();
return(clearinghouse);
}
public static string RunOne(bool showForms)
{
string retVal = "";
long provNum = ProviderC.ListShort[0].ProvNum; //dentist #1
Patient pat = Patients.GetPat(PatientTC.PatNum1); //patient#1
if (pat.PriProv != provNum)
{
Patient oldPat = pat.Copy();
pat.PriProv = provNum; //this script uses the primary provider for the patient
Patients.Update(pat, oldPat);
}
PatPlan patplan = PatPlans.GetPatPlan(pat.PatNum, 1);
InsSub sub = InsSubs.GetOne(patplan.InsSubNum);
InsPlan plan = InsPlans.GetPlan(sub.PlanNum, new List <InsPlan>());
//the UI would block this due to carrier not supporting this transaction type.
Clearinghouse clearinghouseHq = Clearinghouses.GetDefaultDental();
Clearinghouse clearinghouseClin = Clearinghouses.OverrideFields(clearinghouseHq, Clinics.ClinicNum);
long etransNum = CanadianOutput.SendElegibility(clearinghouseClin, pat.PatNum, plan, new DateTime(1999, 1, 1), patplan.Relationship, patplan.PatID, showForms, sub);
Etrans etrans = Etranss.GetEtrans(etransNum);
string message = EtransMessageTexts.GetMessageText(etrans.EtransMessageTextNum);
CCDFieldInputter formData = new CCDFieldInputter(message);
string responseStatus = formData.GetValue("G05");
if (responseStatus != "R")
{
throw new Exception("Should be R");
}
retVal += "Eligibility #1 successful.\r\n";
return(retVal);
}
///<summary>Attempts to request benefits. If successful the 270 request is returned.
///Otherwise null is returned and the out error string will contain more information. Mimics FormInsPlan.butGetElectronic_Click().</summary>
public static Etrans TryInsVerifyRequest(InsVerify insVerify, InsPlan insPlan, Carrier carrier, InsSub insSub, out string error)
{
error = "";
Etrans etrans270Request = null;
Clearinghouse clearinghouseHq = Clearinghouses.GetDefaultEligibility();
if (clearinghouseHq == null)
{
error = "No clearinghouse is set as default.";
return(null);
}
if (!clearinghouseHq.CommBridge.In(EclaimsCommBridge.ClaimConnect, EclaimsCommBridge.EDS, EclaimsCommBridge.WebMD))
{
error = "So far, eligibility checks only work with ClaimConnect, EDS, WebMD (Emdeon Dental), and CDAnet.";
return(null);
}
error = X271.ValidateSettings();
if (error.IsNullOrEmpty())
{
Clearinghouse clearinghouse = Clearinghouses.OverrideFields(clearinghouseHq, insVerify.ClinicNum); //ClinicNum pulled from appointment.
try {
//Can return null, can throw exceptions
etrans270Request = x270Controller.RequestBenefits(clearinghouse, insPlan, insVerify.PatNum, carrier, insSub, out error);
}
catch (Exception ex) {
error = ex.Message;
}
}
return(etrans270Request);
}
private static string Run(int scriptNum, Carrier carrier, CanadianNetwork network, Provider prov, out Etrans etrans, DateTime reconciliationDate)
{
string retVal = "";
Clearinghouse clearinghouseHq = Canadian.GetCanadianClearinghouseHq(carrier);
Clearinghouse clearinghouseClin = Clearinghouses.OverrideFields(clearinghouseHq, Clinics.ClinicNum);
etrans = CanadianOutput.GetSummaryReconciliation(clearinghouseClin, carrier, network, prov, reconciliationDate);
retVal += "Summary Reconciliation#" + scriptNum.ToString() + " successful.\r\n";
return(retVal);
}
private static string Run(int scriptNum, Carrier carrier, Provider treatProv, Provider billingProv, DateTime reconciliationDate, out List <Etrans> etransAcks)
{
string retVal = "";
Clearinghouse clearinghouseHq = Canadian.GetCanadianClearinghouseHq(carrier);
Clearinghouse clearinghouseClin = Clearinghouses.OverrideFields(clearinghouseHq, Clinics.ClinicNum);
etransAcks = CanadianOutput.GetPaymentReconciliations(clearinghouseClin, carrier, treatProv, billingProv, reconciliationDate, 0);
retVal += "Payment Reconciliation#" + scriptNum.ToString() + " successful.\r\n";
return(retVal);
}
private static string Run(int scriptNum, bool version2, bool sendToItrans, Carrier carrier, out List <Etrans> etransRequests)
{
string retVal = "";
Provider prov = Providers.GetProv(PrefC.GetLong(PrefName.PracticeDefaultProv));
Clearinghouse clearinghouseHq = Canadian.GetCanadianClearinghouseHq(carrier);
Clearinghouse clearinghouseClin = Clearinghouses.OverrideFields(clearinghouseHq, Clinics.ClinicNum);
etransRequests = CanadianOutput.GetOutstandingTransactions(clearinghouseClin, version2, sendToItrans, carrier, prov, false);
retVal += "Outstanding Transactions#" + scriptNum.ToString() + " successful.\r\n";
return(retVal);
}
///<summary>Called from Eclaims and includes multiple claims.</summary>
public static string SendBatch(List <ClaimSendQueueItem> queueItems, int batchNum)
{
for (int i = 0; i < queueItems.Count; i++)
{
//A setting for the clearinghouse could have changed so we need to always refresh the clearinghouse variable before sending any batches.
if (i == 0)
{
clearinghouse = Clearinghouses.GetClearinghouse(queueItems[i].ClearinghouseNum);
}
if (!CreateClaim(queueItems[i].PatNum, queueItems[i].ClaimNum, batchNum))
{
return("");
}
}
return("Sent");
}
///<summary>Returns a string describing all missing data on this claim. Claim will not be allowed to be sent electronically unless this string comes back empty.</summary>
public static string GetMissingData(ClaimSendQueueItem queueItem)
{
Clearinghouse clearhouse = Clearinghouses.GetClearinghouse(queueItem.ClearinghouseNum);
if (clearhouse.Eformat == ElectronicClaimFormat.X12)
{
return(X12.GetMissingData(queueItem));
}
else if (clearhouse.Eformat == ElectronicClaimFormat.Renaissance)
{
return(Renaissance.GetMissingData(queueItem));
}
else if (clearhouse.Eformat == ElectronicClaimFormat.Canadian)
{
return(Canadian.GetMissingData(queueItem));
}
return("");
}
public static string Run(int scriptNum, string responseExpected, string responseTypeExpected, Claim claim, bool showForms, int pageNumber, int lastPageNumber, double firstExamFee, double diagnosticPhaseFee)
{
string retVal = "";
ClaimSendQueueItem queueItem = Claims.GetQueueList(claim.ClaimNum, claim.ClinicNum, 0)[0];
Clearinghouse clearinghouseHq = ClearinghouseL.GetClearinghouseHq(queueItem.ClearinghouseNum);
Clearinghouse clearinghouseClin = Clearinghouses.OverrideFields(clearinghouseHq, Clinics.ClinicNum);
Eclaims.GetMissingData(clearinghouseClin, queueItem); //,out warnings);
if (queueItem.MissingData != "")
{
return("Cannot send predetermination until missing data is fixed:\r\n" + queueItem.MissingData + "\r\n");
}
#if DEBUG
Canadian.testNumber = scriptNum;
claim.PreAuthString = "" + pageNumber + "," + lastPageNumber + "," + firstExamFee + "," + diagnosticPhaseFee;
#endif
long etransNum = Canadian.SendClaim(clearinghouseClin, queueItem, showForms);
Etrans etrans = Etranss.GetEtrans(etransNum);
string message = EtransMessageTexts.GetMessageText(etrans.EtransMessageTextNum);
CCDFieldInputter formData = new CCDFieldInputter(message);
string responseType = formData.GetValue("A04");
if (responseType != responseTypeExpected)
{
return("Form type is '" + responseType + "' but should be '" + responseTypeExpected + "'\r\n");
}
string responseStatus = formData.GetValue("G05");
if (responseStatus != responseExpected)
{
return("G05 is '" + responseStatus + "' but should be '" + responseExpected + "'\r\n");
}
if (responseExpected == "R" && responseTypeExpected == "11")
{
//so far, only for #6. We need some other way to test if successful transaction
string errorMsgCount = formData.GetValue("G06");
if (errorMsgCount == "00")
{
return("Wrong message count.\r\n");
}
}
retVal += "Predetermination #" + scriptNum + " page " + pageNumber + " of " + lastPageNumber + " successful.\r\n";
return(retVal);
}
public static string Run(int scriptNum, string responseExpected, string responseTypeExpected, Claim claim, bool showForms)
{
string retVal = "";
ClaimSendQueueItem queueItem = Claims.GetQueueList(claim.ClaimNum, claim.ClinicNum, 0)[0];
Clearinghouse clearinghouseHq = ClearinghouseL.GetClearinghouseHq(queueItem.ClearinghouseNum);
Clearinghouse clearinghouseClin = Clearinghouses.OverrideFields(clearinghouseHq, Clinics.ClinicNum);
Eclaims.GetMissingData(clearinghouseClin, queueItem); //,out warnings);
if (queueItem.MissingData != "")
{
return("Cannot send claim until missing data is fixed:\r\n" + queueItem.MissingData + "\r\n");
}
#if DEBUG
Canadian.testNumber = scriptNum;
#endif
long etransNum = Canadian.SendClaim(clearinghouseClin, queueItem, showForms);
Etrans etrans = Etranss.GetEtrans(etransNum);
string message = EtransMessageTexts.GetMessageText(etrans.EtransMessageTextNum);
CCDFieldInputter formData = new CCDFieldInputter(message);
string responseType = formData.GetValue("A04");
if (responseType != responseTypeExpected)
{
return("Form type should be " + responseTypeExpected + "\r\n");
}
string responseStatus = formData.GetValue("G05");
if (responseStatus != responseExpected)
{
return("G05 should be " + responseExpected + "\r\n");
}
if (responseExpected == "R" && responseTypeExpected == "11")
{
//so far, only for #6. We need some other way to test if successful transaction
string errorMsgCount = formData.GetValue("G06");
if (errorMsgCount == "00")
{
return("Wrong message count.\r\n");
}
}
retVal += "Claim #" + scriptNum.ToString() + " successful.\r\n";
return(retVal);
}
public static string Run(int scriptNum, string responseExpected, Claim claim)
{
string retVal = "";
InsPlan insPlan = InsPlans.GetPlan(claim.PlanNum, null);
InsSub insSub = InsSubs.GetOne(claim.InsSubNum);
Carrier carrier = Carriers.GetCarrier(insPlan.CarrierNum);
Clearinghouse clearinghouseHq =
Clearinghouses.GetClearinghouse(Clearinghouses.AutomateClearinghouseHqSelection(carrier.ElectID, claim.MedType));
Clearinghouse clearinghouseClin = Clearinghouses.OverrideFields(clearinghouseHq, Clinics.ClinicNum);
long etransNum = CanadianOutput.SendClaimReversal(clearinghouseClin, claim, insPlan, insSub);
Etrans etrans = Etranss.GetEtrans(etransNum);
string message = EtransMessageTexts.GetMessageText(etrans.EtransMessageTextNum);
CCDFieldInputter formData = new CCDFieldInputter(message);
string responseStatus = formData.GetValue("G05");
if (responseStatus != responseExpected)
{
return("G05 should be " + responseExpected + "\r\n");
}
retVal += "Reversal #" + scriptNum.ToString() + " successful.\r\n";
return(retVal);
}
///<summary>Supply a list of ClaimSendQueueItems. Called from FormClaimSend. Can only send to one clearinghouse at a time.
///The queueItems must contain at least one item. Each item in queueItems must have the same ClinicNum. Cannot include Canadian.</summary>
public static void SendBatch(Clearinghouse clearinghouseClin, List <ClaimSendQueueItem> queueItems, EnumClaimMedType medType,
IFormClaimFormItemEdit formClaimFormItemEdit, Renaissance.FillRenaissanceDelegate fillRenaissance, ITerminalConnector terminalConnector)
{
string messageText = "";
if (clearinghouseClin.Eformat == ElectronicClaimFormat.Canadian)
{
MessageBox.Show(Lans.g("Eclaims", "Cannot send Canadian claims as part of Eclaims.SendBatch."));
return;
}
//get next batch number for this clearinghouse
int batchNum = Clearinghouses.GetNextBatchNumber(clearinghouseClin);
//---------------------------------------------------------------------------------------
//Create the claim file for this clearinghouse
if (clearinghouseClin.Eformat == ElectronicClaimFormat.x837D_4010 ||
clearinghouseClin.Eformat == ElectronicClaimFormat.x837D_5010_dental ||
clearinghouseClin.Eformat == ElectronicClaimFormat.x837_5010_med_inst)
{
messageText = x837Controller.SendBatch(clearinghouseClin, queueItems, batchNum, medType, false);
}
else if (clearinghouseClin.Eformat == ElectronicClaimFormat.Renaissance)
{
messageText = Renaissance.SendBatch(clearinghouseClin, queueItems, batchNum, formClaimFormItemEdit, fillRenaissance);
}
else if (clearinghouseClin.Eformat == ElectronicClaimFormat.Dutch)
{
messageText = Dutch.SendBatch(clearinghouseClin, queueItems, batchNum);
}
else if (clearinghouseClin.Eformat == ElectronicClaimFormat.Ramq)
{
messageText = Ramq.SendBatch(clearinghouseClin, queueItems, batchNum);
}
else
{
messageText = ""; //(ElectronicClaimFormat.None does not get sent)
}
if (messageText == "") //if failed to create claim file properly,
{
return; //don't launch program or change claim status
}
//----------------------------------------------------------------------------------------
//Launch Client Program for this clearinghouse if applicable
if (clearinghouseClin.CommBridge == EclaimsCommBridge.None)
{
AttemptLaunch(clearinghouseClin, batchNum);
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.WebMD)
{
if (!WebMD.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + "\r\n" + WebMD.ErrorMessage);
return;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.BCBSGA)
{
if (!BCBSGA.Launch(clearinghouseClin, batchNum, terminalConnector))
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + "\r\n" + BCBSGA.ErrorMessage);
return;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.Renaissance)
{
AttemptLaunch(clearinghouseClin, batchNum);
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.ClaimConnect)
{
if (ClaimConnect.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show("Upload successful.");
}
else
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + "\r\n" + ClaimConnect.ErrorMessage);
return;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.RECS)
{
if (!RECS.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Claim file created, but could not launch RECS client.") + "\r\n" + RECS.ErrorMessage);
//continue;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.Inmediata)
{
if (!Inmediata.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Claim file created, but could not launch Inmediata client.") + "\r\n" + Inmediata.ErrorMessage);
//continue;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.AOS) // added by SPK 7/13/05
{
if (!AOS.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Claim file created, but could not launch AOS Communicator.") + "\r\n" + AOS.ErrorMessage);
//continue;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.PostnTrack)
{
AttemptLaunch(clearinghouseClin, batchNum);
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.MercuryDE)
{
if (!MercuryDE.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + "\r\n" + MercuryDE.ErrorMessage);
return;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.ClaimX)
{
if (!ClaimX.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Claim file created, but encountered an error while launching ClaimX Client.") + ":\r\n" + ClaimX.ErrorMessage);
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.EmdeonMedical)
{
if (!EmdeonMedical.Launch(clearinghouseClin, batchNum, medType))
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + "\r\n" + EmdeonMedical.ErrorMessage);
return;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.DentiCal)
{
if (!DentiCal.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + DentiCal.ErrorMessage);
return;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.NHS)
{
if (!NHS.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + "\r\n" + NHS.ErrorMessage);
return;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.EDS)
{
if (!EDS.Launch(clearinghouseClin, messageText))
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + "\r\n" + EDS.ErrorMessage);
return;
}
}
else if (clearinghouseClin.CommBridge == EclaimsCommBridge.Ramq)
{
if (!Ramq.Launch(clearinghouseClin, batchNum))
{
MessageBox.Show(Lans.g("Eclaims", "Error sending.") + Ramq.ErrorMessage);
return;
}
}
//----------------------------------------------------------------------------------------
//finally, mark the claims sent. (only if not Canadian)
EtransType etype = EtransType.ClaimSent;
if (clearinghouseClin.Eformat == ElectronicClaimFormat.Renaissance)
{
etype = EtransType.Claim_Ren;
}
//Canadians cannot send in batches (see above). RAMQ is performing a similar algorithm but the steps are in a different order in Ramq.cs.
if (clearinghouseClin.Eformat != ElectronicClaimFormat.Canadian && clearinghouseClin.Eformat != ElectronicClaimFormat.Ramq)
{
//Create the etransmessagetext that all claims in the batch will point to.
EtransMessageText etransMsgText = new EtransMessageText();
etransMsgText.MessageText = messageText;
EtransMessageTexts.Insert(etransMsgText);
for (int j = 0; j < queueItems.Count; j++)
{
Etrans etrans = Etranss.SetClaimSentOrPrinted(queueItems[j].ClaimNum, queueItems[j].PatNum,
clearinghouseClin.HqClearinghouseNum, etype, batchNum, Security.CurUser.UserNum);
etrans.EtransMessageTextNum = etransMsgText.EtransMessageTextNum;
Etranss.Update(etrans);
//Now we need to update our cache of claims to reflect the change that took place in the database above in Etranss.SetClaimSentOrPrinted()
queueItems[j].ClaimStatus = "S";
}
}
}
///<summary>Supply a list of ClaimSendQueueItems. Called from FormClaimSend. Can only send to one clearinghouse at a time. Able to send just send one claim. Cannot include Canadian.</summary>
public static void SendBatch(List <ClaimSendQueueItem> queueItems, Clearinghouse clearhouse, EnumClaimMedType medType)
{
string messageText = "";
if (clearhouse.Eformat == ElectronicClaimFormat.Canadian)
{
MsgBox.Show("Eclaims", "Cannot send Canadian claims as part of Eclaims.SendBatch.");
return;
}
//get next batch number for this clearinghouse
int batchNum = Clearinghouses.GetNextBatchNumber(clearhouse);
//---------------------------------------------------------------------------------------
//Create the claim file for this clearinghouse
if (clearhouse.Eformat == ElectronicClaimFormat.x837D_4010 ||
clearhouse.Eformat == ElectronicClaimFormat.x837D_5010_dental ||
clearhouse.Eformat == ElectronicClaimFormat.x837_5010_med_inst)
{
messageText = x837Controller.SendBatch(queueItems, batchNum, clearhouse, medType);
}
else if (clearhouse.Eformat == ElectronicClaimFormat.Renaissance)
{
messageText = Renaissance.SendBatch(queueItems, batchNum);
}
else if (clearhouse.Eformat == ElectronicClaimFormat.Dutch)
{
messageText = Dutch.SendBatch(queueItems, batchNum);
}
else
{
messageText = ""; //(ElectronicClaimFormat.None does not get sent)
}
if (messageText == "") //if failed to create claim file properly,
{
return; //don't launch program or change claim status
}
//----------------------------------------------------------------------------------------
//Launch Client Program for this clearinghouse if applicable
if (clearhouse.CommBridge == EclaimsCommBridge.None)
{
AttemptLaunch(clearhouse, batchNum);
}
else if (clearhouse.CommBridge == EclaimsCommBridge.WebMD)
{
if (!WebMD.Launch(clearhouse, batchNum))
{
MessageBox.Show(Lan.g("Eclaims", "Error sending."));
return;
}
}
else if (clearhouse.CommBridge == EclaimsCommBridge.BCBSGA)
{
if (!BCBSGA.Launch(clearhouse, batchNum))
{
MessageBox.Show(Lan.g("Eclaims", "Error sending."));
return;
}
}
else if (clearhouse.CommBridge == EclaimsCommBridge.Renaissance)
{
AttemptLaunch(clearhouse, batchNum);
}
else if (clearhouse.CommBridge == EclaimsCommBridge.ClaimConnect)
{
if (!ClaimConnect.Launch(clearhouse, batchNum))
{
MessageBox.Show(Lan.g("Eclaims", "Error sending."));
return;
}
}
else if (clearhouse.CommBridge == EclaimsCommBridge.RECS)
{
if (!RECS.Launch(clearhouse, batchNum))
{
MessageBox.Show("Claim file created, but could not launch RECS client.");
//continue;
}
}
else if (clearhouse.CommBridge == EclaimsCommBridge.Inmediata)
{
if (!Inmediata.Launch(clearhouse, batchNum))
{
MessageBox.Show("Claim file created, but could not launch Inmediata client.");
//continue;
}
}
else if (clearhouse.CommBridge == EclaimsCommBridge.AOS) // added by SPK 7/13/05
{
if (!AOS.Launch(clearhouse, batchNum))
{
MessageBox.Show("Claim file created, but could not launch AOS Communicator.");
//continue;
}
}
else if (clearhouse.CommBridge == EclaimsCommBridge.PostnTrack)
{
AttemptLaunch(clearhouse, batchNum);
}
else if (clearhouse.CommBridge == EclaimsCommBridge.MercuryDE)
{
if (!MercuryDE.Launch(clearhouse, batchNum))
{
MsgBox.Show("Eclaims", "Error sending.");
return;
}
}
else if (clearhouse.CommBridge == EclaimsCommBridge.ClaimX)
{
if (!ClaimX.Launch(clearhouse, batchNum))
{
MessageBox.Show("Claim file created, but encountered an error while launching ClaimX Client.");
}
}
else if (clearhouse.CommBridge == EclaimsCommBridge.EmdeonMedical)
{
if (!EmdeonMedical.Launch(clearhouse, batchNum, medType))
{
MessageBox.Show(Lan.g("Eclaims", "Error sending."));
return;
}
}
//----------------------------------------------------------------------------------------
//finally, mark the claims sent. (only if not Canadian)
EtransType etype = EtransType.ClaimSent;
if (clearhouse.Eformat == ElectronicClaimFormat.Renaissance)
{
etype = EtransType.Claim_Ren;
}
if (clearhouse.Eformat != ElectronicClaimFormat.Canadian)
{
for (int j = 0; j < queueItems.Count; j++)
{
Etrans etrans = Etranss.SetClaimSentOrPrinted(queueItems[j].ClaimNum, queueItems[j].PatNum, clearhouse.ClearinghouseNum, etype, batchNum);
Etranss.SetMessage(etrans.EtransNum, messageText);
}
}
}
///<summary>Supply an arrayList of type ClaimSendQueueItem. Called from FormClaimSend. Can send to multiple clearinghouses simultaneously.</summary>
public static void SendBatches(ArrayList queueItems)
{
//claimsByCHouse is of type ClaimSendQueueItem
ArrayList[] claimsByCHouse = new ArrayList[Clearinghouses.List.Length];
for (int i = 0; i < claimsByCHouse.Length; i++)
{
claimsByCHouse[i] = new ArrayList();
}
//divide the items by clearinghouse:
for (int i = 0; i < queueItems.Count; i++)
{
claimsByCHouse[Clearinghouses.GetIndex(((ClaimSendQueueItem)queueItems[i]).ClearinghouseNum)]
.Add(queueItems[i]);
}
//for any clearinghouses with claims, send them:
int batchNum;
bool result = true;
for (int i = 0; i < claimsByCHouse.Length; i++)
{
if (claimsByCHouse[i].Count == 0)
{
continue;
}
//get next batch number for this clearinghouse
batchNum = Clearinghouses.GetNextBatchNumber(Clearinghouses.List[i]);
//---------------------------------------------------------------------------------------
//Create the claim file(s) for this clearinghouse
if (Clearinghouses.List[i].Eformat == ElectronicClaimFormat.X12)
{
result = X12.SendBatch(claimsByCHouse[i], batchNum);
}
else if (Clearinghouses.List[i].Eformat == ElectronicClaimFormat.Renaissance)
{
result = Renaissance.SendBatch(claimsByCHouse[i], batchNum);
}
else if (Clearinghouses.List[i].Eformat == ElectronicClaimFormat.Canadian)
{
//Canadian is a little different because we need the sequence numbers.
//So all programs are launched and statuses changed from within Canadian.SendBatch()
//We don't care what the result is.
Canadian.SendBatch(claimsByCHouse[i], batchNum);
continue;
}
else
{
result = false; //(ElectronicClaimFormat.None does not get sent)
}
if (!result) //if failed to create claim file properly,
{
continue; //don't launch program or change claim status
}
//----------------------------------------------------------------------------------------
//Launch Client Program for this clearinghouse if applicable
if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.None)
{
AttemptLaunch(Clearinghouses.List[i], batchNum);
}
else if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.WebMD)
{
if (!WebMD.Launch(Clearinghouses.List[i], batchNum))
{
MessageBox.Show(Lan.g("Eclaims", "Error sending."));
continue;
}
}
else if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.BCBSGA)
{
if (!BCBSGA.Launch(Clearinghouses.List[i], batchNum))
{
MessageBox.Show(Lan.g("Eclaims", "Error sending."));
continue;
}
}
else if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.Renaissance)
{
AttemptLaunch(Clearinghouses.List[i], batchNum);
}
else if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.ClaimConnect)
{
if (!WebClaim.Launch(Clearinghouses.List[i], batchNum))
{
MessageBox.Show(Lan.g("Eclaims", "Error sending."));
continue;
}
}
else if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.RECS)
{
if (!RECS.Launch(Clearinghouses.List[i], batchNum))
{
MessageBox.Show("Claim file created, but could not launch RECS client.");
//continue;
}
}
else if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.Inmediata)
{
if (!Inmediata.Launch(Clearinghouses.List[i], batchNum))
{
MessageBox.Show("Claim file created, but could not launch Inmediata client.");
//continue;
}
}
else if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.AOS) // added by SPK 7/13/05
{
if (!AOS.Launch(Clearinghouses.List[i], batchNum))
{
MessageBox.Show("Claim file created, but could not launch AOS Communicator.");
//continue;
}
}
else if (Clearinghouses.List[i].CommBridge == EclaimsCommBridge.PostnTrack)
{
AttemptLaunch(Clearinghouses.List[i], batchNum);
//if(!PostnTrack.Launch(Clearinghouses.List[i],batchNum)){
// MessageBox.Show("Claim file created, but could not launch AOS Communicator.");
//continue;
//}
}
//----------------------------------------------------------------------------------------
//finally, mark the claims sent. (only if not Canadian)
EtransType etype = EtransType.ClaimSent;
if (Clearinghouses.List[i].Eformat == ElectronicClaimFormat.Renaissance)
{
etype = EtransType.Claim_Ren;
}
if (Clearinghouses.List[i].Eformat != ElectronicClaimFormat.Canadian)
{
for (int j = 0; j < claimsByCHouse[i].Count; j++)
{
Etranss.SetClaimSentOrPrinted(((ClaimSendQueueItem)claimsByCHouse[i][j]).ClaimNum,
((ClaimSendQueueItem)claimsByCHouse[i][j]).PatNum,
Clearinghouses.List[i].ClearinghouseNum, etype);
}
}
} //for(int i=0;i<claimsByCHouse.Length;i++){
}
