public async Task <ActionResult> PostRemoveSample(Lab lab, Sample sample)
{
if (sample == null)
{
return(HttpNotFound());
}
var labSample = await DbContext.LabSamples
.Include(ls => ls.Sample)
.FirstOrDefaultAsync(ls => ls.LabId == lab.LabId && ls.SampleId == sample.SampleId);
if (labSample == null)
{
return(HttpNotFound());
}
try
{
await LabsDao.RemoveSample(this, lab.LabId, sample.SampleId);
}
catch (Exception e)
{
ModelState.AddModelError("", e);
return(View("RemoveSample", new LabsRemoveSampleViewModel
{
Lab = lab,
LabSample = labSample
}));
}
return(RedirectToAction("Samples", new { lab = lab.LabId }));
}
public async Task <ActionResult> PostRemoveReagent(Lab lab, [System.Web.Http.FromUri] long usedReagentId, LabsRemoveReagentViewModel model)
{
var usedReagent = await DbContext.UsedReagents
.Include(ur => ur.Reagent)
.FirstOrDefaultAsync(ur => ur.UsedReagentId == usedReagentId);
if (usedReagent == null)
{
return(RedirectToAction("Reagents", new { lab = lab.LabId }));
}
model.Lab = lab;
model.Reagent = usedReagent.Reagent;
if (!ModelState.IsValid)
{
return(View("RemoveReagent", model));
}
try
{
await LabsDao.RemoveReagent(this, lab.LabId, usedReagentId, model.ReturnQuantity);
}
catch (Exception e)
{
ModelState.AddModelError("", e);
return(RedirectToAction("RemoveReagent", new { usedReagentId }));
}
return(RedirectToAction("Reagents", new { lab = lab.LabId }));
}
public async Task <ActionResult> SamplePostComment(Lab lab, Sample sample, LabsSampleDetailsViewModel model)
{
if (sample == null)
{
return(HttpNotFound());
}
var newModel = await LabsDao.GetSampleDetails(this, lab.LabId, sample.SampleId);
newModel.Message = model.Message;
if (!ModelState.IsValid)
{
return(View("SampleDetails", newModel));
}
try
{
await LabsDao.PostComment(this, lab.LabId, sample.SampleId, model);
}
catch (Exception e)
{
ModelState.AddModelError("", e);
return(View("SampleDetails", newModel));
}
return(RedirectToAction("SampleDetails", new { lab = lab.LabId, sample = sample.SampleId }));
}
public async Task <IHttpActionResult> List(string query = null)
{
return(JsonWithPermissions(new
{
Results = await LabsDao.Find(this, query)
}));
}
private async Task <(Lab lab, bool isLabManager)> GetLab(long labId)
{
var lab = await LabsDao.Read(this, labId);
var isLabManager = IsLabManager(lab);
return(lab, isLabManager);
}
public async Task <IHttpActionResult> Samples(long labId, string query = null)
{
var(_, isLabManager) = await GetLab(labId);
return(JsonWithPermissions(new
{
Results = await LabsDao.ListSamples(this, labId, query)
}, isLabManager, isLabManager, isLabManager));
}
public async Task <IHttpActionResult> Reagents(long labId)
{
var(_, isLabManager) = await GetLab(labId);
return(JsonWithPermissions(new
{
Results = await LabsDao.ListReagents(this, labId)
}, true, isLabManager, isLabManager));
}
public async Task <ActionResult> ConfirmAddSample(Lab lab, Sample sample)
{
if (sample == null)
{
return(HttpNotFound());
}
await LabsDao.AddSample(this, lab.LabId, sample.SampleId);
return(RedirectToAction("Samples", new { lab = lab.LabId }));
}
public async Task <ActionResult> SampleDetails(Lab lab, Sample sample)
{
var model = await LabsDao.GetSampleDetails(this, lab.LabId, sample.SampleId);
if (model == null)
{
return(HttpNotFound());
}
return(View(model));
}
public async Task <IHttpActionResult> Report(long labId)
{
var result = await LabsDao.GenerateReport(this, labId);
if (result == null)
{
return(NotFound());
}
return(JsonWithPermissions(result));
}
public async Task <IHttpActionResult> RemoveReagent(long labId, long usedReagentId, int returnQuantity = 0)
{
var result = await LabsDao.RemoveReagent(this, labId, usedReagentId, returnQuantity);
if (result == null)
{
return(NotFound());
}
return(JsonWithPermissions(result, true, true, true));
}
public async Task <IHttpActionResult> RemoveSample(long labId, long sampleId)
{
var result = await LabsDao.RemoveSample(this, labId, sampleId);
if (result == null)
{
return(NotFound());
}
return(JsonWithPermissions(result, true, true, true));
}
public async Task <IHttpActionResult> UpdateSample(long labId, long sampleId, LabsApiEditSampleModel model)
{
var result = await LabsDao.UpdateSample(this, labId, sampleId, model);
if (result == null)
{
return(NotFound());
}
return(JsonWithPermissions(result, true, true, true));
}
public async Task <IHttpActionResult> Comment(long labId, long sampleId, LabsApiCommentModel model)
{
var result = await LabsDao.PostComment(this, labId, sampleId, model);
if (result == null)
{
return(NotFound());
}
return(JsonWithPermissions(result, true, false, false));
}
public async Task <IHttpActionResult> SampleDetails(long labId, long sampleId)
{
var result = await LabsDao.GetSampleDetails(this, labId, sampleId);
if (result == null)
{
return(NotFound());
}
return(JsonWithPermissions(result, result.IsLabManager, result.IsLabManager, result.IsLabManager));
}
public async Task <ActionResult> Samples(Lab lab, string query = null)
{
var userId = HttpContext.User.Identity.GetUserId();
var model = new LabsSamplesViewModel
{
Lab = lab,
Query = query,
LabSamples = await LabsDao.ListSamples(this, lab.LabId, query),
IsLabManager = lab.UserIsLabManager(userId)
};
return(View(model));
}
public async Task <IHttpActionResult> AddReagent(long labId, long reagentId, int quantity = 1)
{
var(_, isLabManager) = await GetLab(labId);
var result = await LabsDao.AddReagent(this, labId, reagentId, quantity);
if (result == null)
{
return(NotFound());
}
return(JsonWithPermissions(result, true, isLabManager, isLabManager));
}
public async Task <IHttpActionResult> Delete(long labId)
{
var(_, isLabManager) = await GetLab(labId);
var result = await LabsDao.Delete(this, labId);
if (result == null)
{
return(NotFound());
}
return(JsonWithPermissions(result, User.IsPrivileged(), isLabManager, User.IsAdmin()));
}
public async Task <ActionResult> Reagents(Lab lab)
{
var userId = HttpContext.User.Identity.GetUserId();
var results = await LabsDao.ListReagents(this, lab.LabId);
var model = new LabsReagentsViewModel
{
Lab = lab,
UsedReagents = results,
IsLabManager = lab.UserIsLabManager(userId)
};
return(View(model));
}
public async Task <ActionResult> Members(Lab lab)
{
var userId = HttpContext.User.Identity.GetUserId();
var members = await LabsDao.ListMembers(this, lab.LabId);
var model = new LabsMembersViewModel
{
Lab = lab,
Members = members,
IsLabManager = lab.UserIsLabManager(userId)
};
return(View(model));
}
public async Task <IHttpActionResult> Update(long labId, LabsEditViewModel model)
{
var(_, isLabManager) = await GetLab(labId);
var lab = await LabsDao.Read(this, labId);
if (lab == null)
{
return(NotFound());
}
var result = await LabsDao.Update(this, lab, model);
return(JsonWithPermissions(result, User.IsPrivileged(), isLabManager, User.IsAdmin()));
}
public async Task <ActionResult> Index(string query = null)
{
var results = await LabsDao.Find(this, query);
if (results.Count == 0 && string.IsNullOrWhiteSpace(query))
{
results = null;
}
var model = new LabsSearchViewModel
{
Query = query,
Results = results
};
return(View(model));
}
public async Task <ActionResult> AddMember(Lab lab, string query = null)
{
var model = new LabsAddMemberViewModel
{
Lab = lab,
};
if (string.IsNullOrWhiteSpace(query))
{
return(View(model));
}
model.Query = query;
model.Results = await LabsDao.ListAddableMembers(this, lab.LabId, query);
return(View(model));
}
public async Task <ActionResult> AddSample(Lab lab, string query = null)
{
if (string.IsNullOrWhiteSpace(query))
{
return(View(new LabsAddSampleViewModel {
Lab = lab
}));
}
var model = new LabsAddSampleViewModel
{
Lab = lab,
Query = query,
Results = await LabsDao.ListAddableSamples(this, lab.TestId, query)
};
return(View(model));
}
public async Task <ActionResult> Edit(Lab lab, LabsEditViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
await LabsDao.Update(this, lab, model);
}
catch (Exception e)
{
ModelState.AddModelError("", e.ToString());
return(View(model));
}
return(RedirectToAction("Details", new { lab = lab.LabId }));
}
public async Task <ActionResult> Create(LabsCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
await LabsDao.Create(this, model);
}
catch (Exception e)
{
ModelState.AddModelError("", e.ToString());
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> ConfirmAddReagent(Lab lab, Reagent reagent, LabsConfirmAddReagentViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
await LabsDao.AddReagent(this, lab, reagent, model.Quantity);
}
catch (Exception e)
{
ModelState.AddModelError("", e);
return(View(model));
}
return(RedirectToAction("Reagents", new { lab = lab.LabId }));
}
public async Task <ActionResult> EditSample(Lab lab, Sample sample, LabsEditSampleViewModel model)
{
if (sample == null)
{
return(HttpNotFound());
}
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
await LabsDao.UpdateSample(this, lab.LabId, sample.SampleId, model);
}
catch (Exception e)
{
ModelState.AddModelError("", e);
return(View(model));
}
return(RedirectToAction("Samples", new { lab = lab.LabId }));
}
public async Task <ActionResult> Report(Lab lab)
{
return(View(await LabsDao.GenerateReport(this, lab)));
}
public async Task <ActionResult> PostRemoveMember(Lab lab, string userId)
{
await LabsDao.RemoveMember(this, lab.LabId, userId);
return(RedirectToAction("Members", new { lab = lab.LabId }));
}
