public async Task <IActionResult> Update(string name)
{
IdentityUser user = await _userManagerService.FindByNameAsync(User.Identity.Name);
Package pac = _packageService.GetSingle(p => p.Name == name);
if (pac.UserId == user.Id)
{
PackageUpdateViewModel vm = new PackageUpdateViewModel
{
PackageId = pac.PackageId,
Name = pac.Name,
LocName = pac.LocName,
Description = pac.Description,
Price = pac.Price,
Picture = pac.Picture,
LocState = pac.LocState,
Active = pac.Active
};
return(View(vm));
}
else
{
return(RedirectToAction("DeniedPackage", "Account"));
}
}
private async Task UpdateAsync(PackageUpdateViewModel package)
{
if (viewModel.Update.CanExecute(package))
{
await viewModel.Update.ExecuteAsync(package);
}
}
//[Authorize("TravelProvider")]
public async Task <IActionResult> Update(int id)
{
//get the user who already logged in
IdentityUser user = await _userManagerService.FindByNameAsync(User.Identity.Name);
//get the profile for this user
Package package = _packageDataService.GetSingle(p => p.PackageId == id);
if (package?.UserId == user.Id)
{
//create vm
PackageUpdateViewModel vm = new PackageUpdateViewModel
{
PackageId = package.PackageId,
PackName = package.PackName,
PackLocation = package.PackLocation,
PackDescription = package.PackDescription,
PackPrice = package.PackPrice,
PackImage = package.PackImage,
PackageStatus = package.PackageStatus
};
return(View(vm));
}
else
{
return(RedirectToAction("Login", "Account"));
}
}
public async Task <IActionResult> Update(int id)
{
IdentityUser user = await _userManagerService.FindByNameAsync(User.Identity.Name);
Package package = _packageDataService.GetSingle(p => p.PackageId == id);
IEnumerable <Location> locationList = _locationDataService.GetAll();
if (package.UserId == user.Id)
{
PackageUpdateViewModel vm = new PackageUpdateViewModel
{
PackageId = package.PackageId,
PackageName = package.Name,
LocationName = package.Location,
Price = package.Price,
Description = package.Description,
Picture = package.Picture,
IsAvailable = package.IsAvailable,
//LocationList = ViewBag.LocationName = new SelectList(locationList, "LocationId", "Name"),
LocationId = package.LocationId,
UserId = package.UserId
};
return(View(vm));
}
else
{
return(RedirectToAction("Denied", "Account"));
}
}
public static PackageDetail GetPackageDetail(this PackageUpdateViewModel viewModel)
=> new PackageDetail
{
PackageId = viewModel.Id,
Area = viewModel.Area,
Price = viewModel.Price,
SortText = viewModel.SortText,
Title = viewModel.Title,
};
public async Task <IActionResult> Update(PackageUpdateViewModel vm, IFormFile file)
{
if (ModelState.IsValid)
{
Package package = _packageService.GetSingle(p => p.PackageId == vm.PackageId);
package.Name = vm.Name;
package.LocName = vm.LocName;
package.Price = vm.Price;
package.Description = vm.Description;
package.LocState = vm.LocState;
package.Active = vm.Active;
//Package pac = new Package
//{
// LocationId = int.Parse(TempData["locId"].ToString()),
// Name = vm.Name,
// Price = vm.Price,
// Description = vm.Description,
// Active = vm.Active,
// Picture=vm.Picture
//};
//upload the picture to the file system
//assign the picture URL to the cat object
if (file != null)
{
//check ??
//upload server path
var serverPath = Path.Combine(_environment.WebRootPath, "uploads");
//create a folder
Directory.CreateDirectory(Path.Combine(serverPath, User.Identity.Name));
//get the file name
string fileName = FileNameHelper.GetNameFormated(Path.GetFileName(file.FileName));
//stream the file to the srever
using (var fileStream = new FileStream(Path.Combine(serverPath, User.Identity.Name, fileName), FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
//assign the picture URL to the cat object
package.Picture = User.Identity.Name + "/" + fileName;
//string oldPicturePath = "~/uploads/" + vm.Picture;
//FileInfo myfileinf = new FileInfo(oldPicturePath);
//myfileinf.Delete();
}
//save to db
_packageService.Update(package);
//go home
return(RedirectToAction("Index", "Home"));
}
else
{
return(View(vm));
}
}
public static PackageDetail GetPackageDetail(this PackageUpdateViewModel viewModel)
=> new PackageDetail
{
PackageId = viewModel.Id,
Area = viewModel.Area,
Price = viewModel.Price,
SortText = viewModel.SortText,
Title = viewModel.Title,
Language = Base.Properties.Resources.DEFAULT_LANGUAGE
};
public async Task <BaseJsonResult> CreateNewPackage([FromBody] PackageUpdateViewModel viewModel)
{
var packageServiceModel = viewModel.ToPackageServiceModel();
packageServiceModel.User = CurrentUser;
var newPackage = await _packageService.CreateNewPackage(packageServiceModel);
return(new BaseJsonResult(Omi.Base.Properties.Resources.POST_SUCCEEDED, newPackage.Id));
}
public async Task <BaseJsonResult> UpdatePackage([FromBody] PackageUpdateViewModel model)
{
if (!ModelState.IsValid)
{
return(new ModelStateErrorJsonResult(ModelState.Values));
}
var packageServiceModel = model.ToPackageServiceModel();
packageServiceModel.User = CurrentUser;
await _packageService.UpdatePackageAsync(packageServiceModel);
return(new BaseJsonResult(Omi.Base.Properties.Resources.POST_SUCCEEDED, model.Id));
}
public static PackageServiceModel ToPackageServiceModel(this PackageUpdateViewModel viewModel)
{
var taxonomyIds = new List <long>()
{
viewModel.HouseTypeId, viewModel.DesignThemeId,
};
if (viewModel.PackageIncludedItemIds != null)
{
taxonomyIds.AddRange(viewModel.PackageIncludedItemIds);
}
if (viewModel.PackageFurnitureIncludedItemIds != null)
{
taxonomyIds.AddRange(viewModel.PackageFurnitureIncludedItemIds);
}
var pictureFileIds = new List <long>();
if (viewModel.Pictures != null)
{
pictureFileIds = pictureFileIds.Concat(viewModel.Pictures.Select(o => o.FileId)).ToList();
}
var detail = viewModel.GetPackageDetail();
var addNewpackageServiceModel = new PackageServiceModel()
{
Id = viewModel.Id,
Name = viewModel.Title.ToEntityName(),
IsPerspective = viewModel.IsPerspective,
Detail = detail,
TaxonomyIds = taxonomyIds,
AvatarFileId = viewModel.Avatar.FileId,
PictureFileIds = pictureFileIds,
};
if (viewModel.Products != null)
{
addNewpackageServiceModel.PackageProducts = new List <PackageProduct>(
viewModel.Products.Where(o => o.ProductId != default).Select(o => new PackageProduct {
EntityId = viewModel.Id, ProductId = o.ProductId, Quantity = o.Quantity,
})
);
}
return(addNewpackageServiceModel);
}
private void RunSelfUpdate(MainWindow wnd)
{
UpdatesViewModel updates = wnd.ViewModel.Updates;
updates.IsPrereleaseIncluded = true;
updates.Refresh.Completed += async() =>
{
bool canUpdate = false;
PackageUpdateViewModel package = updates.Packages.FirstOrDefault(p => p.Current.Id == Args.SelfPackageId);
if (package != null)
{
if (package.Target.Version == Args.SelfUpdateVersion)
{
canUpdate = true;
}
else
{
if (package.Current.LoadVersions.CanExecute())
{
package.Current.LoadVersions.Execute();
}
PackageViewModel version = package.Current.Versions.FirstOrDefault(p => p.Version == Args.SelfUpdateVersion);
if (version != null)
{
package.Target = version.Model;
canUpdate = true;
}
else
{
Navigator.Notify("Self Update Error", $"Unnable to find update package (version {Args.SelfUpdateVersion}) for PackageManager.", Navigator.MessageType.Error);
}
}
}
else
{
Navigator.Notify("Self Update Error", $"Unnable to find update package for PackageManager.", Navigator.MessageType.Error);
}
if (canUpdate)
{
await updates.Update.ExecuteAsync(package);
}
Shutdown();
};
wnd.SelectUpdatesTab();
}
//[Authorize("TravelProvider")]
public async Task <IActionResult> Update(PackageUpdateViewModel vm, IFormFile file)
{
if (ModelState.IsValid)
{
//get the user who already logged in
IdentityUser user = await _userManagerService.FindByNameAsync(User.Identity.Name);
Package pack = new Package
{
UserId = user.Id,
PackageId = vm.PackageId,
PackName = vm.PackName,
PackLocation = vm.PackLocation,
PackDescription = vm.PackDescription,
PackPrice = vm.PackPrice,
PackImage = vm.PackImage,
PackageStatus = vm.PackageStatus
};
if (file != null)
{
//upload server path
var uploadPath = Path.Combine(_environment.WebRootPath, "images");
//create subfolder
Directory.CreateDirectory(Path.Combine(uploadPath, User.Identity.Name));
//get the file name
string fileName = FileNameHelper.GetNameFormated(Path.GetFileName(file.FileName));
// stream the file to the srever
using (var fileStream = new FileStream(Path.Combine(uploadPath, User.Identity.Name, fileName), FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
//add the file url to category
pack.PackImage = "images" + "/" + User.Identity.Name + "/" + fileName;
}
//save changes
_packageDataService.Update(pack);
//go home
return(RedirectToAction("Index", "Package"));
}
return(View(vm));
}
public async Task <ActionResult> UpdatePackage(PackageUpdateViewModel model)
{
var user = await userManager.FindByNameAsync(User.Identity.Name);
var userPackages = await userRepository.GetUserpackages(user.UserName);
var package = userPackages.Declarations.Find(x => x.Id == model.Id);
mapper.Map(model, package);
var result = await declarationRepository.Edit(package);
if (result)
{
return(Json(new { success = true }));
}
return(Json(new { success = false }));
}
public void Update()
{
var packageOptions = new PackageOptions();
var package = new Package(ExtractPath, "Test");
var viewModel = new PackageUpdateViewModel(package.Object, package.Object, packageOptions.Object, false);
var install = new InstallService(ExtractPath, package, package, package);
var selfUpdate = new SelfUpdateService(false, null);
var command = new UpdateCommand(install.Object, selfUpdate.Object);
Assert.IsTrue(command.CanExecute(viewModel));
command.ExecuteAsync(viewModel).Wait();
Assert.IsFalse(selfUpdate.IsSelfUpdateCalled);
Assert.IsFalse(selfUpdate.RunNewInstanceCalled);
Assert.IsTrue(install.UninstallCalled);
Assert.IsTrue(install.InstallCalled);
}
protected async override Task ExecuteAsync(CancellationToken cancellationToken)
{
PackageUpdateViewModel selfUpdate = null;
foreach (PackageUpdateViewModel package in viewModel.Packages.ToList())
{
if (package.IsSelf)
{
selfUpdate = package;
}
else
{
await UpdateAsync(package);
}
}
if (selfUpdate != null)
{
await UpdateAsync(selfUpdate);
}
}
public static PackageServiceModel ToPackageServiceModel(this PackageUpdateViewModel viewModel)
{
var taxonomyIds = new List <long>(viewModel.PackageIncludedItemIds)
{
viewModel.HouseTypeId, viewModel.DesignThemeId,
};
var pictureFileIds = new List <long>(viewModel.Pictures.Select(o => o.FileId));
var detail = viewModel.GetPackageDetail();
var addNewpackageServiceModel = new PackageServiceModel()
{
Id = viewModel.Id,
Name = viewModel.Title.ToEntityName(),
Detail = detail,
TaxonomyIds = taxonomyIds,
AvatarFileId = viewModel.Avatar.FileId,
PictureFileIds = pictureFileIds
};
return(addNewpackageServiceModel);
}
public async Task MainAsync(string[] args)
{
Args = new Args(args);
if (!Directory.Exists(Args.Path))
{
Console.WriteLine("Missing argument '--path' - a target path to install packages to.");
return;
}
if (Args.IsUpdateCount)
{
UpdatesViewModel viewModel = CreateUpdatesViewModel();
await viewModel.Refresh.ExecuteAsync();
Console.WriteLine(viewModel.Packages.Count);
}
else if (Args.IsUpdatePackage)
{
UpdatesViewModel viewModel = CreateUpdatesViewModel();
await viewModel.Refresh.ExecuteAsync();
PackageUpdateViewModel packageModel = viewModel.Packages.FirstOrDefault(p => p.Target.Id == Args.PackageId);
if (packageModel != null && viewModel.Update.CanExecute(packageModel))
{
await viewModel.Update.ExecuteAsync(packageModel);
Console.WriteLine($"Updated '{packageModel.Target.Id}' to version '{packageModel.Target.Version}'.");
Environment.ExitCode = 0;
}
else
{
Console.WriteLine($"There is no available update for package '{Args.PackageId}'.");
Environment.ExitCode = 1;
}
}
}
public async Task <IActionResult> Update(PackageUpdateViewModel vm, IFormFile file)
{
if (ModelState.IsValid)
{
Package package = _packageDataService.GetSingle(p => p.PackageId == vm.PackageId);
package.PackageId = vm.PackageId;
package.Name = vm.PackageName;
package.Location = vm.LocationName;
//package.Location = vm.LocationList.SelectedValue.ToString(),
package.Price = vm.Price;
package.Description = vm.Description;
package.IsAvailable = vm.IsAvailable;
package.LocationId = vm.LocationId;
package.UserId = vm.UserId;
if (file != null)
{
var serverPath = Path.Combine(_environment.WebRootPath, "uploads/package");
Directory.CreateDirectory(Path.Combine(serverPath, User.Identity.Name));
string fileName = FileNameHelper.GetNameFormatted(Path.GetFileName(file.FileName));
using (var fileStream = new FileStream(Path.Combine(serverPath, User.Identity.Name, fileName), FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
package.Picture = User.Identity.Name + "/" + fileName;
}
_packageDataService.Update(package);
return(RedirectToAction("Details", "Package", new { id = package.PackageId }));
}
else
{
return(View(vm));
}
}