public async Task <Response <List <OrderDetailsDTO> > > GetPaidCustomersFullOrderDetails(string bidId, string userId)
{
BidEntity bid = await _context.Bids.Where(b => b.Id == bidId).Include(b => b.CurrentParticipancies).ThenInclude(p => p.Buyer).Include(b => b.ChosenProposal).FirstOrDefaultAsync();
if (bid == null)
{
return(new Response <List <OrderDetailsDTO> >()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = BidNotFoundFailString
});
}
List <OrderDetailsDTO> orderDetailsList = bid.CurrentParticipancies.Where(p => p.HasPaid).Select(p => new OrderDetailsDTO {
BuyerName = p.Buyer.Name,
BuyerEmail = p.Buyer.Email,
BuyerAddress = p.Buyer.Address,
BuyerPhoneNumber = p.Buyer.PhoneNumber,
BuyerPostalCode = p.Buyer.PostalCode,
NumOfOrderedUnits = p.NumOfUnits
}).ToList();
return(new Response <List <OrderDetailsDTO> >()
{
DTOObject = orderDetailsList, IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
public async Task <Response> AddBuyer(BidBuyerJoinRequest bidBuyerJoinRequest)
{
BidEntity bid = await _context.Bids.Where(b => b.Id == bidBuyerJoinRequest.BidId).Include(b => b.CurrentParticipancies).FirstOrDefaultAsync().ConfigureAwait(false);
if (bid == null)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = BidNotFoundFailString
});
}
bid.CurrentParticipancies.Add(new ParticipancyEntity {
BidId = bidBuyerJoinRequest.BidId,
BuyerId = bidBuyerJoinRequest.BuyerId,
NumOfUnits = bidBuyerJoinRequest.Items
});
bid.UnitsCounter += bidBuyerJoinRequest.Items;
try
{
_context.Bids.Update(bid);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = ex.Message
});
}
return(new Response()
{
IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
public async Task <Response> UpdateBidProposalsToRelevant(string bidId)
{
BidEntity bid_ent = await _context.Bids.Where(b => b.Id == bidId).Include(b => b.CurrentProposals).FirstOrDefaultAsync().ConfigureAwait(false);
if (bid_ent == null)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = BidNotFoundFailString
});
}
try
{
bid_ent.CurrentProposals = bid_ent.CurrentProposals.Where(proposal => proposal.MinimumUnits <= bid_ent.UnitsCounter && proposal.ProposedPrice <= bid_ent.MaxPrice).ToList();
bid_ent.PotenialSuplliersCounter = bid_ent.CurrentProposals.Count();
if (bid_ent.PotenialSuplliersCounter == 1)
{
bid_ent.ChosenProposal = bid_ent.CurrentProposals.First();
}
_context.Bids.Update(bid_ent);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
return(new Response <BidPhase>()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = ex.Message
});
}
return(new Response()
{
IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
private async Task <Response> ModifyBidPhase(string bidId, BidPhase newPhase)
{
BidEntity bid = await _context.Bids.FindAsync(bidId).ConfigureAwait(false);
if (bid == null)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = BidNotFoundFailString
});
}
bid.Phase = newPhase;
try
{
_context.Bids.Update(bid);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = ex.Message
});
}
return(new Response()
{
IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
public void InsertBid(BidEntity bid)
{
// connects to the database.
using (SqlConnection cnn = new SqlConnection(ConnectionString))
{
// create a variable with the query command
string query = "INSERT INTO Bids (Bid, ContributorUsername, SupplierUsername, TaskId, DateCreated) VALUES (@Bid, @ContributorUsername, @SupplierUsername, @TaskId, @DateCreated)";
using (SqlCommand command = new SqlCommand(query, cnn))
{
command.Parameters.AddWithValue("@Bid", bid.Bid);
command.Parameters.AddWithValue("@ContributorUsername", bid.ContributorUsername);
command.Parameters.AddWithValue("@SupplierUsername", bid.SupplierUsername);
command.Parameters.AddWithValue("@TaskId", bid.TaskId);
command.Parameters.AddWithValue("@DateCreated", bid.DateCreated);
cnn.Open();
int result = command.ExecuteNonQuery();
cnn.Close();
// Check Error
if (result < 0)
{
Console.WriteLine("Error inserting data into Database!");
}
}
}
}
public async Task <Response> GetProposalWithMaxVotes(string bidId)
{
BidEntity bid = await _context.Bids.Where(bid => bid.Id == bidId).Include(bid => bid.CurrentProposals).FirstOrDefaultAsync().ConfigureAwait(false);
if (bid == null)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = BidNotFoundFailString
});
}
SupplierProposalEntity chosenProposalEntity = bid.CurrentProposals.Where(proposal => proposal.MinimumUnits <= bid.UnitsCounter && proposal.ProposedPrice <= bid.MaxPrice).Aggregate(
(currWinner, x) => (currWinner == null || x.Votes > currWinner.Votes ? x : currWinner));
bid.ChosenProposal = chosenProposalEntity;
bid.PotenialSuplliersCounter = 1;
try
{
_context.Bids.Update(bid);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = ex.Message
});
}
return(new Response()
{
IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
public async Task <Response <BidDTO> > CreateNewBid(NewBidRequest bidRquest)
{
// create
BidEntity bidEnitity = _mapper.Map <BidEntity>(bidRquest);
bidEnitity.CreationDate = DateTime.Now;
bidEnitity.Id = Guid.NewGuid().ToString();
// add to db
if (mockedBidsSet.TryAdd(bidEnitity.Id, bidEnitity))
{
BidDTO bidDto = _mapper.Map <BidDTO>(bidEnitity);
return(new Response <BidDTO> {
IsOperationSucceeded = true,
//SuccessOrFailureMessage = bidDto.GetType().GetProperties().ToList().ForEach(entity => { })
DTOObject = bidDto,
});
}
else
{
return(new Response <BidDTO> {
IsOperationSucceeded = false,
SuccessOrFailureMessage = "failed to add to db"
});
}
}
public async Task <Response> CreateNewBid(NewBidRequest bidRequest)
{
BidEntity bidEntity = _mapper.Map <BidEntity>(bidRequest);
//TODO is this the time we want? (or global).
bidEntity.CreationDate = DateTime.Now;
bidEntity.Id = Guid.NewGuid().ToString();
bidEntity.UnitsCounter = 0;
bidEntity.PotenialSuplliersCounter = 0;
bidEntity.Product.Id = Guid.NewGuid().ToString();
bidEntity.CurrentParticipancies = new List <ParticipancyEntity>();
bidEntity.CurrentProposals = new List <SupplierProposalEntity>();
_context.Bids.Add(bidEntity);
try
{
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
//TODO log exception and return proper error message instead
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = ex.Message
});
}
BidDTO dto = _mapper.Map <BidDTO>(bidEntity);
return(new Response()
{
IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
public async Task <Response> AddSupplierProposal(SupplierProposalRequest supplierProposalRequest)
{
BidEntity bid = await _context.Bids.Where(b => b.Id == supplierProposalRequest.BidId).Include(b => b.CurrentProposals).FirstOrDefaultAsync().ConfigureAwait(false);
if (bid == null)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = BidNotFoundFailString
});
}
// TODO? validate supplier
SupplierProposalEntity new_proposal_ent = _mapper.Map <SupplierProposalEntity>(supplierProposalRequest);
bid.CurrentProposals.Add(new_proposal_ent);
bid.PotenialSuplliersCounter += 1;
try
{
_context.Bids.Update(bid);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = ex.Message
});
}
return(new Response()
{
IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
public ActionResult CreateBid(CreateBidModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var lot = lotService.GetById(model.LotId);
var user = userService.GetOneByPredicate(u => u.Name == User.Identity.Name);
if (!CheckBidPossibility(user, lot))
{
return(RedirectToAction("Details", "Lot", new { id = model.LotId }));
}
if (lot.Bids.Count > 0)
{
int max = lot.Bids.Max(e => e.Price);
if (model.Price <= max)
{
ModelState.AddModelError("Price", "Your price is less than others");
return(View(model));
}
}
var bid = new BidEntity();
if (user != null)
{
bid.ProfileId = user.ProfileId;
}
bid.LotId = model.LotId;
bid.Price = model.Price;
bid.Date = DateTime.Now;
bidService.Create(bid);
return(RedirectToAction("Details", "Lot", new { id = model.LotId }));
}
private static bool FilterByPrices(BidEntity bid, int maxPriceFilter, int minPriceFilter)
{
return
((maxPriceFilter < Int32.MaxValue) ? bid.MaxPrice < maxPriceFilter : false
||
minPriceFilter <= 0 || bid.MaxPrice > minPriceFilter);
}
public async Task <Response> DeleteBid(string bidId)
{
BidEntity bid = await _context.Bids.Where(b => b.Id == bidId).Include(b => b.CurrentParticipancies).Include(b => b.CurrentProposals).FirstOrDefaultAsync().ConfigureAwait(false);
if (bid == null)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = BidNotFoundFailString
});
}
_context.Bids.Remove(bid);
try
{
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
return(new Response()
{
IsOperationSucceeded = false, SuccessOrFailureMessage = ex.Message
});
}
return(new Response()
{
IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
public bool TryCreateBid(BidEntity bid, LotEntity lot)
{
if (lot.UserId == bid.UserId || DateTime.Now >= (lot.StartDate + new TimeSpan(lot.Duration, 0, 0, 0)))
{
return(false);
}
CreateBid(bid);
return(true);
}
public async Task <IActionResult> CreateBid([FromBody] BidEntity bid)
{
while (User.Identity.Name == null)
{
}
bid.UserIdBuyer = User.Identity.Name;
bid.Created = DateTime.Now;
_bidLogic.Add(bid);
unitOfWork.Commit();
return(Ok(bid));
}
public static DalBid ToDalBid(this BidEntity bid)
{
return(new DalBid
{
Amount = bid.Amount,
Id = bid.Id,
LotId = bid.LotId,
Placed = bid.Placed,
UserId = bid.UserId
});
}
public void AddBid(BidEntity bid)
{
try
{
_bidRepository.Create(bid.ToDalBid());
_uow.Commit();
}
catch (DalBidTooLowException)
{
throw new BllBidTooLowException();
}
}
public void DeleteBid(BidEntity entity)
{
try
{
_bidRepository.Delete(entity.ToDalBid());
_unitOfWork.Commit();
}
catch (Exception exception)
{
Log.LogError(exception);
}
}
public static BidViewModel ToBidViewModel(this BidEntity bidEntity)
{
return(new BidViewModel()
{
Id = bidEntity.Id,
UserRefId = bidEntity.UserRefId,
BidTime = bidEntity.BidTime,
BidAmount = bidEntity.BidAmount,
LotRefId = bidEntity.LotRefId,
UserLogin = bidEntity.UserLogin
});
}
public static DalBid ToDalBid(this BidEntity bidEntity)
{
DalBid newBid = new DalBid
{
Id = bidEntity.Id,
Price = bidEntity.Price,
Date = bidEntity.Date,
LotId = bidEntity.LotId,
UserId = bidEntity.UserId
};
return(newBid);
}
public static BidViewModel ToMvcBid(this BidEntity bidEntity)
{
return(new BidViewModel()
{
Id = bidEntity.Id,
Price = bidEntity.Price,
Date = bidEntity.Date,
LotId = bidEntity.LotId,
UserId = bidEntity.UserId,
LotName = bidEntity.Lot.Name,
UserName = bidEntity.User.Name
});
}
private static void PopulateBidEntity(BidEntity bidEntity)
{
//TODO is this the time we want? (or global).
bidEntity.CreationDate = DateTime.UtcNow.AddHours(2);
bidEntity.ExpirationDate = bidEntity.ExpirationDate.Date.AddHours(23).AddMinutes(59).AddSeconds(59);
bidEntity.Id = Guid.NewGuid().ToString();
bidEntity.UnitsCounter = 0;
bidEntity.PotenialSuplliersCounter = 0;
bidEntity.Product.Id = Guid.NewGuid().ToString();
bidEntity.CurrentParticipancies = new List <ParticipancyEntity>();
bidEntity.CurrentProposals = new List <SupplierProposalEntity>();
bidEntity.Phase = BidPhase.Join;
}
public static BidViewModel ToBidViewModel(this BidEntity bid)
{
return(new BidViewModel
{
Amount = bid.Amount,
Id = bid.Id,
Lot = bid.Lot.ToLotViewModel(),
LotId = bid.LotId,
Placed = bid.Placed,
User = bid.User.ToUserViewModel(),
UserId = bid.UserId
});
}
public static DalBid ToDalBid(this BidEntity bidEntity)
{
return(new DalBid()
{
Id = bidEntity.Id,
UserRefId = bidEntity.UserRefId,
LotRefId = bidEntity.LotRefId,
LotName = bidEntity.LotName,
UserLogin = bidEntity.UserLogin,
BidTime = bidEntity.BidTime,
BidAmount = bidEntity.BidAmount
});
}
private async Task <bool> isValidNewBidAsync(BidEntity bidEntity)
{
var activeBidsWithSameProduct = await _context.Bids.Include(b => b.Product).Where(b => b.Product.Id == bidEntity.Product.Id && b.Phase == BidPhase.Join).ToListAsync();
if (activeBidsWithSameProduct.Count() > 3)
{
return(false);
}
if (activeBidsWithSameProduct.Any(b => b.MaxPrice == bidEntity.MaxPrice || b.OwnerId == bidEntity.OwnerId))
{
return(false);
}
return(true);
}
public static BidViewModel ToBidViewModel(this BidEntity model)
{
if (model == null)
{
return(null);
}
return(new BidViewModel
{
Id = model.Id,
Date = model.Date,
Price = model.Price,
LotId = model.LotId,
});
}
public static DalBid ToDalBid(this BidEntity bidEntity)
{
if (bidEntity == null)
{
return(null);
}
return(new DalBid
{
Id = bidEntity.Id,
ProfileId = bidEntity.ProfileId,
Date = bidEntity.Date,
Price = bidEntity.Price,
LotId = bidEntity.LotId
});
}
private static bool FilterBuyerBids(BidEntity buyerBid, BidsTime timeFiler)
{
DateTime currentTime = DateTime.Now;
switch (timeFiler)
{
case BidsTime.Old:
return(buyerBid.ExpirationDate <= currentTime);
case BidsTime.Live:
return(buyerBid.ExpirationDate > currentTime);
default: //null
return(true);
}
}
private static bool FilterByCategories(BidEntity bid, string category, string subCategory)
{
if (category == null)
{
return(true);
}
else if (bid.Category.Equals(category) && subCategory == null)
{
return(true);
}
else if (bid.SubCategory != null)
{
return(bid.Category.Equals(category) && bid.SubCategory.Equals(subCategory));
}
return(false);
}
public async Task <Response <BidDTO> > GetBid(string bidId)
{
BidEntity bid = await _context.Bids.Where(b => b.Id == bidId).Include(b => b.Product).FirstOrDefaultAsync().ConfigureAwait(false);
if (bid == null)
{
return(new Response <BidDTO>()
{
DTOObject = null, IsOperationSucceeded = false, SuccessOrFailureMessage = BidNotFoundFailString
});
}
BidDTO bidDTO = _mapper.Map <BidDTO>(bid);
return(new Response <BidDTO>()
{
DTOObject = bidDTO, IsOperationSucceeded = true, SuccessOrFailureMessage = this.getSuccessMessage()
});
}
public ActionResult GetBidsList(BidListViewModel model)
{
LotEntity currentLot = _lotService.GetLotEntity((int)model.LotId);
string currentUserEmail = currentLot.User.Email;
decimal currentPrice = currentLot.LastPrice ?? currentLot.StartPrice;
if (currentUserEmail == User.Identity.Name)
{
ModelState.AddModelError("", "You can not add bid for your own lot");
}
else if ((model.Price <= currentPrice))
{
ModelState.AddModelError("", string.Format("Your bid must be higher than the last bet {0} byn ", currentPrice));
}
else if (ModelState.IsValid)
{
BidEntity newBid = new BidEntity {
Price = model.Price, LotId = model.LotId, UserId = _userService.GetUserByEmail(User.Identity.Name).Id, Date = DateTime.Now
};
if (_bidService.TryCreateBid(newBid, currentLot))
{
currentLot.LastPrice = newBid.Price;
_lotService.UpdateLot(currentLot);
}
if (!Request.IsAjaxRequest())
{
return(RedirectToAction("LotDetails", new { id = model.LotId }));
}
else
{
model.Bids = _bidService.GetAllBidEntitiesByLotId(model.LotId).Select(b => b.ToMvcBid()).OrderByDescending(b => b.Price);
return(PartialView(model));
}
}
if (!Request.IsAjaxRequest())
{
return(RedirectToAction("LotDetails", new { id = model.LotId }));
}
else
{
model.Bids = _bidService.GetAllBidEntitiesByLotId(model.LotId).Select(b => b.ToMvcBid()).OrderByDescending(b => b.Price);
return(PartialView(model));
}
}
