コード例 #1
0
        public async Task <SummaryVolumesResult> PostExportSummaryVolumesTbc([FromBody] SummaryVolumesRequest request)
        {
            _log.LogDebug($"{nameof(PostExportSummaryVolumesTbc)}: {JsonConvert.SerializeObject(request)}");

            request.Validate();
            return(await
                   RequestExecutorContainerFactory.Build <SummaryVolumesExecutor>(_logger,
#if RAPTOR
                                                                                  raptorClient,
#endif
                                                                                  configStore : configStore, trexCompactionDataProxy : tRexCompactionDataProxy,
                                                                                  fileImportProxy : FileImportProxy, customHeaders : CustomHeaders, userId : GetUserId())
                   .ProcessAsync(request) as
                   SummaryVolumesResult);
        }
コード例 #2
0
        public async Task <ActionResult <ContractExecutionResult> > GetSummaryVolumes(
            [FromServices] ISummaryDataHelper summaryDataHelper,
            [FromQuery] Guid projectUid,
            [FromQuery] Guid baseUid,
            [FromQuery] Guid topUid,
            [FromQuery] bool explicitFilters = false)
        {
            Log.LogInformation($"{nameof(GetSummaryVolumes)}: " + Request.QueryString);

            if (baseUid == Guid.Empty || topUid == Guid.Empty)
            {
                return(BadRequest(new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError, "Invalid surface parameter(s).")));
            }

            var(baseDesign, topDesign, baseFilter, topFilter) = await ResolveDesignAndFilterReferences(summaryDataHelper, projectUid, baseUid, topUid);

            if (baseFilter == null && baseDesign == null || topFilter == null && topDesign == null)
            {
                return(BadRequest(new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError, "Can not resolve either baseSurface or topSurface")));
            }

            var volumeCalcType = summaryDataHelper.GetVolumesType(baseFilter, topFilter);

            if (volumeCalcType == VolumesType.None)
            {
                return(BadRequest(new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError, "Missing volumes calculation type")));
            }

            var projectId = await GetLegacyProjectId(projectUid);

            var request = SummaryVolumesRequest.CreateAndValidate(projectId, projectUid, baseFilter, topFilter, baseDesign, topDesign, volumeCalcType, explicitFilters);

            CompactionVolumesSummaryResult volumesSummaryResult;

            try
            {
                var result = await RequestExecutorContainerFactory
                             .Build <SummaryVolumesExecutorV2>(LoggerFactory,
                                                               configStore : ConfigStore, trexCompactionDataProxy : TRexCompactionDataProxy, customHeaders : CustomHeaders,
                                                               userId : GetUserId(), fileImportProxy : FileImportProxy)
                             .ProcessAsync(request) as SummaryVolumesResult;

                if (result == null)
                {
                    return(Ok(new CompactionVolumesSummaryResult(0, "No production data found")));
                }

                volumesSummaryResult = CompactionVolumesSummaryResult.Create(result, await GetProjectSettingsTargets(projectUid));
            }
            catch (ServiceException exception)
            {
                Log.LogError($"{nameof(GetSummaryVolumes)}: {exception.GetResult.Message} ({exception.GetResult.Code})");
                return(BadRequest(new ContractExecutionResult(exception.GetResult.Code, exception.GetResult.Message)));
            }
            finally
            {
                Log.LogInformation($"{nameof(GetSummaryVolumes)} returned: " + Response.StatusCode);
            }

            if (Log.IsTraceEnabled())
            {
                Log.LogTrace($"{nameof(GetSummaryVolumes)} result: " + JsonConvert.SerializeObject(volumesSummaryResult));
            }

            return(Ok(volumesSummaryResult));
        }