void SetMeasurementValue(Models.MeasurementSubmissionViewModel measurement, string property, object value)
        {
            if (value == null)
            {
                return;
            }

            float num;

            switch (property.TrimEnd(' ', '*').ToLower())
            {
            case "rawvalue":
            case "raw value":
                measurement.RawValue = value.ToStringEx();
                break;

            case "definition":
                measurement.Definition = value.ToStringEx();
                break;

            case "measure":
                if (float.TryParse(value.ToStringEx(), out num))
                {
                    measurement.Measure = num;
                }
                break;

            case "total":
                if (float.TryParse(value.ToStringEx(), out num))
                {
                    measurement.Total = num;
                }
                break;
            }
        }
        public Models.MeasureSubmissionViewModel Convert(IList <string> errors)
        {
            var measure = new Models.MeasureSubmissionViewModel();

            foreach (var row in GetMetadataRows())
            {
                var cells = row.Descendants <Cell>().ToArray();

                if (cells.Length == 0)
                {
                    continue;
                }

                //check if the first cell is in column A, if not skip
                string cellReference = cells[0].CellReference.Value;
                if (!cellReference.StartsWith("A", StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                string metadataHeader = GetCellValue(cells[0]);

                string value = string.Empty;

                if (cells.Length > 1)
                {
                    cellReference = cells[1].CellReference.Value;
                    if (cellReference.StartsWith("B", StringComparison.OrdinalIgnoreCase))
                    {
                        value = GetCellValue(cells[1]);
                    }
                }

                SetMeasureValue(measure, metadataHeader, value);
            }

            var measurementRows = GetValuesRows().ToArray();

            if (measurementRows.Length > 1)
            {
                var measurements = new List <Models.MeasurementSubmissionViewModel>();

                //going to assume for a valid document that the first four cells of the first row will always have a value
                //assume that the cell reference for each header will be A1-D1.
                var headers = measurementRows.First().Descendants <Cell>().Take(4).Select(c => GetCellValue(c)).ToArray();

                foreach (var row in measurementRows.Skip(1))
                {
                    var cells       = row.Descendants <Cell>().ToArray();
                    var measurement = new Models.MeasurementSubmissionViewModel();

                    foreach (var cell in cells)
                    {
                        switch (cell.CellReference.Value[0].ToStringEx().ToUpper())
                        {
                        case "A":
                            SetMeasurementValue(measurement, headers[0], GetCellValue(cell));
                            break;

                        case "B":
                            SetMeasurementValue(measurement, headers[1], GetCellValue(cell));
                            break;

                        case "C":
                            SetMeasurementValue(measurement, headers[2], GetCellValue(cell));
                            break;

                        case "D":
                            SetMeasurementValue(measurement, headers[3], GetCellValue(cell));
                            break;
                        }
                    }

                    if (measurement.IsNotNull())
                    {
                        measurements.Add(measurement);
                    }
                }

                measure.Measures = measurements;
            }

            return(measure);
        }