public async Task <ActionResult> Delete(Guid?id, string auctionId, bool?saveChangeError = false)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (saveChangeError.GetValueOrDefault())
{
ViewBag.ErrorMessage = "Произошла ошибка при удалении.";
}
var auction = config.AuctionHouses.Search(auctionId);
if (auction == null)
{
ModelState.AddModelError(string.Empty, Resource.errAuctionNotFound);
}
Auctions.SetAuction(auction);
ViewBag.Auction = auction;
var categoryDTO = await _categoryService.GetCategoryAsync(id);
if (categoryDTO == null)
{
return(HttpNotFound());
}
var categoryVM = Mapper.Map <CategoryViewModel>(categoryDTO);
return(View(categoryVM));
}
public async Task <ActionResult> Edit(Guid?id, string auctionId)
{
if (id == null || auctionId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var auction = config.AuctionHouses.Search(auctionId);
if (auction == null)
{
ModelState.AddModelError(string.Empty, Resource.errAuctionNotFound);
}
Auctions.SetAuction(auction);
DropdownAuction();
var categoryDTO = await _categoryService.GetCategoryAsync(id);
if (categoryDTO == null)
{
return(HttpNotFound());
}
var categoryVM = Mapper.Map <CategoryViewModel>(categoryDTO);
return(View(categoryVM));
}
public async Task <ActionResult> DeleteProduct(Guid?id, string auctionId, bool?saveChangeError = false)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (saveChangeError.GetValueOrDefault())
{
ViewBag.ErrorMessage = "Произошла ошибка при удалении.";
}
var auction = config.AuctionHouses.Search(auctionId);
Auctions.SetAuction(auction);
ViewBag.AuctionName = auction.Name;
var productDTO = await _productService.GetProductAsync(id);
if (productDTO == null)
{
return(HttpNotFound());
}
ViewBag.Category = (await _categoryService.ShowAwalaibleCategoriesAsync()).FirstOrDefault(c => c.Id == productDTO.CategoryID).Name;
var productVM = Mapper.Map <ProductViewModel>(productDTO);
return(View(productVM));
}
public async Task <ActionResult> EditProduct(Guid?id, string auctionId)
{
DropdownAuction();
await DropdownCategory();
ViewBag.OldAuction = auctionId;
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var auction = config.AuctionHouses.Search(auctionId);
Auctions.SetAuction(auction);
var productDTO = await _productService.GetProductAsync(id);
if (productDTO == null)
{
return(HttpNotFound());
}
if (productDTO.State != State.Draft)
{
return(RedirectToAction("UserProductList"));
}
var productVM = Mapper.Map <ProductViewModel>(productDTO);
return(View(productVM));
}
public async Task <JsonResult> Index(string products)
{
dynamic listProducts = new ExpandoObject();
if (Request.IsAjaxRequest())
{
try
{
listProducts = JsonConvert.DeserializeObject(products);
foreach (var product in (IEnumerable <dynamic>)listProducts)
{
var auction = product.auction.ToString();
var currAuction = config.AuctionHouses.Search(auction);
Auctions.SetAuction(currAuction);
ProductDTO currProduct = await _productService.GetProductAsync(Guid.Parse(product.id.ToString()));
currProduct.State = (State)Enum.Parse(typeof(State), product.state.ToString());
currProduct.StartDate = DateTime.Now;
await _productService.EditProductAsync(currProduct);
_logger.Info(string.Format("moderator change state on product - {0}, auction -{1}", currProduct.Id, auction));
}
return(Json(JsonConvert.SerializeObject(Url.Action("Index", "Home", new { lang = "en-Us", auction = "Auction1" }))));
}
catch (Exception)
{
}
}
return(Json(JsonConvert.SerializeObject(Url.Action("Index", "Moderate", new { lang = "en-Us", auction = "Auction1" }))));
}
public async Task <Dictionary <string, IEnumerable <BidViewModel> > > GetBidsFromListProduct([FromBody] IEnumerable <ProductsListWithAuction> products)
{
if (products.FirstOrDefault() == null)
{
return(null);
}
Dictionary <string, IEnumerable <BidViewModel> > listlastBids = new Dictionary <string, IEnumerable <BidViewModel> >();
foreach (var productList in products)
{
var auction = config.AuctionHouses.Search(productList.Auction);
if (auction != null)
{
Auctions.SetAuction(auction);
var productsDTO = productList.Products.Select(pr => Mapper.Map <BussinessLogic.Models.ProductDTO>(pr));
var listLastBid = await _bidService.ShowLastBidForListProductAsync(productsDTO);
var listBidVM = listLastBid.Select(b => Mapper.Map <BidViewModel>(b));
listlastBids.Add(productList.Auction, listBidVM);
}
}
return(listlastBids);
}
public async Task <ActionResult> Edit(Guid?id, string auctionId)
{
await DropDown();
DropdownAuction();
ViewBag.OldAuction = auctionId;
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var auction = config.AuctionHouses.Search(auctionId);
if (auction == null)
{
ModelState.AddModelError(string.Empty, Resource.errAuctionNotFound);
}
Auctions.SetAuction(auction);
var productDTO = await _productService.GetProductAsync(id);
if (productDTO == null)
{
return(HttpNotFound());
}
var productVM = Mapper.Map <ProductViewModel>(productDTO);
return(View(productVM));
}
public async Task <ActionResult> Index()
{
var listPermissions = (await _customUserManager.GetAllPermissionsAsync()).Where(p => p.UserId == Guid.Parse(ClaimId));
var dictionaryProduct = new Dictionary <string, IList <ProductViewModel> >();
foreach (var permission in listPermissions)
{
if ((int)permission.Role == (int)Models.Role.Admin)
{
foreach (AuctionHouseElement auction in config.AuctionHouses)
{
Auctions.SetAuction(auction);
var draftProducts = await _productService.ShowProductsForModerationAsync();
dictionaryProduct.Add(auction.Name, draftProducts.Select(pr => Mapper.Map <ProductViewModel>(pr)).ToList());
}
}
if ((int)permission.Role == (int)Models.Role.Moderator)
{
var currAuction = config.AuctionHouses.Search(permission.AuctionId);
Auctions.SetAuction(currAuction);
var draftProducts = await _productService.ShowProductsForModerationAsync(permission.CategoriesId);
if (draftProducts.Count() > 0)
{
dictionaryProduct.Add(permission.AuctionId, draftProducts.Select(pr => Mapper.Map <ProductViewModel>(pr)).ToList());
}
}
}
return(View(dictionaryProduct));
}
public async Task <ActionResult> Index(string lang = "en-Us", string auction = "Auction1", int page = 1)
{
var auctionModel = config.AuctionHouses.Search(auction);
if (auctionModel != null)
{
Auctions.SetAuction(auctionModel);
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var listProducts = await _productService.ShowAwalaibleProductsAsync();
if (listProducts.IsNullOrEmpty())
{
return(View("~/Views/Home/EmptyModel.cshtml"));
}
PageInfo pageInfo = new PageInfo {
PageNumber = page, TotalItems = listProducts.Count()
};
var listLastBid = await _bidService.ShowLastBidForListProductAsync(listProducts);
var listViewProducts = listProducts.Select(pr => new ProductClientViewModel
{
Id = pr.Id,
CategoryID = pr.CategoryID,
Description = pr.Description,
Duration = pr.Duration.TotalSeconds,
Name = pr.Name,
Picture = pr.Picture,
StartDate = pr.StartDate,
StartPrice = pr.StartPrice
});
IEnumerable <ProductClientViewModel> productPerPages = listViewProducts.Skip((page - 1) * pageInfo.PageSize).Take(pageInfo.PageSize);
var listBidViewModel = listLastBid.Select(b => Mapper.Map <BidViewModel>(b));
var userResult = await _customUserManager.GetAllUsersAsync();
var userVM = userResult.Select(u => Mapper.Map <ProfileViewModel>(u));
ProductsWithBidViewModel categoryWithBids = new ProductsWithBidViewModel()
{
Products = productPerPages,
PageInfo = pageInfo,
Bids = listBidViewModel,
Users = userVM
};
ViewBag.BidStep = BidStep;
ViewBag.Auction = auctionModel.Name;
return(View("~/Views/Home/Index.cshtml", categoryWithBids));
}
public async Task <IEnumerable <ProductViewModel> > GetProductsFromCategory(string auctionId, Guid categoryId)
{
var auction = config.AuctionHouses.Search(auctionId);
if (auction != null)
{
Auctions.SetAuction(auction);
return((await _productService.ShowProductsFromCategoryAsync(categoryId)).Select(p => Mapper.Map <ProductViewModel>(p)));
}
return(null);
}
public async Task <Dictionary <string, IEnumerable <BidViewModel> > > GetAllBids()
{
var bidDictionary = new Dictionary <string, IEnumerable <BidViewModel> >();
foreach (AuctionHouseElement auction in config.AuctionHouses)
{
Auctions.SetAuction(auction);
bidDictionary.Add(auction.Name, (await _bidService.GetBidsAsync()).Select(c => Mapper.Map <BidViewModel>(c)));
}
return(bidDictionary);
}
public async Task <ActionResult> Category(Guid?id, string lang = "en-Us", string auction = "Auction1")
{
var auctionModel = config.AuctionHouses.Search(auction);
if (auctionModel != null)
{
Auctions.SetAuction(auctionModel);
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (id == null)
{
return(null);
}
var products = await _productService.ShowProductsFromCategoryAsync(id.GetValueOrDefault());
if (products == null || products.IsNullOrEmpty())
{
return(View("~/Views/Home/EmptyModel.cshtml"));
}
var listLastBid = await _bidService.ShowLastBidForListProductAsync(products);
var listViewProducts = products.Select(pr => new ProductClientViewModel
{
Id = pr.Id,
CategoryID = pr.CategoryID,
Description = pr.Description,
Duration = pr.Duration.TotalSeconds,
Name = pr.Name,
Picture = pr.Picture,
StartDate = pr.StartDate
});
var listBidViewModel = listLastBid.Select(b => Mapper.Map <BidViewModel>(b));
var userResult = await _customUserManager.GetAllUsersAsync();
var userVM = userResult.Select(u => Mapper.Map <ProfileViewModel>(u));
ProductsWithBidViewModel categoryWithBids = new ProductsWithBidViewModel()
{
Products = listViewProducts,
Bids = listBidViewModel,
Users = userVM
};
ViewBag.BidStep = BidStep;
ViewBag.Auction = auctionModel.Name;
return(View("~/Views/Home/Index.cshtml", categoryWithBids));
}
public async Task <Dictionary <string, IEnumerable <ProductViewModel> > > GetAllProducts()
{
var productsDictionary = new Dictionary <string, IEnumerable <ProductViewModel> >();
foreach (AuctionHouseElement auction in config.AuctionHouses)
{
Auctions.SetAuction(auction);
var productsResult = await _productService.GetProductsAsync();
productsDictionary.Add(auction.Name, productsResult.Select(p => Mapper.Map <ProductViewModel>(p)));
}
return(productsDictionary);
}
public async Task <ProductViewModel> GetProduct(string auctionId, Guid productId)
{
var auction = config.AuctionHouses.Search(auctionId);
if (auction != null)
{
Auctions.SetAuction(auction);
var productDTO = await _productService.GetProductAsync(productId);
return(Mapper.Map <ProductViewModel>(productDTO));
}
return(null);
}
public async Task <IEnumerable <CategoryViewModel> > GetCategoriesFromAuction(string auctionId)
{
var auction = config.AuctionHouses.Search(auctionId);
if (auction != null)
{
Auctions.SetAuction(auction);
var categoriesList = await _categoryService.ShowAwalaibleCategoriesAsync();
return(categoriesList.Select(c => Mapper.Map <CategoryViewModel>(c)));
}
return(null);
}
public async Task <IEnumerable <BidViewModel> > GetBidsFromAuction(string auctionId)
{
var auction = config.AuctionHouses.Search(auctionId);
if (auction != null)
{
Auctions.SetAuction(auction);
var bidList = await _bidService.GetBidsAsync();
return(bidList.Select(c => Mapper.Map <BidViewModel>(c)));
}
return(null);
}
public async Task <Dictionary <string, IEnumerable <CategoryViewModel> > > GetAllCategories()
{
var categoryDictionary = new Dictionary <string, IEnumerable <CategoryViewModel> >();
foreach (AuctionHouseElement auction in config.AuctionHouses)
{
Auctions.SetAuction(auction);
var categoryResult = await _categoryService.ShowAwalaibleCategoriesAsync();
categoryDictionary.Add(auction.Name, categoryResult.Select(c => Mapper.Map <CategoryViewModel>(c)));
}
return(categoryDictionary);
}
public async Task <ActionResult> UserWinProductList(Guid?id)
{
if (id == null)
{
if (ClaimId != null)
{
id = new Guid(ClaimId);
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
var catalogDictionary = new Dictionary <string, CatalogViewModel>();
foreach (AuctionHouseElement auction in config.AuctionHouses)
{
Auctions.SetAuction(auction);
var bidWinnerList = await _bidService.WinnerListProductAsync(id.GetValueOrDefault());
var productList = await _productService.ShowAwalaibleProductsWithTimeOffAsync();
////need fix to outdating
var productWinnerList = new List <ProductDTO>();
ProductDTO product;
foreach (var bid in bidWinnerList)
{
product = productList.FirstOrDefault(pr => pr.Id == bid.ProductId);
if (product != null)
{
productWinnerList.Add(product);
}
}
var productVMList = productWinnerList.Select(pr => Mapper.Map <ProductViewModel>(pr));
var categoryList = await _categoryService.ShowAwalaibleCategoriesAsync();
var categoryVMList = categoryList.Select(pr => Mapper.Map <CategoryViewModel>(pr));
catalogDictionary.Add(auction.Name, new CatalogViewModel()
{
CategoriesVM = categoryVMList, ProductVM = productVMList
});
}
return(View(catalogDictionary));
}
private async Task DropdownCategory()
{
var auction = ((IEnumerable <dynamic>)ViewBag.Auction).First();
var currAuction = config.AuctionHouses.Search(auction.Value);
Auctions.SetAuction(currAuction);
var categories = await _categoryService.ShowAwalaibleCategoriesAsync();
ViewBag.Categories = categories.Select(c => new
{
categoryId = c.Id,
Value = c.Name,
});
}
public async Task <ActionResult> Delete(Guid?id, string auctionId)
{
try
{
var auction = config.AuctionHouses.Search(auctionId);
Auctions.SetAuction(auction);
await _productService.RemoveProductAsync(id);
}
catch (Exception)
{
return(RedirectToAction("Delete", new { id = id, saveChangesError = true }));
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> EditToPost(CategoryViewModel categoryVM, string auctionId, string oldAuction)
{
if (categoryVM.Id == null || auctionId == null || oldAuction == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var auction = config.AuctionHouses.Search(auctionId);
var currAuction = config.AuctionHouses.Search(oldAuction);
if (auction == null || currAuction == null)
{
ModelState.AddModelError(string.Empty, Resource.errAuctionNotFound);
}
Auctions.SetAuction(auction);
if (!await _categoryService.IsUnigueNameAsync(categoryVM.Name))
{
ModelState.AddModelError("Name", Resource.errNotUnique);
}
else
{
var categoryDTO = Mapper.Map <CategoryDTO>(categoryVM);
try
{
if (currAuction.Name != auction.Name)
{
Auctions.SetAuction(currAuction);
await _categoryService.RemoveCategoryAsync(categoryVM.Id);
await _categoryService.AddCategoryAsync(categoryDTO);
}
else
{
await _categoryService.EditCategoryAsync(categoryDTO);
}
return(RedirectToAction("Index"));
}
catch (Exception)
{
ModelState.AddModelError(string.Empty, "Невозможно обновить текущее значение");
}
}
DropdownAuction();
return(View());
}
public async Task <ActionResult> RenderImageProduct(Guid id, string auctionId)
{
var auction = config.AuctionHouses.Search(auctionId);
if (auction == null)
{
////error
}
Auctions.SetAuction(auction);
var product = await _productService.GetProductAsync(id);
var imageByteProduct = ImageHelper.Base64ToImage(product.Picture);
return(File(imageByteProduct, "image/png"));
}
public async Task <JsonResult> GetCategory(string data)
{
IEnumerable <CategoryDTO> categories = null;
if (Request.IsAjaxRequest())
{
dynamic auctionObj = JsonConvert.DeserializeObject(data);
var auction = config.AuctionHouses.Search(auctionObj.auctionId.ToString());
Auctions.SetAuction(auction);
categories = await _categoryService.ShowAwalaibleCategoriesAsync();
return(Json(JsonConvert.SerializeObject(categories, Formatting.None)));
}
return(Json(JsonConvert.SerializeObject(categories, Formatting.None)));
}
public async Task <IHttpActionResult> MakeABid([FromBody] BidViewModel bid, string auctionId)
{
bid.DateTime = DateTime.Now;
var auction = config.AuctionHouses.Search(auctionId);
if (auction == null)
{
BadRequest();
}
Auctions.SetAuction(auction);
var product = await _productService.GetProductAsync(bid.ProductId);
if (product == null)
{
BadRequest();
}
var user = await _customUserManager.FindByIdAsync(bid.UserId.ToString());
if (user == null)
{
BadRequest();
}
var lastBid = await _bidService.ShowLastBidForProductAsync(product.Id);
bid.Id = Guid.NewGuid();
if (lastBid == null && bid.Price > BidStep)
{
await _bidService.AddBidAsync(Mapper.Map <BussinessLogic.Models.Bid>(bid));
return(Ok());
}
if (bid.Price >= lastBid.Price + BidStep && lastBid.DateTime < bid.DateTime)
{
await _bidService.AddBidAsync(Mapper.Map <BussinessLogic.Models.Bid>(bid));
return(Ok());
}
return(BadRequest());
}
public async Task <ActionResult> Create(CategoryViewModel categoryVM, string auctionId)
{
if (auctionId == null)
{
ModelState.AddModelError(string.Empty, Resource.errAuctionNotFound);
}
var auction = config.AuctionHouses.Search(auctionId);
if (auction == null)
{
ModelState.AddModelError(string.Empty, Resource.errAuctionNotFound);
}
Auctions.SetAuction(auction);
if (!await _categoryService.IsUnigueNameAsync(categoryVM.Name))
{
ModelState.AddModelError("Name", Resource.errNotUnique);
}
try
{
if (ModelState.IsValid)
{
var categoryDTO = new CategoryDTO()
{
Id = Guid.NewGuid()
};
categoryVM.Id = categoryDTO.Id;
categoryDTO.InjectFrom(categoryVM);
await _categoryService.AddCategoryAsync(categoryDTO);
return(RedirectToAction("Index"));
}
}
catch (DataException)
{
ModelState.AddModelError(string.Empty, "try again");
}
DropdownAuction();
return(View(categoryVM));
}
public async Task <CategoryViewModel> GetCategory(string auctionId, Guid id)
{
var auction = config.AuctionHouses.Search(auctionId);
if (auction != null)
{
Auctions.SetAuction(auction);
var category = await _categoryService.GetCategoryAsync(id);
if (category == null)
{
return(null);
}
return(Mapper.Map <CategoryViewModel>(category));
}
return(null);
}
public async Task <ActionResult> Delete(Guid?id, string auctionId)
{
try
{
var auction = config.AuctionHouses.Search(auctionId);
if (auction == null)
{
ModelState.AddModelError(string.Empty, Resource.errAuctionNotFound);
}
Auctions.SetAuction(auction);
await _categoryService.RemoveCategoryAsync(id);
}
catch (Exception)
{
return(RedirectToAction("Delete", new { id = id, saveChangesError = true }));
}
return(RedirectToAction("Index"));
}
public async Task <IHttpActionResult> CreateProduct([FromBody] ProductViewModel product, string auctionId)
{
var auction = config.AuctionHouses.Search(auctionId);
if (auction == null)
{
return(NotFound());
}
Auctions.SetAuction(auction);
////fix for user
product.Id = Guid.NewGuid();
product.State = State.Draft;
product.StartDate = DateTime.Now;
var productDTO = Mapper.Map <ProductDTO>(product);
await _productService.AddProductAsync(productDTO);
return(Ok());
}
public async Task <ActionResult> Index()
{
var productDictionary = new Dictionary <string, CatalogViewModel>();
foreach (AuctionHouseElement auction in config.AuctionHouses)
{
Auctions.SetAuction(auction);
var categoriesResult = await _categoryService.ShowAwalaibleCategoriesAsync();
var categoriesList = categoriesResult.Select(m => Mapper.Map <CategoryViewModel>(m));
var productResult = await _productService.GetProductsAsync();
var productViewModelList = productResult.Select(c => Mapper.Map <ProductViewModel>(c));
productDictionary.Add(auction.Name, new CatalogViewModel()
{
CategoriesVM = categoriesList, ProductVM = productViewModelList
});
}
return(View(productDictionary));
}
public async Task <ActionResult> UserProductList(Guid?id)
{
if (id == null)
{
if (ClaimId != null)
{
id = new Guid(ClaimId);
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
var productDictionary = new Dictionary <string, CatalogViewModel>();
foreach (AuctionHouseElement auction in config.AuctionHouses)
{
Auctions.SetAuction(auction);
var productList = await _productService.ShowProductsOfUserAsync(id.GetValueOrDefault());
var productVMList = productList.Select(pr => Mapper.Map <ProductViewModel>(pr));
var categoryList = await _categoryService.ShowAwalaibleCategoriesAsync();
var categoryVMList = categoryList.Select(pr => Mapper.Map <CategoryViewModel>(pr));
if (productList.FirstOrDefault() != null)
{
productDictionary.Add(auction.Name, new CatalogViewModel()
{
CategoriesVM = categoryVMList, ProductVM = productVMList
});
}
}
return(View(productDictionary));
}
