public void LabSheetService_ParseLabSheetA1_Empty_First_Line_Error_Test()
{
Setup();
FileInfo fiLabSheetTestFile = new FileInfo(TestFileName);
Assert.IsTrue(fiLabSheetTestFile.Exists);
StreamReader sr = fiLabSheetTestFile.OpenText();
string FullFileText = sr.ReadToEnd();
sr.Close();
List <string> variableStrList = new List <string>()
{
"Version", "Sampling Plan Type", "Sample Type", "Lab Sheet Type", "Subsector", "Date", "Tides", "Sample Crew Initials",
"Incubation Start Same Day", "Incubation Start Time", "Incubation End Time", "Incubation Time Calculated", "Water Bath Count",
"Water Bath", "TC Has 2 Coolers", "TC Field", "TC Lab", "TC First", "TC Average", "Control Lot", "Positive 35", "Non Target 35",
"Negative 35", "Positive 44.5", "Non Target 44.5", "Negative 44.5", "Blank 35", "Blank 44.5", "Lot 35", "Lot 44.5",
"Daily Duplicate", "Intertech Duplicate", "Intertech Read", "Run Weather Comment", "Run Comment", "Sample Bottle Lot Number",
"Salinities", "Results", "Recorded"
};
foreach (string variableStr in variableStrList)
{
string FullFileText2 = FullFileText.Replace((variableStr == "Water Bath" ? "Water Bath|" : variableStr), "");;
LabSheetA1Sheet labSheetA1Sheet = csspLabSheetParser.ParseLabSheetA1(FullFileText2);
Assert.AreEqual("ERR: Variable " + variableStr + " could not be found.", labSheetA1Sheet.Error);
}
}
public void LabSheetService_ParseLabSheetA1_MPN_Parameter_Empty_Error_Test()
{
Setup();
FileInfo fiLabSheetTestFile = new FileInfo(TestFileName);
Assert.IsTrue(fiLabSheetTestFile.Exists);
StreamReader sr = fiLabSheetTestFile.OpenText();
string FullFileText = sr.ReadToEnd();
sr.Close();
string FullFileContent = FullFileText;
StringBuilder sb = new StringBuilder();
sb.Clear();
StringReader sr2 = new StringReader(FullFileContent);
int LineNumber = 0;
string StartText = "0022 13:13";
for (int j = 0; j < 10000; j++)
{
string LineStr = sr2.ReadLine();
if (LineStr == null)
{
break;
}
if (LineStr.StartsWith(StartText) && LineNumber == 0)
{
LineNumber = j;
LineStr = LineStr.Replace(
"0022 13:13 4 2 2 1.0 2.0 ER Routine 32",
"0022 13:13 4 2 2 1.0 2.0 ER Routine aa");
sb.AppendLine(LineStr);
}
else
{
sb.AppendLine(LineStr);
}
}
FullFileText = sb.ToString();
LabSheetA1Sheet labSheetA1Sheet = csspLabSheetParser.ParseLabSheetA1(FullFileText);
Assert.AreEqual("", labSheetA1Sheet.Error);
Assert.AreEqual(-999, labSheetA1Sheet.LabSheetA1MeasurementList[0].MPN);
}
public void LabSheetService_ParseLabSheetA1_Site_Parameter_Empty_Error_Test()
{
Setup();
FileInfo fiLabSheetTestFile = new FileInfo(TestFileName);
Assert.IsTrue(fiLabSheetTestFile.Exists);
StreamReader sr = fiLabSheetTestFile.OpenText();
string FullFileText = sr.ReadToEnd();
sr.Close();
string FullFileContent = FullFileText;
StringBuilder sb = new StringBuilder();
sb.Clear();
StringReader sr2 = new StringReader(FullFileContent);
int LineNumber = 0;
string StartText = "0022 13:13";
string VarText = "Site";
for (int j = 0; j < 10000; j++)
{
string LineStr = sr2.ReadLine();
if (LineStr == null)
{
break;
}
if (LineStr.StartsWith(StartText) && LineNumber == 0)
{
LineNumber = j;
LineStr = LineStr.Replace("0022", "");
sb.AppendLine(LineStr);
}
else
{
sb.AppendLine(LineStr);
}
}
FullFileText = sb.ToString();
LabSheetA1Sheet labSheetA1Sheet = csspLabSheetParser.ParseLabSheetA1(FullFileText);
Assert.AreEqual(string.Format(LabSheetParserRes.ErrorReadingFileAtLine_Error_, 1, string.Format(LabSheetParserRes._IsRequired, VarText)), labSheetA1Sheet.Error);
}
public void Setup(LanguageEnum LanguageRequest)
{
CultureInfo cultureInfo = new CultureInfo(LanguageRequest + "-CA");
csspLabSheetParser = new CSSPLabSheetParser();
FileInfo fiLabSheetTestFile = new FileInfo(@"C:\CSSP latest code\CSSPLabSheetParserDLL\CSSPLabSheetParserDLLTest\LabSheetTestFile.txt");
Assert.IsTrue(fiLabSheetTestFile.Exists);
StreamReader sr = fiLabSheetTestFile.OpenText();
string FullFileText = sr.ReadToEnd();
sr.Close();
LabSheetA1Sheet labSheetA1Sheet = csspLabSheetParser.ParseLabSheetA1(FullFileText);
Assert.AreEqual("", labSheetA1Sheet.Error);
csspFCFormWriter = new CSSPFCFormWriter(LanguageRequest, FullFileText);
}
public void LabSheetAndA1Sheet_Every_Property_Has_Get_Set_Test()
{
LabSheet val1 = new LabSheet();
labSheetAndA1Sheet.LabSheet = val1;
Assert.AreEqual(val1, labSheetAndA1Sheet.LabSheet);
LabSheetA1Sheet val2 = new LabSheetA1Sheet();
labSheetAndA1Sheet.LabSheetA1Sheet = val2;
Assert.AreEqual(val2, labSheetAndA1Sheet.LabSheetA1Sheet);
bool val3 = true;
labSheetAndA1Sheet.HasErrors = val3;
Assert.AreEqual(val3, labSheetAndA1Sheet.HasErrors);
IEnumerable <ValidationResult> val12 = new List <ValidationResult>()
{
new ValidationResult("First CSSPError Message")
}.AsEnumerable();
labSheetAndA1Sheet.ValidationResults = val12;
Assert.AreEqual(val12, labSheetAndA1Sheet.ValidationResults);
}
public void LabSheetService_ParseLabSheetA1_Good_Test()
{
Setup();
FileInfo fiLabSheetTestFile = new FileInfo(TestFileName);
Assert.IsTrue(fiLabSheetTestFile.Exists);
StreamReader sr = fiLabSheetTestFile.OpenText();
string FullFileText = sr.ReadToEnd();
sr.Close();
LabSheetA1Sheet labSheetA1Sheet = csspLabSheetParser.ParseLabSheetA1(FullFileText);
Assert.AreEqual("", labSheetA1Sheet.Error);
Assert.AreEqual(1, labSheetA1Sheet.Version);
Assert.AreEqual(SamplingPlanTypeEnum.Subsector, labSheetA1Sheet.SamplingPlanType);
Assert.AreEqual(SampleTypeEnum.Routine, labSheetA1Sheet.SampleType);
Assert.AreEqual(LabSheetTypeEnum.A1, labSheetA1Sheet.LabSheetType);
Assert.AreEqual("NB-01-020-002 (Charlo)", labSheetA1Sheet.SubsectorName);
Assert.AreEqual(560, labSheetA1Sheet.SubsectorTVItemID);
Assert.AreEqual("2016", labSheetA1Sheet.RunYear);
Assert.AreEqual("10", labSheetA1Sheet.RunMonth);
Assert.AreEqual("25", labSheetA1Sheet.RunDay);
Assert.AreEqual("HT / HF", labSheetA1Sheet.Tides);
Assert.AreEqual("KJ,KDF", labSheetA1Sheet.SampleCrewInitials);
Assert.AreEqual("true", labSheetA1Sheet.IncubationStartSameDay);
Assert.AreEqual(3, labSheetA1Sheet.WaterBathCount);
Assert.AreEqual("13:13", labSheetA1Sheet.IncubationBath1StartTime);
Assert.AreEqual("12:12", labSheetA1Sheet.IncubationBath2StartTime);
Assert.AreEqual("14:14", labSheetA1Sheet.IncubationBath3StartTime);
Assert.AreEqual("14:12", labSheetA1Sheet.IncubationBath1EndTime);
Assert.AreEqual("12:34", labSheetA1Sheet.IncubationBath2EndTime);
Assert.AreEqual("14:23", labSheetA1Sheet.IncubationBath3EndTime);
Assert.AreEqual("24:59", labSheetA1Sheet.IncubationBath1TimeCalculated);
Assert.AreEqual("24:22", labSheetA1Sheet.IncubationBath2TimeCalculated);
Assert.AreEqual("24:09", labSheetA1Sheet.IncubationBath3TimeCalculated);
Assert.AreEqual("H", labSheetA1Sheet.WaterBath1);
Assert.AreEqual("G", labSheetA1Sheet.WaterBath2);
Assert.AreEqual("F", labSheetA1Sheet.WaterBath3);
Assert.AreEqual("true", labSheetA1Sheet.TCHas2Coolers);
Assert.AreEqual("22", labSheetA1Sheet.TCField1);
Assert.AreEqual("23", labSheetA1Sheet.TCField2);
Assert.AreEqual("7", labSheetA1Sheet.TCLab1);
Assert.AreEqual("8", labSheetA1Sheet.TCLab2);
Assert.AreEqual("3.3", labSheetA1Sheet.TCFirst);
Assert.AreEqual("2.4", labSheetA1Sheet.TCAverage);
Assert.AreEqual("Something from lot", labSheetA1Sheet.ControlLot);
Assert.AreEqual("+", labSheetA1Sheet.Positive35);
Assert.AreEqual("+", labSheetA1Sheet.NonTarget35);
Assert.AreEqual("-", labSheetA1Sheet.Negative35);
Assert.AreEqual("+", labSheetA1Sheet.Bath1Positive44_5);
Assert.AreEqual("+", labSheetA1Sheet.Bath2Positive44_5);
Assert.AreEqual("+", labSheetA1Sheet.Bath3Positive44_5);
Assert.AreEqual("-", labSheetA1Sheet.Bath1NonTarget44_5);
Assert.AreEqual("-", labSheetA1Sheet.Bath2NonTarget44_5);
Assert.AreEqual("-", labSheetA1Sheet.Bath3NonTarget44_5);
Assert.AreEqual("-", labSheetA1Sheet.Bath1Negative44_5);
Assert.AreEqual("-", labSheetA1Sheet.Bath2Negative44_5);
Assert.AreEqual("-", labSheetA1Sheet.Bath3Negative44_5);
Assert.AreEqual("-", labSheetA1Sheet.Blank35);
Assert.AreEqual("-", labSheetA1Sheet.Bath1Blank44_5);
Assert.AreEqual("+", labSheetA1Sheet.Bath2Blank44_5);
Assert.AreEqual("-", labSheetA1Sheet.Bath3Blank44_5);
Assert.AreEqual("87", labSheetA1Sheet.Lot35);
Assert.AreEqual("85", labSheetA1Sheet.Lot44_5);
Assert.AreEqual("3.23045", labSheetA1Sheet.DailyDuplicateRLog);
Assert.AreEqual("0.6872", labSheetA1Sheet.DailyDuplicatePrecisionCriteria);
Assert.AreEqual("Unacceptable", labSheetA1Sheet.DailyDuplicateAcceptableOrUnacceptable);
Assert.AreEqual("1.23045", labSheetA1Sheet.IntertechDuplicateRLog);
Assert.AreEqual("0.093", labSheetA1Sheet.IntertechDuplicatePrecisionCriteria);
Assert.AreEqual("Unacceptable", labSheetA1Sheet.IntertechDuplicateAcceptableOrUnacceptable);
Assert.AreEqual("Unacceptable", labSheetA1Sheet.IntertechReadAcceptableOrUnacceptable);
Assert.AreEqual("This is the weather comment", labSheetA1Sheet.RunWeatherComment);
Assert.AreEqual("This is the Run comment", labSheetA1Sheet.RunComment);
Assert.AreEqual("87,45", labSheetA1Sheet.SampleBottleLotNumber);
Assert.AreEqual("KJ", labSheetA1Sheet.SalinitiesReadBy);
Assert.AreEqual("2016", labSheetA1Sheet.SalinitiesReadYear);
Assert.AreEqual("10", labSheetA1Sheet.SalinitiesReadMonth);
Assert.AreEqual("25", labSheetA1Sheet.SalinitiesReadDay);
Assert.AreEqual("JH", labSheetA1Sheet.ResultsReadBy);
Assert.AreEqual("2016", labSheetA1Sheet.ResultsReadYear);
Assert.AreEqual("10", labSheetA1Sheet.ResultsReadMonth);
Assert.AreEqual("26", labSheetA1Sheet.ResultsReadDay);
Assert.AreEqual("HG", labSheetA1Sheet.ResultsRecordedBy);
Assert.AreEqual("2016", labSheetA1Sheet.ResultsRecordedYear);
Assert.AreEqual("10", labSheetA1Sheet.ResultsRecordedMonth);
Assert.AreEqual("26", labSheetA1Sheet.ResultsRecordedDay);
Assert.AreEqual("0022", labSheetA1Sheet.LabSheetA1MeasurementList[0].Site);
Assert.AreEqual("13:13", labSheetA1Sheet.LabSheetA1MeasurementList[0].Time.Value.ToString("HH:mm"));
Assert.AreEqual(4, labSheetA1Sheet.LabSheetA1MeasurementList[0].Tube10);
Assert.AreEqual(2, labSheetA1Sheet.LabSheetA1MeasurementList[0].Tube1_0);
Assert.AreEqual(2, labSheetA1Sheet.LabSheetA1MeasurementList[0].Tube0_1);
Assert.AreEqual(1.0f, labSheetA1Sheet.LabSheetA1MeasurementList[0].Salinity);
Assert.AreEqual(2.0f, labSheetA1Sheet.LabSheetA1MeasurementList[0].Temperature);
Assert.AreEqual("ER", labSheetA1Sheet.LabSheetA1MeasurementList[0].ProcessedBy);
Assert.AreEqual(SampleTypeEnum.Routine, labSheetA1Sheet.LabSheetA1MeasurementList[0].SampleType);
Assert.AreEqual(32, labSheetA1Sheet.LabSheetA1MeasurementList[0].MPN);
Assert.AreEqual(7153, labSheetA1Sheet.LabSheetA1MeasurementList[0].TVItemID);
Assert.AreEqual("This is a comment for site 22", labSheetA1Sheet.LabSheetA1MeasurementList[0].SiteComment);
Assert.AreEqual(1, labSheetA1Sheet.LabSheetA1MeasurementList[1].MPN);
Assert.AreEqual(6, labSheetA1Sheet.LabSheetA1MeasurementList[2].MPN);
Assert.AreEqual(SampleTypeEnum.Routine, labSheetA1Sheet.LabSheetA1MeasurementList[3].SampleType);
Assert.AreEqual(-999, labSheetA1Sheet.LabSheetA1MeasurementList[3].MPN);
Assert.AreEqual(SampleTypeEnum.DailyDuplicate, labSheetA1Sheet.LabSheetA1MeasurementList[4].SampleType);
Assert.AreEqual(SampleTypeEnum.IntertechDuplicate, labSheetA1Sheet.LabSheetA1MeasurementList[5].SampleType);
Assert.AreEqual(SampleTypeEnum.IntertechRead, labSheetA1Sheet.LabSheetA1MeasurementList[6].SampleType);
}
/// <summary>
/// Validate function for all LabSheetA1SheetService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
LabSheetA1Sheet labSheetA1Sheet = validationContext.ObjectInstance as LabSheetA1Sheet;
labSheetA1Sheet.HasErrors = false;
if (labSheetA1Sheet.Version < 1 || labSheetA1Sheet.Version > 100)
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Version", "1", "100"), new[] { "Version" }));
}
retStr = enums.EnumTypeOK(typeof(SamplingPlanTypeEnum), (int?)labSheetA1Sheet.SamplingPlanType);
if (!string.IsNullOrWhiteSpace(retStr))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SamplingPlanType"), new[] { "SamplingPlanType" }));
}
retStr = enums.EnumTypeOK(typeof(SampleTypeEnum), (int?)labSheetA1Sheet.SampleType);
if (!string.IsNullOrWhiteSpace(retStr))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleType"), new[] { "SampleType" }));
}
retStr = enums.EnumTypeOK(typeof(LabSheetTypeEnum), (int?)labSheetA1Sheet.LabSheetType);
if (!string.IsNullOrWhiteSpace(retStr))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LabSheetType"), new[] { "LabSheetType" }));
}
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.SubsectorName))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SubsectorName"), new[] { "SubsectorName" }));
}
//SubsectorName has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.SubsectorLocation))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SubsectorLocation"), new[] { "SubsectorLocation" }));
}
//SubsectorLocation has no StringLength Attribute
//SubsectorTVItemID has no Range Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.RunYear))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "RunYear"), new[] { "RunYear" }));
}
//RunYear has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.RunMonth))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "RunMonth"), new[] { "RunMonth" }));
}
//RunMonth has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.RunDay))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "RunDay"), new[] { "RunDay" }));
}
//RunDay has no StringLength Attribute
//RunNumber has no Range Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Tides))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Tides"), new[] { "Tides" }));
}
//Tides has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.SampleCrewInitials))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleCrewInitials"), new[] { "SampleCrewInitials" }));
}
//SampleCrewInitials has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationStartSameDay))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationStartSameDay"), new[] { "IncubationStartSameDay" }));
}
//IncubationStartSameDay has no StringLength Attribute
//WaterBathCount has no Range Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath1StartTime))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath1StartTime"), new[] { "IncubationBath1StartTime" }));
}
//IncubationBath1StartTime has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath2StartTime))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath2StartTime"), new[] { "IncubationBath2StartTime" }));
}
//IncubationBath2StartTime has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath3StartTime))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath3StartTime"), new[] { "IncubationBath3StartTime" }));
}
//IncubationBath3StartTime has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath1EndTime))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath1EndTime"), new[] { "IncubationBath1EndTime" }));
}
//IncubationBath1EndTime has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath2EndTime))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath2EndTime"), new[] { "IncubationBath2EndTime" }));
}
//IncubationBath2EndTime has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath3EndTime))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath3EndTime"), new[] { "IncubationBath3EndTime" }));
}
//IncubationBath3EndTime has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath1TimeCalculated))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath1TimeCalculated"), new[] { "IncubationBath1TimeCalculated" }));
}
//IncubationBath1TimeCalculated has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath2TimeCalculated))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath2TimeCalculated"), new[] { "IncubationBath2TimeCalculated" }));
}
//IncubationBath2TimeCalculated has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IncubationBath3TimeCalculated))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IncubationBath3TimeCalculated"), new[] { "IncubationBath3TimeCalculated" }));
}
//IncubationBath3TimeCalculated has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.WaterBath1))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "WaterBath1"), new[] { "WaterBath1" }));
}
//WaterBath1 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.WaterBath2))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "WaterBath2"), new[] { "WaterBath2" }));
}
//WaterBath2 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.WaterBath3))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "WaterBath3"), new[] { "WaterBath3" }));
}
//WaterBath3 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.TCField1))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TCField1"), new[] { "TCField1" }));
}
//TCField1 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.TCLab1))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TCLab1"), new[] { "TCLab1" }));
}
//TCLab1 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.TCHas2Coolers))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TCHas2Coolers"), new[] { "TCHas2Coolers" }));
}
//TCHas2Coolers has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.TCField2))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TCField2"), new[] { "TCField2" }));
}
//TCField2 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.TCLab2))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TCLab2"), new[] { "TCLab2" }));
}
//TCLab2 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.TCFirst))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TCFirst"), new[] { "TCFirst" }));
}
//TCFirst has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.TCAverage))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TCAverage"), new[] { "TCAverage" }));
}
//TCAverage has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ControlLot))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ControlLot"), new[] { "ControlLot" }));
}
//ControlLot has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Positive35))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Positive35"), new[] { "Positive35" }));
}
//Positive35 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.NonTarget35))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "NonTarget35"), new[] { "NonTarget35" }));
}
//NonTarget35 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Negative35))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Negative35"), new[] { "Negative35" }));
}
//Negative35 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath1Positive44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath1Positive44_5"), new[] { "Bath1Positive44_5" }));
}
//Bath1Positive44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath2Positive44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath2Positive44_5"), new[] { "Bath2Positive44_5" }));
}
//Bath2Positive44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath3Positive44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath3Positive44_5"), new[] { "Bath3Positive44_5" }));
}
//Bath3Positive44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath1NonTarget44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath1NonTarget44_5"), new[] { "Bath1NonTarget44_5" }));
}
//Bath1NonTarget44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath2NonTarget44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath2NonTarget44_5"), new[] { "Bath2NonTarget44_5" }));
}
//Bath2NonTarget44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath3NonTarget44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath3NonTarget44_5"), new[] { "Bath3NonTarget44_5" }));
}
//Bath3NonTarget44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath1Negative44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath1Negative44_5"), new[] { "Bath1Negative44_5" }));
}
//Bath1Negative44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath2Negative44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath2Negative44_5"), new[] { "Bath2Negative44_5" }));
}
//Bath2Negative44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath3Negative44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath3Negative44_5"), new[] { "Bath3Negative44_5" }));
}
//Bath3Negative44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Blank35))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Blank35"), new[] { "Blank35" }));
}
//Blank35 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath1Blank44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath1Blank44_5"), new[] { "Bath1Blank44_5" }));
}
//Bath1Blank44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath2Blank44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath2Blank44_5"), new[] { "Bath2Blank44_5" }));
}
//Bath2Blank44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Bath3Blank44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Bath3Blank44_5"), new[] { "Bath3Blank44_5" }));
}
//Bath3Blank44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Lot35))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Lot35"), new[] { "Lot35" }));
}
//Lot35 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Lot44_5))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Lot44_5"), new[] { "Lot44_5" }));
}
//Lot44_5 has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.RunComment))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "RunComment"), new[] { "RunComment" }));
}
//RunComment has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.RunWeatherComment))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "RunWeatherComment"), new[] { "RunWeatherComment" }));
}
//RunWeatherComment has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.SampleBottleLotNumber))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleBottleLotNumber"), new[] { "SampleBottleLotNumber" }));
}
//SampleBottleLotNumber has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.SalinitiesReadBy))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SalinitiesReadBy"), new[] { "SalinitiesReadBy" }));
}
//SalinitiesReadBy has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.SalinitiesReadYear))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SalinitiesReadYear"), new[] { "SalinitiesReadYear" }));
}
//SalinitiesReadYear has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.SalinitiesReadMonth))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SalinitiesReadMonth"), new[] { "SalinitiesReadMonth" }));
}
//SalinitiesReadMonth has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.SalinitiesReadDay))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SalinitiesReadDay"), new[] { "SalinitiesReadDay" }));
}
//SalinitiesReadDay has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ResultsReadBy))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ResultsReadBy"), new[] { "ResultsReadBy" }));
}
//ResultsReadBy has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ResultsReadYear))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ResultsReadYear"), new[] { "ResultsReadYear" }));
}
//ResultsReadYear has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ResultsReadMonth))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ResultsReadMonth"), new[] { "ResultsReadMonth" }));
}
//ResultsReadMonth has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ResultsReadDay))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ResultsReadDay"), new[] { "ResultsReadDay" }));
}
//ResultsReadDay has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ResultsRecordedBy))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ResultsRecordedBy"), new[] { "ResultsRecordedBy" }));
}
//ResultsRecordedBy has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ResultsRecordedYear))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ResultsRecordedYear"), new[] { "ResultsRecordedYear" }));
}
//ResultsRecordedYear has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ResultsRecordedMonth))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ResultsRecordedMonth"), new[] { "ResultsRecordedMonth" }));
}
//ResultsRecordedMonth has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ResultsRecordedDay))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ResultsRecordedDay"), new[] { "ResultsRecordedDay" }));
}
//ResultsRecordedDay has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.DailyDuplicateRLog))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DailyDuplicateRLog"), new[] { "DailyDuplicateRLog" }));
}
//DailyDuplicateRLog has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.DailyDuplicatePrecisionCriteria))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DailyDuplicatePrecisionCriteria"), new[] { "DailyDuplicatePrecisionCriteria" }));
}
//DailyDuplicatePrecisionCriteria has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.DailyDuplicateAcceptableOrUnacceptable))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DailyDuplicateAcceptableOrUnacceptable"), new[] { "DailyDuplicateAcceptableOrUnacceptable" }));
}
//DailyDuplicateAcceptableOrUnacceptable has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IntertechDuplicateRLog))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IntertechDuplicateRLog"), new[] { "IntertechDuplicateRLog" }));
}
//IntertechDuplicateRLog has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IntertechDuplicatePrecisionCriteria))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IntertechDuplicatePrecisionCriteria"), new[] { "IntertechDuplicatePrecisionCriteria" }));
}
//IntertechDuplicatePrecisionCriteria has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IntertechDuplicateAcceptableOrUnacceptable))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IntertechDuplicateAcceptableOrUnacceptable"), new[] { "IntertechDuplicateAcceptableOrUnacceptable" }));
}
//IntertechDuplicateAcceptableOrUnacceptable has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.IntertechReadAcceptableOrUnacceptable))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "IntertechReadAcceptableOrUnacceptable"), new[] { "IntertechReadAcceptableOrUnacceptable" }));
}
//IntertechReadAcceptableOrUnacceptable has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ApprovalYear))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ApprovalYear"), new[] { "ApprovalYear" }));
}
//ApprovalYear has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ApprovalMonth))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ApprovalMonth"), new[] { "ApprovalMonth" }));
}
//ApprovalMonth has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ApprovalDay))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ApprovalDay"), new[] { "ApprovalDay" }));
}
//ApprovalDay has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.ApprovedBySupervisorInitials))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ApprovedBySupervisorInitials"), new[] { "ApprovedBySupervisorInitials" }));
}
//ApprovedBySupervisorInitials has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.BackupDirectory))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "BackupDirectory"), new[] { "BackupDirectory" }));
}
//BackupDirectory has no StringLength Attribute
if (string.IsNullOrWhiteSpace(labSheetA1Sheet.Log))
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Log"), new[] { "Log" }));
}
//Log has no StringLength Attribute
if (!string.IsNullOrWhiteSpace(labSheetA1Sheet.SamplingPlanTypeText) && labSheetA1Sheet.SamplingPlanTypeText.Length > 100)
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SamplingPlanTypeText", "100"), new[] { "SamplingPlanTypeText" }));
}
if (!string.IsNullOrWhiteSpace(labSheetA1Sheet.SampleTypeText) && labSheetA1Sheet.SampleTypeText.Length > 100)
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SampleTypeText", "100"), new[] { "SampleTypeText" }));
}
if (!string.IsNullOrWhiteSpace(labSheetA1Sheet.LabSheetTypeText) && labSheetA1Sheet.LabSheetTypeText.Length > 100)
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "LabSheetTypeText", "100"), new[] { "LabSheetTypeText" }));
}
//CSSPError: Type not implemented [LabSheetA1MeasurementList] of type [List`1]
//CSSPError: Type not implemented [LabSheetA1MeasurementList] of type [LabSheetA1Measurement]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
labSheetA1Sheet.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
public LabSheetA1SheetTest()
{
labSheetA1Sheet = new LabSheetA1Sheet();
}
private LabSheetA1Sheet GetFilledRandomLabSheetA1Sheet(string OmitPropName)
{
LabSheetA1Sheet labSheetA1Sheet = new LabSheetA1Sheet();
if (OmitPropName != "Version")
{
labSheetA1Sheet.Version = GetRandomInt(1, 100);
}
if (OmitPropName != "SamplingPlanType")
{
labSheetA1Sheet.SamplingPlanType = (SamplingPlanTypeEnum)GetRandomEnumType(typeof(SamplingPlanTypeEnum));
}
if (OmitPropName != "SampleType")
{
labSheetA1Sheet.SampleType = (SampleTypeEnum)GetRandomEnumType(typeof(SampleTypeEnum));
}
if (OmitPropName != "LabSheetType")
{
labSheetA1Sheet.LabSheetType = (LabSheetTypeEnum)GetRandomEnumType(typeof(LabSheetTypeEnum));
}
if (OmitPropName != "SubsectorName")
{
labSheetA1Sheet.SubsectorName = GetRandomString("", 20);
}
if (OmitPropName != "SubsectorLocation")
{
labSheetA1Sheet.SubsectorLocation = GetRandomString("", 20);
}
// should implement a Range for the property SubsectorTVItemID and type LabSheetA1Sheet
if (OmitPropName != "RunYear")
{
labSheetA1Sheet.RunYear = GetRandomString("", 20);
}
if (OmitPropName != "RunMonth")
{
labSheetA1Sheet.RunMonth = GetRandomString("", 20);
}
if (OmitPropName != "RunDay")
{
labSheetA1Sheet.RunDay = GetRandomString("", 20);
}
// should implement a Range for the property RunNumber and type LabSheetA1Sheet
if (OmitPropName != "Tides")
{
labSheetA1Sheet.Tides = GetRandomString("", 20);
}
if (OmitPropName != "SampleCrewInitials")
{
labSheetA1Sheet.SampleCrewInitials = GetRandomString("", 20);
}
if (OmitPropName != "IncubationStartSameDay")
{
labSheetA1Sheet.IncubationStartSameDay = GetRandomString("", 20);
}
// should implement a Range for the property WaterBathCount and type LabSheetA1Sheet
if (OmitPropName != "IncubationBath1StartTime")
{
labSheetA1Sheet.IncubationBath1StartTime = GetRandomString("", 20);
}
if (OmitPropName != "IncubationBath2StartTime")
{
labSheetA1Sheet.IncubationBath2StartTime = GetRandomString("", 20);
}
if (OmitPropName != "IncubationBath3StartTime")
{
labSheetA1Sheet.IncubationBath3StartTime = GetRandomString("", 20);
}
if (OmitPropName != "IncubationBath1EndTime")
{
labSheetA1Sheet.IncubationBath1EndTime = GetRandomString("", 20);
}
if (OmitPropName != "IncubationBath2EndTime")
{
labSheetA1Sheet.IncubationBath2EndTime = GetRandomString("", 20);
}
if (OmitPropName != "IncubationBath3EndTime")
{
labSheetA1Sheet.IncubationBath3EndTime = GetRandomString("", 20);
}
if (OmitPropName != "IncubationBath1TimeCalculated")
{
labSheetA1Sheet.IncubationBath1TimeCalculated = GetRandomString("", 20);
}
if (OmitPropName != "IncubationBath2TimeCalculated")
{
labSheetA1Sheet.IncubationBath2TimeCalculated = GetRandomString("", 20);
}
if (OmitPropName != "IncubationBath3TimeCalculated")
{
labSheetA1Sheet.IncubationBath3TimeCalculated = GetRandomString("", 20);
}
if (OmitPropName != "WaterBath1")
{
labSheetA1Sheet.WaterBath1 = GetRandomString("", 20);
}
if (OmitPropName != "WaterBath2")
{
labSheetA1Sheet.WaterBath2 = GetRandomString("", 20);
}
if (OmitPropName != "WaterBath3")
{
labSheetA1Sheet.WaterBath3 = GetRandomString("", 20);
}
if (OmitPropName != "TCField1")
{
labSheetA1Sheet.TCField1 = GetRandomString("", 20);
}
if (OmitPropName != "TCLab1")
{
labSheetA1Sheet.TCLab1 = GetRandomString("", 20);
}
if (OmitPropName != "TCHas2Coolers")
{
labSheetA1Sheet.TCHas2Coolers = GetRandomString("", 20);
}
if (OmitPropName != "TCField2")
{
labSheetA1Sheet.TCField2 = GetRandomString("", 20);
}
if (OmitPropName != "TCLab2")
{
labSheetA1Sheet.TCLab2 = GetRandomString("", 20);
}
if (OmitPropName != "TCFirst")
{
labSheetA1Sheet.TCFirst = GetRandomString("", 20);
}
if (OmitPropName != "TCAverage")
{
labSheetA1Sheet.TCAverage = GetRandomString("", 20);
}
if (OmitPropName != "ControlLot")
{
labSheetA1Sheet.ControlLot = GetRandomString("", 20);
}
if (OmitPropName != "Positive35")
{
labSheetA1Sheet.Positive35 = GetRandomString("", 20);
}
if (OmitPropName != "NonTarget35")
{
labSheetA1Sheet.NonTarget35 = GetRandomString("", 20);
}
if (OmitPropName != "Negative35")
{
labSheetA1Sheet.Negative35 = GetRandomString("", 20);
}
if (OmitPropName != "Bath1Positive44_5")
{
labSheetA1Sheet.Bath1Positive44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath2Positive44_5")
{
labSheetA1Sheet.Bath2Positive44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath3Positive44_5")
{
labSheetA1Sheet.Bath3Positive44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath1NonTarget44_5")
{
labSheetA1Sheet.Bath1NonTarget44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath2NonTarget44_5")
{
labSheetA1Sheet.Bath2NonTarget44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath3NonTarget44_5")
{
labSheetA1Sheet.Bath3NonTarget44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath1Negative44_5")
{
labSheetA1Sheet.Bath1Negative44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath2Negative44_5")
{
labSheetA1Sheet.Bath2Negative44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath3Negative44_5")
{
labSheetA1Sheet.Bath3Negative44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Blank35")
{
labSheetA1Sheet.Blank35 = GetRandomString("", 20);
}
if (OmitPropName != "Bath1Blank44_5")
{
labSheetA1Sheet.Bath1Blank44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath2Blank44_5")
{
labSheetA1Sheet.Bath2Blank44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Bath3Blank44_5")
{
labSheetA1Sheet.Bath3Blank44_5 = GetRandomString("", 20);
}
if (OmitPropName != "Lot35")
{
labSheetA1Sheet.Lot35 = GetRandomString("", 20);
}
if (OmitPropName != "Lot44_5")
{
labSheetA1Sheet.Lot44_5 = GetRandomString("", 20);
}
if (OmitPropName != "RunComment")
{
labSheetA1Sheet.RunComment = GetRandomString("", 20);
}
if (OmitPropName != "RunWeatherComment")
{
labSheetA1Sheet.RunWeatherComment = GetRandomString("", 20);
}
if (OmitPropName != "SampleBottleLotNumber")
{
labSheetA1Sheet.SampleBottleLotNumber = GetRandomString("", 20);
}
if (OmitPropName != "SalinitiesReadBy")
{
labSheetA1Sheet.SalinitiesReadBy = GetRandomString("", 20);
}
if (OmitPropName != "SalinitiesReadYear")
{
labSheetA1Sheet.SalinitiesReadYear = GetRandomString("", 20);
}
if (OmitPropName != "SalinitiesReadMonth")
{
labSheetA1Sheet.SalinitiesReadMonth = GetRandomString("", 20);
}
if (OmitPropName != "SalinitiesReadDay")
{
labSheetA1Sheet.SalinitiesReadDay = GetRandomString("", 20);
}
if (OmitPropName != "ResultsReadBy")
{
labSheetA1Sheet.ResultsReadBy = GetRandomString("", 20);
}
if (OmitPropName != "ResultsReadYear")
{
labSheetA1Sheet.ResultsReadYear = GetRandomString("", 20);
}
if (OmitPropName != "ResultsReadMonth")
{
labSheetA1Sheet.ResultsReadMonth = GetRandomString("", 20);
}
if (OmitPropName != "ResultsReadDay")
{
labSheetA1Sheet.ResultsReadDay = GetRandomString("", 20);
}
if (OmitPropName != "ResultsRecordedBy")
{
labSheetA1Sheet.ResultsRecordedBy = GetRandomString("", 20);
}
if (OmitPropName != "ResultsRecordedYear")
{
labSheetA1Sheet.ResultsRecordedYear = GetRandomString("", 20);
}
if (OmitPropName != "ResultsRecordedMonth")
{
labSheetA1Sheet.ResultsRecordedMonth = GetRandomString("", 20);
}
if (OmitPropName != "ResultsRecordedDay")
{
labSheetA1Sheet.ResultsRecordedDay = GetRandomString("", 20);
}
if (OmitPropName != "DailyDuplicateRLog")
{
labSheetA1Sheet.DailyDuplicateRLog = GetRandomString("", 20);
}
if (OmitPropName != "DailyDuplicatePrecisionCriteria")
{
labSheetA1Sheet.DailyDuplicatePrecisionCriteria = GetRandomString("", 20);
}
if (OmitPropName != "DailyDuplicateAcceptableOrUnacceptable")
{
labSheetA1Sheet.DailyDuplicateAcceptableOrUnacceptable = GetRandomString("", 20);
}
if (OmitPropName != "IntertechDuplicateRLog")
{
labSheetA1Sheet.IntertechDuplicateRLog = GetRandomString("", 20);
}
if (OmitPropName != "IntertechDuplicatePrecisionCriteria")
{
labSheetA1Sheet.IntertechDuplicatePrecisionCriteria = GetRandomString("", 20);
}
if (OmitPropName != "IntertechDuplicateAcceptableOrUnacceptable")
{
labSheetA1Sheet.IntertechDuplicateAcceptableOrUnacceptable = GetRandomString("", 20);
}
if (OmitPropName != "IntertechReadAcceptableOrUnacceptable")
{
labSheetA1Sheet.IntertechReadAcceptableOrUnacceptable = GetRandomString("", 20);
}
if (OmitPropName != "ApprovalYear")
{
labSheetA1Sheet.ApprovalYear = GetRandomString("", 20);
}
if (OmitPropName != "ApprovalMonth")
{
labSheetA1Sheet.ApprovalMonth = GetRandomString("", 20);
}
if (OmitPropName != "ApprovalDay")
{
labSheetA1Sheet.ApprovalDay = GetRandomString("", 20);
}
if (OmitPropName != "ApprovedBySupervisorInitials")
{
labSheetA1Sheet.ApprovedBySupervisorInitials = GetRandomString("", 20);
}
if (OmitPropName != "IncludeLaboratoryQAQC")
{
labSheetA1Sheet.IncludeLaboratoryQAQC = true;
}
if (OmitPropName != "BackupDirectory")
{
labSheetA1Sheet.BackupDirectory = GetRandomString("", 20);
}
if (OmitPropName != "Log")
{
labSheetA1Sheet.Log = GetRandomString("", 20);
}
if (OmitPropName != "SamplingPlanTypeText")
{
labSheetA1Sheet.SamplingPlanTypeText = GetRandomString("", 5);
}
if (OmitPropName != "SampleTypeText")
{
labSheetA1Sheet.SampleTypeText = GetRandomString("", 5);
}
if (OmitPropName != "LabSheetTypeText")
{
labSheetA1Sheet.LabSheetTypeText = GetRandomString("", 5);
}
//CSSPError: property [LabSheetA1MeasurementList] and type [LabSheetA1Sheet] is not implemented
return(labSheetA1Sheet);
}
public LabSheetA1Sheet ParseLabSheetA1(string LabSheetFileContent)
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-CA");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-CA");
StringBuilder sbPrevCommands = new StringBuilder();
LabSheetA1Sheet labSheetA1Sheet = new LabSheetA1Sheet()
{
Error = ""
};
List <string> VarArr = new List <string>();
StringBuilder sbFileContent = new StringBuilder(LabSheetFileContent);
// Verison
string retStr = GetVariableValueStr("Version", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.Version = int.Parse(retStr);
// Sampling Plan Type
retStr = GetVariableValueStr("Sampling Plan Type", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.SamplingPlanType = SamplingPlanTypeEnum.Error;
for (int i = 1, count = Enum.GetNames(typeof(SamplingPlanTypeEnum)).Count(); i < count; i++)
{
if (((SamplingPlanTypeEnum)i).ToString() == retStr)
{
labSheetA1Sheet.SamplingPlanType = (SamplingPlanTypeEnum)i;
break;
}
}
// Sample Type
retStr = GetVariableValueStr("Sample Type", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.SampleType = SampleTypeEnum.Error;
for (int i = 101, count = Enum.GetNames(typeof(SampleTypeEnum)).Count() + 100; i < count; i++)
{
if (((SampleTypeEnum)i).ToString() == retStr)
{
labSheetA1Sheet.SampleType = (SampleTypeEnum)i;
break;
}
}
// Lab Sheet Type
retStr = GetVariableValueStr("Lab Sheet Type", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.LabSheetType = LabSheetTypeEnum.Error;
for (int i = 1, count = Enum.GetNames(typeof(LabSheetTypeEnum)).Count(); i < count; i++)
{
if (((LabSheetTypeEnum)i).ToString() == retStr)
{
labSheetA1Sheet.LabSheetType = (LabSheetTypeEnum)i;
break;
}
}
// Subsector
retStr = GetVariableValueStr("Subsector", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
if (VarArr.Count != 2)
{
labSheetA1Sheet.Error = "ERR: Subsector variable should have 2 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.SubsectorName = VarArr[0].Trim();
labSheetA1Sheet.SubsectorTVItemID = int.Parse(VarArr[1].Trim());
// Date
retStr = GetVariableValueStr("Date", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Date variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.RunYear = VarArr[0].Trim();
labSheetA1Sheet.RunMonth = VarArr[1].Trim();
labSheetA1Sheet.RunDay = VarArr[2].Trim();
// Run
retStr = GetVariableValueStr("Run", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
if (VarArr.Count != 1)
{
labSheetA1Sheet.Error = "ERR: Run variable should have 1 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.RunNumber = int.Parse(VarArr[0].Trim());
// Tides
retStr = GetVariableValueStr("Tides", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.Tides = retStr;
// Include Laboratory QA/QC
retStr = GetVariableValueStr("IncludeLaboratoryQAQC", sbFileContent);
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 1)
{
labSheetA1Sheet.Error = "ERR: IncludeLaboratoryQAQC should have 1 values";
return(labSheetA1Sheet);
}
else
{
if (VarArr[0].ToLower().StartsWith("t"))
{
labSheetA1Sheet.IncludeLaboratoryQAQC = true;
}
else
{
labSheetA1Sheet.IncludeLaboratoryQAQC = false;
}
}
if (labSheetA1Sheet.IncludeLaboratoryQAQC)
{
// Sample Crew Initials
retStr = GetVariableValueStr("Sample Crew Initials", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.SampleCrewInitials = retStr;
// Incubation Start Same Day
retStr = GetVariableValueStr("Incubation Start Same Day", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.IncubationStartSameDay = retStr;
// Incubation Start Time
retStr = GetVariableValueStr("Incubation Start Time", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Incubation Start Time variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.IncubationBath1StartTime = VarArr[0].Trim();
labSheetA1Sheet.IncubationBath2StartTime = VarArr[1].Trim();
labSheetA1Sheet.IncubationBath3StartTime = VarArr[2].Trim();
// Incubation End Time
retStr = GetVariableValueStr("Incubation End Time", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Incubation End Time variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.IncubationBath1EndTime = VarArr[0].Trim();
labSheetA1Sheet.IncubationBath2EndTime = VarArr[1].Trim();
labSheetA1Sheet.IncubationBath3EndTime = VarArr[2].Trim();
// Incubation Time Calculated
retStr = GetVariableValueStr("Incubation Time Calculated", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Incubation Time Calculated variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.IncubationBath1TimeCalculated = VarArr[0].Trim();
labSheetA1Sheet.IncubationBath2TimeCalculated = VarArr[1].Trim();
labSheetA1Sheet.IncubationBath3TimeCalculated = VarArr[2].Trim();
// Water Bath Count
retStr = GetVariableValueStr("Water Bath Count", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.WaterBathCount = int.Parse(retStr);
// Water Bath
retStr = GetVariableValueStr("Water Bath", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Water Bath variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.WaterBath1 = VarArr[0].Trim();
labSheetA1Sheet.WaterBath2 = VarArr[1].Trim();
labSheetA1Sheet.WaterBath3 = VarArr[2].Trim();
// TC Has 2 Coolers
retStr = GetVariableValueStr("TC Has 2 Coolers", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.TCHas2Coolers = retStr;
// TC Field
retStr = GetVariableValueStr("TC Field", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 2)
{
labSheetA1Sheet.Error = "ERR: TC Field variable should have 2 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.TCField1 = VarArr[0].Trim();
labSheetA1Sheet.TCField2 = VarArr[1].Trim();
// TC Lab
retStr = GetVariableValueStr("TC Lab", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 2)
{
labSheetA1Sheet.Error = "ERR: TC Lab variable should have 2 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.TCLab1 = VarArr[0].Trim();
labSheetA1Sheet.TCLab2 = VarArr[1].Trim();
// TC First
retStr = GetVariableValueStr("TC First", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.TCFirst = retStr;
// TC Average
retStr = GetVariableValueStr("TC Average", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.TCAverage = retStr;
// Control Lot
retStr = GetVariableValueStr("Control Lot", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.ControlLot = retStr;
// Positive 35
retStr = GetVariableValueStr("Positive 35", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.Positive35 = retStr;
// Non Target 35
retStr = GetVariableValueStr("Non Target 35", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.NonTarget35 = retStr;
// Negative 35
retStr = GetVariableValueStr("Negative 35", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.Negative35 = retStr;
// Positive 44.5
retStr = GetVariableValueStr("Positive 44.5", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Positive 44.5 variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.Bath1Positive44_5 = VarArr[0].Trim();
labSheetA1Sheet.Bath2Positive44_5 = VarArr[1].Trim();
labSheetA1Sheet.Bath3Positive44_5 = VarArr[2].Trim();
// Non Target 44.5
retStr = GetVariableValueStr("Non Target 44.5", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Non Target 44.5 variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.Bath1NonTarget44_5 = VarArr[0].Trim();
labSheetA1Sheet.Bath2NonTarget44_5 = VarArr[1].Trim();
labSheetA1Sheet.Bath3NonTarget44_5 = VarArr[2].Trim();
// Negative 44.5
retStr = GetVariableValueStr("Negative 44.5", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Negative 44.5 variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.Bath1Negative44_5 = VarArr[0].Trim();
labSheetA1Sheet.Bath2Negative44_5 = VarArr[1].Trim();
labSheetA1Sheet.Bath3Negative44_5 = VarArr[2].Trim();
// Blank 35
retStr = GetVariableValueStr("Blank 35", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.Blank35 = retStr;
// Blank 44.5
retStr = GetVariableValueStr("Blank 44.5", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Blank 44.5 variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.Bath1Blank44_5 = VarArr[0].Trim();
labSheetA1Sheet.Bath2Blank44_5 = VarArr[1].Trim();
labSheetA1Sheet.Bath3Blank44_5 = VarArr[2].Trim();
// Lot 35
retStr = GetVariableValueStr("Lot 35", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.Lot35 = retStr;
// Lot 44.5
retStr = GetVariableValueStr("Lot 44.5", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
}
labSheetA1Sheet.Lot44_5 = retStr;
// Daily Duplicate
retStr = GetVariableValueStr("Daily Duplicate", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Daily Duplicate variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.DailyDuplicateRLog = VarArr[0].Trim();
labSheetA1Sheet.DailyDuplicatePrecisionCriteria = VarArr[1].Trim();
labSheetA1Sheet.DailyDuplicateAcceptableOrUnacceptable = VarArr[2].Trim();
// Intertech Duplicate
retStr = GetVariableValueStr("Intertech Duplicate", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Intertech Duplicate variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.IntertechDuplicateRLog = VarArr[0].Trim();
labSheetA1Sheet.IntertechDuplicatePrecisionCriteria = VarArr[1].Trim();
labSheetA1Sheet.IntertechDuplicateAcceptableOrUnacceptable = VarArr[2].Trim();
// Intertech Read
retStr = GetVariableValueStr("Intertech Read", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.IntertechReadAcceptableOrUnacceptable = retStr;
// Sample Bottle Lot Number
retStr = GetVariableValueStr("Sample Bottle Lot Number", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.SampleBottleLotNumber = retStr;
// Salinities
retStr = GetVariableValueStr("Salinities", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 4)
{
labSheetA1Sheet.Error = "ERR: Salinities variable should have 4 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.SalinitiesReadBy = VarArr[0].Trim();
labSheetA1Sheet.SalinitiesReadYear = VarArr[1].Trim();
labSheetA1Sheet.SalinitiesReadMonth = VarArr[2].Trim();
labSheetA1Sheet.SalinitiesReadDay = VarArr[3].Trim();
// Results
retStr = GetVariableValueStr("Results", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 4)
{
labSheetA1Sheet.Error = "ERR: Results variable should have 4 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.ResultsReadBy = VarArr[0].Trim();
labSheetA1Sheet.ResultsReadYear = VarArr[1].Trim();
labSheetA1Sheet.ResultsReadMonth = VarArr[2].Trim();
labSheetA1Sheet.ResultsReadDay = VarArr[3].Trim();
// Recorded
retStr = GetVariableValueStr("Recorded", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 4)
{
labSheetA1Sheet.Error = "ERR: Recorded variable should have 4 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.ResultsRecordedBy = VarArr[0].Trim();
labSheetA1Sheet.ResultsRecordedYear = VarArr[1].Trim();
labSheetA1Sheet.ResultsRecordedMonth = VarArr[2].Trim();
labSheetA1Sheet.ResultsRecordedDay = VarArr[3].Trim();
// Approved By Supervisor Initials
retStr = GetVariableValueStr("Approved By Supervisor Initials", sbFileContent);
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 1)
{
labSheetA1Sheet.Error = "ERR: Approved By Supervisor Initials should have 1 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.ApprovedBySupervisorInitials = VarArr[0].Trim();
// Approval Date
retStr = GetVariableValueStr("Approval Date", sbFileContent);
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Approval Date should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.ApprovalYear = VarArr[0].Trim();
labSheetA1Sheet.ApprovalMonth = VarArr[1].Trim();
labSheetA1Sheet.ApprovalDay = VarArr[2].Trim();
}
else
{
if (labSheetA1Sheet.Version == 2)
{
// Daily Duplicate
retStr = GetVariableValueStr("Daily Duplicate", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Daily Duplicate variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.DailyDuplicateRLog = VarArr[0].Trim();
labSheetA1Sheet.DailyDuplicatePrecisionCriteria = VarArr[1].Trim();
labSheetA1Sheet.DailyDuplicateAcceptableOrUnacceptable = VarArr[2].Trim();
// Intertech Duplicate
retStr = GetVariableValueStr("Intertech Duplicate", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
VarArr = retStr.Split("|".ToCharArray(), StringSplitOptions.None).ToList();
if (VarArr.Count != 3)
{
labSheetA1Sheet.Error = "ERR: Intertech Duplicate variable should have 3 values";
return(labSheetA1Sheet);
}
labSheetA1Sheet.IntertechDuplicateRLog = VarArr[0].Trim();
labSheetA1Sheet.IntertechDuplicatePrecisionCriteria = VarArr[1].Trim();
labSheetA1Sheet.IntertechDuplicateAcceptableOrUnacceptable = VarArr[2].Trim();
// Intertech Read
retStr = GetVariableValueStr("Intertech Read", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.IntertechReadAcceptableOrUnacceptable = retStr;
}
}
// Run Weather Comment
retStr = GetVariableValueStr("Run Weather Comment", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.RunWeatherComment = retStr;
// Run Comment
retStr = GetVariableValueStr("Run Comment", sbFileContent);
if (retStr.StartsWith("ERR:"))
{
labSheetA1Sheet.Error = retStr;
return(labSheetA1Sheet);
}
labSheetA1Sheet.RunComment = retStr;
using (StringReader sr = new StringReader(LabSheetFileContent))
{
int LineNumber = 0;
string OldFirstObj = "";
string lineStr = "";
while ((lineStr = sr.ReadLine()) != null)
{
if (!(lineStr.StartsWith("Site") || lineStr.StartsWith("Log")))
{
continue;
}
LineNumber += 1;
List <string> ValueArr = lineStr.Split("\t".ToCharArray(), StringSplitOptions.None).ToList();
for (int i = 0, count = ValueArr.Count; i < count; i++)
{
ValueArr[i] = ValueArr[i].Trim();
}
switch (ValueArr[0])
{
case "Site":
{
while ((lineStr = sr.ReadLine()) != null)
{
if (lineStr == "________________________________")
{
break;
}
ValueArr = lineStr.Split("\t".ToCharArray(), StringSplitOptions.None).ToList();
for (int i = 0, count = ValueArr.Count; i < count; i++)
{
ValueArr[i] = ValueArr[i].Trim();
}
if (ValueArr.Count != 13)
{
labSheetA1Sheet.Error = string.Format(LabSheetParserRes.ErrorReadingFileAtLine_Error_, LineNumber, string.Format(LabSheetParserRes._Requires_Value, ValueArr[0], 13));
return(labSheetA1Sheet);
}
List <string> ValueList = new List <string>();
int col = 0;
LabSheetA1Measurement a1Measurement = new LabSheetA1Measurement();
foreach (string s in ValueArr)
{
ValueList.Add(s);
switch (col)
{
case 0: // Site
{
if (string.IsNullOrWhiteSpace(s))
{
labSheetA1Sheet.Error = string.Format(LabSheetParserRes.ErrorReadingFileAtLine_Error_, LineNumber, string.Format(LabSheetParserRes._IsRequired, "Site"));
return(labSheetA1Sheet);
}
a1Measurement.Site = s;
}
break;
case 1: // Time converted into date for DB
{
a1Measurement.Time = null;
if (!string.IsNullOrWhiteSpace(s))
{
int Year = 0;
int Month = 0;
int Day = 0;
int Hour = 0;
int Minute = 0;
int.TryParse(labSheetA1Sheet.RunYear, out Year);
int.TryParse(labSheetA1Sheet.RunMonth, out Month);
int.TryParse(labSheetA1Sheet.RunDay, out Day);
if (s.Length == 5)
{
int.TryParse(s.Substring(0, 2), out Hour);
int.TryParse(s.Substring(3, 2), out Minute);
}
if (Hour > 23)
{
Hour = 0;
}
if (Minute > 59)
{
Minute = 0;
}
a1Measurement.Time = new DateTime(Year, Month, Day, Hour, Minute, 0);
}
}
break;
case 2: // MPN
{
a1Measurement.MPN = null;
if (!string.IsNullOrWhiteSpace(s))
{
int TempInt = -1;
if (s.Trim().StartsWith("<"))
{
TempInt = 1;
}
else if (s.Trim().StartsWith(">"))
{
TempInt = 1700;
}
else
{
if (!int.TryParse(s, out TempInt))
{
TempInt = -999;
}
}
a1Measurement.MPN = TempInt;
}
}
break;
case 3: // Tube 10
{
a1Measurement.Tube10 = null;
if (!string.IsNullOrWhiteSpace(s))
{
int TempInt = -1;
int.TryParse(s, out TempInt);
if (TempInt == -1)
{
continue;
}
if (TempInt >= 0)
{
a1Measurement.Tube10 = TempInt;
}
}
}
break;
case 4: // Tube 1.0
{
a1Measurement.Tube1_0 = null;
if (!string.IsNullOrWhiteSpace(s))
{
int TempInt = -1;
int.TryParse(s, out TempInt);
if (TempInt == -1)
{
continue;
}
if (TempInt >= 0)
{
a1Measurement.Tube1_0 = TempInt;
}
}
}
break;
case 5: // Tube 0.1
{
a1Measurement.Tube0_1 = null;
if (!string.IsNullOrWhiteSpace(s))
{
int TempInt = -1;
int.TryParse(s, out TempInt);
if (TempInt == -1)
{
continue;
}
if (TempInt >= 0)
{
a1Measurement.Tube0_1 = TempInt;
}
}
}
break;
case 6: // Salinity
{
a1Measurement.Salinity = null;
if (!string.IsNullOrWhiteSpace(s))
{
float TempFloat = -1;
float.TryParse(s, out TempFloat);
if (TempFloat == -1)
{
continue;
}
if (TempFloat >= 0)
{
a1Measurement.Salinity = TempFloat;
}
}
}
break;
case 7: // Temperature
{
a1Measurement.Temperature = null;
if (!string.IsNullOrWhiteSpace(s))
{
float TempFloat = -99.0f;
float.TryParse(s, out TempFloat);
if (TempFloat == -99.0f)
{
continue;
}
a1Measurement.Temperature = TempFloat;
}
}
break;
case 8: // ProcessedBy
{
a1Measurement.ProcessedBy = null;
if (!string.IsNullOrWhiteSpace(s))
{
a1Measurement.ProcessedBy = s;
}
}
break;
case 9: // SampleType
{
a1Measurement.SampleType = SampleTypeEnum.Error;
if (!string.IsNullOrWhiteSpace(s))
{
for (int i = 1, count = Enum.GetNames(typeof(SampleTypeEnum)).Length; i < count; i++)
{
int j = i + 100;
string SampleTypeTest = ((SampleTypeEnum)j).ToString();
SampleTypeEnum SampleTypeValue = (SampleTypeEnum)j;
if (SampleTypeTest == s)
{
a1Measurement.SampleType = SampleTypeValue;
break;
}
}
}
}
break;
case 10: // TVItemID of the MWQMSite
{
a1Measurement.TVItemID = 0;
if (!string.IsNullOrWhiteSpace(s))
{
int TempInt = 0;
if (!int.TryParse(s, out TempInt))
{
TempInt = 0;
}
a1Measurement.TVItemID = TempInt;
}
}
break;
case 11: // SiteComment
{
a1Measurement.SiteComment = null;
if (!string.IsNullOrWhiteSpace(s))
{
a1Measurement.SiteComment = s;
}
}
break;
default:
break;
}
col += 1;
}
if (!string.IsNullOrWhiteSpace(a1Measurement.Site))
{
labSheetA1Sheet.LabSheetA1MeasurementList.Add(a1Measurement);
}
}
}
break;
case "Log":
{
sbPrevCommands.AppendLine("________________________________");
sbPrevCommands.AppendLine("Log");
while ((lineStr = sr.ReadLine()) != null)
{
sbPrevCommands.AppendLine(lineStr);
}
labSheetA1Sheet.Log = sbPrevCommands.ToString();
}
break;
default:
{
labSheetA1Sheet.Error = string.Format(LabSheetParserRes.ErrorReadingFileAtLine_Error_, LineNumber, string.Format(LabSheetParserRes.UnknownParameter_, ValueArr[0]));
return(labSheetA1Sheet);
}
}
OldFirstObj = ValueArr[0];
}
}
return(labSheetA1Sheet);
}
