private void CloseAuctions()
{
logger.InfoFormat("CloseAuctions: {0}", JsonConvert.SerializeObject(new
{
}));
try
{
using (AuctionDB db = new AuctionDB())
{
var now = DateTime.UtcNow;
var auctions = db.Auctions.Where(a => a.ClosingTime <= now && a.Status != AuctionStatus.COMPLETED).Include(a => a.Bids.Select(b => b.User)).ToList();
foreach (var auction in auctions)
{
logger.InfoFormat("CloseAuctions: Auction {0} is closed", JsonConvert.SerializeObject(new
{
auction.Id,
auction.Name,
auction.CurrentPrice,
auction.Currency,
}));
auction.Status = AuctionStatus.COMPLETED;
db.Entry(auction).State = EntityState.Modified;
// za svakog korisnika vraca najveci bid
var results = auction.Bids.GroupBy(b => b.User).Select(g => new
{
tokens = g.Max(b => b.NumberOfTokens),
user = g.Key
});
// vratiti tokene svima koji nisu pobedili
foreach (var result in results)
{
// nije pobednik
if (auction.User != result.user)
{
logger.InfoFormat("CloseAuctions: user is getting tokens back {0}", JsonConvert.SerializeObject(new
{
result.tokens,
result.user.UserName
}));
result.user.NumberOfTokens += result.tokens;
db.Entry(result.user).State = EntityState.Modified;
}
}
}
db.SaveChanges();
}
}
catch (Exception e)
{
logger.Error("CloseAuctions", e);
}
}
public bool OpenAuction(string id)
{
logger.InfoFormat("OpenAuction: {0}", JsonConvert.SerializeObject(new
{
id
}));
try
{
if (String.IsNullOrEmpty(id))
{
logger.ErrorFormat("OpenAuction: {0} id is null", JsonConvert.SerializeObject(new
{
id
}));
return(false);
}
var guidId = new Guid(id);
using (AuctionDB db = new AuctionDB())
{
var auction = db.Auctions.Where(a => a.Id.Equals(guidId)).SingleOrDefault();
if (auction == null)
{
logger.ErrorFormat("OpenAuction: Auction {0} doesn't exist", JsonConvert.SerializeObject(new
{
auction
}));
return(false);
}
auction.OpeningTime = DateTime.UtcNow;
auction.ClosingTime = DateTime.UtcNow.Add(TimeSpan.FromSeconds(auction.Duration));
auction.Status = AuctionStatus.OPENED;
db.Entry(auction).State = EntityState.Modified;
db.SaveChanges();
logger.InfoFormat("OpenAuction: Auction is {0} open", JsonConvert.SerializeObject(new
{
auction.Id,
auction.Name,
auction.OpeningTime,
auction.Duration,
auction.ClosingTime,
auction.CurrentPrice,
auction.Currency
}));
return(true);
}
}
catch (Exception e)
{
logger.Error("OpenAuction", e);
}
// something went wrong
return(false);
}
public bool SetDefaultValues(EditDefaultValuesViewModel model)
{
logger.InfoFormat("SetDefaultValues: {0}", JsonConvert.SerializeObject(new
{
model
}));
if (model == null)
{
logger.ErrorFormat("GetEditDefaultValues: {0} model is null", JsonConvert.SerializeObject(new
{
}));
return(false);
}
try
{
using (AuctionDB db = new AuctionDB())
{
DefaultValues defaultValues = db.DefaultValues.SingleOrDefault();
if (defaultValues == null)
{
logger.InfoFormat("SetDefaultValues: {0} defaultValues is null", JsonConvert.SerializeObject(new
{
}));
defaultValues = new DefaultValues();
db.Entry(defaultValues).State = EntityState.Added;
}
else
{
db.Entry(defaultValues).State = EntityState.Modified;
}
defaultValues.AuctionDuration = model.AuctionDuration;
defaultValues.Currency = model.Currency;
defaultValues.NumberOfAuctionsPerPage = model.NumberOfAuctionsPerPage;
defaultValues.SilverTokenNumber = model.SilverTokenNumber;
defaultValues.GoldTokenNumber = model.GoldTokenNumber;
defaultValues.PlatinuTokenNumber = model.PlatinuTokenNumber;
defaultValues.TokenValue = model.TokenValue;
db.SaveChanges();
logger.InfoFormat("SetDefaultValues: {0} new defaultValues", JsonConvert.SerializeObject(new
{
}));
return(true);
}
}
catch (Exception e)
{
logger.Error("SetDefaultValues", e);
}
//something went wrong
return(false);
}
public Guid?CreateOrder(OrderPackage package, string orderUserId)
{
logger.InfoFormat("CreateOrder: {0} ", JsonConvert.SerializeObject(new
{
package,
orderUserId
}));
try
{
using (AuctionDB db = new AuctionDB())
{
var defaultValues = db.DefaultValues.SingleOrDefault();
var orderUser = db.Users.Where(u => u.Id.Equals(orderUserId)).SingleOrDefault();
if (orderUser == null || defaultValues == null)
{
logger.ErrorFormat("CreateOrder: Something is null {0} ", JsonConvert.SerializeObject(new
{
orderUser,
defaultValues
}));
return(null);
}
Order order = new Order
{
Currency = defaultValues.Currency,
Id = Guid.NewGuid(),
User = orderUser,
NumberOfTokens = (package == OrderPackage.SILVER ? defaultValues.SilverTokenNumber
: package == OrderPackage.GOLD ? defaultValues.GoldTokenNumber
: defaultValues.PlatinuTokenNumber),
Status = OrderStatus.CANCELED
};
order.Price = order.NumberOfTokens * defaultValues.TokenValue;
db.Orders.Add(order);
db.SaveChanges();
logger.InfoFormat("CreateOrder: new order {0} ", JsonConvert.SerializeObject(new
{
order.Id,
order.Currency,
order.NumberOfTokens,
order.Status,
order.Price,
}));
return(order.Id);
}
}
catch (Exception e)
{
logger.Error("CreateOrder", e);
}
return(null);
}
public bool SetOrderStatus(string orderID, OrderStatus status)
{
logger.InfoFormat("SetOrderStatus: {0} ", JsonConvert.SerializeObject(new
{
orderID,
status
}));
try
{
using (AuctionDB db = new AuctionDB())
{
var order = db.Orders.Include(a => a.User).Where(o => o.Id.ToString() == orderID).SingleOrDefault();
if (order == null)
{
logger.ErrorFormat("SetOrderStatus: order {0} is null ", JsonConvert.SerializeObject(new
{
order
}));
return(false);
}
order.Status = status;
if (status == OrderStatus.COMPLETED)
{
// add tokens to the user
order.User.NumberOfTokens += order.NumberOfTokens;
db.Entry(order.User).State = EntityState.Modified;
}
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
logger.InfoFormat("SetOrderStatus: updated order {0} ", JsonConvert.SerializeObject(new
{
order.Id,
order.NumberOfTokens,
order.Status,
order.User.UserName
}));
return(true);
}
}
catch (Exception e)
{
logger.Error("SetOrderStatus", e);
}
return(false);
}
//------------------------------ EVENTHANDLERS --------------------------------------------------------
/**
* This method assigns the best BuyingOffer
* of a salesSupply to a new value object,
* overwriting the existing value.
*/
private void CreateButton_Click(object sender, RoutedEventArgs e)
{
string priceStr = TxtBoxPriceOffer.Text;
double oldOffer = _salesSupply.HighestPrice;
if (priceStr == null || priceStr == "" || priceStr == "Angiv pris")
{
ErrorLabel.Content = "Indtast venligst et beløb.";
ErrorLabel.Visibility = Visibility.Visible;
}
else
{
try
{
double price = Convert.ToDouble(priceStr);
if (price > oldOffer && !priceStr.Contains("-"))
{
BuyingOffer offer = new BuyingOffer(price, _salesSupply, _buyerInfo);
_context.AddBuyingOfferToSalesSupply(_salesSupply, offer);
_context.SaveChanges();
_main.ListBox.ItemsSource = null;
_main.ListBox.ItemsSource = _context.GetSalesSupplies();
_main.Show();
this.Hide();
}
else if (priceStr.Contains("-"))
{
ErrorLabel.Content = "Indtast venligst et positivt tal.";
ErrorLabel.Visibility = Visibility.Visible;
}
else
{
ErrorLabel.Content = "Indtast venligst et beløb som overgår det forrige bud.";
ErrorLabel.Visibility = Visibility.Visible;
}
}
catch (Exception)
{
ErrorLabel.Content = "Indtast venligst et tal.";
ErrorLabel.Visibility = Visibility.Visible;
}
}
}
public MainWindow(string name, string number, string email)
{
InitializeComponent();
_name = name;
_number = number;
_email = email;
_context = new AuctionDB();
DataContext = _context;
ContactInfo dbBuyerInfo = _context.GetContactInfoByStrings(_name, _number, _email);
if (dbBuyerInfo == null)
{
_buyerInfo = new ContactInfo(_name, _number, _email);
_context.ContactInfoes.Add(_buyerInfo);
_context.SaveChanges();
}
else
{
_buyerInfo = dbBuyerInfo;
}
ListBox.ItemsSource = _context.GetSalesSupplies();
}
public bool MakeBid(string auctionId, long?offerTokens, string userId)
{
logger.InfoFormat("MakeBid: {0} ", JsonConvert.SerializeObject(new
{
auctionId,
offerTokens,
userId
}));
if (auctionId == null || offerTokens == null)
{
logger.ErrorFormat("MakeBid: something is null {0} ", JsonConvert.SerializeObject(new
{
auctionId,
offerTokens,
}));
return(false);
}
try
{
var guidId = new Guid(auctionId);
using (AuctionDB db = new AuctionDB())
{
CloseAuctions();
var auction = db.Auctions.Where(a => a.Id.Equals(guidId)).Include(a => a.Bids).SingleOrDefault();
var user = db.Users.Where(u => u.Id.Equals(userId)).SingleOrDefault();
var dv = db.DefaultValues.SingleOrDefault();
if (auction == null || user == null || dv == null || auction.Status != AuctionStatus.OPENED)
{
logger.ErrorFormat("MakeBid: something is null or auction is not open {0} ", JsonConvert.SerializeObject(new
{
auction,
user,
dv
}));
return(false);
}
var maxBid = auction.Bids.Max(b => (long?)b.NumberOfTokens);
if (maxBid == null)
{
maxBid = (long?)(Math.Ceiling(auction.CurrentPrice / dv.TokenValue));
}
else
{
// offer should be one token more than the current max bid
maxBid++;
}
// offer is too low
if (offerTokens < maxBid)
{
return(false);
}
// max offer of this user for this auction
var userMaxBid = auction.Bids.Where(b => b.User.Id.Equals(userId)).Max(b => (long?)b.NumberOfTokens);
long tokensToPay = 0;
if (userMaxBid == null)
{
// this is users first bid
tokensToPay = (long)offerTokens;
}
else
{
// this is not users first bid, should pay only the diffeerence
tokensToPay = (long)offerTokens - (long)userMaxBid;
}
if (user.NumberOfTokens < tokensToPay)
{
logger.ErrorFormat("MakeBid: user doesn't have enough tokens {0} ", JsonConvert.SerializeObject(new
{
tokensToPay,
user.UserName,
}));
// there is not enough tokens
return(false);
}
// update auction last bidder
auction.User = user;
auction.CurrentPrice = (long)offerTokens * dv.TokenValue;
//db.Entry(auction).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (System.Data.Entity.Infrastructure.DbUpdateException e)
{
// catch possible concurrency exception
logger.Error("Make Bid", e);
return(false);
}
// update user token
user.NumberOfTokens -= tokensToPay;
db.Entry(user).State = EntityState.Modified;
// create and add new bid
Bid bid = new Bid
{
Id = Guid.NewGuid(),
Auction = auction,
NumberOfTokens = (long)offerTokens,
PlacingTime = DateTime.UtcNow,
User = user
};
db.Bids.Add(bid);
db.SaveChanges();
logger.InfoFormat("MakeBid: new bid and updated auction {0} ", JsonConvert.SerializeObject(new
{
bid.Auction.Name,
bid.PlacingTime,
bid.NumberOfTokens,
bid.User.UserName,
auctionUser = auction.User.UserName,
auction.CurrentPrice
}));
return(true);
}
}
catch (Exception e)
{
logger.Error("MakeBid", e);
}
return(false);
}
public bool CreateAuction(CreateAuctionViewModel model)
{
logger.InfoFormat("CreateAuction: {0}", JsonConvert.SerializeObject(new
{
model.Currency,
model.Duration,
model.Name,
model.StartPrice
}));
try
{
// make image
var image = model.Image;
var imageBytes = new byte[image.ContentLength];
image.InputStream.Read(imageBytes, 0, imageBytes.Length);
// check if file is an image
Image.FromStream(new MemoryStream(imageBytes)).Dispose();
using (AuctionDB db = new AuctionDB())
{
//DefaultValues defaultValues = db.DefaultValues.SingleOrDefault();
//if (defaultValues == null)
//{
// logger.ErrorFormat("GetAuctionById: Default valuse {0} is null", JsonConvert.SerializeObject(new
// {
// defaultValues
// }));
// return false;
//}
Auction auction = new Auction
{
Id = Guid.NewGuid(),
Name = model.Name,
Image = imageBytes,
Duration = model.Duration,
StartPrice = model.StartPrice,
CurrentPrice = model.StartPrice,
CreatingTime = DateTime.UtcNow,
Status = AuctionStatus.READY,
Currency = model.Currency,
};
db.Auctions.Add(auction);
db.SaveChanges();
logger.InfoFormat("CreateAuction: new Auction {0}", JsonConvert.SerializeObject(new
{
auction.Id,
auction.Name,
auction.Duration,
auction.StartPrice,
auction.CreatingTime,
auction.Status,
}));
return(true);
}
}
catch (Exception e)
{
logger.Error("CreateAuction", e);
}
// something went wrong
return(false);
}