// GET: Edit
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
var itemService = CreateItemService();
var detail = await itemService.GetItemById((int)id);
var itemImageService = CreateItemImageService();
var images = await itemImageService.GetItemImages();
var viewModel =
new EditItemViewModel
{
Id = detail.Id,
Name = detail.Name,
Description = detail.Description,
ModelNumber = detail.ModelNumber,
SerialNumber = detail.SerialNumber,
Value = detail.Value,
ItemImageId = detail.ItemImageId
};
viewModel.Images = images.OrderBy(n => n.FileName).Select(i => new SelectListItem
{
Text = i.FileName,
Value = i.Id.ToString()
});
return(View(viewModel));
}
private async void EditInventoryButton_Click(object sender, RoutedEventArgs e)
{
var selectedInventory = DataGridInventory.SelectedItem as InventoryRow;
if (selectedInventory != null)
{
_editItemViewModel = new ViewModels.EditItemViewModel
{
Id = selectedInventory.Id,
Engineer = selectedInventory.Engineer,
Name = selectedInventory.Name,
RawMaterial = selectedInventory.RawMaterial,
DevelopmentStatus = Enum.Parse <DevelopmentStatus>(selectedInventory.Status, true),
DevelopmentStartDate = selectedInventory.DevelopmentStartDate,
ExpectedCompletionDate = selectedInventory.ExpectedCompletionDate,
Notes = selectedInventory.Notes,
ImageSource = selectedInventory.ImageSource
};
var editItemView = new EditItemView
{
EditItemViewModel = _editItemViewModel
};
await editItemView.ShowAsync();
}
else
{
await new MessageDialog("Please select an item to edit").ShowAsync();
}
}
public EditItemPage(EditItemViewModel viewModel)
{
InitializeComponent();
viewModel.CurrentPage = this;
BindingContext = viewModel;
Appearing += viewModel.OnPageAppeared;
}
public IActionResult EditItem(string itemId)
{
var item = this.itemService.GetItemById(new Guid(itemId));
var viewModel = new EditItemViewModel();
foreach (var prop in item.GetType().GetProperties())
{
if (prop.GetValue(item, null) != null)
{
if (viewModel.GetType().GetProperties().SingleOrDefault(x => x.Name == prop.Name) != null)
{
var propertyToModify = viewModel.GetType().GetProperties().SingleOrDefault(x => x.Name == prop.Name);
propertyToModify.SetValue(viewModel, prop.GetValue(item, null));
}
}
}
foreach (var prop in item.SpecificProperties.GetType().GetProperties())
{
if (prop.GetValue(item.SpecificProperties, null) != null)
{
if (viewModel.GetType().GetProperties().SingleOrDefault(x => x.Name == prop.Name) != null)
{
var propertyToModify = viewModel.GetType().GetProperties().SingleOrDefault(x => x.Name == prop.Name);
propertyToModify.SetValue(viewModel, prop.GetValue(item.SpecificProperties, null));
}
}
}
return(View(viewModel));
}
//[Route("/Items/Edit/{id}")]
public IActionResult Edit(int id)
{
if (User.Identity.IsAuthenticated)
{
string userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
List <Item> existingItems = db
.Items
.Include(i => i.Owner)
.Include(i => i.Brand)
.Include(i => i.Model)
.Include(i => i.Category)
.Where(i => i.Sold == false && i.ID == id)
.ToList();
if (existingItems.Count != 0)
{
Item item = existingItems[0];
if (item.OwnerId == userId)
{
EditItemViewModel editItemViewModel = new EditItemViewModel(item, db.Categories.ToList());
return(View(editItemViewModel));
}
}
return(ViewItem(id));
}
return(Redirect("/Account/Login"));
}
public void EditItem(EditItemViewModel model)
{
using (var context = new HardwareShopContext())
{
var item = this.GetItemById(model.ItemId, context);
item.SubCategoryId = model.SubCategoryId;
item.Description = model.Description;
item.Quantity = model.Quantity;
item.Price = model.Price;
item.NewPrice = model.NewPrice;
item.Model = model.Model;
item.ItemStatus = model.ItemStatus;
item.ManufacturerName = model.ManufacturerName;
item.WarrantyLengthMonths = model.WarrantyLengthMonths;
if (model.PictureBase != null)
{
MemoryStream stream = new MemoryStream();
model.PictureBase.InputStream.CopyTo(stream);
byte[] pictureInData = stream.ToArray();
item.Picture = pictureInData;
}
context.SaveChanges();
}
}
public async Task <ViewResult> Edit(int itemId)
{
// Get current user
var currentUser = await this._userManager.GetUserAsync(this.User);
using (var client = new OnebrbApi())
{
client.BaseUri = new Uri(_apiOptions.BaseAddress, UriKind.Absolute);
var response = await client.GetItemAsync(itemId);
ItemServiceModel itemModel = this._mapper.Map <ItemServiceModel>(response.Body);
EditItemViewModel editItemViewModel = this._mapper.Map <EditItemViewModel>(itemModel);
if (editItemViewModel == null)
{
return(View("Errors/NotFound"));
}
// Only the product author is allowed to edit it
if (editItemViewModel.UserId != currentUser.Id)
{
return(View("Errors/Unauthorized"));
}
editItemViewModel.SecurityHash = currentUser.SecurityHash;
return(View(editItemViewModel));
}
}
// GET: Items/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var item = await _context.Items.FindAsync(id);
if (item == null)
{
return(NotFound());
}
EditItemViewModel editItemViewModel = new EditItemViewModel
{
ID = item.ID,
Name = item.Name,
Brand = item.Brand,
ExistingPicture = item.Picture,
Price = item.Price,
Description = item.Description,
Category = item.Category,
CategoryID = item.CategoryID
};
ViewBag.CategoryID = new SelectList(_CategoryRepository.GetAll(), "CategoryID", "Name");
return(View(editItemViewModel));
}
public ActionResult EditItem(int?Id)
{
EditItemViewModel viewModel = new EditItemViewModel();
using (FreshChoiceEntities db = new FreshChoiceEntities())
{
if (Id == null)
{
viewModel.Item = new Item();
}
else
{
viewModel.Item = db.Items.Where(w => w.ItemId == (int)Id).FirstOrDefault();
}
viewModel.Categories = db.Categories.ToList();
viewModel.Brands = db.Brands.ToList();
viewModel.Images = db.Images.Where(w => w.ItemId == viewModel.Item.ItemId).ToList();
var catJson = viewModel.Categories
.Select(s => new { s.CategoryName, s.CategoryId })
.ToList();
var brandJson = viewModel.Brands
.Select(s => new { s.BrandName, s.CategoryId, s.BrandId })
.ToList();
viewModel.CategoriesJson = JsonConvert.SerializeObject(catJson);
viewModel.BrandsJson = JsonConvert.SerializeObject(brandJson);
}
return(View(viewModel));
}
public virtual IActionResult SaveBlogEdit(EditItemViewModel model)
{
// Get the blog that is for this controller instance
if (Current != null)
{
// Get the item that needs to be saved
IBlogItem blogItem = (model.Id == "") ? new BlogItem() : Current.Get(new BlogHeader()
{
Id = Current.Parameters.Provider.DecodeId(model.Id)
});
// Blog item valid?
if (blogItem != null)
{
// Update the properties of the blog item from the incoming model
blogItem.Copy(model);
// (Re)Save the blog item back to the blog handler
blogItem = Current.Save(blogItem);
}
else
{
throw new ItemNotFoundBlogException("Item with id '{id}' not found");
}
}
// Call the common view handler
return(EditBlogCommon(model.Id));
}
/// <summary>
/// Copys a given edit model (flat version for editing) in to this item
/// </summary>
/// <param name="from"></param>
/// <returns>The the current item</returns>
public IBlogItem Copy(EditItemViewModel from)
{
// Copy the items in
this.Header.Author = from.Author;
this.Header.Name = from.Name;
this.Header.Description = from.Description;
this.Header.PublishedDate = DateTime.Parse(from.PublishedDate);
this.Header.Tags = from.Tags.SplitCSV();
this.Header.SEOTags = from.SEOTags.SplitCSV();
this.Content = from.Content;
this.Files = (from.Files != null) ? new List <BlogFile>() : null;
// Copy the files in (not by reference), there might be no files array if sent from
// the direct save
if (this.Files != null && from.Files != null)
{
from.Files.ForEach(file =>
{
this.Files.Add(new BlogFile()
{
Content = file.Content,
Filename = file.Filename,
Tags = file.Tags,
Title = file.Title
});
});
}
// Return itself after the copy in
return(this);
}
public EditItemViewModel GetItemForEdition(int id)
{
Item item = this.Context.Items.Find(id);
EditItemViewModel viewModel = Mapper.Map <EditItemViewModel>(item);
return(viewModel);
}
public async Task <ActionResult <Item> > Create(EditItemViewModel itemModel, int storeId)
{
try
{
var item = new Item
{
Name = itemModel.Name,
Ingredients = itemModel.Ingredients,
ItemImageUrl = itemModel.ItemImageUrl,
Price = itemModel.Price,
StoreId = storeId,
ItemModifiers = itemModel.ItemModifiers
.Where(modifier => modifier.Selected)
.Select(modifier => new ItemModifier
{
ModifierId = modifier.Id,
AdditionalCost = modifier.AdditionalCost ?? 0
})
.ToList()
};
await itemService.AddItem(item, storeId);
return(RedirectToAction(nameof(Index), new { storeId }));
}
catch
{
return(View(itemModel));
}
}
public async Task <IActionResult> Edit(int id)
{
Item theItem = context.Items.Single(i => i.ID == id);
if (theItem == null)
{
return(new NotFoundResult());
}
var authorizationResult = await _authorizationService.AuthorizeAsync(User, theItem, new ManageItemAccessRequirement());
if (authorizationResult.Succeeded)
{
EditItemViewModel editItemViewModel = new EditItemViewModel(context.Suppliers.ToList())
{
ID = theItem.ID,
SKU = theItem.SKU,
Description = theItem.Description,
SupplierID = theItem.SupplierID
};
return(View(editItemViewModel));
}
else
{
return(new ForbidResult());
}
}
private bool IsUserAuthorizedToEdit(EditItemViewModel editItemViewModel)
{
bool isAdmin = this.User.IsInRole("Admin");
bool isStoreManager = this.User.IsInRole("StoreManager");
return(isAdmin || isStoreManager);
}
public ActionResult EditItem(EditItemViewModel viewModel)
{
try
{
// Saving viewModel's values (User) to orderItem's properties
if (ModelState.IsValid)
{
// Gets user object
var orderItem = db.OrderItem.Single(oi => oi.Id == viewModel.OrderItem.Id);
// Explicitly verify that the Item exists
var item = db.Item.Single(i => i.Id == viewModel.OrderItem.ItemId);
// Updates user object
orderItem.ItemId = viewModel.OrderItem.ItemId;
orderItem.Price = viewModel.OrderItem.Price;
// Save changes
db.SaveChanges();
// Message to handle Edit's status result
TempData["success"] = "Order Item was updated successfully";
return(RedirectToAction("Details", new { id = orderItem.OrderId }));
}
return(View(viewModel));
}
catch (Exception)
{
// Message to handle Edit's status result
TempData["danger"] = "Order was not updated";
return(RedirectToAction("Index"));
}
}
public async Task <IActionResult> EditItem(EditItemViewModel model)
{
if (ModelState.IsValid)
{
if (database.Items.Where(r => r.Id != model.Id).All(r => r.InventoryNumber != model.InventoryNumber && r.OrganizationId == model.OrganizationId))
{
var item = await database.Items.FirstOrDefaultAsync(r => r.Id == model.Id);
item.InventoryNumber = model.InventoryNumber;
item.Name = model.Name;
item.Description = model.Description;
item.Cost = model.Cost;
item.Status = model.Status;
database.Update(item);
await database.SaveChangesAsync();
return(RedirectToAction("AllItems"));
}
else
{
ModelState.AddModelError("", "Инвентарный номер должен быть уникален");
}
}
return(View(model));
}
public ActionResult AddItem(EditItemViewModel model)
{
if (model.Item.ItemId > 0)
{
// modyfikacja kursu
db.Entry(model.Item).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("AddItem", new { potwierdzenie = true }));
}
else
{
// Sprawdzenie, czy użytkownik wybrał plik
if (ModelState.IsValid)
{
model.Item.addTime = DateTime.Now;
db.Entry(model.Item).State = EntityState.Added;
db.SaveChanges();
return(RedirectToAction("AddItem", new { potwierdzenie = true }));
}
else
{
var kategorie = db.ItemCategories.ToList();
model.categories = kategorie;
return(View(model));
}
}
}
public IActionResult EditTitleImage([FromForm] EditItemViewModel model)
{
if (ModelState.IsValid)
{
var item = this.dataManager.Items.GetItem(model.ItemId);
if (model.TitleImage != null)
{
byte[] dataImage = null;
using (var binaryReader = new BinaryReader(model.TitleImage.OpenReadStream()))
{
dataImage = binaryReader.ReadBytes((int)model.TitleImage.Length);
}
item.TitleImage = dataImage;
this.dataManager.Items.SaveItem(item);
return(Redirect($"/Items/Item/{item.UserId}"));
}
else
{
ModelState.AddModelError(string.Empty, "CHOOSE NEW PHOTO");
return(View(model));
}
}
else
{
return(View(model));
}
}
public IActionResult EditItem(Guid itemId)
{
var editItemVM = new EditItemViewModel
{
Item = _operationDb.GetModels <Item>(i => i.Id == itemId).First()
};
return(View(editItemVM));
}
public IActionResult Edit(EditItemViewModel model)
{
var Session = HttpContext.Session.GetString("PubSession"); //user must be logged in to view orders
if (Session != null)
{
PubSessions pubSession = _context.GetPubSession(Session); //get session info
if (pubSession != null) //session exists
{
if (pubSession.UserId > 0) //if a user is logged in...
{
PubUsers pubUser = _context.GetPubUser(pubSession.UserId);
if (pubUser != null && pubUser.UserAccessRank == UserAccessRank.Admin) //if user exists
{
if (ModelState.IsValid) //user is an admin, allow access to editing.
{
PubItems EditedItem = new PubItems()
{
ItemId = model.ItemID,
ItemDescription = model.ItemDescription,
ItemName = model.ItemName,
ItemOnSale = model.ItemOnSale,
ItemPrice = model.ItemPrice,
ItemStock = model.ItemStock,
ItemType = model.ItemType,
ItemImagePath = model.ItemExistingImagePath
};
if (model.ItemImage != null)
{
if (model.ItemExistingImagePath != null)
{
string existingFilePath = Path.Combine(webHostEnvironment.WebRootPath, "images", model.ItemExistingImagePath);
System.IO.File.Delete(existingFilePath);
}
EditedItem.ItemImagePath = ProcessUploadedFile(model);
}
//int result = _context.AddPubItem();
if (_context.EditPubItem(EditedItem) == true)
{
return(RedirectToAction("Details", new { id = EditedItem.ItemId }));
}
else
{
ModelState.AddModelError("", "An error occured, could not create a new item.");
//ERROR: item was not added
}
}
return(View(model));
}
}
}
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Edit(int id, EditItemViewModel model)
{
/*
* if (id != model.ID)
* {
* return NotFound();
* }
*/
if (ModelState.IsValid)
{
Item item = _context.Items.Find(model.ID);
item.Name = model.Name;
item.Description = model.Description;
item.Price = model.Price;
item.Brand = model.Brand;
item.Category = model.Category;
item.CategoryID = model.CategoryID;
if (model.Picture != null)
{
if (model.ExistingPicture != null)
{
string filePath = Path.Combine(hostingEnvironment.WebRootPath,
"images/items", model.ExistingPicture);
System.IO.File.Delete(filePath);
}
item.Picture = ProcessUploadedFile(model);
}
try
{
_context.Update(item);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemExists(item.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.CategoryID = new SelectList(_CategoryRepository.GetAll(), "CategoryID", "Name", model.Category);
return(View(model));
}
public IActionResult EditItem(EditItemViewModel editItemVM)
{
_operationDb.GetModels <Item>(i => i.Id == editItemVM.Item.Id).Update(i => new Item
{
Name = editItemVM.Item.Name,
Quantity = editItemVM.Item.Quantity,
Price = editItemVM.Item.Price
});
return(RedirectToAction(nameof(Index)));
}
public ActionResult Create(EditItemViewModel data)
{
try
{
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public void EditProperties(EditItemViewModel e, Category category, Brand brand, Model model)
{
Title = e.Title;
Price = e.Price;
Description = e.Description;
Condition = (Condition)Enum.Parse(typeof(Condition), e.Condition);
Category = category;
Brand = brand;
Model = model;
Year = e.Year;
}
public ActionResult Edit(EditItemViewModel editModel)
{
if (!this.ModelState.IsValid)
{
editModel.SubCategories = this.itemService.GetAllSubCategories();
return(this.View(editModel));
}
this.itemService.EditItem(editModel);
return(this.RedirectToAction("Details", "Item", new { itemId = editModel.ItemId }));
}
public async Task <IActionResult> Edit(EditItemViewModel viewModel)
{
var item = viewModel.Item;
ModelState.Remove("Item.CreatorId");
ModelState.Remove("GiftListItemId");
ModelState.Remove("WishListItemId");
if (ModelState.IsValid)
{
try
{
var user = await GetCurrentUserAsync();
item.CreatorId = user.Id;
_context.Update(item);
await _context.SaveChangesAsync();
if (viewModel.WishListItemId > 0)
{
var wishListItem = await _context.WishListItems.FindAsync(viewModel.WishListItemId);
wishListItem.Notes = viewModel.WishListItem.Notes;
_context.Update(wishListItem);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Details), new { id = item.ItemId, wishListItemId = wishListItem.WishListItemId }));
}
if (viewModel.GiftListItemId > 0)
{
var giftListItem = await _context.GiftListItems.FindAsync(viewModel.GiftListItemId);
giftListItem.Notes = viewModel.GiftListItem.Notes;
_context.Update(giftListItem);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Details), new { id = item.ItemId, giftListItemId = giftListItem.GiftListItemId }));
}
}
catch (DbUpdateConcurrencyException)
{
if (!ItemExists(item.ItemId))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(View(viewModel));
}
public IActionResult EditItem(EditItemViewModel editItemViewModel)
{
if (ModelState.IsValid)
{
TheString = editItemViewModel.NewElement2;
return(Redirect("/Home/Result"));
}
return(Redirect("/Home/Error"));
}
public IActionResult EditItem(EditItemViewModel editItemViewModel)
{
if (ModelState.IsValid)
{
TheList.Add(editItemViewModel.NewElement2);
return(Redirect("/Home/Result"));
}
TheList.Add(Bridgeelement);
return(Redirect("/Home/Error"));
}
public IActionResult EditItem()
{
if (TheList.Count > 0)
{
EditItemViewModel editItemViewModel = new EditItemViewModel();
return(View(editItemViewModel));
}
else
{
return(Redirect("/"));
}
}
/// <summary>
/// Constructor for Edit Form
/// </summary>
public EditForm()
{
InitializeComponent();
viewModel = App.OrdersListViewModel.SelectedItemEditViewModelInstance;
if (!viewModel.IsInitialized)
{
viewModel.InitializationCompleted += new EventHandler<InitializationCompletedEventArgs>(OnViewModelInitialization);
viewModel.Initialize();
}
else
{
this.DataContext = viewModel;
}
}
