public async Task <IHttpActionResult> Postpatient_data(patient_data patient_data)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.patient_data.Add(patient_data);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (patient_dataExists(patient_data.mobile_no))
{
return(Conflict());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IHttpActionResult> Putpatient_data(patient_data patient_data)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Entry(patient_data).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!patient_dataExists(patient_data.mobile_no))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(System.Net.HttpStatusCode.NoContent));
}
[Route("appointments")] //appointment details of the patient
public async Task <IHttpActionResult> patientAppointment(patient_data patient)
{
List <reception_view> allAppointments = await db.reception_view.Where(temp => temp.patient_name == patient.patient_name).ToListAsync();
if (allAppointments != null)
{
return(Ok(allAppointments));
}
return(NotFound());
}
public IHttpActionResult SearchPatientAdmin(long mobile_no)
{
patient_data patient = db.patient_data.Where(x => x.mobile_no == mobile_no).FirstOrDefault();
if (patient != null)
{
return(Ok(patient));
}
return(NotFound());
}
public IHttpActionResult deletePatient(patient_data patient)
{
patient_data _patient = db.patient_data.Where(x => x.mobile_no == patient.mobile_no).FirstOrDefault();
if (_patient != null)
{
db.patient_data.Remove(_patient);
db.SaveChanges();
return(Ok(patient));
}
return(NotFound());
}
public async Task <IHttpActionResult> patientLogin(patient_data verifyPatient)
{
long patientId = Convert.ToInt64(verifyPatient.mobile_no);
string patientPassword = verifyPatient.password;
patient_data patient = await db.patient_data.FindAsync(patientId);
if (patient != null)
{
if (patient.password == patientPassword)
{
return(Ok(patient));
}
}
return(NotFound());
}
public ActionResult login(accountlog model)
{
using (var context = new patient_data())
{
bool isValid = context.userlogins.Any(x => x.username == model.username && x.password == model.password);
if (isValid)
{
FormsAuthentication.SetAuthCookie(model.username, false);
return(RedirectToAction("add", "patient"));
}
Response.Write("<script>alert('Invalid');</script>");
ModelState.AddModelError("", "Invalid username and password");
}
return(View());
}
/// <summary>
/// Tests patient and appointment lists.
/// </summary>
/// <param name="appts">List of appointments to substitute in our mockup.</param>
/// <param name="patients">List of patients to substitute in our mockup.</param>
/// <param name="compare_date">The date to compare in our mockup.</param>
/// <returns></returns>
private static IEnumerable <Transaction> TestPatientsAndAppointments(
List <appointment_data> appts,
List <patient_data> patients,
DateTime compare_date)
{
var mock_appts = new Mock <DbSet <appointment_data> >();
mock_appts.As <IQueryable <appointment_data> >().Setup(m => m.Provider)
.Returns(appts.AsQueryable <appointment_data>().Provider);
mock_appts.As <IQueryable <appointment_data> >().Setup(m => m.Expression)
.Returns(appts.AsQueryable <appointment_data>().Expression);
mock_appts.As <IQueryable <appointment_data> >().Setup(m => m.ElementType)
.Returns(appts.AsQueryable <appointment_data>().ElementType);
mock_appts.As <IQueryable <appointment_data> >().Setup(m => m.GetEnumerator())
.Returns(appts.AsQueryable <appointment_data>().GetEnumerator());
var mock_patients = new Mock <DbSet <patient_data> >();
mock_patients.As <IQueryable <patient_data> >().Setup(m => m.Provider)
.Returns(patients.AsQueryable <patient_data>().Provider);
mock_patients.As <IQueryable <patient_data> >().Setup(m => m.Expression)
.Returns(patients.AsQueryable <patient_data>().Expression);
mock_patients.As <IQueryable <patient_data> >().Setup(m => m.ElementType)
.Returns(patients.AsQueryable <patient_data>().ElementType);
mock_patients.As <IQueryable <patient_data> >().Setup(m => m.GetEnumerator())
.Returns(patients.AsQueryable <patient_data>().GetEnumerator());
var fake_entities = new Mock <broadlyEntities>();
fake_entities.Setup(c => c.appointment_data).Returns(mock_appts.Object);
fake_entities.Setup(c => c.patient_data).Returns(mock_patients.Object);
IEnumerable <Transaction> transactions = DataSource.GetTransactions(compare_date, fake_entities.Object);
Assert.IsNotNull(transactions);
Assert.IsTrue(transactions is IQueryable);
Assert.IsTrue(transactions is IQueryable <Transaction>);
foreach (Transaction transaction in transactions)
{
// There is an email
Assert.IsTrue(!string.IsNullOrEmpty(transaction.PatientEmail));
// The appoinment time matches
Assert.IsTrue(transaction.AppointmentTime == compare_date);
// There is a transaction with this Id
appointment_data appt = appts.Find(x => x.appointment_id == transaction.AppointmentId);
Assert.IsNotNull(appt);
// There is a patient with the appt's Id
patient_data patient = patients.Find(x => x.patient_id == appt.patient_id);
Assert.IsNotNull(patient);
// Check content
Assert.IsTrue(transaction.AppointmentId == appt.appointment_id);
Assert.IsTrue(transaction.AppointmentTime == appt.scheduled);
Assert.IsTrue(appt.status == "completed");
Assert.IsTrue(transaction.PatientFirstName == patient.first_name);
Assert.IsTrue(transaction.PatientLastName == patient.last_name);
Assert.IsTrue(transaction.PatientId == patient.patient_id);
Assert.IsTrue(transaction.PatientPhone == patient.phone);
}
return(transactions);
}
