public override bool AfterSave()
{
if (IsDoctorRelated == null || !Convert.ToBoolean(IsDoctorRelated))
{
return(true);
}
if (DoctorID == null)
{
MessageToView = "You should choose the Doctor";
return(false);
}
Doctor_Diagnosis_cu bridge = DBCommon.CreateNewDBEntity <Doctor_Diagnosis_cu>();
bridge.Diagnosis_CU_ID = ((Diagnosis_cu)ActiveCollector.ActiveDBItem).ID;
bridge.Doctor_CU_ID = Convert.ToInt32(DoctorID);
if (UserID != null)
{
bridge.InsertedBy = Convert.ToInt32(UserID);
}
bridge.IsOnDuty = true;
switch (((IDiagnosis_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType)
{
case DB_CommonTransactionType.DeleteExisting:
bridge.IsOnDuty = false;
break;
}
bridge.IsMerkInsertion = false;
return(bridge.SaveChanges());
}
public static AccountingJournalEntryTransaction CreateAccountingJournalEntryTransaction(
object accountingJournalTransaction_ID, object amount, object serial, object chartOfAccount_CU_ID, object isDebit,
object description)
{
if (amount == null || serial == null || accountingJournalTransaction_ID == null ||
chartOfAccount_CU_ID == null || isDebit == null)
{
return(null);
}
AccountingJournalEntryTransaction accountingJournalEntryTransaction =
DBCommon.CreateNewDBEntity <AccountingJournalEntryTransaction>();
accountingJournalEntryTransaction.Amount = Convert.ToDouble(amount);
accountingJournalEntryTransaction.Serial = serial.ToString();
accountingJournalEntryTransaction.AccountingJournalTransaction_ID = Convert.ToInt32(accountingJournalTransaction_ID);
accountingJournalEntryTransaction.ChartOfAccount_CU_ID = Convert.ToInt32(chartOfAccount_CU_ID);
accountingJournalEntryTransaction.IsDebit = Convert.ToBoolean(isDebit);
if (description != null)
{
accountingJournalEntryTransaction.Description = description.ToString();
}
return(accountingJournalEntryTransaction);
}
public static CashBoxInOutTransaction CreateCashBoxInOutTransaction(object transactionDate,
object cashBoxTransactionType_P_ID, object chartOfAccount_CU_ID, object generalChartOfAccountType_CU_ID,
object transactionAmount, object paymentType_P_ID, object cashBox_CU_ID, object bank_CU_ID, object bankAccount_CU_ID,
object currency_CU_ID, object currencyExchangeRate, object transcationSerial, object description)
{
if (transactionDate == null || cashBoxTransactionType_P_ID == null || chartOfAccount_CU_ID == null ||
generalChartOfAccountType_CU_ID == null || transactionAmount == null || paymentType_P_ID == null ||
currency_CU_ID == null)
{
return(null);
}
CashBoxInOutTransaction cashBoxInOutTransaction = DBCommon.CreateNewDBEntity <CashBoxInOutTransaction>();
cashBoxInOutTransaction.TranscationDate = Convert.ToDateTime(transactionDate);
cashBoxInOutTransaction.CashBoxTransactionType_P_ID = Convert.ToInt32(cashBoxTransactionType_P_ID);
cashBoxInOutTransaction.ChartOfAccount_CU_ID = Convert.ToInt32(chartOfAccount_CU_ID);
cashBoxInOutTransaction.GeneralChartOfAccountType_CU_ID = Convert.ToInt32(generalChartOfAccountType_CU_ID);
cashBoxInOutTransaction.TransactionAmount = Convert.ToDouble(transactionAmount);
cashBoxInOutTransaction.PaymentType_P_ID = Convert.ToInt32(paymentType_P_ID);
cashBoxInOutTransaction.Currency_CU_ID = Convert.ToInt32(currency_CU_ID);
if (currencyExchangeRate != null)
{
cashBoxInOutTransaction.CurrencyExchangeRate = Convert.ToDouble(currencyExchangeRate);
}
if (transcationSerial != null)
{
cashBoxInOutTransaction.TranscationSerial = transcationSerial.ToString();
}
cashBoxInOutTransaction.IsCancelled = false;
return(cashBoxInOutTransaction);
}
private void btnAddToList_Click(object sender, EventArgs e)
{
if (spnAmount.EditValue == null || Math.Abs(Convert.ToDouble(spnAmount.EditValue)) < 0.0001)
{
return;
}
if (CashBoxInOutTransactionsList == null)
{
CashBoxInOutTransactionsList = new List <CashBoxInOutTransaction>();
}
CashBoxInOutTransaction cashBoxInOutTransaction = DBCommon.CreateNewDBEntity <CashBoxInOutTransaction>();
if (CashBoxTransactionType_P_ID != null)
{
cashBoxInOutTransaction.CashBoxTransactionType_P_ID = Convert.ToInt32(CashBoxTransactionType_P_ID);
}
if (TransactionAmount != null)
{
cashBoxInOutTransaction.TransactionAmount = chkExpenses.Checked || chkReverseRevenue.Checked
? Convert.ToDouble(TransactionAmount) * -1
: Convert.ToDouble(TransactionAmount);
}
if (TranscationSerial != null)
{
cashBoxInOutTransaction.TranscationSerial = TranscationSerial.ToString();
}
if (Description != null)
{
cashBoxInOutTransaction.Description = Description.ToString();
}
if (TranscationDate != null)
{
cashBoxInOutTransaction.TranscationDate = Convert.ToDateTime(TranscationDate);
}
if (ApplicationStaticConfiguration.ActiveCashBox != null)
{
cashBoxInOutTransaction.CashBox_CU_ID = ApplicationStaticConfiguration.ActiveCashBox.ID;
}
cashBoxInOutTransaction.AddedType = AddedType.NewelyAdded;
CashBoxInOutTransactionsList.Add(cashBoxInOutTransaction);
listToBeViewedOnly.Clear();
listToBeViewedOnly.AddRange(CashBoxInOutTransaction.ItemsList.FindAll(item =>
!Convert.ToInt32(item.AddedType).Equals(Convert.ToInt32(AddedType.Removed))));
listToBeViewedOnly.AddRange(CashBoxInOutTransactionsList.FindAll(item =>
!Convert.ToInt32(item.AddedType).Equals(Convert.ToInt32(AddedType.Removed))));
grdCashBoxInOutTransactions.DataSource = listToBeViewedOnly.OrderByDescending(item => item.TranscationDate);
grdCashBoxInOutTransactions.RefreshDataSource();
gridView7.SelectRow(-1);
ClearControls();
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <InsuranceCarrier_InsuranceLevel_cu>();
((IInsurancePolicyViewer)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <InPatientRoomBed_cu>();
((IInPatientRoomBedViewer)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <InventoryItem_UnitMeasurment_cu>();
((IInventoryItem_UnitMeasurment_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <FinanceInvoice>();
((IFinanceInvoiceCreation)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <User_UserGroup_cu>();
((IUser_UserGroup_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <OrganizationMachine_cu>();
((IOrganizationMachine_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <ServiceCategory_StationPoint_cu>();
((IServiceCategory_StationPointViewer)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <GeneralChartOfAccountType_cu>();
((IGeneralChartOfAccountTypeViewer)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <DiagnosisCategory_Diagnosis_cu>();
((IDiagnosisCategory_Diagnosis_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType =
DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <CashBoxInOutTransaction>();
((ICashBoxInOutTransactionViewer)ActiveCollector.ActiveViewer).CommonTransactionType =
DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool AfterSave()
{
if ((InvoicePayment)ActiveDBItem == null)
{
return(false);
}
switch (PaymentViewerType)
{
case PaymentViewerType.MedicalInvoicePayment:
Invoice invoice = DBCommon.GetEntity <Invoice>(Convert.ToInt32(((InvoicePayment)ActiveDBItem).InvoiceID));
if (invoice != null)
{
invoice.IsPaymentsEnough = Convert.ToBoolean(IsPaymentEnough);
InvoiceShare invoiceShare = DBCommon.GetEntity <InvoiceShare>(Convert.ToInt32(((InvoicePayment)ActiveDBItem).InvoiceID));
invoiceShare.TotalPayment = Convert.ToBoolean(IsRefund)
? Convert.ToDouble(invoiceShare.TotalPayment) + Convert.ToDouble(PaymentAmount) * -1
: Convert.ToDouble(invoiceShare.TotalPayment) + Convert.ToDouble(PaymentAmount);
if (Math.Abs(Convert.ToDouble(invoiceShare.TotalPayment) - Convert.ToDouble(invoiceShare.TotalRequestedAmount)) <
0.0001)
{
invoice.IsPaymentsEnough = true;
}
invoice.DBCommonTransactionType = DB_CommonTransactionType.UpdateExisting;
invoiceShare.DBCommonTransactionType = DB_CommonTransactionType.UpdateExisting;
invoice.InvoiceShare = invoiceShare;
return(invoice.SaveChanges());
}
break;
case PaymentViewerType.PatientDepositPayment:
PatientDepositeBalance patientBalance = DBCommon.CreateNewDBEntity <PatientDepositeBalance>();
patientBalance.Service_CU_ID = Convert.ToInt32(ServiceID);
patientBalance.Patient_CU_ID = Convert.ToInt32(((Patient_cu)Patient).ID);
patientBalance.Date = Convert.ToDateTime(PaymentDate);
patientBalance.Blance = Convert.ToDouble(PaymentAmount);
patientBalance.Factor = 1;
patientBalance.IsOnDuty = true;
if (UserID != null)
{
patientBalance.InsertedBy = Convert.ToInt32(UserID);
}
return(patientBalance.SaveChanges());
break;
}
return(false);
}
public override bool CreateNew()
{
if (ActiveDBItem == null)
{
ActiveDBItem = DBCommon.CreateNewDBEntity <Person_cu>();
if (ActiveDBItem != null)
{
((Person_cu)ActiveDBItem).Supplier_cu = DBCommon.CreateNewDBEntity <Supplier_cu>();
}
((ISupplierViewer)ActiveCollector.ActiveViewer).CommonTransactionType = DB_CommonTransactionType.SaveNew;
return(true);
}
return(false);
}
public override bool AfterSave()
{
if ((FinanceInvoice)ActiveDBItem == null)
{
return(false);
}
if (FinanceInvoiceDetailsList != null && FinanceInvoiceDetailsList.Count > 0)
{
foreach (FinanceInvoiceDetail invoiceDetail in FinanceInvoiceDetailsList.OrderBy(item => item.UnitMeasurment_CU_ID))
{
InventoryItemTransaction inventoryItemTransaction = DBCommon.CreateNewDBEntity <InventoryItemTransaction>();
inventoryItemTransaction.UnitMeasurment_CU_ID = Convert.ToInt32(invoiceDetail.UnitMeasurment_CU_ID);
inventoryItemTransaction.InventoryItem_CU_ID = Convert.ToInt32(invoiceDetail.InventoryItem_CU_ID);
inventoryItemTransaction.InventoryHousing_CU_ID = Convert.ToInt32(invoiceDetail.InventoryHousing_CU_ID);
inventoryItemTransaction.Quantity = Convert.ToDouble(invoiceDetail.Quantity);
inventoryItemTransaction.Date = Convert.ToDateTime(invoiceDetail.Date);
inventoryItemTransaction.IsOnDuty = true;
if (UserID != null)
{
inventoryItemTransaction.InsertedBy = Convert.ToInt32(UserID);
}
DB_InvoiceType invoiceType = (DB_InvoiceType)Convert.ToInt32(((FinanceInvoice)ActiveDBItem).InvoiceType_P_ID);
switch (invoiceType)
{
case DB_InvoiceType.SellingInvoice:
case DB_InvoiceType.ReturningPurchasingInvoice:
inventoryItemTransaction.TransactionFactor = -1;
inventoryItemTransaction.InventoryItemTransactionType_P_ID =
Convert.ToInt32(DB_InventoryItemTransactionType.OutputTransaction);
break;
case DB_InvoiceType.PurchasingInvoice:
case DB_InvoiceType.ReturningSellingInvoice:
inventoryItemTransaction.TransactionFactor = 1;
inventoryItemTransaction.InventoryItemTransactionType_P_ID =
Convert.ToInt32(DB_InventoryItemTransactionType.InputTransaction);
break;
}
inventoryItemTransaction.SaveChanges();
}
}
FinanceInvoiceDetailsList = null;
return(true);
}
public static LoggingHistory CreateLoggingHistory()
{
if (ActiveLoginUser == null || OrganizationMachine == null)
{
return(null);
}
LoggingHistory log = DBCommon.CreateNewDBEntity <LoggingHistory>();
log.User_UC_ID = ActiveLoginUser.Person_CU_ID;
log.LoginDate = DateTime.Now;
log.UserName = ActiveLoginUser.LoginName;
log.Password = ActiveLoginUser.Password;
log.OragnizationID = OrganizationMachine.ID;
log.OragnizationName = OrganizationMachineName;
log.PrivateOragnizationID = (int)Organization;
return(log);
}
private void btnAddToList_Click(object sender, EventArgs e)
{
if (lkeChildElement.EditValue == null)
{
XtraMessageBox.Show("You should select Element before adding", "Notice",
MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1,
DefaultBoolean.Default);
return;
}
if (spnOrderIndex.EditValue == null)
{
XtraMessageBox.Show("You should enter the Order Index before adding", "Notice",
MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1,
DefaultBoolean.Default);
return;
}
if (List_PrintOrders == null)
{
List_PrintOrders = new List <PEM_ElementPrintOrder_cu>();
}
PEM_ElementPrintOrder_cu printOrder = DBCommon.CreateNewDBEntity <PEM_ElementPrintOrder_cu>();
printOrder.PEMR_Elemet_P_ID = Convert.ToInt32(lkeChildElement.EditValue);
printOrder.OrderIndex = Convert.ToInt32(spnOrderIndex.EditValue);
printOrder.IsOnDuty = true;
printOrder.InsertedBy = ApplicationStaticConfiguration.ActiveLoginUser.ID;
if (txtDescription.EditValue != null && string.IsNullOrEmpty(txtDescription.Text) &&
string.IsNullOrWhiteSpace(txtDescription.Text))
{
printOrder.AddedDescription = txtDescription.Text;
}
if (!List_PrintOrders.Exists(item => Convert.ToInt32(item.PEMR_Elemet_P_ID)
.Equals(Convert.ToInt32(printOrder.PEMR_Elemet_P_ID))))
{
List_PrintOrders.Add(printOrder);
}
grdElements.DataSource = List_PrintOrders.OrderBy(item => item.OrderIndex);
grdElements.RefreshDataSource();
ClearControls();
}
public static PatientAttachment_cu CreateNewPatientAttachement(int patientID, string imageName,
string imagePath, DB_ImageType imageType, object description, int userID)
{
PatientAttachment_cu patientAttachment = DBCommon.CreateNewDBEntity <PatientAttachment_cu>();
patientAttachment.Patient_CU_ID = patientID;
patientAttachment.ImageName = imageName;
patientAttachment.ImagePath = imagePath;
patientAttachment.ImageType_P_ID = Convert.ToInt32(imageType);
patientAttachment.IsOnDuty = true;
if (description != null)
{
patientAttachment.Description = description.ToString();
}
patientAttachment.InsertedBy = userID;
return(patientAttachment);
}
public static QueueManager CreateNewQueueManager(Invoice invoice, InvoiceDetail invoiceDetail,
ServiceCategory_StationPoint_cu serviceCategoryStationPoint,
List <StationPointStage_cu> stationPointStagesList)
{
if (invoice == null || invoiceDetail == null || serviceCategoryStationPoint == null)
{
return(null);
}
QueueManager manager = DBCommon.CreateNewDBEntity <QueueManager>();
if (invoiceDetail.Doctor_CU_ID != null)
{
manager.Doctor_CU_ID = Convert.ToInt32(invoiceDetail.Doctor_CU_ID);
}
manager.InvoiceDetailID = invoiceDetail.ID;
manager.Service_CU_ID = invoiceDetail.Service_CU_ID != null
? Convert.ToInt32(invoiceDetail.Service_CU_ID)
: (int?)null;
if (invoiceDetail.StationPointID != null)
{
manager.StationPoint_CU_ID = Convert.ToInt32(invoiceDetail.StationPointID);
}
else
{
manager.StationPoint_CU_ID = serviceCategoryStationPoint.StationPoint_CU_ID;
}
if (invoiceDetail.StationPointStagesID != null)
{
manager.StationPointStage_CU_ID = Convert.ToInt32(invoiceDetail.StationPointStagesID);
}
else if (stationPointStagesList.Count > 0)
{
manager.StationPointStage_CU_ID = stationPointStagesList.First().ID;
}
manager.Patient_CU_ID = invoice.Patient_CU_ID;
manager.QueueManagerStatus_P_ID = (int)DB_QueueManagerStatus.Waiting;
manager.IsOnDuty = true;
return(manager);
}
public static QueueManager CreateNewQueueManager(Invoice invoice, InvoiceDetail invoiceDetail,
int stationPointID, int stationPointStageID)
{
QueueManager manager = DBCommon.CreateNewDBEntity <QueueManager>();
if (invoiceDetail.Doctor_CU_ID != null)
{
manager.Doctor_CU_ID = Convert.ToInt32(invoiceDetail.Doctor_CU_ID);
}
manager.InvoiceDetailID = invoiceDetail.ID;
manager.Service_CU_ID = invoiceDetail.Service_CU_ID != null
? Convert.ToInt32(invoiceDetail.Service_CU_ID)
: (int?)null;
manager.StationPoint_CU_ID = stationPointID;
manager.StationPointStage_CU_ID = stationPointStageID;
manager.Patient_CU_ID = invoice.Patient_CU_ID;
manager.QueueManagerStatus_P_ID = (int)DB_QueueManagerStatus.Waiting;
manager.IsOnDuty = true;
return(manager);
}
public static AccountingJournalTransaction CreateAccountingJournalTransaction(object jounralSerial,
object transactionDate, object transactionAmount, object financialTransactionType_P_ID, object description)
{
if (jounralSerial == null || transactionDate == null || transactionAmount == null ||
financialTransactionType_P_ID == null)
{
return(null);
}
AccountingJournalTransaction accountingJournalTransaction =
DBCommon.CreateNewDBEntity <AccountingJournalTransaction>();
accountingJournalTransaction.JounralSerial = jounralSerial.ToString();
accountingJournalTransaction.TransactionDate = Convert.ToDateTime(transactionDate);
accountingJournalTransaction.TransactionAmount = Convert.ToDouble(transactionAmount);
accountingJournalTransaction.FinancialTransactionType_P_ID = Convert.ToInt32(financialTransactionType_P_ID);
if (description != null)
{
accountingJournalTransaction.Description = description.ToString();
}
return(accountingJournalTransaction);
}
public override bool AfterSave()
{
GeneralChartOfAccountType_cu generalChartOfAccountType = (GeneralChartOfAccountType_cu)ActiveDBItem;
if (generalChartOfAccountType == null)
{
return(false);
}
ChartOfAccount_GeneralChartOfAccountType_cu chartOfAccountGeneralChartOfAccount =
DBCommon.CreateNewDBEntity <ChartOfAccount_GeneralChartOfAccountType_cu>();
if (chartOfAccountGeneralChartOfAccount == null)
{
return(false);
}
if (ChartOfAccount_CU_ID != null)
{
chartOfAccountGeneralChartOfAccount.ChartOfAccount_CU_ID = Convert.ToInt32(ChartOfAccount_CU_ID);
}
chartOfAccountGeneralChartOfAccount.GeneralChartOfAccountType_CU_ID = generalChartOfAccountType.ID;
if (UserID != null)
{
chartOfAccountGeneralChartOfAccount.InsertedBy = Convert.ToInt32(UserID);
}
chartOfAccountGeneralChartOfAccount.IsOnDuty = true;
switch (((IGeneralChartOfAccountTypeViewer)ActiveCollector.ActiveViewer).CommonTransactionType)
{
case DB_CommonTransactionType.DeleteExisting:
chartOfAccountGeneralChartOfAccount.IsOnDuty = false;
break;
}
chartOfAccountGeneralChartOfAccount.SaveChanges();
DB_CashBoxTransactionType privateGeneralChartOfAccountType =
(DB_CashBoxTransactionType)generalChartOfAccountType.GeneralChartOfAccountType_P_ID;
List <CashBoxTransactionType_GeneralChartOfAccountType_p> privateList =
CashBoxTransactionType_GeneralChartOfAccountType_p.ItemsList.FindAll(
item =>
Convert.ToInt32(item.GeneralChartOfAccountType_P_ID).Equals(Convert.ToInt32(privateGeneralChartOfAccountType)));
if (privateList.Count == 0)
{
return(false);
}
CashBoxTransactionType_GeneralChartOfAccountType_cu cashBoxTransactionTypeGeneralChartOfAccountType = null;
foreach (CashBoxTransactionType_GeneralChartOfAccountType_p cashBoxTransactionTypeGeneralChartOfAccountTypeP in privateList)
{
cashBoxTransactionTypeGeneralChartOfAccountType =
DBCommon.CreateNewDBEntity <CashBoxTransactionType_GeneralChartOfAccountType_cu>();
if (cashBoxTransactionTypeGeneralChartOfAccountType == null)
{
return(false);
}
cashBoxTransactionTypeGeneralChartOfAccountType.CashBoxTransactionType_P_ID =
cashBoxTransactionTypeGeneralChartOfAccountTypeP.CashBoxTransactionType_P_ID;
cashBoxTransactionTypeGeneralChartOfAccountType.GeneralChartOfAccountType_CU_ID = generalChartOfAccountType.ID;
if (UserID != null)
{
cashBoxTransactionTypeGeneralChartOfAccountType.InsertedBy = Convert.ToInt32(UserID);
}
cashBoxTransactionTypeGeneralChartOfAccountType.IsOnDuty = true;
switch (((IGeneralChartOfAccountTypeViewer)ActiveCollector.ActiveViewer).CommonTransactionType)
{
case DB_CommonTransactionType.DeleteExisting:
cashBoxTransactionTypeGeneralChartOfAccountType.IsOnDuty = false;
break;
}
cashBoxTransactionTypeGeneralChartOfAccountType.SaveChanges();
}
if (cashBoxTransactionTypeGeneralChartOfAccountType != null)
{
cashBoxTransactionTypeGeneralChartOfAccountType.LoadItemsList();
}
return(true);
}
public override bool Collect(AbstractDataCollector <TEntity> collector)
{
if (collector == null)
{
return(false);
}
ActiveCollector = collector;
ID = ((IFinanceInvoiceCreation)ActiveCollector.ActiveViewer).ID;
if (ActiveDBItem == null)
{
return(false);
}
((FinanceInvoice)ActiveDBItem).DBCommonTransactionType = CommonTransactionType;
if (InvoiceTypeID != null)
{
((FinanceInvoice)ActiveDBItem).InvoiceType_P_ID = (int)InvoiceTypeID;
}
if (InvoicePaymentTypeID != null)
{
((FinanceInvoice)ActiveDBItem).InvoicePaymentType_P_ID = (int)InvoicePaymentTypeID;
}
if (InvoiceCreationDate != null)
{
((FinanceInvoice)ActiveDBItem).InvoiceCreationDate = Convert.ToDateTime(InvoiceCreationDate);
}
DB_InvoiceType invoiceType = (DB_InvoiceType)Convert.ToInt32(((FinanceInvoice)ActiveDBItem).InvoiceType_P_ID);
switch (invoiceType)
{
case DB_InvoiceType.SellingInvoice:
case DB_InvoiceType.ReturningSellingInvoice:
if (Person_CU_ID != null)
{
((FinanceInvoice)ActiveDBItem).Customer_CU_ID = Convert.ToInt32(Person_CU_ID);
}
break;
case DB_InvoiceType.PurchasingInvoice:
case DB_InvoiceType.ReturningPurchasingInvoice:
if (Person_CU_ID != null)
{
((FinanceInvoice)ActiveDBItem).Supplier_CU_ID = Convert.ToInt32(Person_CU_ID);
}
break;
}
((FinanceInvoice)ActiveDBItem).IsPrinted = false;
if (InvoiceSerialNumber != null)
{
((FinanceInvoice)ActiveDBItem).InvoiceSerial = InvoiceSerialNumber.ToString();
}
((FinanceInvoice)ActiveDBItem).PrintingDate = null;
((FinanceInvoice)ActiveDBItem).IsPaymentsEnough = Convert.ToBoolean(IsPaymentEnough);
if (InvoiceDescription != null)
{
((FinanceInvoice)ActiveDBItem).Description = InvoiceDescription.ToString();
}
((FinanceInvoice)ActiveDBItem).Description = null;
((FinanceInvoice)ActiveDBItem).IsOnDuty = true;
((FinanceInvoice)ActiveDBItem).IsFinanciallyReviewed = false;
((FinanceInvoice)ActiveDBItem).IsFinanciallyCompleted = false;
((FinanceInvoice)ActiveDBItem).IsCancelled = false;
((FinanceInvoice)ActiveDBItem).CancelledBy = null;
((FinanceInvoice)ActiveDBItem).CancellationDate = null;
((FinanceInvoice)ActiveDBItem).IsSuspended = false;
if (UserID != null)
{
((FinanceInvoice)ActiveDBItem).InsertedBy = Convert.ToInt32(UserID);
}
double accummulativeRequiredAmount = 0;
if (FinanceInvoiceDetailsList != null && FinanceInvoiceDetailsList.Count > 0)
{
foreach (FinanceInvoiceDetail invoiceDetail in FinanceInvoiceDetailsList)
{
if (UserID != null)
{
invoiceDetail.InsertedBy = Convert.ToInt32(UserID);
}
((FinanceInvoice)ActiveDBItem).FinanceInvoiceDetails.Add(invoiceDetail);
accummulativeRequiredAmount = accummulativeRequiredAmount +
Convert.ToDouble(invoiceDetail.PricePerUnit) * Convert.ToDouble(invoiceDetail.Quantity);
}
}
else
{
return(false);
}
((FinanceInvoice)ActiveDBItem).FinanceInvoiceShare = new FinanceInvoiceShare();
((FinanceInvoice)ActiveDBItem).FinanceInvoiceShare.TotalRequestedAmount = accummulativeRequiredAmount;
if (UserID != null)
{
((FinanceInvoice)ActiveDBItem).FinanceInvoiceShare.InsertedBy = Convert.ToInt32(UserID);
}
if (AmountPaid != null)
{
((FinanceInvoice)ActiveDBItem).FinanceInvoiceShare.TotalPayment = Convert.ToDouble(AmountPaid);
}
if (Convert.ToBoolean(PaymentTypeID) && AmountPaid != null &&
Convert.ToDouble(AmountPaid) >= 0)
{
FinanceInvoicePayment invoicePayment = DBCommon.CreateNewDBEntity <FinanceInvoicePayment>();
invoicePayment.Amount = Convert.ToDouble(AmountPaid);
if (InvoiceCreationDate != null)
{
invoicePayment.Date = Convert.ToDateTime(InvoiceCreationDate);
}
invoicePayment.PaymentType_P_ID = (int)DB_PaymentType.CashPayment;
invoicePayment.PaymentSerial = "123";
invoicePayment.IsOnDuty = true;
invoicePayment.Description = "sdfsdfsdf";
invoicePayment.IsRemainingReturned = Convert.ToBoolean(IsRemainingReturned);
if (UserID != null)
{
invoicePayment.InsertedBy = Convert.ToInt32(UserID);
}
((FinanceInvoice)ActiveDBItem).FinanceInvoicePayments.Add(invoicePayment);
}
return(true);
}
public override bool Collect(AbstractDataCollector <TEntity> collector)
{
if (collector == null)
{
return(false);
}
ActiveCollector = collector;
ID = ((IPatientInvoiceCreation)ActiveCollector.ActiveViewer).ID;
if (ActiveDBItem == null)
{
return(false);
}
((Invoice)ActiveDBItem).DBCommonTransactionType = CommonTransactionType;
((Invoice)ActiveDBItem).InvoiceType_P_ID = (int)InvoiceTypeID;
((Invoice)ActiveDBItem).InvoicePaymentType_P_ID = (int)DB_InvoicePaymentType.CashInvoice;
((Invoice)ActiveDBItem).InvoiceCreationDate = Convert.ToDateTime(InvoiceCreationDate);
((Invoice)ActiveDBItem).Patient_CU_ID = Convert.ToInt32(PatientID);
((Invoice)ActiveDBItem).IsPrinted = false;
((Invoice)ActiveDBItem).InvoiceSerial = null;
((Invoice)ActiveDBItem).PrintingDate = null;
((Invoice)ActiveDBItem).IsPaymentsEnough = Convert.ToBoolean(IsPaymentEnough);
((Invoice)ActiveDBItem).Description = null;
((Invoice)ActiveDBItem).IsOnDuty = true;
switch ((DB_InvoiceType)InvoiceTypeID)
{
case DB_InvoiceType.OutPatientNotPrivate:
case DB_InvoiceType.OutPatientPrivate:
((Invoice)ActiveDBItem).IsFinanciallyReviewed = true;
break;
case DB_InvoiceType.InPatientPrivate:
case DB_InvoiceType.InPatientNotPrivate:
((Invoice)ActiveDBItem).IsFinanciallyReviewed = false;
break;
}
((Invoice)ActiveDBItem).IsMedicallyDone = false;
((Invoice)ActiveDBItem).IsFinanciallyCompleted = false;
((Invoice)ActiveDBItem).IsCancelled = false;
((Invoice)ActiveDBItem).CancelledBy = null;
((Invoice)ActiveDBItem).CancellationDate = null;
((Invoice)ActiveDBItem).IsSuspended = false;
((Invoice)ActiveDBItem).InvoiceShare = new InvoiceShare();
if (AccummulativeServicesPatientShare != null)
{
((Invoice)ActiveDBItem).InvoiceShare.TotalPatientShare = Convert.ToDouble(AccummulativeServicesPatientShare);
}
if (AccummulativeServicesInsuranceShare != null)
{
((Invoice)ActiveDBItem).InvoiceShare.TotalInsuranceShare = Convert.ToDouble(AccummulativeServicesInsuranceShare);
}
((Invoice)ActiveDBItem).InvoiceShare.TotalPayment = 0;
((Invoice)ActiveDBItem).InvoiceShare.IsInsuranceApplied = Convert.ToBoolean(IsInsuranceAppliedToInvoice);
if (InsuranceCarrierID != null)
{
((Invoice)ActiveDBItem).InvoiceShare.InsuranceCarrier_CU_ID = Convert.ToInt32(InsuranceCarrierID);
}
if (InsuranceLevelID != null)
{
((Invoice)ActiveDBItem).InvoiceShare.InsuanceLevel_CU_ID = Convert.ToInt32(InsuranceLevelID);
}
if (InsurancePercentage != null)
{
((Invoice)ActiveDBItem).InvoiceShare.InsurancePercentageApplied = Convert.ToDouble(InsurancePercentage) / 100;
}
if (InsurancePatientMaxAmount != null)
{
((Invoice)ActiveDBItem).InvoiceShare.InsurancePatientMaxAmount = Convert.ToDouble(InsurancePatientMaxAmount);
}
((Invoice)ActiveDBItem).InvoiceShare.IsSurchargeApplied = Convert.ToBoolean(IsSurchargeAppliedToInvoice);
if (SurchargeAmount != null)
{
((Invoice)ActiveDBItem).InvoiceShare.TotalSurchargeAccummulativePercentage = Convert.ToDouble(SurchargeAmount);
}
((Invoice)ActiveDBItem).InvoiceShare.IsStampApplied = Convert.ToBoolean(IsStampApplied);
if (StampAmount != null)
{
((Invoice)ActiveDBItem).InvoiceShare.TotalStampAmount = Convert.ToDouble(StampAmount);
}
((Invoice)ActiveDBItem).InvoiceShare.IsSurchargeDistributedToInsurancePercentage = true;
((Invoice)ActiveDBItem).InvoiceShare.IsSurchargeAppliedToPatientOnly = false;
if (UserID != null)
{
((Invoice)ActiveDBItem).InvoiceShare.InsertedBy = Convert.ToInt32(UserID);
}
((Invoice)ActiveDBItem).InvoiceShare.IsStampDistributedToInsurancePercentage = true;
((Invoice)ActiveDBItem).InvoiceShare.IsStampAppliedToPatientOnly = false;
if (Convert.ToBoolean(IsPaymentAttached) && AmountPaid != null &&
Convert.ToDouble(AmountPaid) >= 0)
{
InvoicePayment invoicePayment = DBCommon.CreateNewDBEntity <InvoicePayment>();
invoicePayment.Amount = ((Invoice)ActiveDBItem).InvoiceShare.TotalPayment = Convert.ToDouble(AmountPaid);
if (InvoiceCreationDate != null)
{
invoicePayment.Date = Convert.ToDateTime(InvoiceCreationDate);
}
invoicePayment.PaymentType_P_ID = (int)DB_PaymentType.CashPayment;
invoicePayment.PaymentSerial = "123";
invoicePayment.IsOnDuty = true;
invoicePayment.Description = ((Invoice)ActiveDBItem).Description;
invoicePayment.IsRemainingReturned = Convert.ToBoolean(IsRemainingReturned);
if (UserID != null)
{
invoicePayment.InsertedBy = Convert.ToInt32(UserID);
}
((Invoice)ActiveDBItem).InvoicePayments.Add(invoicePayment);
}
if (UserID != null)
{
((Invoice)ActiveDBItem).InsertedBy = Convert.ToInt32(UserID);
}
if (Grid_InvoiceDetails != null && Grid_InvoiceDetails.Count > 0)
{
switch (CommonTransactionType)
{
case DB_CommonTransactionType.CreateNew:
foreach (InvoiceDetail invoiceDetail in Grid_InvoiceDetails)
{
if (UserID != null)
{
invoiceDetail.InsertedBy = Convert.ToInt32(UserID);
}
((Invoice)ActiveDBItem).InvoiceDetails.Add(invoiceDetail);
}
break;
case DB_CommonTransactionType.UpdateExisting:
if (Grid_InvoiceDetails.Count >= ((Invoice)ActiveDBItem).InvoiceDetails.Count)
{
foreach (InvoiceDetail invoiceDetail in Grid_InvoiceDetails)
{
if (UserID != null)
{
invoiceDetail.InsertedBy = Convert.ToInt32(UserID);
}
if (((Invoice)ActiveDBItem).InvoiceDetails.ToList()
.Exists(item => Convert.ToInt32(item.ID).Equals(Convert.ToInt32(invoiceDetail.ID))))
{
continue;
}
if (UserID != null)
{
invoiceDetail.InsertedBy = Convert.ToInt32(UserID);
}
invoiceDetail.InvoiceID = ((Invoice)ActiveDBItem).ID;
invoiceDetail.SaveChanges();
}
}
else
{
foreach (InvoiceDetail invoiceDetail in ((Invoice)ActiveDBItem).InvoiceDetails)
{
if (Grid_InvoiceDetails.ToList()
.Exists(item => Convert.ToInt32(item.ID).Equals(Convert.ToInt32(invoiceDetail.ID))))
{
continue;
}
invoiceDetail.IsOnDuty = false;
invoiceDetail.InvoiceID = ((Invoice)ActiveDBItem).ID;
invoiceDetail.DBCommonTransactionType = DB_CommonTransactionType.UpdateExisting;
invoiceDetail.SaveChanges();
}
}
break;
}
}
else
{
return(false);
}
return(true);
}
public override bool Collect(AbstractDataCollector <TEntity> collector)
{
if (collector == null)
{
return(false);
}
ActiveCollector = collector;
ID = ((IInPatientRoomViewer)ActiveCollector.ActiveViewer).ID;
if (ActiveDBItem == null)
{
return(false);
}
((InPatientRoom_cu)ActiveDBItem).DBCommonTransactionType =
((IInPatientRoomViewer)ActiveCollector.ActiveViewer).CommonTransactionType;
((InPatientRoom_cu)ActiveDBItem).Name_P = ((IInPatientRoomViewer)ActiveCollector.ActiveViewer).NameP.ToString();
((InPatientRoom_cu)ActiveDBItem).Name_S = ((IInPatientRoomViewer)ActiveCollector.ActiveViewer).NameS.ToString();
((InPatientRoom_cu)ActiveDBItem).Floor_CU_ID =
Convert.ToInt32(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).Floor);
((InPatientRoom_cu)ActiveDBItem).InPatientRoomClassification_CU_ID =
Convert.ToInt32(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).InPatientRoomClassification);
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).Description != null)
{
((InPatientRoom_cu)ActiveDBItem).Description =
((IInPatientRoomViewer)ActiveCollector.ActiveViewer).Description.ToString();
}
else
{
((InPatientRoom_cu)ActiveDBItem).Description = null;
}
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).InternalCode != null)
{
((InPatientRoom_cu)ActiveDBItem).InternalCode =
((IInPatientRoomViewer)ActiveCollector.ActiveViewer).InternalCode.ToString();
}
else
{
((InPatientRoom_cu)ActiveDBItem).InternalCode = null;
}
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).ShortName != null)
{
((InPatientRoom_cu)ActiveDBItem).ShortName =
((IInPatientRoomViewer)ActiveCollector.ActiveViewer).ShortName.ToString();
}
else
{
((InPatientRoom_cu)ActiveDBItem).ShortName = null;
}
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).HasMainPatientPricing)
{
InPatientRoom_InPatientAdmissionPricingType_cu pricingObject =
DBCommon.CreateNewDBEntity <InPatientRoom_InPatientAdmissionPricingType_cu>();
if (pricingObject != null)
{
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).PricePerDay_MainPatient != null &&
Convert.ToDouble(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).PricePerDay_MainPatient) > 0)
{
pricingObject.PricePerDay =
Convert.ToDouble(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).PricePerDay_MainPatient);
}
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).MinimumAddmissionAmount_MainPatient != null &&
Convert.ToDouble(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).MinimumAddmissionAmount_MainPatient) > 0)
{
pricingObject.MinimumAddmissionAmount =
Convert.ToDouble(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).MinimumAddmissionAmount_MainPatient);
}
pricingObject.InPatientAddmissionPricingType_P_ID = (int)DB_InPatientAddmissionPricingType.MainPatientPricing;
}
((InPatientRoom_cu)ActiveDBItem).InPatientRoom_InPatientAdmissionPricingType_cu.Add(pricingObject);
}
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).HasCompanionPricing)
{
InPatientRoom_InPatientAdmissionPricingType_cu pricingObject =
DBCommon.CreateNewDBEntity <InPatientRoom_InPatientAdmissionPricingType_cu>();
if (pricingObject != null)
{
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).PricePerDay_CompanionPatient != null &&
Convert.ToDouble(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).PricePerDay_CompanionPatient) > 0)
{
pricingObject.PricePerDay =
Convert.ToDouble(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).PricePerDay_CompanionPatient);
}
if (((IInPatientRoomViewer)ActiveCollector.ActiveViewer).MinimumAddmissionAmount_CompanionPatient != null &&
Convert.ToDouble(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).MinimumAddmissionAmount_CompanionPatient) > 0)
{
pricingObject.MinimumAddmissionAmount =
Convert.ToDouble(((IInPatientRoomViewer)ActiveCollector.ActiveViewer).MinimumAddmissionAmount_CompanionPatient);
}
pricingObject.InPatientAddmissionPricingType_P_ID = (int)DB_InPatientAddmissionPricingType.CompanionPricing;
}
((InPatientRoom_cu)ActiveDBItem).InPatientRoom_InPatientAdmissionPricingType_cu.Add(pricingObject);
}
if (UserID != null)
{
((InPatientRoom_cu)ActiveDBItem).InsertedBy = Convert.ToInt32(UserID);
}
((InPatientRoom_cu)ActiveDBItem).IsOnDuty = true;
switch (((IStationPointStageViewer)ActiveCollector.ActiveViewer).CommonTransactionType)
{
case DB_CommonTransactionType.DeleteExisting:
((InPatientRoom_cu)ActiveDBItem).IsOnDuty = false;
break;
}
RelatedViewers = ((IInPatientRoomViewer)ActiveCollector.ActiveViewer).RelatedViewers;
return(true);
}
public override bool SaveChanges(DB_CommonTransactionType commonTransactionType)
{
if (ActiveCollector.ActiveDBItem == null)
{
return(false);
}
List <Person_ChartOfAccount_cu> list = null;
if (Convert.ToBoolean(IsDebitChartOfAccount) || Convert.ToBoolean(IsTaxChartOfAccount) ||
Convert.ToBoolean(IsCurrentChartOfAccount) ||
Convert.ToBoolean(IsCreditChartOfAccount))
{
list = new List <Person_ChartOfAccount_cu>();
}
if (Convert.ToBoolean(IsDebitChartOfAccount) && Debit_ChartOfAccount != null)
{
Person_ChartOfAccount_cu personChart = DBCommon.CreateNewDBEntity <Person_ChartOfAccount_cu>();
personChart.ChartOfAccount_CU_ID = Convert.ToInt32(Debit_ChartOfAccount);
personChart.PersonChartOfAccountType_P_ID = (int)DB_PersonChartOtAccountType.DebitAccountingCode;
personChart.Person_CU_ID = Convert.ToInt32(Person_CU_ID);
personChart.IsOnDuty = true;
if (UserID != null)
{
personChart.InsertedBy = Convert.ToInt32(UserID);
}
switch (((IPerson_ChartOfAccount_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType)
{
case DB_CommonTransactionType.DeleteExisting:
personChart.IsOnDuty = false;
break;
}
if (list != null)
{
list.Add(personChart);
}
}
if (Convert.ToBoolean(IsCreditChartOfAccount) && Credit_ChartOfAccount != null)
{
Person_ChartOfAccount_cu personChart = DBCommon.CreateNewDBEntity <Person_ChartOfAccount_cu>();
personChart.ChartOfAccount_CU_ID = Convert.ToInt32(Credit_ChartOfAccount);
personChart.PersonChartOfAccountType_P_ID = (int)DB_PersonChartOtAccountType.CreditAccountingCode;
personChart.Person_CU_ID = Convert.ToInt32(Person_CU_ID);
personChart.IsOnDuty = true;
if (UserID != null)
{
personChart.InsertedBy = Convert.ToInt32(UserID);
}
switch (((IPerson_ChartOfAccount_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType)
{
case DB_CommonTransactionType.DeleteExisting:
personChart.IsOnDuty = false;
break;
}
if (list != null)
{
list.Add(personChart);
}
}
if (Convert.ToBoolean(IsCurrentChartOfAccount) && Current_ChartOfAccount != null)
{
Person_ChartOfAccount_cu personChart = DBCommon.CreateNewDBEntity <Person_ChartOfAccount_cu>();
personChart.ChartOfAccount_CU_ID = Convert.ToInt32(Current_ChartOfAccount);
personChart.PersonChartOfAccountType_P_ID = (int)DB_PersonChartOtAccountType.CurrentAccountingCode;
personChart.Person_CU_ID = Convert.ToInt32(Person_CU_ID);
personChart.IsOnDuty = true;
if (UserID != null)
{
personChart.InsertedBy = Convert.ToInt32(UserID);
}
switch (((IPerson_ChartOfAccount_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType)
{
case DB_CommonTransactionType.DeleteExisting:
personChart.IsOnDuty = false;
break;
}
if (list != null)
{
list.Add(personChart);
}
}
if (Convert.ToBoolean(IsTaxChartOfAccount) && Tax_ChartOfAccount != null)
{
Person_ChartOfAccount_cu personChart = DBCommon.CreateNewDBEntity <Person_ChartOfAccount_cu>();
personChart.ChartOfAccount_CU_ID = Convert.ToInt32(Tax_ChartOfAccount);
personChart.PersonChartOfAccountType_P_ID = (int)DB_PersonChartOtAccountType.TaxAccountingCode;
personChart.Person_CU_ID = Convert.ToInt32(Person_CU_ID);
personChart.IsOnDuty = true;
if (UserID != null)
{
personChart.InsertedBy = Convert.ToInt32(UserID);
}
switch (((IPerson_ChartOfAccount_Viewer)ActiveCollector.ActiveViewer).CommonTransactionType)
{
case DB_CommonTransactionType.DeleteExisting:
personChart.IsOnDuty = false;
break;
}
if (list != null)
{
list.Add(personChart);
}
}
if (list != null && list.Count > 0)
{
foreach (Person_ChartOfAccount_cu personChartOfAccountCu in list)
{
personChartOfAccountCu.SaveChanges();
personChartOfAccountCu.LoadItemsList();
}
}
return(true);
}
public static InvoiceDetail_Accommodation CreateNew_InvoiceDetail_Accommodation(InvoiceDetail parentInvoiceDetail,
object servicePrice, object startDate, object bedId, object overridenroomClassId, object isSurchargeApplied,
object isTaxApplied, object serviceDescription,
object isServiceIncludedInInsurance, object insurancePercetnage)
{
if (bedId == null || parentInvoiceDetail == null)
{
return(null);
}
InvoiceDetail_Accommodation accommodation = DBCommon.CreateNewDBEntity <InvoiceDetail_Accommodation>();
if (parentInvoiceDetail.InvoiceDetail_Accommodation == null)
{
parentInvoiceDetail.InvoiceDetail_Accommodation = new List <InvoiceDetail_Accommodation>();
}
parentInvoiceDetail.InvoiceDetail_Accommodation.Add(accommodation);
if (Convert.ToBoolean(isServiceIncludedInInsurance) && insurancePercetnage != null)
{
accommodation.PatientShare = (1 - Convert.ToDouble(insurancePercetnage)) * Convert.ToDouble(servicePrice);
accommodation.InsuranceShare = Convert.ToDouble(insurancePercetnage) * Convert.ToDouble(servicePrice);
accommodation.IsInsuranceApplied = true;
}
else
{
accommodation.PatientShare = Convert.ToDouble(servicePrice);
accommodation.InsuranceShare = 0;
accommodation.IsInsuranceApplied = false;
}
InPatientRoomBed_cu roomBed =
InPatientRoomBed_cu.ItemsList.Find(item => Convert.ToInt32(item.ID).Equals(Convert.ToInt32(bedId)));
if (roomBed == null)
{
return(null);
}
InPatientRoom_cu room =
InPatientRoom_cu.ItemsList.Find(
item => Convert.ToInt32(item.ID).Equals(Convert.ToInt32(roomBed.InPatientRoom_CU_ID)));
if (room == null)
{
return(null);
}
InPatientRoomClassification_cu roomClassification =
InPatientRoomClassification_cu.ItemsList.Find(
item => Convert.ToInt32(item.ID).Equals(Convert.ToInt32(room.InPatientRoomClassification_CU_ID)));
if (roomClassification == null)
{
return(null);
}
accommodation.InPatientRoomBed_CU_ID = roomBed.ID;
accommodation.InPatientRoom_CU_ID = room.ID;
accommodation.InPatientRoomClassification_CU_ID = roomClassification.ID;
accommodation.IsOnDuty = true;
accommodation.IsSurchargeApplied = Convert.ToBoolean(isSurchargeApplied);
accommodation.StartDate = Convert.ToDateTime(startDate);
if (serviceDescription != null)
{
accommodation.Description = serviceDescription.ToString();
}
return(accommodation);
}
