protected override void OnAppearing()
        {
            //if (PropertyController.BasketFlag)
            //{
            //    PropertyController.BasketFlag = false;
            //    Navigation.PushAsync(new BasketPage());
            //}
            //else
            //{
            //    PropertyController.BasketFlag = true;
            //}

            BasketViewModel viewModel = BindingContext as BasketViewModel;

            viewModel.Refresh();
            int totalPrice = SetTotalPrice();

            if (totalPrice == 0)
            {
                btn_Proceed.IsEnabled = false;
            }
            else
            {
                btn_Proceed.IsEnabled = true;
            }
        }
Esempio n. 2
0
        public MainWindow()
        {
            InitializeComponent();

            // Использование сервиса. Pаботает с IIS
            DataContext = new BasketViewModel(new WcfDataContext());

            // Использование сервиса. Работает с отдельным хостом
            //DataContext = new BasketViewModel(new WcfSelfHostDataContext());

            /*
             * Для прямого подключения приложения к БД.
             *
             * string dbPathName = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
             * string dbFileName = "database.sqlite";
             * string databasePath = Path.Combine(dbPathName, dbFileName);
             *
             * //Реализация с использованием Sqlite-net-pcl
             * DataManager dataManager = new DataManager(new ProductRepositoryBySqliteNet(databasePath), new PurchaseRepositoryBySqliteNet(databasePath));
             * DataContext = new BasketViewModel(new DbDataContext(dataManager));*/

            //Реализация с использованием System.Data.SQLite

            /*SQLiteDatabase sqliteDatabase = new SQLiteDatabase(dbPathName, dbFileName);
             * IProductRepository productRepository = new ProductRepository(sqliteDatabase);
             * IPurchaseRepository purchaseRepository = new PurchaseRepository(sqliteDatabase);
             * this.dataManager = new DataManager(productRepository, purchaseRepository);
             * DataContext = new BasketViewModel(new DbDataContext(dataManager));*/
        }
        public void AnonymousNoCashpoolHaveBetsNotAlwaysActiveInBasket()
        {
            var     stationRepository = new StationRepository();
            decimal reserved;
            decimal factor;

            WsdlRepository.Setup(x => x.GetBalance(It.IsAny <uid>(), out reserved, out factor)).Returns(10m);
            StationSettings StationSettings = new StationSettings();

            IoCContainer.Kernel.Rebind <IStationSettings>().ToConstant(StationSettings).InSingletonScope();

            TicketHandler.Setup(x => x.TicketsInBasket).Returns(new SyncObservableCollection <Ticket>());
            TicketHandler.Object.TicketsInBasket.Add(new Ticket());
            TicketHandler.Object.TicketsInBasket[0].MaxBet = 500;
            ChangeTracker.Setup(x => x.CurrentUser).Returns(new LoggedInUser(1, "1", 10, 10, 10, 10));
            ChangeTracker.Setup(x => x.IsBasketOpen).Returns(true);
            Repository.Setup(x => x.GetAllStationAppConfigs()).Returns(new List <StationAppConfigSr>()
            {
                new StationAppConfigSr("CashAcceptorAlwayActive", 0),
                new StationAppConfigSr("AllowAnonymousBetting", 1),
            });
            var basket = new BasketViewModel();

            StationSettings.PrefFileName = "PrefFile.txt";
            StationSettings.Init();
            StationSettings.GetCashInManagerInstance();

            stationRepository.SetCashInDefaultState(10);
            System.Threading.Thread.Sleep(500);
            Assert.AreEqual(StationSettings.IsCashInEnabled, true);
        }
Esempio n. 4
0
        // GET: Basket
        public ActionResult Index(string id)
        {
            List <BasketEntry> basketEntries = db.BasketEntries.Where(x => x.UserID == id).ToList();
            Dictionary <ProductViewModel, int> productList = new Dictionary <ProductViewModel, int>();

            int sum = 0;

            foreach (BasketEntry entry in basketEntries)
            {
                Product product = db.Products.FirstOrDefault(x => x.ID.ToString() == entry.ProductID);
                sum += (int)product.Price * entry.Quantity;
                ProductViewModel pvm = CustomerProductMappers.ProductToViewModel(product);
                productList.Add(pvm, entry.Quantity);
            }

            BasketViewModel basketViewModel = new BasketViewModel()
            {
                ProductsInBasket = productList,
                Sum = sum
            };

            basketViewModel.UserId = id;



            return(View(basketViewModel));
        }
Esempio n. 5
0
        public BasketPage()
        {
            InitializeComponent();

            _basketViewModel = new BasketViewModel();
            BindingContext   = _basketViewModel;
        }
Esempio n. 6
0
        public ActionResult Save(BasketViewModel model)
        {
            Basket prodInBasket = ConvertToProductListModel(model);

            _basketService.SaveProductListInBox(prodInBasket);
            return(View("Index"));
        }
Esempio n. 7
0
        public ActionResult UpdateBasket(BasketViewModel model)
        {
            if (ModelState.IsValid)
            {
                // The only thing that can be updated in this basket is the quantity
                foreach (var item in model.Items)
                {
                    Console.WriteLine("model: key=" + item.Key + ", " + "new quantity=" + item.Quantity);

                    if (Basket.Items.First(x => x.Key == item.Key).Quantity != item.Quantity)
                    {
                        Basket.UpdateQuantity(item.Key, item.Quantity);
                    }
                }

                // * Tidbit - Everytime "Save()" is called on the Basket, a new VersionKey (Guid) is generated.
                // *** This is used to validate the SalePreparationBase (BasketCheckoutPrepartion in this case),
                // *** asserting that any previously saved information (rate quotes, shipments ...) correspond to the Basket version.
                // *** If the versions do not match, the  the checkout workflow is essentially reset - meaning
                // *** you have to start the checkout process all over
                Basket.Save();
            }

            return(RedirectToUmbracoPage(BasketContentId));
        }
Esempio n. 8
0
        public async Task <IActionResult> Index()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                throw new ArgumentNullException(nameof(user));
            }

            var basket = await _basketService.Get(user.Name);

            if (basket == null)
            {
                throw new ArgumentNullException(nameof(basket));
            }

            var productCardsView = _mapper.Map <ICollection <Core.CoreModels.ProductCard>, ICollection <ProductCardViewModel> >(basket.ProductCards);

            var model = new BasketViewModel
            {
                Name         = basket.User.Name,
                UserLogin    = basket.User.UserName,
                ProductCards = productCardsView
            };

            return(View("~/Views/Basket/Index.cshtml", model));
        }
Esempio n. 9
0
        public IActionResult Create()
        {
            BasketViewModel basket = new BasketViewModel();
            HttpClient      client = new HttpClient();
            var             result = client.GetAsync("https://localhost:44309/api/basket/1").Result;

            if (result.IsSuccessStatusCode)
            {
                basket = result.Content.ReadAsAsync <BasketViewModel>().Result;
            }
            basket.items = BasketToViewModel.Convert(basket.BasketItems);

            foreach (var item in basket.items)
            {
                result = client.GetAsync("https://localhost:44309/api/product/" + item.ProductId).Result;
                if (result.IsSuccessStatusCode)
                {
                    item.product = result.Content.ReadAsAsync <ProductViewModel>().Result;
                }
            }
            CreateOrderViewModel order = new CreateOrderViewModel()
            {
                User       = basket.User,
                items      = BasketToCreateOrder.Convert(basket.items),
                TotalPrice = basket.items.Select(p => p.product.Price).Sum(),
            };

            if (order.OrderItems == null)
            {
                return(RedirectToAction("Index", "Basket", new { userId = order.User.Id }));
            }

            return(View(order));
        }
Esempio n. 10
0
        /// <summary>
        /// Creates the purchase event.
        /// </summary>
        private Purchase SetupPurchase(CheckoutDetailsViewModel checkoutDetails, BasketViewModel basketViewModel)
        {
            var shippingAddress = new AddressDetails
            {
                FirstName   = checkoutDetails.User.FirstName,
                LastName    = checkoutDetails.User.LastName,
                PhoneNumber = checkoutDetails.User.Phone,
                Street1     = checkoutDetails.ShippingAddress.Address1,
                Street2     = checkoutDetails.ShippingAddress.Address2,
                City        = checkoutDetails.ShippingAddress.City,
                State       = checkoutDetails.ShippingAddress.State,
                ZipCode     = checkoutDetails.ShippingAddress.ZipCode,
                Country     = checkoutDetails.ShippingAddress.CountryRegion
            };

            var billingAddress = new AddressDetails
            {
                FirstName   = checkoutDetails.User.FirstName,
                LastName    = checkoutDetails.User.LastName,
                PhoneNumber = checkoutDetails.User.Phone,
                Street1     = checkoutDetails.BillingAddress.Address1,
                Street2     = checkoutDetails.BillingAddress.Address2,
                City        = checkoutDetails.BillingAddress.City,
                State       = checkoutDetails.BillingAddress.State,
                ZipCode     = checkoutDetails.BillingAddress.ZipCode,
                Country     = checkoutDetails.BillingAddress.CountryRegion
            };

            var device = new DeviceContext
            {
                DeviceContextId  = _contextAccessor.GetSessionId(),
                ExternalDeviceId = Guid.NewGuid().ToString(),
                IPAddress        = _contextAccessor.HttpContext.Connection.RemoteIpAddress.ToString(),
                Provider         = DeviceContextProvider.DFPFingerPrinting.ToString()
            };
        public void Setup()
        {
            _basketViewModel = new BasketViewModel <ApprenticeshipBasketItemViewModel>()
            {
                BasketId = Guid.Parse(_basketId)
            };

            _apprenticeshipFavouritesBasketRead = new ApprenticeshipFavouritesBasketRead(_apprenticeshipFavouritesBasket);

            _mediatorMock = new Mock <IMediator>();

            _mediatorMock
            .Setup(m => m.Send(It.IsAny <AddOrRemoveFavouriteInBasketCommand>(), CancellationToken.None))
            .ReturnsAsync(new AddOrRemoveFavouriteInBasketResponse());

            _basketViewModelMapperMock = new Mock <IBasketViewModelMapper>();
            _cookieManagerMock         = new Mock <ICookieManager>();
            _cacheStorageServiceMock   = new Mock <ICacheStorageService>();
            _cacheSettingsMock         = new Mock <ICacheSettings>();
            _configMock = new Mock <IFatConfigurationSettings>();

            _addFromApprenticeshipDetailsModel = GetApprenticeshipDetailsRequestModel();
            _addFromApprenticeshipResultsModel = GetApprenticeshipResultsRequestModel();
            _addFromProviderDetailsModel       = GetProviderDetailsRequestModel();
            _addFromProviderSearchModel        = GetProviderResultsRequestModel();
            _deleteFromBasketViewModel         = GetDeleteFromBasketViewModel();

            _basketViewModelMapperMock.Setup(s => s.Map(new ApprenticeshipFavouritesBasketRead(), It.IsAny <Guid>())).Returns(new BasketViewModel <ApprenticeshipBasketItemViewModel>());
            _basketViewModelMapperMock.Setup(s => s.Map(_apprenticeshipFavouritesBasketRead, It.IsAny <Guid>())).Returns(_basketViewModel);

            _basketOrchestrator = new BasketOrchestrator(_mediatorMock.Object, _cookieManagerMock.Object, _basketViewModelMapperMock.Object, _cacheStorageServiceMock.Object, _cacheSettingsMock.Object, _configMock.Object);
        }
Esempio n. 12
0
        public IActionResult Basket(int id)
        {
            User   user   = context.Users.FirstOrDefault(u => u.Email == User.Identity.Name);
            Basket basket = context.Baskets.FirstOrDefault(p => p.UserId == user.Id);

            if (basket == null)
            {
                basket = new Basket()
                {
                    UserId = user.Id
                };
                context.Baskets.Add(basket);
            }
            BasketToPhone mod = new BasketToPhone
            {
                PhoneId  = id,
                BasketId = basket.Id
            };

            context.BasketToPhones.Add(mod);
            context.SaveChanges();
            List <BasketToPhone> list = context.BasketToPhones.Where(b => b.BasketId == basket.Id).Include(p => p.Phone).ToList();

            BasketViewModel model = new BasketViewModel {
                User = user, BasketToPhones = list
            };

            return(View(model));
        }
Esempio n. 13
0
        public async Task <IActionResult> OnGet()
        {
            Basket = await _basketService.GetBasket(_settings.Value.UserId);

            var inventoryList = new List <InventoryModel>();

            foreach (var item in Basket.Items)
            {
                var inventory = _inventoryRepository.GetInventoryById(item.Id);
                inventory.RentalDays = item.RentalDays;

                inventoryList.Add(inventory);
            }

            if (!inventoryList.Any())
            {
                return(Page());
            }

            var result = await _invoiceService.GetInvoice(inventoryList).Result.ReadAsStreamAsync();

            _basketService.DeleteBasket(Basket.Id);

            return(File(result, "application/txt", "invoice.txt"));
        }
        /// <summary>
        /// Get the Cart of the customer. we have a dummy customer for demonstration.
        /// </summary>
        /// <returns></returns>
        private BasketViewModel GetBasket()
        {
            var b = new BasketViewModel();

            b.Basket = this.productService.GetBasket("dummyuser");
            return(b);
        }
Esempio n. 15
0
        public void CreateBasket()
        {
            // Given there are two pets available for sale
            _blackie = new Pet {
                Name = "Blackie"
            };
            _sandy = new Pet {
                Name = "Sandy"
            };
            _petRepository = new Mock <ILookAfterPets>();
            _petRepository.SetupGet(p => p.UnsoldPets).Returns(new ObservableCollection <Pet> {
                _blackie, _sandy
            });

            // Given we can respond to accessories being selected and deselected
            _accessoryRepository = new Mock <ILookAfterAccessories>();
            _accessoryRepository.Setup(ar => ar.OnAccessorySelected(It.IsAny <EventHandler <AccessoryEventArgs> >()))
            .Callback <EventHandler <AccessoryEventArgs> >(eh => _accessoriesSelected += eh);
            _accessoryRepository.Setup(ar => ar.OnAccessoryUnselected(It.IsAny <EventHandler <AccessoryEventArgs> >()))
            .Callback <EventHandler <AccessoryEventArgs> >(eh => _accessoriesUnselected += eh);

            // Given we can respond to messages
            _messenger = new Mock <IHandleMessages>();

            // Given we can publish events
            _events = new StubEventAggregator();

            // Given a basket model
            _basketModel = new BasketViewModel(_petRepository.Object, _accessoryRepository.Object, _messenger.Object, _events);

            // Given we're listening to the properties that change
            _propertiesChanged            = new List <string>();
            _basketModel.PropertyChanged += (o, e) => _propertiesChanged.Add(e.PropertyName);
        }
        private BasketViewModel BasketToViewModel(Basket basket)
        {
            var model = new BasketViewModel
            {
                BuyerId = basket.BuyerId,
                Id      = basket.Id,
                Items   = basket.Items.Select((item, index) =>
                {
                    var itemModel = new BasketItemViewModel
                    {
                        Id            = index,
                        CatalogItemId = item.CatalogItemId,
                        Quantity      = item.Quantity,
                        UnitPrice     = item.UnitPrice
                    };

                    var catalogItemTask = _session.LoadAsync <CatalogItem>("Catalog/" + item.CatalogItemId);
                    if (catalogItemTask.Status != TaskStatus.RanToCompletion)
                    {
                        throw new InvalidOperationException("Should never happen: " + catalogItemTask.Status, catalogItemTask.Exception);
                    }

                    var catalogItem        = catalogItemTask.Result;
                    itemModel.OldUnitPrice = catalogItem.Price;
                    itemModel.ProductName  = catalogItem.Name;
                    itemModel.PictureUrl   = _uriComposer.ComposePicUri(catalogItem.PictureUri);

                    return(itemModel);
                }).ToList()
            };

            return(model);
        }
        public BasketViewModel GetBasketDetails(string ownerId)
        {
            Basket basket = this.Context.Baskets
                            .FirstOrDefault(b => b.Owner.Id == ownerId);

            if (basket == null)
            {
                return(null);
            }

            var countBooks = basket.Books
                             .GroupBy(b => b.Book.Id)
                             .Select(b => new CountBookInBasketViewModel()
            {
                Count    = b.Count(),
                Book     = Mapper.Map <Book, BookDetailsViewModel>(b.First().Book),
                BookId   = b.First().Book.Id,
                NewCount = 0
            }).ToList();

            BasketViewModel viewModel = Mapper.Map <Basket, BasketViewModel>(basket);

            foreach (var countBook in countBooks)
            {
                this.CheckForCurrentPromotion(countBook);
                countBook.NewPrice = this.CheckNewPrice(countBook.Book.Price, countBook.PromotionDiscount);
            }
            viewModel.Books         = countBooks;
            viewModel.DeliveryPrice = this.CheckDeliveryPrice(basket.TotalPrice);

            return(viewModel);
        }
Esempio n. 18
0
        public async Task <BasketViewModel> GetBasket(int basketId)
        {
            var basketSpec = new BasketWithItemsSpecification(basketId);
            var basket     = _basketRepository.List(basketSpec).FirstOrDefault();

            if (basket == null)
            {
                return(await CreateBasket());
            }

            var viewModel = new BasketViewModel();

            viewModel.Id      = basket.Id;
            viewModel.BuyerId = basket.BuyerId;
            viewModel.Items   = basket.Items.Select(i =>
            {
                var itemModel = new BasketItemViewModel()
                {
                    Id            = i.Id,
                    UnitPrice     = i.UnitPrice,
                    Quantity      = i.Quantity,
                    CatalogItemId = i.CatalogItemId
                };
                var item              = _itemRepository.GetById(i.CatalogItemId);
                itemModel.PictureUrl  = _uriComposer.ComposePicUri(item.PictureUri);
                itemModel.ProductName = item.Name;
                return(itemModel);
            })
                                .ToList();
            return(viewModel);
        }
Esempio n. 19
0
        public ActionResult Details(int id)
        {
            var             prodInBox = _basketService.GetProductInBox(id);
            BasketViewModel product   = ConvertToProductViewModel(prodInBox);

            return(View(product));
        }
Esempio n. 20
0
        public BasketPage()
        {
            InitializeComponent();
            var vm = new BasketViewModel();

            this.DataContext = vm;
        }
Esempio n. 21
0
        public async Task <BasketViewModel> GetBasket(string userId)
        {
            var vm = new BasketViewModel()
            {
                BuyerId = userId,
                Items   = new List <BasketItemViewModel>(),
            };

            //sepet yoksa boş bir listeli sepet döndür.
            if (!await _basketService.BasketExistsAsync(userId))
            {
                return(vm);
            }

            var basket = await _basketRepository.FirstOrDefaultAsync(new BasketWithItemsSpecification(userId));

            var productIds     = basket.Items.Select(x => x.ProductId).ToArray();
            var basketProducts = await _productRepository.ListAsync(new ProductSpecification(productIds));

            vm.Id    = basket.Id;
            vm.Items = basket.Items.Select(x =>
            {
                var product = basketProducts.First(p => p.Id == x.ProductId);
                return(new BasketItemViewModel()
                {
                    Id = x.Id,
                    ProductId = x.ProductId,
                    Quantity = x.Quantity,
                    UnitPrice = x.UnitPrice,
                    ProductName = product.Name,
                    PictureUri = product.PictureUri
                });
            }).ToList();
            return(vm);
        }
Esempio n. 22
0
        public async Task <IActionResult> Post(BasketViewModel model)
        {
            int usrId = Convert.ToInt32(User.Claims
                                        .First(p => p.Type == "userId").Value);
            BasketValidator validator = new BasketValidator();
            var             result    = validator.Validate(model);

            if (!result.IsValid)
            {
                return(BadRequest("Model is not valid"));
            }
            var product = _context.Products?.Include(p => p.ProductInfos)
                          .FirstOrDefault(p => p.Id == model.ProductId);

            if (product == null)
            {
                return(NotFound());
            }
            var basket = _mapper.Map <Basket>(model);

            //Use current user id
            basket.UserId = usrId;
            _context.Baskets.Add(basket);
            await _context.SaveChangesAsync();

            return(Ok());
        }
Esempio n. 23
0
        public ActionResult BasketPage()
        {
            var basket = basketManager.GetBasket(User.Identity.GetUserId());

            var products = productManager.GetById(basket.Products.Select(it => it.ProductId));

            var basketProductViewModelsList = products.Select(it =>
            {
                var basketProductViewModel   = Mapper.Map <BasketProductViewModel>(it);
                basketProductViewModel.Count = basket.Products.FirstOrDefault(p => p.ProductId == basketProductViewModel.Id).Count;

                return(basketProductViewModel);
            });

            var basketPrice = 0m;

            foreach (var p in basketProductViewModelsList)
            {
                basketPrice += p.Price * p.Count;
            }

            var model = new BasketViewModel()
            {
                Products   = basketProductViewModelsList.ToList(),
                TotalPrice = basketPrice
            };

            return(View(model));
        }
        private async Task <BasketViewModel> CreateBasketViewModel()
        {
            var    basketId = Request.Cookies.GetCurrentBasketId(settings);
            Basket basket   = await basketService.GetBasket(basketId);

            var basketLines = await basketService.GetLinesForBasket(basketId);

            var lineViewModels = basketLines.Select(bl => new BasketLineViewModel
            {
                LineId    = bl.BasketLineId,
                EventId   = bl.EventId,
                EventName = bl.Event.Name,
                Date      = bl.Event.Date,
                Price     = bl.Price,
                Quantity  = bl.TicketAmount
            });


            var basketViewModel = new BasketViewModel
            {
                BasketLines = lineViewModels.ToList()
            };

            basketViewModel.ShoppingCartTotal = basketViewModel.BasketLines.Sum(bl => bl.Price * bl.Quantity);

            return(basketViewModel);
        }
Esempio n. 25
0
        public ActionResult UpdateBasket(BasketViewModel viewModel)
        {
            Basket basket = Basket.GetBasket();

            basket.UpdateBasket(viewModel.BasketLines);
            return(RedirectToAction("Index"));
        }
Esempio n. 26
0
        /// <summary>
        /// Adds to basket.
        /// </summary>
        /// <param name="laptop">The laptop.</param>
        /// <returns></returns>
        public async Task <BasketViewModel> AddToBasket(BasketItem laptop)
        {
            // Add new laptop and its configuration into basket.
            var basketItems = await _laptopRepository.AddToBasket(laptop);

            // laptops in basket
            var laptops = basketItems.Select(basket => basket.LaptopId).Distinct().ToList();

            // create basket view model
            var laptopList = await _laptopRepository.GetLaptopList();

            var laptopConfigurationList = await _laptopRepository.GetConfigurationList();

            var basketViewModel = new BasketViewModel();

            laptops.ForEach(laptopId =>
            {
                var laptopConfigurations = basketItems.Where(b => b.LaptopId == laptopId)
                                           .Select(basket => basket.LaptopConfigurationId).ToList();
                basketViewModel.BasketItems.Add(new BasketItems
                {
                    Laptop = laptopList.FirstOrDefault(l => l.Id == laptopId),
                    LaptopConfigurations = laptopConfigurationList.Where(lc => laptopConfigurations.Contains(lc.Id))
                                           .ToList()
                });
            });

            return(basketViewModel);
        }
Esempio n. 27
0
        public async Task <BasketViewModel> Getbasket()
        {
            var userId = ExtensionMethod.GetUserId(_httpContextAccessor.HttpContext);

            if (userId == null)
            {
                throw new ArgumentNullException("userId invalied");
            }
            var basket = await _basketRepository.GetAsync(userId);

            var basketModel = new BasketViewModel
            {
                buyerId     = basket.BuyerId,
                BasketItems = basket.Items
                              .Select(x => new BasketItemViewModel
                {
                    BasketId     = basket.Id,
                    FoodId       = x.FoodId,
                    FoodName     = x.FoodName,
                    UnitPrice    = x.UnitPrice,
                    OldUnitPrice = x.OldUnitPrice,
                    PictureUrl   = x.PictureUrl,
                    Quantity     = x.Quantity,
                })
                              .ToList()
            };

            return(basketModel);
        }
Esempio n. 28
0
        public ActionResult MiniCart()
        {
            var model = new BasketViewModel();

            var basket = basketService.GetBaskets(new Headstone.Models.Requests.BasketRequest()
            {
                UserIds = new List <int> {
                    CurrentUser.Id
                }
            }).Result.FirstOrDefault();

            if (basket != null)
            {
                if (basket.BasketItems.Count == 0)
                {
                    return(PartialView(model));
                }                                                                 // TODO EKIN KONTROL EDERSEN SEVINIRIM
                var product = metaDataServiceClient.GetProducts(new MetaData.API.Models.Queries.Live.ProductQuery()
                {
                    ProductIds = basket.BasketItems.Select(p => p.ProductID).ToList(),
                    Envelope   = "full"
                }).Result;

                model = new BasketViewModel().From(basket);
                if (basket.BasketItems.Any())
                {
                    model.BasketItems.Where(b => b.ProductID == product.FirstOrDefault(p => p.ProductId == b.ProductID).ProductId).FirstOrDefault().ProductName = product.FirstOrDefault(p => p.ProductId == model.BasketItems.FirstOrDefault(b => b.ProductID == p.ProductId).ProductID).Name;
                    model.BasketItems.Where(b => b.ProductID == product.FirstOrDefault(p => p.ProductId == b.ProductID).ProductId).FirstOrDefault().ListPrice   = product.FirstOrDefault(p => p.ProductId == model.BasketItems.FirstOrDefault(b => b.ProductID == p.ProductId).ProductID).Properties.FirstOrDefault(k => k.Key == "ListPrice").Value;
                    model.BasketItems.Where(b => b.ProductID == product.FirstOrDefault(p => p.ProductId == b.ProductID).ProductId).FirstOrDefault().Price       = product.FirstOrDefault(p => p.ProductId == model.BasketItems.FirstOrDefault(b => b.ProductID == p.ProductId).ProductID).Properties.FirstOrDefault(k => k.Key == "Price").Value;
                }
            }

            return(PartialView(model));
        }
Esempio n. 29
0
 private async void BayNoAuthenticated(BasketViewModel model)
 {
     string       message      = model.noAutorize;
     EmailService emailservice = new EmailService(Configuration);
     await emailservice.SendEmailAsync(model.Email, "Purchase",
                                       "you bought t-shirts: " + message);
 }
Esempio n. 30
0
        public async Task <IActionResult> AddItemToBasket(BasketItemCreateViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest("Invalid model"));
            }

            BasketViewModel basket = await _basketViewModelService.GetOrCreateBasketForUserAsync(User.Identity.Name);

            var priceResult = Pounds.Create(model.PriceInPounds);

            if (priceResult.IsFailure)
            {
                return(BadRequest(priceResult.Error));
            }

            var result = await _basketService.AddItemToBasketAsync(basket.Id, model.ProductId, model.Quantity, priceResult.Value);

            if (result.IsFailure)
            {
                return(NotFound(result.Error));
            }

            BasketItemViewModel item = await _basketViewModelService.GetBasketItemForUserAsync(User.Identity.Name, result.Value);

            return(CreatedAtAction("GetItem", new { id = item.Id }, item));
        }
 public void Initialize()
 {
     var petRepository = _container.Resolve<PetRepository>();
     var basketViewModel = new BasketViewModel(petRepository);
     _regionManager.Regions["BasketRegion"].Add(new BasketPanel(basketViewModel));
 }
 public BasketPanel(BasketViewModel model)
 {
     InitializeComponent();
     DataContext = model;
 }