public async Task <ActionResult> RegisterUserAsync(RegisterUserModel model)
        {
            model.AcceptUserAgreement = true;

            if (ModelState.IsValid)
            {
                var user = new ApplicationUser
                {
                    UserName       = model.Email,
                    Email          = model.Email,
                    FirstName      = model.Name,
                    IsActive       = true,
                    Registered     = DateTime.Now,
                    EmailConfirmed = true
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    // Add a default subscription called "Free" to all users.
                    await SubscriptionExtensions.RegisterUserSubscriptionCode("Free", user.Id);

                    return(PartialView("_RegisterUserPartial", model));
                }

                AddUserErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return(PartialView("_RegisterUserPartial", model));
        }
Пример #2
0
        public async Task TestListAddressesAtSubscriptionLevel()
        {
            AsyncPageable <AddressResource> addresses       = SubscriptionExtensions.GetAddressResourcesAsync(Subscription);
            List <AddressResource>          addressesResult = await addresses.ToEnumerableAsync();

            Assert.NotNull(addressesResult);
            Assert.IsTrue(addressesResult.Count >= 1);
        }
Пример #3
0
        public async Task TestListOrderItemsAtSubscriptionLevel()
        {
            AsyncPageable <OrderItemResource> orderItems       = SubscriptionExtensions.GetOrderItemResourcesAsync(Subscription);
            List <OrderItemResource>          orderItemsResult = await orderItems.ToEnumerableAsync();

            Assert.NotNull(orderItemsResult);
            Assert.IsTrue(orderItemsResult.Count >= 1);
        }
        public async Task TestListProductFamiliesMetadata()
        {
            AsyncPageable <ProductFamiliesMetadataDetails> productFamiliesMetadata =
                SubscriptionExtensions.GetProductFamiliesMetadataAsync(Subscription);
            List <ProductFamiliesMetadataDetails> productFamiliesMetadataResult = await productFamiliesMetadata.ToEnumerableAsync();

            Assert.NotNull(productFamiliesMetadataResult);
            Assert.IsTrue(productFamiliesMetadataResult.Count >= 1);
        }
        public async Task <ActionResult> Register(string code)
        {
            if (Request.IsAuthenticated)
            {
                var userId     = HttpContext.GetUserId();
                var registered = await SubscriptionExtensions.RegisterUserSubscriptionCode(userId, code);

                if (!registered)
                {
                    throw new ApplicationException();
                }

                return(PartialView("_RegisterCodePartial"));
            }
            return(View());
        }
Пример #6
0
        public async Task <ActionResult> Register(string code)
        {
            if (Request.IsAuthenticated)
            {
                // Extension method for fetching the user id
                var userId = HttpContext.GetUserId();
                // Extension method for registering a code with a user
                var registered = await SubscriptionExtensions.RegisterUserSubscriptionCode(code, userId);

                if (!registered)
                {
                    throw new ApplicationException();
                }
                return(PartialView("_RegisterCodePartial"));
            }
            return(View());
        }
        public async Task TestListConfigurations()
        {
            ConfigurationFilters configurationFilters = new(GetHierarchyInformation());

            configurationFilters.FilterableProperty.Add(new FilterableProperty(SupportedFilterTypes.ShipToCountries,
                                                                               new List <string>()
            {
                "US"
            }));
            ConfigurationsRequest configurationsRequest = new(
                new List <ConfigurationFilters>()
            {
                configurationFilters
            });
            AsyncPageable <ProductConfiguration> configurations = SubscriptionExtensions.GetConfigurationsAsync(Subscription,
                                                                                                                configurationsRequest);
            List <ProductConfiguration> configurationsResult = await configurations.ToEnumerableAsync();

            Assert.NotNull(configurationsResult);
            Assert.IsTrue(configurationsResult.Count >= 1);
        }
        public async Task TestListProductFamilies()
        {
            IList <FilterableProperty> filterableProperty = new List <FilterableProperty>()
            {
                new FilterableProperty(SupportedFilterTypes.ShipToCountries, new List <string>()
                {
                    "US"
                })
            };
            IDictionary <string, IList <FilterableProperty> > filterableProperties =
                new Dictionary <string, IList <FilterableProperty> >()
            {
                { "azurestackedge", filterableProperty }
            };
            ProductFamiliesRequest        productFamiliesRequest = new(filterableProperties);
            AsyncPageable <ProductFamily> productFamilies        = SubscriptionExtensions.GetProductFamiliesAsync(Subscription, productFamiliesRequest);
            List <ProductFamily>          productFamiliesResult  = await productFamilies.ToEnumerableAsync();

            Assert.NotNull(productFamiliesResult);
            Assert.IsTrue(productFamiliesResult.Count >= 1);
        }