public async Task <ActionResult <Rating> > Delete(int id)
{
// Request a new token
var token = await webAPIToken.New();
// Get rating by id
var rating = await webAPI.GetOneAsync <Rating>(ApiURL.RATING_BY_ID + id, token);
// Get user by id
rating.User = await webAPI.GetOneAsync <User>(ApiURL.USER_BY_ID + rating.UserId, token);
// Get product by id
var product = await webAPI.GetOneAsync <AllProductsViewModel>(ApiURL.PRODUCTS + rating.ProductId, token);
rating.Product = new Product
{
Name = product.Name,
Category = new Category {
Name = product.Name
},
Brand = new Brand {
Name = product.BrandName
},
Photo = product.Photo
};
return(View(rating));
}
public async Task <IActionResult> Index()
{
var token = await webAPIToken.New();
var allUserOrders = await webAPI.GetAllAsync <AllUserOrders>(ApiURL.ORDERS_BY_USER + User.Identity.Name, token);
return(View(allUserOrders));
}
public async Task <IActionResult> Update([Bind] News model)
{
var token = await webAPIToken.New();
var result = await webAPI.UpdateAsync <News>(model, ApiURL.NEWS + model.Id, token);
TempData["Article"] = "Nyhetsartikeln har uppdaterats";
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Index()
{
var cartId = HttpContext.Session.GetString(_cartSessionCookie);
// Does user have a shoppingcart Id?
if (cartId == null)
{
return(RedirectToAction("Index", "Home"));
}
// Are there any products in the cart??
var content = await webAPI.GetAllAsync <OrderItemsModel>(ApiURL.CARTS_CONTENT + cartId);
if (content.Count == 0)
{
return(RedirectToAction("Index", "ShoppingCart"));
}
// Is user logged in?
if (User.Identity.IsAuthenticated)
{
orderviewmodel = await webAPI.GetOneAsync <OrderViewModel>(ApiURL.CARTS_CONTENT_PAY + $"{cartId}/{User.Identity.Name}");
// Does user have a complete shippingaddress?
if (!orderviewmodel.AddressComplete)
{
TempData["Address Null"] = "Vänligen ange din adressinformation";
}
// Check if order contains products out of stock
if (orderviewmodel.Products.Any(x => x.QuantityInStock - x.Amount < 0))
{
TempData["QuantityOverload"] = "Din order innehåller ett större antal produkter än vad vi har på lager vilket påverkar leveranstiden.";
}
}
else
{
TempData["LoginNeeded"] = "Du måste vara inloggad för att kunna handla...";
return(RedirectToAction("Index", "ShoppingCart"));
}
OrderAndPaymentMethods.OrderViewModel = orderviewmodel;
var token = await webAPIToken.New();
OrderAndPaymentMethods.User = await webAPI.GetOneAsync <User>(ApiURL.USERS + User.Identity.Name, token);
return(View(OrderAndPaymentMethods));
}
public async Task <IActionResult> EditCategory([Bind] Category model)
{
model.categoryCollection = await GetAllCategories();
if (ModelState.IsValid)
{
// If category contains an Id, update it, else create new category!
if (model.Id > 0)
{
var result = model.categoryCollection.Where(x => x.Id == model.Id).FirstOrDefault();
result.Name = model.Name;
var token = await webAPIToken.New();
var response = await webAPI.UpdateAsync(result, ApiURL.CATEGORIES + result.Id, token);
TempData["CategoryUpdate"] = "Kategorin har uppdaterats!";
}
else
{
// Does category already exist?
if (model.categoryCollection.Any(x => x.Name == model.Name))
{
ModelState.AddModelError("Name", "Kategorin finns redan registrerad!");
return(View("EditCategory", model));
}
// Create new category
var category = new Category()
{
Name = model.Name
};
// Post to API
var token = await webAPIToken.New();
var response = await webAPI.PostAsync <Category>(category, ApiURL.CATEGORIES, token);
TempData["NewCategory"] = "Ny kategori har skapats!";
}
return(RedirectToAction("EditCategory", "Category", new { id = "" }));
}
else
{
return(View("EditCategory", model));
}
}
public async Task <IActionResult> Edit([Bind] Brand model)
{
model.BrandsCollection = await GetAllBrands();
if (ModelState.IsValid)
{
if (model.Id > 0)
{
var brand = model.BrandsCollection.Where(x => x.Id == model.Id).FirstOrDefault();
brand.Name = model.Name;
var token = await webAPIToken.New();
var response = await webAPI.UpdateAsync(brand, ApiURL.BRANDS, token);
}
else
{
// Does brand already exist?
if (model.BrandsCollection.Any(x => x.Name == model.Name))
{
ModelState.AddModelError("Name", "Tillverkaren finns redan registrerad!");
return(View("index", model));
}
// Create new brand
var brand = new Brand()
{
Name = model.Name
};
// Post to API
var token = await webAPIToken.New();
var response = await webAPI.PostAsync(brand, ApiURL.BRANDS, token);
TempData["NewBrand"] = "Ny tillverkare har skapats!";
}
return(RedirectToAction("index", "Brand"));
}
else
{
return(View("index", model));
}
}
public async Task <ActionResult> EditUser()
{
var email = User.Identity.Name;
var token = await webAPIToken.New();
var user = await webAPI.GetOneAsync <User>(ApiURL.USERS + email, token);
var editUserInfoModel = new EditUserInfoModel()
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber,
StreetAddress = user.StreetAddress,
ZipCode = user.ZipCode,
City = user.City
};
return(View(editUserInfoModel));
}
public async Task <ActionResult <IEnumerable <AllProductsViewModel> > > Index(string searchtext)
{
List <AllProductsViewModel> products = new List <AllProductsViewModel>();
// Anything to search for
if (searchtext != null)
{
// Admin search
if (User.Identity.IsAuthenticated && User.IsInRole("Admin"))
{
var token = await webAPIToken.New();
products = await webAPI.GetAllAsync <AllProductsViewModel>(ApiURL.SEARCH_ADMIN + searchtext.ToLower(), token);
}
else
{
products = await webAPI.GetAllAsync <AllProductsViewModel>(ApiURL.SEARCH + searchtext.ToLower());
}
return(View(products));
}
return(RedirectToAction("AllProducts", "Product"));
}
public async Task <ActionResult> CreateProduct(IFormFile file, [Bind] AllProductsViewModel model)
{
try
{
if (ModelState.IsValid)
{
if (!IsUploadedFileImage(file))
{
ModelState.AddModelError("Photo", "Filen är ogiltig!");
TempData["Errors"] = "Filen är ogiltig!";
model.Categories = await webAPI.GetAllAsync <Category>(ApiURL.CATEGORIES);
model.Brands = await webAPI.GetAllAsync <Brand>(ApiURL.BRANDS);
return(View(model));
}
// Instantiate new product
Product newProduct = new Product()
{
Name = model.Name,
Price = model.Price,
Quantity = model.Quantity,
CategoryId = model.CategoryId,
BrandId = model.BrandId,
Description = model.Description,
FullDescription = model.FullDescription,
Specification = model.Specification,
Discount = model.Discount,
ActiveProduct = model.ActiveProduct
};
// Request token
var token = await webAPIToken.New();
// Store product
var apiResonse = await webAPI.PostAsync(newProduct, ApiURL.PRODUCTS, token);
// Deserialize API response content and get ID of newly created product
var newProductId = webAPI.DeserializeJSON <AllProductsViewModel>(apiResonse.ResponseContent).Id;
newProduct.Id = newProductId;
// Store image in www root folder with unique product Id
if (file != null)
{
// Set category folder name
var folderName = await GetCategoryName(model.CategoryId);
// Store new image
ProductImage productImage = new ProductImage(environment.WebRootPath, folderName, file);
newProduct.Photo = productImage.StoreImage(newProduct.Id);
}
// Update product with image
var response = webAPI.UpdateAsync <Product>(newProduct, ApiURL.PRODUCTS + newProduct.Id, token);
}
else
{
model.Categories = await webAPI.GetAllAsync <Category>(ApiURL.CATEGORIES);
model.Brands = await webAPI.GetAllAsync <Brand>(ApiURL.BRANDS);
TempData["Errors"] = "Fyll i formuläret ordentligt";
return(View(model));
}
TempData["Succesmsg"] = $"Great!! {model.Name} skapad i databasen";
return(RedirectToAction("AllProducts", "Product"));
}
catch
{
TempData["Database error"] = "Sorry!! Något gick fel när du lägger Data till databasen";
return(RedirectToAction("CreateProduct", "Product"));
}
}
