示例#1
0
        protected virtual void SetViewModelContext(
            ProductViewModel productViewModel,
            VariantViewModel selectedVariantVm,
            IEnumerable <VariantViewModel> allVariantsVm)
        {
            //TODO: Move this to final mapping step?
            productViewModel.Context["productId"] = productViewModel.ProductId;

            if (selectedVariantVm != null)
            {
                productViewModel.Context["allVariants"]        = allVariantsVm.Select(v => new { v.ListPrice, v.Id, v.Kvas, v.Sku });
                productViewModel.Context["selectedVariantId"]  = selectedVariantVm.Id;
                productViewModel.Context["displayedVariantId"] = selectedVariantVm.Id;
            }

            //Some additionnal Context Required by JS

            productViewModel.Context["CategoryId"] = productViewModel.CategoryId;
            productViewModel.Context["Sku"]        = productViewModel.Sku;
            productViewModel.Context["keyVariantAttributeItems"] = productViewModel.KeyVariantAttributeItems;
            productViewModel.Context["CreateAccountUrl"]         = productViewModel.CreateAccountUrl;

            // Transfer custom properties that might have been added
            foreach (var property in productViewModel.Bag)
            {
                productViewModel.Context[property.Key] = property.Value;
            }
        }
        public async Task <IActionResult> RegisterConfirmed(int?variantId, IList <int> sIds)
        {
            if (variantId == null || !sIds.Any())
            {
                return(BadRequest());
            }

            if (ModelState.IsValid)
            {
                var variant = (await _variantRepository.GetVariantById(variantId.Value));
                if (variant == null)
                {
                    return(NotFound());
                }
                var students = await Task.WhenAll(sIds.Select(id =>
                                                              _studentRepository.GetStudentById(id)
                                                              ));

                if (students != null)
                {
                    var studentsPostDto = students.Select(StudentViewModel.CreateStudentPostDto).ToList();
                    var registrationDto = VariantViewModel.CreateRegistrationDto(variant);
                    var registeredIds   = await WisClient.RegisterStudents(studentsPostDto, registrationDto);

                    foreach (var registeredId in registeredIds)
                    {
                        await _studentRepository.RegisterStudent(registeredId);

                        await _studentRepository.SaveChanges();
                    }
                }
            }
            return(RedirectToAction(nameof(Index)));
        }
        public List <VariantViewModel> GetSelected()
        {
            List <VariantViewModel> Listvartient = new List <VariantViewModel>();

            foreach (var items in obj.Carts)
            {
                var objVVM = new VariantViewModel();

                var id          = items.VariantId;
                var ThatVarient = obj.Variants.Find(id);

                objVVM.Image       = ThatVarient.Product.Image;
                objVVM.Name        = ThatVarient.Product.Name;
                objVVM.Description = ThatVarient.Product.Description;
                objVVM.Category    = ThatVarient.Product.Category;
                objVVM.Size        = ThatVarient.Size;
                objVVM.Color       = ThatVarient.Color;
                objVVM.Price       = ThatVarient.Price;
                objVVM.Count       = items.Count;
                objVVM.TotalPrice  = items.TotalPrice;
                objVVM.CartId      = items.CartId;

                Listvartient.Add(objVVM);
            }

            return(Listvartient);
        }
示例#4
0
        public async Task <IActionResult> Variant(int optionId)
        {
            try
            {
                if (User.Identity.IsAuthenticated)
                {
                    var user = await _userManager.GetUserAsync(User);

                    ViewBag.Name = user.Name;
                }
                var option  = _optionService.GetOption(optionId);
                var subject = _subjectService.GetSubject(option.SubjectId);
                var whoAdd  = _userService.GetUserNameById(option.UserId);
                ViewBag.Subject = subject.Name;
                var problemOptions = _optionService.GetProblemOptions(option.Id);
                var model          = new VariantViewModel
                {
                    UserName  = whoAdd,
                    SubjectId = subject.Id
                };
                foreach (var po in problemOptions)
                {
                    var problem = _problemService.GetProblem(po.ProblemId);
                    model.Problems.Add(problem);
                    model.Pictures.AddRange(_pictureService.GetPicturesByProblemId(problem.Id));
                }
                return(View(model));
            }
            catch (Exception exc)
            {
                return(base.RedirectToAction("Error", "Home", new ErrorViewModel {
                    Message = exc.Message
                }));
            }
        }
示例#5
0
        // GET: CheckOut
        public ActionResult Index()
        {
            var cartObj = db.Carts;

            List <VariantViewModel> Listvartient = new List <VariantViewModel>();

            foreach (var items in cartObj)
            {
                var objVVM = new VariantViewModel();

                var id          = items.VariantId;
                var ThatVarient = db.Variants.Find(id);

                objVVM.Image       = ThatVarient.Product.Image;
                objVVM.Name        = ThatVarient.Product.Name;
                objVVM.Description = ThatVarient.Product.Description;
                objVVM.Category    = ThatVarient.Product.Category;
                objVVM.Size        = ThatVarient.Size;
                objVVM.Color       = ThatVarient.Color;
                objVVM.Price       = ThatVarient.Price;
                objVVM.Count       = items.Count;
                objVVM.TotalPrice  = items.TotalPrice;
                objVVM.CartId      = items.CartId;

                Listvartient.Add(objVVM);
            }

            return(View(Listvartient));
        }
        /// <summary>
        /// Creates a product view model based on an Item and Rendering
        /// </summary>
        /// <param name="productItem">The product item to based the model on</param>
        /// <param name="rendering">The rendering to initialize the model with</param>
        /// <returns>A Product View Model</returns>
        protected ProductViewModel GetProductViewModel(Item productItem, Rendering rendering)
        {
            if (this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] != null)
            {
                return((ProductViewModel)this.CurrentSiteContext.Items[CurrentProductViewModelKeyName]);
            }

            var variants = new List <VariantViewModel>();

            if (productItem != null && productItem.HasChildren)
            {
                foreach (Item item in productItem.Children)
                {
                    var v = new VariantViewModel(item);
                    variants.Add(v);
                }
            }

            var productViewModel = new ProductViewModel();

            productViewModel.Initialize(rendering, variants);
            PopulateStockInformation(productViewModel);

            this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] = productViewModel;

            return((ProductViewModel)this.CurrentSiteContext.Items[CurrentProductViewModelKeyName]);
        }
示例#7
0
 /// <summary>
 /// Initializes specifications for a given variant.
 /// </summary>
 /// <param name="productId">ID of the product.</param>
 /// <param name="productImages">Available product images.</param>
 /// <param name="cultureInfo">Culture info.</param>
 /// <param name="variantViewModel">ViewModel to be impacted.</param>
 protected virtual void InitializeVariantSpecificaton(
     Overture.ServiceModel.Products.Product product,
     ProductDefinition productDefinition,
     VariantViewModel variantViewModel)
 {
     variantViewModel.Specifications = ProductSpecificationsViewService.GetProductSpecificationsViewModel(new GetProductSpecificationsParam
     {
         VariantId         = variantViewModel.Id,
         Product           = product,
         ProductDefinition = productDefinition
     });
 }
        public async Task <Data.Variant> CreateVariantAsync(VariantViewModel model)
        {
            var variant = new Data.Variant()
            {
                Value       = model.Value,
                Id          = model.Id,
                CreatedAt   = model.CreatedAt,
                IsDeleted   = false,
                VariantType = model.VariantType
            };

            return(await _variantManager.CreateVariantAsync(variant));
        }
示例#9
0
        /// <summary>
        /// Initializes image fields for a given variant.
        /// </summary>
        /// <param name="productId">ID of the product.</param>
        /// <param name="productImages">Available product images.</param>
        /// <param name="cultureInfo">Culture info.</param>
        /// <param name="variantViewModel">ViewModel to be impacted.</param>
        protected virtual void InitializeVariantImages(
            string productId,
            IEnumerable <AllProductImages> productImages,
            CultureInfo cultureInfo,
            VariantViewModel variantViewModel)
        {
            var images        = BuildImages(productId, variantViewModel.Id, variantViewModel.DisplayName, productImages, cultureInfo).ToList();
            var selectedImage = images.Find(i => i.Selected) ?? images.FirstOrDefault();

            variantViewModel.Images           = images;
            variantViewModel.SelectedImage    = selectedImage;
            variantViewModel.FallbackImageUrl = selectedImage != null ? selectedImage.FallbackImageUrl : string.Empty;
        }
示例#10
0
        public ProductViewModel GetGiftCardViewModel(Item productItem, Rendering currentRendering)
        {
            if (this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] != null)
            {
                return((ProductViewModel)this.CurrentSiteContext.Items[CurrentProductViewModelKeyName]);
            }

            var variants = new List <VariantViewModel>();

            if (productItem != null && productItem.HasChildren)
            {
                foreach (Item item in productItem.Children)
                {
                    var v = new VariantViewModel(item);
                    variants.Add(v);
                }
            }

            var productViewModel = new ProductViewModel(productItem);

            productViewModel.Initialize(currentRendering, variants);
            productViewModel.ProductName = productViewModel.DisplayName;

            if (this.CurrentSiteContext.UrlContainsCategory)
            {
                productViewModel.ParentCategoryId = CatalogUrlManager.ExtractCategoryNameFromCurrentUrl();

                var category = this.CatalogManager.GetCategory(productViewModel.ParentCategoryId);
                if (category != null)
                {
                    productViewModel.ParentCategoryName = category.DisplayName;
                }
            }

            //Special handling for gift card
            if (productViewModel.ProductId == StorefrontManager.CurrentStorefront.GiftCardProductId)
            {
                productViewModel.GiftCardAmountOptions = GetGiftCardAmountOptions(productViewModel);
            }
            else
            {
                this.CatalogManager.GetProductPrice(this.CurrentVisitorContext, productViewModel);
                productViewModel.CustomerAverageRating = this.CatalogManager.GetProductRating(productItem);
            }

            this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] = productViewModel;

            return(productViewModel);
        }
        public ActionResult Details(int?id)
        {
            if (Session["EmailId"] == null)
            {
                return(RedirectToAction("MessageDetails"));
            }


            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var     variants = new List <VariantViewModel>();
            Product product  = db.Products.Find(id);

            if (product == null)
            {
                return(HttpNotFound());
            }

            if (Session["EmailId"] != null)
            {
                foreach (var variant in product.Variants)
                {
                    var v = new VariantViewModel
                    {
                        Id           = variant.VariantId,
                        ProductId    = product.ProductId,
                        Name         = product.Name,
                        Image        = product.Image,
                        Category     = product.Category,
                        Description  = product.Description,
                        Size         = variant.Size,
                        Color        = variant.Color,
                        AvailableQty = variant.AvailableQty,
                        Price        = variant.Price,

                        Checked = false
                    };
                    variants.Add(v);
                }

                return(View(variants));
            }

            return(RedirectToAction("Login", "Account"));
        }
示例#12
0
 public ActionResult ShowVariant(Guid variantID)
 {
     try
     {
         ModelState.Clear();
         VariantDTO       variantDTO       = productBusinessContext.GetVariant(variantID);
         ProductDTO       productDTO       = productBusinessContext.GetProduct(variantDTO.Product.ID);
         VariantViewModel variantViewModel = ProductViewModelMapper.Map <VariantDTO, VariantViewModel>(variantDTO);
         ProductViewModel productViewModel = ProductViewModelMapper.Map <ProductDTO, ProductViewModel>(productDTO);
         productViewModel.variantDisplay = variantViewModel;
         return(View(productViewModel));
     }catch (Exception ex)
     {
         return(RedirectToAction("ExceptionCatch", "Static", new { exception = ex }));
     }
 }
        // GET: Variants/Create
        public async Task <IActionResult> Create(CourseViewModel courseVm, int?itemId, int?points)
        {
            if (!ModelState.IsValid || courseVm == null || itemId == null || points == null)
            {
                return(BadRequest());
            }

            var variantsDto = await WisClient.GetVariantsAsync(courseVm.WisId, itemId.Value);

            if (variantsDto == null)
            {
                return(NotFound());
            }
            var variantsVm = variantsDto.Select(v => VariantViewModel.CreateVariantVm(v, itemId.Value, points.Value, courseVm));

            return(View(variantsVm));
        }
示例#14
0
 //[HttpPost]
 public ActionResult UpdateVariant(Guid variantID)
 {
     try
     {
         Guid             VariantID        = variantID;
         ProductViewModel productViewModel = new ProductViewModel();
         VariantDTO       variantDTO       = productBusinessContext.GetVariant(VariantID);
         VariantViewModel variantViewModel = ProductProductVMMapper.Map <VariantDTO, VariantViewModel>(variantDTO);
         ProductDTO       productDTO       = productBusinessContext.GetProduct(variantDTO.Product.ID);
         productViewModel = CategoryProductVMMapper.Map <ProductDTO, ProductViewModel>(productDTO);
         productViewModel.variantDisplay = variantViewModel;
         return(View(productViewModel.variantDisplay));
     }
     catch (Exception ex)
     {
         return(RedirectToAction("DefaultExceptionCatch", "Default", new { exception = ex.Message }));
     }
 }
示例#15
0
 protected virtual void MergeSelectedVariantVmToProductVm(
     VariantViewModel selectedVariantVm,
     ProductViewModel productViewModel)
 {
     if (selectedVariantVm == null)
     {
         productViewModel.Sku = productViewModel.Sku;
     }
     else
     {
         productViewModel.SelectedVariantId = selectedVariantVm.Id;
         productViewModel.Sku              = selectedVariantVm.Sku;
         productViewModel.DisplayName      = selectedVariantVm.DisplayName;
         productViewModel.ListPrice        = selectedVariantVm.ListPrice;
         productViewModel.Images           = selectedVariantVm.Images;
         productViewModel.SelectedImage    = selectedVariantVm.SelectedImage;
         productViewModel.FallbackImageUrl = selectedVariantVm.FallbackImageUrl;
     }
 }
        // GET: Variants/Details/id
        public async Task <IActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(BadRequest());
            }

            var variant = await _variantRepository
                          .GetVariantById(id.Value);

            if (variant == null)
            {
                return(NotFound());
            }

            var variantVm = VariantViewModel.CreateVariantVm(variant);

            return(View(variantVm));
        }
示例#17
0
        /// <summary>
        /// update variant information on variant change.
        /// </summary>
        /// <param name="variantID"></param>
        /// <returns>ActionResult--> returns updated variant info</returns>

        public ActionResult UpdateVariant(string variantID)
        {
            try
            {
                ModelState.Clear();
                Guid             VariantID        = new Guid(variantID);
                VariantDTO       variantDTO       = productBusinessContext.GetVariant(VariantID);
                ProductDTO       productDTO       = productBusinessContext.GetProduct(variantDTO.Product.ID);
                VariantViewModel variantViewModel = ProductViewModelMapper.Map <VariantDTO, VariantViewModel>(variantDTO);
                ProductViewModel productViewModel = ProductViewModelMapper.Map <ProductDTO, ProductViewModel>(productDTO);
                productViewModel.variantDisplay = variantViewModel;
                return(View(productViewModel.variantDisplay));
                //return RedirectToAction("ShowVariant", new { variantID = variantDTO.ID });
            }
            catch (Exception ex)
            {
                return(RedirectToAction("ExceptionCatch", "Static", new { exception = ex.Message }));
            }
        }
        public ActionResult TestStarting(int testId, int questionId = 1)
        {
            var config = new MapperConfiguration(cfg => cfg.CreateMap <KnowledgeSystemDAL.Models.Question, StartingTestQuestionViewModel>());
            var mapper = config.CreateMapper();
            List <QuestionViewModel> questions = new List <QuestionViewModel>();

            foreach (var item in questionRepository.GetAllQuestionByTestId(testId))
            {
                QuestionViewModel questionViewModel = new QuestionViewModel();

                questionViewModel.Id     = item.Id;
                questionViewModel.Text   = item.Text;
                questionViewModel.TestID = item.TestID;

                questions.Add(questionViewModel);
            }

            List <VariantViewModel> variants = new List <VariantViewModel>();

            foreach (var item in variantRepository.GetAllByQuestionId(questionId))
            {
                VariantViewModel variant = new VariantViewModel();
                variant.Id         = item.Id;
                variant.Text       = item.Text;
                variant.IsRight    = item.IsRight;
                variant.QuestionId = item.QuestionId;

                variants.Add(variant);
            }
            variants.Count();
            var pageInfo = new QuestionPageInformation {
                TestId = testId, QuestionId = questionId, TotalPages = questionRepository.GetAllQuestionByTestId(testId).Count
            };
            var startingQuestionViewModel = new StartingTestQuestionViewModel {
                QuestionPageInformation = pageInfo, Question = questions, Variants = variants
            };


            return(View(startingQuestionViewModel));
        }
示例#19
0
        private ProductViewModel GetProductViewModel(Item productItem, Rendering rendering)
        {
            if (this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] != null)
            {
                return((ProductViewModel)this.CurrentSiteContext.Items[CurrentProductViewModelKeyName]);
            }

            var variants = new List <VariantViewModel>();

            if (productItem != null && productItem.HasChildren)
            {
                foreach (Item item in productItem.Children)
                {
                    var v = new VariantViewModel(item);
                    variants.Add(v);
                }
            }

            var productViewModel = new ProductViewModel(productItem);

            productViewModel.Initialize(rendering, variants);
            productViewModel.ProductName = productViewModel.DisplayName;

            if (this.CurrentSiteContext.UrlContainsCategory)
            {
                productViewModel.ParentCategoryId = CatalogUrlManager.ExtractCategoryNameFromCurrentUrl();
                var category = _catalogManager.GetCategory(productViewModel.ParentCategoryId);

                if (category != null)
                {
                    productViewModel.ParentCategoryName = category.DisplayName;
                }
            }

            _catalogManager.GetProductPrice(this.CurrentVisitorContext, productViewModel);
            productViewModel.CustomerAverageRating = _catalogManager.GetProductRating(productItem);
            this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] = productViewModel;

            return(productViewModel);
        }
        /// <summary>
        /// Creates a product view model based on an Item and Rendering
        /// </summary>
        /// <param name="productItem">The product item to based the model on</param>
        /// <param name="rendering">The rendering to initialize the model with</param>
        /// <returns>A Product View Model</returns>
        protected ProductViewModel GetProductViewModel(Item productItem, Rendering rendering)
        {
            if (this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] != null)
            {
                return((ProductViewModel)this.CurrentSiteContext.Items[CurrentProductViewModelKeyName]);
            }

            var variants = new List <VariantViewModel>();

            if (productItem != null && productItem.HasChildren)
            {
                foreach (Item item in productItem.Children)
                {
                    var v = new VariantViewModel(item);
                    variants.Add(v);
                }
            }

            var productViewModel = new ProductViewModel(productItem);

            productViewModel.Initialize(rendering, variants);
            //Set Discount Info
            productViewModel.Discounts = this.GetProductDiscountInfo(productItem);

            //Special handling for gift card
            if (productViewModel.ProductId == StorefrontManager.CurrentStorefront.GiftCardProductId)
            {
                productViewModel.GiftCardAmountOptions = GetGiftCardAmountOptions(productViewModel);
            }
            else
            {
                this.CatalogManager.GetProductPrice(productViewModel);
                productViewModel.CustomerAverageRating = this.CatalogManager.GetProductRating(productItem);
            }

            this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] = productViewModel;
            return(productViewModel);
        }
示例#21
0
        protected virtual void SetViewModelContext(
            ProductViewModel productViewModel,
            VariantViewModel selectedVariantVm,
            IEnumerable <VariantViewModel> allVariantsVm)
        {
            //TODO: Move this to final mapping step?
            productViewModel.Context["productId"] = productViewModel.ProductId;

            if (selectedVariantVm != null)
            {
                productViewModel.Context["allVariants"]        = allVariantsVm.Select(v => new { v.DisplayListPrice, v.Id, v.Kvas, v.Sku });
                productViewModel.Context["selectedVariantId"]  = selectedVariantVm.Id;
                productViewModel.Context["displayedVariantId"] = selectedVariantVm.Id;
            }

            //Some additionnal Context Required by JS
            productViewModel.Context["Brand"]       = productViewModel.Brand;
            productViewModel.Context["DisplayName"] = productViewModel.DisplayName;
            productViewModel.Context["CategoryId"]  = productViewModel.CategoryId;
            productViewModel.Context["Sku"]         = productViewModel.Sku;
            productViewModel.Context["keyVariantAttributeItems"] = productViewModel.KeyVariantAttributeItems;
            productViewModel.Context["CreateAccountUrl"]         = productViewModel.CreateAccountUrl;
            productViewModel.Context["Weight"]        = productViewModel.Weight;
            productViewModel.Context["WeightUOM"]     = productViewModel.WeightUOM;
            productViewModel.Context["ItemFormat"]    = productViewModel.ItemFormat;
            productViewModel.Context["SellingMethod"] = productViewModel.SellingMethod;
            productViewModel.Context["UnitOfMeasure"] = productViewModel.UnitOfMeasure;
            productViewModel.Context["IsUnit"]        = productViewModel.IsUnit;
            productViewModel.Context["IsUnitMeasure"] = productViewModel.IsUnitMeasure;
            productViewModel.Context["IsApproxUnit"]  = productViewModel.IsApproxUnit;

            // Transfer custom properties that might have been added
            foreach (var property in productViewModel.Bag)
            {
                productViewModel.Context[property.Key] = property.Value;
            }
        }
        public async Task <IActionResult> CreateConfirmed(VariantViewModel variantVm)
        {
            if (ModelState.IsValid)
            {
                if (!_variantRepository.VariantExists(variantVm.WisId))
                {
                    try
                    {
                        var variant = VariantViewModel.CreateVariant(variantVm);
                        if (variant != null)
                        {
                            await _variantRepository.InsertVariant(variant);

                            await _variantRepository.SaveChanges();

                            VariantViewModel.ActiveVariantId = variant.Id;
                        }
                    }
                    catch (DbUpdateConcurrencyException) { }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View());
        }
示例#23
0
 /// <summary>
 /// Return the initial state of the KVA selector
 /// The default implementation initialize the KVA with the selected Variant;
 /// A common override is to initialize the KVA only if the selected Variant match the requested Variant
 ///
 /// </summary>
 /// <param name="selectedVariant"></param>
 /// <param name="param"></param>
 /// <returns></returns>
 protected virtual Dictionary <string, object> GetSelectedKvas(
     VariantViewModel selectedVariant,
     CreateProductDetailViewModelParam param)
 {
     return(selectedVariant == null ? new Dictionary <string, object>() : selectedVariant.Kvas);
 }
        /// <summary>
        /// Creates a product view model based on an Item and Rendering
        /// </summary>
        /// <param name="productItem">The product item to based the model on</param>
        /// <param name="rendering">The rendering to initialize the model with</param>
        /// <returns>A Product View Model</returns>
        protected ProductViewModel GetProductViewModel(Item productItem, Rendering rendering)
        {
            if (this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] != null)
            {
                return (ProductViewModel) this.CurrentSiteContext.Items[CurrentProductViewModelKeyName];
            }

            var variants = new List<VariantViewModel>();
            if (productItem != null && productItem.HasChildren)
            {
                foreach (Item item in productItem.Children)
                {
                    var v = new VariantViewModel(item);
                    variants.Add(v);
                }
            }

            var productViewModel = new ProductViewModel();
            productViewModel.Initialize(rendering, variants);
            PopulateStockInformation(productViewModel);

            this.CurrentSiteContext.Items[CurrentProductViewModelKeyName] = productViewModel;

            return (ProductViewModel)this.CurrentSiteContext.Items[CurrentProductViewModelKeyName];
        }
        public ActionResult ShowOrders()
        {
            if (Session["EmailId"] == null)
            {
                return(RedirectToAction("MessageDetails"));
            }

            List <MyOrdersViewModel> ModelList = new List <MyOrdersViewModel>();


            foreach (Order order in db.Orders)
            {
                if (order.PersonId.Equals(Session["EmailId"].ToString()))
                {
                    MyOrdersViewModel model = new MyOrdersViewModel();
                    model.Address     = order.Address;
                    model.TotalAmount = order.TotalAmount;

                    foreach (OrderedProduct variant in db.OrderedProducts)
                    {
                        if (variant.OrderId == order.OrderId)
                        {
                            var obj = (from s in db.Variants
                                       where s.VariantId == variant.VariantId
                                       select s
                                       ).Single();

                            var count = 0;

                            foreach (var item in db.OrderedProducts)
                            {
                                if (item.VariantId == variant.VariantId && order.OrderId == variant.OrderId)
                                {
                                    count = item.Quantity;
                                }
                            }

                            var productDetail = (from s in db.Products
                                                 where s.ProductId == obj.ProductId
                                                 select s
                                                 ).Single();

                            VariantViewModel VVMObj = new VariantViewModel();
                            VVMObj.Name        = productDetail.Name;
                            VVMObj.ProductId   = productDetail.ProductId;
                            VVMObj.Description = productDetail.Description;
                            VVMObj.Category    = productDetail.Category;
                            VVMObj.Color       = obj.Color;
                            VVMObj.Size        = obj.Size;
                            VVMObj.Quantity    = count;
                            model.Variants.Add(VVMObj);
                        }
                    }


                    ModelList.Add(model);
                }
            }

            return(View(ModelList));
        }
        public virtual ProductDetailViewModel CreateDetailsViewModel()
        {
            ProductDetailViewModel productDetailViewModel = null;

            var currentProduct =
                Ucommerce.EntitiesV2.Product.FirstOrDefault(x => x.Guid == CatalogContext.CurrentProduct.Guid);

            if (currentProduct != null)
            {
                var    imageService    = ObjectFactory.Instance.Resolve <IImageService>();
                var    currentCategory = CatalogContext.CurrentCategory;
                string displayName     = string.Empty;
                if (currentProduct.ParentProduct != null)
                {
                    displayName = $"{currentProduct.ParentProduct.DisplayName()} ";
                }

                displayName += currentProduct.DisplayName();

                var productPrice = CatalogLibrary.CalculatePrices(new List <Guid>()
                {
                    currentProduct.Guid
                }).Items
                                   .FirstOrDefault();

                decimal price    = 0;
                decimal discount = 0;

                if (productPrice != null)
                {
                    price    = productPrice.PriceExclTax;
                    discount = productPrice.DiscountExclTax;
                    var currentCatalog = CatalogContext.CurrentCatalog;
                    if (currentCatalog != null && currentCatalog.ShowPricesIncludingTax)
                    {
                        price    = productPrice.PriceInclTax;
                        discount = productPrice.DiscountInclTax;
                    }
                }

                var imageUrl         = imageService.GetImage(currentProduct.PrimaryImageMediaId).Url;
                var absoluteImageUrl = UrlPath.ResolveAbsoluteUrl(imageUrl);

                var definition      = currentProduct.ProductDefinition;
                var isProductFamily = definition.IsProductFamily();

                productDetailViewModel = new ProductDetailViewModel()
                {
                    DisplayName          = displayName,
                    Guid                 = currentProduct.Guid,
                    PrimaryImageMediaUrl = absoluteImageUrl,
                    LongDescription      = currentProduct.LongDescription(),
                    ShortDescription     = currentProduct.ShortDescription(),
                    ProductUrl           = UrlService.GetUrl(CatalogContext.CurrentCatalog, CatalogContext.CurrentProduct),
                    Price                = new Money(price, CatalogContext.CurrentPriceGroup.CurrencyISOCode).ToString(),
                    Discount             = discount > 0
                                                ? new Money(discount, CatalogContext.CurrentPriceGroup.CurrencyISOCode).ToString()
                                                : "",
                    Sku               = currentProduct.Sku,
                    Rating            = Convert.ToInt32(Math.Round(currentProduct.Rating.GetValueOrDefault())),
                    VariantSku        = currentProduct.VariantSku,
                    IsVariant         = currentProduct.IsVariant,
                    IsProductFamily   = currentProduct.ProductDefinition.IsProductFamily(),
                    AllowOrdering     = currentProduct.AllowOrdering,
                    IsSellableProduct = !isProductFamily || currentProduct.Variants.Any()
                };

                if (currentProduct.ParentProduct != null)
                {
                    var parentProduct = CatalogLibrary.GetProduct(currentProduct.ParentProduct.Sku);
                    productDetailViewModel.ParentProductUrl =
                        UrlService.GetUrl(CatalogContext.CurrentCatalog, parentProduct);
                    productDetailViewModel.ParentProductDisplayName = currentProduct.ParentProduct.DisplayName();
                }

                if (currentCategory != null)
                {
                    productDetailViewModel.CategoryDisplayName = currentCategory.DisplayName;
                    productDetailViewModel.CategoryUrl         = UrlService.GetUrl(CatalogContext.CurrentCatalog,
                                                                                   CatalogContext.CurrentCategories.Append(CatalogContext.CurrentCategory).Compact(),
                                                                                   CatalogContext.CurrentProduct);
                    productDetailViewModel.ProductUrl =
                        UrlService.GetUrl(CatalogContext.CurrentCatalog, CatalogContext.CurrentProduct);
                }

                var invariantFields = currentProduct.ProductProperties;

                var localizationContext = ObjectFactory.Instance.Resolve <ILocalizationContext>();

                var fieldsForCurrentLanguage =
                    currentProduct.GetProperties(localizationContext.CurrentCultureCode).ToList();

                productDetailViewModel.ProductProperties = invariantFields.Concat(fieldsForCurrentLanguage).ToList();


                var uniqueVariants = from v in currentProduct.Variants.SelectMany(p => p.ProductProperties)
                                     where v.ProductDefinitionField.DisplayOnSite
                                     group v by v.ProductDefinitionField
                                     into g
                                     select g;

                foreach (var vt in uniqueVariants)
                {
                    var typeViewModel = productDetailViewModel.VariantTypes
                                        .Where(z => z.Id == vt.Key.ProductDefinitionFieldId)
                                        .FirstOrDefault();

                    if (typeViewModel == null)
                    {
                        typeViewModel = new VariantTypeViewModel
                        {
                            Id          = vt.Key.ProductDefinitionFieldId,
                            Name        = vt.Key.Name,
                            DisplayName = vt.Key.GetDisplayName()
                        };

                        productDetailViewModel.VariantTypes.Add(typeViewModel);
                    }

                    var variants = vt.ToList();

                    foreach (var variant in variants)
                    {
                        var variantViewModel = typeViewModel.Values
                                               .Where(v => v.Value == variant.Value)
                                               .FirstOrDefault();

                        if (variantViewModel == null)
                        {
                            variantViewModel = new VariantViewModel
                            {
                                Value    = variant.Value,
                                TypeName = typeViewModel.Name
                            };

                            if (!string.IsNullOrEmpty(variant.Product.PrimaryImageMediaId))
                            {
                                var variantImageUrl = imageService.GetImage(variant.Product.PrimaryImageMediaId).Url;
                                variantViewModel.PrimaryImageMediaUrl = UrlPath.ResolveAbsoluteUrl(variantImageUrl);
                            }

                            typeViewModel.Values.Add(variantViewModel);
                        }
                    }
                }

                productDetailViewModel.Routes.Add(RouteConstants.ADD_TO_BASKET_ROUTE_NAME,
                                                  RouteConstants.ADD_TO_BASKET_ROUTE_VALUE);
            }

            return(productDetailViewModel);
        }
示例#27
0
        public virtual ProductDetailViewModel CreateDetailsViewModel()
        {
            ProductDetailViewModel productDetailViewModel = null;

            var currentProduct = SiteContext.Current.CatalogContext.CurrentProduct;

            if (currentProduct != null)
            {
                var    imageService    = UCommerce.Infrastructure.ObjectFactory.Instance.Resolve <IImageService>();
                var    currentCategory = SiteContext.Current.CatalogContext.CurrentCategory;
                string displayName     = string.Empty;
                if (currentProduct.ParentProduct != null)
                {
                    displayName = $"{currentProduct.ParentProduct.DisplayName()} ";
                }

                displayName += currentProduct.DisplayName();

                var productPrice = CatalogLibrary.CalculatePrice(new List <Product>()
                {
                    currentProduct
                }).Items.FirstOrDefault();

                decimal price    = 0;
                decimal discount = 0;

                if (productPrice != null)
                {
                    price    = productPrice.PriceExclTax;
                    discount = productPrice.DiscountExclTax;
                    var currentCatalog = SiteContext.Current.CatalogContext.CurrentCatalog;
                    if (currentCatalog != null && currentCatalog.ShowPricesIncludingVAT)
                    {
                        price    = productPrice.PriceInclTax;
                        discount = productPrice.DiscountInclTax;
                    }
                }

                var imageUrl         = imageService.GetImage(currentProduct.PrimaryImageMediaId).Url;
                var absoluteImageUrl = UrlPath.ResolveAbsoluteUrl(imageUrl);

                productDetailViewModel = new ProductDetailViewModel()
                {
                    DisplayName          = displayName,
                    Guid                 = currentProduct.Guid,
                    PrimaryImageMediaUrl = absoluteImageUrl,
                    LongDescription      = currentProduct.LongDescription(),
                    ShortDescription     = currentProduct.ShortDescription(),
                    ProductUrl           = CatalogLibrary.GetNiceUrlForProduct(currentProduct, currentCategory),
                    Price                = new Money(price, SiteContext.Current.CatalogContext.CurrentPriceGroup.Currency).ToString(),
                    Discount             = new Money(discount, SiteContext.Current.CatalogContext.CurrentPriceGroup.Currency).ToString(),
                    Sku             = currentProduct.Sku,
                    Rating          = Convert.ToInt32(Math.Round(currentProduct.Rating.GetValueOrDefault())),
                    VariantSku      = currentProduct.VariantSku,
                    IsVariant       = currentProduct.IsVariant,
                    IsProductFamily = currentProduct.ProductDefinition.IsProductFamily(),
                    AllowOrdering   = currentProduct.AllowOrdering,
                };

                if (currentProduct.ParentProduct != null)
                {
                    productDetailViewModel.ParentProductUrl =
                        CatalogLibrary.GetNiceUrlForProduct(currentProduct.ParentProduct, currentCategory);
                    productDetailViewModel.ParentProductDisplayName = currentProduct.ParentProduct.DisplayName();
                }

                if (currentCategory != null)
                {
                    productDetailViewModel.CategoryDisplayName = currentCategory.DisplayName();
                    productDetailViewModel.CategoryUrl         = CatalogLibrary.GetNiceUrlForCategory(currentCategory);
                    productDetailViewModel.ProductUrl          = CatalogLibrary.GetNiceUrlForProduct(currentProduct, currentCategory);
                }


                foreach (var pv in currentProduct.Variants)
                {
                    foreach (var v in pv.ProductProperties)
                    {
                        if (v.ProductDefinitionField != null && v.ProductDefinitionField.IsVariantProperty)
                        {
                            if (productDetailViewModel.VariantTypes.Any(t => t.Id == v.ProductDefinitionField.Id))
                            {
                            }
                        }
                    }
                }


                var uniqueVariants = from v in currentProduct.Variants.SelectMany(p => p.ProductProperties)
                                     where v.ProductDefinitionField.DisplayOnSite
                                     group v by v.ProductDefinitionField into g
                                     select g;

                foreach (var vt in uniqueVariants)
                {
                    var typeViewModel = productDetailViewModel.VariantTypes
                                        .Where(z => z.Id == vt.Key.ProductDefinitionFieldId)
                                        .FirstOrDefault();

                    if (typeViewModel == null)
                    {
                        typeViewModel = new VariantTypeViewModel
                        {
                            Id          = vt.Key.ProductDefinitionFieldId,
                            Name        = vt.Key.Name,
                            DisplayName = vt.Key.GetDisplayName()
                        };

                        productDetailViewModel.VariantTypes.Add(typeViewModel);
                    }

                    var variants = vt.ToList();

                    foreach (var variant in variants)
                    {
                        var variantViewModel = typeViewModel.Values
                                               .Where(v => v.Value == variant.Value)
                                               .FirstOrDefault();

                        if (variantViewModel == null)
                        {
                            variantViewModel = new VariantViewModel
                            {
                                Value    = variant.Value,
                                TypeName = typeViewModel.Name
                            };

                            if (!string.IsNullOrEmpty(variant.Product.PrimaryImageMediaId))
                            {
                                var variantImageUrl = imageService.GetImage(variant.Product.PrimaryImageMediaId).Url;
                                variantViewModel.PrimaryImageMediaUrl = UrlPath.ResolveAbsoluteUrl(variantImageUrl);
                            }

                            typeViewModel.Values.Add(variantViewModel);
                        }
                    }
                }

                productDetailViewModel.Routes.Add(RouteConstants.ADD_TO_BASKET_ROUTE_NAME, RouteConstants.ADD_TO_BASKET_ROUTE_VALUE);
            }

            return(productDetailViewModel);
        }
        public async Task <ActionResult <string> > CreateStudent([FromForm] string uid)
        {
            if (uid != null)
            {
                var auth = WisClient.AuthBase64;
                if (string.IsNullOrEmpty(auth))
                {
                    return(NotFound());
                }
                Debug.WriteLine("Incoming ID: " + uid);
                var studentRfidDto = await WisClient.GetStudentByRfidUid(uid);

                int?activeVariantId = VariantViewModel.ActiveVariantId;
                if (activeVariantId == null)
                {
                    return("Variant!");
                }
                int variantId = activeVariantId.Value;
                var variant   = await _variantRepository.GetVariantById(variantId);

                var studentsDto = await WisClient.GetStudents(variant.WisCourseId);

                var studentDto = studentsDto?.Single(s => s.Login == studentRfidDto.Login);
                if (studentDto == null)
                {
                    return("Not found");
                }
                if (_studentRepository.StudentExists(studentDto.Id))
                {
                    return("Registered");
                }
                try
                {
                    var student        = StudentViewModel.CreateStudent(studentDto);
                    var studentPostDto = StudentViewModel.CreateStudentPostDto(student);
                    await _studentRepository.InsertStudent(student);

                    await _studentRepository.AddStudentToVariant(student.Id, variantId);

                    await _studentRepository.SaveChanges();

                    if (WisClient.AutoRegister)
                    {
                        var registerStudentsDto = new List <StudentPostDto> {
                            studentPostDto
                        };
                        var registrationDto = VariantViewModel.CreateRegistrationDto(variant);
                        var registeredIds   = await WisClient.RegisterStudents(registerStudentsDto, registrationDto);

                        foreach (var registeredId in registeredIds)
                        {
                            await _studentRepository.RegisterStudent(registeredId);

                            await _studentRepository.SaveChanges();
                        }
                    }
                }
                catch (DbUpdateConcurrencyException) { }

                return(studentRfidDto.Login);
            }

            return(NotFound());
        }
示例#29
0
 public void Initialize(ProductEntity product, bool initializeAsMock = false)
 {
     Assert.ArgumentNotNull((object)product, nameof(product));
     CatalogItem = product.Item;
     ProductId   = product.ProductId;
     if (!initializeAsMock)
     {
         IsBundle   = ItemTypeProvider.IsBundle(product.Item);
         IsCategory = ItemTypeProvider.GetItemType(CatalogItem) == Sitecore.Commerce.XA.Foundation.Common.Constants.ItemTypes.Category;
         SetImages();
         string str = product.Item[FieldIDs.DisplayName.ToString()];
         DisplayName       = string.IsNullOrEmpty(str) ? string.Empty : str;
         Features          = CatalogItem["Features"];
         CatalogName       = StorefrontContext.CurrentStorefront.Catalog;
         Description       = CatalogItem["Description"];
         StockStatus       = product.StockStatus;
         StockStatusName   = product.StockStatusName;
         DisplayNameRender = PageContext.Current.HtmlHelper.Sitecore().Field(FieldIDs.DisplayName.ToString(), product.Item);
         DescriptionRender = PageContext.Current.HtmlHelper.Sitecore().Field("Description", product.Item);
         SetLink();
         if (IsBundle)
         {
             List <BundledItemViewModel> bundledItemViewModelList = new List <BundledItemViewModel>();
             NameValueCollection         urlParameters            = WebUtil.ParseUrlParameters(CatalogItem[Sitecore.Commerce.XA.Foundation.Common.Constants.ItemFieldNames.BundleItems]);
             foreach (string index in urlParameters)
             {
                 BundledItemViewModel model = ModelProvider.GetModel <BundledItemViewModel>();
                 Item obj = Context.Database.GetItem(ID.Parse(index));
                 model.Initialize(obj, System.Convert.ToDecimal(urlParameters[index], CultureInfo.InvariantCulture));
                 bundledItemViewModelList.Add(model);
             }
             BundledItems = bundledItemViewModelList;
         }
     }
     else
     {
         IsCategory      = false;
         StockStatus     = product.StockStatus;
         StockStatusName = product.StockStatusName;
         Images          = new List <MediaItem>();
     }
     CurrencySymbol = CurrentStorefront.SelectedCurrency;
     AdjustedPrice  = product.AdjustedPrice;
     HighestPricedVariantAdjustedPrice = product.HighestPricedVariantAdjustedPrice;
     ListPrice = product.ListPrice;
     LowestPricedVariantAdjustedPrice = product.LowestPricedVariantAdjustedPrice;
     LowestPricedVariantListPrice     = product.LowestPricedVariantListPrice;
     CustomerAverageRating            = product.CustomerAverageRating;
     if (product.Variants != null && product.Variants.Any <VariantEntity>())
     {
         List <VariantViewModel> variantViewModelList = new List <VariantViewModel>();
         foreach (VariantEntity variant in product.Variants)
         {
             VariantViewModel model = ModelProvider.GetModel <VariantViewModel>();
             model.Initialize(variant);
             variantViewModelList.Add(model);
         }
         Variants = variantViewModelList;
     }
     if (initializeAsMock)
     {
         return;
     }
     VariantDefinitions = VariantDefinitionProvider.GetVariantDefinitions(CatalogItem);
 }
示例#30
0
 public ActionResult VariantInfo(VariantViewModel VariantViewModelParam)
 {
     return(View(VariantViewModelParam));
 }