Beispiel #1
0
        /// <summary>
        /// Add a string array of data
        /// </summary>
        public Task <string> SendImportedFilesToWebApiV5TBC(TestSupport ts, long projectId, string[] importFileArray, int row, HttpStatusCode statusCode = HttpStatusCode.OK)
        {
            var uri = $"api/v5/projects/{projectId}/importedfiles";
            var ed  = ts.ConvertImportFileArrayToObject(importFileArray, row);

            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = "u710e3466-1d47-45e3-87b8-81d1127ed4ed",
                Path               = Path.GetFullPath(ed.Name),
                Name               = Path.GetFileName(ed.Name),
                ImportedFileTypeId = ed.ImportedFileType,
                CreatedUtc         = ed.FileCreatedUtc,
                AlignmentFile      = ed.ImportedFileType == ImportedFileType.Alignment
                        ? new AlignmentFile {
                    Offset = 1
                } : null,
                SurfaceFile = ed.ImportedFileType == ImportedFileType.SurveyedSurface
          ? new SurfaceFile {
                    SurveyedUtc = new DateTime()
                } : null,
                LineworkFile = ed.ImportedFileType == ImportedFileType.Linework
        ? new LineworkFile {
                    DxfUnitsTypeId = DxfUnitsType.Meters
                } : null
            };

            var requestJson = JsonConvert.SerializeObject(importedFileTbc, new JsonSerializerSettings {
                DateTimeZoneHandling = DateTimeZoneHandling.Unspecified
            });

            return(RestClient.SendHttpClientRequest(uri, HttpMethod.Put, MediaTypes.JSON, MediaTypes.JSON, ts.CustomerUid.ToString(), requestJson, expectedHttpCode: statusCode));
        }
Beispiel #2
0
        public async Task <ReturnLongV5Result> UpsertImportedFileV5TBC(
            [FromRoute] long projectId,
            [FromBody] ImportedFileTbc importedFileTbc,
            [FromServices] ISchedulerProxy schedulerProxy)
        {
            // MobileLinework .kml/.kmz files are sent along with linework files
            //     we need to suppress any error and return as if all ok.
            //     however we won't have a LegacyFileId to return - hmmm hope Business centre ignores this
            if (importedFileTbc.ImportedFileTypeId == ImportedFileType.MobileLinework)
            {
                Logger.LogInformation(
                    $"{nameof(UpsertImportedFileV5TBC)}: Ignore MobileLinework from BusinessCentre. projectId {projectId} importedFile: {JsonConvert.SerializeObject(importedFileTbc)}");

                return(ReturnLongV5Result.CreateLongV5Result(HttpStatusCode.OK, -1));
            }

            // 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;

            importedFileTbc = FileImportV5TBCDataValidator.ValidateUpsertImportedFileRequest(new Guid(projectUid), importedFileTbc);
            Logger.LogInformation(
                $"{nameof(UpsertImportedFileV5TBC)}: projectId {projectId} projectUid {projectUid} importedFile: {JsonConvert.SerializeObject(importedFileTbc)}");

            var fileEntry = await TccHelper.GetFileInfoFromTccRepository(importedFileTbc, Logger, ServiceExceptionHandler, FileRepo);

            await TccHelper.CopyFileWithinTccRepository(importedFileTbc,
                                                        CustomerUid, projectUid, FileSpaceId,
                                                        Logger, ServiceExceptionHandler, FileRepo).ConfigureAwait(false);

            ImportedFileDescriptorSingleResult importedFileResult;

            using (var ms = await TccHelper.GetFileStreamFromTcc(importedFileTbc, Logger, ServiceExceptionHandler, FileRepo))
            {
                importedFileResult = await UpsertFileInternal(importedFileTbc.Name, ms, new Guid(projectUid),
                                                              importedFileTbc.ImportedFileTypeId,
                                                              importedFileTbc.ImportedFileTypeId == ImportedFileType.Linework
                                                              ?importedFileTbc.LineworkFile.DxfUnitsTypeId
                                                              : DxfUnitsType.Meters,
                                                              fileEntry.createTime, fileEntry.modifyTime,
                                                              importedFileTbc.ImportedFileTypeId == ImportedFileType.SurveyedSurface
                                                              ?importedFileTbc.SurfaceFile.SurveyedUtc
                                                              : (DateTime?)null, schedulerProxy);
            }

            // Automapper maps src.ImportedFileId to LegacyFileId, so this IS the one sent to TRex and used to ref via TCC
            var response = importedFileResult != null
        ? ReturnLongV5Result.CreateLongV5Result(HttpStatusCode.OK, importedFileResult.ImportedFileDescriptor.LegacyFileId)
        : ReturnLongV5Result.CreateLongV5Result(HttpStatusCode.InternalServerError, -1);

            Logger.LogInformation(
                $"{nameof(UpsertImportedFileV5TBC)}: Completed successfully. Response: {response} importedFile: {JsonConvert.SerializeObject(importedFileResult)}");

            return(response);
        }
Beispiel #3
0
        /// <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);
        }
Beispiel #4
0
        public void ValidateImportFile_CompleteDesignSurface()
        {
            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = _fileSpaceId,
                Path               = _path,
                Name               = "TheAlignment.ttm",
                ImportedFileTypeId = ImportedFileType.DesignSurface,
                CreatedUtc         = _createdUtc
            };

            FileImportV5TBCDataValidator.ValidateUpsertImportedFileRequest(_projectUid, importedFileTbc);
        }
Beispiel #5
0
        public void ValidateImportFile_CompleteLinework()
        {
            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = _fileSpaceId,
                Path               = _path,
                Name               = "TheLineWork.dxf",
                ImportedFileTypeId = ImportedFileType.Linework,
                CreatedUtc         = _createdUtc,
                LineworkFile       = new LineworkFile {
                    DxfUnitsTypeId = DxfUnitsType.ImperialFeet
                }
            };

            FileImportV5TBCDataValidator.ValidateUpsertImportedFileRequest(_projectUid, importedFileTbc);
        }
Beispiel #6
0
        public void ValidateImportFile_IncompleteLinework()
        {
            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = _fileSpaceId,
                Path               = _path,
                Name               = "TheLineWork.dxf",
                ImportedFileTypeId = ImportedFileType.Linework,
                CreatedUtc         = _createdUtc
            };

            var ex = Assert.Throws <ServiceException>(
                () => FileImportV5TBCDataValidator.ValidateUpsertImportedFileRequest(_projectUid, importedFileTbc));

            Assert.NotEqual(-1, ex.GetContent.IndexOf("2075", StringComparison.Ordinal));
        }
Beispiel #7
0
        public void ValidateImportFile_UnsupportedImportedFileType()
        {
            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = _fileSpaceId,
                Path               = _path,
                Name               = _name,
                ImportedFileTypeId = ImportedFileType.MassHaulPlan,
                CreatedUtc         = _createdUtc
            };

            var ex = Assert.Throws <ServiceException>(
                () => FileImportV5TBCDataValidator.ValidateUpsertImportedFileRequest(_projectUid, importedFileTbc));

            Assert.NotEqual(-1, ex.GetContent.IndexOf("2031", StringComparison.Ordinal));
        }
Beispiel #8
0
        public void ValidateImportFile_InvalidProjectId()
        {
            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = _fileSpaceId,
                Path               = _path,
                Name               = _name,
                ImportedFileTypeId = _importedFileTypeId,
                CreatedUtc         = _createdUtc
            };

            var ex = Assert.Throws <ServiceException>(
                () => FileImportV5TBCDataValidator.ValidateUpsertImportedFileRequest(new Guid(), importedFileTbc));

            Assert.NotEqual(-1, ex.GetContent.IndexOf("2005", StringComparison.Ordinal));
        }
Beispiel #9
0
        public void ValidateImportFile_CompleteAlignment()
        {
            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = _fileSpaceId,
                Path               = _path,
                Name               = "TheAlignment.svl",
                ImportedFileTypeId = ImportedFileType.Alignment,
                CreatedUtc         = _createdUtc,
                AlignmentFile      = new AlignmentFile {
                    Offset = 3
                }
            };

            FileImportV5TBCDataValidator.ValidateUpsertImportedFileRequest(_projectUid, importedFileTbc);
        }
Beispiel #10
0
        public void ValidateImportFile_CompleteSurveyedSurface()
        {
            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = _fileSpaceId,
                Path               = _path,
                Name               = "TheSurfaceFile.ttm",
                ImportedFileTypeId = ImportedFileType.SurveyedSurface,
                CreatedUtc         = _createdUtc,
                SurfaceFile        = new SurfaceFile {
                    SurveyedUtc = DateTime.UtcNow.AddDays(-1)
                }
            };

            FileImportV5TBCDataValidator.ValidateUpsertImportedFileRequest(_projectUid, importedFileTbc);
        }
Beispiel #11
0
        public async Task CopyTCCFile()
        {
            var serviceExceptionHandler = ServiceProvider.GetRequiredService <IServiceExceptionHandler>();

            var importedFileTbc = new ImportedFileTbc
            {
                FileSpaceId        = _fileSpaceId,
                Name               = "MoundRoadlinework.dxf",
                Path               = "/BC Data/Sites/Chch Test Site/Designs/Mound Road",
                ImportedFileTypeId = ImportedFileType.Linework,
                CreatedUtc         = DateTime.UtcNow
            };

            var fileRepo = new Mock <IFileRepository>();

            fileRepo.Setup(fr => fr.FolderExists(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(true);
            fileRepo.Setup(fr => fr.CopyFile(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(true);

            await TccHelper.CopyFileWithinTccRepository(importedFileTbc,
                                                        _customerUid.ToString(), Guid.NewGuid().ToString(), "f9sdg0sf9",
                                                        _log, serviceExceptionHandler, fileRepo.Object).ConfigureAwait(false);
        }
Beispiel #12
0
        /// <summary>
        /// Validate the Upsert request i.e. that the parameters are as expected.
        /// </summary>
        /// <param name="projectId"></param>
        /// <param name="importedFile"></param>
        public static ImportedFileTbc ValidateUpsertImportedFileRequest(Guid projectUid,
                                                                        ImportedFileTbc importedFile)
        {
            if (projectUid == Guid.Empty)
            {
                throw new ServiceException(HttpStatusCode.BadRequest,
                                           new ContractExecutionResult(projectErrorCodesProvider.GetErrorNumberwithOffset(5),
                                                                       projectErrorCodesProvider.FirstNameWithOffset(5)));
            }

            if (!Enum.IsDefined(typeof(ImportedFileType), importedFile.ImportedFileTypeId))
            {
                throw new ServiceException(HttpStatusCode.BadRequest,
                                           new ContractExecutionResult(projectErrorCodesProvider.GetErrorNumberwithOffset(30),
                                                                       projectErrorCodesProvider.FirstNameWithOffset(30)));
            }

            if (!(importedFile.ImportedFileTypeId >= ImportedFileType.Linework && importedFile.ImportedFileTypeId <= ImportedFileType.Alignment))
            {
                throw new ServiceException(HttpStatusCode.BadRequest,
                                           new ContractExecutionResult(projectErrorCodesProvider.GetErrorNumberwithOffset(31),
                                                                       projectErrorCodesProvider.FirstNameWithOffset(31)));
            }

            ProjectDataValidator.ValidateBusinessCentreFile(importedFile);


            if (importedFile.ImportedFileTypeId == ImportedFileType.Linework &&
                (importedFile.LineworkFile == null ||
                 !Enum.IsDefined(typeof(DxfUnitsType), importedFile.LineworkFile.DxfUnitsTypeId))
                )
            {
                throw new ServiceException(HttpStatusCode.BadRequest,
                                           new ContractExecutionResult(projectErrorCodesProvider.GetErrorNumberwithOffset(75),
                                                                       projectErrorCodesProvider.FirstNameWithOffset(75)));
            }

            if (importedFile.ImportedFileTypeId == ImportedFileType.SurveyedSurface &&
                (importedFile.SurfaceFile == null ||
                 importedFile.SurfaceFile.SurveyedUtc < DateTime.UtcNow.AddYears(-30) || importedFile.SurfaceFile.SurveyedUtc > DateTime.UtcNow.AddDays(2))
                )
            {
                throw new ServiceException(HttpStatusCode.BadRequest,
                                           new ContractExecutionResult(projectErrorCodesProvider.GetErrorNumberwithOffset(33),
                                                                       projectErrorCodesProvider.FirstNameWithOffset(33)));
            }

            if (importedFile.ImportedFileTypeId == ImportedFileType.Alignment &&
                importedFile.AlignmentFile == null)
            {
                throw new ServiceException(HttpStatusCode.BadRequest,
                                           new ContractExecutionResult(projectErrorCodesProvider.GetErrorNumberwithOffset(95),
                                                                       projectErrorCodesProvider.FirstNameWithOffset(95)));
            }

            var fileExtension = Path.GetExtension(importedFile.Name).ToLower();

            if (!(
                    (importedFile.ImportedFileTypeId == ImportedFileType.Linework && fileExtension == ".dxf") ||
                    (importedFile.ImportedFileTypeId == ImportedFileType.DesignSurface && fileExtension == ".ttm") ||
                    (importedFile.ImportedFileTypeId == ImportedFileType.SurveyedSurface && fileExtension == ".ttm") ||
                    (importedFile.ImportedFileTypeId == ImportedFileType.Alignment && fileExtension == ".svl")
                    ))
            {
                throw new ServiceException(HttpStatusCode.BadRequest,
                                           new ContractExecutionResult(projectErrorCodesProvider.GetErrorNumberwithOffset(32),
                                                                       projectErrorCodesProvider.FirstNameWithOffset(32)));
            }

            return(importedFile);
        }