private void LoadEntitiesForOrderSubmission(Order pOrder, BookStoreEntityModelContainer pContainer)
{
foreach (OrderItem item in pOrder.OrderItems)
{
item.Media.Stocks = pContainer.Media.Include("Stocks").First(p => p.Id == item.Media.Id).Stocks;
}
}
public Media GetMediaById(int pId)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
return(lContainer.Media.Include("Stocks").First(p => p.Id == pId));
}
}
private void RestoreStock(List <OrderItem> orderItems, BookStoreEntityModelContainer pContainer)
{
List <int> orderIds = orderItems.Select(o => o.Id).ToList <int>();
List <OrderStock> orderStocks = (from OrderStock1 in pContainer.OrderStocks.Include("Stock").Include("OrderItem")
where orderIds.Contains(OrderStock1.OrderItem.Id)
select OrderStock1).ToList <OrderStock>();
Console.WriteLine("================Stock Restore================");
Console.WriteLine("Order items:");
foreach (OrderStock orderStock in orderStocks)
{
Stock stock = pContainer.Stocks.SingleOrDefault(r => r.Id == orderStock.Stock.Id);
// the item was not chosen
if (stock == null)
{
continue;
}
Console.WriteLine(" " + orderStock.OrderItem.Book.Title + ": Quantity: " + orderStock.Quantity);
stock.Quantity = stock.Quantity.Value + orderStock.Quantity;
pContainer.Entry(orderStock).State = System.Data.Entity.EntityState.Deleted;
pContainer.OrderStocks.Remove(orderStock);
pContainer.Stocks.Attach(stock);
pContainer.Entry(stock).Property(x => x.Quantity).IsModified = true;
}
Console.WriteLine("Time: " + DateTime.Now);
Console.WriteLine("=============================================");
Console.WriteLine(" ");
}
/*
* Adds a new book Purchase into the db
*/
public void AddPurchase(Media pMedia, User pUser)
{
// Ensure duplicate rows do not exist for the same media purchase
if (CheckIfPurchaseExistsForMedia(pMedia.Id, pUser.Id))
{
return;
}
using (TransactionScope lScope = new TransactionScope())
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
Purchase Purchase = new Purchase
{
Media = pMedia,
User = pUser
};
lContainer.Users.Attach(pUser);
lContainer.Media.Attach(pMedia);
lContainer.Purchases.Add(Purchase);
lContainer.SaveChanges();
lScope.Complete();
}
}
public void NotifyTransferFailed(string pOrderNumber, string reason, string customerEmail)
{
using (var lScope = new TransactionScope())
{
/*var orderNumber = Guid.Parse(pOrderNumber);
* using (var lContainer = new BookStoreEntityModelContainer())
* {
*/
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
//NEED TO RE-ADD back the reset stock level
Order pOrder = lContainer.Orders.Find(Int32.Parse(pOrderNumber));
pOrder.ResetStockLevels();
// var order = lContainer.Orders.Include("Customer").FirstOrDefault(pOrder => pOrder.OrderNumber == orderNumber);
EmailProvider.SendMessage(new EmailMessage()
{
ToAddress = customerEmail,
// Message = "There was an error in processsing your order " + pOrderNumber + " " + reason
Message = "There was an error in processsing your order " + pOrder.OrderNumber.ToString() + " " + reason
// Message = "There was an error in processsing your order, get in contact with the BookStore team so we can help you out!"
});
lScope.Complete();
}
}
}
public void addLike(int media_id, int userid)
{
using (TransactionScope lScope = new TransactionScope())
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
var h = from history in lContainer.PurchasedHistories
where history.Media.Id == media_id && history.User.Id == userid
select history;
var m = lContainer.Media.Include("Stocks").First(p => p.Id == media_id);
var val = h.First();
if (val.Rating == false)
{
m.Like += 1;
val.Rating = true;
}
else
{
if (val.RateValue == 0)
{
m.Like += 1;
m.Dislike -= 1;
}
}
val.RateValue = 1;
val.RateDate = DateTime.Now;
lContainer.SaveChanges();
lScope.Complete();
}
}
public void FundsTransferError(Guid pOrderGuid)
{
using (TransactionScope lScope = new TransactionScope())
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
try
{
Console.WriteLine("Funds Transfer Error");
var pOrder = lContainer.Orders
.Include("Customer").FirstOrDefault(x => x.OrderNumber == pOrderGuid);
EmailProvider.SendMessage(new EmailMessage()
{
ToAddress = pOrder.Customer.Email,
Message = "You have insufficient funds in your bank account. Your order " + pOrderGuid + " has been cancelled."
});
lContainer.SaveChanges();
lScope.Complete();
}
catch (Exception lException)
{
Console.WriteLine("Error in FundsTransferError: " + lException.Message);
throw;
}
}
}
}
public void SubmitOrder(Order pOrder)
{
using (TransactionScope lScope = new TransactionScope())
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
try
{
LoadWarehouseStocks(pOrder);
FindWarehouse(pOrder);
pOrder.Warehouse = lContainer.Warehouses.Where(warehouse => warehouse.Id == pOrder.Warehouse_Id).First().Name;
pOrder.Store = "OnLine";
pOrder.OrderNumber = Guid.NewGuid();
foreach (OrderItem orderItem in pOrder.OrderItems)
{
lContainer.OrderItems.Add(orderItem);
}
lContainer.Orders.Add(pOrder);
Console.WriteLine("Order Received: " + pOrder.OrderNumber);
TransferFundsFromCustomer(UserProvider.ReadUserById(pOrder.Customer.Id).BankAccountNumber, (double)pOrder.Total, pOrder.OrderNumber, pOrder.Customer.Id);
Console.WriteLine("Funds Transfer Requested by Customer:" + pOrder.Customer.Id);
lContainer.SaveChanges();
lScope.Complete();
}
catch (Exception lException)
{
SendOrderErrorMessage(pOrder, lException);
throw;
}
}
}
}
private Order RetrieveDeliveryOrder(Guid pDeliveryId)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
Delivery lDelivery = lContainer.Deliveries.Include("Order.Customer").Where((pDel) => pDel.ExternalDeliveryIdentifier == pDeliveryId).FirstOrDefault();
// Order was cancelled
if (lDelivery == null)
{
Console.WriteLine("============Retrieve Deliver Order============");
Console.WriteLine("Order Number: " + pDeliveryId);
Console.WriteLine("Status: FAILED");
Console.WriteLine("Time: " + DateTime.Now);
Console.WriteLine("==============================================");
Console.WriteLine(" ");
return(null);
}
Console.WriteLine("============Retrieve Deliver Order============");
Console.WriteLine("Order Number: " + pDeliveryId);
Console.WriteLine("Status: SUCCESS");
Console.WriteLine("Time: " + DateTime.Now);
Console.WriteLine("==============================================");
Console.WriteLine(" ");
return(lDelivery.Order);
}
}
public int GetTotalBooks()
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
return(lContainer.Books.Count <Book>());
}
}
/*
* Checks if a logged in user has purchased a media
*/
public bool CheckIfPurchaseExistsForMedia(int pMediaId, int pUserId)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
return(lContainer.Purchases.Include("User").Include("Media").SingleOrDefault(p => p.Media.Id == pMediaId && p.User.Id == pUserId) != null);
}
}
private static void CreateUser()
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
if (lContainer.Users.Where((pUser) => pUser.Name == "Customer").Count() > 0)
{
return;
}
}
User lCustomer = new User()
{
Name = "Customer",
LoginCredential = new LoginCredential()
{
UserName = "******", Password = "******"
},
Email = "*****@*****.**",
Address = "1 Central Park",
BankAccountNumber = 456,
};
ServiceLocator.Current.GetInstance <IUserProvider>().CreateUser(lCustomer);
}
private static void CreateOperator()
{
Role lOperatorRole = new Role()
{
Name = "Operator"
};
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
if (lContainer.Roles.Count() > 0)
{
return;
}
}
User lOperator = new User()
{
Name = "Operator",
LoginCredential = new LoginCredential()
{
UserName = "******", Password = "******"
},
Email = "*****@*****.**",
Address = "1 Central Park"
};
lOperator.Roles.Add(lOperatorRole);
ServiceLocator.Current.GetInstance <IUserProvider>().CreateUser(lOperator);
}
public void CancelOrder(int UserOrderID)
{
using (TransactionScope lScope = new TransactionScope())
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
Order UserOrder = lContainer.Orders.Find(UserOrderID);
//re-add the stock quantities from the order back to the stock
UserOrder.ResetStockLevels();
//make use of the message queues here
try
{
//give the customer their money back
TransferFundsToCustomer(UserProvider.ReadUserById(UserOrder.Customer.Id).BankAccountNumber, UserOrder.Total ?? 0.0, (UserOrder.Id).ToString(), UserOrder.Customer.Email);
}
catch (EndpointNotFoundException)
{
Debug.WriteLine("Bank process not found please switch on for a full refund.");
}
//soft delete order from order table
UserOrder.Deleted = true;
//save changes
lContainer.SaveChanges();
lScope.Complete();
}
}
}
public void DeliverySubmitted(Guid pOrderGuid, Guid pDeliveryGuid)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
Console.WriteLine("Delivery for order: " + pOrderGuid + "has been submitted for delivery. Delivery id: " + pDeliveryGuid);
var pOrder = lContainer.Orders.Include("Customer").First(x => x.OrderNumber == pOrderGuid);
Delivery lDelivery = new Delivery()
{
DeliveryStatus = DeliveryStatus.Submitted,
SourceAddress = "Book Store Address",
DestinationAddress = pOrder.Customer.Address,
Order = pOrder,
ExternalDeliveryIdentifier = pDeliveryGuid
};
pOrder.Delivery = lDelivery;
lContainer.Deliveries.Add(lDelivery);
//update stocks
foreach (OrderItem lOrderItem in pOrder.OrderItems)
{
int book_id = lContainer.WBooks.Where(books => books.Title == lOrderItem.Book.Title).First().Id;
WStock lWStock = lContainer.WStocks.Where(stock => stock.Warehouse_id == pOrder.Warehouse_Id).Where(Stock => Stock.WBook_id == book_id).First();
lWStock.quantity -= lOrderItem.Quantity;
}
lContainer.SaveChanges();
SendOrderPlacedConfirmation(pOrder);
}
}
public List <Media> getRecommendationList(int media_id, int user_id)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
var usersWithTheSameRate = from history in lContainer.PurchasedHistories
where history.Media.Id == media_id && history.User.Id != user_id && history.RateValue == 1
select history.User.Id;
List <Media> result = new List <Media>();
foreach (int userid in usersWithTheSameRate.ToList())
{
var h = from history in lContainer.PurchasedHistories
where history.Media.Id != media_id && history.User.Id == userid && history.RateValue == 1
orderby history.RateDate descending
select history.Media.Id;
foreach (int t in h.ToList())
{
var m = lContainer.Media.Include("Stocks").First(p => p.Id == t);
result.Add(m);
}
}
lContainer.SaveChanges();
return(result);
}
}
public User ReadUserById(int pUserId)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
User lCustomer = lContainer.Users.Include("LoginCredential").Where((pUser) => pUser.Id == pUserId).FirstOrDefault();
return(lCustomer);
}
}
public List <Role> GetRolesForUserName(string pUserName)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
var lUser = lContainer.Users.Include("Roles").FirstOrDefault((pUser) => pUser.LoginCredential.UserName == pUserName);
return(lUser.Roles.ToList());
}
}
private Order RetrieveDeliveryOrder(Guid pDeliveryId)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
Delivery lDelivery = lContainer.Deliveries.Include("Order.Customer").Where((pDel) => pDel.ExternalDeliveryIdentifier == pDeliveryId).FirstOrDefault();
return(lDelivery.Order);
}
}
public List <Entities.Book> GetBook(int pOffset, int pCount)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
return((from Book in lContainer.Books
orderby Book.Id
select Book).Skip(pOffset).Take(pCount).ToList());
}
}
public List <Entities.Book> GetBook(int pOffset, int pCount)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
return((from Book in lContainer.Books.Include(Common.ReflectionUtil.GetPropertyName(() => new Book().Stock))
orderby Book.Id
select Book).Skip(pOffset).Take(pCount).ToList());
}
}
public void DeleteUser(User pUser)
{
using (TransactionScope lScope = new TransactionScope())
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
lContainer.Users.Remove(pUser);
lContainer.SaveChanges();
}
}
public List <Entities.Media> GetMediaItems(int pOffset, int pCount)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
return((from MediaItem in lContainer.Media.Include("Stocks")
orderby MediaItem.Id
select MediaItem).Skip(pOffset).Take(pCount).ToList());
}
}
private void AttachEntitiesToContext(BookStoreEntityModelContainer pContainer, Order pOrder)
{
pContainer.Users.Attach(pOrder.Customer);
pOrder.OrderItems.ToList().ForEach(p => pContainer.Media.Attach(p.Media));
pContainer.Orders.Add(pOrder);
//load stock entities so that we'll be able to update their details
LoadEntitiesForOrderSubmission(pOrder, pContainer);
}
public Book GetBookById(int pId)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
return((from Book in lContainer.Books.Include(Common.ReflectionUtil.GetPropertyName(() => new Book().Stock))
where Book.Id == pId
select Book).FirstOrDefault());
}
}
public void UpdateUser(User pUser)
{
using (TransactionScope lScope = new TransactionScope())
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
lContainer.Entry(pUser).State = EntityState.Modified;
lContainer.SaveChanges();
lScope.Complete();
}
}
//private void MarkAppropriateUnchangedAssociations(Order pOrder)
//{
// pOrder.Customer.MarkAsUnchanged();
// pOrder.Customer.LoginCredential.MarkAsUnchanged();
// foreach (OrderItem lOrder in pOrder.OrderItems)
// {
// lOrder.Book.Stock.MarkAsUnchanged();
// lOrder.Book.MarkAsUnchanged();
// }
//}
private void LoadBookStocks(Order pOrder)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
foreach (OrderItem lOrderItem in pOrder.OrderItems)
{
lOrderItem.Book.Stock = lContainer.Stocks.Where((pStock) => pStock.Book.Id == lOrderItem.Book.Id).FirstOrDefault();
}
}
}
public void UpdateUser(User pUser)
{
using (TransactionScope lScope = new TransactionScope())
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
lContainer.Users.Add(pUser);
lContainer.SaveChanges();
lScope.Complete();
}
}
public bool ValidateUserCredentials(string username, string password)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
var lCredentials = from lCredential in lContainer.LoginCredentials
where lCredential.UserName == username && lCredential.EncryptedPassword == password
select lCredential;
return(lCredentials.Count() > 0);
}
}
public bool ValidateUserCredentials(string username, string password)
{
using (BookStoreEntityModelContainer lContainer = new BookStoreEntityModelContainer())
{
string lHashedPassword = Common.Cryptography.sha512encrypt(password);
var lCredentials = from lCredential in lContainer.LoginCredentials
where lCredential.UserName == username && lCredential.EncryptedPassword == lHashedPassword
select lCredential;
return(lCredentials.Count() > 0);
}
}
