public JsonResult AddLabTestResult(LabTestResult labTestResult)
 {
     try
     {
         var result = this._labTestResultService.AddLabTestResult(labTestResult);
         if (result != null)
         {
             return(Json(new
             {
                 success = true,
                 labTestResultId = result.LabTestResultId
             }));
         }
         else
         {
             return(Json(new
             {
                 success = false,
                 message = "Đã xảy ra lỗi trong quá trình tạo mới"
             }));
         }
     }
     catch (Exception ex)
     {
         return(Json(new
         {
             success = true,
             message = ex.Message
         }));
     }
 }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            if (Session["role"] != null && Session["role"].ToString() == "ADM")
            {
                LabTestResult labTestResult = await db.LabTestResults.FindAsync(id);

                db.LabTestResults.Remove(labTestResult);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            else
            {
                return(View("~/Views/LabTestResults/NotLoggedIn.cshtml"));
            }
        }
        public LabTestResult AddLabTestResult(LabTestResult labTestResult)
        {
            try
            {
                var unitOfWork = RepositoryHelper.GetUnitOfWork();
                var context    = unitOfWork.Context;
                using (var transaction = context.Database.BeginTransaction())
                {
                    var labTestResultTmp = new LabTestResult()
                    {
                        PatientId   = labTestResult.PatientId,
                        Comment     = labTestResult.Comment,
                        CreatedDate = DateTime.UtcNow.AddHours(7)
                    };
                    context.Set <LabTestResult>().Add(labTestResultTmp);
                    var result = unitOfWork.SaveChanges();
                    if (result.Any())
                    {
                        transaction.Rollback();
                        return(null);
                    }

                    var labTestResultDetails = labTestResult.LabTestResultDetails.Where(x => !String.IsNullOrEmpty(x.Value)).ToList();
                    var listIds    = labTestResultDetails.Select(y => y.LabTestDetailId).ToList();
                    var allLabTest = context.Set <LabTestDetail>().Where(x => listIds.Contains(x.LabTestDetailId)).ToList();
                    labTestResultDetails.ForEach(x =>
                    {
                        x.LabTestResultId = labTestResultTmp.LabTestResultId;
                        x.Price           = allLabTest.FirstOrDefault(y => y.LabTestDetailId == x.LabTestDetailId).Price;
                    });
                    context.Set <LabTestResultDetail>().AddRange(labTestResultDetails);
                    labTestResultTmp.TotalPrice = labTestResultDetails.Sum(x => x.Price.GetValueOrDefault());
                    result = unitOfWork.SaveChanges();
                    if (result.Any())
                    {
                        transaction.Rollback();
                        return(null);
                    }
                    transaction.Commit();
                    return(labTestResultTmp);
                }
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
Beispiel #4
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="LabResultForm" /> class.
 /// </summary>
 /// <param name="testOrder">The Lab Test Order.</param>
 public LabResultForm(LabTestOrder testOrder)
 {
     this.InitializeComponent();
     this.resultController = new LabTestResultController();
     try
     {
         this.result = this.resultController.GetById(testOrder.TestResultId);
     }
     catch
     {
         this.result = null;
     }
     if (this.result == null)
     {
         this.result = new LabTestResult(testOrder.TestOrderedId, "");
     }
     this.textBox.Text = this.result.TestResults;
 }
 public JsonResult UpdateLabTestResult(LabTestResult labTestResult)
 {
     try
     {
         var result = this._labTestResultService.UpdateLabTestResult(labTestResult);
         return(Json(new
         {
             success = true
         }));
     }
     catch (Exception ex)
     {
         return(Json(new
         {
             success = true,
             message = ex.Message
         }));
     }
 }///
        public async Task <ActionResult> Edit([Bind(Include = "Id,LabTestsConductedId,Result,CreatedDate")] LabTestResult labTestResult)
        {
            if (Session["role"] != null && Session["role"].ToString() == "ADM")
            {
                if (ModelState.IsValid)
                {
                    db.Entry(labTestResult).State = EntityState.Modified;
                    await db.SaveChangesAsync();

                    return(RedirectToAction("Index"));
                }
                ViewBag.LabTestsConductedId = new SelectList(db.LabTestsConducteds, "Id", "PatientName", labTestResult.LabTestsConductedId);
                return(View(labTestResult));
            }
            else
            {
                return(View("~/Views/LabTestResults/NotLoggedIn.cshtml"));
            }
        }
        // GET: LabTestResults/Details/5
        public async Task <ActionResult> Details(int?id)
        {
            if (Session["role"] != null)
            {
                if (id == null)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                }
                LabTestResult labTestResult = await db.LabTestResults.FindAsync(id);

                if (labTestResult == null)
                {
                    return(HttpNotFound());
                }
                return(View(labTestResult));
            }
            else
            {
                return(View("~/Views/LabTestResults/NotLoggedIn.cshtml"));
            }
        }
        public bool UpdateLabTestResult(LabTestResult labTestResult)
        {
            try
            {
                var unitOfWork = RepositoryHelper.GetUnitOfWork();
                var context    = unitOfWork.Context;
                var labTest    = context.Set <LabTestResult>()
                                 .Include(x => x.LabTestResultDetails)
                                 .SingleOrDefault(x => x.LabTestResultId == labTestResult.LabTestResultId);
                labTest.Patient   = null;
                labTest.PatientId = labTestResult.PatientId;
                labTest.Comment   = labTestResult.Comment;
                context.Set <LabTestResultDetail>().RemoveRange(labTest.LabTestResultDetails);
                var labTestResultDetails = labTestResult.LabTestResultDetails.Where(x => !String.IsNullOrEmpty(x.Value)).ToList();

                var listIds    = labTestResultDetails.Select(y => y.LabTestDetailId).ToList();
                var allLabTest = context.Set <LabTestDetail>().Where(x => listIds.Contains(x.LabTestDetailId)).ToList();
                labTestResultDetails.ForEach(x =>
                {
                    x.Price = allLabTest.FirstOrDefault(y => y.LabTestDetailId == x.LabTestDetailId).Price;
                });
                labTest.TotalPrice           = labTestResultDetails.Sum(x => x.Price.GetValueOrDefault());
                labTest.LabTestResultDetails = labTestResultDetails;



                var result = unitOfWork.SaveChanges();
                if (result.Any())
                {
                    return(false);
                }

                return(true);
            }
            catch (Exception ex)
            {
                return(false);
            }
        }
        // GET: LabTestResults/Edit/5
        public async Task <ActionResult> Edit(int?id)
        {
            if (Session["role"] != null && Session["role"].ToString() == "ADM")
            {
                if (id == null)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                }
                LabTestResult labTestResult = await db.LabTestResults.FindAsync(id);

                if (labTestResult == null)
                {
                    return(HttpNotFound());
                }
                ViewBag.LabTestsConductedId = new SelectList(db.LabTestsConducteds, "Id", "PatientName", labTestResult.LabTestsConductedId);
                return(View(labTestResult));
            }
            else
            {
                return(View("~/Views/LabTestResults/NotLoggedIn.cshtml"));
            }
        }
 public void Update(LabTestResult result)
 {
     this.labTestResultRepository.Update(result);
 }
 public void Add(LabTestResult labTestOrdered)
 {
     this.labTestResultRepository.Add(labTestOrdered);
 }