Task IUserNotifier.NotifyOutbid(User user, Auctions.Auction auction)
{
Contract.Requires(user != null);
Contract.Requires(auction != null);
throw new NotImplementedException();
}
public IActionResult createAuctions(AuctionViewModel newAuct)
{
int? CurrentUser = HttpContext.Session.GetInt32("CurrentUser");
Users user = _context.Users.Where(x => x.idUser == CurrentUser).SingleOrDefault();
if (newAuct.EndDate < DateTime.Now)
{
ViewBag.DateError = "End Date must be after today";
return(View("createAuctions"));
}
if (ModelState.IsValid)
{
Auctions auction = new Auctions
{
Product = newAuct.Product,
StartingBid = newAuct.StartingBid,
Description = newAuct.Description,
EndDate = newAuct.EndDate,
idUser = user.idUser,
};
_context.Add(auction);
_context.SaveChanges();
return(Redirect("/Dashboard"));
}
return(Redirect("/Dashboard"));
}
private void subastasToolStripMenuItem_Click(object sender, EventArgs e)
{
var auctions = new Auctions();
auctions.Show();
this.Close();
}
public void BuyItem(Auctions auction, Guid userId)
{
var ac = (from a in db.Auctions where a.Id == auction.Id select a).DefaultIfEmpty(null).FirstOrDefault();
if (ac == null)
{
return;
}
if (!ac.Finalized && auction.EndDate > DateTime.Now && ac.ItemsNumber > 0 && userId != ac.OwnerId)
{
ac.ItemsNumber--;
Buyed b = new Buyed()
{
AuctionId = ac.Id, Date = DateTime.Now, UserId = userId, ItemsNum = 1
};
db.Buyed.Add(b);
if (ac.ItemsNumber == 0)
{
AuctionsRepository aucitonsRepo = new AuctionsRepository(db);
aucitonsRepo.CloseAuction(ac);
}
else
{
db.SaveChanges();
}
}
db.SaveChanges();
}
private void LoadOffers(Auctions auction)
{
offers = offersRepo.GetForAuction(view.AuctionId);
view.BestBidLabelVisiblity = true;
view.HighestBidFieldVisiblity = true;
view.BestBidUserNameLabelVisiblity = true;
view.BidFieldVisiblity = true;
view.BidBtnVisiblity = true;
if (offers.Count() == 0)
{
view.BestBidLabelText = "Licytacja od: ";
view.BestBidUserNameLabelVisiblity = false;
return;
}
view.BestBidUserNameFieldVisiblity = true;
if (offers[0].Price >= auction.BuyItNowPrice)
{
view.BuyItNowLabelVisiblity = false;
view.BuyItNowPriceFieldVisiblity = false;
view.BuyItNowBtnVisiblity = false;
}
view.HighestBidField = currencyRepo.Exchange(offers[0].Price, currencyCode);
view.BestBidUserNameField = offers[0].BiddrName;
view.BestBidderId = offers[0].BidderId;
view.MinimumOffer = currencyRepo.ExchangeWithoutCC((offers[0].Price + 1), currencyCode).ToString();
view.LoadOffersControls(offers.Count());
}
public AuctionAllBids GetAuctionWithAllBids(Guid id)
{
return(Auctions.Where(a => a.id == id)
.Select(a => new AuctionAllBids
{
Auction = new PartialAuction
{
id = a.id,
name = a.name,
starting_price = a.starting_price,
duration = a.duration,
owner = a.owner,
description = a.description,
state = a.state,
created = a.created,
opened = a.opened,
closed = a.closed,
won = a.won
},
Bids = a.Bids.OrderByDescending(b => b.amount).Select(bb => new PartialBid
{
bidder = bb.bidder,
amount = bb.amount,
firstName = bb.Bidder.first_name,
lastName = bb.Bidder.last_name,
created = bb.created
}).ToList()
}).SingleOrDefault());
}
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 <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 <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));
}
/// <summary>
/// Resolves auctions for each site's units and stores the results in AuctionResults
/// </summary>
public void RunAuctions()
{
AuctionResults.Clear();
List <string> validSites = new List <string>(MyConfig.Sites.Keys);
Auctions = Auctions.Select(auction =>//removes bids from invalid sites, that way the results will be empty
{
if (!validSites.Contains(auction.Site))
{
auction.Bids.Clear();
}
return(auction);
}).ToList(); //would have but this below, but it makes it look terrible
AuctionResults = Auctions.Select(auction => //foreach auction
auction.Units.Select(unit => //foreach unit
auction.Bids.Where(bid => bid.Unit == unit && //valid units
MyConfig.Sites[auction.Site].Bidders.Contains(bid.Bidder) && //valid bidders
GetAdjustedBid(bid) >= MyConfig.Sites[auction.Site].Floor) //valid minimum bid. Invalid sites had their bids culled, so no need to worry about indexing exceptions
.OrderByDescending(bid => GetAdjustedBid(bid))
.Select(bid => bid) //new AuctionUnitResult(bid.Bidder, bid.BidAmt, bid.Unit))
.FirstOrDefault() //Winning bid in a unit.
//From what I understand, linq does not waste time converting the other items in the above .Select, only the first.
).Where(unitRes => unitRes != null).ToList() //winning bid for each unit. Ignores ones that did not have a winner, aka null results
).ToList(); //will keep empty auctions
}
public IActionResult ViewAuction(int auctid)
{
CheckFinishedAuctions();
List <CurrentUser> ret = HttpContext.Session.GetObjectFromJson <List <CurrentUser> >("curr");
if (ret == null || ret[0].id == 0)
{
return(RedirectToAction(""));
}
else
{
string LocalVariable = HttpContext.Session.GetString("biderror");
if (LocalVariable != null)
{
ViewBag.error = LocalVariable;
}
ViewBag.CurrentUser = ret[0];
Auctions getauct = _context.auctions.Include(a => a.seller).Include(a => a.bidders).SingleOrDefault(w => w.id == auctid);
if (getauct == null)
{
return(RedirectToAction("Dashboard"));
}
List <Bidders> bidlist = _context.bidders.Where(b => b.auctionid == auctid).Include(b => b.bidder).OrderByDescending(b => b.bidamount).ToList();
ViewBag.auct = getauct;
ViewBag.bidlist = bidlist;
return(View());
}
}
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));
}
private void AuctionBetExecute(object parameter)
{
if (IsLogged)
{
Auctions auction = db.Auctions.Where(auc => auc.AuctionId == int.Parse(parameter.ToString())).FirstOrDefault();
if (auction.SellerUserId == UserId)
{
}
else if (auction.EndTime <= Time)
{
auction.IsEnd = true;
}
else if (auction.BuyNowPrice != 0 && Money >= auction.BuyNowPrice)
{
auction.CurrentPrice = (int)auction.BuyNowPrice;
auction.WinnerUserId = UserId;
auction.IsEnd = true;
}
else if (auction.CurrentPrice < Money)
{
auction.CurrentPrice = Money;
auction.WinnerUserId = UserId;
}
else
{
MessageBox.Show("Chyba");
}
db.SaveChanges();
ChangeProperty("Auctions");
}
}
public IActionResult VNew(Auctionsvm Model, DateTime end, string name, int bid, string description)
{
if (end < DateTime.Now)
{
ViewBag.error = "Please Enter a Future Date";
return(View("New"));
}
else if (ModelState.IsValid)
{
string a1 = HttpContext.Session.GetString("user");
Person a2 = _context.Users.SingleOrDefault(User => User.Username == a1);
Auctions NewAuction = new Auctions
{
Name = name,
Description = description,
Bid = bid,
Start = DateTime.Now,
End = end,
Person = a2,
};
_context.Add(NewAuction);
_context.SaveChanges();
return(RedirectToAction("welcome"));
}
else
{
ViewBag.error = ModelState.Values;
return(View("New"));
}
}
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 ActionResult Create(Auctions bt)
{
string error = string.Empty;
if (ModelState.IsValid)
{
bool isSuccess = _serv.CreateAuction(bt);
TempData["AlertCSS"] = isSuccess ? "alert success" : "alert error";
if (!isSuccess)
{
ModelState.AddModelError("", error);
}
else
{
TempData["OutputMessage"] = "Record Successfully Created";
}
if (ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
}
return(View());
}
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 ActionResult Create([Bind(Include = "AuctionTitle, PriceStart, DescriptionShort, DescriptionLong")] CreateAuctionViewModel auc)
{
if (ModelState.IsValid)
{
Auctions auction = new Auctions()
{
Id = Guid.NewGuid().ToString(),
CategoryId = "1",
Title = auc.AuctionTitle,
StartPrice = auc.PriceStart,
Currency = "USD",
CreatorId = User.Identity.GetUserId(),
ShortDescription = auc.DescriptionShort,
LongDescription = auc.DescriptionLong,
DateCreated = DateTime.Now,
//ExpiresIn = (int)auc.ExpiresIn.,
};
db.auctions.auctions.Add(auction);
db.auctions.SaveChanges();
return(Redirect("~/AuctionPageViewModels/Index/" + auction.Id));
}
return(Redirect("/"));
}
public IEnumerable <Aukcje.Models.CommentWithAuction> SelectComments()
{
IEnumerable <Aukcje.Models.CommentWithAuction> list = new List <CommentWithAuction>();
IEnumerable <Aukcje.Auction> Auctions;
IEnumerable <Aukcje.Comment> Comments;
using (var ctx = new bazaEntities())
{
Auctions = ctx.Auctions.ToList();
Comments = ctx.Comments.ToList();
}
string sellerName = HttpContext.Current.Request.QueryString["UID"] ?? view.UName;
Auctions = Auctions.Where(p => p.seller.Equals(sellerName) && p.status == "zakonczone");
list = from p in Auctions
join c in Comments
on p.commentID equals c.CommentID
select new CommentWithAuction()
{
aukcja = p, Comment = c, ConsumerName = "asd"
};
return(list);
}
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));
}
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
Server server = this.servers[(int)e.Argument];
bool flag = false;
while (!flag)
{
Console.WriteLine("Starting " + server.apiName);
this.startedDelegate(server);
Auctions auctions = this.explorer.GetAuctions(server.apiName);
auctions.filterData();
if (auctions != null)
{
server.auctions = auctions;
this.refreshDelegate(server);
flag = true;
}
else
{
Console.WriteLine("parsing failed " + server.apiName);
flag = false;
}
}
Console.WriteLine("completed " + server.apiName);
}
private void _auctionCall(IAuction auction)
{
AuctionStarter auctionStarter = new AuctionStarter(auction, Agents);
auctionStarter.startAuction();
if (auction.AgentsName.Count != 0)
{
AuctionManager auctionManager = new AuctionManager(auction);
Console.WriteLine($"\nThe auction on {auction.Product.Name} starts now!!! The min price is : {auction.BestPrice}");
auctionManager.Manage();
_restAgentsFlag();
try
{
Auctions.RemoveAt(Auctions.IndexOf(auction));
}
catch (ArgumentOutOfRangeException ex)
{
Console.WriteLine($"Can't delete {auction.Product.Name} ");
}
}
else
{
try
{
Auctions.RemoveAt(Auctions.IndexOf(auction));
}
catch (ArgumentOutOfRangeException ex)
{
Console.WriteLine($"Can't delete {auction.Product.Name} ");
}
}
}
public void Get_TW_Realm_Auction_Data()
{
WowExplorer twExplorer = new WowExplorer(Region.TW, Locale.zh_TW, APIKey);
Auctions auctions = twExplorer.GetAuctions("Balnazzar");
Assert.IsTrue(auctions.AllAuctionHouses.Auctions.Count() > 0);
}
public IActionResult Delete(int id)
{
Auctions a3 = _context.Auctions.SingleOrDefault(auctions => auctions.id == id);
_context.Remove(a3);
_context.SaveChanges();
return(RedirectToAction("welcome"));
}
public void Get_EU_Realm_Auction_Data()
{
WowExplorer euExplorer = new WowExplorer(Region.EU, Locale.fr_FR, APIKey);
Auctions auctions = euExplorer.GetAuctions("Twisting Nether");
Assert.IsTrue(auctions.AllAuctionHouses.Auctions.Count() > 0);
}
public AuctionManager()
{
INSTANCE = this;
log4net.Config.XmlConfigurator.Configure();
logger = LogManager.GetLogger(typeof(AuctionManager));
auctions = new Auctions();
auctionUpdates = new AuctionUpdates();
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
activeAuctions = Auctions.GetStartedAuctions();
AuctionsRepeater.DataSource = activeAuctions;
AuctionsRepeater.DataBind();
}
public void RemoveAuction()
{
Auctions.Remove(this);
AuctionItem = null;
Safe.Auction = null;
OnGoing = false;
ClaimPeriod = DateTime.MinValue;
}
// GET: BidsNewViewModels/Create
public ActionResult Create()
{
Auctions auction = new Auctions();
ModelContainer cont = new ModelContainer();
cont.AddModel(auction);
return(View(cont));
}
public Auction GetAuction(string ID)
{
var query =
from a in Auctions.Include("Bids.User")
where a.ID.ToString() == ID
select a;
return(query.SingleOrDefault());
}
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 void SaveAuction(Auction auction)
{
var existingRecord = Context.Auctions.FirstOrDefault(x => x.AuctionRef == auction.AuctionRef);
if (existingRecord != null)
{
existingRecord.EndDate = auction.EndDate;
existingRecord.MinBid = auction.MinBid;
Context.Auctions.AddOrUpdate(existingRecord);
}
else
{
var auc = new Auctions();
auc.FromDomainObject(auction);
Context.Auctions.AddOrUpdate(auc);
}
Context.Save();
}
