public async Task <IActionResult> UpdatePackage(string package, [FromBody] UpdatePackageViewModel vm)
{
if (!ModelState.IsValid || PackageUtils.UnescapeName(package) != vm.Name)
{
return(BadRequestResponse);
}
try {
await _packageService.CommitAsync(vm.Name, ToPatch(vm));
return(Ok("updated package"));
}
catch (DuplicatePackageVersionException) {
return(DuplicateVersionResponse);
}
catch (PackageVersionNotFoundException nfe) {
return(Error($"package version not found ({nfe.Identifier.Version})", HttpStatusCode.BadRequest));
}
}
public async Task <IActionResult> Update(int id, UpdatePackageViewModel vm, IFormFile ImgPath)
{
var loggedUser = await _userManagerService.FindByNameAsync(User.Identity.Name);
Package pack = _packRepo.GetSingle(p => p.PackageId == id);
if (ModelState.IsValid && pack != null)
{
pack.Name = vm.Name;
pack.Location = vm.Location;
pack.Description = vm.Description;
pack.Price = vm.Price;
pack.IsActive = vm.IsActive;
pack.UserId = loggedUser.Id;
if (ImgPath != null)
{
string uploadPath = Path.Combine(_environment.WebRootPath, "Uploads");
uploadPath = Path.Combine(uploadPath, User.Identity.Name);
Directory.CreateDirectory(Path.Combine(uploadPath, pack.Name));
string fileName = Path.GetFileName(ImgPath.FileName);
using (FileStream fs = new FileStream(Path.Combine(uploadPath, pack.Name, fileName), FileMode.Create))
{
ImgPath.CopyTo(fs);
}
pack.ImgPath = Path.Combine(User.Identity.Name, pack.Name, fileName);
}
_packRepo.Update(pack);
return(RedirectToAction("Display", "Package", new { id = pack.PackageId }));
}
ModelState.AddModelError("", "Information required!");
return(View(vm));
}
private static PackagePatch ToPatch(UpdatePackageViewModel vm)
{
var patch = new PackagePatch()
{
UpdatedVersions = new List <PackageVersion>(),
PublishedVersions = new List <PublishedPackageVersion>(),
UpdatedDistTags = vm.DistTags
};
foreach (var kvp in vm.Versions)
{
var id = new PackageIdentifier(vm.Name, kvp.Key);
var version = new PublishedPackageVersion()
{
Id = id,
Manifest = kvp.Value
};
if (vm.Attachments == null || !vm.Attachments.TryGetValue(PackageUtils.GetTarballName(id), out var attachment))
{
patch.UpdatedVersions.Add(version);
}
else
{
version.Tarball = new Tarball()
{
Package = id,
Data = Convert.FromBase64String(attachment.Data)
};
patch.PublishedVersions.Add(version);
}
}
return(patch);
}
public async Task <IActionResult> Update(int id)
{
var loggedUser = await _userManagerService.FindByNameAsync(User.Identity.Name);
Package pack = _packRepo.GetSingle(p => p.PackageId == id);
if (pack != null)
{
UpdatePackageViewModel vm = new UpdatePackageViewModel
{
PackId = id,
Name = pack.Name,
Location = pack.Location,
Description = pack.Description,
Price = pack.Price,
IsActive = pack.IsActive,
UserId = loggedUser.Id,
ImgPath = pack.ImgPath
};
return(View(vm));
}
return(RedirectToAction("Index", "Category"));
}
public async Task <IActionResult> UpdatePackageAsync(string package, string revision, [FromBody] UpdatePackageViewModel vm)
{
if (!ModelState.IsValid || PackageUtils.UnescapeName(package) != vm.Name)
{
return(BadRequestResponse);
}
var overview = await _packageService.GetPackageAsync(vm.Name);
if (overview == null)
{
return(PackageNotFoundResponse);
}
var patch = ToPatch(vm);
// Allow for deletes when a revision is specified (this is basically a 'replace the model' update)
patch.DeletedVersions = overview.Versions.Select(v => v.Id)
.Where(id => !vm.Versions.ContainsKey(id.Version))
.ToList();
try {
await _packageService.CommitAsync(overview.Name, patch);
return(Ok(GetResults(patch)));
}
catch (DuplicatePackageVersionException) {
return(DuplicateVersionResponse);
}
catch (PackageVersionNotFoundException nfe) {
return(Error($"package version not found ({nfe.Identifier.Version})", HttpStatusCode.BadRequest));
}
}
