public void LabSheetDetail_Controller_Put_Test()
        {
            foreach (LanguageEnum LanguageRequest in AllowableLanguages)
            {
                foreach (int ContactID in new List <int>()
                {
                    AdminContactID
                })                                                             //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
                {
                    LabSheetDetailController labSheetDetailController = new LabSheetDetailController(DatabaseTypeEnum.SqlServerTestDB);
                    Assert.IsNotNull(labSheetDetailController);
                    Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, labSheetDetailController.DatabaseType);

                    LabSheetDetail labSheetDetailLast = new LabSheetDetail();
                    using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
                    {
                        Query query = new Query();
                        query.Language = LanguageRequest;

                        LabSheetDetailService labSheetDetailService = new LabSheetDetailService(query, db, ContactID);
                        labSheetDetailLast = (from c in db.LabSheetDetails select c).FirstOrDefault();
                    }

                    // ok with LabSheetDetail info
                    IHttpActionResult jsonRet = labSheetDetailController.GetLabSheetDetailWithID(labSheetDetailLast.LabSheetDetailID);
                    Assert.IsNotNull(jsonRet);

                    OkNegotiatedContentResult <LabSheetDetail> Ret = jsonRet as OkNegotiatedContentResult <LabSheetDetail>;
                    LabSheetDetail labSheetDetailRet = Ret.Content;
                    Assert.AreEqual(labSheetDetailLast.LabSheetDetailID, labSheetDetailRet.LabSheetDetailID);

                    BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
                    Assert.IsNull(badRequest);

                    // Put to return success
                    IHttpActionResult jsonRet2 = labSheetDetailController.Put(labSheetDetailRet, LanguageRequest.ToString());
                    Assert.IsNotNull(jsonRet2);

                    OkNegotiatedContentResult <LabSheetDetail> labSheetDetailRet2 = jsonRet2 as OkNegotiatedContentResult <LabSheetDetail>;
                    Assert.IsNotNull(labSheetDetailRet2);

                    BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
                    Assert.IsNull(badRequest2);

                    // Put to return CSSPError because LabSheetDetailID of 0 does not exist
                    labSheetDetailRet.LabSheetDetailID = 0;
                    IHttpActionResult jsonRet3 = labSheetDetailController.Put(labSheetDetailRet, LanguageRequest.ToString());
                    Assert.IsNotNull(jsonRet3);

                    OkNegotiatedContentResult <LabSheetDetail> labSheetDetailRet3 = jsonRet3 as OkNegotiatedContentResult <LabSheetDetail>;
                    Assert.IsNull(labSheetDetailRet3);

                    BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
                    Assert.IsNotNull(badRequest3);
                }
            }
        }
Esempio n. 2
0
 public IHttpActionResult GetLabSheetDetailList([FromUri] string lang = "en", [FromUri] int skip  = 0, [FromUri] int take      = 200,
                                                [FromUri] string asc  = "", [FromUri] string desc = "", [FromUri] string where = "", [FromUri] string extra = "")
 {
     using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
     {
         LabSheetDetailService labSheetDetailService = new LabSheetDetailService(new Query()
         {
             Lang = lang
         }, db, ContactID);
        public IHttpActionResult GetLabSheetDetailWithID([FromUri] int LabSheetDetailID, [FromUri] string lang = "en", [FromUri] string extra = "")
        {
            using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
            {
                LabSheetDetailService labSheetDetailService = new LabSheetDetailService(new Query()
                {
                    Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
                }, db, ContactID);

                labSheetDetailService.Query = labSheetDetailService.FillQuery(typeof(LabSheetDetail), lang, 0, 1, "", "", extra);

                if (labSheetDetailService.Query.Extra == "A")
                {
                    LabSheetDetailExtraA labSheetDetailExtraA = new LabSheetDetailExtraA();
                    labSheetDetailExtraA = labSheetDetailService.GetLabSheetDetailExtraAWithLabSheetDetailID(LabSheetDetailID);

                    if (labSheetDetailExtraA == null)
                    {
                        return(NotFound());
                    }

                    return(Ok(labSheetDetailExtraA));
                }
                else if (labSheetDetailService.Query.Extra == "B")
                {
                    LabSheetDetailExtraB labSheetDetailExtraB = new LabSheetDetailExtraB();
                    labSheetDetailExtraB = labSheetDetailService.GetLabSheetDetailExtraBWithLabSheetDetailID(LabSheetDetailID);

                    if (labSheetDetailExtraB == null)
                    {
                        return(NotFound());
                    }

                    return(Ok(labSheetDetailExtraB));
                }
                else
                {
                    LabSheetDetail labSheetDetail = new LabSheetDetail();
                    labSheetDetail = labSheetDetailService.GetLabSheetDetailWithLabSheetDetailID(LabSheetDetailID);

                    if (labSheetDetail == null)
                    {
                        return(NotFound());
                    }

                    return(Ok(labSheetDetail));
                }
            }
        }
        public void LabSheetDetail_Controller_GetLabSheetDetailWithID_Test()
        {
            foreach (LanguageEnum LanguageRequest in AllowableLanguages)
            {
                foreach (int ContactID in new List <int>()
                {
                    AdminContactID
                })                                                             //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
                {
                    LabSheetDetailController labSheetDetailController = new LabSheetDetailController(DatabaseTypeEnum.SqlServerTestDB);
                    Assert.IsNotNull(labSheetDetailController);
                    Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, labSheetDetailController.DatabaseType);

                    LabSheetDetail labSheetDetailFirst = new LabSheetDetail();
                    using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
                    {
                        LabSheetDetailService labSheetDetailService = new LabSheetDetailService(new Query(), db, ContactID);
                        labSheetDetailFirst = (from c in db.LabSheetDetails select c).FirstOrDefault();
                    }

                    // ok with LabSheetDetail info
                    IHttpActionResult jsonRet = labSheetDetailController.GetLabSheetDetailWithID(labSheetDetailFirst.LabSheetDetailID);
                    Assert.IsNotNull(jsonRet);

                    OkNegotiatedContentResult <LabSheetDetail> Ret = jsonRet as OkNegotiatedContentResult <LabSheetDetail>;
                    LabSheetDetail labSheetDetailRet = Ret.Content;
                    Assert.AreEqual(labSheetDetailFirst.LabSheetDetailID, labSheetDetailRet.LabSheetDetailID);

                    BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
                    Assert.IsNull(badRequest);

                    // Not Found
                    IHttpActionResult jsonRet2 = labSheetDetailController.GetLabSheetDetailWithID(0);
                    Assert.IsNotNull(jsonRet2);

                    OkNegotiatedContentResult <LabSheetDetail> labSheetDetailRet2 = jsonRet2 as OkNegotiatedContentResult <LabSheetDetail>;
                    Assert.IsNull(labSheetDetailRet2);

                    NotFoundResult notFoundRequest = jsonRet2 as NotFoundResult;
                    Assert.IsNotNull(notFoundRequest);
                }
            }
        }
        public IHttpActionResult Delete([FromBody] LabSheetDetail labSheetDetail, [FromUri] string lang = "en")
        {
            using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
            {
                LabSheetDetailService labSheetDetailService = new LabSheetDetailService(new Query()
                {
                    Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
                }, db, ContactID);

                if (!labSheetDetailService.Delete(labSheetDetail))
                {
                    return(BadRequest(String.Join("|||", labSheetDetail.ValidationResults)));
                }
                else
                {
                    labSheetDetail.ValidationResults = null;
                    return(Ok(labSheetDetail));
                }
            }
        }
        public void LabSheetDetail_Controller_GetLabSheetDetailList_Test()
        {
            foreach (LanguageEnum LanguageRequest in AllowableLanguages)
            {
                foreach (int ContactID in new List <int>()
                {
                    AdminContactID
                })                                                             //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
                {
                    LabSheetDetailController labSheetDetailController = new LabSheetDetailController(DatabaseTypeEnum.SqlServerTestDB);
                    Assert.IsNotNull(labSheetDetailController);
                    Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, labSheetDetailController.DatabaseType);

                    LabSheetDetail labSheetDetailFirst = new LabSheetDetail();
                    int            count = -1;
                    Query          query = new Query();
                    using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
                    {
                        LabSheetDetailService labSheetDetailService = new LabSheetDetailService(query, db, ContactID);
                        labSheetDetailFirst = (from c in db.LabSheetDetails select c).FirstOrDefault();
                        count = (from c in db.LabSheetDetails select c).Count();
                        count = (query.Take > count ? count : query.Take);
                    }

                    // ok with LabSheetDetail info
                    IHttpActionResult jsonRet = labSheetDetailController.GetLabSheetDetailList();
                    Assert.IsNotNull(jsonRet);

                    OkNegotiatedContentResult <List <LabSheetDetail> > ret = jsonRet as OkNegotiatedContentResult <List <LabSheetDetail> >;
                    Assert.AreEqual(labSheetDetailFirst.LabSheetDetailID, ret.Content[0].LabSheetDetailID);
                    Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);

                    List <LabSheetDetail> labSheetDetailList = new List <LabSheetDetail>();
                    count = -1;
                    query = new Query();
                    using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
                    {
                        LabSheetDetailService labSheetDetailService = new LabSheetDetailService(query, db, ContactID);
                        labSheetDetailList = (from c in db.LabSheetDetails select c).OrderBy(c => c.LabSheetDetailID).Skip(0).Take(2).ToList();
                        count = (from c in db.LabSheetDetails select c).Count();
                    }

                    if (count > 0)
                    {
                        query.Skip = 0;
                        query.Take = 5;
                        count      = (query.Take > count ? query.Take : count);

                        // ok with LabSheetDetail info
                        jsonRet = labSheetDetailController.GetLabSheetDetailList(query.Language.ToString(), query.Skip, query.Take);
                        Assert.IsNotNull(jsonRet);

                        ret = jsonRet as OkNegotiatedContentResult <List <LabSheetDetail> >;
                        Assert.AreEqual(labSheetDetailList[0].LabSheetDetailID, ret.Content[0].LabSheetDetailID);
                        Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);

                        if (count > 1)
                        {
                            query.Skip = 1;
                            query.Take = 5;
                            count      = (query.Take > count ? query.Take : count);

                            // ok with LabSheetDetail info
                            IHttpActionResult jsonRet2 = labSheetDetailController.GetLabSheetDetailList(query.Language.ToString(), query.Skip, query.Take);
                            Assert.IsNotNull(jsonRet2);

                            OkNegotiatedContentResult <List <LabSheetDetail> > ret2 = jsonRet2 as OkNegotiatedContentResult <List <LabSheetDetail> >;
                            Assert.AreEqual(labSheetDetailList[1].LabSheetDetailID, ret2.Content[0].LabSheetDetailID);
                            Assert.AreEqual((count > query.Take ? query.Take : count), ret2.Content.Count);
                        }
                    }
                }
            }
        }
        public void LabSheetDetail_Controller_Post_Test()
        {
            foreach (LanguageEnum LanguageRequest in AllowableLanguages)
            {
                foreach (int ContactID in new List <int>()
                {
                    AdminContactID
                })                                                             //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
                {
                    LabSheetDetailController labSheetDetailController = new LabSheetDetailController(DatabaseTypeEnum.SqlServerTestDB);
                    Assert.IsNotNull(labSheetDetailController);
                    Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, labSheetDetailController.DatabaseType);

                    LabSheetDetail labSheetDetailLast = new LabSheetDetail();
                    using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
                    {
                        Query query = new Query();
                        query.Language = LanguageRequest;
                        query.Asc      = "";
                        query.Desc     = "";

                        LabSheetDetailService labSheetDetailService = new LabSheetDetailService(query, db, ContactID);
                        labSheetDetailLast = (from c in db.LabSheetDetails select c).FirstOrDefault();
                    }

                    // ok with LabSheetDetail info
                    IHttpActionResult jsonRet = labSheetDetailController.GetLabSheetDetailWithID(labSheetDetailLast.LabSheetDetailID);
                    Assert.IsNotNull(jsonRet);

                    OkNegotiatedContentResult <LabSheetDetail> Ret = jsonRet as OkNegotiatedContentResult <LabSheetDetail>;
                    LabSheetDetail labSheetDetailRet = Ret.Content;
                    Assert.AreEqual(labSheetDetailLast.LabSheetDetailID, labSheetDetailRet.LabSheetDetailID);

                    BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
                    Assert.IsNull(badRequest);

                    // Post to return CSSPError because LabSheetDetailID exist
                    IHttpActionResult jsonRet2 = labSheetDetailController.Post(labSheetDetailRet, LanguageRequest.ToString());
                    Assert.IsNotNull(jsonRet2);

                    OkNegotiatedContentResult <LabSheetDetail> labSheetDetailRet2 = jsonRet2 as OkNegotiatedContentResult <LabSheetDetail>;
                    Assert.IsNull(labSheetDetailRet2);

                    BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
                    Assert.IsNotNull(badRequest2);

                    // Post to return newly added LabSheetDetail
                    labSheetDetailRet.LabSheetDetailID          = 0;
                    labSheetDetailController.Request            = new System.Net.Http.HttpRequestMessage();
                    labSheetDetailController.Request.RequestUri = new System.Uri("http://localhost:5000/api/labSheetDetail");
                    IHttpActionResult jsonRet3 = labSheetDetailController.Post(labSheetDetailRet, LanguageRequest.ToString());
                    Assert.IsNotNull(jsonRet3);

                    CreatedNegotiatedContentResult <LabSheetDetail> labSheetDetailRet3 = jsonRet3 as CreatedNegotiatedContentResult <LabSheetDetail>;
                    Assert.IsNotNull(labSheetDetailRet3);

                    BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
                    Assert.IsNull(badRequest3);

                    IHttpActionResult jsonRet4 = labSheetDetailController.Delete(labSheetDetailRet, LanguageRequest.ToString());
                    Assert.IsNotNull(jsonRet4);

                    OkNegotiatedContentResult <LabSheetDetail> labSheetDetailRet4 = jsonRet4 as OkNegotiatedContentResult <LabSheetDetail>;
                    Assert.IsNotNull(labSheetDetailRet4);

                    BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
                    Assert.IsNull(badRequest4);
                }
            }
        }
        public IHttpActionResult GetLabSheetDetailList([FromUri] string lang = "en", [FromUri] int skip  = 0, [FromUri] int take      = 200,
                                                       [FromUri] string asc  = "", [FromUri] string desc = "", [FromUri] string where = "", [FromUri] string extra = "")
        {
            using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
            {
                LabSheetDetailService labSheetDetailService = new LabSheetDetailService(new Query()
                {
                    Lang = lang
                }, db, ContactID);

                if (extra == "A") // QueryString contains [extra=A]
                {
                    labSheetDetailService.Query = labSheetDetailService.FillQuery(typeof(LabSheetDetailExtraA), lang, skip, take, asc, desc, where, extra);

                    if (labSheetDetailService.Query.HasErrors)
                    {
                        return(Ok(new List <LabSheetDetailExtraA>()
                        {
                            new LabSheetDetailExtraA()
                            {
                                HasErrors = labSheetDetailService.Query.HasErrors,
                                ValidationResults = labSheetDetailService.Query.ValidationResults,
                            },
                        }.ToList()));
                    }
                    else
                    {
                        return(Ok(labSheetDetailService.GetLabSheetDetailExtraAList().ToList()));
                    }
                }
                else if (extra == "B") // QueryString contains [extra=B]
                {
                    labSheetDetailService.Query = labSheetDetailService.FillQuery(typeof(LabSheetDetailExtraB), lang, skip, take, asc, desc, where, extra);

                    if (labSheetDetailService.Query.HasErrors)
                    {
                        return(Ok(new List <LabSheetDetailExtraB>()
                        {
                            new LabSheetDetailExtraB()
                            {
                                HasErrors = labSheetDetailService.Query.HasErrors,
                                ValidationResults = labSheetDetailService.Query.ValidationResults,
                            },
                        }.ToList()));
                    }
                    else
                    {
                        return(Ok(labSheetDetailService.GetLabSheetDetailExtraBList().ToList()));
                    }
                }
                else // QueryString has no parameter [extra] or extra is empty
                {
                    labSheetDetailService.Query = labSheetDetailService.FillQuery(typeof(LabSheetDetail), lang, skip, take, asc, desc, where, extra);

                    if (labSheetDetailService.Query.HasErrors)
                    {
                        return(Ok(new List <LabSheetDetail>()
                        {
                            new LabSheetDetail()
                            {
                                HasErrors = labSheetDetailService.Query.HasErrors,
                                ValidationResults = labSheetDetailService.Query.ValidationResults,
                            },
                        }.ToList()));
                    }
                    else
                    {
                        return(Ok(labSheetDetailService.GetLabSheetDetailList().ToList()));
                    }
                }
            }
        }
Esempio n. 9
0
        public string UploadLabSheetDetailInDB(LabSheetAndA1Sheet labSheetAndA1Sheet)
        {
            string retStr = "";

            // Filling LabSheetDetailModel
            LabSheetDetail labSheetDetailNew = new LabSheetDetail();

            labSheetDetailNew.LabSheetID        = labSheetAndA1Sheet.LabSheet.LabSheetID;
            labSheetDetailNew.SamplingPlanID    = labSheetAndA1Sheet.LabSheet.SamplingPlanID;
            labSheetDetailNew.SubsectorTVItemID = labSheetAndA1Sheet.LabSheet.SubsectorTVItemID;
            labSheetDetailNew.Version           = labSheetAndA1Sheet.LabSheetA1Sheet.Version;
            //labSheetDetailNew.IncludeLaboratoryQAQC = labSheetAndA1Sheet.LabSheetA1Sheet.IncludeLaboratoryQAQC;

            // RunDate
            DateTime RunDate  = new DateTime();
            int      RunYear  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear));
            int      RunMonth = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth));
            int      RunDay   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay));

            if (RunYear != 1900)
            {
                RunDate = new DateTime(RunYear, RunMonth, RunDay);
            }

            labSheetDetailNew.RunDate = RunDate;

            labSheetDetailNew.Tides = labSheetAndA1Sheet.LabSheetA1Sheet.Tides;
            labSheetDetailNew.SampleCrewInitials = labSheetAndA1Sheet.LabSheetA1Sheet.SampleCrewInitials;

            if (labSheetAndA1Sheet.LabSheetA1Sheet.IncludeLaboratoryQAQC)
            {
                // IncubationBath1StartDate
                DateTime IncubationBath1StartDate   = new DateTime();
                int      IncubationBath1StartYear   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear));
                int      IncubationBath1StartMonth  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth));
                int      IncubationBath1StartDay    = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay));
                int      IncubationBath1StartHour   = 0;
                int      IncubationBath1StartMinute = 0;
                if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1StartTime.Length == 5)
                {
                    IncubationBath1StartHour   = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1StartTime.Substring(0, 2));
                    IncubationBath1StartMinute = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1StartTime.Substring(3, 2));
                }
                if (IncubationBath1StartYear != 1900)
                {
                    IncubationBath1StartDate = new DateTime(IncubationBath1StartYear, IncubationBath1StartMonth, IncubationBath1StartDay, IncubationBath1StartHour, IncubationBath1StartMinute, 0);
                }

                labSheetDetailNew.IncubationBath1StartTime = IncubationBath1StartDate;

                // IncubationBath1EndDate
                DateTime IncubationBath1EndDate   = new DateTime();
                int      IncubationBath1EndYear   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear));
                int      IncubationBath1EndMonth  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth));
                int      IncubationBath1EndDay    = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay));
                int      IncubationBath1EndHour   = 0;
                int      IncubationBath1EndMinute = 0;
                if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1EndTime.Length == 5)
                {
                    IncubationBath1EndHour   = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1EndTime.Substring(0, 2));
                    IncubationBath1EndMinute = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1EndTime.Substring(3, 2));
                }
                if (IncubationBath1EndYear != 1900)
                {
                    IncubationBath1EndDate = new DateTime(IncubationBath1EndYear, IncubationBath1EndMonth, IncubationBath1EndDay, IncubationBath1EndHour, IncubationBath1EndMinute, 0).AddDays(1);
                }

                labSheetDetailNew.IncubationBath1EndTime = IncubationBath1EndDate;

                // IncubationBath1TimeCalculated_minutes
                int IncubationBath1TimeCalculated_minutes = 0;
                if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1TimeCalculated.Length == 5)
                {
                    IncubationBath1TimeCalculated_minutes  = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1TimeCalculated.Substring(0, 2)) * 60;
                    IncubationBath1TimeCalculated_minutes += int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath1TimeCalculated.Substring(3, 2));
                }

                labSheetDetailNew.IncubationBath1TimeCalculated_minutes = IncubationBath1TimeCalculated_minutes;

                labSheetDetailNew.WaterBath1 = labSheetAndA1Sheet.LabSheetA1Sheet.WaterBath1;

                labSheetDetailNew.WaterBathCount = labSheetAndA1Sheet.LabSheetA1Sheet.WaterBathCount;

                if (labSheetDetailNew.WaterBathCount > 1)
                {
                    // IncubationBath2StartDate
                    DateTime IncubationBath2StartDate   = new DateTime();
                    int      IncubationBath2StartYear   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear));
                    int      IncubationBath2StartMonth  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth));
                    int      IncubationBath2StartDay    = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay));
                    int      IncubationBath2StartHour   = 0;
                    int      IncubationBath2StartMinute = 0;
                    if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2StartTime.Length == 5)
                    {
                        IncubationBath2StartHour   = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2StartTime.Substring(0, 2));
                        IncubationBath2StartMinute = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2StartTime.Substring(3, 2));
                    }
                    if (IncubationBath2StartYear != 1900)
                    {
                        IncubationBath2StartDate = new DateTime(IncubationBath2StartYear, IncubationBath2StartMonth, IncubationBath2StartDay, IncubationBath2StartHour, IncubationBath2StartMinute, 0);
                    }

                    labSheetDetailNew.IncubationBath2StartTime = IncubationBath2StartDate;

                    // IncubationBath2EndDate
                    DateTime IncubationBath2EndDate   = new DateTime();
                    int      IncubationBath2EndYear   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear));
                    int      IncubationBath2EndMonth  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth));
                    int      IncubationBath2EndDay    = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay));
                    int      IncubationBath2EndHour   = 0;
                    int      IncubationBath2EndMinute = 0;
                    if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2EndTime.Length == 5)
                    {
                        IncubationBath2EndHour   = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2EndTime.Substring(0, 2));
                        IncubationBath2EndMinute = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2EndTime.Substring(3, 2));
                    }
                    if (IncubationBath2EndYear != 1900)
                    {
                        IncubationBath2EndDate = new DateTime(IncubationBath2EndYear, IncubationBath2EndMonth, IncubationBath2EndDay, IncubationBath2EndHour, IncubationBath2EndMinute, 0).AddDays(1);
                    }

                    labSheetDetailNew.IncubationBath2EndTime = IncubationBath2EndDate;

                    // IncubationBath2TimeCalculated_minutes
                    int IncubationBath2TimeCalculated_minutes = 0;
                    if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2TimeCalculated.Length == 5)
                    {
                        IncubationBath2TimeCalculated_minutes  = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2TimeCalculated.Substring(0, 2)) * 60;
                        IncubationBath2TimeCalculated_minutes += int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath2TimeCalculated.Substring(3, 2));
                    }

                    labSheetDetailNew.IncubationBath2TimeCalculated_minutes = IncubationBath2TimeCalculated_minutes;

                    labSheetDetailNew.WaterBath2         = labSheetAndA1Sheet.LabSheetA1Sheet.WaterBath2;
                    labSheetDetailNew.Bath2Positive44_5  = labSheetAndA1Sheet.LabSheetA1Sheet.Bath2Positive44_5;
                    labSheetDetailNew.Bath2NonTarget44_5 = labSheetAndA1Sheet.LabSheetA1Sheet.Bath2NonTarget44_5;
                    labSheetDetailNew.Bath2Negative44_5  = labSheetAndA1Sheet.LabSheetA1Sheet.Bath2Negative44_5;
                    labSheetDetailNew.Bath2Blank44_5     = labSheetAndA1Sheet.LabSheetA1Sheet.Bath2Blank44_5;
                }

                if (labSheetDetailNew.WaterBathCount > 2)
                {
                    // IncubationBath3StartDate
                    DateTime IncubationBath3StartDate   = new DateTime();
                    int      IncubationBath3StartYear   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear));
                    int      IncubationBath3StartMonth  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth));
                    int      IncubationBath3StartDay    = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay));
                    int      IncubationBath3StartHour   = 0;
                    int      IncubationBath3StartMinute = 0;
                    if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3StartTime.Length == 5)
                    {
                        IncubationBath3StartHour   = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3StartTime.Substring(0, 2));
                        IncubationBath3StartMinute = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3StartTime.Substring(3, 2));
                    }
                    if (IncubationBath3StartYear != 1900)
                    {
                        IncubationBath3StartDate = new DateTime(IncubationBath3StartYear, IncubationBath3StartMonth, IncubationBath3StartDay, IncubationBath3StartHour, IncubationBath3StartMinute, 0);
                    }

                    labSheetDetailNew.IncubationBath3StartTime = IncubationBath3StartDate;

                    // IncubationBath3EndDate
                    DateTime IncubationBath3EndDate   = new DateTime();
                    int      IncubationBath3EndYear   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunYear));
                    int      IncubationBath3EndMonth  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunMonth));
                    int      IncubationBath3EndDay    = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.RunDay));
                    int      IncubationBath3EndHour   = 0;
                    int      IncubationBath3EndMinute = 0;
                    if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3EndTime.Length == 5)
                    {
                        IncubationBath3EndHour   = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3EndTime.Substring(0, 2));
                        IncubationBath3EndMinute = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3EndTime.Substring(3, 2));
                    }
                    if (IncubationBath3EndYear != 1900)
                    {
                        IncubationBath3EndDate = new DateTime(IncubationBath3EndYear, IncubationBath3EndMonth, IncubationBath3EndDay, IncubationBath3EndHour, IncubationBath3EndMinute, 0).AddDays(1);
                    }

                    labSheetDetailNew.IncubationBath3EndTime = IncubationBath3EndDate;

                    // IncubationBath3TimeCalculated_minutes
                    int IncubationBath3TimeCalculated_minutes = 0;
                    if (labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3TimeCalculated.Length == 5)
                    {
                        IncubationBath3TimeCalculated_minutes  = int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3TimeCalculated.Substring(0, 2)) * 60;
                        IncubationBath3TimeCalculated_minutes += int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IncubationBath3TimeCalculated.Substring(3, 2));
                    }

                    labSheetDetailNew.IncubationBath3TimeCalculated_minutes = IncubationBath3TimeCalculated_minutes;

                    labSheetDetailNew.WaterBath3         = labSheetAndA1Sheet.LabSheetA1Sheet.WaterBath3;
                    labSheetDetailNew.Bath3Positive44_5  = labSheetAndA1Sheet.LabSheetA1Sheet.Bath3Positive44_5;
                    labSheetDetailNew.Bath3NonTarget44_5 = labSheetAndA1Sheet.LabSheetA1Sheet.Bath3NonTarget44_5;
                    labSheetDetailNew.Bath3Negative44_5  = labSheetAndA1Sheet.LabSheetA1Sheet.Bath3Negative44_5;
                    labSheetDetailNew.Bath3Blank44_5     = labSheetAndA1Sheet.LabSheetA1Sheet.Bath3Blank44_5;
                }

                labSheetDetailNew.TCField1 = null;
                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.TCField1))
                {
                    float temp = 0.0f;
                    if (float.TryParse(labSheetAndA1Sheet.LabSheetA1Sheet.TCField1, out temp))
                    {
                        labSheetDetailNew.TCField1 = temp;
                    }
                }
                labSheetDetailNew.TCLab1 = null;
                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.TCLab1))
                {
                    float temp = 0.0f;
                    if (float.TryParse(labSheetAndA1Sheet.LabSheetA1Sheet.TCLab1, out temp))
                    {
                        labSheetDetailNew.TCLab1 = temp;
                    }
                }
                labSheetDetailNew.TCField2 = null;
                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.TCField2))
                {
                    float temp = 0.0f;
                    if (float.TryParse(labSheetAndA1Sheet.LabSheetA1Sheet.TCField2, out temp))
                    {
                        labSheetDetailNew.TCField2 = temp;
                    }
                }
                labSheetDetailNew.TCLab2 = null;
                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.TCLab2))
                {
                    float temp = 0.0f;
                    if (float.TryParse(labSheetAndA1Sheet.LabSheetA1Sheet.TCLab2, out temp))
                    {
                        labSheetDetailNew.TCLab2 = temp;
                    }
                }
                labSheetDetailNew.TCFirst = null;
                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.TCFirst) && !labSheetAndA1Sheet.LabSheetA1Sheet.TCFirst.Contains("-"))
                {
                    float temp = 0.0f;
                    if (float.TryParse(labSheetAndA1Sheet.LabSheetA1Sheet.TCFirst, out temp))
                    {
                        labSheetDetailNew.TCFirst = temp;
                    }
                }
                labSheetDetailNew.TCAverage = null;
                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.TCAverage) && !labSheetAndA1Sheet.LabSheetA1Sheet.TCAverage.Contains("-"))
                {
                    float temp = 0.0f;
                    if (float.TryParse(labSheetAndA1Sheet.LabSheetA1Sheet.TCAverage, out temp))
                    {
                        labSheetDetailNew.TCAverage = temp;
                    }
                }
                labSheetDetailNew.ControlLot         = labSheetAndA1Sheet.LabSheetA1Sheet.ControlLot;
                labSheetDetailNew.Positive35         = labSheetAndA1Sheet.LabSheetA1Sheet.Positive35;
                labSheetDetailNew.NonTarget35        = labSheetAndA1Sheet.LabSheetA1Sheet.NonTarget35;
                labSheetDetailNew.Negative35         = labSheetAndA1Sheet.LabSheetA1Sheet.Negative35;
                labSheetDetailNew.Bath1Positive44_5  = labSheetAndA1Sheet.LabSheetA1Sheet.Bath1Positive44_5;
                labSheetDetailNew.Bath1NonTarget44_5 = labSheetAndA1Sheet.LabSheetA1Sheet.Bath1NonTarget44_5;
                labSheetDetailNew.Bath1Negative44_5  = labSheetAndA1Sheet.LabSheetA1Sheet.Bath1Negative44_5;
                labSheetDetailNew.Blank35            = labSheetAndA1Sheet.LabSheetA1Sheet.Blank35;
                labSheetDetailNew.Bath1Blank44_5     = labSheetAndA1Sheet.LabSheetA1Sheet.Bath1Blank44_5;
                labSheetDetailNew.Lot35                 = labSheetAndA1Sheet.LabSheetA1Sheet.Lot35;
                labSheetDetailNew.Lot44_5               = labSheetAndA1Sheet.LabSheetA1Sheet.Lot44_5;
                labSheetDetailNew.RunComment            = labSheetAndA1Sheet.LabSheetA1Sheet.RunComment;
                labSheetDetailNew.RunWeatherComment     = labSheetAndA1Sheet.LabSheetA1Sheet.RunWeatherComment;
                labSheetDetailNew.SampleBottleLotNumber = labSheetAndA1Sheet.LabSheetA1Sheet.SampleBottleLotNumber;
                labSheetDetailNew.SalinitiesReadBy      = labSheetAndA1Sheet.LabSheetA1Sheet.SalinitiesReadBy;

                // SalinitiesReadDate
                DateTime SalinitiesReadDate  = new DateTime();
                int      SalinitiesReadYear  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.SalinitiesReadYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.SalinitiesReadYear));
                int      SalinitiesReadMonth = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.SalinitiesReadMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.SalinitiesReadMonth));
                int      SalinitiesReadDay   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.SalinitiesReadDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.SalinitiesReadDay));
                if (SalinitiesReadYear != 1900)
                {
                    SalinitiesReadDate = new DateTime(SalinitiesReadYear, SalinitiesReadMonth, SalinitiesReadDay);
                }

                labSheetDetailNew.SalinitiesReadDate = SalinitiesReadDate;
                labSheetDetailNew.ResultsReadBy      = labSheetAndA1Sheet.LabSheetA1Sheet.ResultsReadBy;

                // ResultsReadDate
                DateTime ResultsReadDate  = new DateTime();
                int      ResultsReadYear  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsReadYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsReadYear));
                int      ResultsReadMonth = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsReadMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsReadMonth));
                int      ResultsReadDay   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsReadDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsReadDay));
                if (ResultsReadYear != 1900)
                {
                    ResultsReadDate = new DateTime(ResultsReadYear, ResultsReadMonth, ResultsReadDay);
                }

                labSheetDetailNew.ResultsReadDate   = ResultsReadDate;
                labSheetDetailNew.ResultsRecordedBy = labSheetAndA1Sheet.LabSheetA1Sheet.ResultsRecordedBy;

                // ResultsRecordedDate
                DateTime ResultsRecordedDate  = new DateTime();
                int      ResultsRecordedYear  = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsRecordedYear) ? 1900 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsRecordedYear));
                int      ResultsRecordedMonth = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsRecordedMonth) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsRecordedMonth));
                int      ResultsRecordedDay   = (string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsRecordedDay) ? 1 : int.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.ResultsRecordedDay));
                if (ResultsRecordedYear != 1900)
                {
                    ResultsRecordedDate = new DateTime(ResultsRecordedYear, ResultsRecordedMonth, ResultsRecordedDay);
                }

                labSheetDetailNew.ResultsRecordedDate = ResultsRecordedDate;

                labSheetDetailNew.DailyDuplicateRLog = 0.0f;
                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicateRLog) && !labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicateRLog.StartsWith("N"))
                {
                    try
                    {
                        labSheetDetailNew.DailyDuplicateRLog = float.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicateRLog);
                    }
                    catch (Exception)
                    {
                        // nothing
                    }
                }

                labSheetDetailNew.DailyDuplicatePrecisionCriteria = null;
                labSheetDetailNew.DailyDuplicateRLog                  = null;
                labSheetDetailNew.DailyDuplicateAcceptable            = null;
                labSheetDetailNew.IntertechDuplicatePrecisionCriteria = null;
                labSheetDetailNew.IntertechDuplicateRLog              = null;
                labSheetDetailNew.IntertechDuplicateAcceptable        = null;
                labSheetDetailNew.IntertechReadAcceptable             = null;

                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicatePrecisionCriteria))
                {
                    labSheetDetailNew.DailyDuplicatePrecisionCriteria = float.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicatePrecisionCriteria);
                }

                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicateRLog))
                {
                    if (!labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicateRLog.StartsWith("N"))
                    {
                        labSheetDetailNew.DailyDuplicateRLog = float.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicateRLog);
                    }
                }

                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicateAcceptableOrUnacceptable))
                {
                    labSheetDetailNew.DailyDuplicateAcceptable = (labSheetAndA1Sheet.LabSheetA1Sheet.DailyDuplicateAcceptableOrUnacceptable != "Acceptable" ? false : true);
                }

                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.IntertechDuplicatePrecisionCriteria))
                {
                    labSheetDetailNew.IntertechDuplicatePrecisionCriteria = float.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IntertechDuplicatePrecisionCriteria);
                }

                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.IntertechDuplicateRLog))
                {
                    if (!labSheetAndA1Sheet.LabSheetA1Sheet.IntertechDuplicateRLog.StartsWith("N"))
                    {
                        labSheetDetailNew.IntertechDuplicateRLog = float.Parse(labSheetAndA1Sheet.LabSheetA1Sheet.IntertechDuplicateRLog);
                    }
                }

                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.IntertechDuplicateAcceptableOrUnacceptable))
                {
                    labSheetDetailNew.IntertechDuplicateAcceptable = (labSheetAndA1Sheet.LabSheetA1Sheet.IntertechDuplicateAcceptableOrUnacceptable != "Acceptable" ? false : true);
                }

                if (!string.IsNullOrWhiteSpace(labSheetAndA1Sheet.LabSheetA1Sheet.IntertechReadAcceptableOrUnacceptable))
                {
                    labSheetDetailNew.IntertechReadAcceptable = (labSheetAndA1Sheet.LabSheetA1Sheet.IntertechReadAcceptableOrUnacceptable != "Acceptable" ? false : true);
                }
            }

            LabSheetDetailService labSheetDetailService = new LabSheetDetailService(LanguageEnum.en, _User);

            LabSheetDetail labSheetDetailExist = labSheetDetailService.GetLabSheetDetailExistDB(labSheetDetailNew);

            if (!string.IsNullOrWhiteSpace(labSheetDetailExist.Error))
            {
                labSheetDetailExist = labSheetDetailService.PostAddLabSheetDetailDB(labSheetDetailNew);
                if (!string.IsNullOrWhiteSpace(labSheetDetailExist.Error))
                {
                    richTextBoxStatus.AppendText("Lab sheet detail could not be loaded to the local DB. Error [" + labSheetDetailExist.Error + "]\r\n");
                    return(labSheetDetailExist.Error);
                }
            }
            else
            {
                labSheetDetailNew.LabSheetDetailID = labSheetDetailExist.LabSheetDetailID;
                labSheetDetailExist = labSheetDetailService.PostUpdateLabSheetDetailDB(labSheetDetailNew);
                if (!string.IsNullOrWhiteSpace(labSheetDetailExist.Error))
                {
                    richTextBoxStatus.AppendText("Lab sheet detail could not be loaded to the local DB. Error [" + labSheetDetailExist.Error + "]\r\n");
                    return(labSheetDetailExist.Error);
                }
            }

            retStr = UploadLabSheetTubeMPNDetailInDB(labSheetDetailExist.LabSheetDetailID, labSheetAndA1Sheet.LabSheetA1Sheet.LabSheetA1MeasurementList);
            if (!string.IsNullOrWhiteSpace(retStr))
            {
                richTextBoxStatus.AppendText("Lab sheet tube and MPN detail could not be loaded to the local DB. Error [" + retStr + "]\r\n");
                return(retStr);
            }

            return(retStr);
        }