Beispiel #1
0
        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);
Beispiel #2
0
        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);
        }
Beispiel #3
0
        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());
        }