public ActionResult <IEnumerable <dynamic> > InsertPatient([FromBody] PatientDataModel patient)
{
PatientDataModel patientInfo;
if (!PatientValidator.ValidatePatient(patient))
{
return(BadRequest("Please enter valid input"));
}
try
{
patientInfo = _patientBusinessLogic.InsertPatient(patient);
}
catch
{
return(StatusCode(500, "unable to insert patient information"));
}
var responseData = new Dictionary <string, dynamic>
{
{ "patientId", patientInfo.PatientId },
{ "patientName", patientInfo.PatientName },
{ "email", patientInfo.Email },
{ "address", patientInfo.Address },
{ "mobile", patientInfo.Mobile },
};
return(Ok(responseData));
}
public PatientDataInformationControllerTest()
{
// Lets create some sample PatientDataModels
patientDataModel1 = new PatientDataModel {
ForeName = "AA", SurName = "BB", Gender = "Male"
};
patientDataModel2 = new PatientDataModel {
ForeName = "CC", SurName = "DD", Gender = "Female"
};
patientDataModel3 = new PatientDataModel {
ForeName = "EE", SurName = "FF", Gender = "Male"
};
patientDataModel4 = new PatientDataModel {
ForeName = "GG", SurName = "HH", Gender = "Female"
};
patientDataModel5 = new PatientDataModel {
ForeName = "II", SurName = "JJ", Gender = "Male"
};
patientDataModels = new List <PatientDataModel>
{
patientDataModel1,
patientDataModel2,
patientDataModel3,
patientDataModel4
};
// Lets create our dummy repository
patientssRepo = new InMemoryPatientRepository(patientDataModels);
// Now lets create the PatientDataInformationController object to test and pass our patientDataModels
controller = new PatientDataInformationController(patientssRepo);
}
public void TestInsertPatientSuccessful()
{
var patient = new PatientDataModel();
var patientLogic = new PatientBusinessLogic(_repo);
patientLogic.InsertPatient(patient);
}
public ResultOfType <PatientResultDataModel> PatchPatient(PatientDataModel patientDataModel)
{
Logger.LogInfo("PostNewPatient : Start.");
if (patientDataModel == null)
{
return(new Return <PatientResultDataModel>().Error().As(EStatusDetail.BadRequest).AddingGenericError(
null, "Les données sont vides.").WithDefaultResult());
}
Logger.LogInfo(string.Format("Post New Patient : Start --- CIN = {0}, Email = {1}",
patientDataModel.Cin, patientDataModel.Email));
// Id validation
var validationResult = ValidateUpdatedPatientProperties(patientDataModel);
if (validationResult != null)
{
Logger.LogInfo(string.Format("Post New Patient : End --- Status = {0}, Message= {1}",
validationResult.Status, validationResult.Errors[0].Message));
return(validationResult);
}
validationResult = ValidatePasword(patientDataModel.Password, patientDataModel.NomPrenom);
if (validationResult != null)
{
Logger.LogInfo(string.Format("Post New Patient : End --- Status = {0}, Message= {1}",
validationResult.Status, validationResult.Errors[0].Message));
return(validationResult);
}
patientDataModel.CreationDate = DateTime.UtcNow;
//Get patient to update it
var patientToUpdate = _patientRepository.GetAll().FirstOrDefault(p => p.Cin.Equals(patientDataModel.Cin));
if (patientToUpdate == null)
{
return(new Return <PatientResultDataModel>()
.Error().AsValidationFailure(null, "Problème de récupération d'un patient. Veuillez nous contacter pour signaler ce problème.", "Patient")
.WithDefaultResult());
}
patientToUpdate.Adresse = patientDataModel.Adresse;
patientToUpdate.Password = CrossCuttingLayer.Encryption.RijndaelEncryption.Encrypt(patientDataModel.Password);
patientToUpdate.NomPrenom = patientDataModel.NomPrenom;
patientToUpdate.Telephone = patientDataModel.Telephone;
patientToUpdate.Sexe = patientDataModel.Sexe;
patientToUpdate.DateNaissance = patientDataModel.DateNaissance;
patientToUpdate.LastModificationDate = DateTime.UtcNow;
_patientRepository.Update(patientToUpdate);
Logger.LogInfo("Post New patient : End --- Status = OK, Message= {1}");
return
(new Return <PatientResultDataModel>().OK().WithResult(new PatientResultDataModel {
Cin = patientToUpdate.Cin, Adresse = patientToUpdate.Adresse, Email = patientToUpdate.Email, NomPrenom = patientToUpdate.NomPrenom, Telephone = patientToUpdate.Telephone, DateNaissance = patientToUpdate.DateNaissance
}));
}
private void SetDependentFields(PatientDataModel model)
{
string sectionCode = model.SectionCode;
if (!sectionCode.StartsWith(_prefix))
{
sectionCode = $"{_prefix}{sectionCode}";
}
_model = new PreScreenModel();
PopulateAccordions(_model);
PopulateItems(_model);
var preScreen = _dataContext.PreScreens.Find(model.PreScreenId);
ApplyFilter(preScreen.PreScreenType.Name);
var sections = GetSections();
var section = sections.Where(p => p.GetUniqueClientCode() == sectionCode).Single();
var dependentItems = section.Items.Where(p => p.DependsOnCode != null).ToList();
foreach (var item in dependentItems)
{
var dependentValue = item.DependsOnAssertValue;
var dependentCode = item.DependsOnCode;
if (model.Items.Where(p => p.Key == dependentCode).Single().Value != dependentValue)
{
var dependent = model.Items.Where(p => p.Key == item.ClientCode).Single();
dependent.Value = null;
item.Required = false;
}
}
}
public PatientDataModel UpdatePatient(PatientDataModel patientDetailChanges)
{
string id = patientDetailChanges.PatientId;
if (_context.Patients.Find(id) != null)
{
PatientDataModel patient = _context.Patients.Find(id);
if (patient != null)
{
patient.PatientName = patientDetailChanges.PatientName;
patient.PatientAge = patientDetailChanges.PatientAge;
patient.Email = patientDetailChanges.Email;
patient.BedId = patientDetailChanges.BedId;
patient.ContactNo = patientDetailChanges.ContactNo;
patient.Address = patientDetailChanges.Address;
_context.SaveChanges();
return(patient);
}
return(null);
}
return(null);
//_context.Patients.Update(patientDetailChanges);
// _context.SaveChanges();
// return patientDetailChanges;
}
/// <summary>
///Method to add patients in to db
/// </summary>
/// <param name="patientdata"></param>
/// <returns>1 for successful posting and 2 for conflicts in data</returns>
public async Task <int> PostPatientRecord(PatientDataModel patientdata)
{
Guid gid = Guid.NewGuid();
PatientRecord pr = new PatientRecord()
{
PatientID = gid.ToString(),
ForeName = patientdata.ForeName,
SurName = patientdata.SurName,
Gender = patientdata.Gender,
DateofBirth = patientdata.DateofBirth,
HomeNumber = patientdata.TelePhoneNumbers.HomeNumber,
WorkNumber = patientdata.TelePhoneNumbers.WorkNumber,
MobileNumber = patientdata.TelePhoneNumbers.MobileNumber,
};
db.PatientRecords.Add(pr);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (PatientRecordExists(pr.PatientID))
{
return(2);
}
else
{
throw;
}
}
return(1);
}
private static void CheckPatientValid(PatientDataModel patientInfo)
{
if (patientInfo == null)
{
throw new ArgumentException("Invalid bed id");
}
}
public ActionResult EditDetails()
{
CASDatabaseEntities db = new CASDatabaseEntities();
PatientDataModel dt = new PatientDataModel();
var id = Convert.ToInt32(Session["UserID"]);;
var getData = db.Patients.Where(m => m.UserID == id).FirstOrDefault();
if (getData != null)
{
dt.FirstName = getData.FirstName;
dt.LastName = getData.LastName;
dt.Gender = getData.Gender;
dt.DOB = Convert.ToDateTime(getData.DOB);
dt.Address = getData.Address;
dt.ContactNo = getData.ContactNo;
dt.EmgContactName = getData.EmgContactName;
dt.EmgContactNo = getData.EmgContactNo;
}
else
{
dt.FirstName = null;
}
return(View(dt));
}
public JsonResult UpdatePatientData(string id, PatientDataModel model)
{
SetContextLists();
//Filter 1, strip out the model.data prefix.
StripModelDataPrefix(model);
model.PreScreenId = long.Parse(id);
SetDependentFields(model);
using (var transaction = _dataContext.Database.BeginTransaction())
{
//Save the patient data.
SavePatientData(model);
_dataContext.SaveChanges();
//All the alerts and notifications/ tasks go here after saving a section.
SendSCARequestedAlert(model.PreScreenId);
SendPlanInGraceAlert(model.PreScreenId);
_dataContext.SaveChanges();
transaction.Commit();
}
return(Json(new { Status = Constant.RESPONSE_OK, Description = "Section saved successfully." }));
}
public void Add(PatientDataModel theModel)
{
var request = new RestRequest("api/patient/requests/submit/" + theModel.PatientID, Method.POST)
{
RequestFormat = DataFormat.Json
};
request.AddBody(new
{
DoctorID = theModel.DoctorID,
PatientID = theModel.PatientID,
Name = theModel.Name,
Start = theModel.StartDate.ToString("yyyy-MM-dd"),
End = theModel.EndDate.ToString("yyyy-MM-dd"),
Type = theModel.Type,
Time = theModel.Time.ToShortTimeString(),
RecordID = theModel.RecordID,
RecordName = theModel.RecordName
});
var response = _client.Execute(request);
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception(response.ErrorMessage);
}
}
public static void UpdatePatientData(PatientDataModel patient)
{
if (Users == null)
{
Initialize();
}
Patients.FirstOrDefault(x => x.PatientData.ID == patient.ID).PatientData = patient;
}
internal static bool ValidatePatient(PatientDataModel patient)
{
if (Utils.IsValueNull(patient.PatientName) == Utils.IsValueNull(patient.Email) ==
Utils.IsValueNull(patient.Mobile) == Utils.IsLengthValid(patient.Mobile, 10) == false)
{
return(true);
}
return(false);
}
public PatientDataModel InsertPatient(PatientDataModel patient)
{
patient.PatientId = 1;
if (patient.PatientName == "Hari")
{
throw new Exception("unable to insert patient information");
}
return(patient);
}
public async Task <IActionResult> CreatePatient()
{
var patientDataModel = new PatientDataModel
{
HealthInsurances = await _healthInsuranceService.GetAll()
};
return(PartialView("_CreatePatient", patientDataModel));
}
public IActionResult Get(string id)
{
PatientDataModel patient = _patientdatabase.GetPatientInfoFromId(id);
if (patient != null)
{
return(Ok(patient));
}
return(BadRequest("Patient not found!"));
}
public PatientDataModel Update(PatientDataModel model)
{
var data = context.PatientDatas.FirstOrDefault(x => x.Id == model.Id);
data.Value = model.PropValue;
data.PropertyId = model.PropertyId;
data.Date = model.Date;
context.SaveChanges();
return(model);
}
Tuple <PatientDataModel, BedInformation> IPatientBusinessLogic.AllotBedToPatient(BedAllotmentModel allotBed)
{
if (allotBed.PatientId == 2)
{
throw new Exception();
}
var objPatientInfo = new PatientDataModel();
var objBedInfo = new BedInformation();
return(new Tuple <PatientDataModel, BedInformation>(objPatientInfo, objBedInfo));
}
public BedDataModel BedInfoFromPatientId(string patientId)
{
PatientDataModel details = _context.Patients.Find(patientId);
if (details != null)
{
BedDataModel bed = _context.Beds.Find(details.BedId);
return(bed);
}
return(null);
}
public IActionResult Delete(string id)
{
PatientDataModel patient = _patientdatabase.GetPatientInfoFromId(id);
if (patient != null)
{
var result = _patientdatabase.DischargePatient(id);
return(Ok(result));
}
return(BadRequest("Delete operation failed. Patient does not exist!"));
}
public void UpdatePatientInfo(string mrn, PatientDataModel state, ITransactionManager manager)
{
for (int i = 0; i < _db.Count; i++)
{
if (_db[i].MRN == mrn)
{
_db.Insert(i, state);
return;
}
}
}
private void InitializeDatabase(DbContext context)
{
var patient = new PatientDataModel
{
PatientName = "TestPatient",
Address = "TestAddr",
Email = "TestEmail",
Mobile = "9898989898"
};
context.Add(patient);
var bed = new BedInformation
{
PatientId = 1,
BedId = "1A1",
BedInColumn = 1,
BedInRow = 2,
WardNumber = "1A"
};
context.Add(bed);
var medicalDevice = new MedicalDevice
{
DeviceName = "TestDevice",
MaxValue = 160,
MinValue = 80
};
context.Add(medicalDevice);
var wardInfo = new IcuWardInformation()
{
WardNumber = "1B",
Department = "Dept",
TotalBed = 2
};
context.Add(wardInfo);
var bed2 = new BedInformation
{
PatientId = null,
BedId = "1B1",
BedInColumn = 1,
BedInRow = 2,
WardNumber = "1B"
};
context.Add(bed2);
context.SaveChanges();
}
public IActionResult Put(string id, [FromBody] PatientDataModel patientDetailchanges)
{
if (patientDetailchanges.PatientId == id)
{
var result = _patientdatabase.UpdatePatient(patientDetailchanges);
if (result != null)
{
return(Ok(result));
}
}
return(BadRequest("Update operation failed. Patient does not exist!"));
}
public IHttpActionResult Get()
{
try
{
var result = new PatientDataModel().Get();
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult Create(PatientDataModel theModel)
{
try
{
RestClient.Add(theModel);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public PatientDataModel DischargePatient(string patientId)
{
PatientDataModel patient = _context.Patients.Find(patientId);
if (patient != null)
{
_context.Patients.Remove(patient);
_context.SaveChanges();
return(patient);
}
return(null);
}
public ActionResult UpdateHistory(int?ID, PatientDataModel dt)
{
CASDatabaseEntities db = new CASDatabaseEntities();
Patient objPatient = new Patient();
int id = Convert.ToInt32(ID);
var getData = db.Patients.Where(m => m.PatientID == id).FirstOrDefault();
getData.History = dt.History;
db.SaveChanges();
return(RedirectToAction("History", "Physician"));
}
public JsonResult PatientData(string Context, string SectionCode, long ContextId)
{
PatientDataModel model = new PatientDataModel()
{
Context = Context,
ContextId = ContextId,
SectionCode = SectionCode
};
StripModelDataPrefix(model);
string code = model.SectionCode;
switch (Context)
{
case "Patient":
var lstPatient = _dataContext.PatientData.Where(p => p.PatientId == ContextId && p.SectionCode == code && p.Deleted == false).ToList();
model.Items = lstPatient.Where(p => p.Type != "Table").Select(p => new KeyValuePairModel()
{
Key = p.ItemCode, Value = p.Value
}).ToList();
model.Tables = new List <TableDataModel>();
foreach (var item in lstPatient.Where(p => p.Type == "Table"))
{
if (!string.IsNullOrEmpty(item.Value))
{
model.Tables.Add((TableDataModel)Common.XmlDeserialize(typeof(TableDataModel), item.Value));
}
}
break;
case "PreScreen":
var lstPreScreen = _dataContext.PreScreenData.Where(p => p.PreScreenId == ContextId && p.SectionCode == code && p.Deleted == false).ToList();
model.Items = lstPreScreen.Where(p => p.Type != "Table").Select(p => new KeyValuePairModel()
{
Key = p.ItemCode, Value = p.Value
}).ToList();
model.Tables = new List <TableDataModel>();
foreach (var item in lstPreScreen.Where(p => p.Type == "Table"))
{
if (!string.IsNullOrEmpty(item.Value))
{
model.Tables.Add((TableDataModel)Common.XmlDeserialize(typeof(TableDataModel), item.Value));
}
}
break;
default:
return(Json(new { Status = Constant.RESPONSE_ERROR, Description = "Context not implemented" }));
}
return(Json(model, JsonRequestBehavior.AllowGet));
}
internal static async Task <string> PostPatientData(PatientDataModel requestObj)
{
try
{
HttpResponseMessage response = await Client.PostAsJsonAsync("api/PatientData/", requestObj).ConfigureAwait(false);
return(ConvertHttpResponseToStringResponse(ref response));
}
catch (Exception exception)
{
return(exception.Message);
}
}
public void TestInsertPatientThrowsException()
{
PatientDataController controller = new PatientDataController(operations);
var patient = new PatientDataModel
{
PatientName = "Hari", Address = "address", Mobile = "9898933898", Email = "*****@*****.**"
};
var actualResponse = controller.InsertPatient(patient);
var actualResponseObject = actualResponse.Result as ObjectResult;
Assert.NotNull(actualResponse);
Assert.Equal(500, actualResponseObject.StatusCode);
}
