private CompactionReportResult ConvertTRexStationOffsetResult(CompactionReportStationOffsetRequest request, Stream stream)
{
log.LogDebug($"{nameof(ConvertTRexStationOffsetResult)}: Retrieving response data from TRex");
var stationOffsetReportResult = new StationOffsetReportResultPackager(ReportType.StationOffset);
stationOffsetReportResult.Read((stream as MemoryStream)?.ToArray());
var stationRows = new StationRow[stationOffsetReportResult.GriddedData.NumberOfRows];
for (var i = 0; i < stationOffsetReportResult.GriddedData.NumberOfRows; i++)
{
var station = stationOffsetReportResult.GriddedData.Rows[i];
var stationRow = StationRow.Create(station, request);
for (var j = 0; j < station.Offsets.Count; j++)
{
stationRow.Offsets[j] = StationOffsetRow.CreateRow(station.Offsets[j], request);
}
stationRows[i] = stationRow;
}
var startAndEndTime = request.Filter.StartUtc ?? DateTime.UtcNow;
var stationOffsetReport = new StationOffsetReport(startAndEndTime, startAndEndTime, stationRows, request);
return(CompactionReportResult.CreateExportDataResult(stationOffsetReport, 1));
}
private CompactionReportResult ConvertStationOffsetResult(CompactionReportStationOffsetRequest request, Stream stream)
{
log.LogDebug($"{nameof(ConvertStationOffsetResult)}");
// Unpack the data for the report and construct a stream containing the result
var reportPackager = new TRaptorReportsPackager(TRaptorReportType.rrtStationOffset)
{
ReturnCode = TRaptorReportReturnCode.rrrcUnknownError
};
log.LogDebug($"{nameof(ConvertStationOffsetResult)}: Retrieving response data");
reportPackager.ReadFromStream(stream);
var stationRows = new StationRow[reportPackager.StationOffsetReport.NumberOfStations];
for (var i = 0; i < reportPackager.StationOffsetReport.NumberOfStations; i++)
{
var station = reportPackager.StationOffsetReport.Stations[i];
var stationRow = StationRow.Create(station, request);
for (var j = 0; j < station.NumberOfOffsets; j++)
{
stationRow.Offsets[j] = StationOffsetRow.CreateRow(station.Offsets[j], request);
}
stationRows[i] = stationRow;
}
var startAndEndTime = request.Filter.StartUtc ?? DateTime.UtcNow;
var stationOffsetReport = new StationOffsetReport(startAndEndTime, startAndEndTime, stationRows, request);
return(CompactionReportResult.CreateExportDataResult(stationOffsetReport, 1));
}
public void LoadOffsetsSingleOffset_Streaming_Successful()
{
// When Response returned via MasterData Proxies,
// it is converted to byte[], then stream then file stream, then back
double station1 = 10;
var stationOffsetRowStation1_1 = new StationOffsetRow(
station1, -1, 1.0, 2.0, 3.0,
4.0, 5, 6, 7, 8
);
var stationOffsetRows = new List <StationOffsetRow>()
{
stationOffsetRowStation1_1
};
var stationOffsetResponse = new StationOffsetReportRequestResponse_ApplicationService()
{
};
stationOffsetResponse.LoadStationOffsets(stationOffsetRows);
var retrievedStation1 = stationOffsetResponse.StationOffsetReportDataRowList.Where(x => x.Station == station1).First();
Assert.NotNull(retrievedStation1);
var original = new StationOffsetReportResult(ReportType.StationOffset);
original.GriddedData.Rows.Add(retrievedStation1);
original.GriddedData.ReportElevation = true;
original.GriddedData.ReportCutFill = true;
original.GriddedData.ReportCmv = false;
original.GriddedData.ReportMdp = true;
original.GriddedData.ReportPassCount = false;
original.GriddedData.ReportTemperature = true;
var byteArrayOfOriginal = original.Write();
var copyOfOrig = new StationOffsetReportResult();
copyOfOrig.Read(byteArrayOfOriginal);
// Graceful WebReq
var fileStream = new FileStreamResult(new MemoryStream(byteArrayOfOriginal), ContentTypeConstants.ApplicationOctetStream);
var memoryStream = (MemoryStream)fileStream.FileStream;
var resultFromStream = new StationOffsetReportResult();
resultFromStream.Read(memoryStream.ToArray());
Assert.True(ReportType.StationOffset == resultFromStream.ReportType, "Invalid report type");
Assert.True(original.GriddedData.Rows.Count == resultFromStream.GriddedData.Rows.Count, "Invalid number of rows");
Assert.Equal(original.GriddedData.Rows[0].Station, resultFromStream.GriddedData.Rows[0].Station);
Assert.Equal(original.GriddedData.Rows[0].Offsets.Count, resultFromStream.GriddedData.Rows[0].Offsets.Count);
Assert.Equal(original.GriddedData.Rows[0].Offsets[0].Offset, resultFromStream.GriddedData.Rows[0].Offsets[0].Offset);
Assert.Equal(original.GriddedData.Rows[0].Offsets[0].Northing, resultFromStream.GriddedData.Rows[0].Offsets[0].Northing);
Assert.Equal(original.GriddedData.Rows[0].Minimum.CutFill, resultFromStream.GriddedData.Rows[0].Minimum.CutFill);
Assert.Equal(original.GriddedData.Rows[0].Maximum.Elevation, resultFromStream.GriddedData.Rows[0].Maximum.Elevation);
}
public void LoadOffsetsSingleOffset_Successful()
{
var stationOffsetRow1 = new StationOffsetRow(
1.0, -1, 1.0, 2.0, 3.0,
4.0, 5, 6, 7, 8
);
var stationOffsetRows = new List <StationOffsetRow>()
{
stationOffsetRow1
};
var stationOffsetDataRowManual = new StationOffsetReportDataRow_ApplicationService
(stationOffsetRow1.Station, stationOffsetRows);
StationOffsetReportDataRow_ApplicationService stationOffsetDataRowAuto = null;
var queryStations = from stationOffsetRow in stationOffsetRows
group stationOffsetRow by stationOffsetRow.Station
into newGroup
orderby newGroup.Key
select newGroup;
Assert.Single(queryStations);
foreach (var stationGroup in queryStations)
{
Assert.Equal(stationOffsetRow1.Station, stationGroup.Key);
Assert.Single(stationGroup);
foreach (var offset in stationGroup)
{
Assert.Equal(stationOffsetRow1.Station, offset.Station);
Assert.Equal(stationOffsetRow1.Offset, offset.Offset);
Assert.Equal(stationOffsetRow1.Cmv, offset.Cmv);
}
// making a new copy, ensures the compare doesn't pass solely on ReferenceEquals case
var stationOffsetRowCopy = stationGroup.First();
var stationOffsetRowCopyList = new List <StationOffsetRow>()
{
new StationOffsetRow(stationOffsetRowCopy.Station, stationOffsetRowCopy.Offset,
stationOffsetRowCopy.Northing, stationOffsetRowCopy.Easting, stationOffsetRowCopy.Elevation, stationOffsetRowCopy.CutFill,
stationOffsetRowCopy.Cmv, stationOffsetRowCopy.Mdp, stationOffsetRowCopy.PassCount, stationOffsetRowCopy.Temperature)
};
stationOffsetDataRowAuto = new StationOffsetReportDataRow_ApplicationService
(stationGroup.Key, stationOffsetRowCopyList);
}
Assert.Equal(stationOffsetDataRowManual.Station, stationOffsetDataRowAuto.Station);
Assert.Equal(stationOffsetDataRowManual.Offsets.Count, stationOffsetDataRowAuto.Offsets.Count);
Assert.Equal(stationOffsetDataRowManual.Offsets[0].Offset, stationOffsetDataRowAuto.Offsets[0].Offset);
Assert.Equal(stationOffsetDataRowManual.Offsets[0].Northing, stationOffsetDataRowAuto.Offsets[0].Northing);
Assert.Equal(stationOffsetDataRowManual.Minimum.CutFill, stationOffsetDataRowAuto.Minimum.CutFill);
Assert.Equal(stationOffsetDataRowManual.Maximum.Elevation, stationOffsetDataRowAuto.Maximum.Elevation);
}
public void LoadOffsetsMultiStations_Successful()
{
double station1 = 10;
var stationOffsetRowStation1_1 = new StationOffsetRow(
station1, -1, 1.0, 2.0, 3.0,
4.0, 5, 6, 7, 8
);
var stationOffsetRowStation1_2 = new StationOffsetRow(
station1, 5, 1.2, 2.2, 3.2,
4.2, 1, 2, 3, 4
);
double station2 = 20;
var stationOffsetRowStation2_1 = new StationOffsetRow(
station2, -1, 1.0, 2.0, 3.0,
4.0, 5, 6, 7, 8
);
var stationOffsetRowStation2_2 = new StationOffsetRow(
station2, 5, 1.2, 2.2, 3.2,
4.2, 1, 2, 3, 4
);
var stationOffsetRows = new List <StationOffsetRow>()
{
stationOffsetRowStation1_1, stationOffsetRowStation1_2,
stationOffsetRowStation2_1, stationOffsetRowStation2_2
};
Assert.Equal(4, stationOffsetRows.Count);
var stationOffsetResponse = new StationOffsetReportRequestResponse_ApplicationService()
{
};
stationOffsetResponse.LoadStationOffsets(stationOffsetRows);
Assert.Equal(2, stationOffsetResponse.StationOffsetReportDataRowList.Count);
var retrievedStation1 = stationOffsetResponse.StationOffsetReportDataRowList.Where(x => x.Station == station1).First();
Assert.Equal(station1, stationOffsetRowStation1_1.Station);
Assert.Equal(2, retrievedStation1.Offsets.Count);
Assert.Equal(station1, retrievedStation1.Offsets[0].Station);
Assert.Equal(stationOffsetRowStation1_1.Offset, retrievedStation1.Offsets[0].Offset);
Assert.Equal(stationOffsetRowStation1_1.Cmv, retrievedStation1.Offsets[0].Cmv);
var retrievedStation2 = stationOffsetResponse.StationOffsetReportDataRowList.Where(x => x.Station == station2).First();
Assert.Equal(station2, stationOffsetRowStation2_2.Station);
Assert.Equal(2, retrievedStation2.Offsets.Count);
Assert.Equal(station2, retrievedStation2.Offsets[1].Station);
Assert.Equal(stationOffsetRowStation2_2.Offset, retrievedStation2.Offsets[1].Offset);
Assert.Equal(stationOffsetRowStation2_2.Cmv, retrievedStation2.Offsets[1].Cmv);
}
private StationOffsetRow ExtractRequiredValues(IDesignWrapper cutFillDesignWrapper, StationOffsetPoint point, ClientCellProfileLeafSubgrid clientGrid, int cellX, int cellY)
{
clientGrid.CalculateWorldOrigin(out double subgridWorldOriginX, out double subgridWorldOriginY);
var cell = clientGrid.Cells[cellX, cellY];
var result = new StationOffsetRow(point.Station, point.Offset, cell.CellYOffset + subgridWorldOriginY, cell.CellXOffset + subgridWorldOriginX);
(IClientHeightLeafSubGrid designHeights, DesignProfilerRequestResult errorCode)getDesignHeightsResult = (null, DesignProfilerRequestResult.UnknownError);
if (requestArgument.ReferenceDesign != null && requestArgument.ReferenceDesign.DesignID != Guid.Empty)
{
getDesignHeightsResult = cutFillDesignWrapper.Design.GetDesignHeightsViaLocalCompute(siteModel, cutFillDesignWrapper.Offset, clientGrid.OriginAsCellAddress(), clientGrid.CellSize);
if (getDesignHeightsResult.errorCode != DesignProfilerRequestResult.OK || getDesignHeightsResult.designHeights == null)
{
string errorMessage;
if (getDesignHeightsResult.errorCode == DesignProfilerRequestResult.NoElevationsInRequestedPatch)
{
errorMessage = "StationOffset Report. Call to RequestDesignElevationPatch failed due to no elevations in requested patch.";
Log.LogInformation(errorMessage);
}
else
{
errorMessage = $"StationOffset Report. Call to RequestDesignElevationPatch failed due to no TDesignProfilerRequestResult return code {getDesignHeightsResult.errorCode}.";
Log.LogWarning(errorMessage);
}
}
}
if (cell.PassCount == 0) // Nothing for us to do, as cell is not in our areaControlSet...
{
return(result);
}
result.Elevation = requestArgument.ReportElevation ? cell.Height : Consts.NullHeight;
result.CutFill = (requestArgument.ReportCutFill && (getDesignHeightsResult.designHeights != null) &&
getDesignHeightsResult.designHeights.Cells[cellX, cellY] != Consts.NullHeight)
? cell.Height - getDesignHeightsResult.designHeights.Cells[cellX, cellY]
: Consts.NullHeight;
// CCV is equiv to CMV in this instance
result.Cmv = (short)(requestArgument.ReportCmv ? cell.LastPassValidCCV : CellPassConsts.NullCCV);
result.Mdp = (short)(requestArgument.ReportMdp ? cell.LastPassValidMDP : CellPassConsts.NullMDP);
result.PassCount = (short)(requestArgument.ReportPassCount ? cell.PassCount : CellPassConsts.NullPassCountValue);
result.Temperature = (short)(requestArgument.ReportTemperature ? cell.LastPassValidTemperature : CellPassConsts.NullMaterialTemperatureValue);
return(result);
}
public void LoadOffsetsMultiOffset_Successful()
{
double station1 = 1;
var stationOffsetRow1 = new StationOffsetRow(
station1, -1, 1.0, 2.0, 3.0,
4.0, 5, 6, 7, 8
);
var stationOffsetRow2 = new StationOffsetRow(
station1, 5, 1.2, 2.2, 3.2,
4.2, 1, 2, 3, 4
);
var stationOffsetRows = new List <StationOffsetRow>()
{
stationOffsetRow1, stationOffsetRow2
};
var stationOffsetDataRowManual = new StationOffsetReportDataRow_ApplicationService
(station1, stationOffsetRows);
StationOffsetReportDataRow_ApplicationService stationOffsetDataRowAuto = null;
var queryStations = from stationOffsetRow in stationOffsetRows
group stationOffsetRow by stationOffsetRow.Station
into newGroup
orderby newGroup.Key
select newGroup;
Assert.Single(queryStations);
foreach (var stationGroup in queryStations)
{
Assert.Equal(stationOffsetRow1.Station, stationGroup.Key);
Assert.Equal(2, stationGroup.Count());
stationOffsetDataRowAuto = new StationOffsetReportDataRow_ApplicationService
(stationGroup.Key, stationGroup.ToList());
}
Assert.Equal(stationOffsetDataRowManual.Station, stationOffsetDataRowAuto.Station);
Assert.Equal(stationOffsetDataRowManual.Offsets.Count, stationOffsetDataRowAuto.Offsets.Count);
Assert.Equal(stationOffsetDataRowManual.Offsets[0].Offset, stationOffsetDataRowAuto.Offsets[0].Offset);
Assert.Equal(stationOffsetDataRowManual.Offsets[0].Northing, stationOffsetDataRowAuto.Offsets[0].Northing);
Assert.Equal(stationOffsetDataRowManual.Minimum.CutFill, stationOffsetDataRowAuto.Minimum.CutFill);
Assert.Equal(stationOffsetDataRowManual.Maximum.Elevation, stationOffsetDataRowAuto.Maximum.Elevation);
}
public void Constructor_should_return_fully_populated_object()
{
var stationOffset = new TStationOffset
{
Northing = 12.34,
Easting = 56.78,
Elevation = 90.12,
CutFill = 34.56,
CMV = 78,
MDP = 90,
PassCount = 12345,
Temperature = 21.43,
Position = 54.65,
Station = 87.09
};
var request = CompactionReportStationOffsetRequest.CreateRequest(
0, null, null, 0, null, true, true, true, true, true, true, null, null, 0, 0, 0, null, null, null
);
var result = StationOffsetRow.CreateRow(stationOffset, request);
Assert.AreEqual(stationOffset.Northing, result.Northing);
Assert.AreEqual(stationOffset.Easting, result.Easting);
Assert.AreEqual(stationOffset.Elevation, result.Elevation);
Assert.AreEqual(stationOffset.CutFill, result.CutFill);
Assert.AreEqual((double)stationOffset.CMV / 10, result.CMV);
Assert.AreEqual((double)stationOffset.MDP / 10, result.MDP);
Assert.AreEqual(stationOffset.PassCount, result.PassCount);
Assert.AreEqual(stationOffset.Temperature / 10, result.Temperature);
Assert.AreEqual(stationOffset.Position, result.Offset);
Assert.AreEqual(stationOffset.Station, result.Station);
Assert.IsTrue(result.ElevationReport);
Assert.IsTrue(result.CutFillReport);
Assert.IsTrue(result.CMVReport);
Assert.IsTrue(result.MDPReport);
Assert.IsTrue(result.PassCountReport);
Assert.IsTrue(result.TemperatureReport);
}
public void LoadOffsetsMultiStationsStatistics_Successful()
{
double station1 = 10;
var stationOffsetRowStation1_1 = new StationOffsetRow(
station1, -1, 1.0, 2.0, 3.0,
4.0, 5, 6, 7, 8
);
var stationOffsetRowStation1_2 = new StationOffsetRow(
station1, 5, 1.2, 2.2, 3.2,
3.6, 1, 2, 3, 4
);
double station2 = 20;
var stationOffsetRowStation2_1 = new StationOffsetRow(
station2, -1, 1.0, 2.0, 3.0,
4.0, 5, 6, 7, 8
);
var stationOffsetRowStation2_2 = new StationOffsetRow(
station2, 5, 1.2, 2.2, 3.2,
4.2, 1, 2, 3, 4
);
var stationOffsetRows = new List <StationOffsetRow>()
{
stationOffsetRowStation1_1, stationOffsetRowStation1_2,
stationOffsetRowStation2_1, stationOffsetRowStation2_2
};
Assert.Equal(4, stationOffsetRows.Count);
var stationOffsetResponse = new StationOffsetReportRequestResponse_ApplicationService()
{
};
stationOffsetResponse.LoadStationOffsets(stationOffsetRows);
Assert.Equal(2, stationOffsetResponse.StationOffsetReportDataRowList.Count);
var retrievedStation1 = stationOffsetResponse.StationOffsetReportDataRowList.Where(x => x.Station == station1).First();
Assert.Equal(0, retrievedStation1.Minimum.Northing);
Assert.Equal(0, retrievedStation1.Minimum.Easting);
Assert.Equal(stationOffsetRowStation1_1.Elevation, retrievedStation1.Minimum.Elevation);
Assert.Equal(stationOffsetRowStation1_2.CutFill, retrievedStation1.Minimum.CutFill);
Assert.Equal(stationOffsetRowStation1_2.Cmv, retrievedStation1.Minimum.Cmv);
Assert.Equal(stationOffsetRowStation1_2.Mdp, retrievedStation1.Minimum.Mdp);
Assert.Equal(stationOffsetRowStation1_2.PassCount, retrievedStation1.Minimum.PassCount);
Assert.Equal(stationOffsetRowStation1_2.Temperature, retrievedStation1.Minimum.Temperature);
Assert.Equal(0, retrievedStation1.Maximum.Northing);
Assert.Equal(0, retrievedStation1.Maximum.Easting);
Assert.Equal(stationOffsetRowStation1_2.Elevation, retrievedStation1.Maximum.Elevation);
Assert.Equal(stationOffsetRowStation1_1.CutFill, retrievedStation1.Maximum.CutFill);
Assert.Equal(stationOffsetRowStation1_1.Cmv, retrievedStation1.Maximum.Cmv);
Assert.Equal(stationOffsetRowStation1_1.Mdp, retrievedStation1.Maximum.Mdp);
Assert.Equal(stationOffsetRowStation1_1.PassCount, retrievedStation1.Maximum.PassCount);
Assert.Equal(stationOffsetRowStation1_1.Temperature, retrievedStation1.Maximum.Temperature);
Assert.Equal(0, retrievedStation1.Average.Northing);
Assert.Equal(0, retrievedStation1.Average.Easting);
Assert.Equal(3.1, retrievedStation1.Average.Elevation);
Assert.Equal(3.8, retrievedStation1.Average.CutFill);
Assert.Equal(3, retrievedStation1.Average.Cmv);
Assert.Equal(4, retrievedStation1.Average.Mdp);
Assert.Equal(5, retrievedStation1.Average.PassCount);
Assert.Equal(6, retrievedStation1.Average.Temperature);
}
