public void PD_PostProfileProductionDataFailed()
{
ProfileProductionDataRequest request = CreateRequest();
MemoryStream raptorResult = null;
Assert.IsTrue(RaptorConverters.DesignDescriptor(request.AlignmentDesign).IsNull(), "A linear profile expected.");
ProfilesHelper.ConvertProfileEndPositions(request.GridPoints, request.WGS84Points, out TWGS84Point startPt, out var endPt, out bool positionsAreGrid);
TASNodeServiceRPCVerb_RequestProfile_Args args
= __Global.Construct_RequestProfile_Args
(request.ProjectId.Value,
-1, // don't care
positionsAreGrid,
startPt,
endPt,
RaptorConverters.ConvertFilter(request.Filter),
RaptorConverters.ConvertLift(request.LiftBuildSettings, TFilterLayerMethod.flmAutomatic),
RaptorConverters.DesignDescriptor(request.AlignmentDesign),
request.ReturnAllPassesAndLayers);
// Create the mock PDSClient with successful result...
var mockRaptorClient = new Mock <IASNodeClient>();
var mockLogger = new Mock <ILoggerFactory>();
var mockConfigStore = new Mock <IConfigurationStore>();
mockRaptorClient.Setup(prj => prj.GetProfile(It.IsAny <TASNodeServiceRPCVerb_RequestProfile_Args>() /*args*/)).Returns(raptorResult);
// Create an executor...
var executor = RequestExecutorContainerFactory.Build <ProfileProductionDataExecutor>(mockLogger.Object, mockRaptorClient.Object, configStore: mockConfigStore.Object);
Assert.ThrowsExceptionAsync <ServiceException>(async() => await executor.ProcessAsync(request));
}
public void CompactionReportStationOffsetExecutor_Raptor_NoResult()
{
var userPreferences = new UserPreferenceData {
Language = "en-US"
};
var request = CompactionReportStationOffsetRequest.CreateRequest(
33, null, null, 0, null, true, true, true, true, true, true, null, null, 0, 0, 0, null, userPreferences, "New Zealand Standard Time");
var filterSettings = RaptorConverters.ConvertFilter(request.Filter);
var cutfillDesignDescriptor = RaptorConverters.DesignDescriptor(request.DesignFile);
var alignmentDescriptor = RaptorConverters.DesignDescriptor(request.AlignmentFile);
var TASNodeUserPreference = ExportRequestHelper.ConvertToRaptorUserPreferences(request.UserPreferences, request.ProjectTimezone);
var options = RaptorConverters.convertOptions(null, request.LiftBuildSettings, 0,
request.Filter?.LayerType ?? FilterLayerMethod.None, DisplayMode.Height, false);
var mockConfigStore = new Mock <IConfigurationStore>();
mockConfigStore.Setup(x => x.GetValueBool("ENABLE_TREX_GATEWAY_STATIONOFFSET")).Returns(false);
MemoryStream responseData;
var raptorClient = new Mock <IASNodeClient>();
var args = ASNode.StationOffsetReport.RPC.__Global.Construct_StationOffsetReport_Args(
request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
(int)CompactionReportType.StationOffset,
ASNodeRPC.__Global.Construct_TASNodeRequestDescriptor(Guid.NewGuid(), 0,
TASNodeCancellationDescriptorType.cdtProdDataReport),
TASNodeUserPreference,
alignmentDescriptor,
cutfillDesignDescriptor,
request.StartStation,
request.EndStation,
request.Offsets,
request.CrossSectionInterval,
request.ReportElevation,
request.ReportCutFill,
request.ReportCMV,
request.ReportMDP,
request.ReportPassCount,
request.ReportTemperature,
(int)GridReportOption.Unused,
0, 0, 0, 0, 0, 0, 0, // Northings, Eastings and Direction values are not used on Station Offset report.
filterSettings,
RaptorConverters.ConvertLift(request.LiftBuildSettings, filterSettings.LayerMethod),
options
);
raptorClient.Setup(x => x.GetReportStationOffset(args, out responseData)).Returns(0); // icsrrUnknownError
var executor = RequestExecutorContainerFactory
.Build <CompactionReportStationOffsetExecutor>(_logger, raptorClient.Object, configStore: mockConfigStore.Object);
Assert.ThrowsExceptionAsync <ServiceException>(async() => await executor.ProcessAsync(request));
}
protected override async Task <ContractExecutionResult> ProcessAsyncEx <T>(T item)
{
try
{
var request = CastRequestObjectTo <CutFillDetailsRequest>(item);
#if RAPTOR
if (UseTRexGateway("ENABLE_TREX_GATEWAY_CUTFILL"))
{
#endif
var trexRequest = new TRexCutFillDetailsRequest(
request.ProjectUid.Value,
request.CutFillTolerances,
request.Filter,
request.DesignDescriptor,
AutoMapperUtility.Automapper.Map <OverridingTargets>(request.LiftBuildSettings),
AutoMapperUtility.Automapper.Map <LiftSettings>(request.LiftBuildSettings));
return(await trexCompactionDataProxy.SendDataPostRequest <CompactionCutFillDetailedResult, TRexCutFillDetailsRequest>(trexRequest, "/cutfill/details", customHeaders));
#if RAPTOR
}
var filter = RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient);
var designDescriptor = RaptorConverters.DesignDescriptor(request.DesignDescriptor);
var liftBuildSettings =
RaptorConverters.ConvertLift(request.LiftBuildSettings, TFilterLayerMethod.flmNone);
var raptorResult = raptorClient.GetCutFillDetails(request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
ASNodeRPC.__Global.Construct_TASNodeRequestDescriptor(Guid.NewGuid(), 0, TASNodeCancellationDescriptorType.cdtCutfillDetailed),
new TCutFillSettings
{
Offsets = request.CutFillTolerances,
DesignDescriptor = designDescriptor
}
,
filter,
liftBuildSettings,
out var cutFillDetails);
if (raptorResult == TASNodeErrorStatus.asneOK)
{
return(new CompactionCutFillDetailedResult(cutFillDetails.Percents));
}
throw CreateServiceException <CompactionCutFillExecutor>((int)raptorResult);
#endif
}
finally
{
ContractExecutionStates.ClearDynamic();
}
}
private CompactionProfileResult <CompactionProfileCell> ProcessProductionDataWithRaptor(
CompactionProfileProductionDataRequest request)
{
MemoryStream memoryStream;
var filter = RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient);
var designDescriptor = RaptorConverters.DesignDescriptor(request.CutFillDesignDescriptor);
var alignmentDescriptor = RaptorConverters.DesignDescriptor(request.AlignmentDesign);
var liftBuildSettings =
RaptorConverters.ConvertLift(request.LiftBuildSettings, TFilterLayerMethod.flmNone);
ProfilesHelper.ConvertProfileEndPositions(request.GridPoints, request.WGS84Points, out var startPt, out var endPt,
out var positionsAreGrid);
if (request.IsAlignmentDesign)
{
var args
= ASNode.RequestAlignmentProfile.RPC.__Global.Construct_RequestAlignmentProfile_Args
(request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
ProfilesHelper.PROFILE_TYPE_NOT_REQUIRED,
request.StartStation ?? ValidationConstants3D.MIN_STATION,
request.EndStation ?? ValidationConstants3D.MIN_STATION,
alignmentDescriptor,
filter,
liftBuildSettings,
designDescriptor,
request.ReturnAllPassesAndLayers);
memoryStream = raptorClient.GetAlignmentProfile(args);
}
else
{
var args
= ASNode.RequestProfile.RPC.__Global.Construct_RequestProfile_Args
(request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
ProfilesHelper.PROFILE_TYPE_HEIGHT,
positionsAreGrid,
startPt,
endPt,
filter,
liftBuildSettings,
designDescriptor,
request.ReturnAllPassesAndLayers);
memoryStream = raptorClient.GetProfile(args);
}
return(memoryStream != null?ConvertProfileResult(memoryStream, request.LiftBuildSettings) : null);
}
private ContractExecutionResult ProcessWithRaptor(CompactionReportStationOffsetRequest request)
{
var filterSettings = RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient);
var cutfillDesignDescriptor = RaptorConverters.DesignDescriptor(request.DesignFile);
var alignmentDescriptor = RaptorConverters.DesignDescriptor(request.AlignmentFile);
var userPreferences =
ExportRequestHelper.ConvertToRaptorUserPreferences(request.UserPreferences, request.ProjectTimezone);
var options = RaptorConverters.convertOptions(null, request.LiftBuildSettings, 0,
request.Filter?.LayerType ?? FilterLayerMethod.None, DisplayMode.Height, false);
log.LogDebug($"{nameof(ProcessWithRaptor)}: About to call GetReportStationOffset");
var args = ASNode.StationOffsetReport.RPC.__Global.Construct_StationOffsetReport_Args(
request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
(int)CompactionReportType.StationOffset,
ASNodeRPC.__Global.Construct_TASNodeRequestDescriptor(Guid.NewGuid(), 0,
TASNodeCancellationDescriptorType.cdtProdDataReport),
userPreferences,
alignmentDescriptor,
cutfillDesignDescriptor,
request.StartStation,
request.EndStation,
request.Offsets,
request.CrossSectionInterval,
request.ReportElevation,
request.ReportCutFill,
request.ReportCMV,
request.ReportMDP,
request.ReportPassCount,
request.ReportTemperature,
(int)GridReportOption.Unused,
0, 0, 0, 0, 0, 0, 0, // Northings, Eastings and Direction values are not used on Station Offset report.
filterSettings,
RaptorConverters.ConvertLift(request.LiftBuildSettings, filterSettings.LayerMethod),
options
);
int raptorResult = raptorClient.GetReportStationOffset(args, out var responseData);
if (raptorResult == 1) // icsrrNoError
{
return(responseData.Length > 0
? ConvertStationOffsetResult(request, responseData)
: CreateNullStationOffsetReturnedResult());
}
throw CreateServiceException <CompactionReportStationOffsetExecutor>();
}
/// <summary>
/// Sends a POST request to Production Data Server (PDS) client.
/// </summary>
/// <param name="item">POST request description.</param>
/// <param name="surveyedSurfaces">Returned list of Surveyed Surfaces.</param>
/// <returns>True if the processed request from PDS was successful, false - otherwise.</returns>
protected override bool SendRequestToPdsClient(object item, out TSurveyedSurfaceDetails[] surveyedSurfaces)
{
var request = CastRequestObjectTo <SurveyedSurfaceRequest>(item);
surveyedSurfaces = null;
var args = ASNode.GroundSurface.RPC.__Global
.Construct_GroundSurface_Args(
request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
request.SurveyedSurface.Id,
request.SurveyedUtc,
RaptorConverters.DesignDescriptor(request.SurveyedSurface)
);
return(raptorClient.StoreGroundSurfaceFile(args));
}
protected virtual bool GetCellDatumData(CellDatumRequest request, out TCellProductionData data)
{
var raptorFilter = RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient);
return(raptorClient.GetCellProductionData
(request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
(int)RaptorConverters.convertDisplayMode(request.DisplayMode),
request.GridPoint?.x ?? 0,
request.GridPoint?.y ?? 0,
request.LLPoint != null ? RaptorConverters.ConvertWGSPoint(request.LLPoint) : new TWGS84Point(),
request.LLPoint == null,
raptorFilter,
RaptorConverters.ConvertLift(request.LiftBuildSettings, raptorFilter.LayerMethod),
RaptorConverters.DesignDescriptor(request.Design),
out data));
}
private ProfileResult PerformProductionDataProfilePost(ProfileProductionDataRequest request)
{
MemoryStream memoryStream;
if (request.IsAlignmentDesign)
{
var args = ASNode.RequestAlignmentProfile.RPC.__Global.Construct_RequestAlignmentProfile_Args(
request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
ProfilesHelper.PROFILE_TYPE_NOT_REQUIRED,
request.StartStation ?? ValidationConstants3D.MIN_STATION,
request.EndStation ?? ValidationConstants3D.MIN_STATION,
RaptorConverters.DesignDescriptor(request.AlignmentDesign),
RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient),
RaptorConverters.ConvertLift(request.LiftBuildSettings, TFilterLayerMethod.flmAutomatic),
RaptorConverters.DesignDescriptor(request.AlignmentDesign),
request.ReturnAllPassesAndLayers);
memoryStream = raptorClient.GetAlignmentProfile(args);
}
else
{
ProfilesHelper.ConvertProfileEndPositions(
request.GridPoints,
request.WGS84Points,
out VLPDDecls.TWGS84Point startPt,
out VLPDDecls.TWGS84Point endPt,
out bool positionsAreGrid);
var args = ASNode.RequestProfile.RPC.__Global.Construct_RequestProfile_Args(
request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
ProfilesHelper.PROFILE_TYPE_NOT_REQUIRED,
positionsAreGrid,
startPt,
endPt,
RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient),
RaptorConverters.ConvertLift(request.LiftBuildSettings, TFilterLayerMethod.flmAutomatic),
RaptorConverters.DesignDescriptor(request.AlignmentDesign),
request.ReturnAllPassesAndLayers);
memoryStream = raptorClient.GetProfile(args);
}
return(memoryStream != null
? ConvertProfileResult(memoryStream, request.CallId ?? Guid.NewGuid())
: null); // TODO: return appropriate result
}
/// <summary>
/// Get the station range for the alignment file
/// </summary>
/// <param name="project"></param>
/// <param name="alignDescriptor"></param>
/// <param name="customHeaders"></param>
/// <returns>The station range</returns>
public async Task <AlignmentStationRangeResult> GetAlignmentStationRange(ProjectData project, DesignDescriptor alignDescriptor, IHeaderDictionary customHeaders)
{
if (alignDescriptor == null)
{
throw new ServiceException(HttpStatusCode.BadRequest, new ContractExecutionResult(
ContractExecutionStatesEnum.FailedToGetResults,
"Invalid request - Missing alignment file"));
}
//AlignmentStationResult result = null;
var description = TileServiceUtils.DesignDescriptionForLogging(alignDescriptor);
log.LogDebug($"{nameof(GetAlignmentStationRange)}: projectUid={project.ProjectUID}, projectId={project.ShortRaptorProjectId}, alignment={description}");
//Get the station extents
#if RAPTOR
if (UseTRexGateway("ENABLE_TREX_GATEWAY_DESIGN_BOUNDARY"))
{
#endif
var queryParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("projectUid", project.ProjectUID.ToString()),
new KeyValuePair <string, string>("designUid", alignDescriptor.FileUid.ToString())
}
;
return(await tRexCompactionDataProxy.SendDataGetRequest <AlignmentStationRangeResult>(project.ProjectUID.ToString(), "/design/alignment/stationrange", customHeaders, queryParams));
#if RAPTOR
}
var alignmentDescriptor = RaptorConverters.DesignDescriptor(alignDescriptor);
var success = raptorClient.GetStationExtents(project.LegacyProjectId, alignmentDescriptor,
out double startStation, out double endStation);
if (success)
{
return(new AlignmentStationRangeResult(startStation, endStation));
}
#endif
throw new ServiceException(HttpStatusCode.BadRequest, new ContractExecutionResult(
ContractExecutionStatesEnum.FailedToGetResults,
$"Failed to get station range for alignment file: {alignDescriptor.File.FileName}"));
}
private ContractExecutionResult ProcessWithRaptor(CompactionReportGridRequest request)
{
var raptorFilter = RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient);
var options = RaptorConverters.convertOptions(null, request.LiftBuildSettings, 0,
request.Filter?.LayerType ?? FilterLayerMethod.None, DisplayMode.Height, false);
log.LogDebug($"{nameof(ProcessWithRaptor)}: About to call GetReportGrid");
var args = ASNode.GridReport.RPC.__Global.Construct_GridReport_Args(
request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
(int)CompactionReportType.Grid,
ASNodeRPC.__Global.Construct_TASNodeRequestDescriptor(Guid.NewGuid(), 0,
TASNodeCancellationDescriptorType.cdtProdDataReport),
RaptorConverters.DesignDescriptor(request.DesignFile),
request.GridInterval,
request.ReportElevation,
request.ReportCutFill,
request.ReportCMV,
request.ReportMDP,
request.ReportPassCount,
request.ReportTemperature,
(int)request.GridReportOption,
request.StartNorthing,
request.StartEasting,
request.EndNorthing,
request.EndEasting,
request.Azimuth,
raptorFilter,
RaptorConverters.ConvertLift(request.LiftBuildSettings, raptorFilter.LayerMethod),
options
);
int raptorResult = raptorClient.GetReportGrid(args, out var responseData);
if (raptorResult == 1) // icsrrNoError
{
return(responseData.Length > 0
? ConvertGridResult(request, responseData)
: CreateNullGridReturnedResult());
}
throw CreateServiceException <CompactionReportGridExecutor>();
}
private CompactionProfileResult <CompactionProfileVertex> PerformProductionDataProfilePost(CompactionProfileDesignRequest request)
{
CompactionProfileResult <CompactionProfileVertex> result;
try
{
ProfilesHelper.ConvertProfileEndPositions(request.GridPoints, request.WGS84Points, out TWGS84Point startPt, out TWGS84Point endPt, out bool positionsAreGrid);
var designProfile = DesignProfiler.ComputeProfile.RPC.__Global.Construct_CalculateDesignProfile_Args(
request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
false,
startPt,
endPt,
ValidationConstants3D.MIN_STATION,
ValidationConstants3D.MAX_STATION,
RaptorConverters.DesignDescriptor(request.DesignDescriptor),
RaptorConverters.EmptyDesignDescriptor,
RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient),
positionsAreGrid);
var memoryStream = raptorClient.GetDesignProfile(designProfile);
if (memoryStream != null)
{
result = ConvertProfileResult(memoryStream);
memoryStream.Close();
}
else
{
//For convenience return empty list rather than null for easier manipulation
result = new CompactionProfileResult <CompactionProfileVertex> {
results = new List <CompactionProfileVertex>()
};
}
}
finally
{
ContractExecutionStates.ClearDynamic();
}
return(result);
}
protected override async Task <ContractExecutionResult> ProcessAsyncEx <T>(T item)
{
try
{
var request = CastRequestObjectTo <ProjectFileDescriptor>(item);
var zoomResult = new ZoomRangeResult();
var fileType = request.FileType;
log.LogDebug($"FileType is: {fileType}");
//Tell Raptor to update its cache.
//Note: surveyed surface file names are the TCC one including the surveyed UTC in the file name
if (fileType == ImportedFileType.Alignment ||
fileType == ImportedFileType.DesignSurface ||
fileType == ImportedFileType.SurveyedSurface)
{
log.LogDebug("Updating Raptor design cache");
var result1 = raptorClient.UpdateCacheWithDesign(request.ProjectId.Value, request.File.FileName, 0, false);
if (result1 != TDesignProfilerRequestResult.dppiOK)
{
throw new ServiceException(HttpStatusCode.BadRequest, new ContractExecutionResult(
ContractExecutionStatesEnum.FailedToGetResults,
$"Failed to update Raptor design cache with error: {ContractExecutionStates.FirstNameWithOffset((int) result1)}"));
}
}
switch (fileType)
{
case ImportedFileType.Linework:
//case ImportedFileType.DesignSurface:
case ImportedFileType.Alignment:
var suffix = FileUtils.GeneratedFileSuffix(fileType);
//Get PRJ file contents from Raptor
log.LogDebug($"Getting projection file from Raptor for file {request.File.FileName}");
var dxfUnitsType = fileType == ImportedFileType.Linework
? (TVLPDDistanceUnits)request.DXFUnitsType
: TVLPDDistanceUnits.vduMeters; //always metric for design surface and alignment as we generate the DXF file.
log.LogDebug($"Units selected {dxfUnitsType}");
var result2 = raptorClient.GetCoordinateSystemProjectionFile(request.ProjectId.Value,
dxfUnitsType, out string prjFile);
if (result2 != TASNodeErrorStatus.asneOK)
{
//We need gracefully fail here as the file may be imported to an empty datamodel
log.LogWarning("Failed to get requested " + FileUtils.PROJECTION_FILE_EXTENSION + " file with error: {0}.",
ContractExecutionStates.FirstNameWithOffset((int)result2));
return(new AddFileResult(ContractExecutionStatesEnum.ExecutedSuccessfully, "Add file notification partially successful - no tiles can be generated")
{
MinZoomLevel = 0,
MaxZoomLevel = 0,
FileUid = request.FileUid,
FileDescriptor = request.File,
UserEmailAddress = request.UserEmailAddress
});
/*throw new ServiceException(HttpStatusCode.BadRequest, new ContractExecutionResult(
* ContractExecutionStatesEnum.FailedToGetResults,
* string.Format("Failed to get requested " + FileUtils.PROJECTION_FILE_EXTENSION + " file with error: {0}.",
* ContractExecutionStates.FirstNameWithOffset((int)result2))));*/
}
//Note: Cannot have async void therefore bool result from method. However, failure handled inside method so ignore return value here.
await CreateTransformFile(request.ProjectId.Value, request.File, prjFile, suffix, FileUtils.PROJECTION_FILE_EXTENSION);
//Get GM_XFORM file contents from Raptor
log.LogDebug("Getting horizontal adjustment file from Raptor");
var result3 = raptorClient.GetCoordinateSystemHorizontalAdjustmentFile(request.CoordSystemFileName,
request.ProjectId.Value, dxfUnitsType, out string haFile);
if (result3 != TASNodeErrorStatus.asneOK)
{
log.LogWarning("Failed to get requested " + FileUtils.HORIZONTAL_ADJUSTMENT_FILE_EXTENSION + $" file with error: {ContractExecutionStates.FirstNameWithOffset((int) result2)}.");
return(new AddFileResult(ContractExecutionStatesEnum.ExecutedSuccessfully, "Add file notification partially successful. Can not create horizontal adjustment - no tiles can be generated")
{
MinZoomLevel = 0,
MaxZoomLevel = 0,
FileUid = request.FileUid,
FileDescriptor = request.File,
UserEmailAddress = request.UserEmailAddress
});
/* throw new ServiceException(HttpStatusCode.BadRequest, new ContractExecutionResult(
* ContractExecutionStatesEnum.FailedToGetResults,
* string.Format(
* "Failed to get requested " + FileUtils.HORIZONTAL_ADJUSTMENT_FILE_EXTENSION + " file with error: {0}.",
* ContractExecutionStates.FirstNameWithOffset((int)result2))));*/
}
//An empty string means there is no horizontal adjustment in coordinate system so no file to create
if (haFile != string.Empty)
{
await CreateTransformFile(request.ProjectId.Value, request.File, haFile, suffix,
FileUtils.HORIZONTAL_ADJUSTMENT_FILE_EXTENSION);
}
if (fileType != ImportedFileType.Linework)
{
log.LogDebug($"Creating DXF file with Units selected {request.DXFUnitsType}");
//Get alignment or surface boundary as DXF file from Raptor
if (!await CreateDxfFile(request.ProjectId.Value, request.File, suffix, request.DXFUnitsType))
{
//We need gracefully fail here as the file may be imported to an empty datamodel
log.LogWarning("Failed to get requested " + FileUtils.DXF_FILE_EXTENSION);
return(new AddFileResult(ContractExecutionStatesEnum.ExecutedSuccessfully, "Add file notification partially successful. Can not create DXF - no tiles can be generated")
{
MinZoomLevel = 0,
MaxZoomLevel = 0,
FileUid = request.FileUid,
FileDescriptor = request.File,
UserEmailAddress = request.UserEmailAddress
});
}
}
//Calculate the zoom range
string generatedName = FileUtils.GeneratedFileName(request.File.FileName, suffix, FileUtils.DXF_FILE_EXTENSION);
var fullGeneratedName = $"{request.File.Path}/{generatedName}";
zoomResult = await tileGenerator.CalculateTileZoomRange(request.File.FilespaceId, fullGeneratedName).ConfigureAwait(false);
//Generate DXF tiles
await tileGenerator.CreateDxfTiles(request.ProjectId.Value, request.File, suffix, zoomResult, false).ConfigureAwait(false);
break;
case ImportedFileType.SurveyedSurface:
log.LogDebug("Storing ground surface file in Raptor");
var dd = new DesignDescriptor(request.FileId, request.File, 0.0);
var args = ASNode.GroundSurface.RPC.__Global
.Construct_GroundSurface_Args(
request.ProjectId.Value,
request.FileId,
FileUtils.SurveyedSurfaceUtc(request.File.FileName).Value,
RaptorConverters.DesignDescriptor(dd)
);
if (!raptorClient.StoreGroundSurfaceFile(args))
{
throw new ServiceException(HttpStatusCode.BadRequest,
new ContractExecutionResult(ContractExecutionStatesEnum.InternalProcessingError,
"Failed to store ground surface file"));
}
break;
}
return(new AddFileResult(ContractExecutionStatesEnum.ExecutedSuccessfully, "Add file notification successful")
{
MinZoomLevel = zoomResult.minZoom,
MaxZoomLevel = zoomResult.maxZoom,
FileUid = request.FileUid,
FileDescriptor = request.File,
UserEmailAddress = request.UserEmailAddress
});
}
finally
{
ContractExecutionStates.ClearDynamic();
}
}
private CompactionProfileResult <CompactionSummaryVolumesProfileCell> ProcessSummaryVolumesWithRaptor(CompactionProfileProductionDataRequest request)
{
var alignmentDescriptor = RaptorConverters.DesignDescriptor(request.AlignmentDesign);
var liftBuildSettings =
RaptorConverters.ConvertLift(request.LiftBuildSettings, TFilterLayerMethod.flmNone);
var baseFilter = RaptorConverters.ConvertFilter(request.BaseFilter, request.ProjectId, raptorClient);
var topFilter = RaptorConverters.ConvertFilter(request.TopFilter, request.ProjectId, raptorClient);
var volumeDesignDescriptor = RaptorConverters.DesignDescriptor(request.VolumeDesignDescriptor);
ProfilesHelper.ConvertProfileEndPositions(request.GridPoints, request.WGS84Points, out var startPt, out var endPt,
out var positionsAreGrid);
if (request.VolumeCalcType.HasValue && request.VolumeCalcType.Value != VolumeCalcType.None)
{
var volCalcType = (TComputeICVolumesType)request.VolumeCalcType.Value;
if (volCalcType == TComputeICVolumesType.ic_cvtBetween2Filters && !request.ExplicitFilters)
{
RaptorConverters.AdjustFilterToFilter(ref baseFilter, topFilter);
}
MemoryStream memoryStream;
if (request.IsAlignmentDesign)
{
var args
= ASNode.RequestSummaryVolumesAlignmentProfile.RPC.__Global
.Construct_RequestSummaryVolumesAlignmentProfile_Args
(request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
ProfilesHelper.PROFILE_TYPE_NOT_REQUIRED,
volCalcType,
request.StartStation ?? ValidationConstants3D.MIN_STATION,
request.EndStation ?? ValidationConstants3D.MIN_STATION,
alignmentDescriptor,
baseFilter,
topFilter,
liftBuildSettings,
volumeDesignDescriptor);
memoryStream = raptorClient.GetSummaryVolumesAlignmentProfile(args);
}
else
{
var args
= ASNode.RequestSummaryVolumesProfile.RPC.__Global.Construct_RequestSummaryVolumesProfile_Args(
request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID,
ProfilesHelper.PROFILE_TYPE_HEIGHT,
volCalcType,
startPt,
endPt,
positionsAreGrid,
baseFilter,
topFilter,
liftBuildSettings,
volumeDesignDescriptor);
memoryStream = raptorClient.GetSummaryVolumesProfile(args);
}
return(memoryStream != null?ConvertSummaryVolumesProfileResult(memoryStream, request.VolumeCalcType.Value) : null);
}
return(null);
}
/// <summary>
/// Gets the list of points making up the alignment boundary.
/// If the start & end station and left & right offsets are zero,
/// then gets the centerline of the alignment.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="alignDescriptor">Design descriptor for the alignment file</param>
/// <param name="startStation">Start station for the alignment file boundary</param>
/// <param name="endStation">End station for the alignment file boundary</param>
/// <param name="leftOffset">Left offset for the alignment file boundary</param>
/// <param name="rightOffset">Right offset for the alignment file boundary</param>
/// <param name="customHeaders"></param>
/// <returns>A list of latitude/longitude points in degrees</returns>
public async Task <IEnumerable <WGSPoint> > GetAlignmentPoints(ProjectData project, DesignDescriptor alignDescriptor,
double startStation = 0, double endStation = 0, double leftOffset = 0, double rightOffset = 0, IHeaderDictionary customHeaders = null)
{
var description = TileServiceUtils.DesignDescriptionForLogging(alignDescriptor);
log.LogDebug($"{nameof(GetAlignmentPoints)}: projectUid={project.ProjectUID}, projectId={project.ShortRaptorProjectId}, alignment={description}");
List <WGSPoint> alignmentPoints = null;
if (alignDescriptor != null)
{
bool success = true;
bool isCenterline = startStation == 0 && endStation == 0 &&
leftOffset == 0 && rightOffset == 0;
if (isCenterline)
{
try
{
var stationRange = await GetAlignmentStationRange(project, alignDescriptor, customHeaders);
startStation = stationRange.StartStation;
endStation = stationRange.EndStation;
}
catch
{
success = false;
}
}
if (success)
{
log.LogDebug($"{nameof(GetAlignmentPoints)}: projectId={project.ShortRaptorProjectId}, station range={startStation}-{endStation}");
#if RAPTOR
if (UseTRexGateway("ENABLE_TREX_GATEWAY_DESIGN_BOUNDARY"))
#endif
return(await ProcessDesignFilterBoundaryWithTRex(project.ProjectUID.ToString(), alignDescriptor, customHeaders));
#if RAPTOR
var alignmentDescriptor = RaptorConverters.DesignDescriptor(alignDescriptor);
success = raptorClient.GetDesignFilterBoundaryAsPolygon(
DesignProfiler.ComputeDesignFilterBoundary.RPC.__Global.Construct_CalculateDesignFilterBoundary_Args(
project.LegacyProjectId,
alignmentDescriptor,
startStation, endStation, leftOffset, rightOffset,
DesignProfiler.ComputeDesignFilterBoundary.RPC.TDesignFilterBoundaryReturnType.dfbrtList), out TWGS84Point[] pdsPoints);
if (success && pdsPoints != null && pdsPoints.Length > 0)
{
log.LogDebug($"{nameof(GetAlignmentPoints)} success: projectId={project.LegacyProjectId}, number of points={pdsPoints.Length}");
alignmentPoints = new List <WGSPoint>();
//For centerline, we only need half the points as normally GetDesignFilterBoundaryAsPolygon
//has offsets so is returning a polygon.
//Since we have no offsets we have the centreline twice.
var count = isCenterline ? pdsPoints.Length / 2 : pdsPoints.Length;
for (var i = 0; i < count; i++)
{
alignmentPoints.Add(new WGSPoint(pdsPoints[i].Lat, pdsPoints[i].Lon));
}
}
#endif
}
}
return(alignmentPoints);
}
