/// <summary>
/// Sets activated state for imported files.
/// </summary>
protected async Task <IEnumerable <Guid> > SetFileActivatedState(string projectUid, Dictionary <Guid, bool> fileUids)
{
Logger.LogDebug($"SetFileActivatedState: projectUid={projectUid}, {fileUids.Keys.Count} files with changed state");
var deactivatedFileList = await ImportedFileRequestDatabaseHelper.GetImportedFileProjectSettings(projectUid, UserId, ProjectRepo).ConfigureAwait(false) ?? new List <ActivatedFileDescriptor>();
Logger.LogDebug($"SetFileActivatedState: originally {deactivatedFileList.Count} deactivated files");
var missingUids = new List <Guid>();
foreach (var key in fileUids.Keys)
{
//fileUids contains only uids of files whose state has changed.
//In the project settings we store only deactivated files.
//Therefore if the value is true remove from the list else add to the list
if (fileUids[key])
{
var item = deactivatedFileList.SingleOrDefault(d => d.ImportedFileUid == key.ToString());
if (item != null)
{
deactivatedFileList.Remove(item);
}
else
{
missingUids.Add(key);
Logger.LogInformation($"SetFileActivatedState: ImportFile '{key}' not found in project settings.");
}
}
else
{
deactivatedFileList.Add(new ActivatedFileDescriptor {
ImportedFileUid = key.ToString(), IsActivated = false
});
}
}
Logger.LogDebug($"SetFileActivatedState: now {deactivatedFileList.Count} deactivated files, {missingUids.Count} missingUids");
var projectSettingsRequest =
_requestFactory.Create <ProjectSettingsRequestHelper>(r => r
.CustomerUid(CustomerUid))
.CreateProjectSettingsRequest(projectUid, JsonConvert.SerializeObject(deactivatedFileList), ProjectSettingsType.ImportedFiles);
projectSettingsRequest.Validate();
_ = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <UpsertProjectSettingsExecutor>(LoggerFactory, ConfigStore, ServiceExceptionHandler,
CustomerUid, UserId, headers : customHeaders,
productivity3dV2ProxyCompaction : Productivity3dV2ProxyCompaction,
projectRepo : ProjectRepo, cwsProjectClient : CwsProjectClient)
.ProcessAsync(projectSettingsRequest)
) as ProjectSettingsResult;
var changedUids = fileUids.Keys.Except(missingUids);
Logger.LogDebug($"SetFileActivatedState: {changedUids.Count()} changedUids");
return(changedUids);
}
public async Task UpdateZoomLevelsInDatabase(object parameters)
{
RasterTileNotificationParameters result;
try
{
result = JObject.FromObject(parameters).ToObject <RasterTileNotificationParameters>();
}
catch (Exception e)
{
log.LogError(e, "Bad parameters passed to generated DXF tiles notification");
/*
* throw new ServiceException(HttpStatusCode.InternalServerError,
* new ContractExecutionResult(ContractExecutionStatesEnum.InternalProcessingError,
* "Wrong parameters passed to generated DXF tiles notification"));
*/
return;
}
log.LogInformation($"Received {ProjectFileRasterTilesGeneratedNotification.PROJECT_FILE_RASTER_TILES_GENERATED_KEY} notification: {JsonConvert.SerializeObject(result)}");
var existing = await projectRepo.GetImportedFile(result.FileUid.ToString());
//Check file is still there, user may have deleted it in the meanwhile
if (existing != null)
{
await ImportedFileRequestDatabaseHelper.UpdateImportedFileInDb(
existing, existing.FileDescriptor, existing.SurveyedUtc, result.MinZoomLevel, result.MaxZoomLevel,
existing.FileCreatedUtc, existing.FileUpdatedUtc, existing.ImportedBy, log, serviceExceptionHandler, projectRepo);
}
}
public async Task <ContractExecutionResult> CreateReferenceSurface(
[FromQuery] Guid projectUid,
[FromQuery] string filename,
[FromQuery] DateTime fileCreatedUtc,
[FromQuery] DateTime fileUpdatedUtc,
[FromQuery] Guid parentUid,
[FromQuery] double offset,
[FromServices] ISchedulerProxy schedulerProxy,
[FromServices] IPreferenceProxy prefProxy)
{
Logger.LogInformation($"{nameof(CreateReferenceSurface)}: projectUid {projectUid} filename: {filename} parentUid: {parentUid} offset: {offset}");
await ValidateProjectId(projectUid.ToString());
//Check parent design does exist
var importedFiles = await ImportedFileRequestDatabaseHelper.GetImportedFileList(projectUid.ToString(), Logger, UserId, ProjectRepo);
var parent = importedFiles.FirstOrDefault(i => i.ImportedFileUid == parentUid.ToString());
if (parent == null)
{
ServiceExceptionHandler.ThrowServiceException(HttpStatusCode.BadRequest, 120);
}
//Fill in file name if not provided
if (string.IsNullOrEmpty(filename))
{
filename = await DefaultReferenceSurfaceName(prefProxy, offset, Path.GetFileNameWithoutExtension(parent.Name));
}
//Validate parameters
FileImportDataValidator.ValidateUpsertImportedFileRequest(projectUid, ImportedFileType.ReferenceSurface, DxfUnitsType.Meters, fileCreatedUtc,
fileUpdatedUtc, UserEmailAddress, null, filename, parentUid, offset);
//Check reference surface does not exist
await ValidateFileDoesNotExist(projectUid.ToString(), filename, ImportedFileType.ReferenceSurface, null, parentUid, offset);
var importedFileResult = await UpsertFileInternal(filename, null, projectUid, ImportedFileType.ReferenceSurface, DxfUnitsType.Meters,
fileCreatedUtc, fileUpdatedUtc, null, schedulerProxy, parentUid, offset);
//If parent design is deactivated then deactivate reference surface
if (!parent.IsActivated)
{
var filesToUpdate = new Dictionary <Guid, bool>();
filesToUpdate.Add(new Guid(importedFileResult.ImportedFileDescriptor.ImportedFileUid), false);
await DoActivationAndNotification(projectUid.ToString(), filesToUpdate);
importedFiles = await ImportedFileRequestDatabaseHelper.GetImportedFileList(projectUid.ToString(), Logger, UserId, ProjectRepo);
importedFileResult.ImportedFileDescriptor = importedFiles.SingleOrDefault(i =>
i.ImportedFileUid == importedFileResult.ImportedFileDescriptor.ImportedFileUid);
}
Logger.LogInformation(
$"{nameof(CreateReferenceSurface)}: Completed successfully. Response: {JsonConvert.SerializeObject(importedFileResult)}");
return(importedFileResult);
}
public async Task <ImportedFileDescriptorListResult> GetImportedFilesV6([FromQuery] string projectUid)
{
Logger.LogInformation($"{nameof(GetImportedFilesV6)}: projectUid={projectUid}");
var result = new ImportedFileDescriptorListResult
{
ImportedFileDescriptors = await ImportedFileRequestDatabaseHelper.GetImportedFileList(projectUid, Logger, UserId, ProjectRepo)
};
return(result);
}
private async Task CheckIfUsedInFilter(DeleteImportedFile deleteImportedFile)
{
if (deleteImportedFile.IsDesignFileType)
{
var filters = await ImportedFileRequestDatabaseHelper.GetFilters(deleteImportedFile.ProjectUid, customHeaders, filterServiceProxy);
if (filters != null && filters.Any())
{
var fileUidStr = deleteImportedFile.ImportedFileUid.ToString();
if (filters.Any(f => f.DesignUid == fileUidStr || f.AlignmentUid == fileUidStr))
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.BadRequest, 112);
}
}
}
}
public async Task <ContractExecutionResult> DeleteImportedFileV6(
[FromQuery] Guid projectUid,
[FromQuery] Guid?importedFileUid, // for 3dpm imported files
[FromServices] IPegasusClient pegasusClient,
[FromServices] IWebClientWrapper webClient)
{
Logger.LogInformation($"{nameof(DeleteImportedFileV6)}: projectUid {projectUid} importedFileUid: {importedFileUid}");
await ValidateProjectId(projectUid.ToString());
var importedFiles = await ImportedFileRequestDatabaseHelper.GetImportedFiles(projectUid.ToString(), Logger, ProjectRepo).ConfigureAwait(false);
ImportedFile existing = null;
if (importedFiles.Count > 0)
{
existing = importedFiles.FirstOrDefault(f => f.ImportedFileUid == importedFileUid.ToString());
}
if (existing == null)
{
ServiceExceptionHandler.ThrowServiceException(HttpStatusCode.BadRequest, 56);
return(new ContractExecutionResult(ContractExecutionStatesEnum.InternalProcessingError, "shouldn't get here")); // to keep compiler happy
}
var deleteImportedFile = new DeleteImportedFile(
projectUid, existing.ImportedFileType, JsonConvert.DeserializeObject <FileDescriptor>(existing.FileDescriptor),
Guid.Parse(existing.ImportedFileUid), existing.ImportedFileId, existing.LegacyImportedFileId,
DataOceanRootFolderId, existing.SurveyedUtc);
var result = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <DeleteImportedFileExecutor>(
LoggerFactory, ConfigStore, ServiceExceptionHandler, CustomerUid, UserId, UserEmailAddress, customHeaders,
persistantTransferProxyFactory : persistantTransferProxyFactory, filterServiceProxy : filterServiceProxy, tRexImportFileProxy : tRexImportFileProxy,
projectRepo : ProjectRepo, dataOceanClient : DataOceanClient, authn : Authorization, pegasusClient : pegasusClient, cwsProjectClient : CwsProjectClient)
.ProcessAsync(deleteImportedFile)
);
await NotificationHubClient.Notify(new ProjectChangedNotification(projectUid));
Logger.LogInformation(
$"{nameof(DeleteImportedFileV6)}: Completed successfully. projectUid {projectUid} importedFileUid: {importedFileUid}");
return(result);
}
public async Task <ImmutableList <DesignDetailV5Result> > GetImportedFilesV5TBC([FromRoute] long projectId, [FromRoute] long?id = null)
{
Logger.LogInformation($"{nameof(GetImportedFilesV5TBC)}: projectId {projectId} id {id}");
// this also validates that this customer has access to the projectUid
var project = await ProjectRequestHelper.GetProjectForCustomer(new Guid(CustomerUid), new Guid(UserId), projectId, Logger, ServiceExceptionHandler, CwsProjectClient, customHeaders);
var projectUid = project.ProjectId;
var files = await ImportedFileRequestDatabaseHelper.GetImportedFileList(projectUid, Logger, UserId, ProjectRepo)
.ConfigureAwait(false);
var selected = id.HasValue ? files.Where(x => x.LegacyFileId == id.Value) : files;
return(selected.Select(x => new DesignDetailV5Result {
id = x.LegacyFileId, name = x.Name, fileType = (int)x.ImportedFileType, insertUTC = x.ImportedUtc
}).ToImmutableList());
}
/// <summary>
/// Validate that the uploaded file doesn't already exist in the database.
/// Should only be called from create methods where there's an expectation the file isn't already present.
/// </summary>
private async Task ValidateFileDoesNotExist(string projectUid, string filename, ImportedFileType importedFileType, DateTime?surveyedUtc, Guid?parentUid, double?offset)
{
var fileExists = false;
var importedFileList = ImportedFileRequestDatabaseHelper.GetImportedFileList(projectUid, Logger, UserId, ProjectRepo)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
ImportedFileDescriptor importedFileDescriptor = null;
if (importedFileList.Count > 0)
{
if (importedFileType == ImportedFileType.ReferenceSurface)
{
importedFileDescriptor = importedFileList.FirstOrDefault(
f => f.ImportedFileType == ImportedFileType.ReferenceSurface &&
f.ParentUid == parentUid && f.Offset.EqualsToNearestMillimeter(offset));
}
else
{
importedFileDescriptor = importedFileList.FirstOrDefault(
f => string.Equals(f.Name, filename, StringComparison.OrdinalIgnoreCase) &&
f.ImportedFileType == importedFileType &&
(importedFileType != ImportedFileType.SurveyedSurface || f.SurveyedUtc == surveyedUtc));
}
}
fileExists = importedFileDescriptor != null;
if (fileExists)
{
var message = $"{nameof(ValidateFileDoesNotExist)}: File: {filename} has already been imported.";
Logger.LogError(message);
ServiceExceptionHandler.ThrowServiceException(HttpStatusCode.BadRequest, importedFileType == ImportedFileType.ReferenceSurface ? 121 : 58);
}
}
/// <summary>
/// Deletes file via Trex
/// </summary>
protected override async Task <ContractExecutionResult> ProcessAsyncEx <T>(T item)
{
var deleteImportedFile = CastRequestObjectTo <DeleteImportedFile>(item, errorCode: 68);
await CheckIfUsedInFilter(deleteImportedFile);
await CheckIfHasReferenceSurfacesAsync(deleteImportedFile);
// DB change must be made before productivity3dV2ProxyNotification.DeleteFile is called as it calls back here to get list of Active files
//Don't think the above comment applies any more !
var deleteImportedFileEvent = await ImportedFileRequestDatabaseHelper.DeleteImportedFileInDb
(deleteImportedFile.ProjectUid, deleteImportedFile.ImportedFileUid, serviceExceptionHandler, projectRepo);
ImportedFileInternalResult importedFileInternalResult = null;
if (deleteImportedFile.IsTRexDesignFileType)
{
//Now delete in TRex
await ImportedFileRequestHelper.NotifyTRexDeleteFile(deleteImportedFile.ProjectUid,
deleteImportedFile.ImportedFileType, deleteImportedFile.FileDescriptor.FileName,
deleteImportedFile.ImportedFileUid,
deleteImportedFile.SurveyedUtc,
log, customHeaders, serviceExceptionHandler,
tRexImportFileProxy);
//and from s3 bucket
ProjectRequestHelper.DeleteFileFromS3Repository(
deleteImportedFile.ProjectUid.ToString(), deleteImportedFile.FileDescriptor.FileName,
deleteImportedFile.ImportedFileType == ImportedFileType.SurveyedSurface, deleteImportedFile.SurveyedUtc,
log, serviceExceptionHandler, persistantTransferProxyFactory.NewProxy(TransferProxyType.DesignImport));
}
if (deleteImportedFile.ImportedFileType == ImportedFileType.Linework ||
deleteImportedFile.ImportedFileType == ImportedFileType.GeoTiff)
{
var dataOceanFileName = DataOceanFileUtil.DataOceanFileName(deleteImportedFile.FileDescriptor.FileName,
deleteImportedFile.ImportedFileType == ImportedFileType.SurveyedSurface || deleteImportedFile.ImportedFileType == ImportedFileType.GeoTiff,
deleteImportedFile.ImportedFileUid, deleteImportedFile.SurveyedUtc);
importedFileInternalResult = await DataOceanHelper.DeleteFileFromDataOcean(
dataOceanFileName, deleteImportedFile.DataOceanRootFolder, customerUid,
deleteImportedFile.ProjectUid, deleteImportedFile.ImportedFileUid, log, dataOceanClient, authn, configStore);
var tasks = new List <Task>();
//delete generated DXF tiles
var dxfFileName = DataOceanFileUtil.GeneratedFileName(dataOceanFileName, deleteImportedFile.ImportedFileType);
var dataOceanPath = DataOceanFileUtil.DataOceanPath(deleteImportedFile.DataOceanRootFolder, customerUid, deleteImportedFile.ProjectUid.ToString());
var fullFileName = $"{dataOceanPath}{Path.DirectorySeparatorChar}{dxfFileName}";
tasks.Add(pegasusClient.DeleteTiles(fullFileName, DataOceanHelper.CustomHeaders(authn)));
await Task.WhenAll(tasks);
}
if (importedFileInternalResult != null)
{
await ImportedFileRequestDatabaseHelper.UndeleteImportedFile
(deleteImportedFile.ProjectUid, deleteImportedFile.ImportedFileUid, serviceExceptionHandler, projectRepo);
serviceExceptionHandler.ThrowServiceException(importedFileInternalResult.StatusCode, importedFileInternalResult.ErrorNumber, importedFileInternalResult.ResultCode, importedFileInternalResult.ErrorMessage1);
}
return(new ContractExecutionResult());
}
public async Task <IActionResult> UpdateImportedFileActivationStateV6(string projectUid, [FromBody] ActivatedImportFilesRequest request)
{
Logger.LogInformation($"{nameof(UpdateImportedFileActivationStateV6)}:");
await ValidateProjectId(projectUid).ConfigureAwait(false);
if (request == null)
{
ServiceExceptionHandler.ThrowServiceException(HttpStatusCode.InternalServerError, 40);
}
var fileIds = string.Join(",", request.ImportedFileDescriptors.Select(x => x.ImportedFileUid));
if (string.IsNullOrEmpty(fileIds))
{
return(Ok(new { Code = HttpStatusCode.BadRequest, Message = "Request contains no imported file IDs." }));
}
Logger.LogInformation($"{nameof(UpdateImportedFileActivationStateV6)}: projectUid: {projectUid}, fileUids: {fileIds}");
var importedFiles = await ImportedFileRequestDatabaseHelper.GetImportedFileList(projectUid, Logger, UserId, ProjectRepo).ConfigureAwait(false);
if (!importedFiles.Any())
{
Logger.LogInformation($"{nameof(UpdateImportedFileActivationStateV6)}: Attempt to set file activation state when project contains no files");
return(Ok(new { Code = HttpStatusCode.BadRequest, Message = "Project contains no imported files." }));
}
var filesToUpdate = new Dictionary <Guid, bool>();
foreach (var activatedFileDescriptor in request.ImportedFileDescriptors)
{
var existingFile = importedFiles.FirstOrDefault(f => f.ImportedFileUid == activatedFileDescriptor.ImportedFileUid);
if (existingFile == null)
{
Logger.LogError(
$"{nameof(UpdateImportedFileActivationStateV6)}: File doesn't exist. projectUid {projectUid}, fileUid: {activatedFileDescriptor.ImportedFileUid}");
continue;
}
if (existingFile.ImportedFileType == ImportedFileType.ReferenceSurface)
{
Logger.LogError(
$"{nameof(UpdateImportedFileActivationStateV6)}: Attempt to set file activation on a reference surface. projectUid {projectUid}, fileUid: {activatedFileDescriptor.ImportedFileUid}");
continue;
}
if (existingFile.IsActivated == activatedFileDescriptor.IsActivated)
{
Logger.LogDebug(
$"{nameof(UpdateImportedFileActivationStateV6)}: File activation state is already set to {existingFile.IsActivated}. No changes required. {existingFile.ImportedFileUid}");
continue;
}
Logger.LogInformation(
$"{nameof(UpdateImportedFileActivationStateV6)}: File queued for updating: {JsonConvert.SerializeObject(existingFile)}");
filesToUpdate.Add(new Guid(activatedFileDescriptor.ImportedFileUid), activatedFileDescriptor.IsActivated);
//If user is activating or deactivating a design which has reference surfaces, do as a group
if (existingFile.ImportedFileType == ImportedFileType.DesignSurface)
{
var children = importedFiles
.Where(f => f.ParentUid.HasValue && f.ParentUid.ToString() == existingFile.ImportedFileUid).ToList();
if (children.Count > 0)
{
Logger.LogInformation(
$"{nameof(UpdateImportedFileActivationStateV6)}: Setting file activation state of reference surfaces for design {existingFile.ImportedFileUid}");
foreach (var child in children)
{
if (child.IsActivated != activatedFileDescriptor.IsActivated)
{
filesToUpdate.Add(new Guid(child.ImportedFileUid), activatedFileDescriptor.IsActivated);
}
}
}
}
}
if (!filesToUpdate.Any())
{
Logger.LogInformation($"{nameof(UpdateImportedFileActivationStateV6)}: No files eligible for activation state change.");
return(Ok(new { Code = HttpStatusCode.OK, Message = "Success" }));
}
try
{
await DoActivationAndNotification(projectUid, filesToUpdate);
return(Ok(new { Code = HttpStatusCode.OK, Message = "Success" }));
}
catch (Exception exception)
{
return(new JsonResult(new { Code = HttpStatusCode.InternalServerError, exception.GetBaseException().Message }));
}
}
/// <summary>
/// Adds file via Trex
/// </summary>
protected override async Task <ContractExecutionResult> ProcessAsyncEx <T>(T item)
{
var importedFile = CastRequestObjectTo <CreateImportedFile>(item, errorCode: 68);
await ImportedFileRequestDatabaseHelper.CheckIfParentSurfaceExistsAsync(importedFile.ImportedFileType, importedFile.ParentUid, serviceExceptionHandler, projectRepo);
// need to write to Db prior to
// notifying TRex as Trex needs the ImportedFileUid
var createImportedFileEvent = await ImportedFileRequestDatabaseHelper.CreateImportedFileinDb(
Guid.Parse(customerUid),
importedFile.ProjectUid,
importedFile.ImportedFileType, importedFile.DxfUnitsType, importedFile.FileName,
importedFile.SurveyedUtc, JsonConvert.SerializeObject(importedFile.FileDescriptor),
importedFile.FileCreatedUtc, importedFile.FileUpdatedUtc, userEmailAddress,
log, serviceExceptionHandler, projectRepo, importedFile.ParentUid, importedFile.Offset,
importedFile.ImportedFileUid);
if (importedFile.IsTRexDesignFileType)
{
await ImportedFileRequestHelper.NotifyTRexAddFile(importedFile.ProjectUid,
importedFile.ImportedFileType, importedFile.FileName, createImportedFileEvent.ImportedFileUID,
importedFile.SurveyedUtc,
log, customHeaders, serviceExceptionHandler,
tRexImportFileProxy, projectRepo);
}
if (importedFile.ImportedFileType == ImportedFileType.Linework ||
importedFile.ImportedFileType == ImportedFileType.GeoTiff)
{
var project = ProjectRequestHelper.GetProject(importedFile.ProjectUid, new Guid(customerUid), new Guid(userId), log, serviceExceptionHandler, cwsProjectClient, customHeaders);
var existing = projectRepo.GetImportedFile(createImportedFileEvent.ImportedFileUID.ToString());
await Task.WhenAll(project, existing);
var dcFileName = importedFile.ImportedFileType == ImportedFileType.GeoTiff ?
null :
DataOceanFileUtil.DataOceanFileName(project.Result.CoordinateSystemFileName, false, importedFile.ProjectUid, null);
//Generate raster tiles
var jobRequest = TileGenerationRequestHelper.CreateRequest(
importedFile.ImportedFileType,
customerUid,
importedFile.ProjectUid.ToString(),
existing.Result.ImportedFileUid,
importedFile.DataOceanRootFolder,
importedFile.DataOceanFileName,
dcFileName,
importedFile.DxfUnitsType,
importedFile.SurveyedUtc);
await schedulerProxy.ScheduleVSSJob(jobRequest, customHeaders);
}
var fileDescriptor = new ImportedFileDescriptorSingleResult(
(await ImportedFileRequestDatabaseHelper
.GetImportedFileList(importedFile.ProjectUid.ToString(), log, userId, projectRepo))
.ToImmutableList()
.First(f => f.ImportedFileUid == createImportedFileEvent.ImportedFileUID.ToString())
);
log.LogInformation(
$"CreateImportedFileV4. completed successfully. Response: {JsonConvert.SerializeObject(fileDescriptor)}");
return(fileDescriptor);
}
/// <summary>
/// Common file processing method used by all importedFile endpoints.
/// </summary>
protected async Task <ImportedFileDescriptorSingleResult> UpsertFileInternal(
string filename,
Stream fileStream,
Guid projectUid,
ImportedFileType importedFileType,
DxfUnitsType dxfUnitsType,
DateTime fileCreatedUtc,
DateTime fileUpdatedUtc,
DateTime?surveyedUtc,
ISchedulerProxy schedulerProxy,
Guid?parentUid = null,
double?offset = null)
{
ImportedFileDescriptorSingleResult importedFile = null;
var existing = await ImportedFileRequestDatabaseHelper
.GetImportedFileForProject
(projectUid.ToString(), filename, importedFileType, surveyedUtc,
Logger, ProjectRepo, offset, parentUid)
.ConfigureAwait(false);
var creating = existing == null;
Logger.LogInformation(
creating
? $"{nameof(UpsertFileInternal)}. file doesn't exist already in DB: {filename} projectUid {projectUid} ImportedFileType: {importedFileType} surveyedUtc {(surveyedUtc == null ? "N/A" : surveyedUtc.ToString())} parentUid {parentUid} offset: {offset}"
: $"{nameof(UpsertFileInternal)}. file exists already in DB. Will be updated: {JsonConvert.SerializeObject(existing)}");
FileDescriptor fileDescriptor = null;
var importedFileUid = creating ? Guid.NewGuid() : Guid.Parse(existing.ImportedFileUid);
var dataOceanFileName = DataOceanFileUtil.DataOceanFileName(filename,
importedFileType == ImportedFileType.SurveyedSurface || importedFileType == ImportedFileType.GeoTiff,
importedFileUid, surveyedUtc);
if (importedFileType == ImportedFileType.ReferenceSurface)
{
//FileDescriptor not used for reference surface but validation requires values
fileDescriptor = FileDescriptor.CreateFileDescriptor("Not applicable", "Not applicable", filename);
}
else
{
if (IsTRexDesignFileType(importedFileType))
{
fileDescriptor = ProjectRequestHelper.WriteFileToS3Repository(
fileStream, projectUid.ToString(), filename,
importedFileType == ImportedFileType.SurveyedSurface, surveyedUtc,
Logger, ServiceExceptionHandler, persistantTransferProxyFactory.NewProxy(TransferProxyType.DesignImport));
}
//This is needed for ATs.
fileDescriptor = FileDescriptor.CreateFileDescriptor(
FileSpaceId,
$"/{CustomerUid}/{projectUid}",
filename);
if (importedFileType == ImportedFileType.Linework || importedFileType == ImportedFileType.GeoTiff)
{
//save copy to DataOcean
await DataOceanHelper.WriteFileToDataOcean(
fileStream, DataOceanRootFolderId, CustomerUid, projectUid.ToString(), dataOceanFileName,
Logger, ServiceExceptionHandler, DataOceanClient, Authorization, importedFileUid, ConfigStore);
}
}
if (creating)
{
var createImportedFile = new CreateImportedFile(
projectUid, filename, fileDescriptor, importedFileType, surveyedUtc, dxfUnitsType,
fileCreatedUtc, fileUpdatedUtc, DataOceanRootFolderId, parentUid, offset, importedFileUid, dataOceanFileName);
importedFile = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <CreateImportedFileExecutor>(
LoggerFactory, ConfigStore, ServiceExceptionHandler, CustomerUid, UserId, UserEmailAddress, customHeaders,
productivity3dV2ProxyCompaction : Productivity3dV2ProxyCompaction,
persistantTransferProxyFactory : persistantTransferProxyFactory, tRexImportFileProxy : tRexImportFileProxy,
projectRepo : ProjectRepo, dataOceanClient : DataOceanClient, authn : Authorization, schedulerProxy : schedulerProxy,
cwsProjectClient : CwsProjectClient)
.ProcessAsync(createImportedFile)
) as ImportedFileDescriptorSingleResult;
Logger.LogInformation(
$"{nameof(UpsertFileInternal)}: Create completed successfully. Response: {JsonConvert.SerializeObject(importedFile)}");
}
else
{
// this also validates that this customer has access to the projectUid
var project = await ProjectRequestHelper.GetProject(projectUid, new Guid(CustomerUid), new Guid(UserId), Logger, ServiceExceptionHandler, CwsProjectClient, customHeaders);
var importedFileUpsertEvent = new UpdateImportedFile(
projectUid, project.ShortRaptorProjectId, importedFileType,
(importedFileType == ImportedFileType.SurveyedSurface || importedFileType == ImportedFileType.GeoTiff)
? surveyedUtc
: null,
dxfUnitsType, fileCreatedUtc, fileUpdatedUtc, fileDescriptor,
Guid.Parse(existing?.ImportedFileUid), existing.ImportedFileId,
DataOceanRootFolderId, offset, dataOceanFileName);
importedFile = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <UpdateImportedFileExecutor>(
LoggerFactory, ConfigStore, ServiceExceptionHandler, CustomerUid, UserId, UserEmailAddress, customHeaders,
productivity3dV2ProxyCompaction : Productivity3dV2ProxyCompaction,
tRexImportFileProxy : tRexImportFileProxy,
projectRepo : ProjectRepo, dataOceanClient : DataOceanClient, authn : Authorization, schedulerProxy : schedulerProxy,
cwsProjectClient : CwsProjectClient)
.ProcessAsync(importedFileUpsertEvent)
) as ImportedFileDescriptorSingleResult;
Logger.LogInformation(
$"{nameof(UpsertFileInternal)}: Update completed successfully. Response: {JsonConvert.SerializeObject(importedFile)}");
}
await NotificationHubClient.Notify(new ProjectChangedNotification(projectUid));
return(importedFile);
}
/// <summary>
/// Processes the Upsert
/// </summary>
protected override async Task <ContractExecutionResult> ProcessAsyncEx <T>(T item)
{
var importedFile = CastRequestObjectTo <UpdateImportedFile>(item, errorCode: 68);
var existingImportedFile = await projectRepo.GetImportedFile(importedFile.ImportedFileUid.ToString());
if (existingImportedFile == null)
{
throw new ServiceException(HttpStatusCode.BadRequest,
new ContractExecutionResult(ProjectErrorCodesProvider.GetErrorNumberwithOffset(122),
ProjectErrorCodesProvider.FirstNameWithOffset(122)));
}
if (importedFile.IsTRexDesignFileType)
{
await ImportedFileRequestHelper.NotifyTRexUpdateFile(importedFile.ProjectUid,
importedFile.ImportedFileType, importedFile.FileDescriptor.FileName, importedFile.ImportedFileUid,
importedFile.SurveyedUtc,
log, customHeaders, serviceExceptionHandler,
tRexImportFileProxy);
}
if (importedFile.ImportedFileType == ImportedFileType.Linework ||
importedFile.ImportedFileType == ImportedFileType.GeoTiff)
{
string dcFileName = null;
if (importedFile.ImportedFileType == ImportedFileType.Linework)
{
var project = await ProjectRequestHelper.GetProject(importedFile.ProjectUid, new Guid(customerUid), new Guid(userId), log, serviceExceptionHandler, cwsProjectClient, customHeaders);
dcFileName = DataOceanFileUtil.DataOceanFileName(project.CoordinateSystemFileName, false, importedFile.ProjectUid, null);
}
var jobRequest = TileGenerationRequestHelper.CreateRequest(
importedFile.ImportedFileType,
customerUid,
importedFile.ProjectUid.ToString(),
existingImportedFile.ImportedFileUid,
importedFile.DataOceanRootFolder,
importedFile.DataOceanFileName,
dcFileName,
importedFile.DxfUnitsTypeId,
importedFile.SurveyedUtc);
await schedulerProxy.ScheduleVSSJob(jobRequest, customHeaders);
}
// if all succeeds, update Db and put update to kafka que
var updateImportedFileEvent = await ImportedFileRequestDatabaseHelper.UpdateImportedFileInDb(existingImportedFile,
existingImportedFile.FileDescriptor,
importedFile.SurveyedUtc, existingImportedFile.MinZoomLevel, existingImportedFile.MaxZoomLevel,
importedFile.FileCreatedUtc, importedFile.FileUpdatedUtc, userEmailAddress,
log, serviceExceptionHandler, projectRepo);
var fileDescriptor = new ImportedFileDescriptorSingleResult(
(await ImportedFileRequestDatabaseHelper.GetImportedFileList(importedFile.ProjectUid.ToString(), log, userId, projectRepo))
.ToImmutableList()
.FirstOrDefault(f => f.ImportedFileUid == importedFile.ImportedFileUid.ToString())
);
log.LogInformation(
$"UpdateImportedFileExecutor. entry {(fileDescriptor.ImportedFileDescriptor == null ? "not " : "")}retrieved from DB : {JsonConvert.SerializeObject(fileDescriptor)}");
return(fileDescriptor);
}
