public async Task <PatchUpdatePackageResponse?> Handle(PatchUpdatePackageRequest message)
{
var updatePackage = await _updatePackageRepository.GetFirstOrDefaultBySpecs(
new ProjectSpec(message.ProjectId), new VersionSpec(message.CurrentVersion),
new IncludeAllSpec());
if (updatePackage == null)
{
return(ReturnError(ResourceNotFoundError.UpdatePackageNotFound(message.ProjectId, message.CurrentVersion.ToString(false))));
}
await UpdateFiles(updatePackage, message.UpdatePackage, message.AsymmetricKeyPassword);
if (HasError)
{
return(default);
public async Task <CreateUpdatePackageResponse?> Handle(CreateUpdatePackageRequest message)
{
var project = await _projectRepository.GetById(message.ProjectId);
if (project == null)
{
return(ReturnError(ResourceNotFoundError.ProjectNotFound(message.ProjectId)));
}
var package = message.UpdatePackage;
var updatePackage = new UpdatePackage(package.Version, message.ProjectId);
updatePackage.Description = package.Description;
updatePackage.CustomFields = package.CustomFields;
if (!CopyChangelogs(updatePackage, package.Changelogs))
{
return(null); // error
}
await _addFilesAction.AddFiles(updatePackage, package.Files, message.AsymmetricKeyPassword);
if (InheritError(_addFilesAction))
{
return(null); // error
}
CopyDistributions(updatePackage, package.Distributions);
try
{
await _updatePackageRepository.Add(updatePackage);
}
catch (Exception)
{
if (await _updatePackageRepository.GetFirstOrDefaultBySpecs(new ProjectSpec(project.Id),
new VersionSpec(updatePackage.VersionInfo.SemVersion)) != null)
{
SetError(new UpdatePackageAlreadyExistsError());
return(null);
}
throw;
}
await _updatePackageRepository.OrderUpdatePackages(message.ProjectId, updatePackage.VersionInfo.SemVersion);
return(new CreateUpdatePackageResponse(updatePackage.Id));
}
public async Task <ActionResult <UpdatePackageDto> > GetUpdatePackage(int projectId, string version, [FromServices] AppDbContext context)
{
if (!SemVersion.TryParse(version, out var semVersion))
{
return(new UrlParameterValidationError("Invalid version").ToActionResult());
}
var query = context.UpdatePackages.Where(x => x.ProjectId == projectId && x.VersionInfo.Version == semVersion !.ToString(false));
var package = await _mapper.ProjectTo <UpdatePackageDto>(query).FirstOrDefaultAsync();
if (package == null)
{
return(ResourceNotFoundError.UpdatePackageNotFound(projectId, version).ToActionResult());
}
return(package);
}
public async Task AddFiles(UpdatePackage package, IEnumerable <UpdateFileInfo> files, string?keyPassword)
{
var project = await _projectRepository.GetById(package.ProjectId);
if (project == null)
{
SetError(ResourceNotFoundError.ProjectNotFound(package.ProjectId));
return;
}
var signatureFactory = CreateFileSignatureFactory(project.AsymmetricKey, keyPassword);
if (signatureFactory == null)
{
return; // error
}
foreach (var file in files)
{
if (string.IsNullOrEmpty(file.Path))
{
SetError(new FieldValidationError("Files", "The path of a file must not be empty"));
return;
}
var storedFile = await _filesRepository.FindByHash(file.Hash);
if (storedFile == null)
{
SetError(new StoredFileNotFoundError(file.Hash));
return;
}
var signature = signatureFactory(file);
if (signature == null)
{
return; // error
}
var updateFile = new UpdateFile(file.Path, file.Hash.ToString(), signature);
package.AddFile(updateFile);
}
}
public async Task <ActionResult> PatchUpdatePackage(JsonPatchDocument <UpdatePackageDto> patchDocument, int projectId, string version,
[FromQuery] string?password, [FromServices] IPatchUpdatePackageUseCase useCase, [FromServices] IUpdatePackageRepository repo,
[FromServices] IMapper mapper)
{
// find update package
var updatePackage = await repo.GetFirstOrDefaultBySpecs(new ProjectSpec(projectId), new VersionSpec(version),
new IncludeAllSpec());
if (updatePackage == null)
{
return(ResourceNotFoundError.UpdatePackageNotFound(projectId, version).ToActionResult());
}
// apply patch to dto copy
var updatePackageDto = mapper.Map <UpdatePackageDto>(updatePackage);
patchDocument.ApplyTo(updatePackageDto);
// validate new state
var validator = new UpdatePackageValidator();
var result = validator.Validate(updatePackageDto);
if (!result.IsValid)
{
return(result.ToActionResult());
}
var updateInfo = GetInfo(updatePackageDto);
await useCase.Handle(new PatchUpdatePackageRequest(projectId, updatePackage.VersionInfo.SemVersion, updateInfo, password));
if (useCase.HasError)
{
return(useCase.ToActionResult());
}
return(Ok());
}
