public string Put()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
SchedulingDbContext schDbContext = new SchedulingDbContext(connString);
string reqType = this.ReadQueryStringData("reqType");
string str = this.ReadPostData();
try
{
#region Update Shifts (Manage Shifts)
if (reqType == "UpdateShift")
{
ShiftsMasterModel shiftData = DanpheJSONConvert.DeserializeObject <ShiftsMasterModel>(str);
shiftData.ModifiedOn = System.DateTime.Now;
schDbContext.ShiftsMaster.Attach(shiftData);
schDbContext.Entry(shiftData).State = EntityState.Modified;
schDbContext.Entry(shiftData).Property(x => x.CreatedOn).IsModified = false;
schDbContext.Entry(shiftData).Property(x => x.CreatedBy).IsModified = false;
schDbContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = shiftData;
}
#endregion
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
try
{
VisitDbContext dbContext = new VisitDbContext(base.connString);
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
if (reqType == "concludeVisit")
{
var visitid = DanpheJSONConvert.DeserializeObject <int>(str);
var visit = dbContext.Visits.Where(v => v.PatientVisitId == visitid).Select(p => p).FirstOrDefault();
visit.ConcludeDate = System.DateTime.Now;
dbContext.Visits.Attach(visit);
dbContext.Entry(visit).Property(a => a.ConcludeDate).IsModified = true;
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Error " + ex.Message;
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Put()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
try
{
//RbacUser currentUser = HttpContext.Session.Get<RbacUser>("currentuser");
string reqType = this.ReadQueryStringData("reqType");
string ipStr = this.ReadPostData();
CoreDbContext coreDbContext = new CoreDbContext(connString);
if (reqType == "updateQnairs")
{
//this is used to 1. Rename Questionnaire, 2. Change Display Sequence.
List <Questionnaire> qnrListFromclient = DanpheJSONConvert.
DeserializeObject <List <Questionnaire> >(ipStr);
if (qnrListFromclient != null && qnrListFromclient.Count > 0)
{
foreach (Questionnaire qnr in qnrListFromclient)
{
qnr.ChildQuestions = null; //needed since otherwise it goes on to add existing ChildQuestion again.
//coreDbContext.Entry(qnrFromClient).Property(q => q.Text).IsModified = true;
coreDbContext.Entry(qnr).State = EntityState.Modified;
}
coreDbContext.SaveChanges();
}
responseData.Results = qnrListFromclient;
}
else if (reqType == "updateQtn")
{
Question qtnVM = DanpheJSONConvert.
DeserializeObject <Question>(ipStr);
if (qtnVM != null)
{
//use GraphDiff's updategraph method to save/delete question and option (hierarchy)
coreDbContext.UpdateGraph(qtnVM,
map => map.OwnedCollection(a => a.Options));
coreDbContext.SaveChanges();
responseData.Results = qtnVM;
}
}
responseData.Status = "OK";
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
try
{
//RbacUser currentUser = HttpContext.Session.Get<RbacUser>("currentuser");
string reqType = this.ReadQueryStringData("reqType");
string ipStr = this.ReadPostData();
CoreDbContext coreDbContext = new CoreDbContext(connString);
if (reqType == "addQuestion")
{
Question qtnVM = DanpheJSONConvert.
DeserializeObject <Question>(ipStr);
if (qtnVM != null)
{
coreDbContext.Questions.Add(qtnVM);
coreDbContext.SaveChanges();
responseData.Results = qtnVM;
}
}
else if (reqType == "addQnair")
{
Questionnaire qnrVM = DanpheJSONConvert.
DeserializeObject <Questionnaire>(ipStr);
if (qnrVM != null)
{
Questionnaire qnr = qnrVM;
coreDbContext.Questionnaires.Add(qnr);
coreDbContext.SaveChanges();
//we get qnairId once it is saved to database.
qnrVM.QnairId = qnr.QnairId;
}
responseData.Results = qnrVM;
}
responseData.Status = "OK";
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
[HttpPost]// POST api/values
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>(); //type 'object' since we have variable return types
responseData.Status = "OK"; //by default status would be OK, hence assigning at the top
string ipDataString = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
try
{
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
BillingDbContext billingDbContext = new BillingDbContext(connString);
if (reqType == "Deposit")
{
BillingDeposit deposit = DanpheJSONConvert.DeserializeObject <BillingDeposit>(ipDataString);
deposit.CreatedOn = System.DateTime.Now;
deposit.CreatedBy = currentUser.EmployeeId;
BillingFiscalYear fiscYear = BillingBL.GetFiscalYear(connString);
deposit.FiscalYearId = fiscYear.FiscalYearId;
if (deposit.DepositType != "depositdeduct")
{
deposit.ReceiptNo = BillingBL.GetDepositReceiptNo(connString);
}
deposit.FiscalYear = fiscYear.FiscalYearFormatted;
EmployeeModel currentEmp = billingDbContext.Employee.Where(emp => emp.EmployeeId == currentUser.EmployeeId).FirstOrDefault();
deposit.BillingUser = currentEmp.FirstName + " " + currentEmp.LastName;
deposit.IsActive = true; //yubraj: 18th Dec '18
billingDbContext.BillingDeposits.Add(deposit);
billingDbContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = deposit;//check if we need to send back the whole input object back to client.--sudarshan
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
try
{
string reqType = this.ReadQueryStringData("reqType");
string ipStr = this.ReadPostData();
DoctorsDbContext dbContext = new DoctorsDbContext(connString);
if (reqType == "addPatientData")
{
List <VisitSummaryModel> patDataList = DanpheJSONConvert.
DeserializeObject <List <VisitSummaryModel> >(ipStr);
if (patDataList != null)
{
patDataList.ForEach(patData =>
{
patData.CreatedOn = DateTime.Now;
patData.CreatedBy = currentUser.CreatedBy;
dbContext.VisitSummary.Add(patData);
});
dbContext.SaveChanges();
responseData.Results = patDataList;
}
else
{
throw new Exception("Invalid Patient object.");
}
}
responseData.Status = "OK";
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Put()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
DicomDbContext dbContextDicom = new DicomDbContext(connStringPACSServer);
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
string inputSting = this.ReadPostData();
try
{
//if(inputSting !=null && reqType="putToolData")
//{
object clientData = DanpheJSONConvert.DeserializeObject <object>(inputSting);
JObject obj = JObject.Parse(inputSting);
var FileToolData = obj["FileToolData"].ToString();
var DicomFileId = int.Parse(obj["DicomFileId"]["dicomFileId"].ToString());
DicomFileInfoModel getDataForUpdate = dbContextDicom.DicomFiles.Where(d => d.DicomFileId == DicomFileId).FirstOrDefault <DicomFileInfoModel>();
getDataForUpdate.FileToolData = FileToolData;
getDataForUpdate.ModifiedBy = currentUser.UserId;
getDataForUpdate.ModifiedOn = DateTime.Now;
dbContextDicom.DicomFiles.Attach(getDataForUpdate);
dbContextDicom.Entry(getDataForUpdate).Property(u => u.CreatedOn).IsModified = true;
dbContextDicom.Entry(getDataForUpdate).State = EntityState.Modified;
dbContextDicom.SaveChanges();
responseData.Results = getDataForUpdate.DicomFileId;
responseData.Status = "OK";
//}
//else{
// responseData.Status = "Failed";
// responseData.Results = "input data is not available";
// }
}
catch (Exception ex)
{
responseData.Status = "Failed";
}
return(DanpheJSONConvert.SerializeObject(responseData));
}
public string Post()
{
DanpheHTTPResponse <Object> responseData = new DanpheHTTPResponse <Object>();
try
{
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
//if (!string.IsNullOrEmpty(reqType) && reqType == "quickAppointment")
//{
// return QuickAppointmentCreate();
//}
//else
//{
AppointmentModel ipApptModel = DanpheJSONConvert.DeserializeObject <AppointmentModel>(str);
if (ipApptModel.PatientId == 0)
{
ipApptModel.PatientId = null;
}
AppointmentDbContext apptDbContext = new AppointmentDbContext(connString);
apptDbContext.Appointments.Add(ipApptModel);
apptDbContext.SaveChanges();
responseData.Results = ipApptModel;
responseData.Status = "OK";
// }
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Put()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
try
{
string reqType = this.ReadQueryStringData("reqType");
string ipStr = this.ReadPostData();
DoctorsDbContext dbContext = new DoctorsDbContext(connString);
if (reqType == "updatePatientData")
{
List <VisitSummaryModel> patDataList = DanpheJSONConvert.DeserializeObject <List <VisitSummaryModel> >(ipStr);
patDataList.ForEach(data =>
{
data.ModifiedOn = DateTime.Now;
data.ModifiedBy = currentUser.CreatedBy;
dbContext.Entry(data).State = EntityState.Modified;
dbContext.Entry(data).Property(u => u.CreatedBy).IsModified = false;
dbContext.Entry(data).Property(u => u.CreatedOn).IsModified = false;
});
dbContext.SaveChanges();
responseData.Results = patDataList;
}
responseData.Status = "OK";
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Put()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
try
{
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
NotiFicationDbContext notificationDbContext = new NotiFicationDbContext(connString);
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
int EmployeeId = currentUser.EmployeeId;
if (reqType == "mark-as-read")
{
List <NotificationViewModel> messageList = DanpheJSONConvert.DeserializeObject <List <NotificationViewModel> >(str);
if (messageList != null && messageList.Count > 0)
{
foreach (NotificationViewModel msg in messageList)
{
msg.IsRead = true; ///update IsRead property
msg.ReadBy = EmployeeId; ///update Readby property by current loggedIn User
notificationDbContext.Notifications.Attach(msg);
notificationDbContext.Entry(msg).Property(x => x.IsRead).IsModified = true;
notificationDbContext.Entry(msg).Property(x => x.ReadBy).IsModified = true;
}
}
notificationDbContext.SaveChanges();
responseData.Results = messageList;
responseData.Status = "OK";
}
else if (reqType == "archive")
{
List <NotificationViewModel> messageList = DanpheJSONConvert.DeserializeObject <List <NotificationViewModel> >(str);
if (messageList != null && messageList.Count > 0)
{
foreach (NotificationViewModel msg in messageList)
{
msg.IsArchived = true; ///update IsArchived property
notificationDbContext.Notifications.Attach(msg);
notificationDbContext.Entry(msg).Property(x => x.IsArchived).IsModified = true;
}
}
notificationDbContext.SaveChanges();
responseData.Results = messageList;
responseData.Status = "OK";
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Invalid Request Type";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Put()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
try
{
VisitDbContext dbContext = new VisitDbContext(base.connString);
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
//string billingStatus = this.ReadQueryStringData("billingStatus");
//int patientVisitId = ToInt(this.ReadQueryStringData("billingStatus"));
bool continuedVisitStatus = ToBool(this.ReadQueryStringData("continuedVisitStatus"));
if (reqType == "reassignProvider")
{
VisitModel visitData = DanpheJSONConvert.DeserializeObject <VisitModel>(str);
visitData.ModifiedOn = System.DateTime.Now;
visitData.ProviderName = GetProviderName(visitData.ProviderId);
BillingDbContext billingDbContext = new BillingDbContext(base.connString);
Boolean Flag = false;
Flag = VisitBL.ReAssignProviderTxn(dbContext, visitData, billingDbContext);
if (Flag)
{
responseData.Status = "OK";
}
else
{
responseData.Status = "Failed";
}
}
else if (reqType == "changeProvider")
{
VisitModel data = DanpheJSONConvert.DeserializeObject <VisitModel>(str);
var visit = dbContext.Visits.Where(v => v.PatientVisitId == data.PatientVisitId).Select(p => p).FirstOrDefault();
visit.ModifiedBy = data.ModifiedBy;
visit.ModifiedOn = System.DateTime.Now;
visit.ProviderName = GetProviderName(data.ProviderId);
visit.ProviderId = data.ProviderId;
visit.Remarks = string.IsNullOrEmpty(visit.Remarks) ? data.Remarks : (visit.Remarks + data.Remarks);
dbContext.Visits.Attach(visit);
dbContext.Entry(visit).Property(a => a.ModifiedBy).IsModified = true;
dbContext.Entry(visit).Property(a => a.ModifiedOn).IsModified = true;
dbContext.Entry(visit).Property(a => a.ProviderName).IsModified = true;
dbContext.Entry(visit).Property(a => a.ProviderId).IsModified = true;
dbContext.Entry(visit).Property(a => a.Remarks).IsModified = true;
dbContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = visit.ProviderName;
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
WardSupplyDbContext wardSupplyDbContext = new WardSupplyDbContext(connString);
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
PharmacyDbContext phrmdbcontext = new PharmacyDbContext(connString);
string reqType = this.ReadQueryStringData("reqType");
string str = this.ReadPostData();
try
{
if (!String.IsNullOrEmpty(str))
{
#region Post:Ward Request
if (reqType == "ward-requistion")
{
WARDRequisitionModel WardReq = DanpheJSONConvert.DeserializeObject <WARDRequisitionModel>(str);
WardReq.CreatedOn = DateTime.Now.Date;
WardReq.CreatedBy = currentUser.EmployeeId;
WardReq.Status = "pending";
wardSupplyDbContext.WARDRequisitionModel.Add(WardReq);
wardSupplyDbContext.SaveChanges();
responseData.Results = WardReq;
responseData.Status = "OK";
}
#endregion
#region POST: Consumption
else if (reqType == "post-consumption")
{
PHRMInvoiceTransactionItemsModel invoice = new PHRMInvoiceTransactionItemsModel();
List <WARDStockModel> wardStockList = new List <WARDStockModel>();
WARDStockModel wardStock = new WARDStockModel();
List <WARDConsumptionModel> consumptionList = JsonConvert.DeserializeObject <List <WARDConsumptionModel> >(str);
PHRMStockTransactionItemsModel phrmStockTxnItems = new PHRMStockTransactionItemsModel();
foreach (var consmption in consumptionList)
{
//adding invoice in PHRM_TXN_Invoice
invoice.ItemId = consmption.ItemId;
invoice.ItemName = consmption.ItemName;
invoice.BatchNo = consmption.BatchNo;
invoice.Quantity = consmption.Quantity;
invoice.Price = consmption.MRP;
invoice.MRP = consmption.MRP;
invoice.SubTotal = consmption.SubTotal;
invoice.TotalAmount = consmption.SubTotal;
invoice.CreatedBy = consmption.CreatedBy;
invoice.CreatedOn = System.DateTime.Now;
invoice.CounterId = consmption.CounterId;
invoice.BilItemStatus = "wardconsumption";
invoice.ExpiryDate = consmption.ExpiryDate;
invoice.PatientId = consmption.PatientId;
invoice.VATPercentage = 0;
invoice.DiscountPercentage = 0;
invoice.FreeQuantity = 0;
phrmdbcontext.PHRMInvoiceTransactionItems.Add(invoice);
phrmdbcontext.SaveChanges();
//adding consumption in WARD_Consumption
consmption.InvoiceItemId = invoice.InvoiceItemId;
consmption.CreatedOn = System.DateTime.Now;
wardSupplyDbContext.WARDConsumptionModel.Add(consmption);
wardSupplyDbContext.SaveChanges();
//adding record in list for updating stock available quantity
wardStock = new WARDStockModel();
wardStock.ItemId = consmption.ItemId;
wardStock.MRP = (float)consmption.MRP;
wardStock.ExpiryDate = consmption.ExpiryDate;
wardStock.BatchNo = consmption.BatchNo;
wardStock.WardId = consmption.WardId;
wardStock.DispachedQuantity = consmption.Quantity;
wardStockList.Add(wardStock);
//adding record in the PHRM_StockTxnItems
phrmStockTxnItems.CreatedBy = currentUser.EmployeeId;
phrmStockTxnItems.CreatedOn = DateTime.Now;
phrmStockTxnItems.BatchNo = consmption.BatchNo;
phrmStockTxnItems.ItemId = consmption.ItemId;
phrmStockTxnItems.Price = consmption.MRP;
phrmStockTxnItems.MRP = consmption.MRP;
phrmStockTxnItems.ReferenceItemCreatedOn = DateTime.Now;
phrmStockTxnItems.ReferenceNo = consmption.InvoiceItemId;
phrmStockTxnItems.GoodsReceiptItemId = null;
phrmStockTxnItems.CCCharge = null;
phrmStockTxnItems.Quantity = consmption.Quantity;
phrmStockTxnItems.ExpiryDate = consmption.ExpiryDate;
phrmStockTxnItems.FreeQuantity = 0;
phrmStockTxnItems.DiscountPercentage = 0;
phrmStockTxnItems.VATPercentage = 0;
phrmStockTxnItems.InOut = "out";
phrmStockTxnItems.TransactionType = "wardsupply";
phrmStockTxnItems.SubTotal = consmption.SubTotal;
phrmStockTxnItems.TotalAmount = consmption.SubTotal;
phrmdbcontext.PHRMStockTransactionModel.Add(phrmStockTxnItems);
phrmdbcontext.SaveChanges();
}
if (WardSupplyBL.UpdateWardSockQuantity(wardStockList, wardSupplyDbContext))
{
responseData.Status = "OK";
responseData.Results = consumptionList;
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Falied to update stock details.";
}
}
#endregion
#region POST: Inventory Consumption
else if (reqType == "post-inventory-consumption")
{
PHRMInvoiceTransactionItemsModel invoice = new PHRMInvoiceTransactionItemsModel();
List <WARDStockModel> wardStockList = new List <WARDStockModel>();
WARDStockModel wardStock = new WARDStockModel();
List <WARDInventoryConsumptionModel> consumptionList = JsonConvert.DeserializeObject <List <WARDInventoryConsumptionModel> >(str);
PHRMStockTransactionItemsModel phrmStockTxnItems = new PHRMStockTransactionItemsModel();
foreach (var consmption in consumptionList)
{
//adding record in list for updating stock available quantity
var AvailableQuantity = consmption.Quantity - consmption.ConsumeQuantity;
WARDStockModel stockDetail = (from stock in wardSupplyDbContext.WARDStockModel
where stock.ItemId == consmption.ItemId & stock.StockType == "inventory" && stock.DepartmentId == consmption.DepartmentId
select stock
).FirstOrDefault();
stockDetail.AvailableQuantity = AvailableQuantity;
wardSupplyDbContext.Entry(stockDetail).Property(a => a.AvailableQuantity).IsModified = true;
//adding consumption in [WARD_INV_Consumption]
AvailableQuantity = consmption.ConsumeQuantity;
consmption.Quantity = AvailableQuantity;
consmption.CreatedOn = System.DateTime.Now;
wardSupplyDbContext.WARDInventoryConsumptionModel.Add(consmption);
wardSupplyDbContext.SaveChanges();
}
responseData.Status = "OK";
responseData.Results = consumptionList;
}
#endregion
#region POST : update stock transaction, Post to Stock table and post to Transaction table
else if (reqType == "transfer-stock")
{
WARDStockModel stockManageData = DanpheJSONConvert.DeserializeObject <WARDStockModel>(str);
if (stockManageData != null)
{
Boolean flag = false;
flag = WardSupplyBL.StockTransfer(stockManageData, wardSupplyDbContext, currentUser);
if (flag)
{
responseData.Status = "OK";
responseData.Results = 1;
}
else
{
responseData.ErrorMessage = "Transfer Item is null or failed to Save";
responseData.Status = "Failed";
}
}
}
#endregion
#region POST : update stock transaction, Post to Stock table and post to Transaction table
else if (reqType == "transfer-inventory-stock")
{
WARDStockModel stockManageData = DanpheJSONConvert.DeserializeObject <WARDStockModel>(str);
if (stockManageData != null)
{
Boolean flag = false;
flag = WardSupplyBL.StockInventoryTransfer(stockManageData, wardSupplyDbContext, currentUser);
if (flag)
{
responseData.Status = "OK";
responseData.Results = 1;
}
else
{
responseData.ErrorMessage = "Transfer Item is null or failed to Save";
responseData.Status = "Failed";
}
}
}
#endregion
#region POST : delete from stock table in wardsupply. add stock in inventory and update in stock transaction
else if (reqType == "transfer-back-to-inventory")
{
WARDStockModel stockManageData = DanpheJSONConvert.DeserializeObject <WARDStockModel>(str);
if (stockManageData != null)
{
Boolean flag = false;
flag = WardSupplyBL.BackToInventoryTransfer(stockManageData, wardSupplyDbContext, currentUser);
if (flag)
{
responseData.Status = "OK";
responseData.Results = 1;
}
else
{
responseData.ErrorMessage = "Transfer Item is null or failed to Save";
responseData.Status = "Failed";
}
}
}
#endregion
#region POST : update stock tranaction, Post to Stock table and Transaction Table
else if (reqType == "breakage-stock")
{
WARDStockModel stockManageData = DanpheJSONConvert.DeserializeObject <WARDStockModel>(str);
if (stockManageData != null)
{
Boolean flag = false;
flag = WardSupplyBL.StockBreakage(stockManageData, wardSupplyDbContext, currentUser);
if (flag)
{
responseData.Status = "OK";
responseData.Results = 1;
}
else
{
responseData.ErrorMessage = "Breakage item is null or failed to save";
responseData.Status = "Failed";
}
}
}
#endregion
#region POST : Ward To Pharmacy Tranfer of Stock
else if (reqType == "returnStockToPharmacy")
{
List <WARDStockModel> stockManageData = DanpheJSONConvert.DeserializeObject <List <WARDStockModel> >(str);
if (stockManageData != null)
{
Boolean flag = false;
flag = WardSupplyBL.StockTransferToPharmacy(stockManageData, wardSupplyDbContext, phrmdbcontext, currentUser);
if (flag)
{
responseData.Status = "OK";
responseData.Results = 1;
}
else
{
responseData.ErrorMessage = "Failed to save. Check the items.";
responseData.Status = "Failed";
}
}
}
#endregion
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Client Object is empty";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
//DanpheTeleMedDbContext dbContext = new DanpheTeleMedDbContext(connString);
responseData.Status = "OK";
try
{
string str = new StreamReader(Request.Body).ReadToEnd();
string reqType = Request.Query["reqType"];
responseData.Results = str + reqType;
#region Save User
if (reqType == "save-user")
{
UserModel user = DanpheJSONConvert.DeserializeObject <UserModel>(str);
if (user != null)
{
var usr = dbContext.User.Where(u => u.UserName == user.UserName).Select(a => a).ToList();
if (usr.Count > 0)
{
responseData.Status = "Falied";
responseData.ErrorMessage = "User already exits";
}
else
{
dbContext.User.Add(user);
dbContext.SaveChanges();
responseData.Results = user;
responseData.Status = "OK";
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "user information not received";
}
}
#endregion
#region Save Conference
else if (reqType == "save-new-conference")
{
ConferenceModel conference = DanpheJSONConvert.DeserializeObject <ConferenceModel>(str);
if (conference != null)
{
ConferenceUserModel conferenceUser = new ConferenceUserModel();
conferenceUser.ConferenceRoomId = conference.ConferenceRoomId;
conferenceUser.UserName = GetUserName(dbContext, conference.CreatedBy);
conferenceUser.JoinTime = conference.CreatedOn;
dbContext.Conference.Add(conference);
dbContext.ConferenceUser.Add(conferenceUser);
dbContext.SaveChanges();
responseData.Results = conference;
responseData.Status = "OK";
}
}
#endregion
#region Add new user in conference
else if (reqType == "add-conference-user")
{
ConferenceUserModel conferenceUser = DanpheJSONConvert.DeserializeObject <ConferenceUserModel>(str);
if (conferenceUser != null)
{
dbContext.ConferenceUser.Add(conferenceUser);
dbContext.SaveChanges();
responseData.Results = conferenceUser;
responseData.Status = "OK";
}
}
#endregion
#region Save conference chat
else if (reqType == "save-conference-chat")
{
ConferenceChatModel conferenceChat = DanpheJSONConvert.DeserializeObject <ConferenceChatModel>(str);
if (conferenceChat != null)
{
dbContext.ConferenceChat.Add(conferenceChat);
dbContext.SaveChanges();
responseData.Results = conferenceChat;
responseData.Status = "OK";
}
}
#endregion
#region Save new session of p2p connection
else if (reqType == "save-new-session")
{
SessionTxnModel sessionTxn = DanpheJSONConvert.DeserializeObject <SessionTxnModel>(str);
if (sessionTxn != null)
{
dbContext.SessionTxns.Add(sessionTxn);
dbContext.SaveChanges();
SessionUserTxnModel sessionUserTxn = new SessionUserTxnModel();
sessionUserTxn.SessionId = sessionTxn.SessionId;
sessionUserTxn.SessionOwnerId = sessionTxn.CreatedBy;
sessionUserTxn.OwnerJoinTime = sessionTxn.CreatedOn;
sessionUserTxn.UserId = sessionTxn.CallingTo;
sessionUserTxn.UserJoinTime = sessionTxn.CreatedOn;
dbContext.SessionUserTxns.Add(sessionUserTxn);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region Add new user in p2p session
else if (reqType == "add-session-user")
{
SessionUserTxnModel sessionUserTxn = DanpheJSONConvert.DeserializeObject <SessionUserTxnModel>(str);
if (sessionUserTxn != null)
{
if (sessionUserTxn.SessionOwnerId > 0)
{
dbContext.SessionUserTxns.Add(sessionUserTxn);
dbContext.SaveChanges();
}
else
{
var newuser = (from u in dbContext.SessionUserTxns
where u.SessionId == sessionUserTxn.SessionId
select u).FirstOrDefault();
newuser.UserId = sessionUserTxn.UserId;
newuser.UserJoinTime = sessionUserTxn.UserJoinTime;
dbContext.SessionUserTxns.Attach(newuser);
dbContext.Entry(newuser).Property(a => a.UserId).IsModified = true;
dbContext.Entry(newuser).Property(a => a.UserJoinTime).IsModified = true;
dbContext.Entry(newuser).State = EntityState.Modified;
dbContext.SaveChanges();
}
}
responseData.Results = sessionUserTxn;
responseData.Status = "OK";
}
#endregion
#region Save session chat in p2p connection
else if (reqType == "save-session-chat")
{
SessionChatModel sessionChat = DanpheJSONConvert.DeserializeObject <SessionChatModel>(str);
if (sessionChat != null)
{
var schat = (from s in dbContext.SessionUserTxns
where s.SessionId == sessionChat.SessionId
select new
{
s.SessionOwnerId,
s.UserId
}).FirstOrDefault();
sessionChat.ReceiverId = (schat.UserId == sessionChat.SenderId) ? schat.SessionOwnerId : schat.UserId;
dbContext.SessionChat.Add(sessionChat);
dbContext.SaveChanges();
responseData.Results = sessionChat;
responseData.Status = "OK";
}
}
#endregion
#region save assessment
else if (reqType == "save-assessment")
{
ClinicalAssessmentModel assessment = DanpheJSONConvert.DeserializeObject <ClinicalAssessmentModel>(str);
if (assessment != null)
{
dbContext.Assessment.Add(assessment);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save complain
else if (reqType == "save-complain")
{
ClinicalComplainModel complain = DanpheJSONConvert.DeserializeObject <ClinicalComplainModel>(str);
if (complain != null)
{
dbContext.Complain.Add(complain);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save examination
else if (reqType == "save-examination")
{
ClinicalExaminationModel examination = DanpheJSONConvert.DeserializeObject <ClinicalExaminationModel>(str);
if (examination != null)
{
dbContext.Examination.Add(examination);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save orders
else if (reqType == "save-orders")
{
ClinicalOrderModel order = DanpheJSONConvert.DeserializeObject <ClinicalOrderModel>(str);
if (order != null)
{
dbContext.Order.Add(order);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save plan
else if (reqType == "save-plan")
{
ClinicalPlanModel plan = DanpheJSONConvert.DeserializeObject <ClinicalPlanModel>(str);
if (plan != null)
{
dbContext.Plan.Add(plan);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save consult request
else if (reqType == "save-consult-request")
{
ConsultRequestModel consult = DanpheJSONConvert.DeserializeObject <ConsultRequestModel>(str);
if (consult != null)
{
dbContext.ConsultRequest.Add(consult);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region End Video Call
else if (reqType == "end-video-call")
{
SessionTxnModel sessionTxn = DanpheJSONConvert.DeserializeObject <SessionTxnModel>(str);
var es = (from st in dbContext.SessionTxns
where st.SessionId == sessionTxn.SessionId
select st).FirstOrDefault();
if (es != null)
{
es.EndTime = sessionTxn.EndTime;
dbContext.SessionTxns.Attach(es);
dbContext.Entry(es).Property(a => a.EndTime).IsModified = true;
dbContext.Entry(es).State = EntityState.Modified;
dbContext.SaveChanges();
}
responseData.Results = es;
responseData.Status = "OK";
}
#endregion
else
{
responseData.Results = "Wrong data";
responseData.Status = "OK";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + "exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Put()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
try
{
BillingDbContext billingDbContext = new BillingDbContext(connString);
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
if (reqType == "update-adtItems-duration")
{
List <BedDurationTxnDetailsVM> bedDurationDetails = DanpheJSONConvert.DeserializeObject <List <BedDurationTxnDetailsVM> >(str);
if (bedDurationDetails != null && bedDurationDetails.Count > 0)
{
double totalDuration = bedDurationDetails[0].TotalDays;
int patientVisitId = bedDurationDetails[0].PatientVisitId;
BillingTransactionItemModel billItem = new BillingTransactionItemModel();
//foreach (var bedItem in bedDurationDetails)
//{
// billItem = (from bill in billingDbContext.BillingTransactionItems
// where bill.PatientVisitId == bedItem.PatientVisitId
// && bill.ServiceDepartmentName.ToLower() == "bed charges"
// && bill.ItemId == bedItem.BedFeatureId
// select bill).FirstOrDefault();
// if (billItem != null)
// {
// billItem.Quantity = bedItem.Days;
// billItem.SubTotal = bedItem.SubTotal;
// billItem.TaxableAmount = bedItem.TaxableAmount;
// billItem.NonTaxableAmount = bedItem.NonTaxableAmount;
// //sud,Yub : 11Feb'19 -- Re-Calculate DiscountAmount based on Existing Discount Percent.
// billItem.DiscountAmount = (bedItem.SubTotal * billItem.DiscountPercent) / 100;
// billItem.TotalAmount = billItem.SubTotal - billItem.DiscountAmount;
// billingDbContext.Entry(billItem).Property(a => a.Quantity).IsModified = true;
// billingDbContext.Entry(billItem).Property(a => a.SubTotal).IsModified = true;
// billingDbContext.Entry(billItem).Property(a => a.TaxableAmount).IsModified = true;
// billingDbContext.Entry(billItem).Property(a => a.NonTaxableAmount).IsModified = true;
// billingDbContext.Entry(billItem).Property(a => a.DiscountAmount).IsModified = true;
// billingDbContext.Entry(billItem).Property(a => a.TotalAmount).IsModified = true;
// }
//}
//update duration for Medical and Resident officer/Nursing Charges
billItem = (from bill in billingDbContext.BillingTransactionItems
join itmCfg in billingDbContext.BillItemPrice on new { bill.ServiceDepartmentId, bill.ItemId } equals new { itmCfg.ServiceDepartmentId, itmCfg.ItemId }
where bill.PatientVisitId == patientVisitId && itmCfg.IntegrationName == "Medical and Resident officer/Nursing Charges"
select bill).FirstOrDefault();
if (billItem != null)
{
billItem.Quantity = totalDuration > 0 ? totalDuration : 1;
billItem.SubTotal = billItem.Price * billItem.Quantity;
//sud,Yub : 11Feb'19 -- Re-Calculate DiscountAmount based on Existing Discount Percent.
billItem.DiscountAmount = (billItem.SubTotal * billItem.DiscountPercent) / 100;
billItem.TotalAmount = billItem.SubTotal - billItem.DiscountAmount;
// billItem.TotalAmount = billItem.NonTaxableAmount = billItem.SubTotal;//removed: sud:11Feb'19--this is incorrect.
billingDbContext.Entry(billItem).Property(a => a.Quantity).IsModified = true;
billingDbContext.Entry(billItem).Property(a => a.SubTotal).IsModified = true;
billingDbContext.Entry(billItem).Property(a => a.DiscountAmount).IsModified = true;
billingDbContext.Entry(billItem).Property(a => a.TotalAmount).IsModified = true;
billingDbContext.Entry(billItem).Property(a => a.NonTaxableAmount).IsModified = true;
}
responseData.Status = "OK";
billingDbContext.SaveChanges();
responseData.Results = "quantity updated";
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Unable to upadate bed duration details.";
}
}
else if (reqType == "update-billtxnItem")
{
List <BillingTransactionItemModel> txnItems = DanpheJSONConvert.DeserializeObject <List <BillingTransactionItemModel> >(str);
if (txnItems != null)
{
txnItems.ForEach(item =>
{
BillingTransactionBL.UpdateBillingTransactionItems(billingDbContext, item);
});
}
responseData.Status = "OK";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
//return null;
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
try
{
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
//MasterDbContext masterDbContext = new MasterDbContext(connString);
if (reqType == "set-landing-page")
{
RbacDbContext rbacdbContext = new RbacDbContext(connString);
RbacUser user = DanpheJSONConvert.DeserializeObject <RbacUser>(str);
if (user != null)
{
var currUser = rbacdbContext.Users.Where(a => a.UserId == user.UserId).Select(a => a).FirstOrDefault();
currUser.LandingPageRouteId = user.LandingPageRouteId;
rbacdbContext.Users.Attach(currUser);
rbacdbContext.Entry(currUser).Property(a => a.LandingPageRouteId).IsModified = true;
rbacdbContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = currUser.LandingPageRouteId;
}
}
// if (reqType != null && reqType == "AddToPreference")
// {
// string preferenceType = this.ReadQueryStringData("preferenceType");
// string preferenceName = null;
// string preferenceIdType = null;
// if (preferenceType == "lab")
// {
// preferenceName = "Labtestpreferences";
// preferenceIdType = "LabTestId";
// }
// else if (preferenceType == "imaging")
// {
// preferenceName = "Imagingpreferences";
// preferenceIdType = "ImagingItemId";
// }
// else if(preferenceType == "medication")
// {
// preferenceName = "Medicationpreferences";
// preferenceIdType = "MedicineId";
// }
// string clientValue = this.ReadPostData();
// RbacUser currentUser = HttpContext.Session.Get<RbacUser>("currentuser");
// EmployeePreferences employeePreference = (from pref in masterDbContext.EmployeePreferences
// where pref.EmployeeId == currentUser.EmployeeId && pref.PreferenceName == preferenceName
// select pref).FirstOrDefault();
// if (employeePreference == null)
// {
// //this is used to convert string into xml
// XmlDocument xdoc = JsonConvert.DeserializeXmlNode("{\"Row\":{" + preferenceIdType + ":" + clientValue + "}}", "root");
// //this is add new perference
// EmployeePreferences employeePref = new EmployeePreferences();
// employeePref.PreferenceName = preferenceName;
// employeePref.PreferenceValue = xdoc.InnerXml;
// employeePref.EmployeeId = currentUser.EmployeeId;
// employeePref.CreatedBy = currentUser.EmployeeId; ;
// employeePref.CreatedOn = DateTime.Now;
// employeePref.IsActive = true;
// masterDbContext.EmployeePreferences.Add(employeePref);
// masterDbContext.SaveChanges();
// responseData.Status = "OK";
// responseData.Results = clientValue;
// }
// else
// {
// //creating object of XmlDocument
// XmlDocument prefXmlDoc = new XmlDocument();
// //loading the database PreferenceValue in object of XmlDocument(prefXmlDoc)
// prefXmlDoc.LoadXml(employeePreference.PreferenceValue);
// //creating xmlElement with tag Row
// XmlElement Row = prefXmlDoc.CreateElement("Row");
// //creating xmlElement with tag LabTestId/ImagingTypeId
// XmlElement typeId = prefXmlDoc.CreateElement(preferenceIdType);
// //provididng value to the element of LabTestId/ImagingTypeId
// typeId.InnerText = clientValue;
// //appending LabTestId/ImagingTypeId element ot Row element as child
// Row.AppendChild(typeId);
// //Appending the Row elemt to the root element of xml
// prefXmlDoc.DocumentElement.AppendChild(Row);
// //replacing the old value of employeePreference.PreferenceValue with new one
// employeePreference.PreferenceValue = prefXmlDoc.InnerXml;
// employeePreference.ModifiedBy = currentUser.EmployeeId;
// employeePreference.ModifiedOn = DateTime.Now;
// masterDbContext.Entry(employeePreference).State = EntityState.Modified;
// masterDbContext.SaveChanges();
// responseData.Status = "OK";
// responseData.Results = clientValue;
// }
// }
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
[HttpPost]// POST api/values
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
int CreatedBy = ToInt(this.ReadQueryStringData("CreatedBy"));
responseData.Status = "OK";//by default status would be OK, hence assigning at the top
string ipDataString = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
try
{
BillingDbContext billingDbContext = new BillingDbContext(connString);
if (reqType == "postSettlementInvoice")//submit
{
BillSettlementModel settlement = DanpheJSONConvert.DeserializeObject <BillSettlementModel>(ipDataString);
//List<BillingTransactionItemModel> billTxnItm = DanpheJSONConvert.DeserializeObject<List<BillingTransactionItemModel>>(ipDataString);
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
using (var dbTransaction = billingDbContext.Database.BeginTransaction())
{
try
{
var txns = settlement.BillingTransactions;
//step:0, As EF automatically Inserts Child collection (billingtransactionmodel) while inserting settlement
// we have to first create a new list and set settlement.BillingTransactions as null.
List <BillingTransactionModel> newTxnList = new List <BillingTransactionModel>();
foreach (BillingTransactionModel txn in txns)
{
BillingTransactionModel newTxn = BillingTransactionModel.GetCloneWithItems(txn);
newTxnList.Add(newTxn);
}
settlement.BillingTransactions = null;
//Step1: assign server side values to the input model and Save the settlementModel
settlement.SettlementReceiptNo = GetSettlementReceiptNo(billingDbContext);
settlement.CreatedOn = System.DateTime.Now;
settlement.SettlementDate = System.DateTime.Now;
settlement.FiscalYearId = BillingBL.GetFiscalYear(billingDbContext).FiscalYearId;
settlement.CreatedBy = currentUser.EmployeeId;
billingDbContext.BillSettlements.Add(settlement);
billingDbContext.SaveChanges();
if (newTxnList != null && newTxnList.Count > 0)
{
//step2: Update necessary fields of BillingTransaction acc to above Settlement Object
foreach (var txn in newTxnList)
{
billingDbContext.BillingTransactions.Attach(txn);
txn.SettlementId = settlement.SettlementId;
txn.BillStatus = "paid";
txn.PaidAmount = txn.TotalAmount;
txn.PaidDate = settlement.SettlementDate;
txn.PaymentReceivedBy = currentUser.EmployeeId; //added: sud: 29may'18
txn.PaidCounterId = settlement.CounterId; //added: sud: 29may'18
billingDbContext.Entry(txn).Property(b => b.BillStatus).IsModified = true;
billingDbContext.Entry(txn).Property(b => b.SettlementId).IsModified = true;
billingDbContext.Entry(txn).Property(b => b.PaidAmount).IsModified = true;
billingDbContext.Entry(txn).Property(b => b.PaidDate).IsModified = true;
billingDbContext.Entry(txn).Property(b => b.PaymentReceivedBy).IsModified = true; //added: sud: 29may'18
billingDbContext.Entry(txn).Property(b => b.PaidCounterId).IsModified = true; //added: sud: 29may'18
//setp3: Update BillStatus and PaidDate of each transaction items attached with above transactions
List <BillingTransactionItemModel> txnItems = billingDbContext.BillingTransactionItems
.Where(b => b.BillingTransactionId == txn.BillingTransactionId).ToList();
if (txnItems != null && txnItems.Count > 0)
{
for (int i = 0; i < txnItems.Count; i++)
{
txnItems[i] = BillingTransactionBL.UpdateTxnItemBillStatus(billingDbContext,
txnItems[i],
"paid",
currentUser.EmployeeId,
settlement.SettlementDate,
settlement.CounterId);
}
billingDbContext.SaveChanges();
}
}
billingDbContext.SaveChanges();
}
//step: 4 Add new row to deposit table if Deposit is deducted
if (settlement.DepositDeducted != null && settlement.DepositDeducted > 0)
{
VisitModel patientVisit = billingDbContext.Visit.Where(visit => visit.PatientId == settlement.PatientId)
.OrderByDescending(a => a.PatientVisitId)
.FirstOrDefault();
BillingDeposit depositModel = new BillingDeposit()
{
Amount = settlement.DepositDeducted,
DepositType = "depositdeduct",
IsActive = true,
FiscalYearId = BillingBL.GetFiscalYear(billingDbContext).FiscalYearId,
Remarks = "Deposit used in Settlement Receipt No. SR" + settlement.SettlementReceiptNo + " on " + settlement.SettlementDate,
CreatedBy = currentUser.EmployeeId,
CreatedOn = DateTime.Now,
CounterId = settlement.CounterId,
PatientVisitId = patientVisit != null ? (int?)patientVisit.PatientVisitId : null,
SettlementId = settlement.SettlementId,
PatientId = settlement.PatientId,
DepositBalance = 0,
ReceiptNo = BillingBL.GetDepositReceiptNo(connString),
PaymentMode = "cash",//yubraj 4th July '19
};
billingDbContext.BillingDeposits.Add(depositModel);
billingDbContext.SaveChanges();
////update iscurrent and isactive in deposit table for settlement
//List<BillingDeposit> depositDetail= (from dep in billingDbContext.BillingDeposits
// where dep.PatientId==settlement.PatientId &&
// dep.IsCurrent==true &&
// dep.IsActive==true
// select dep).ToList();
//if (depositDetail != null)
//{
// depositDetail.ForEach(d =>
// {
// //d.IsActive = false;
// d.IsCurrent = false;
// billingDbContext.SaveChanges();
// });
//}
}
dbTransaction.Commit();
responseData.Status = "OK";
responseData.Results = settlement;
}
catch (Exception ex)
{
dbTransaction.Rollback();
responseData.Status = "Failed";
responseData.ErrorMessage = ex.ToString();
}
}
}
//responseData.Results = null;
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
//if reqtype=employee, then use masterdbcontext.employee.add and so on for others.
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>(); //type 'object' since we have variable return types
responseData.Status = "OK"; //by default status would be OK, hence assigning at the top
InventoryDbContext inventoryDBContext = new InventoryDbContext(connString);
try
{
//string str = Request.Form.Keys.First<string>();
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
string vendorName = this.ReadQueryStringData("vendorName");
int itemId = ToInt(this.ReadQueryStringData("itemId"));
if (reqType == "AddVendors")
{
VendorMasterModel vendorModel = DanpheJSONConvert.DeserializeObject <VendorMasterModel>(str);
vendorModel.CreatedOn = System.DateTime.Now;
inventoryDBContext.Vendors.Add(vendorModel);
inventoryDBContext.SaveChanges();
responseData.Results = vendorModel;
responseData.Status = "OK";
}
else if (reqType == "AddItemCategory")
{
ItemCategoryMasterModel itemcategoryModel = DanpheJSONConvert.DeserializeObject <ItemCategoryMasterModel>(str);
itemcategoryModel.CreatedOn = System.DateTime.Now;
inventoryDBContext.ItemCategoryMaster.Add(itemcategoryModel);
inventoryDBContext.SaveChanges();
responseData.Results = itemcategoryModel;
responseData.Status = "OK";
}
else if (reqType == "AddItemSubCategory")
{
ItemSubCategoryMasterModel itemsubcategoryModel = DanpheJSONConvert.DeserializeObject <ItemSubCategoryMasterModel>(str);
itemsubcategoryModel.CreatedOn = System.DateTime.Now;
inventoryDBContext.ItemSubCategoryMaster.Add(itemsubcategoryModel);
inventoryDBContext.SaveChanges();
responseData.Results = itemsubcategoryModel;
responseData.Status = "OK";
}
//posting to inventory terms & conditions
else if (reqType == "PostInventoryTerms")
{
InventoryTermsModel termsconditions = DanpheJSONConvert.DeserializeObject <InventoryTermsModel>(str);
termsconditions.CreatedOn = System.DateTime.Now;
inventoryDBContext.InventoryTerms.Add(termsconditions);
inventoryDBContext.SaveChanges();
responseData.Results = termsconditions;
responseData.Status = "OK";
}
else if (reqType == "AddUnitOfMeasurement")
{
UnitOfMeasurementMasterModel unitofmeasurementModel = DanpheJSONConvert.DeserializeObject <UnitOfMeasurementMasterModel>(str);
unitofmeasurementModel.CreatedOn = System.DateTime.Now;
inventoryDBContext.UnitOfMeasurementMaster.Add(unitofmeasurementModel);
inventoryDBContext.SaveChanges();
responseData.Results = unitofmeasurementModel;
responseData.Status = "OK";
}
else if (reqType == "AddPackagingType")
{
PackagingTypeMasterModel packagingtypeModel = DanpheJSONConvert.DeserializeObject <PackagingTypeMasterModel>(str);
packagingtypeModel.CreatedOn = System.DateTime.Now;
inventoryDBContext.PackagingTypeMaster.Add(packagingtypeModel);
inventoryDBContext.SaveChanges();
responseData.Results = packagingtypeModel;
responseData.Status = "OK";
}
else if (reqType == "AddAccountHead")
{
AccountHeadMasterModel accountheadModel = DanpheJSONConvert.DeserializeObject <AccountHeadMasterModel>(str);
accountheadModel.CreatedOn = System.DateTime.Now;
inventoryDBContext.AccountHeadMaster.Add(accountheadModel);
inventoryDBContext.SaveChanges();
responseData.Results = accountheadModel;
responseData.Status = "OK";
}
else if (reqType == "AddItem")
{
ItemMasterModel itemModel = DanpheJSONConvert.DeserializeObject <ItemMasterModel>(str);
itemModel.CreatedOn = System.DateTime.Now;
inventoryDBContext.Items.Add(itemModel);
inventoryDBContext.SaveChanges();
responseData.Results = itemModel;
responseData.Status = "OK";
}
else if (reqType == "AddCurrency")
{
CurrencyMasterModel currencyModel = DanpheJSONConvert.DeserializeObject <CurrencyMasterModel>(str);
currencyModel.CreatedOn = System.DateTime.Now;
inventoryDBContext.CurrencyMaster.Add(currencyModel);
inventoryDBContext.SaveChanges();
responseData.Results = currencyModel;
responseData.Status = "OK";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
//if reqtype=employee, then use masterdbcontext.employee.add and so on for others.
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>(); //type 'object' since we have variable return types
responseData.Status = "OK"; //by default status would be OK, hence assigning at the top
AccountingDbContext accountingDBContext = new AccountingDbContext(connString);
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
try
{
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
string companyName = this.ReadQueryStringData("companyName");
if (reqType == "AddLedgers")
{
LedgerModel ledger = DanpheJSONConvert.DeserializeObject <LedgerModel>(str);
if (accountingDBContext.Ledgers.Any(r => r.LedgerGroupId == ledger.LedgerGroupId && r.LedgerName == ledger.LedgerName))
{
responseData.Status = "Failed";
}
else
{
ledger.CreatedOn = System.DateTime.Now;
accountingDBContext.Ledgers.Add(ledger);
accountingDBContext.SaveChanges();
if (ledger.LedgerType == "pharmacysupplier")
{
LedgerMappingModel ledgerMapping = new LedgerMappingModel();
ledgerMapping.LedgerId = ledger.LedgerId;
ledgerMapping.LedgerType = ledger.LedgerType;
ledgerMapping.ReferenceId = (int)ledger.LedgerReferenceId;
accountingDBContext.LedgerMappings.Add(ledgerMapping);
}
accountingDBContext.SaveChanges();
responseData.Results = ledger;
responseData.Status = "OK";
}
}
if (reqType == "AddLedgersList")
{
List <LedgerModel> Ledgrs = DanpheJSONConvert.DeserializeObject <List <LedgerModel> >(str);
//if (accountingDBContext.Ledgers.Any(r => r.LedgerGroupId == ledger.LedgerGroupId && r.LedgerName == ledger.LedgerName))
//{
// responseData.Status = "Failed";
//}
//else
//{
Ledgrs.ForEach(ledger =>
{
ledger.CreatedOn = System.DateTime.Now;
accountingDBContext.Ledgers.Add(ledger);
accountingDBContext.SaveChanges();
if (ledger.LedgerType == "pharmacysupplier")
{
LedgerMappingModel ledgerMapping = new LedgerMappingModel();
ledgerMapping.LedgerId = ledger.LedgerId;
ledgerMapping.LedgerType = ledger.LedgerType;
ledgerMapping.ReferenceId = (int)ledger.LedgerReferenceId;
accountingDBContext.LedgerMappings.Add(ledgerMapping);
}
});
accountingDBContext.SaveChanges();
responseData.Results = Ledgrs;
responseData.Status = "OK";
//}
}
else if (reqType == "AddVouchers")
{
VoucherModel voucher = DanpheJSONConvert.DeserializeObject <VoucherModel>(str);
voucher.CreatedOn = System.DateTime.Now;
voucher.CreatedBy = currentUser.UserId;
accountingDBContext.Vouchers.Add(voucher);
accountingDBContext.SaveChanges();
responseData.Results = voucher;
responseData.Status = "OK";
}
else if (reqType == "AddVoucherHead")
{
VoucherHeadModel voucherHead = DanpheJSONConvert.DeserializeObject <VoucherHeadModel>(str);
if (accountingDBContext.VoucherHeads.Any(x => x.VoucherHeadId == voucherHead.VoucherHeadId && x.VoucherHeadName == voucherHead.VoucherHeadName))
{
responseData.Status = "Failed";
}
else
{
voucherHead.CreatedOn = System.DateTime.Now;
voucherHead.CreatedBy = currentUser.UserId;
accountingDBContext.VoucherHeads.Add(voucherHead);
accountingDBContext.SaveChanges();
responseData.Results = voucherHead;
responseData.Status = "OK";
}
}
else if (reqType == "AddItems")
{
ItemModel item = DanpheJSONConvert.DeserializeObject <ItemModel>(str);
item.CreatedOn = System.DateTime.Now;
accountingDBContext.Items.Add(item);
accountingDBContext.SaveChanges();
var itemWithLedgerName = (from led in accountingDBContext.Ledgers
where led.LedgerId == item.LedgerId
select new
{
ItemId = item.ItemId,
ItemName = item.ItemName,
AvailableQuantity = item.AvailableQuantity,
IsActive = item.IsActive,
Description = item.Description,
LedgerId = item.LedgerId,
LedgerName = led.LedgerName
}
);
responseData.Results = itemWithLedgerName;
responseData.Status = "OK";
}
else if (reqType == "AddLedgersGroup")
{
LedgerGroupModel ledgerGrpData = DanpheJSONConvert.DeserializeObject <LedgerGroupModel>(str);
if (accountingDBContext.LedgerGroups.Any(r => r.LedgerGroupName == ledgerGrpData.LedgerGroupName && r.COA == ledgerGrpData.COA && r.PrimaryGroup == ledgerGrpData.PrimaryGroup))
{
responseData.Status = "Failed";
}
else
{
ledgerGrpData.CreatedOn = DateTime.Now;
ledgerGrpData.CreatedBy = currentUser.UserId;
accountingDBContext.LedgerGroups.Add(ledgerGrpData);
accountingDBContext.SaveChanges();
responseData.Results = ledgerGrpData;
responseData.Status = "OK";
}
}
else if (reqType == "manageVoucherWithLedgegroup")
{
List <VoucherLedgerGroupMapModel> mappedData = DanpheJSONConvert.DeserializeObject <List <VoucherLedgerGroupMapModel> >(str);
var postMappedLedgerGroup = new List <VoucherLedgerGroupMapModel>();
var putMappedLedgerGroup = new List <VoucherLedgerGroupMapModel>();
//map and separate two list for add and update
mappedData.ForEach(x =>
{
if (x.actionName == "post")
{
x.CreatedOn = DateTime.Now;
x.CreatedBy = currentUser.UserId;
postMappedLedgerGroup.Add(x);
}
else if (x.actionName == "put")
{
putMappedLedgerGroup.Add(x);
}
});
//update
foreach (var itm in putMappedLedgerGroup)
{
accountingDBContext.VoucherLedgerGroupMaps.Attach(itm);
accountingDBContext.Entry(itm).Property(x => x.IsActive).IsModified = true;
}
accountingDBContext.SaveChanges();
//add
foreach (var itm in postMappedLedgerGroup)
{
accountingDBContext.VoucherLedgerGroupMaps.Add(itm);
}
accountingDBContext.SaveChanges();
responseData.Status = "OK";
}
else if (reqType == "AddFiscalYear")
{
FiscalYearModel fsModel = DanpheJSONConvert.DeserializeObject <FiscalYearModel>(str);
var checkFiscalYear = (from fs in accountingDBContext.FiscalYears
where ((fs.FiscalYearName == fsModel.FiscalYearName) && (fs.IsActive == true))
select fs).FirstOrDefault();
if (checkFiscalYear != null)
{
fsModel = null;
responseData.Results = fsModel;
}
else
{
fsModel.CreatedOn = System.DateTime.Now;
fsModel.CreatedBy = currentUser.UserId;
accountingDBContext.FiscalYears.Add(fsModel);
accountingDBContext.SaveChanges();
var fiscalCurtData = (from fisCal in accountingDBContext.FiscalYears
where fisCal.FiscalYearId == fsModel.FiscalYearId
select new
{
FiscalYearId = fisCal.FiscalYearId,
FiscalYearName = fisCal.FiscalYearName,
StartYear = fisCal.StartDate,
EndYear = fisCal.EndDate,
Description = fisCal.Description,
IsActive = fisCal.IsActive,
});
responseData.Results = fiscalCurtData;
}
responseData.Status = "OK";
}
else if (reqType == "AddCostCenterItem")
{
CostCenterItemModel costCenterMod = DanpheJSONConvert.DeserializeObject <CostCenterItemModel>(str);
costCenterMod.CreatedOn = System.DateTime.Now;
costCenterMod.CreatedBy = currentUser.UserId;
accountingDBContext.CostCenterItems.Add(costCenterMod);
accountingDBContext.SaveChanges();
var curtCostCenterItmData = (from costCenterItm in accountingDBContext.CostCenterItems
where costCenterItm.CostCenterItemId == costCenterMod.CostCenterItemId
select new
{
CostCenterItemId = costCenterItm.CostCenterItemId,
CostCenterItemName = costCenterItm.CostCenterItemName,
Description = costCenterItm.Description,
IsActive = costCenterItm.IsActive,
});
responseData.Status = "OK";
responseData.Results = curtCostCenterItmData;
}
else if (reqType == "AddLedgerGroupCategory")
{
LedgerGroupCategoryModel ledGrpCatMod = DanpheJSONConvert.DeserializeObject <LedgerGroupCategoryModel>(str);
ledGrpCatMod.CreatedOn = System.DateTime.Now;
ledGrpCatMod.CreatedBy = currentUser.UserId;
accountingDBContext.LedgerGroupsCategory.Add(ledGrpCatMod);
accountingDBContext.SaveChanges();
var curtLedGrpCategoryData = (from ledgrpCat in accountingDBContext.LedgerGroupsCategory
join chartOfAcc in accountingDBContext.ChartOfAccounts on ledgrpCat.ChartOfAccountId equals chartOfAcc.ChartOfAccountId
where ledgrpCat.LedgerGroupCategoryId == ledGrpCatMod.LedgerGroupCategoryId
select new
{
LedgerGroupCategoryId = ledgrpCat.LedgerGroupCategoryId,
LedgerGroupCategoryName = ledgrpCat.LedgerGroupCategoryName,
ChartOfAccountName = chartOfAcc.ChartOfAccountName,
Description = ledgrpCat.Description,
IsActive = ledgrpCat.IsActive,
IsDebit = ledgrpCat.IsDebit,
});
responseData.Status = "OK";
responseData.Results = curtLedGrpCategoryData;
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
try
{
var req = context.HttpContext.Request;
try
{
//this check only for dicom file posting
//this condition is used for checking datas of listener.exe
if (req.Method.ToUpper() == "POST" && req.Path.Value.ToString() == "/api/Dicom")
{
string bodyData = ReadBodyAsString(context.HttpContext.Request);
var obj = JObject.Parse(bodyData);
RbacUser currUser = DanpheJSONConvert.DeserializeObject <RbacUser>(obj["currentuser"].ToString());
var flag = RBAC.IsValidUser(currUser.UserName, currUser.Password);
if (flag == false)
{
context.Result = new JsonResult(new DanpheHTTPResponse <object> {
Status = "Failed", ErrorMessage = "Unauthorized Access", Results = ""
});
}
}
else
{
//Checking user is logged in or not
RbacUser currentUser = context.HttpContext.Session.Get <RbacUser>("currentuser");
if (currentUser == null)
{
//Return unauthorized response to browser
context.Result = new JsonResult(new DanpheHTTPResponse <object> {
Status = "Failed", ErrorMessage = "Unauthorized Access", Results = ""
});
}
}
}
catch (Exception ex)
{
//Return unauthorized response to browser
context.Result = new JsonResult(new DanpheHTTPResponse <object> {
Status = "Failed", ErrorMessage = "Unauthorized Access", Results = ""
});
}
////Nagesh- 29 Aug 2017- Commented because we are not checking permission level for api call, only checking is Authenticated user or not
//else
// {
////Get all valid permissions for logged in user from session variable
//List<RbacPermission> validPermissionList = context.HttpContext.Session.Get<List<RbacPermission>>("validpermissionlist");
//if (validPermissionList.Count > 0)
//{
// RbacPermission currentPermission = validPermissionList.Find(a => a.PermissionName == apiPermissionName);
// //Check is currentPermission has value or not
// //if (currentPermission == null || currentPermission.PermissionName == null)
// if ("sssss" != apiPermissionName)
// {
// //Return unauthorized response to browser
// context.Result = new JsonResult(new DanpheHTTPResponse<object>{ Status = "Failed", ErrorMessage = "Unauthorized Access", Results = "" });
// }
//}
//else
//{
// //Return unauthorized response to browser
// context.Result = new JsonResult(new { HttpStatusCode.Unauthorized });
//}
// }
}
catch (Exception ex)
{
//Write exception handling logic here
throw ex;
}
}
public string Update(/*string reqType*/)
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
AccountingDbContext accountingDBContext = new AccountingDbContext(connString);
try
{
//string str = Request.Form.Keys.First<string>();
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
if (!String.IsNullOrEmpty(str))
{
if (reqType == "itemISActive")
{
ItemModel item = DanpheJSONConvert.DeserializeObject <ItemModel>(str);
accountingDBContext.Items.Attach(item);
accountingDBContext.Entry(item).Property(x => x.IsActive).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Results = item;
responseData.Status = "OK";
}
else if (reqType == "ledgerISActive")
{
LedgerModel ledger = DanpheJSONConvert.DeserializeObject <LedgerModel>(str);
accountingDBContext.Ledgers.Attach(ledger);
accountingDBContext.Entry(ledger).Property(x => x.IsActive).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Results = ledger;
responseData.Status = "OK";
}
else if (reqType == "updateLedgerGrpIsActive")
{
LedgerGroupModel ledgerGrp = DanpheJSONConvert.DeserializeObject <LedgerGroupModel>(str);
accountingDBContext.LedgerGroups.Attach(ledgerGrp);
accountingDBContext.Entry(ledgerGrp).Property(x => x.IsActive).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = ledgerGrp;
}
else if (reqType == "updateLedgerGroup")
{
LedgerGroupModel ledgerGroup = DanpheJSONConvert.DeserializeObject <LedgerGroupModel>(str);
var ledgerGrp = accountingDBContext.LedgerGroups.Where(x => x.LedgerGroupId == ledgerGroup.LedgerGroupId).FirstOrDefault();
if (ledgerGrp != null)
{
ledgerGrp.COA = ledgerGroup.COA;
ledgerGrp.Description = ledgerGroup.Description;
ledgerGrp.IsActive = ledgerGroup.IsActive;
ledgerGrp.LedgerGroupName = ledgerGroup.LedgerGroupName;
ledgerGrp.ModifiedBy = ledgerGroup.ModifiedBy;
ledgerGrp.ModifiedOn = System.DateTime.Now;
ledgerGrp.PrimaryGroup = ledgerGroup.PrimaryGroup;
accountingDBContext.LedgerGroups.Attach(ledgerGrp);
accountingDBContext.Entry(ledgerGrp).Property(x => x.COA).IsModified = true;
accountingDBContext.Entry(ledgerGrp).Property(x => x.Description).IsModified = true;
accountingDBContext.Entry(ledgerGrp).Property(x => x.IsActive).IsModified = true;
accountingDBContext.Entry(ledgerGrp).Property(x => x.LedgerGroupName).IsModified = true;
accountingDBContext.Entry(ledgerGrp).Property(x => x.ModifiedBy).IsModified = true;
accountingDBContext.Entry(ledgerGrp).Property(x => x.ModifiedOn).IsModified = true;
accountingDBContext.Entry(ledgerGrp).Property(x => x.PrimaryGroup).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Results = ledgerGrp;
responseData.Status = "OK";
}
else
{
responseData.Status = "Failed";
}
}
else if (reqType == "updateFiscalYearStatus")
{
FiscalYearModel fiscalYearModel = DanpheJSONConvert.DeserializeObject <FiscalYearModel>(str);
accountingDBContext.FiscalYears.Attach(fiscalYearModel);
accountingDBContext.Entry(fiscalYearModel).Property(x => x.IsActive).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = fiscalYearModel;
}
else if (reqType == "updateCostCenterItemStatus")
{
CostCenterItemModel ccImodel = DanpheJSONConvert.DeserializeObject <CostCenterItemModel>(str);
accountingDBContext.CostCenterItems.Attach(ccImodel);
accountingDBContext.Entry(ccImodel).Property(x => x.IsActive).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = ccImodel;
}
else if (reqType == "updateLedgerGrpCategoryIsActive")
{
LedgerGroupCategoryModel ledgerGrpCat = DanpheJSONConvert.DeserializeObject <LedgerGroupCategoryModel>(str);
accountingDBContext.LedgerGroupsCategory.Attach(ledgerGrpCat);
accountingDBContext.Entry(ledgerGrpCat).Property(x => x.IsActive).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = ledgerGrpCat;
}
else if (reqType == "UpdateLedger")
{
LedgerModel ledger = DanpheJSONConvert.DeserializeObject <LedgerModel>(str);
var led = accountingDBContext.Ledgers.Where(s => s.LedgerId == ledger.LedgerId).FirstOrDefault();
if (led != null)
{
led.IsActive = ledger.IsActive;
led.LedgerName = ledger.LedgerName;
led.OpeningBalance = ledger.OpeningBalance;
led.Description = ledger.Description;
led.IsCostCenterApplicable = ledger.IsCostCenterApplicable;
led.DrCr = ledger.DrCr;
accountingDBContext.Ledgers.Attach(led);
accountingDBContext.Entry(led).Property(x => x.IsActive).IsModified = true;
accountingDBContext.Entry(led).Property(x => x.LedgerName).IsModified = true;
accountingDBContext.Entry(led).Property(x => x.Description).IsModified = true;
accountingDBContext.Entry(led).Property(x => x.DrCr).IsModified = true;
accountingDBContext.Entry(led).Property(x => x.IsCostCenterApplicable).IsModified = true;
accountingDBContext.Entry(led).Property(x => x.OpeningBalance).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = led;
}
else
{
responseData.Status = "Failed";
}
}
else if (reqType == "UpdateVoucherHead")
{
VoucherHeadModel voucher = DanpheJSONConvert.DeserializeObject <VoucherHeadModel>(str);
var voucherHead = accountingDBContext.VoucherHeads.Where(s => s.VoucherHeadId == voucher.VoucherHeadId).FirstOrDefault();
if (voucherHead != null)
{
voucherHead.IsActive = voucher.IsActive;
voucherHead.VoucherHeadName = voucher.VoucherHeadName;
voucherHead.Description = voucher.Description;
voucherHead.ModifiedOn = System.DateTime.Now;
voucherHead.ModifiedBy = voucher.ModifiedBy;
accountingDBContext.VoucherHeads.Attach(voucherHead);
accountingDBContext.Entry(voucherHead).Property(x => x.IsActive).IsModified = true;
accountingDBContext.Entry(voucherHead).Property(x => x.VoucherHeadName).IsModified = true;
accountingDBContext.Entry(voucherHead).Property(x => x.Description).IsModified = true;
accountingDBContext.Entry(voucherHead).Property(x => x.ModifiedOn).IsModified = true;
accountingDBContext.Entry(voucherHead).Property(x => x.ModifiedBy).IsModified = true;
accountingDBContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = voucherHead;
}
else
{
responseData.Status = "Failed";
}
}
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Update(/*string reqType*/)
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
InventoryDbContext inventoryDBContext = new InventoryDbContext(connString);
try
{
//string str = Request.Form.Keys.First<string>();
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
if (!String.IsNullOrEmpty(str))
{
if (reqType == "UpdateVendors")
{
VendorMasterModel vendor = DanpheJSONConvert.DeserializeObject <VendorMasterModel>(str);
inventoryDBContext.Vendors.Attach(vendor);
inventoryDBContext.Entry(vendor).State = EntityState.Modified;
inventoryDBContext.Entry(vendor).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(vendor).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = vendor;
responseData.Status = "OK";
}
else if (reqType == "UpdateInventoryTerms")
{
InventoryTermsModel termsconditions = DanpheJSONConvert.DeserializeObject <InventoryTermsModel>(str);
inventoryDBContext.InventoryTerms.Attach(termsconditions);
inventoryDBContext.Entry(termsconditions).State = EntityState.Modified;
inventoryDBContext.Entry(termsconditions).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(termsconditions).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = termsconditions;
responseData.Status = "OK";
}
if (reqType == "UpdateItemCategory")
{
ItemCategoryMasterModel itemcategoryModel = DanpheJSONConvert.DeserializeObject <ItemCategoryMasterModel>(str);
inventoryDBContext.ItemCategoryMaster.Attach(itemcategoryModel);
inventoryDBContext.Entry(itemcategoryModel).State = EntityState.Modified;
inventoryDBContext.Entry(itemcategoryModel).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(itemcategoryModel).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = itemcategoryModel;
responseData.Status = "OK";
}
if (reqType == "UpdateItemSubCategory")
{
ItemSubCategoryMasterModel itemsubcategoryModel = DanpheJSONConvert.DeserializeObject <ItemSubCategoryMasterModel>(str);
inventoryDBContext.ItemSubCategoryMaster.Attach(itemsubcategoryModel);
inventoryDBContext.Entry(itemsubcategoryModel).State = EntityState.Modified;
inventoryDBContext.Entry(itemsubcategoryModel).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(itemsubcategoryModel).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = itemsubcategoryModel;
responseData.Status = "OK";
}
if (reqType == "UpdateUnitOfMeasurement")
{
UnitOfMeasurementMasterModel unitofmeasurementModel = DanpheJSONConvert.DeserializeObject <UnitOfMeasurementMasterModel>(str);
inventoryDBContext.UnitOfMeasurementMaster.Attach(unitofmeasurementModel);
inventoryDBContext.Entry(unitofmeasurementModel).State = EntityState.Modified;
inventoryDBContext.Entry(unitofmeasurementModel).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(unitofmeasurementModel).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = unitofmeasurementModel;
responseData.Status = "OK";
}
if (reqType == "UpdatePackagingType")
{
PackagingTypeMasterModel packagingtypeModel = DanpheJSONConvert.DeserializeObject <PackagingTypeMasterModel>(str);
inventoryDBContext.PackagingTypeMaster.Attach(packagingtypeModel);
inventoryDBContext.Entry(packagingtypeModel).State = EntityState.Modified;
inventoryDBContext.Entry(packagingtypeModel).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(packagingtypeModel).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = packagingtypeModel;
responseData.Status = "OK";
}
if (reqType == "UpdateAccountHead")
{
AccountHeadMasterModel accountheadModel = DanpheJSONConvert.DeserializeObject <AccountHeadMasterModel>(str);
inventoryDBContext.AccountHeadMaster.Attach(accountheadModel);
inventoryDBContext.Entry(accountheadModel).State = EntityState.Modified;
inventoryDBContext.Entry(accountheadModel).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(accountheadModel).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = accountheadModel;
responseData.Status = "OK";
}
if (reqType == "UpdateItem")
{
ItemMasterModel itemModel = DanpheJSONConvert.DeserializeObject <ItemMasterModel>(str);
inventoryDBContext.Items.Attach(itemModel);
inventoryDBContext.Entry(itemModel).State = EntityState.Modified;
inventoryDBContext.Entry(itemModel).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(itemModel).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = itemModel;
responseData.Status = "OK";
}
if (reqType == "UpdateCurrency")
{
CurrencyMasterModel currencyModel = DanpheJSONConvert.DeserializeObject <CurrencyMasterModel>(str);
inventoryDBContext.CurrencyMaster.Attach(currencyModel);
inventoryDBContext.Entry(currencyModel).State = EntityState.Modified;
inventoryDBContext.Entry(currencyModel).Property(x => x.CreatedOn).IsModified = false;
inventoryDBContext.Entry(currencyModel).Property(x => x.CreatedBy).IsModified = false;
inventoryDBContext.SaveChanges();
responseData.Results = currencyModel;
responseData.Status = "OK";
}
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Put()
{
DanpheHTTPResponse <string> responseData = new DanpheHTTPResponse <string>();
try
{
string str = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
string status = this.ReadQueryStringData("status");
int appointmentId = ToInt(this.ReadQueryStringData("appointmentId"));
int patientId = ToInt(this.ReadQueryStringData("patientId"));
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
//update patientId in Appointment Table
if (reqType == "updatePatientId" && patientId != 0)
{
AppointmentDbContext dbContextUpdate = new AppointmentDbContext(connString);
AppointmentModel dbAppointment = dbContextUpdate.Appointments
.Where(a => a.AppointmentId == appointmentId)
.FirstOrDefault <AppointmentModel>();
dbAppointment.PatientId = patientId;
dbContextUpdate.Entry(dbAppointment).State = EntityState.Modified;
dbContextUpdate.SaveChanges();
responseData.Status = "OK";
responseData.Results = "Appointment information updated successfully.";
}
//update appointmentStatus
else if (reqType == "updateAppStatus" && !string.IsNullOrEmpty(status))
{
AppointmentDbContext dbContextUpdate = new AppointmentDbContext(connString);
AppointmentModel dbAppointment = dbContextUpdate.Appointments
.Where(a => a.AppointmentId == appointmentId)
.FirstOrDefault <AppointmentModel>();
dbAppointment.AppointmentStatus = status.ToLower();
dbContextUpdate.Entry(dbAppointment).State = EntityState.Modified;
dbContextUpdate.SaveChanges();
responseData.Status = "OK";
responseData.Results = "Appointment information updated successfully.";
}
else if (reqType == "updateAppointmentStatus")
{
AppointmentDbContext dbContextUpdate = new AppointmentDbContext(connString);
AppointmentModel appointmentData = DanpheJSONConvert.DeserializeObject <AppointmentModel>(str);
dbContextUpdate.Appointments.Attach(appointmentData);
dbContextUpdate.Entry(appointmentData).State = EntityState.Modified;
dbContextUpdate.Entry(appointmentData).Property(x => x.CreatedOn).IsModified = false;
dbContextUpdate.Entry(appointmentData).Property(x => x.CreatedBy).IsModified = false;
appointmentData.CancelledOn = System.DateTime.Now;
appointmentData.CancelledBy = currentUser.EmployeeId;
dbContextUpdate.SaveChanges();
responseData.Status = "OK";
responseData.Results = "Appointment information updated successfully";
}
else
{
//throw new Exception("Cannot match any reqType");
//throw new NotImplementedException("cannot match any request type. given requesttype " + reqType + " is not implemented.");
responseData.Status = "Failed";
responseData.ErrorMessage = "Cannot match any reqType";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
[HttpPost]// POST api/values
public string Post(string reqType)
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
string ipDataString = this.ReadPostData();
responseData.Status = "OK";//by default status would be OK, hence assigning at the top
try
{
BillingDbContext billingDbContext = new BillingDbContext(connString);
MasterDbContext masterDbContext = new MasterDbContext(connString);
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
if (reqType == "returnInvoice")//submit
{
//var currentDate = DateTime.Now;
BillInvoiceReturnModel billInvoiceRet = DanpheJSONConvert.DeserializeObject <BillInvoiceReturnModel>(ipDataString);
if (billInvoiceRet != null)
{
//Transaction Begins
using (var dbContextTransaction = billingDbContext.Database.BeginTransaction())
{
try
{
BillingFiscalYear currFiscYear = BillingBL.GetFiscalYear(billingDbContext);
//credit note number will continue from current fiscal year, regardless whether the bill was generated in earlier fiscal year.. (sud:30Aug'18)
int?maxCreditNoteNum = billingDbContext.BillReturns.Where(a => a.FiscalYearId == currFiscYear.FiscalYearId).Max(a => a.CreditNoteNumber);
billInvoiceRet.CreatedOn = DateTime.Now;
if (maxCreditNoteNum == null || !maxCreditNoteNum.HasValue)
{
maxCreditNoteNum = 0;
}
billInvoiceRet.FiscalYear = currFiscYear.FiscalYearFormatted;
billInvoiceRet.FiscalYearId = currFiscYear.FiscalYearId;
billInvoiceRet.CreditNoteNumber = (int?)(maxCreditNoteNum + 1);
billInvoiceRet.CreatedBy = currentUser.EmployeeId;
billingDbContext.BillReturns.Add(billInvoiceRet);
billingDbContext.SaveChanges();
//update transactiontable after bill is returned..
int invoiceNo = billInvoiceRet.RefInvoiceNum;
//BillingTransactionModel billTxn = billingDbContext.BillingTransactions
// .Where(b => b.InvoiceNo == billInvoiceRet.RefInvoiceNum)
// .FirstOrDefault();
//changed: sud: 18July, since Invoice No will repeat with fiscal year, so need to find by billingtransactionid.
BillingTransactionModel billTxn = billingDbContext.BillingTransactions
.Where(b => b.BillingTransactionId == billInvoiceRet.BillingTransactionId)
.FirstOrDefault();
billingDbContext.BillingTransactions.Attach(billTxn);
billTxn.ReturnStatus = true;
billingDbContext.Entry(billTxn).Property(a => a.ReturnStatus).IsModified = true;
billingDbContext.SaveChanges();
if (billTxn.IsInsuranceBilling == true)
{
double deductableInsuranceAmount = (billTxn.TotalAmount ?? default(double)) * -1;
BillingBL.UpdateInsuranceCurrentBalance(connString,
billTxn.PatientId,
billTxn.InsuranceProviderId ?? default(int),
currentUser.EmployeeId, deductableInsuranceAmount, true);
}
var invoiceItems = billingDbContext.BillingTransactionItems.Where(b => b.BillingTransactionId == billInvoiceRet.BillingTransactionId).ToList();
//replaced calling centralized function in BillingBL
for (int i = 0; i < invoiceItems.Count; i++)
{
invoiceItems[i] = BillingTransactionBL.UpdateTxnItemBillStatus(billingDbContext,
invoiceItems[i],
"returned",
currentUser.EmployeeId);
}
//Yubraj: 18th Dec '18 :: Updating IsActive in deposit table while invoice return
List <BillingDeposit> deposit = (from dpt in billingDbContext.BillingDeposits
where dpt.BillingTransactionId == billInvoiceRet.BillingTransactionId &&
(dpt.DepositType == "depositdeduct" || dpt.DepositType == "ReturnDeposit")
select dpt).ToList();
if (deposit != null)
{
deposit.ForEach(a =>
{
a.IsActive = true; //keeping false was affecting the patient deposit info
a.ModifiedRemarks = "Updated after invoice return of BillTxnId: " + billInvoiceRet.BillingTransactionId.ToString();
a.ModifiedOn = DateTime.Now;
a.ModifiedBy = currentUser.EmployeeId;
});
}
billInvoiceRet.ReturnedItems = invoiceItems.ToList();
billingDbContext.SaveChanges();
dbContextTransaction.Commit(); //end of transaction
responseData.Results = billInvoiceRet;
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw ex;
}
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "billTransactionitems is invalid";
}
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
string reqType = this.ReadQueryStringData("reqType");
string ipStr = this.ReadPostData();
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
try
{
LabDbContext labDbContext = new LabDbContext(connString);
BillingDbContext billDbContext = new BillingDbContext(connString);
if (reqType != null && reqType == "postLabReport")
{
LabReportTemplateModel labReportTemplate = DanpheJSONConvert.DeserializeObject <LabReportTemplateModel>(ipStr);
labReportTemplate.CreatedOn = System.DateTime.Now;
labReportTemplate.CreatedBy = currentUser.EmployeeId;
//Remove Previous Default Template Set and make the current one default by Assigning IsDefault of previous to False and Current to True
if (labReportTemplate.IsDefault == true)
{
LabReportTemplateModel rowToUpdate = (from rep in labDbContext.LabReportTemplates
where rep.IsDefault == true
select rep
).FirstOrDefault();
labDbContext.LabReportTemplates.Attach(rowToUpdate);
rowToUpdate.IsDefault = false;
labDbContext.SaveChanges();
}
labDbContext.LabReportTemplates.Add(labReportTemplate);
labDbContext.SaveChanges();
responseData.Results = labReportTemplate;
}
else if (reqType == "postLabTest")
{
using (var dbContextTransaction = labDbContext.Database.BeginTransaction())
{
try
{
LabTestModel labTest = DanpheJSONConvert.DeserializeObject <LabTestModel>(ipStr);
BillItemPrice billItemPrice = new BillItemPrice();
labTest.CreatedBy = currentUser.EmployeeId;
labTest.CreatedOn = System.DateTime.Now;
labDbContext.LabTests.Add(labTest);
labDbContext.SaveChanges();
var labComponentMapList = labTest.LabTestComponentMap;
if (labTest.TemplateType.ToLower() == "html")
{
var htmlComp = labTest.LabTestComponentsJSON[0];
labDbContext.LabTestComponents.Add(htmlComp);
labDbContext.SaveChanges();
LabTestComponentMapModel htmlCompToMap = new LabTestComponentMapModel();
htmlCompToMap.ComponentId = htmlComp.ComponentId;
htmlCompToMap.LabTestId = labTest.LabTestId;
htmlCompToMap.CreatedBy = currentUser.EmployeeId;
htmlCompToMap.CreatedOn = System.DateTime.Now;
htmlCompToMap.IsActive = true;
labDbContext.LabTestComponentMap.Add(htmlCompToMap);
labDbContext.SaveChanges();
}
else
{
foreach (var component in labComponentMapList)
{
component.CreatedBy = currentUser.EmployeeId;
component.CreatedOn = System.DateTime.Now;
component.LabTestId = labTest.LabTestId;
labDbContext.LabTestComponentMap.Add(component);
labDbContext.SaveChanges();
}
}
labDbContext.LabTests.Attach(labTest);
billItemPrice.ItemName = labTest.LabTestName;
//Will Update this hardcode Later
billItemPrice.ServiceDepartmentId = labTest.ServiceDepartmentId ?? default(int); //typecase for default int
billItemPrice.Price = 0;
billItemPrice.ItemId = Convert.ToInt32(labTest.LabTestId);
billItemPrice.TaxApplicable = labTest.IsTaxApplicable;
billItemPrice.DiscountApplicable = true;
billItemPrice.CreatedBy = currentUser.EmployeeId;
billItemPrice.CreatedOn = System.DateTime.Now;
billItemPrice.IsActive = true;
billItemPrice.IsFractionApplicable = false;
billItemPrice.EHSPrice = 0;
billItemPrice.IsNormalPriceApplicable = true;
Int64 labTestId = labTest.LabTestId;//LabtestId comes only after this model is saved to database
if (string.IsNullOrEmpty(labTest.LabTestCode))
{
labTest.LabTestCode = "L-" + labTest.LabTestId.ToString("D6");
}
labTest.ProcedureCode = "LAB-" + labTest.LabTestId.ToString("D6");
labDbContext.Entry(labTest).Property(t => t.LabTestCode).IsModified = true;
labDbContext.Entry(labTest).Property(t => t.ProcedureCode).IsModified = true;
billItemPrice.ProcedureCode = labTest.ProcedureCode;
labDbContext.BillItemPrice.Add(billItemPrice);
labDbContext.SaveChanges();
dbContextTransaction.Commit();
responseData.Results = labTest;
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw (ex);
}
}
}
else if (reqType == "postLabComponents")
{
List <LabTestJSONComponentModel> componentList = DanpheJSONConvert.DeserializeObject <List <LabTestJSONComponentModel> >(ipStr);
using (var dbContextTransaction = labDbContext.Database.BeginTransaction())
{
try
{
var allLabComponents = labDbContext.LabTestComponents.ToList();
foreach (var comp in componentList)
{
var duplicateComponent = allLabComponents.FirstOrDefault(x => x.ComponentName == comp.ComponentName && x.DisplayName == comp.DisplayName);
if (duplicateComponent == null)
{
labDbContext.LabTestComponents.Add(comp);
labDbContext.SaveChanges();
}
}
dbContextTransaction.Commit();
responseData.Results = componentList;
responseData.Status = "OK";
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw (ex);
}
}
}
else if (reqType == "postLabLookUp")
{
CoreCFGLookupModel Lookup = DanpheJSONConvert.DeserializeObject <CoreCFGLookupModel>(ipStr);
using (var dbContextTransaction = labDbContext.Database.BeginTransaction())
{
try
{
var allLookUps = labDbContext.LabLookUps.ToList();
var duplicateComponent = allLookUps.FirstOrDefault(x => x.ModuleName == Lookup.ModuleName && x.LookUpName == Lookup.LookUpName && x.LookupDataJson == Lookup.LookupDataJson);
if (duplicateComponent == null)
{
labDbContext.LabLookUps.Add(Lookup);
labDbContext.SaveChanges();
}
dbContextTransaction.Commit();
responseData.Results = Lookup;
responseData.Status = "OK";
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw (ex);
}
}
}
else if (reqType == "add-vendor")
{
LabVendorsModel vendorFromClient = DanpheJSONConvert.DeserializeObject <LabVendorsModel>(ipStr);
LabVendorsModel defaultVendor = labDbContext.LabVendors.Where(val => val.IsDefault == true).FirstOrDefault();
if (vendorFromClient.IsDefault)
{
if (defaultVendor != null && defaultVendor.IsDefault)
{
defaultVendor.IsDefault = false;
labDbContext.Entry(defaultVendor).State = EntityState.Modified;
labDbContext.Entry(defaultVendor).Property(x => x.IsDefault).IsModified = true;
}
}
labDbContext.LabVendors.Add(vendorFromClient);
labDbContext.SaveChanges();
responseData.Results = vendorFromClient;//return same data to client.
labDbContext.SaveChanges();
}
responseData.Status = "OK";
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
SchedulingDbContext schDbContext = new SchedulingDbContext(connString);
string reqType = this.ReadQueryStringData("reqType");
string str = this.ReadPostData();
try
{
#region Employee Schedule manage : Insert/Update schedules
if (reqType == "manageEmpSchedules")
{
List <EmpSchedules> schedulesData = DanpheJSONConvert.DeserializeObject <List <EmpSchedules> >(str);
Boolean Flag = false;
Flag = SchedulingBL.ManageEmpSchedules(schedulesData, schDbContext);
if (Flag)
{
responseData.Status = "OK";
responseData.Results = 1;
}
else
{
responseData.ErrorMessage = "check console for error details.";
responseData.Status = "Failed";
}
}
#endregion
#region Add Shift (Manage Shifts)
else if (reqType == "AddShift")
{
ShiftsMasterModel shiftMaster = DanpheJSONConvert.DeserializeObject <ShiftsMasterModel>(str);
shiftMaster.CreatedOn = System.DateTime.Now;
schDbContext.ShiftsMaster.Add(shiftMaster);
schDbContext.SaveChanges();
responseData.Status = "OK";
responseData.Results = shiftMaster;
}
#endregion
#region Employee Working Hours manage Transaction
else if (reqType == "EmpWokringHours")
{
WorkingHoursTxnVM workHrsTxnData = DanpheJSONConvert.DeserializeObject <WorkingHoursTxnVM>(str);
Boolean Flag = false;
Flag = SchedulingBL.WorkingHrsTxn(workHrsTxnData, schDbContext);
if (Flag)
{
responseData.Status = "OK";
responseData.Results = 1;
}
else
{
responseData.ErrorMessage = "check console for error details.";
responseData.Status = "Failed";
}
}
#endregion
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Put()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
string reqType = this.ReadQueryStringData("reqType");
string ipStr = this.ReadPostData();
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
try
{
LabDbContext labDbContext = new LabDbContext(connString);
BillingDbContext billDbContext = new BillingDbContext(connString);
if (reqType == "updateLabReport")
{
LabReportTemplateModel labReportTemplate = DanpheJSONConvert.DeserializeObject <LabReportTemplateModel>(ipStr);
labDbContext.LabReportTemplates.Attach(labReportTemplate);
labDbContext.Entry(labReportTemplate).State = EntityState.Modified;
labDbContext.Entry(labReportTemplate).Property(x => x.CreatedOn).IsModified = false;
labDbContext.Entry(labReportTemplate).Property(x => x.CreatedBy).IsModified = false;
labReportTemplate.ModifiedOn = System.DateTime.Now;
labReportTemplate.ModifiedBy = currentUser.EmployeeId;
if (labReportTemplate.IsDefault == true)
{
LabReportTemplateModel rowToUpdate = (from rep in labDbContext.LabReportTemplates
where rep.IsDefault == true
select rep
).FirstOrDefault();
if (rowToUpdate != null)
{
labDbContext.LabReportTemplates.Attach(rowToUpdate);
rowToUpdate.IsDefault = false;
labDbContext.SaveChanges();
}
}
labDbContext.SaveChanges();
responseData.Results = labReportTemplate;
responseData.Status = "OK";
}
else if (reqType == "updateLabTest")
{
LabTestModel labTest = DanpheJSONConvert.DeserializeObject <LabTestModel>(ipStr);
BillItemPrice billItemPrice = billDbContext.BillItemPrice.Where(a => a.ItemName == labTest.LabTestName && a.ItemName == labTest.LabTestName).FirstOrDefault <BillItemPrice>();
using (var dbContextTransaction = labDbContext.Database.BeginTransaction())
{
try
{
//First Make all the Previous Mapping of Current Test False
List <LabTestComponentMapModel> mappedItemList = labDbContext.LabTestComponentMap.Where(mp => mp.LabTestId == labTest.LabTestId).ToList();
mappedItemList.ForEach(x => x.IsActive = false);
labDbContext.SaveChanges();
if (labTest.TemplateType.ToLower() == "html")
{
var componentToAdd = labTest.LabTestComponentsJSON[0];
List <LabTestJSONComponentModel> allOldComponents = (from test in labDbContext.LabTests
join componentMap in labDbContext.LabTestComponentMap on test.LabTestId equals componentMap.LabTestId
join component in labDbContext.LabTestComponents on componentMap.ComponentId equals component.ComponentId
where test.LabTestId == labTest.LabTestId && component.ComponentName == componentToAdd.ComponentName
select component).ToList();
if (allOldComponents.Count() > 0)
{
var componentMapToUpdate = labTest.LabTestComponentMap[0];
componentMapToUpdate.ComponentId = allOldComponents[0].ComponentId;
var existMap = labDbContext.LabTestComponentMap.Where(mp => mp.LabTestId == labTest.LabTestId && mp.ComponentId == componentMapToUpdate.ComponentId).FirstOrDefault();
existMap.IsActive = true;
existMap.DisplaySequence = componentMapToUpdate.DisplaySequence;
existMap.ModifiedBy = currentUser.EmployeeId;
existMap.ModifiedOn = System.DateTime.Now;
labDbContext.Entry(existMap).Property(x => x.IsActive).IsModified = true;
labDbContext.Entry(existMap).Property(x => x.DisplaySequence).IsModified = true;
labDbContext.Entry(existMap).Property(x => x.ModifiedBy).IsModified = true;
labDbContext.Entry(existMap).Property(x => x.ModifiedBy).IsModified = true;
labDbContext.SaveChanges();
}
else
{
labDbContext.LabTestComponents.Add(componentToAdd);
labDbContext.SaveChanges();
var compId = componentToAdd.ComponentId;
var componentMapToAdd = labTest.LabTestComponentMap[0];
componentMapToAdd.ComponentId = compId;
labDbContext.LabTestComponentMap.Add(componentMapToAdd);
labDbContext.SaveChanges();
}
}
else
{
List <LabTestComponentMapModel> labMapToBeUpdated = labTest.LabTestComponentMap;
foreach (var itm in labMapToBeUpdated)
{
var existingMap = labDbContext.LabTestComponentMap.Where(mp => mp.LabTestId == labTest.LabTestId && mp.ComponentId == itm.ComponentId).FirstOrDefault();
//Newly added Mapping
if (existingMap == null)
{
itm.ModifiedBy = currentUser.EmployeeId;
itm.ModifiedOn = System.DateTime.Now;
itm.IsActive = true;
labDbContext.LabTestComponentMap.Add(itm);
labDbContext.SaveChanges();
}
//Update Old Mapping
else
{
existingMap.IsActive = true;
existingMap.IndentationCount = itm.IndentationCount;
existingMap.DisplaySequence = itm.DisplaySequence;
existingMap.ModifiedBy = currentUser.EmployeeId;
existingMap.ModifiedOn = System.DateTime.Now;
labDbContext.Entry(existingMap).Property(x => x.IsActive).IsModified = true;
labDbContext.Entry(existingMap).Property(x => x.IndentationCount).IsModified = true;
labDbContext.Entry(existingMap).Property(x => x.DisplaySequence).IsModified = true;
labDbContext.Entry(existingMap).Property(x => x.ModifiedBy).IsModified = true;
labDbContext.Entry(existingMap).Property(x => x.ModifiedBy).IsModified = true;
labDbContext.SaveChanges();
}
}
}
billItemPrice.IsActive = labTest.IsActive;
billItemPrice.ItemName = labTest.LabTestName;
labDbContext.LabTests.Attach(labTest);
labDbContext.BillItemPrice.Attach(billItemPrice);
labDbContext.Entry(labTest).State = EntityState.Modified;
labDbContext.Entry(labTest).Property(x => x.CreatedOn).IsModified = false;
labDbContext.Entry(labTest).Property(x => x.CreatedBy).IsModified = false;
labDbContext.Entry(labTest).Property(x => x.LabTestCode).IsModified = false;
labDbContext.Entry(labTest).Property(x => x.ProcedureCode).IsModified = false;
billItemPrice.TaxApplicable = labTest.IsTaxApplicable;
labTest.ModifiedOn = System.DateTime.Now;
labTest.ModifiedBy = currentUser.EmployeeId;
labDbContext.Entry(billItemPrice).Property(x => x.TaxApplicable).IsModified = true;
labDbContext.Entry(billItemPrice).Property(x => x.ItemName).IsModified = true;
labDbContext.Entry(billItemPrice).Property(x => x.IsActive).IsModified = true;
labDbContext.SaveChanges();
dbContextTransaction.Commit();
responseData.Results = labTest;
responseData.Status = "OK";
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw (ex);
}
}
}
else if (reqType == "updateDefaultSignatories")
{
List <AdminParametersModel> AllSignatories = DanpheJSONConvert.DeserializeObject <List <AdminParametersModel> >(ipStr);
foreach (AdminParametersModel parameter in AllSignatories)
{
var parm = (from cfg in labDbContext.AdminParameters
where cfg.ParameterId == parameter.ParameterId
select cfg).FirstOrDefault();
parm.ParameterValue = parameter.ParameterValue;
labDbContext.Entry(parm).Property(p => p.ParameterValue).IsModified = true;
labDbContext.SaveChanges();
}
responseData.Results = AllSignatories;
responseData.Status = "OK";
}
else if (reqType == "updateLabTestComponent")
{
List <LabTestJSONComponentModel> componentList = DanpheJSONConvert.DeserializeObject <List <LabTestJSONComponentModel> >(ipStr);
List <LabTestJSONComponentModel> componentListToReturn = new List <LabTestJSONComponentModel>();
using (var dbContextTransaction = labDbContext.Database.BeginTransaction())
{
try
{
var allLabComponents = labDbContext.LabTestComponents.ToList();
foreach (var comp in componentList)
{
var duplicateComponent = allLabComponents.FirstOrDefault(x => x.ComponentName == comp.ComponentName && x.DisplayName == comp.DisplayName);
if (duplicateComponent == null || (duplicateComponent != null && duplicateComponent.ComponentId == comp.ComponentId))
{
var componentId = comp.ComponentId;
var componentToUpdate = (from component in labDbContext.LabTestComponents
where component.ComponentId == componentId
select component).FirstOrDefault();
componentToUpdate.ComponentName = comp.ComponentName;
componentToUpdate.DisplayName = comp.DisplayName;
componentToUpdate.ModifiedBy = currentUser.EmployeeId;
componentToUpdate.ModifiedOn = System.DateTime.Now;
componentToUpdate.Range = comp.Range;
componentToUpdate.MaleRange = comp.MaleRange;
componentToUpdate.FemaleRange = comp.FemaleRange;
componentToUpdate.ChildRange = comp.ChildRange;
componentToUpdate.RangeDescription = comp.RangeDescription;
componentToUpdate.MinValue = comp.MinValue;
componentToUpdate.MaxValue = comp.MaxValue;
componentToUpdate.Unit = comp.Unit;
componentToUpdate.ValueLookup = comp.ValueLookup;
componentToUpdate.ValueType = comp.ValueType;
componentToUpdate.Method = comp.Method;
componentToUpdate.ControlType = comp.ControlType;
labDbContext.Entry(componentToUpdate).State = EntityState.Modified;
labDbContext.Entry(componentToUpdate).Property(x => x.CreatedOn).IsModified = false;
labDbContext.Entry(componentToUpdate).Property(x => x.CreatedBy).IsModified = false;
labDbContext.SaveChanges();
}
}
dbContextTransaction.Commit();
responseData.Results = componentList;
responseData.Status = "OK";
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw (ex);
}
}
}
else if (reqType == "updateLabLookUpComponent")
{
CoreCFGLookupModel Lookup = DanpheJSONConvert.DeserializeObject <CoreCFGLookupModel>(ipStr);
CoreCFGLookupModel LookupToReturn = new CoreCFGLookupModel();
using (var dbContextTransaction = labDbContext.Database.BeginTransaction())
{
try
{
var allLookupComponents = labDbContext.LabLookUps.ToList();
var duplicateComponent = allLookupComponents.FirstOrDefault(x => x.ModuleName == Lookup.ModuleName && x.LookUpName == Lookup.LookUpName && x.LookupDataJson == Lookup.LookupDataJson);
if (duplicateComponent == null || (duplicateComponent != null && duplicateComponent.LookUpId == Lookup.LookUpId))
{
var LookUpId = Lookup.LookUpId;
var LookupToUpdate = (from lookup in labDbContext.LabLookUps
where lookup.LookUpId == LookUpId
select lookup).FirstOrDefault();
LookupToUpdate.LookUpName = Lookup.LookUpName;
LookupToUpdate.LookupDataJson = Lookup.LookupDataJson;
LookupToUpdate.ModuleName = Lookup.ModuleName;
LookupToUpdate.Description = Lookup.Description;
labDbContext.Entry(LookupToUpdate).State = EntityState.Modified;
labDbContext.SaveChanges();
}
dbContextTransaction.Commit();
responseData.Results = Lookup;
responseData.Status = "OK";
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw (ex);
}
}
}
else if (reqType == "updateLabVendor")
{
LabVendorsModel vendorFromClient = DanpheJSONConvert.DeserializeObject <LabVendorsModel>(ipStr);
LabVendorsModel defaultVendor = labDbContext.LabVendors.Where(val => val.IsDefault == true).FirstOrDefault();
if (vendorFromClient != null && vendorFromClient.LabVendorId != 0)
{
if (vendorFromClient.IsDefault)
{
if (defaultVendor != null && defaultVendor.IsDefault)
{
defaultVendor.IsDefault = false;
labDbContext.Entry(defaultVendor).State = EntityState.Modified;
labDbContext.Entry(defaultVendor).Property(x => x.IsDefault).IsModified = true;
}
}
var vendorFromServer = (from ven in labDbContext.LabVendors
where ven.LabVendorId == vendorFromClient.LabVendorId
select ven).FirstOrDefault();
vendorFromServer.VendorCode = vendorFromClient.VendorCode;
vendorFromServer.VendorName = vendorFromClient.VendorName;
vendorFromServer.ContactAddress = vendorFromClient.ContactAddress;
vendorFromServer.ContactNo = vendorFromClient.ContactNo;
vendorFromServer.Email = vendorFromClient.Email;
vendorFromClient.IsActive = vendorFromClient.IsActive;
vendorFromServer.IsExternal = vendorFromClient.IsExternal;
vendorFromServer.IsDefault = vendorFromClient.IsDefault;
labDbContext.Entry(vendorFromServer).Property(v => v.VendorCode).IsModified = true;
labDbContext.Entry(vendorFromServer).Property(v => v.VendorName).IsModified = true;
labDbContext.Entry(vendorFromServer).Property(v => v.ContactAddress).IsModified = true;
labDbContext.Entry(vendorFromServer).Property(v => v.ContactNo).IsModified = true;
labDbContext.Entry(vendorFromServer).Property(v => v.Email).IsModified = true;
labDbContext.Entry(vendorFromServer).Property(v => v.IsActive).IsModified = true;
labDbContext.Entry(vendorFromServer).Property(v => v.IsExternal).IsModified = true;
labDbContext.Entry(vendorFromServer).Property(v => v.IsDefault).IsModified = true;
labDbContext.SaveChanges();
responseData.Results = vendorFromClient;//return the same data to client.
responseData.Status = "OK";
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Couldn't find vendor.";
}
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
responseData.Status = "OK";
//string ipDataString = Request.Form.Keys.First<string>();
try
{
string reqType = this.ReadQueryStringData("reqType");
string ExportType = this.ReadQueryStringData("ExportType");
SystemAdminDbContext systemAdmindbContext = new SystemAdminDbContext(connStringAdmin);
#region Database Backup functionality
if (reqType == "databaseBackup")
{
//Transaction Begin
using (var dbContextTransaction = systemAdmindbContext.Database.BeginTransaction())
{
try
{
//Check Backup Folder is present or not in local system
if (CheckBackupFolderPath())
{
int todayDBBackup = CheckTodaysBackup();
SystemAdminDbContext systemAdminDbContext = new SystemAdminDbContext(connStringAdmin);
int todaysDBBackupFrequency = Convert.ToInt32((from parameters in systemAdminDbContext.AdminParameters
where parameters.ParameterName == "DaillyDBBackupLimit"
select parameters.ParameterValue
).SingleOrDefault());
if (todayDBBackup >= todaysDBBackupFrequency)
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Today You have already taken " + todaysDBBackupFrequency + "DB backup";
}
else
{
//Backup Database with local directory
if (BackupDatabase(connStringAdmin))
{
if (DeleteOldBackupFiles(connStringAdmin))
{
responseData.Status = "OK";
responseData.Results = 1;
dbContextTransaction.Commit();
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Backup Files deleting Error";
dbContextTransaction.Rollback();
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Database Backup failed, Please try again";
}
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Please create Directory(folder) first for Backup.";
}
//Commit Transaction
//dbContextTransaction.Commit();
}
catch (Exception ex)
{
//Rollback all transaction if exception occured
dbContextTransaction.Rollback();
throw ex;
}
}
}
#endregion
#region Database Restore Functionality
else if (reqType == "databaseRestore")
{
string dataString = this.ReadPostData();
DatabaseLogModel dbBackupLogDataFromClient = DanpheJSONConvert.DeserializeObject <DatabaseLogModel>(dataString);
string backupDBFilePath = dbBackupLogDataFromClient.FolderPath + dbBackupLogDataFromClient.FileName;
string backupDBFileVersion = dbBackupLogDataFromClient.DatabaseVersion;
//Transaction Begin
using (var dbContextTransaction = systemAdmindbContext.Database.BeginTransaction())
{
try
{
//Boolean x = System.IO.File.Exists("");
//Check backup file is exist or not for restore
if (System.IO.File.Exists(backupDBFilePath))
{
//check Backup dbfile and current database version compatibility
if (CheckDBVersionForRestore(backupDBFileVersion))
{
//first take backup of Database then restore
BackupDatabase(connStringAdmin);
//Restore database
if (RestoreDatabase(connStringAdmin, dbBackupLogDataFromClient))
{
responseData.Status = "OK";
responseData.Results = 1;
dbContextTransaction.Commit();
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Database restore failed, Please try again";
dbContextTransaction.Rollback();
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Version is not compatible for Restore.";
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "There is no backup file for restore, Please Try again.";
}
}
catch (Exception ex)
{
//Rollback all transaction if exception occured
dbContextTransaction.Rollback();
throw ex;
}
}
}
#endregion
#region Database Export as CSV/XML/pdf files
else if (reqType != null && reqType == "exportDBToCSVOrXMLOrPDF")
{
try
{
if (!String.IsNullOrEmpty(ExportType))
{
CoreDbContext coreDBContext = new CoreDbContext(connString);
//get local export file path for export files and send to user also
string ExportedFilePath = (from parameter in coreDBContext.Parameters
where parameter.ParameterName == "DBExportCSVXMLDirPath"
select parameter.ParameterValue
).SingleOrDefault();
//Call function to complete Export database functionality
if (ExportDatabaseToCSVOrXMLOrPDF(connString, ExportType, ExportedFilePath))
{
responseData.Status = "OK";
responseData.Results = ExportedFilePath;
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Failed to Export Database as " + ExportType;
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "Please select export file type as " + ExportType;
}
}
catch (Exception ex)
{
throw ex;
}
}
#endregion
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "request type is incorrect.";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
[HttpPost]// POST api/values
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>(); //type 'object' since we have variable return types
responseData.Status = "OK"; //by default status would be OK, hence assigning at the top
try
{
string ipDataString = this.ReadPostData();
string reqType = this.ReadQueryStringData("reqType");
RbacUser currentUser = HttpContext.Session.Get <RbacUser>("currentuser");
BillingDbContext billingDbContext = new BillingDbContext(connString);
if (reqType == "postBillTransaction")//submit
{
DateTime currentDate = DateTime.Now;
BillingTransactionModel billTransaction = DanpheJSONConvert.DeserializeObject <BillingTransactionModel>(ipDataString);
if (billTransaction != null)
{
//Transaction Begins
using (var dbContextTransaction = billingDbContext.Database.BeginTransaction())
{
try
{
//step:1 -- make copy of billingTxnItems into new list, so thate EF doesn't add txn items again.
//step:2-- if there's deposit deduction, then add to deposit table.
billTransaction = BillingTransactionBL.PostBillingTransaction(billingDbContext, connString, billTransaction, currentUser.EmployeeId, currentDate);
//step:3-- if there's deposit balance, then add a return transaction to deposit table.
if (billTransaction.PaymentMode != "credit" && billTransaction.DepositBalance != null && billTransaction.DepositBalance > 0)
{
BillingDeposit dep = new BillingDeposit()
{
DepositType = "ReturnDeposit",
Remarks = "Deposit Refunded from InvoiceNo. " + billTransaction.InvoiceCode + billTransaction.InvoiceNo,
//Remarks = "ReturnDeposit" + " for transactionid:" + billTransaction.BillingTransactionId,
Amount = billTransaction.DepositBalance,
IsActive = true,
BillingTransactionId = billTransaction.BillingTransactionId,
DepositBalance = 0,
FiscalYearId = billTransaction.FiscalYearId,
CounterId = billTransaction.CounterId,
CreatedBy = billTransaction.CreatedBy,
CreatedOn = currentDate,
PatientId = billTransaction.PatientId,
PatientVisitId = billTransaction.PatientVisitId,
PaymentMode = billTransaction.PaymentMode,
PaymentDetails = billTransaction.PaymentDetails,
ReceiptNo = billTransaction.ReceiptNo
};
billingDbContext.BillingDeposits.Add(dep);
billingDbContext.SaveChanges();
}
//For cancel BillingTransactionItems
List <BillingTransactionItemModel> item = (from itm in billingDbContext.BillingTransactionItems
where itm.PatientId == billTransaction.PatientId && itm.PatientVisitId == billTransaction.PatientVisitId && itm.BillStatus == "provisional" && itm.Quantity == 0
select itm).ToList();
if (item.Count() > 0)
{
item.ForEach(itm =>
{
var txnItem = BillingTransactionBL.UpdateTxnItemBillStatus(billingDbContext, itm, "adtCancel", billTransaction.CreatedBy.Value, currentDate, billTransaction.CounterId, null);
});
}
dbContextTransaction.Commit();
responseData.Results = billTransaction;
}
catch (Exception ex)
{
//rollback all changes if any error occurs
dbContextTransaction.Rollback();
throw ex;
}
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "billTransaction is invalid";
}
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + " exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
