Beispiel #1
0
        /// <summary>
        /// Processes the summary pass counts request by passing the request to Raptor and returning the result.
        /// </summary>
        protected override async Task <ContractExecutionResult> ProcessAsyncEx <T>(T item)
        {
            try
            {
                var request = CastRequestObjectTo <ExportReport>(item);
#if RAPTOR
                if (UseTRexGateway(configKeys[request.ExportType]))
                {
#endif
                var overrides    = AutoMapperUtility.Automapper.Map <OverridingTargets>(request.LiftBuildSettings);
                var liftSettings = AutoMapperUtility.Automapper.Map <LiftSettings>(request.LiftBuildSettings);

                switch (request.ExportType)
                {
                case ExportTypes.SurfaceExport:
                    var compactionSurfaceExportRequest =
                        new CompactionSurfaceExportRequest(request.ProjectUid.Value, request.Filter, request.Filename, request.Tolerance,
                                                           overrides, liftSettings);

                    log.LogInformation($"Calling TRex SendSurfaceExportRequest for projectUid: {request.ProjectUid}");
                    return(await trexCompactionDataProxy.SendDataPostRequest <CompactionExportResult, CompactionSurfaceExportRequest>(compactionSurfaceExportRequest, "/export/surface/ttm", customHeaders));

                case ExportTypes.VedaExport:
                default://to satisfy the compiler
                    var compactionVetaExportRequest =
                        new CompactionVetaExportRequest(request.ProjectUid.Value, request.Filter, request.Filename, request.CoordType, request.OutputType, request.UserPrefs,
                                                        request.MachineList.Select(m => m.MachineName).ToArray(), overrides, liftSettings);
                    //Note: this way of setting the machine name list is slightly different to the code in CompactionExportExecutor so we don't change the historical behaviour

                    log.LogInformation($"Calling TRex SendVetaExportRequest for projectUid: {request.ProjectUid}");
                    return(await trexCompactionDataProxy.SendDataPostRequest <CompactionExportResult, CompactionVetaExportRequest>(compactionVetaExportRequest, "/export/veta", customHeaders));

                case ExportTypes.PassCountExport:
                    var compactionPassCountExportRequest =
                        new CompactionPassCountExportRequest(request.ProjectUid.Value, request.Filter, request.Filename, request.CoordType,
                                                             request.OutputType, request.UserPrefs, request.RestrictSize, request.RawData, overrides, liftSettings);

                    log.LogInformation($"Calling TRex SendPassCountExportRequest for projectUid: {request.ProjectUid}");
                    return(await trexCompactionDataProxy.SendDataPostRequest <CompactionExportResult, CompactionPassCountExportRequest>(compactionPassCountExportRequest, "/export/passcount", customHeaders));
                }
  #if RAPTOR
            }
            log.LogInformation($"Calling Raptor ProcessWithRaptor for projectUid: {request.ProjectUid}");
            return(ProcessWithRaptor(request));
  #endif
            }
            finally
            {
                ContractExecutionStates.ClearDynamic();
            }
        }
Beispiel #2
0
        public async Task <CompactionExportResult> PostTINSurface([FromBody] CompactionSurfaceExportRequest compactionSurfaceExportRequest)
        {
            Log.LogInformation($"{nameof(PostTINSurface)}: {Request.QueryString}");

            Log.LogDebug($"Accept header is {Request.Headers[HeaderConstants.ACCEPT]}");

            compactionSurfaceExportRequest.Validate();
            ValidateFilterMachines(nameof(PostTINSurface), compactionSurfaceExportRequest.ProjectUid, compactionSurfaceExportRequest.Filter);

            var tinResult = await WithServiceExceptionTryExecuteAsync(() =>
                                                                      RequestExecutorContainer
                                                                      .Build <TINSurfaceExportExecutor>(ConfigStore, LoggerFactory, ServiceExceptionHandler)
                                                                      .ProcessAsync(compactionSurfaceExportRequest)) as TINSurfaceExportResult;

            if (tinResult?.TINData == null || tinResult?.Code != ContractExecutionStatesEnum.ExecutedSuccessfully)
            {
                return(new CompactionExportResult(tinResult.Code, tinResult.Message));
            }

            const string TTM_EXTENSION = ".ttm";
            const string ZIP_EXTENSION = ".zip";

            var fullFileName = BuildTINFilePath(compactionSurfaceExportRequest.FileName, ZIP_EXTENSION);

            if (FileSystem.Exists(fullFileName))
            {
                FileSystem.Delete(fullFileName);
            }

            using (var zipFile = ZipFile.Open(fullFileName, ZipArchiveMode.Create))
            {
                var entry = zipFile.CreateEntry(compactionSurfaceExportRequest.FileName + TTM_EXTENSION);
                using (var stream = entry.Open())
                    new MemoryStream(tinResult?.TINData).CopyTo(stream);
            }

            var s3FileTransfer = new S3FileTransfer(TransferProxyType.Temporary);

            s3FileTransfer.WriteFile(fullFileName, compactionSurfaceExportRequest.ProjectUid, out var url);
            if (FileSystem.Exists(fullFileName)) // remove temp file
            {
                FileSystem.Delete(fullFileName);
            }
            return(new CompactionExportResult(url));
        }