public void OrderManager_InvalidOrder_Guest_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName = GetStoreName();
// setup test
StoreContactDetails details = new StoreContactDetails(storeName, "*****@*****.**", "location", "222", "222", "bank", "cool store");
Store s = storeHandler.OpenStore(details, Owner, context);
string itemName = "testItemD";
Item item = s.AddItem(itemName, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart = new StoreCart(s.Id);
cart.AddToStoreCart(item.Id, 1);
shoppingCart.Add(s.Id, cart);
Order order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(GetGuestId(), shoppingCart, context));
Assert.IsNotNull(order);
order.Status = OrderStatus.DELIVERED;
orderManager.LogOrder(order.userKey, order.OrderId, context);
Assert.AreEqual(orderManager.GetStoreOrdersHistory(s.Id, context).Count, 1);
}
static void Main(string[] args)
{
//bronze card
ICart bronzeShopCart = new StoreCart();
IItem remote = new Item("LG", 150);
CardHolder cardHolderBronze = new CardHolder("Anthony", "Hopkins");
bronzeShopCart.AddItem(remote);
IDiscountCard bronzeCard = new BronzeCard(0, cardHolderBronze);
string billBronze = CashDesk.Pay(bronzeShopCart, bronzeCard);
Console.WriteLine(billBronze + Environment.NewLine);
//silver card
ICart silverShopCart = new StoreCart();
IItem playStation = new Item("PlayStation 5", 850);
silverShopCart.AddItem(playStation);
CardHolder cardHolderSilver = new CardHolder("Jake", "Gyllenhaal");
IDiscountCard silverCard = new SilverCard(600, cardHolderSilver);
string billSilver = CashDesk.Pay(silverShopCart, silverCard);
Console.WriteLine(billSilver + Environment.NewLine);
//gold car
ICart goldShopCart = new StoreCart();
goldShopCart.AddItem(new Item("Toy", 300));
goldShopCart.AddItem(new Item("Cooker", 700));
goldShopCart.AddItem(new Item("Pack-man", 300));
CardHolder cardHolderGold = new CardHolder("Christian", "Bale");
IDiscountCard goldenCard = new GoldCard(1300, cardHolderGold);
string billGold = CashDesk.Pay(goldShopCart, goldenCard);
Console.WriteLine(billGold + Environment.NewLine);
Console.ReadLine();
}
private void CheckInventory(StoreCart storeCart, MarketDbContext context)
{
Guid storeID = storeCart.StoreID;
IStoreInventoryManager store = StoreHandler.GetStoreInventoryManager(storeID, context);
store.IsOrderItemsAmountAvailable(storeCart.Items, context);
}
public void OrderManager_ValidOrder_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName = GetStoreName();
// setup test
StoreContactDetails details = new StoreContactDetails(storeName, "*****@*****.**", "location", "222", "222", "bank", "cool store");
storeHandler.OpenStore(details, Owner, context);
Store s = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName, StringComparison.InvariantCultureIgnoreCase)).First();
string itemName = "testItemD";
Item item = s.AddItem(itemName, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart = new StoreCart(s.Id);
cart.AddToStoreCart(item.Id, 1);
shoppingCart.Add(s.Id, cart);
// test
Order order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(Buyer1, shoppingCart, context));
Assert.IsNotNull(order);
order.Status = OrderStatus.DELIVERED;
Assert.DoesNotThrow(() => orderManager.LogOrder(order.UserId, order.OrderId, context));
}
public void OrderManager_Delivery_Guest_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName = GetStoreName();
// setup test
StoreContactDetails details = new StoreContactDetails(storeName, "*****@*****.**", "location", "222", "222", "bank", "cool store");
storeHandler.OpenStore(details, Owner, context);
Store s = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName, StringComparison.InvariantCultureIgnoreCase)).First();
string itemName = "testItemD";
Item item = s.AddItem(itemName, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart = new StoreCart(s.Id);
cart.AddToStoreCart(item.Id, 1);
shoppingCart.Add(s.Id, cart);
DeliveryReal realDelivery = new DeliveryReal(new HttpClient());
orderManager.Delivery.Real = realDelivery;
Order order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(GetGuestId(), shoppingCart, context));
Assert.IsNotNull(order);
order.Status = OrderStatus.PAYED_FOR;
Assert.DoesNotThrow(() => orderManager.ScheduleDelivery(order.userKey, order.OrderId, "address", "city", "country", "22222", "name", context));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("DefaultConnection")));
//services.AddDefaultIdentity<IdentityUser>(options =>
services.AddDefaultIdentity <ApplicationUser>(options =>
{
options.Password.RequiredLength = 8;
})
.AddDefaultUI(UIFramework.Bootstrap4)
.AddEntityFrameworkStores <ApplicationDbContext>();
services.AddTransient <IBook, BookRepository>();
services.AddTransient <IOrderRepository, OrderRepository>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped(sp => StoreCart.GetCart(sp));
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddSession();
}
public void OrderManager_Payment_Guest_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName = GetStoreName();
// setup test
StoreContactDetails details = new StoreContactDetails(storeName, "*****@*****.**", "location", "222", "222", "bank", "cool store");
storeHandler.OpenStore(details, Owner, context);
Store s = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName, StringComparison.InvariantCultureIgnoreCase)).First();
string itemName = "testItemD";
Item item = s.AddItem(itemName, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context, keyWords: new HashSet <string>()
{
"test"
});
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart = new StoreCart(s.Id);
cart.AddToStoreCart(item.Id, 1);
shoppingCart.Add(s.Id, cart);
PaymentReal realPayment = new PaymentReal(new System.Net.Http.HttpClient());
orderManager.Payment.Real = realPayment;
Order order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(GetGuestId(), shoppingCart, context));
Assert.IsNotNull(order);
Assert.DoesNotThrow(() => orderManager.CollectPayment(order.userKey, order.OrderId, "1111222233334444", "12/2021", "111", "name", "222333231", context));
}
public JsonResult ChangeQuantity(int Id, int Quantity, int?CartId)
{
int adminId = AuthorityHelper.OperatorId ?? 0;
OperationResult oper = new OperationResult(OperationResultType.Error, "更新失败");
var query = _storeCartContract.StoreCarts.Where(x => x.IsDeleted == false && x.IsEnabled == true && x.IsOrder == false);
StoreCart storeCart = null;
if (CartId.HasValue)
{
storeCart = query.FirstOrDefault(f => f.Id == CartId);
}
else
{
storeCart = query.FirstOrDefault(x => x.PurchaserId == adminId);
}
if (storeCart != null)
{
StoreCartItem storeCartItem = storeCart.StoreCartItems.FirstOrDefault(x => x.IsDeleted == false && x.IsEnabled == true && x.Id == Id);
if (storeCartItem != null)
{
storeCartItem.Quantity = Quantity;
storeCartItem.UpdatedTime = DateTime.Now;
storeCartItem.OperatorId = adminId;
oper = _storeCartItemContract.Update(storeCartItem);
}
}
else
{
oper.Message = "购物车不存在";
}
return(Json(oper));
}
public StoreCartController(IAllPhones phoneRepository, IAllUsers userRepository, StoreCart storeCart, AppDBContext context)
{
_phoneRep = phoneRepository;
_storeCart = storeCart;
_userRep = userRepository;
db = context;
}
public OrdersController(IOrderRepository orderRepository, StoreCart shoppingCart, UserManager <ApplicationUser> user, ApplicationDbContext dbContext)
{
_orderRepository = orderRepository;
_shoppingCart = shoppingCart;
_userManager = user;
_context = dbContext;
}
public JsonResult OrderCartStaInfo(int?CartId)
{
float allPieceCount, AllTagPrice, allBigCount, allBigCountReal;
allPieceCount = AllTagPrice = allBigCount = allBigCountReal = 0;
try
{
StoreCart storeCart = new StoreCart();
var query = _storeCartContract.StoreCarts.Where(x => x.IsDeleted == false && x.IsEnabled == true && x.IsOrder == false);
if (CartId.HasValue)
{
storeCart = query.FirstOrDefault(f => f.Id == CartId);
}
if (storeCart.IsNotNull())
{
var items = storeCart.StoreCartItems.Where(w => w.IsEnabled && !w.IsDeleted && w.ParentId == null).SelectMany(s => s.StoreCartItems.Where(w => w.IsEnabled && !w.IsDeleted)).ToList();
allPieceCount = items.Sum(s => s.Quantity);
AllTagPrice = items.Sum(s => s.Quantity * s.Product.ProductOriginNumber.TagPrice);
allBigCountReal = items.GroupBy(g => g.ParentId).Count(); //有商品的总款数
allBigCount = storeCart.StoreCartItems.Where(w => w.IsEnabled && !w.IsDeleted && w.ParentId == null).Count(); //总款数
}
}
catch { }
var rdata = new
{
allPieceCount = allPieceCount,
AllTagPrice = AllTagPrice,
allBigCount = allBigCount,
allBigCountReal = allBigCountReal,
};
return(Json(new OperationResult(OperationResultType.Success, "", rdata), JsonRequestBehavior.AllowGet));
}
public void OrderManager_ValidOrder_TooManyItems_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName = GetStoreName();
// setup test
StoreContactDetails details = new StoreContactDetails(storeName, "*****@*****.**", "location", "222", "222", "bank", "cool store");
storeHandler.OpenStore(details, Owner, context);
Store s = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName, StringComparison.InvariantCultureIgnoreCase)).First();
string itemName = "testItemC";
Item item = s.AddItem(itemName, 1, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart = new StoreCart(s.Id);
cart.AddToStoreCart(item.Id, 3);
shoppingCart.Add(s.Id, cart);
// test
Assert.Throws <ItemAmountException>(() => orderManager.DiscountAndReserve(Buyer1, shoppingCart, context));
}
public void OrderManager_StoreHistory_TwoStores_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName1 = GetStoreName();
string storeName2 = GetStoreName();
// setup test
StoreContactDetails details1 = new StoreContactDetails(storeName1, "*****@*****.**", "location", "222", "222", "bank", "cool store");
StoreContactDetails details2 = new StoreContactDetails(storeName2, "*****@*****.**", "location", "222", "222", "bank", "very cool store");
storeHandler.OpenStore(details1, Owner, context);
storeHandler.OpenStore(details2, Owner, context);
Store store1 = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName1, StringComparison.InvariantCultureIgnoreCase)).First();
Store store2 = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName2, StringComparison.InvariantCultureIgnoreCase)).First();
string itemName1 = "testItemD";
string itemName2 = "testItemE";
Item item1 = store1.AddItem(itemName1, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Item item2 = store2.AddItem(itemName2, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart1 = new StoreCart(store1.Id);
cart1.AddToStoreCart(item1.Id, 1);
shoppingCart.Add(store1.Id, cart1);
StoreCart cart2 = new StoreCart(store2.Id);
cart2.AddToStoreCart(item2.Id, 1);
shoppingCart.Add(store2.Id, cart2);
// test
Order order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(Buyer1, shoppingCart, context));
Assert.IsNotNull(order);
order.Status = OrderStatus.DELIVERED;
Assert.DoesNotThrow(() => orderManager.LogOrder(order.UserId, order.OrderId, context));
List <StoreOrder> storeHistory1 = orderManager.GetStoreOrdersHistory(store1.Id, context);
Assert.AreEqual(1, storeHistory1.Count());
Assert.AreEqual(storeHistory1[0].OrderItemsDict[item1.Id].Name, itemName1);
Assert.AreEqual(storeHistory1[0].StoreId, store1.Id);
List <StoreOrder> storeHistory2 = orderManager.GetStoreOrdersHistory(store2.Id, context);
Assert.AreEqual(1, storeHistory2.Count());
Assert.AreEqual(storeHistory2[0].OrderItemsDict[item2.Id].Name, itemName2);
Assert.AreEqual(storeHistory2[0].StoreId, store2.Id);
}
internal override bool IsValidPurchase(StoreCart cart)
{
int totalItems = 0;
foreach (KeyValuePair <Guid, int> itemAmount in cart.Items)
{
totalItems = totalItems + itemAmount.Value;
}
return(isBetweenMinMax(totalItems));
}
internal override bool IsValidPurchase(StoreCart cart)
{
foreach (KeyValuePair <Guid, int> itemAmount in cart.Items)
{
if (ItemID.Equals(itemAmount.Key))
{
return(isBetweenMinMax(itemAmount.Value));
}
}
return(true);
}
/// <summary>
/// 初始化一键下单界面
/// </summary>
/// <returns></returns>
public ActionResult AddPurchase()
{
StoreCart storeCart = _storeCartContract.StoreCarts.Where(x => x.IsDeleted == false && x.IsEnabled == true && x.IsOrder == false)
.FirstOrDefault(x => x.PurchaserId == AuthorityHelper.OperatorId);
var allPrice = storeCart?.StoreCartItems.Where(w => w.IsEnabled && !w.IsDeleted)?.Sum(s => s.Quantity * s.Product?.ProductOriginNumber?.PurchasePrice ?? 0) ?? 0;
ViewBag.AllPrice = allPrice;
ViewBag.StoreTypes = CacheAccess.GetStoreType(_storeTypeContract, true);
return(PartialView());
}
private void updateMultiply(MyViewHolder myViewHolder, StoreCart tempMap)
{
float items = tempMap.Quantity;
myViewHolder.txtQuan.Text = "" + int.Parse(items.ToString());
myViewHolder.pPrice.Text = "" + myViewHolder.price * items;
var totalAmount = (from data in list select data).Sum(x => x.SelRate * x.Quantity);
CartFragment.tv_total.Text = (activity.Resources.GetString(Resource.String.currency) + " " + totalAmount);
updateintent();
}
public void OrderManager_ReviewPending_Timeout_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName1 = GetStoreName();
string storeName2 = GetStoreName();
// setup test
StoreContactDetails details1 = new StoreContactDetails(storeName1, "*****@*****.**", "location", "222", "222", "bank", "cool store");
StoreContactDetails details2 = new StoreContactDetails(storeName2, "*****@*****.**", "location", "222", "222", "bank", "very cool store");
storeHandler.OpenStore(details1, Owner, context);
storeHandler.OpenStore(details2, Owner, context);
Store store1 = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName1, StringComparison.InvariantCultureIgnoreCase)).First();
Store store2 = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName2, StringComparison.InvariantCultureIgnoreCase)).First();
string itemName1 = "testItemD";
string itemName2 = "testItemE";
Item item1 = store1.AddItem(itemName1, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Item item2 = store2.AddItem(itemName2, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart1 = new StoreCart(store1.Id);
cart1.AddToStoreCart(item1.Id, 2);
shoppingCart.Add(store1.Id, cart1);
StoreCart cart2 = new StoreCart(store2.Id);
cart2.AddToStoreCart(item2.Id, 2);
shoppingCart.Add(store2.Id, cart2);
// test
Order order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(Buyer1, shoppingCart, context));
Assert.IsNotNull(order);
Assert.Throws <ItemAmountException>(() => orderManager.DiscountAndReserve(Buyer1, shoppingCart, context));
context.SaveChanges();
context.Dispose();
Thread.Sleep(1000 * 60 * 4);// sleep max time for delete
using var context2 = new MarketDbContext(inMemoryConnection);
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(Buyer1, shoppingCart, context2));
}
public void OrderManager_ValidOrder_StoreNotFound_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart = new StoreCart(Guid.NewGuid());
cart.AddToStoreCart(Guid.NewGuid(), 1);
shoppingCart.Add(Guid.NewGuid(), cart);
// test
Assert.Throws <StoreNotFoundException>(() => orderManager.DiscountAndReserve(Buyer1, shoppingCart, context));
}
public void Setup()
{
Item1 = Guid.NewGuid();
Item3 = Guid.NewGuid();
Item2 = Guid.NewGuid();
cart1With5 = new StoreCart(MOCK_GUID_FOR_STORE);
cart1With5.AddToStoreCart(Item1, 5);
cart2With5 = new StoreCart(MOCK_GUID_FOR_STORE);
cart2With5.AddToStoreCart(Item2, 5);
multyItemsAmount10 = new StoreCart(MOCK_GUID_FOR_STORE);
multyItemsAmount10.AddToStoreCart(Item1, 2);
multyItemsAmount10.AddToStoreCart(Item2, 3);
multyItemsAmount10.AddToStoreCart(Item3, 5);
}
public void OrderManager_ValidOrder_TwoStores_TwoShoppingCarts_OneDoesntHaveEnoughItems_ShuoldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName1 = GetStoreName();
string storeName2 = GetStoreName();
// setup test
StoreContactDetails details1 = new StoreContactDetails(storeName1, "*****@*****.**", "location", "222", "222", "bank", "cool store");
StoreContactDetails details2 = new StoreContactDetails(storeName2, "*****@*****.**", "location", "222", "222", "bank", "very cool store");
storeHandler.OpenStore(details1, Owner, context);
storeHandler.OpenStore(details2, Owner, context);
Store store1 = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName1, StringComparison.InvariantCultureIgnoreCase)).First();
Store store2 = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName2, StringComparison.InvariantCultureIgnoreCase)).First();
string itemName1 = "testItemD";
string itemName2 = "testItemE";
Item item1 = store1.AddItem(itemName1, 2, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Item item2 = store2.AddItem(itemName2, 0, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Dictionary <Guid, StoreCart> shoppingCart1 = new Dictionary <Guid, StoreCart>();
StoreCart cart1 = new StoreCart(store1.Id);
cart1.AddToStoreCart(item1.Id, 1);
shoppingCart1.Add(store1.Id, cart1);
Dictionary <Guid, StoreCart> shoppingCart2 = new Dictionary <Guid, StoreCart>();
StoreCart cart2 = new StoreCart(store2.Id);
cart2.AddToStoreCart(item2.Id, 1);
shoppingCart2.Add(store2.Id, cart2);
// test
Order order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(Buyer1, shoppingCart1, context));
Assert.IsNotNull(order);
order.Status = OrderStatus.DELIVERED;
Assert.DoesNotThrow(() => orderManager.LogOrder(order.UserId, order.OrderId, context));
Assert.Throws <ItemAmountException>(() => orderManager.DiscountAndReserve(Buyer1, shoppingCart2, context));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <AppDBContent>(optins =>
optins.UseSqlServer(_confString.GetConnectionString("DefaultConnection")));
services.AddTransient <IAllBooks, BookRepository>();
services.AddTransient <IBooksCategory, CategoryRepository>();
services.AddTransient <IAllOrders, OrdersRepository>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped(sp => StoreCart.GetCart(sp));
services.AddMvc(option => option.EnableEndpointRouting = false);
services.AddMemoryCache();
services.AddSession();
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddAuthentication().AddGoogle(googleOptions =>
{
googleOptions.ClientId = Configuration["Authentication:Google:ClientId"];
googleOptions.ClientSecret = Configuration["Authentication:Google:ClientSecret"];
});
services.AddDbContext <AppDBInfo>(options => options.UseSqlServer(_configStr.GetConnectionString("DefaultConnection")));
services.AddMemoryCache();
services.AddSession();
services.AddMvc();
services.AddTransient <IProduct, ProductRepos>();
services.AddTransient <IProductCategory, CategoryRepos>();
services.AddTransient <IAllOrders, OrderRepos>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
// Several cart for different users
services.AddScoped(sc => StoreCart.storeCart(sc));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <AppDBContext>(option => option.UseSqlServer(_confsting.GetConnectionString("DefaultConnection")));
services.AddTransient <IAllPhones, PhoneRepository>();
services.AddTransient <IPhonesCategory, CategoryRepository>();
services.AddTransient <IAllUsers, UserRepository>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
;
services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
.AddCookie(options => //CookieAuthenticationOptions
{
options.LoginPath = new Microsoft.AspNetCore.Http.PathString("/Account/Login");
});
services.AddScoped(sp => StoreCart.GetCart(sp));
services.AddMvc();
services.AddMemoryCache();
services.AddSession();
}
internal override bool IsValidPurchase(StoreCart cart)
{
switch (Op)
{
case Operator.AND:
return(PolicyLeft.IsValidPurchase(cart) && PolicyRight.IsValidPurchase(cart));
case Operator.OR:
return(PolicyLeft.IsValidPurchase(cart) || PolicyRight.IsValidPurchase(cart));
case Operator.XOR:
if (PolicyLeft.IsValidPurchase(cart))
{
return(!PolicyRight.IsValidPurchase(cart));
}
else
{
return(PolicyRight.IsValidPurchase(cart));
}
default:
throw new NotSupportedException();
}
}
public override void OnBindViewHolder(RecyclerView.ViewHolder holder, int position)
{
MyViewHolder myViewHolder = holder as MyViewHolder;
StoreCart map = new StoreCart();
map = list[position];
byte[] imageByteArray = map.ItemImage != null?Base64.Decode(map.ItemImage, Base64Flags.Default) : null;
myViewHolder.prodNAme.Text = map.ItemMastId;
string items = map.Quantity.ToString();
string sprice = map.SelRate.ToString("0.##");
myViewHolder.price = float.Parse(sprice);
myViewHolder.pPrice.Text = "" + (decimal.Parse(sprice) * decimal.Parse(items)).ToString("0.##");
var totalAmount = (from data in list select data).Sum(x => x.SelRate * x.Quantity);
CartFragment.tv_total.Text = activity.Resources.GetString(Resource.String.currency) + " " + totalAmount.ToString("0.##");
myViewHolder.txtQuan.Text = items.ToString();
myViewHolder.minteger = float.Parse(items);
myViewHolder.pQuan.Text = map.Quantity.ToString();
myViewHolder.pMrp.Visibility = ViewStates.Gone;
myViewHolder.pMrp.Text = "";
myViewHolder.pMrp.PaintFlags = (myViewHolder.pMrp.PaintFlags | Android.Graphics.PaintFlags.StrikeThruText);
myViewHolder.btn_Add.Click += delegate
{
myViewHolder.btn_Add.Visibility = ViewStates.Gone;
myViewHolder.ll_addQuan.Visibility = ViewStates.Visible;
float items = map.Quantity;
float price = float.Parse(sprice);
double reward = double.Parse("0.00");
myViewHolder.pPrice.Text = "" + price * items;
updateintent();
};
myViewHolder.txt_close.Click += async delegate
{
if (list.Count > 0)
{
var itemMasterId = list[position].ID;
var deleteURI = BaseURL.DeleteCartItem + itemMasterId;
using (var client = new HttpClient())
{
StringContent content = new StringContent("");
var response = await client.PostAsync(deleteURI, content);
if (response.StatusCode == HttpStatusCode.OK)
{
Toast.MakeText(activity, "Delete successfully", ToastLength.Short);
}
}
list.RemoveAt(position);
}
var totalAmount = (from data in list select data).Sum(x => x.SelRate * x.Quantity);
CartFragment.tv_total.Text = activity.Resources.GetString(Resource.String.currency) + " " + totalAmount;
if (list.Count == 0)
{
CartFragment.noData.Visibility = ViewStates.Visible;
CartFragment.viewCart.Visibility = ViewStates.Gone;
}
CartFragment.totalItems.Text = "" + list.Count() + " Total Items:";
NotifyDataSetChanged();
updateintent();
};
myViewHolder.plus.Click += delegate
{
increaseInteger(myViewHolder);
updateMultiply(myViewHolder, map);
};
myViewHolder.minus.Click += delegate
{
decreaseInteger(myViewHolder);
updateMultiply(myViewHolder, map);
};
Glide.With(activity)
.Load(imageByteArray)
.Apply(RequestOptions.CircleCropTransform())
.Into(myViewHolder.image);
}
internal abstract bool IsValidPurchase(StoreCart cart);
public void OrderManager_UserHistory_2UsersSameStore_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
string storeName = GetStoreName();
// setup test
StoreContactDetails details = new StoreContactDetails(storeName, "*****@*****.**", "location", "222", "222", "bank", "cool store");
storeHandler.OpenStore(details, Owner, context);
Store s = storeHandler.Stores(context).Where(s => s.ContactDetails.Name.Equals(storeName, StringComparison.InvariantCultureIgnoreCase)).First();
string itemName = "testItemD";
Item item = s.AddItem(itemName, 4, new HashSet <string>()
{
"CategoryA"
}, 1.22, context);
Dictionary <Guid, StoreCart> shoppingCart = new Dictionary <Guid, StoreCart>();
StoreCart cart = new StoreCart(s.Id);
cart.AddToStoreCart(item.Id, 1);
shoppingCart.Add(s.Id, cart);
// test
Order order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(Buyer1, shoppingCart, context));
Assert.IsNotNull(order);
order.Status = OrderStatus.DELIVERED;
Assert.DoesNotThrow(() => orderManager.LogOrder(order.UserId, order.OrderId, context));
order = null;
Assert.DoesNotThrow(() => order = orderManager.DiscountAndReserve(Buyer2, shoppingCart, context));
Assert.IsNotNull(order);
order.Status = OrderStatus.DELIVERED;
Assert.DoesNotThrow(() => orderManager.LogOrder(order.UserId, order.OrderId, context));
List <Order> userHistory1 = orderManager.GetUserOrdersHistory(Buyer1, context);
Assert.AreEqual(1, userHistory1.Count());
Order orderHistory1 = userHistory1.First();
Assert.AreEqual(orderHistory1.StoreOrdersDict.Count, 1);
KeyValuePair <Guid, StoreOrder> orderedItemFromStore1 = orderHistory1.StoreOrdersDict.First();
Assert.AreEqual(orderedItemFromStore1.Value.StoreOrderItems.Count, 1);
OrderItem orderedItem1 = orderedItemFromStore1.Value.OrderItemsDict[item.Id];
Assert.AreEqual(orderedItem1.ItemId, item.Id);
List <Order> userHistory2 = orderManager.GetUserOrdersHistory(Buyer1, context);
Assert.AreEqual(1, userHistory2.Count());
Order orderHistory2 = userHistory2.First();
Assert.AreEqual(orderHistory2.StoreOrdersDict.Count, 1);
KeyValuePair <Guid, StoreOrder> orderedItemFromStore2 = orderHistory2.StoreOrdersDict.First();
Assert.AreEqual(orderedItemFromStore2.Value.StoreOrderItems.Count, 1);
OrderItem orderedItem2 = orderedItemFromStore2.Value.OrderItemsDict[item.Id];
Assert.AreEqual(orderedItem2.ItemId, item.Id);
}
public OrderController(IAllOrders allOrders, StoreCart storeCart)
{
this.allOrders = allOrders;
this.storeCart = storeCart;
}
/// <summary>
/// 获取购物车数据
/// </summary>
/// <returns></returns>
public async Task <ActionResult> OrderCartList(int?CartId)
{
GridRequest request = new GridRequest(Request);
int adminId = AuthorityHelper.OperatorId ?? 0;
Expression <Func <StoreCartItem, bool> > predicate = FilterHelper.GetExpression <StoreCartItem>(request.FilterGroup);
var data = await Task.Run(() =>
{
StoreCart storeCart = new StoreCart();
var query = _storeCartContract.StoreCarts.Where(x => x.IsDeleted == false && x.IsEnabled == true && x.IsOrder == false);
if (CartId.HasValue)
{
var mod = query.FirstOrDefault(f => f.Id == CartId);
if (mod.IsNotNull())
{
storeCart = mod;
}
}
else
{
storeCart = query.FirstOrDefault(x => x.PurchaserId == adminId);
}
int count = 0;
ICollection <StoreCartItem> listEntity = new List <StoreCartItem>();
List <string> listNum = new List <string>();
if (storeCart != null)
{
listEntity = storeCart.StoreCartItems;
}
int pageIndex = request.PageCondition.PageIndex;
int pageSize = request.PageCondition.PageSize;
List <StoreCartItem> parents = listEntity.Where(m => m.ParentId == null).AsQueryable()
.Where <StoreCartItem, int>(predicate, request.PageCondition, out count).ToList();
List <string> listNumber = parents.Select(x => x.BigProdNum).ToList();
var listBigProdNumImgs = _productOrigNumberContract.OrigNumbs.Where(x => x.IsDeleted == false && x.IsEnabled == true && listNumber.Any(k => k == x.BigProdNum) == true).Select(s => new { s.BigProdNum, s.ThumbnailPath }).ToList();
Func <IEnumerable <StoreCartItem>, List <StoreCartItem> > getSoure = null;
getSoure = (soure) =>
{
var children = soure.OrderByDescending(x => x.CreatedTime);
List <StoreCartItem> listStoreCartItem = new List <StoreCartItem>();
foreach (var child in children)
{
listStoreCartItem.Add(child);
var childList = child.StoreCartItems;
listStoreCartItem.AddRange(getSoure(childList));
}
return(listStoreCartItem);
};
var list = (from m in getSoure(parents).AsQueryable().Where(predicate)
let bigProdNumAndImg = listBigProdNumImgs.FirstOrDefault(f => f.BigProdNum == m.BigProdNum)
let bigProdNumImg = bigProdNumAndImg != null ? bigProdNumAndImg.ThumbnailPath : ""
let productImg = m.Product != null ? (m.Product.ThumbnailPath != null && m.Product.ThumbnailPath != "") ? m.Product.ThumbnailPath : bigProdNumImg : bigProdNumImg
select new
{
ParentId = m.ParentId,
Id = m.Id.ToString(),
m.BigProdNum,
ProductNumber = m.ParentId == null ? "" : m.Product.ProductNumber,
ProductName = m.Product == null ? "" : m.Product.ProductOriginNumber.ProductName,
ThumbnailPath = m.Product == null ? bigProdNumImg : productImg,
ColorIconPath = m.ParentId == null ? "" : m.Product.Color.IconPath,
SizeName = m.ParentId == null ? "" : m.Product.Size.SizeName,
Quantity = m.Quantity,
Price = m.Product == null ? "" : (m.Product.ProductOriginNumber == null ? "" : m.Product.ProductOriginNumber.TagPrice.ToString())
}).ToList();
return(new GridData <object>(list, count, request.RequestInfo));
});
return(Json(data, JsonRequestBehavior.AllowGet));
}
