public MockGenerator MockToolsAndContentDlls() { var packageId = Path.GetFileNameWithoutExtension(NupkgFile); NugetPackage.Setup(x => x.GetSupportedFrameworks()).Returns(PackageFrameworks); NugetPackage.Setup(x => x.Id).Returns(packageId); NugetPackage.Setup(x => x.Version).Returns(new SemanticVersion("1.0.0.0")); var mockPackageFileTools = new Mock <IPackageFile>(MockBehavior.Strict); mockPackageFileTools.Setup(x => x.Path).Returns(@"tOols\myToolsSample.dLl"); var mockPackageFileContent = new Mock <IPackageFile>(MockBehavior.Strict); mockPackageFileContent.Setup(x => x.Path).Returns(@"contenT\myToolsSample.dLl"); PackageFiles.Add(mockPackageFileTools); PackageFiles.Add(mockPackageFileContent); var packageDir = Path.GetDirectoryName(NupkgFile); FileSystem.Setup(x => x.DirectoryGetFiles(packageDir, "*.dll", SearchOption.AllDirectories)) .Returns(PackageFiles.Select(x => Path.Combine(packageDir, x.Object.Path)).ToArray()); return(this); }
public void should_backup_a_changed_file() { Context(); var packageFile = new PackageFile { Path = filePath, Checksum = "1234" }; packageFiles.Files.Add(packageFile); packageInfo.FilesSnapshot = packageFiles; var packageFileWithUpdatedChecksum = new PackageFile { Path = filePath, Checksum = "4321" }; var fileSystemFiles = new List <string>() { filePath }; fileSystem.Setup(x => x.get_files(It.IsAny <string>(), It.IsAny <string>(), SearchOption.AllDirectories)).Returns(fileSystemFiles); var updatedPackageFiles = new PackageFiles(); updatedPackageFiles.Files = new List <PackageFile> { packageFileWithUpdatedChecksum }; filesService.Setup(x => x.capture_package_files(It.IsAny <string>(), config)).Returns(updatedPackageFiles); because(); fileSystem.Verify(x => x.copy_file(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()), Times.Once); }
private void Update() { Indices.Clear(); LoadedInstanceIds.Clear(); LoadedGroupIds.Clear(); LoadedFileTypeIds.Clear(); foreach (DatabasePackedFile packed in PackageFiles) { Indices.AddRange(packed.Indices); } foreach (DatabaseIndex index in Indices) { if (!LoadedInstanceIds.Contains(index.InstanceId)) { LoadedInstanceIds.Add(index.InstanceId); } if (!LoadedGroupIds.Contains(index.GroupId)) { LoadedGroupIds.Add(index.GroupId); } if (!LoadedFileTypeIds.Contains(index.TypeId)) { LoadedFileTypeIds.Add(index.TypeId); } } Indices.Changed(); PackageFiles.Changed(); }
public MockGenerator MockLibFxDll() { var mockPackageFile = new Mock <IPackageFile>(MockBehavior.Strict); mockPackageFile.Setup(x => x.Path).Returns(@"Lib\dnx451\myLibFxSample.dLl"); PackageFiles.Add(mockPackageFile); FileSystem.Setup(x => x.FileExists(Path.Combine(Path.GetDirectoryName(NupkgFile), @"Lib\dnx451\myLibFxSample.dLl"))).Returns(true); var packageFiles = new List <IPackageFile> { mockPackageFile.Object }; var assemblyMetadata = new AssemblyMetadata { FullPath = Path.Combine(Path.GetDirectoryName(NupkgFile), @"Lib\dnx451\myLibFxSample.dLl"), TargetFrameworks = new List <string> { "dnx451" } }; PackageAssemblyMetadata.Add(assemblyMetadata); var packageDir = Path.GetDirectoryName(NupkgFile); FileSystem.Setup(x => x.DirectoryGetFiles(packageDir, "*.dll", SearchOption.AllDirectories)) .Returns(PackageFiles.Select(x => Path.Combine(packageDir, x.Object.Path)).ToArray()); return(this); }
public void ClosePackage(DatabasePackedFile package) { if (PackageFiles.Remove(package)) { Update(); } }
public async Task <IActionResult> Post([FromBody] UploadPackageRequestDto uploadPackageRequestDto) { IList <PackageFile> files = uploadPackageRequestDto.PackageFiles .Select(file => new PackageFile(file.FileName, file.FileContent)) .ToList(); // put a hard limit on the amount of files per package for now if (files.Count > 99) { return(this.BadRequest("can not have more then 100 items in a package")); } PackageFile ethereumPm = files.FirstOrDefault(f => f.FileName == Constants.EthereumPmJson); if (ethereumPm == null) { return(this.BadRequest("To upload a package you need a `ethereum-pm.json` file")); } JObject ethereumPmJson; try { ethereumPmJson = JObject.Parse(ethereumPm.FileContent); } catch (Exception) { return(this.BadRequest("Invalid JSON - `ethereum-pm.json`")); } EthereumPmMetaData metaData = new EthereumPmMetaData() { Description = (string)ethereumPmJson["description"], GitHub = (string)ethereumPmJson["github"], Private = (bool?)ethereumPmJson["private"] ?? false, Team = (string)ethereumPmJson["team"], Keywords = (IList <string>)ethereumPmJson["keywords"] }; PackageFiles packageFiles = new PackageFiles ( uploadPackageRequestDto.PackageVersion, uploadPackageRequestDto.PackageName, (IReadOnlyCollection <PackageFile>)files ); try { UnpackedJwt unpackedJwt = this._jwtService.UnpackJwtClaimsToProfile(User.Claims.ToList()); await this._packageService.UploadPackageAsync(packageFiles, metaData, unpackedJwt.Username); } catch (Exception ex) { return(this.BadRequest(ex)); } return(this.Ok()); }
public void SetUp() { var exploder = new PackageExploder(new ZipFileService(), new PackageExploderLogger(s => Console.WriteLine(s)), new FileSystem()); theFiles = new PackageFiles(); exploder.ExplodeAssembly("app1", typeof(AssemblyPackageMarker).Assembly, theFiles); }
public void save_to_file(PackageFiles snapshot, string filePath) { if (snapshot == null) { return; } _xmlService.serialize(snapshot, filePath); }
public void should_not_do_anything_if_the_snapshot_is_null() { Context(); files = null; because(); XmlService.Verify(x => x.serialize(files, It.IsAny <string>()), Times.Never); }
public override void Context() { base.Context(); package.Setup(x => x.Id).Returns("bob"); packageInfo = new ChocolateyPackageInformation(package.Object); packageInfo.FilesSnapshot = new PackageFiles(); packageFiles = new PackageFiles(); fileSystem.Setup(x => x.directory_exists(It.IsAny <string>())).Returns(true); }
public void should_save_if_the_snapshot_is_not_null() { Context(); files = new PackageFiles(); because(); XmlService.Verify(x => x.serialize(files, It.IsAny <string>()), Times.Once()); }
public void SetUp() { var fileSystem = new FileSystem(); fileSystem.DeleteDirectory("app1"); var exploder = new BottleExploder(new ZipFileService(fileSystem), new BottleExploderLogger(s => ConsoleWriter.Write(s)), fileSystem); var thePackage = new PackageInfo(new PackageManifest()); theFiles = (PackageFiles)thePackage.Files; exploder.ExplodeAssembly("app1", typeof(AssemblyPackageMarker).Assembly, thePackage); }
public async Task <IActionResult> Get([FromRoute] string packageName, [FromRoute] string version) { string jwtUsername = string.Empty; if (User != null) { UnpackedJwt unpackedJwt = this._jwtService.UnpackJwtClaimsToProfile(User.Claims.ToList()); jwtUsername = unpackedJwt.Username; } PackageFiles packageFiles = await this._packageService.GetPackageFilesAsync(packageName, version, jwtUsername); return(this.Ok(packageFiles)); }
public PackageFiles capture_package_files(string directory, ChocolateyConfiguration config) { var packageFiles = new PackageFiles(); if (!package_install_directory_is_correct(directory)) return packageFiles; this.Log().Debug(() => "Capturing package files in '{0}'".format_with(directory)); //gather all files in the folder var files = _fileSystem.get_files(directory, pattern: "*.*", option: SearchOption.AllDirectories); foreach (string file in files.or_empty_list_if_null().Where(f => !f.EndsWith(ApplicationParameters.PackagePendingFileName))) { packageFiles.Files.Add(get_package_file(file)); } return packageFiles; }
private void load(string file) { //see if the package is already loaded foreach (DatabasePackedFile packed in PackageFiles) { if (packed.packageFileInfo.FullName.Equals(file)) { return; } } DatabasePackedFile package = DatabasePackedFile.LoadFromFile(file); package.Indices.CollectionChanged += PackageIndicesChanged; PackageFiles.Add(package); }
public MockGenerator MockLibExplicitReferencesDll() { var mockPackageFile = new Mock <IPackageFile>(MockBehavior.Strict); mockPackageFile.Setup(x => x.Path).Returns(@"lib\dnx451\mylibfxsample.dll"); var mockPackageFileCore = new Mock <IPackageFile>(MockBehavior.Strict); mockPackageFileCore.Setup(x => x.Path).Returns(@"lib\dnx451\mylibfxsample2.dll"); PackageFiles.Add(mockPackageFile); PackageFiles.Add(mockPackageFileCore); FileSystem.Setup(x => x.FileExists(Path.Combine(Path.GetDirectoryName(NupkgFile), @"lib\dnx451\mylibfxsample.dll"))).Returns(true); var packageFiles = new List <IPackageFile> { mockPackageFile.Object, mockPackageFileCore.Object }; var assemblyMetadataDnx451 = new AssemblyMetadata { FullPath = Path.Combine(Path.GetDirectoryName(NupkgFile), @"lib\dnx451\mylibfxsample.dll"), TargetFrameworks = new List <string> { "dnx451" } }; PackageAssemblyMetadata.Add(assemblyMetadataDnx451); NugetPackage.Setup(x => x.PackageAssemblyReferences).Returns(new List <PackageReferenceSet> { new PackageReferenceSet(DnxVersionUtility.ParseFrameworkName("dnx451"), new [] { @"mylibfxsample.dll" }) }); var packageDir = Path.GetDirectoryName(NupkgFile); FileSystem.Setup(x => x.DirectoryGetFiles(packageDir, "*.dll", SearchOption.AllDirectories)) .Returns(PackageFiles.Select(x => Path.Combine(packageDir, x.Object.Path)).ToArray()); return(this); }
public void AddDirectory() { if (SelectedLink != null) { var validFolderName = GetValidName(newFolderName, SelectedLink.Children); SelectedLink.Children.Add(new ItemLink { OutputFilename = validFolderName, IsDirectory = true }); } else { var validFolderName = GetValidName(newFolderName, PackageFiles); PackageFiles.Add(new ItemLink { OutputFilename = validFolderName, IsDirectory = true }); } }
public PackageFiles capture_package_files(string directory, ChocolateyConfiguration config) { var packageFiles = new PackageFiles(); if (!package_install_directory_is_correct(directory)) { return(packageFiles); } this.Log().Debug(() => "Capturing package files in '{0}'".format_with(directory)); //gather all files in the folder var files = _fileSystem.get_files(directory, pattern: "*.*", option: SearchOption.AllDirectories); foreach (string file in files.or_empty_list_if_null()) { packageFiles.Files.Add(get_package_file(file)); } return(packageFiles); }
public PackageFiles capture_package_files(string directory, ChocolateyConfiguration config) { var packageFiles = new PackageFiles(); if (directory.is_equal_to(ApplicationParameters.InstallLocation) || directory.is_equal_to(ApplicationParameters.PackagesLocation)) { var logMessage = "Install location is not specific enough, cannot capture files:{0} Erroneous install location captured as '{1}'".format_with(Environment.NewLine, directory); this.Log().Error(logMessage); return packageFiles; } this.Log().Debug(() => "Capturing package files in '{0}'".format_with(directory)); //gather all files in the folder var files = _fileSystem.get_files(directory, pattern: "*.*", option: SearchOption.AllDirectories); foreach (string file in files.or_empty_list_if_null()) { packageFiles.Files.Add(get_package_file(file)); } return packageFiles; }
public PackageFiles capture_package_files(string directory, ChocolateyConfiguration config) { var packageFiles = new PackageFiles(); if (directory.is_equal_to(ApplicationParameters.InstallLocation) || directory.is_equal_to(ApplicationParameters.PackagesLocation)) { var logMessage = "Install location is not specific enough, cannot capture files:{0} Erroneous install location captured as '{1}'".format_with(Environment.NewLine, directory); this.Log().Error(logMessage); return(packageFiles); } this.Log().Debug(() => "Capturing package files in '{0}'".format_with(directory)); //gather all files in the folder var files = _fileSystem.get_files(directory, pattern: "*.*", option: SearchOption.AllDirectories); foreach (string file in files.or_empty_list_if_null()) { packageFiles.Files.Add(get_package_file(file)); } return(packageFiles); }
public Save AddPackageFile(PackageFiles file) { using (var client = new LLCContext()) { Console.WriteLine("Adding package file"); client.PackageFiles.Add(file); try { client.SaveChanges(); return(new Save { Status = true }); } catch (Exception e) { Console.WriteLine(e.Message); return(new Save { Status = false }); } } }
// Signature specifies Task private static async Task TransferAsync(string Password) { await Task.Run(() => { if (MassStorage.AvailableFreeSpace >= PSS * 2) { PackageFiles Packs = new PackageFiles(DetectedFiles, PSS, MassStorage.AvailableFreeSpace); int PackCounter = 1; long allSize = 0; foreach (var PackReader in Packs) { if (CTS.IsCancellationRequested) { DetectedFiles.PushRange(PackReader); // ReLoad Pop data, because data not stored! break; } long PackSize = PackReader.AsParallel().Sum(f => f.Length); allSize += PackSize; Reporter("TransformPhysicalDisk", new ReportEventArgs("TransformPhysicalDisk.TransferAsync", ReportCodes.PackagingStarted, "Packaging [{0}] by Size: [{1}] bytes", PackCounter, PackSize)); if (!ZipE.ZipFiles(PackReader, GetTrustFileName(), CTS)) { CTS.Cancel(); DetectedFiles.PushRange(PackReader); // ReLoad Pop data, because data not stored! Reporter("TransformPhysicalDisk", new ReportEventArgs("TransformPhysicalDisk.TransferAsync", ReportCodes.PackagingDone, "Pack [{0}] by Size: [{1}] bytes Rejected", PackCounter++, PackSize)); break; } TransferredFiles.PushRange(PackReader); Reporter("TransformPhysicalDisk", new ReportEventArgs("TransformPhysicalDisk.TransferAsync", ReportCodes.PackagingDone, "Pack [{0}] by Size: [{1}] bytes Transferred", PackCounter++, PackSize)); } Reporter("TransformPhysicalDisk", new ReportEventArgs("TransformPhysicalDisk.TransferAsync", ReportCodes.PackagingDone, "Packaging Complete {0} Packs, Total Packs Size is [{1}] bytes", PackCounter, allSize)); /// ----------------------------------- /// } }); }
public void save_to_file(PackageFiles snapshot, string filePath) { if (snapshot == null) return; _xmlService.serialize(snapshot, filePath); }
public void TestBackupRemove() { InstallContext.Instance.RootLocation = Path.Combine("c:", "choco"); string filePath = Path.Combine("c:", "choco", "lib", "somelib", "license.txt"); string fileConfPath = Path.Combine("c:", "choco", "lib", "somelib", "myconf.xml"); string filePath2 = Path.Combine("c:", "choco", "lib", "somelib", "license2.txt"); RegistryPackage package = new RegistryPackage(); package.Id = "Bob"; package.Version = new SemanticVersion(1, 2, 3, 4); var packageInfo = new ChocolateyPackageInformation(package); var packageFile = new PackageFile { Path = filePath, Checksum = "1234" }; var packageFiles = new PackageFiles() { Files = new List <PackageFile> { packageFile } }; packageInfo.FilesSnapshot = packageFiles; var fileSystemFiles = new [] { filePath }; var config = new ChocolateyConfiguration(); fileSystem.Setup(x => x.get_files(It.IsAny <string>(), It.IsAny <string>(), SearchOption.AllDirectories)).Returns(fileSystemFiles); filesService.Setup(x => x.capture_package_files(It.IsAny <string>(), config)).Returns(packageFiles); using (new LogScope("should_ignore_an_unchanged_file")) { service.backup_changed_files(filePath, config, packageInfo); } var updatedPackageFiles = new PackageFiles() { Files = new List <PackageFile> { new PackageFile { Path = filePath, Checksum = "4321" } } }; using (new LogScope("should_backup_a_changed_file")) { filesService.Setup(x => x.capture_package_files(It.IsAny <string>(), config)).Returns(updatedPackageFiles); service.backup_changed_files(filePath, config, packageInfo); } using (new LogScope("if_snapshot_not_available_should_backup_files_in_folder")) //new case { var confFiles = new[] { fileConfPath }; fileSystem.Setup(x => x.get_files(It.IsAny <string>(), It.IsAny <string[]>(), SearchOption.AllDirectories)).Returns(confFiles); packageInfo.FilesSnapshot = null; service.backup_changed_files(filePath, config, packageInfo); } using (new LogScope("should_do_nothing_if_the_directory_no_longer_exists")) { fileSystem.Setup(x => x.directory_exists(It.IsAny <string>())).Returns(false); filesService.Setup(x => x.get_package_file(It.IsAny <string>())).Returns(packageFile); service.remove_installation_files(package, packageInfo); } using (new LogScope("should_remove_an_unchanged_file")) { fileSystem.Setup(x => x.directory_exists(It.IsAny <string>())).Returns(true); fileSystem.Setup(x => x.get_files(It.IsAny <string>(), It.IsAny <string>(), SearchOption.AllDirectories)).Returns(fileSystemFiles); fileSystem.Setup(x => x.file_exists(filePath)).Returns(true); service.remove_installation_files(package, packageInfo); } using (new LogScope("should_not_delete_a_changed_file")) { filesService.Setup(x => x.get_package_file(It.IsAny <string>())).Returns(updatedPackageFiles.Files[0]); service.remove_installation_files(package, packageInfo); } using (new LogScope("should_not_delete_an_unfound_file")) { var packageFileNotInOriginal = new PackageFile { Path = filePath2, Checksum = "4321" }; filesService.Setup(x => x.get_package_file(It.IsAny <string>())).Returns(packageFileNotInOriginal); service.remove_installation_files(package, packageInfo); } using (new LogScope("generated_package_should_be_in_current_directory")) { fileSystem.Setup(x => x.get_current_directory()).Returns("c:/choco"); service.pack_noop(config); } using (new LogScope("generated_package_should_be_in_specified_directory")) { config.OutputDirectory = "c:/packages"; service.pack_noop(config); } }
public PackageFilesDisplayProxy(PackageFiles original) { UnevaluatedInclude = original.UnevaluatedInclude; }
public void CloseAll() { PackageFiles.Clear(); Update(); }
private void ProcessLink(Regex r, string path, string href, Packages package) { Console.WriteLine(path + href); var text = File.ReadAllText(path + href); var matchList = r.Matches(text); var source = Service.Source("Package Uploads", Models.Admin.SearchType.SourceName); if (matchList.Count > 0) { // One or more links were found so we'll include each in the bulk update foreach (Match m in matchList) { // Allow send through URLs up to 1024 in length to avoid errors string url = m.Groups[1].Value; url = (url.Length >= MaxUrlLength ? url.Substring(0, MaxUrlLength - 1) : url); // Check the link for existance var link = Service.LinkFromUrl(url); if (link == null) { Console.WriteLine($"Adding link {url}"); var now = DateTime.Now; link = new Links { AllTimeMaxDownloadTime = 0, AllTimeMinDownloadTime = 0, AllTimeStdDevDownloadTime = 0, AttemptCount = 0, DateFirstFound = now, DateLastChecked = null, DateLastFound = null, DateUpdated = null, DisabledDate = null, DisabledUser = null, Id = Guid.NewGuid().ToString(), PastWeekMaxDownloadTime = 0, PastWeekMinDownloadTime = 0, PastWeekStdDevDownloadTime = 0, ReportNotBeforeDate = null, Source = source.Id, Url = url, Valid = true }; Service.AddLink(link); } var uri = new Uri(url); var split = href.Split(Path.DirectorySeparatorChar); string parent = null; if (split != null && split.Length > 1) { parent = split[split.Length - 2]; } // Add the link package course location var newFile = new PackageFiles { CourseLocation = href, Id = Guid.NewGuid().ToString(), Link = link.Id, LinkName = m.Groups[2].Value, PackageId = package.Id, ParentFolder = parent, Protocol = uri.Scheme }; Service.AddPackageFile(newFile); } } else { // No links found but we'll include the object in the update without a url (maybe?) } }
public override bool HasPackageScriptsToRun () { BeforeExecute (); var files = new PackageFiles (Package); return files.HasUninstallPackageScript(); }
void CreatePackageFiles(FakePackage package) { packageFiles = new PackageFiles(package); }
public override void Because() { _result = Service.capture_package_files(_packageResult, _config); }
/// <summary> /// /// </summary> /// <param name="packageFiles"></param> /// <param name="ethereumPmMetaData"></param> /// <param name="jwtUsername"></param> /// <returns></returns> public async Task UploadPackageAsync(PackageFiles packageFiles, EthereumPmMetaData ethereumPmMetaData, string jwtUsername) { PackageDetailsEntity packageDetails = await this._dynamoDbService.GetItemAsync <PackageDetailsEntity>(packageFiles.PackageName); // if it is null then its a brand new package if (packageDetails == null) { // should be in a transaction which i will put in, as if one of these // fails then i want to roll back all the data, i don't really want to // to insert then delete so will look at dynamodb to see if this rollback // logic exists TeamsEntity teamsEntity = null; // if it is a package for a team if (!string.IsNullOrEmpty(ethereumPmMetaData.Team)) { teamsEntity = await this._dynamoDbService.GetItemAsync <TeamsEntity>(ethereumPmMetaData.Team); if (teamsEntity == null) { throw new Exception("Team does not exists"); } packageDetails = new PackageDetailsEntity { PackageName = packageFiles.PackageName, Version = new List <string> { packageFiles.Version }, Description = ethereumPmMetaData.Description, Keywords = ethereumPmMetaData.Keywords, Private = ethereumPmMetaData.Private, Team = ethereumPmMetaData.Team, GitHub = ethereumPmMetaData.GitHub, Owner = ethereumPmMetaData.Team, LatestVersion = packageFiles.Version, Deprecated = false, CreatedOn = DateTime.UtcNow }; } else { packageDetails = new PackageDetailsEntity { PackageName = packageFiles.PackageName, Version = new List <string> { packageFiles.Version }, Description = ethereumPmMetaData.Description, Keywords = ethereumPmMetaData.Keywords, Private = ethereumPmMetaData.Private, Team = ethereumPmMetaData.Team, GitHub = ethereumPmMetaData.GitHub, Owner = jwtUsername, LatestVersion = packageFiles.Version, Deprecated = false, AdminUsers = new List <string> { jwtUsername }, Users = new List <string> { jwtUsername }, CreatedOn = DateTime.UtcNow }; } await this._dynamoDbService.PutItemAsync <PackageDetailsEntity>(packageDetails); if (teamsEntity != null) { if (teamsEntity.Packages == null || teamsEntity.Packages.GetType() != typeof(List <string>)) { teamsEntity.Packages = new List <string>(); } teamsEntity.Packages.Add(packageFiles.PackageName); await this._dynamoDbService.PutItemAsync <TeamsEntity>(teamsEntity); } else { // as they have authenticated with the request the user should always exist // do not want to do a load on db to check each time UsersEntity usersEntity = await this._dynamoDbService.GetItemAsync <UsersEntity>(jwtUsername); if (usersEntity.Packages == null || usersEntity.Packages.GetType() != typeof(List <string>)) { usersEntity.Packages = new List <string>(); } usersEntity.Packages.Add(packageFiles.PackageName); await this._dynamoDbService.PutItemAsync <UsersEntity>(usersEntity); } } else { if (!this.UpdatingPackageHigherVersionThenCurrent(packageDetails.LatestVersion, packageFiles.Version)) { throw new Exception("Your package version is not higher then the current one"); } bool allowedToUpdatePackage = await this.AllowedToUpdatePackageAsync(packageDetails.Team, packageDetails.AdminUsers, jwtUsername); if (!allowedToUpdatePackage) { throw new Exception("You are not allowed to update this package"); } packageDetails.Version.Add(packageFiles.Version); packageDetails.GitHub = ethereumPmMetaData.GitHub; packageDetails.LatestVersion = packageFiles.Version; packageDetails.Description = ethereumPmMetaData.Description; packageDetails.Keywords = ethereumPmMetaData.Keywords; await this._dynamoDbService.PutItemAsync <PackageDetailsEntity>(packageDetails); } // upload the files last, this means it all has been successfully inserted into // the db string keyName = $"{packageFiles.PackageName}/{packageFiles.Version}"; await this._s3Service.UploadFilesAsync(packageFiles.Files.ToS3Files(), keyName); }