public async Task CompactionReportStationOffsetExecutor_TRex_NoResult()
{
var projectUid = Guid.NewGuid();
var alignmentDesignUid = Guid.NewGuid();
var userPreferences = new UserPreferenceData {
Language = "en-US"
};
var request = CompactionReportStationOffsetRequest.CreateRequest(
0, projectUid, null, 0, null, false, true, true, true, true, false,
null, new DesignDescriptor(-1,
FileDescriptor.CreateFileDescriptor(string.Empty, string.Empty, projectUid.ToString(),
"theFilename.svl"), -1, alignmentDesignUid), 0, 0, 0, null, userPreferences, "New Zealand Standard Time");
var mockConfigStore = new Mock <IConfigurationStore>();
#if RAPTOR
mockConfigStore.Setup(x => x.GetValueBool("ENABLE_TREX_GATEWAY_STATIONOFFSET")).Returns(true);
#endif
var exception = new ServiceException(HttpStatusCode.InternalServerError,
new ContractExecutionResult(ContractExecutionStatesEnum.InternalProcessingError, $"StationOffset report failed somehow. ProjectUid: { projectUid }"));
var tRexProxy = new Mock <ITRexCompactionDataProxy>();
tRexProxy.Setup(x => x.SendDataPostRequestWithStreamResponse(It.IsAny <CompactionReportStationOffsetTRexRequest>(), It.IsAny <string>(), It.IsAny <IHeaderDictionary>())).Throws(exception);
var executor = RequestExecutorContainerFactory
.Build <CompactionReportStationOffsetExecutor>(_logger, configStore: mockConfigStore.Object, trexCompactionDataProxy: tRexProxy.Object);
var result = await Assert.ThrowsExceptionAsync <ServiceException>(async() => await executor.ProcessAsync(request));
Assert.AreEqual(HttpStatusCode.InternalServerError, result.Code);
Assert.AreEqual(ContractExecutionStatesEnum.InternalProcessingError, result.GetResult.Code);
Assert.AreEqual(exception.GetResult.Message, result.GetResult.Message);
}
public void ValidateSuccessTest()
{
FileDescriptor file = FileDescriptor.CreateFileDescriptor("u72003136-d859-4be8-86de-c559c841bf10",
"BC Data/Sites/Integration10/Designs", "Cycleway.ttm");
file.Validate();
}
public void CanValidateFileDescriptor()
{
var desc = FileDescriptor.CreateFileDescriptor("1", "2.txt", "3");
desc.Validate();
Assert.False(false);
}
public void CanCreateFileDescriptorTest()
{
string bigString = new string('A', 10000);
var validator = new DataAnnotationsValidator();
FileDescriptor file = FileDescriptor.CreateFileDescriptor("u72003136-d859-4be8-86de-c559c841bf10",
"BC Data/Sites/Integration10/Designs", "Cycleway.ttm");
ICollection <ValidationResult> results;
Assert.IsTrue(validator.TryValidate(file, out results));
//Note: file name is string.Empty due to the ValidFilename attribute otherwise get a null reference exception
file = FileDescriptor.CreateFileDescriptor(null, null, string.Empty);
Assert.IsFalse(validator.TryValidate(file, out results), "empty file descriptor failed");
//too big path
file = FileDescriptor.CreateFileDescriptor("u72003136-d859-4be8-86de-c559c841bf10",
bigString, "Cycleway.ttm");
Assert.IsFalse(validator.TryValidate(file, out results), " too big path failed");
//too big file name
file = FileDescriptor.CreateFileDescriptor("u72003136-d859-4be8-86de-c559c841bf10",
"BC Data/Sites/Integration10/Designs", bigString);
Assert.IsFalse(validator.TryValidate(file, out results), "too big file name failed");
}
public void ValidateFailEmptyTest()
{
//empty file descriptor
FileDescriptor file = FileDescriptor.CreateFileDescriptor(
string.Empty, string.Empty, string.Empty);
Assert.ThrowsException <ServiceException>(() => file.Validate());
}
public void CanValidateFileDescriptorWithCustomerAndProjectID()
{
var desc = FileDescriptor.CreateFileDescriptor("1", "132465", "55644", "FILE.FILE");
desc.Validate();
Assert.Equal("/132465/55644", desc.Path);
Assert.Equal("FILE.FILE", desc.FileName);
Assert.Equal("1", desc.FilespaceId);
}
/// <summary>
/// Copies importedFile between filespaces in TCC
/// From FilespaceIDBcCustomer\BC Data to FilespaceIdVisionLink\CustomerUID\ProjectUID
/// returns filespaceID; path and filename which identifies it uniquely in TCC
/// this may be a create or update, so ok if it already exists
/// </summary>
/// <returns></returns>
public static async Task <FileDescriptor> CopyFileWithinTccRepository(ImportedFileTbc sourceFile,
string customerUid, string projectUid, string dstFileSpaceId,
ILogger log, IServiceExceptionHandler serviceExceptionHandler, IFileRepository fileRepo)
{
var srcTccPathAndFile = $"{sourceFile.Path}/{sourceFile.Name}";
var destTccPath = $"/{customerUid}/{projectUid}";
string tccDestinationFileName = sourceFile.Name;
if (sourceFile.ImportedFileTypeId == ImportedFileType.SurveyedSurface)
{
tccDestinationFileName =
tccDestinationFileName.IncludeSurveyedUtcInName(sourceFile.SurfaceFile.SurveyedUtc);
}
var destTccPathAndFile = $"/{customerUid}/{projectUid}/{tccDestinationFileName}";
var tccCopyFileResult = false;
try
{
// The filename already contains the surveyUtc where appropriate
log.LogInformation(
$"CopyFileWithinTccRepository: srcFileSpaceId: {sourceFile.FileSpaceId} destFileSpaceId {dstFileSpaceId} srcTccPathAndFile {srcTccPathAndFile} destTccPathAndFile {destTccPathAndFile}");
// check for exists first to avoid an misleading exception in our logs.
var folderAlreadyExists = await fileRepo.FolderExists(dstFileSpaceId, destTccPath).ConfigureAwait(false);
if (folderAlreadyExists == false)
{
await fileRepo.MakeFolder(dstFileSpaceId, destTccPath).ConfigureAwait(false);
}
// this creates folder if it doesn't exist, and upserts file if it does
tccCopyFileResult = await fileRepo
.CopyFile(sourceFile.FileSpaceId, dstFileSpaceId, srcTccPathAndFile, destTccPathAndFile)
.ConfigureAwait(false);
}
catch (Exception e)
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.InternalServerError, 92, "fileRepo.PutFile",
e.Message);
}
if (tccCopyFileResult == false)
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.InternalServerError, 92);
}
var fileDescriptorTarget =
FileDescriptor.CreateFileDescriptor(dstFileSpaceId, destTccPath, tccDestinationFileName);
log.LogInformation(
$"CopyFileWithinTccRepository: fileDescriptorTarget {JsonConvert.SerializeObject(fileDescriptorTarget)}");
return(fileDescriptorTarget);
}
public async Task UpdateImportedFile_TRexHappyPath_ReferenceSurface()
{
var customHeaders = new HeaderDictionary();
var importedFileUid = Guid.NewGuid();
var parentUid = Guid.NewGuid();
var oldOffset = 1.5;
var newOffset = 1.5;
var importedFileId = 9999;
var TCCFilePath = "/BC Data/Sites/Chch Test Site";
var fileName = "MoundRoadlinework.dxf";
var fileDescriptor = FileDescriptor.CreateFileDescriptor(_fileSpaceId, TCCFilePath, fileName);
var existingImportedFile = new ImportedFile
{
ProjectUid = _projectUid.ToString(),
ImportedFileUid = importedFileUid.ToString(),
LegacyImportedFileId = 200000,
ImportedFileType = ImportedFileType.ReferenceSurface,
Name = fileName,
FileDescriptor = JsonConvert.SerializeObject(fileDescriptor),
Offset = oldOffset,
ParentUid = parentUid.ToString()
};
var importedFilesList = new List <ImportedFile> {
existingImportedFile
};
var updateImportedFile = new UpdateImportedFile(
_projectUid, _shortRaptorProjectId, ImportedFileType.ReferenceSurface, null, DxfUnitsType.Meters, DateTime.UtcNow.AddHours(-45),
DateTime.UtcNow.AddHours(-44), fileDescriptor, importedFileUid, importedFileId, "some folder", newOffset, "some file"
);
var logger = ServiceProvider.GetRequiredService <ILoggerFactory>();
var serviceExceptionHandler = ServiceProvider.GetRequiredService <IServiceExceptionHandler>();
var tRexImportFileProxy = new Mock <ITRexImportFileProxy>();
tRexImportFileProxy.Setup(tr => tr.UpdateFile(It.IsAny <DesignRequest>(), It.IsAny <HeaderDictionary>())).ReturnsAsync(new ContractExecutionResult());
var projectRepo = new Mock <IProjectRepository>();
projectRepo.Setup(pr => pr.StoreEvent(It.IsAny <UpdateImportedFileEvent>())).ReturnsAsync(1);
projectRepo.Setup(pr => pr.GetImportedFile(It.IsAny <string>())).ReturnsAsync(existingImportedFile);
projectRepo.Setup(pr => pr.GetImportedFiles(It.IsAny <string>())).ReturnsAsync(importedFilesList);
var executor = RequestExecutorContainerFactory
.Build <UpdateImportedFileExecutor>(logger, null, serviceExceptionHandler,
_customerUid.ToString(), _userUid.ToString(), _userEmailAddress, customHeaders,
tRexImportFileProxy: tRexImportFileProxy.Object, projectRepo: projectRepo.Object);
var result = await executor.ProcessAsync(updateImportedFile).ConfigureAwait(false) as ImportedFileDescriptorSingleResult;
Assert.Equal(0, result.Code);
Assert.NotNull(result.ImportedFileDescriptor);
Assert.Equal(_projectUid.ToString(), result.ImportedFileDescriptor.ProjectUid);
Assert.Equal(fileDescriptor.FileName, result.ImportedFileDescriptor.Name);
Assert.Equal(newOffset, result.ImportedFileDescriptor.Offset);
}
public void ValidateSuccessTest()
{
DesignDescriptor design = new DesignDescriptor(1234, null, 0);
design.Validate();
design = new DesignDescriptor(0,
FileDescriptor.CreateFileDescriptor("u72003136-d859-4be8-86de-c559c841bf10",
"BC Data/Sites/Integration10/Designs", "Cycleway.ttm"), 0);
design.Validate();
}
public void MapFilterResultHasAlignmentFilterToCombinedFilter()
{
var alignment = new DesignDescriptor(42l, FileDescriptor.CreateFileDescriptor("x", "y", "z"), 0, Guid.NewGuid());
var filter = FilterResult.CreateFilterObsolete(alignmentFile: alignment);
var combinedFilter = AutoMapperUtility.Automapper.Map <FilterResult, CombinedFilter>(filter);
combinedFilter.Should().NotBeNull();
combinedFilter.SpatialFilter.IsDesignMask.Should().BeFalse();
combinedFilter.SpatialFilter.SurfaceDesignMaskDesignUid.Should().Be(Guid.Empty);
combinedFilter.SpatialFilter.IsAlignmentMask.Should().BeTrue();
combinedFilter.SpatialFilter.AlignmentDesignMaskDesignUID.Should().Be(alignment.FileUid.Value);
}
public void UploadFile_should_return_When_filesize_exceeds_max_limit()
{
var filePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var filename = Guid.NewGuid().ToString();
Assert.IsNotNull(filePath);
File.WriteAllBytes(Path.Combine(filePath, filename), new byte[20 * 1024 * 1024 + 1]);
var fileDescriptor = FileDescriptor.CreateFileDescriptor("1", filePath, filename);
var allBytes = File.ReadAllBytes(Path.Combine(fileDescriptor.Path, fileDescriptor.FileName));
(bool success, string message) = uploadUtility.UploadFile(fileDescriptor, allBytes);
Assert.IsFalse(success);
Assert.IsNotNull(message);
}
public void MapImportedFileRepoToResponse()
{
var request = new ImportedFile
{
ProjectUid = Guid.NewGuid().ToString(),
ImportedFileUid = Guid.NewGuid().ToString(),
CustomerUid = Guid.NewGuid().ToString(),
ImportedFileType = ImportedFileType.Alignment,
Name = "this is the filename.svl",
FileDescriptor = JsonConvert.SerializeObject(FileDescriptor.CreateFileDescriptor(Guid.NewGuid().ToString(), "/customerUID/projectUID", "this is the filename.svl")),
FileCreatedUtc = DateTime.UtcNow.AddDays(-2),
FileUpdatedUtc = DateTime.UtcNow.AddDays(-1),
ImportedBy = "*****@*****.**",
SurveyedUtc = null,
ParentUid = null,
Offset = 0,
IsDeleted = false,
LastActionedUtc = DateTime.UtcNow
};
var importedFileDescriptor = AutoMapperUtility.Automapper.Map <ImportedFileDescriptor>(request);
Assert.Equal(request.ProjectUid, importedFileDescriptor.ProjectUid);
Assert.Equal(request.ImportedFileUid, importedFileDescriptor.ImportedFileUid);
Assert.Equal(request.CustomerUid, importedFileDescriptor.CustomerUid);
Assert.Equal(request.ImportedFileType, importedFileDescriptor.ImportedFileType);
Assert.Equal(request.Name, importedFileDescriptor.Name);
Assert.Equal(request.FileCreatedUtc, importedFileDescriptor.FileCreatedUtc);
Assert.Equal(request.FileUpdatedUtc, importedFileDescriptor.FileUpdatedUtc);
Assert.Equal(request.ImportedBy, importedFileDescriptor.ImportedBy);
Assert.Equal(request.SurveyedUtc, importedFileDescriptor.SurveyedUtc);
Assert.Equal(request.ParentUid, importedFileDescriptor.ParentUid.HasValue ? "Fail assertion" : null);
Assert.Equal(request.Offset, importedFileDescriptor.Offset);
Assert.Equal(request.LastActionedUtc, importedFileDescriptor.ImportedUtc);
Assert.True(importedFileDescriptor.IsActivated);
// just make a copy file descriptor is only in the source file, not the destination
var copyOfRequest = AutoMapperUtility.Automapper.Map <ImportedFile>(request);
Assert.Equal(request.ProjectUid, copyOfRequest.ProjectUid);
Assert.Equal(request.FileDescriptor, copyOfRequest.FileDescriptor);
}
private IEnumerable <SurveyedSurfaceDetails> ConvertToSurveyedSurfaceDetails(IEnumerable <TSurveyedSurfaceDetails> surveyedSurfaces)
{
return(surveyedSurfaces.Select(surveyedSurface => SurveyedSurfaceDetails.CreateSurveyedSurfaceDetails(
id: surveyedSurface.ID,
surveyedSurface: new DesignDescriptor(
surveyedSurface.DesignDescriptor.DesignID,
FileDescriptor.CreateFileDescriptor(
surveyedSurface.DesignDescriptor.FileSpaceID,
surveyedSurface.DesignDescriptor.Folder,
surveyedSurface.DesignDescriptor.FileName),
surveyedSurface.DesignDescriptor.Offset),
asAtDate: surveyedSurface.AsAtDate,
extents: new BoundingBox3DGrid(
surveyedSurface.Extents.MinX,
surveyedSurface.Extents.MinY,
surveyedSurface.Extents.MinZ,
surveyedSurface.Extents.MaxX,
surveyedSurface.Extents.MaxY,
surveyedSurface.Extents.MaxZ))));
}
/// <summary>
/// Writes the importedFile to S3
/// if file exists, it will be overwritten
/// returns FileDescriptor for backwards compatability
/// </summary>
/// <returns></returns>
public static FileDescriptor WriteFileToS3Repository(
Stream fileContents, string projectUid, string filename,
bool isSurveyedSurface, DateTime?surveyedUtc,
ILogger log, IServiceExceptionHandler serviceExceptionHandler,
ITransferProxy persistantTransferProxy)
{
var s3FullPath = GetS3FullPath(projectUid, filename, isSurveyedSurface, surveyedUtc);
try
{
persistantTransferProxy.Upload(fileContents, s3FullPath);
}
catch (Exception e)
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.InternalServerError, 57, "transferProxy.Upload()",
e.Message);
}
log.LogInformation($"WriteFileToS3Repository. Process add design :{s3FullPath}, for Project:{projectUid}");
var finalFilename = s3FullPath.Split("/")[1];
return(FileDescriptor.CreateFileDescriptor(string.Empty, string.Empty, finalFilename));
}
public void MapImportedFileRepoToUpdateEvent()
{
var request = new ImportedFile
{
ProjectUid = Guid.NewGuid().ToString(),
ImportedFileUid = Guid.NewGuid().ToString(),
CustomerUid = Guid.NewGuid().ToString(),
ImportedFileType = ImportedFileType.Alignment,
Name = "this is the filename.svl",
FileDescriptor = JsonConvert.SerializeObject(FileDescriptor.CreateFileDescriptor(Guid.NewGuid().ToString(), "/customerUID/projectUID", "this is the filename.svl")),
FileCreatedUtc = DateTime.UtcNow.AddDays(-2),
FileUpdatedUtc = DateTime.UtcNow.AddDays(-1),
ImportedBy = "*****@*****.**",
SurveyedUtc = null,
ParentUid = null,
Offset = 0,
IsDeleted = false,
LastActionedUtc = DateTime.UtcNow
};
var updateImportedFileEvent = AutoMapperUtility.Automapper.Map <UpdateImportedFileEvent>(request);
Assert.Equal(request.LastActionedUtc, updateImportedFileEvent.ActionUTC);
Assert.Equal(request.FileCreatedUtc, updateImportedFileEvent.FileCreatedUtc);
Assert.Equal(request.FileDescriptor, updateImportedFileEvent.FileDescriptor);
Assert.Equal(request.FileUpdatedUtc, updateImportedFileEvent.FileUpdatedUtc);
Assert.Equal(request.ImportedBy, updateImportedFileEvent.ImportedBy);
Assert.Equal(request.ImportedFileUid, updateImportedFileEvent.ImportedFileUID.ToString());
Assert.Equal(request.ProjectUid, updateImportedFileEvent.ProjectUID.ToString());
Assert.Equal(request.SurveyedUtc, updateImportedFileEvent.SurveyedUtc);
// just make a copy file descriptor is only in the source file, not the destination
var copyOfRequest = AutoMapperUtility.Automapper.Map <ImportedFile>(request);
Assert.Equal(request.ProjectUid, copyOfRequest.ProjectUid);
Assert.Equal(request.FileDescriptor, copyOfRequest.FileDescriptor);
}
public void IsAlignmentProfile_Should_return_true_when_AlignmentDesign_file_is_set()
{
var request = new ProfileProductionDataRequest(0, Guid.NewGuid(), ProductionDataType.All, null, 0, new DesignDescriptor(1, FileDescriptor.CreateFileDescriptor("1", "path", "filename"), 0), null, null, 0, 0, null, false);
Assert.IsTrue(request.IsAlignmentDesign);
}
public async Task CreateImportedFile_HappyPath_GeoTiff()
{
// FlowFile uploads the file from client (possibly as a background task via scheduler)
// Controller uploads file to TCC and/or S3
// V2 Note: BCC file has already put the file on TCC.
// the controller a) copies within TCC to client project (raptor)
// b) copies locally and hence to S3. (TRex)
var customHeaders = new HeaderDictionary();
var importedFileUid = Guid.NewGuid();
var TCCFilePath = "/BC Data/Sites/Chch Test Site";
var fileName = "MoundRoad.tif";
var fileDescriptor = FileDescriptor.CreateFileDescriptor(_fileSpaceId, TCCFilePath, fileName);
var fileCreatedUtc = DateTime.UtcNow.AddHours(-45);
var fileUpdatedUtc = fileCreatedUtc.AddHours(1);
var surveyedUtc = fileCreatedUtc.AddHours(-1);
var newImportedFile = new ImportedFile
{
ProjectUid = _projectUid.ToString(),
ImportedFileUid = importedFileUid.ToString(),
ImportedFileId = 999,
LegacyImportedFileId = 200000,
ImportedFileType = ImportedFileType.GeoTiff,
Name = fileDescriptor.FileName,
FileDescriptor = JsonConvert.SerializeObject(fileDescriptor),
SurveyedUtc = surveyedUtc
};
_ = new CreateImportedFileEvent
{
CustomerUID = _customerUid,
ProjectUID = _projectUid,
ImportedFileUID = importedFileUid,
ImportedFileType = ImportedFileType.GeoTiff,
DxfUnitsType = DxfUnitsType.Meters,
Name = fileDescriptor.FileName,
FileDescriptor = JsonConvert.SerializeObject(fileDescriptor),
FileCreatedUtc = fileCreatedUtc,
FileUpdatedUtc = fileUpdatedUtc,
ImportedBy = string.Empty,
SurveyedUTC = surveyedUtc,
ParentUID = null,
Offset = 0,
ActionUTC = DateTime.UtcNow
};
var createImportedFile = new CreateImportedFile(
_projectUid, fileDescriptor.FileName, fileDescriptor, ImportedFileType.GeoTiff, surveyedUtc, DxfUnitsType.Meters,
fileCreatedUtc, fileUpdatedUtc, "some folder", null, 0, importedFileUid, "some file");
var importedFilesList = new List <ImportedFile> {
newImportedFile
};
var mockConfigStore = new Mock <IConfigurationStore>();
var logger = ServiceProvider.GetRequiredService <ILoggerFactory>();
var serviceExceptionHandler = ServiceProvider.GetRequiredService <IServiceExceptionHandler>();
var projectRepo = new Mock <IProjectRepository>();
projectRepo.Setup(pr => pr.StoreEvent(It.IsAny <CreateImportedFileEvent>())).ReturnsAsync(1);
projectRepo.Setup(pr => pr.GetImportedFile(It.IsAny <string>())).ReturnsAsync(newImportedFile);
projectRepo.Setup(pr => pr.GetImportedFiles(It.IsAny <string>())).ReturnsAsync(importedFilesList);
var project = CreateProjectDetailModel(_customerTrn, _projectTrn);
var projectList = CreateProjectListModel(_customerTrn, _projectTrn);
var cwsProjectClient = new Mock <ICwsProjectClient>();
cwsProjectClient.Setup(ps => ps.GetMyProject(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <IHeaderDictionary>())).ReturnsAsync(project);
cwsProjectClient.Setup(ps => ps.GetProjectsForCustomer(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <bool>(), It.IsAny <CwsProjectType?>(), It.IsAny <ProjectStatus?>(), It.IsAny <bool>(), It.IsAny <IHeaderDictionary>())).ReturnsAsync(projectList);
var scheduler = new Mock <ISchedulerProxy>();
scheduler.Setup(s => s.ScheduleVSSJob(It.IsAny <JobRequest>(), It.IsAny <HeaderDictionary>())).ReturnsAsync(new ScheduleJobResult());
var executor = RequestExecutorContainerFactory
.Build <CreateImportedFileExecutor>(logger, mockConfigStore.Object, serviceExceptionHandler,
_customerUid.ToString(), _userUid.ToString(), _userEmailAddress, customHeaders,
projectRepo: projectRepo.Object, schedulerProxy: scheduler.Object,
cwsProjectClient: cwsProjectClient.Object);
var result = await executor.ProcessAsync(createImportedFile).ConfigureAwait(false) as ImportedFileDescriptorSingleResult;
Assert.NotNull(result);
Assert.Equal(0, result.Code);
Assert.NotNull(result.ImportedFileDescriptor);
Assert.Equal(_projectUid.ToString(), result.ImportedFileDescriptor.ProjectUid);
Assert.Equal(fileDescriptor.FileName, result.ImportedFileDescriptor.Name);
}
public async Task DeleteImportedFile_TRex_DesignSurface_WithReferenceSurface()
{
// FlowFile uploads the file from client (possibly as a background task via scheduler)
// Controller uploads file to TCC and/or S3
// V2 Note: BCC file has already put the file on TCC.
// the controller a) copies within TCC to client project (raptor)
// b) copies locally and hence to S3. (TRex)
var customHeaders = new HeaderDictionary();
var importedFileUid = Guid.NewGuid();
var parentUid = Guid.NewGuid();
var offset = 1.5;
var importedFileId = 9999;
var TCCFilePath = "/BC Data/Sites/Chch Test Site";
var fileName = "MoundRoad.ttm";
var fileDescriptor = FileDescriptor.CreateFileDescriptor(_fileSpaceId, TCCFilePath, fileName);
var referenceImportedFile = new ImportedFile
{
ProjectUid = _projectUid.ToString(),
ImportedFileUid = importedFileUid.ToString(),
LegacyImportedFileId = 200000,
ImportedFileType = ImportedFileType.DesignSurface,
Name = fileName,
FileDescriptor = JsonConvert.SerializeObject(fileDescriptor),
};
var parentImportedFile = new ImportedFile
{
ProjectUid = _projectUid.ToString(),
ImportedFileUid = parentUid.ToString(),
ImportedFileId = 998,
LegacyImportedFileId = 200001,
ImportedFileType = ImportedFileType.DesignSurface,
Name = fileDescriptor.FileName,
FileDescriptor = JsonConvert.SerializeObject(fileDescriptor),
ParentUid = parentUid.ToString(),
Offset = offset
};
var deleteImportedFile = new DeleteImportedFile(
_projectUid, ImportedFileType.DesignSurface, fileDescriptor,
importedFileUid, importedFileId, parentImportedFile.LegacyImportedFileId, "some folder", null
);
var referenceList = new List <ImportedFile> {
referenceImportedFile
};
var logger = ServiceProvider.GetRequiredService <ILoggerFactory>();
var serviceExceptionHandler = ServiceProvider.GetRequiredService <IServiceExceptionHandler>();
var tRexImportFileProxy = new Mock <ITRexImportFileProxy>();
tRexImportFileProxy.Setup(tr => tr.DeleteFile(It.IsAny <DesignRequest>(), It.IsAny <HeaderDictionary>())).ReturnsAsync(new ContractExecutionResult());
var filterServiceProxy = new Mock <IFilterServiceProxy>();
filterServiceProxy.Setup(fs => fs.GetFilters(It.IsAny <string>(), It.IsAny <HeaderDictionary>()))
.ReturnsAsync(new List <FilterDescriptor>().ToImmutableList);
var projectRepo = new Mock <IProjectRepository>();
projectRepo.Setup(pr => pr.StoreEvent(It.IsAny <DeleteImportedFileEvent>())).ReturnsAsync(1);
projectRepo.Setup(pr => pr.GetReferencedImportedFiles(It.IsAny <string>())).ReturnsAsync(referenceList);
var dataOceanClient = new Mock <IDataOceanClient>();
dataOceanClient.Setup(f => f.FileExists(It.IsAny <string>(), It.IsAny <HeaderDictionary>())).ReturnsAsync(true);
dataOceanClient.Setup(f => f.DeleteFile(It.IsAny <string>(), It.IsAny <HeaderDictionary>())).ReturnsAsync(true);
var authn = new Mock <ITPaaSApplicationAuthentication>();
authn.Setup(a => a.GetApplicationBearerToken()).Returns("some token");
var pegasusClient = new Mock <IPegasusClient>();
var executor = RequestExecutorContainerFactory
.Build <DeleteImportedFileExecutor>(
logger, null, serviceExceptionHandler, _customerUid.ToString(), _userUid.ToString(), _userEmailAddress,
customHeaders,
filterServiceProxy: filterServiceProxy.Object,
tRexImportFileProxy: tRexImportFileProxy.Object, projectRepo: projectRepo.Object, dataOceanClient: dataOceanClient.Object, authn: authn.Object, pegasusClient: pegasusClient.Object);
await Assert.ThrowsAsync <ServiceException>(async() =>
await executor.ProcessAsync(deleteImportedFile).ConfigureAwait(false));
}
public async Task CreateImportedFile_TRex_ReferenceSurface_NoParentDesign()
{
// FlowFile uploads the file from client (possibly as a background task via scheduler)
// Controller uploads file to TCC and/or S3
// V2 Note: BCC file has already put the file on TCC.
// the controller a) copies within TCC to client project (raptor)
// b) copies locally and hence to S3. (TRex)
var customHeaders = new HeaderDictionary();
var importedFileUid = Guid.NewGuid();
var parentUid = Guid.NewGuid();
var offset = 1.5;
var TCCFilePath = "/BC Data/Sites/Chch Test Site";
var fileName = "MoundRoad.ttm";
var fileDescriptor = FileDescriptor.CreateFileDescriptor(_fileSpaceId, TCCFilePath, fileName);
var fileCreatedUtc = DateTime.UtcNow.AddHours(-45);
var fileUpdatedUtc = fileCreatedUtc;
var newImportedFile = new ImportedFile
{
ProjectUid = _projectUid.ToString(),
ImportedFileUid = importedFileUid.ToString(),
ImportedFileId = 999,
LegacyImportedFileId = 200000,
ImportedFileType = ImportedFileType.ReferenceSurface,
Name = fileDescriptor.FileName,
FileDescriptor = JsonConvert.SerializeObject(fileDescriptor),
Offset = offset,
ParentUid = parentUid.ToString()
};
_ = new CreateImportedFileEvent
{
CustomerUID = _customerUid,
ProjectUID = _projectUid,
ImportedFileUID = importedFileUid,
ImportedFileType = ImportedFileType.ReferenceSurface,
DxfUnitsType = DxfUnitsType.Meters,
Name = fileDescriptor.FileName,
FileDescriptor = JsonConvert.SerializeObject(fileDescriptor),
FileCreatedUtc = fileCreatedUtc,
FileUpdatedUtc = fileUpdatedUtc,
ImportedBy = string.Empty,
SurveyedUTC = null,
ParentUID = parentUid,
Offset = offset,
ActionUTC = DateTime.UtcNow
};
var createImportedFile = new CreateImportedFile(
_projectUid, fileDescriptor.FileName, fileDescriptor, ImportedFileType.ReferenceSurface, null, DxfUnitsType.Meters,
DateTime.UtcNow.AddHours(-45), DateTime.UtcNow.AddHours(-44), "some folder", parentUid, offset, importedFileUid, "some file");
var importedFilesList = new List <ImportedFile> {
newImportedFile
};
var logger = ServiceProvider.GetRequiredService <ILoggerFactory>();
var serviceExceptionHandler = ServiceProvider.GetRequiredService <IServiceExceptionHandler>();
var tRexImportFileProxy = new Mock <ITRexImportFileProxy>();
tRexImportFileProxy.Setup(tr => tr.AddFile(It.IsAny <DesignRequest>(), It.IsAny <HeaderDictionary>())).ReturnsAsync(new ContractExecutionResult());
var projectRepo = new Mock <IProjectRepository>();
projectRepo.Setup(pr => pr.StoreEvent(It.IsAny <CreateImportedFileEvent>())).ReturnsAsync(1);
projectRepo.Setup(pr => pr.GetImportedFile(newImportedFile.ImportedFileUid)).ReturnsAsync(newImportedFile);
projectRepo.Setup(pr => pr.GetImportedFile(parentUid.ToString())).ReturnsAsync((ImportedFile)null);
projectRepo.Setup(pr => pr.GetImportedFiles(It.IsAny <string>())).ReturnsAsync(importedFilesList);
var executor = RequestExecutorContainerFactory
.Build <CreateImportedFileExecutor>(logger, null, serviceExceptionHandler,
_customerUid.ToString(), _userUid.ToString(), _userEmailAddress, customHeaders,
tRexImportFileProxy: tRexImportFileProxy.Object, projectRepo: projectRepo.Object);
await Assert.ThrowsAsync <ServiceException>(async() =>
await executor.ProcessAsync(createImportedFile).ConfigureAwait(false));
}
/// <summary>
/// Gets the <see cref="DesignDescriptor"/> from a given project's fileUid.
/// </summary>
public async Task<DesignDescriptor> GetAndValidateDesignDescriptor(
Guid projectUid, Guid? fileUid, string userUid, IHeaderDictionary customHeaders,
OperationType operation = OperationType.General)
{
if (!fileUid.HasValue)
{
return null;
}
var fileList = await _fileImportProxy.GetFiles(projectUid.ToString(), userUid, customHeaders);
if (fileList == null || fileList.Count == 0)
{
throw new ServiceException(HttpStatusCode.BadRequest,
new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError,
"Project has no appropriate design files."));
}
FileData file = null;
foreach (var f in fileList)
{
bool operationSupported = true;
switch (operation)
{
case OperationType.Profiling:
operationSupported = f.IsProfileSupportedFileType();
break;
default:
//All file types supported
break;
}
if (f.ImportedFileUid == fileUid.ToString() && f.IsActivated && operationSupported)
{
file = f;
break;
}
}
if (file == null)
{
throw new ServiceException(HttpStatusCode.BadRequest,
new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError,
"Unable to access design or alignment file."));
}
var tccFileName = file.Name;
if (file.ImportedFileType == ImportedFileType.SurveyedSurface)
{
//Note: ':' is an invalid character for filenames in Windows so get rid of them
tccFileName = Path.GetFileNameWithoutExtension(tccFileName) +
"_" + file.SurveyedUtc.Value.ToIso8601DateTimeString().Replace(":", string.Empty) +
Path.GetExtension(tccFileName);
}
//For TRex, need the parent design if it's a reference surface
if (file.ImportedFileType == ImportedFileType.ReferenceSurface)
{
var parent = fileList.FirstOrDefault(f => f.ImportedFileUid == file.ParentUid);
if (parent == null)
{
throw new ServiceException(HttpStatusCode.BadRequest,
new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError,
"Unable to access parent design file."));
}
fileUid = Guid.Parse(parent.ImportedFileUid);
file.LegacyFileId = parent.LegacyFileId;
tccFileName = parent.Name;
//The file.Path is CustomerUid + ProjectUid which should be the same for both
}
string fileSpaceId = _configStore.GetValueString("TCCFILESPACEID");
if (string.IsNullOrEmpty(fileSpaceId))
{
var errorString = "Your application is missing an environment variable TCCFILESPACEID";
_log.LogError(errorString);
throw new InvalidOperationException(errorString);
}
var fileDescriptor = FileDescriptor.CreateFileDescriptor(fileSpaceId, file.Path, tccFileName);
return new DesignDescriptor(file.LegacyFileId, fileDescriptor, file.Offset ?? 0.0, fileUid);
}
public void CanValidateInvalidFileDescriptor()
{
Assert.Throws <ServiceException>(() => FileDescriptor.CreateFileDescriptor("1", null, "3").Validate());
}
public void CanCreateFileDescriptor()
{
var desc = FileDescriptor.CreateFileDescriptor("1", "2.txt", "3");
Assert.NotNull(desc);
}
/// <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);
}
