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);
}
