public static FormulaValue Average(Cell cell, FormulaValue[] args)
{
double val = 0, count = 0;
double data;
foreach (var arg in args)
{
switch (arg.type)
{
case FormulaValueType.Range:
ReferenceRange range = RangeFrom(cell, arg);
Worksheet worksheet = WorksheetFrom(cell, range);
worksheet.IterateCells(range.Position, (r, c, inCell) =>
{
if (CellUtility.TryGetNumberData(worksheet, inCell, out data))
{
val += data;
count++;
}
return(true);
});
break;
case FormulaValueType.Number:
val += (double)arg.value;
count++;
break;
case FormulaValueType.Nil:
continue;
}
}
return(count > 0 ? (val / count) : 0);
}
public void AddReferenceRangeTest_Success()
{
StandardReference stdReference = new StandardReference()
{
Title = "testStdReferenceTitle"
};
_unitOfWork.StandardReferences.Add(stdReference);
_unitOfWork.Complete();
string message = string.Empty;
var result = _target.GetReferenceRangeByID(1, out message);
Assert.IsNull(result);
ReferenceRange referenceRange = new ReferenceRange()
{
Title = "Test",
Result = "Testing 123",
StandardReferenceID = 1
};
var saveResult = _target.AddReferenceRange(referenceRange, out message);
Assert.IsNotNull(saveResult);
Assert.AreEqual(string.Empty, message);
result = _target.GetReferenceRangeByID(1, out message);
Assert.IsNotNull(result);
Assert.AreEqual("Test", result.Title);
}
public void GetReferenceRange_MinValueSuccess()
{
StandardReference standardReference = new StandardReference()
{
Title = "Test"
};
ReferenceRange referenceRangeOne = new ReferenceRange()
{
Title = "Underweight",
MinimumValue = 0,
MaximumValue = 18.4,
Result = "NORMAL"
};
_unitOfWork.StandardReferences.Add(standardReference);
_unitOfWork.Complete();
standardReference.ReferenceRanges.Add(referenceRangeOne);
_unitOfWork.Complete();
string message = string.Empty;
ReferenceRange result = _target.GetReferenceRange(1, 0, out message);
Assert.IsNotNull(result);
Assert.AreEqual("Underweight", result.Title);
}
/// <summary>
/// Create chart data serial instance with specified worksheet and reference ranges
/// </summary>
/// <param name="dataSource">Data source to read chart data from worksheet.</param>
/// <param name="worksheet">Instance of worksheet that contains the data to be read.</param>
/// <param name="labelAddress">The address to locate label of serial on worksheet.</param>
/// <param name="dataRange">Serial data range to read serial data for chart from worksheet.</param>
public WorksheetChartDataSerial(WorksheetChartDataSource dataSource, Worksheet worksheet, ReferenceRange labelAddress, ReferenceRange dataRange)
{
this.dataSource = dataSource ?? throw new ArgumentNullException("dataSource");
this.worksheet = worksheet ?? throw new ArgumentNullException("worksheet");
this.LabelAddress = labelAddress;
this.DataRange = dataRange;
}
public void ToDelimitedString_WithAllProperties_ReturnsCorrectlySequencedFields()
{
IType hl7Type = new ReferenceRange
{
NumericRange = new NumericRange
{
LowValue = 1
},
AdministrativeSex = new CodedWithExceptions
{
Identifier = "2"
},
AgeRange = new NumericRange
{
LowValue = 3
},
GestationalAgeRange = new NumericRange
{
LowValue = 4
},
Species = "5",
RaceSubspecies = "6",
Conditions = new Text
{
Value = "7"
}
};
string expected = "1^2^3^4^5^6^7";
string actual = hl7Type.ToDelimitedString();
Assert.Equal(expected, actual);
}
private void AddSerialsFromRange(ReferenceRange serialNamesRange, ReferenceRange serialsRange,
RowOrColumn serialPerRowOrColumn = RowOrColumn.Row)
{
if (serialPerRowOrColumn == RowOrColumn.Row)
{
for (int r = serialsRange.Row; r <= serialsRange.EndRow; r++)
{
var label = new RangePosition(r, serialNamesRange.Col, 1, serialNamesRange.Cols);
var pos = new RangePosition(r, serialsRange.Col, 1, serialsRange.Cols);
this.AddSerial(worksheet,
new ReferenceRange(serialNamesRange.Worksheet, label),
new ReferenceRange(serialsRange.Worksheet, pos));
}
}
else if (serialPerRowOrColumn == RowOrColumn.Column)
{
for (int c = serialsRange.Col; c <= serialsRange.EndCol; c++)
{
var label = new RangePosition(serialNamesRange.Row, c, serialNamesRange.Rows, 1);
var pos = new RangePosition(serialsRange.Row, c, serialsRange.Rows, 1);
this.AddSerial(worksheet,
new ReferenceRange(serialNamesRange.Worksheet, label),
new ReferenceRange(serialsRange.Worksheet, pos));
}
}
else
{
this.AddSerial(worksheet, serialNamesRange, serialsRange);
}
}
/// <summary>
/// Add serial data into data source from a range, set the name as the label of serial.
/// </summary>
/// <param name="worksheet">Worksheet instance to read serial data.</param>
/// <param name="name">Name for serial to be added.</param>
/// <param name="serialRange">Range to read serial data from worksheet.</param>
/// <returns>Instance of chart serial has been added.</returns>
public WorksheetChartDataSerial AddSerial(Worksheet worksheet, ReferenceRange labelAddress, ReferenceRange serialRange)
{
var serial = new WorksheetChartDataSerial(this, worksheet, labelAddress, serialRange);
this.Add(serial);
return(serial);
}
public void GetReferenceRangeByIDTest_NoRecord()
{
StandardReference stdReference = new StandardReference()
{
Title = "testStdReferenceTitle"
};
ReferenceRange referenceRange = new ReferenceRange()
{
Title = "Test",
Result = "Testing 123",
};
stdReference.ReferenceRanges.Add(referenceRange);
_unitOfWork.StandardReferences.Add(stdReference);
_unitOfWork.Complete();
string message = string.Empty;
var result = _target.GetReferenceRangeByID(3, out message);
Assert.IsNull(result);
Assert.AreEqual("Invalid Reference Range ID", message);
}
public void DeleteReferenceRangeTest_Success()
{
StandardReference stdReference = new StandardReference()
{
Title = "testStdReferenceTitle"
};
ReferenceRange referenceRange = new ReferenceRange()
{
Title = "Test",
Result = "Testing 123",
};
stdReference.ReferenceRanges.Add(referenceRange);
_unitOfWork.StandardReferences.Add(stdReference);
_unitOfWork.Complete();
string message = string.Empty;
referenceRange = _target.GetReferenceRangeByID(1, out message);
Assert.IsNotNull(stdReference);
var saveResult = _target.DeleteReferenceRange(1, out message);
Assert.IsTrue(saveResult);
var result = _target.GetReferenceRangeByID(1, out message);
Assert.IsNull(result);
Assert.AreEqual("Invalid Reference Range ID", message);
}
public static FormulaValue Sum(Cell cell, FormulaValue[] args)
{
double val = 0;
foreach (var arg in args)
{
switch (arg.type)
{
case FormulaValueType.Range:
ReferenceRange range = RangeFrom(cell, arg);
Worksheet worksheet = WorksheetFrom(cell, range);
worksheet.IterateCells(range.Position, (r, c, inCell) =>
{
double data;
if (CellUtility.TryGetNumberData(worksheet, inCell, out data))
{
val += data;
}
return(true);
});
break;
case FormulaValueType.Number:
val += (double)arg.value;
break;
}
}
return(val);
}
public void DefaultPropertiesShouldBeCorrect()
{
var referenceRange = new ReferenceRange<OrderedTest>();
Assert.IsNotNull(referenceRange.Range);
var range = new Interval<OrderedTest>();
referenceRange.Range = range;
var orderedTest = new OrderedTest();
Assert.AreEqual(range.HasElement(orderedTest), referenceRange.IsInRange(orderedTest));
}
static Worksheet WorksheetFrom(Cell cell, ReferenceRange range)
{
var worksheet = range.Worksheet != null ? range.Worksheet : cell.Worksheet;
if (worksheet == null)
{
throw new FormulaTypeMismatchException(cell);
}
return(worksheet);
}
public bool DeleteStandardReference(int id, out string message)
{
message = string.Empty;
try
{
using (var unitOfWork = CreateUnitOfWork())
{
var standardReference = unitOfWork.StandardReferences.GetStandardReference(id);
if (standardReference == null)
{
message = "Standard Reference not found";
return(false);
}
if (standardReference.TemplateFields.Any())
{
message = "Standard Reference linked to template.";
return(false);
}
using (TransactionScope scope = new TransactionScope())
{
List <ReferenceRange> referenceRangesToDelete = new List <ReferenceRange>();
foreach (var referenceRange in standardReference.ReferenceRanges)
{
ReferenceRange referenceRangeToDelete = unitOfWork.ReferenceRanges.Get(referenceRange.ReferenceRangeID);
referenceRangesToDelete.Add(referenceRangeToDelete);
}
//remove Reference Range from Standard reference
foreach (ReferenceRange rr in referenceRangesToDelete)
{
standardReference.ReferenceRanges.Remove(rr);
}
//remove Reference Range
unitOfWork.ReferenceRanges.RemoveRange(referenceRangesToDelete);
//remove Standard Reference
unitOfWork.StandardReferences.Remove(standardReference);
unitOfWork.Complete();
scope.Complete();
}
message = string.Empty;
return(true);
}
}
catch (Exception ex)
{
ExceptionLog(ex);
message = "Operation failed during deleting Standard Reference";
return(false);
}
}
public void DefaultPropertiesShouldBeCorrect()
{
var referenceRange = new ReferenceRange <OrderedTest>();
Assert.IsNotNull(referenceRange.Range);
var range = new Interval <OrderedTest>();
referenceRange.Range = range;
var orderedTest = new OrderedTest();
Assert.AreEqual(range.HasElement(orderedTest), referenceRange.IsInRange(orderedTest));
}
public IActionResult DeleteReferenceRange(long id)
{
ReferenceRange range = ref_repo.Find(id);
if (range == null)
{
return(NotFound());
}
ref_repo.Delete(range);
return(Ok());
}
public static FormulaValue Min(Cell cell, FormulaValue[] args)
{
double min = 0;
double data;
bool first = true;
foreach (var arg in args)
{
switch (arg.type)
{
case FormulaValueType.Range:
ReferenceRange range = RangeFrom(cell, arg);
Worksheet worksheet = WorksheetFrom(cell, range);
worksheet.IterateCells(range.Position, (r, c, inCell) =>
{
if (CellUtility.TryGetNumberData(worksheet, inCell, out data))
{
if (first)
{
min = data;
first = false;
}
else if (min > data)
{
min = data;
}
}
return(true);
});
break;
case FormulaValueType.Number:
data = (double)arg.value;
if (first)
{
min = data;
first = false;
}
else if (min > data)
{
min = data;
}
break;
default:
return(null);
}
}
return(min);
}
/// <summary>
/// Validates this ReferenceRangeDetails item
/// </summary>
/// <param name="path">The path to this object as a string</param>
/// <param name="messages">the validation messages to date, these may be added to within this method</param>
public void Validate(string path, List <ValidationMessage> messages)
{
var vb = new ValidationBuilder(path, messages);
if (vb.ArgumentRequiredCheck("ReferenceRangeMeaning", ReferenceRangeMeaning))
{
ReferenceRangeMeaning.Validate(vb.Path + "ReferenceRangeMeaning", vb.Messages);
}
if (vb.ArgumentRequiredCheck("ReferenceRange", ReferenceRange))
{
ReferenceRange.Validate(vb.Path + "ReferenceRange", vb.Messages);
}
}
public static FormulaValue Count(Cell cell, FormulaValue[] args, bool includeEmpty = false)
{
double count = 0;
double data;
foreach (var arg in args)
{
switch (arg.type)
{
case FormulaValueType.Range:
ReferenceRange range = RangeFrom(cell, arg);
Worksheet worksheet = WorksheetFrom(cell, range);
worksheet.IterateCells(range.Position, (r, c, inCell) =>
{
if (includeEmpty)
{
if (inCell.InnerData != null)
{
count++;
}
}
else
{
if (CellUtility.TryGetNumberData(worksheet, inCell, out data))
{
count++;
}
}
return(true);
});
break;
case FormulaValueType.Number:
count++;
break;
case FormulaValueType.String:
if (includeEmpty && !string.IsNullOrEmpty((string)arg.value))
{
count++;
}
break;
}
}
return(count);
}
public static FormulaValue CountIf(Cell cell, FormulaValue[] args)
{
if (cell == null || cell.Worksheet == null)
{
return(null);
}
double count = 0;
ReferenceRange evalRange = RangeFrom(cell, args[0]);
Worksheet evalWorksheet = WorksheetFrom(cell, evalRange);
STValueNode leftExp = new STValueNode(null);
STNode compExp;
FormulaValue compVal = args[1];
if (args[1].type == FormulaValueType.String)
{
compExp = Parser.ParseInterCompareExp(cell, (string)compVal.value);
}
else
{
compExp = new STNode(STNodeType.EQUALS, 0, 0, new List <STNode>(2)
{
leftExp, new STValueNode(args[1])
});
}
evalWorksheet.IterateCells(evalRange, (r, c, inCell) =>
{
leftExp.Value = Evaluator.CreateFormulaValue(inCell);
compExp[0] = leftExp;
var result = (Evaluator.Evaluate(cell, compExp));
if (result.type == FormulaValueType.Boolean && ((bool)result.value))
{
count++;
}
return(true);
});
return(count);
}
public ActionResult EditReferenceRange([Bind(Include = "StandardReferenceID,ReferenceRangeID,Title,MinimumValue,MaximumValue,StringValue,Result,Highlight")] ReferenceRange referenceRange)
{
if (!IsUserAuthenticated())
{
return(RedirectToLogin());
}
string message = string.Empty;
using (var referenceRangeManager = new ReferenceRangeManager(GetLoginUser()))
{
if (referenceRangeManager.UpdateReferenceRange(referenceRange, out message))
{
SetTempDataMessage(Constants.ValueSuccessfuly("Reference Range " + referenceRange.Title + " has been updated"));
return(RedirectToAction("Edit", new { id = referenceRange.StandardReferenceID }));
}
SetViewBagError(message);
return(View(referenceRange));
}
}
public ReferenceRange GetReferenceRange(int standardReferenceID, string value, out string message)
{
message = string.Empty;
try
{
using (var unitOfWork = CreateUnitOfWork())
{
var standardReference = unitOfWork.StandardReferences.GetStandardReference(standardReferenceID);
if (standardReference == null)
{
message = "Invalid Standard Reference ID";
return(null);
}
ReferenceRange referenceRange = null;
if (standardReference.DataType == "Number")
{
double inputValue;
if (double.TryParse(value, out inputValue))
{
referenceRange = standardReference.ReferenceRanges.Where(r => r.MinimumValue <= inputValue && r.MaximumValue >= inputValue).FirstOrDefault();
}
else
{
message = "Incompatible Standard reference Data type";
return(null);
}
}
else if (standardReference.DataType == "String")
{
referenceRange = standardReference.ReferenceRanges.Where(r => r.StringValue.Equals(value, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
}
return(referenceRange);
}
}
catch (Exception ex)
{
ExceptionLog(ex);
message = Constants.OperationFailedDuringRetrievingValue("GetReferenceRange");
return(null);
}
}
private static ReferenceRange <T> Map <T>(this REFERENCE_RANGE model) where T : Ordered <T>
{
var referenceRange = new ReferenceRange <T>
{
Meaning = new Text(model.meaning.value)
{
Formatting = model.meaning.formatting,
Encoding = model.meaning.encoding.Map(),
Language = model.meaning.language.Map(),
Hyperlink = new Uri(model.meaning.hyperlink.value.ToString())
}
};
foreach (TERM_MAPPING mapping in model.meaning.mappings)
{
referenceRange.Meaning.Mappings.Add(mapping.Map());
}
referenceRange.Range = model.range.Map <T>();
return(referenceRange);
}
public ActionResult CreateReferenceRange([Bind(Exclude = "ReferenceRangeID")] ReferenceRange referenceRange)
{
if (!IsUserAuthenticated())
{
return(RedirectToLogin());
}
string message = string.Empty;
using (var referenceRangeManager = new ReferenceRangeManager(GetLoginUser()))
{
var newReferenceRange = referenceRangeManager.AddReferenceRange(referenceRange, out message);
if (newReferenceRange == null)
{
SetViewBagError(message);
return(View(referenceRange));
}
SetTempDataMessage(Constants.ValueSuccessfuly("Reference Range " + newReferenceRange.Title + " has been added"));
return(RedirectToAction("Edit", new { id = newReferenceRange.StandardReferenceID }));
}
}
public void FromDelimitedString_WithAllProperties_ReturnsCorrectlyInitializedFields()
{
IType expected = new ReferenceRange
{
NumericRange = new NumericRange
{
IsSubcomponent = true,
LowValue = 1
},
AdministrativeSex = new CodedWithExceptions
{
IsSubcomponent = true,
Identifier = "2"
},
AgeRange = new NumericRange
{
IsSubcomponent = true,
LowValue = 3
},
GestationalAgeRange = new NumericRange
{
IsSubcomponent = true,
LowValue = 4
},
Species = "5",
RaceSubspecies = "6",
Conditions = new Text
{
IsSubcomponent = true,
Value = "7"
}
};
IType actual = new ReferenceRange();
actual.FromDelimitedString("1^2^3^4^5^6^7");
expected.Should().BeEquivalentTo(actual);
}
public void GetReferenceRange_NoMatch()
{
StandardReference standardReference = new StandardReference()
{
Title = "Test"
};
ReferenceRange referenceRangeOne = new ReferenceRange()
{
Title = "Underweight",
MinimumValue = 0,
MaximumValue = 18.4,
Result = "NORMAL"
};
ReferenceRange referenceRangetwo = new ReferenceRange()
{
Title = "Normal",
MinimumValue = 18.5,
MaximumValue = 24.9,
Result = "NORMAL"
};
_unitOfWork.StandardReferences.Add(standardReference);
_unitOfWork.Complete();
standardReference.ReferenceRanges.Add(referenceRangeOne);
standardReference.ReferenceRanges.Add(referenceRangetwo);
_unitOfWork.Complete();
string message = string.Empty;
ReferenceRange result = _target.GetReferenceRange(1, 25.0, out message);
Assert.IsNull(result);
Assert.AreEqual("Unable to find reference range", message);
}
// GET: Admin/StandardReference/CreateReferenceRange
public ActionResult CreateReferenceRange(int standardReferenceID = 0)
{
if (!IsUserAuthenticated())
{
return(RedirectToLogin());
}
string message = string.Empty;
using (var standardReferenceManager = new StandardReferenceManager())
{
StandardReference standardReference = standardReferenceManager.GetStandardReferenceByID(standardReferenceID, out message);
if (standardReference == null)
{
SetViewBagError("Invalid Standard Reference ID. Create Standard Reference first.");
return(View());
}
ReferenceRange referenceRange = new ReferenceRange();
referenceRange.StandardReferenceID = standardReferenceID;
return(View(referenceRange));
}
}
void CustomFunction_RangeReference()
{
FormulaExtension.CustomFunctions["CountEvenNumber"] = (cell, args) =>
{
if (args.Length < 1 || !(args[0] is ReferenceRange))
{
return(null);
}
ReferenceRange range = (ReferenceRange)args[0];
int count = 0;
// iterate over cells inside a range
cell.Worksheet.IterateCells(range, (r, c, inCell) =>
{
double value;
if (unvell.ReoGrid.Utility.CellUtility.TryGetNumberData(inCell.Data, out value))
{
if ((value % 2) == 0)
{
count++;
}
}
// continue iterate
return(true);
});
return(count);
};
worksheet["G2:K3"] = new object[] { 1, 2, 5, 7, 8, 10, 12, 15, 16, 19 };
worksheet["L2"] = "=CountEvenNumber(G2:K3)";
AssertSame(worksheet["L2"], 5);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Test CheckForOverlaps where the user elects to keep file 1 in the Overlapping Files
/// dialog
/// </summary>
/// ------------------------------------------------------------------------------------
private IScrImportFileInfo CreateStubFileInfo(DummyScrImportFileInfoFactory factory,
string name, ScrReference startRef, ReferenceRange refRange)
{
IScrImportFileInfo f = factory.Create(name, m_mappingList, ImportDomain.Main,
null, null, false);
f.Stub(x => x.IsReadable).Return(true);
f.Stub(x => x.IsStillReadable).Return(true);
f.Stub(x => x.StartRef).Return(startRef);
f.Stub(x => x.BookReferences).Return(new ReferenceRange[] { refRange });
return(f);
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as Observation;
if (dest != null)
{
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.Observation.ObservationStatus>)StatusElement.DeepCopy();
}
if (Category != null)
{
dest.Category = (Hl7.Fhir.Model.CodeableConcept)Category.DeepCopy();
}
if (Code != null)
{
dest.Code = (Hl7.Fhir.Model.CodeableConcept)Code.DeepCopy();
}
if (Subject != null)
{
dest.Subject = (Hl7.Fhir.Model.ResourceReference)Subject.DeepCopy();
}
if (Encounter != null)
{
dest.Encounter = (Hl7.Fhir.Model.ResourceReference)Encounter.DeepCopy();
}
if (Effective != null)
{
dest.Effective = (Hl7.Fhir.Model.Element)Effective.DeepCopy();
}
if (IssuedElement != null)
{
dest.IssuedElement = (Hl7.Fhir.Model.Instant)IssuedElement.DeepCopy();
}
if (Performer != null)
{
dest.Performer = new List <Hl7.Fhir.Model.ResourceReference>(Performer.DeepCopy());
}
if (Value != null)
{
dest.Value = (Hl7.Fhir.Model.Element)Value.DeepCopy();
}
if (DataAbsentReason != null)
{
dest.DataAbsentReason = (Hl7.Fhir.Model.CodeableConcept)DataAbsentReason.DeepCopy();
}
if (Interpretation != null)
{
dest.Interpretation = (Hl7.Fhir.Model.CodeableConcept)Interpretation.DeepCopy();
}
if (CommentsElement != null)
{
dest.CommentsElement = (Hl7.Fhir.Model.FhirString)CommentsElement.DeepCopy();
}
if (BodySite != null)
{
dest.BodySite = (Hl7.Fhir.Model.CodeableConcept)BodySite.DeepCopy();
}
if (Method != null)
{
dest.Method = (Hl7.Fhir.Model.CodeableConcept)Method.DeepCopy();
}
if (Specimen != null)
{
dest.Specimen = (Hl7.Fhir.Model.ResourceReference)Specimen.DeepCopy();
}
if (Device != null)
{
dest.Device = (Hl7.Fhir.Model.ResourceReference)Device.DeepCopy();
}
if (ReferenceRange != null)
{
dest.ReferenceRange = new List <Hl7.Fhir.Model.Observation.ObservationReferenceRangeComponent>(ReferenceRange.DeepCopy());
}
if (Related != null)
{
dest.Related = new List <Hl7.Fhir.Model.Observation.ObservationRelatedComponent>(Related.DeepCopy());
}
if (Component != null)
{
dest.Component = new List <Hl7.Fhir.Model.Observation.ObservationComponentComponent>(Component.DeepCopy());
}
return(dest);
}
else
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
}
public IActionResult AddReferenceRange([FromBody] ReferenceRange model)
{
ref_repo.Add(model);
return(new OkObjectResult(new { ReferenceRangeID = model.ReferenceRangeId }));
}
public List <SummaryCategoryViewModel> GetSummaryCategories(string summaryType)
{
List <SummaryCategoryViewModel> result = new List <SummaryCategoryViewModel>();
List <string> categoryNames = null;
Dictionary <string, List <string> > summaryLabelMap = null;
using (var summaryMappingManager = new SummaryMappingManager())
{
categoryNames = summaryMappingManager.GetAllCategoryNamesBySummaryType(summaryType);
summaryLabelMap = summaryMappingManager.GetSummaryLabelMapBySummaryType(summaryType);
}
if (categoryNames == null)
{
return(result);
}
foreach (var summaryCategoryName in categoryNames)
{
SummaryCategoryViewModel sumCategoryViewModel = new SummaryCategoryViewModel(summaryCategoryName);
if (summaryCategoryName.Contains("Gastrointestinal Health"))
{
sumCategoryViewModel.Highlight = true;
}
foreach (var summary in Participant.Summaries)
{
if (summary != null && summary.PHSEventID.Equals(Event.PHSEventID))
{
if (SummaryHelper.IsFieldNameAndCategoryFoundInSummaryMap(summaryLabelMap, summaryCategoryName, summary.Label))
{
if (summary.SummaryValue == null || summary.SummaryValue.Count() <= 0)
{
continue;
}
SummaryViewModel sumview = new SummaryViewModel(summary);
if (sumCategoryViewModel.Highlight != true)
{
// summary.TemplateFieldID;
if (SummaryHelper.IsHighlightCategoryRequired(summaryCategoryName, summary.TemplateField.SummaryFieldName, summary.SummaryValue))
{
sumCategoryViewModel.Highlight = true;
}
}
if (summary.StandardReferenceID != null && summary.StandardReferenceID > 0 &&
summary.SummaryValue != null)
{
if (SummaryHelper.IsJson(summary.SummaryValue))
{
//if (summary.StandardReferenceID == 1) //Systolic Blood Pressure
//{
// sumview.SummaryValue = summary.SummaryValue;
// sumview.SummaryInnerValue = summary.SummaryValue;
//}else if (summary.StandardReferenceID == 2) //Diastolic Blood Pressure
//{
// sumview.SummaryValue = summary.SummaryValue;
// sumview.SummaryInnerValue = summary.SummaryValue;
//}else if (summary.StandardReferenceID == 3) //Sugar
//{
// sumview.SummaryValue = summary.SummaryValue;
// sumview.SummaryInnerValue = summary.SummaryValue;
//}else
if (summary.StandardReferenceID == 4) //BMI
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
BMIViewModel bmi = serializer.Deserialize <BMIViewModel>(summary.SummaryValue as string);
if (bmi.BodyMassIndex != null)
{
//Weight: 50, Height: 180, BodyMassIndex: 15.43 (UNDERWEIGHT)
sumview.SummaryValue = "Weight: " + bmi.Weight + ", Height: " + bmi.Height + ", BodyMassIndex: " + bmi.BodyMassIndex;
sumview.SummaryInnerValue = bmi.BodyMassIndex;
}
}
}
else
{
sumview.SummaryInnerValue = summary.SummaryValue;
}
ReferenceRange referenceRange = null;
using (var StandardReferenceManager = new StandardReferenceManager())
{
string message = string.Empty;
referenceRange = StandardReferenceManager.GetReferenceRange(summary.StandardReferenceID.GetValueOrDefault(),
sumview.SummaryInnerValue, out message);
}
if (referenceRange != null)
{
sumview.Result = referenceRange.Result;
sumview.Highlight = referenceRange.Highlight;
}
}
if (sumview != null)
{
sumCategoryViewModel.AddSummary(sumview);
}
}
}
}
result.Add(sumCategoryViewModel);
}
return(result);
}
