Esempio n. 1
0
        public async Task <IActionResult> SignUp(SignUpViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            User user = new User()
            {
                Email    = model.Email,
                UserName = model.Email
            };

            IdentityResult res = await userManager.CreateAsync(user, model.Pswd);

            if (res.Succeeded)
            {
                await signInManager.SignInAsync(user, true);

                return(RedirectToAction("Index"));
            }
            else
            {
                foreach (var er in res.Errors)
                {
                    ModelState.AddModelError("Email", er.Description);
                }

                return(View(model));
            }

            return(View());
        }
Esempio n. 2
0
 void RegistrationView_Loaded(object sender, RoutedEventArgs e)
 {
     _model = (SignUpViewModel)this.DataContext;
     _model.PasswordAccessor = () => Password.Password;
     _model.PasswordConfirmationAccessor = () => PasswordConfirmation.Password;
     _model.SignUpCompleted += _model_SignUpCompleted;
 }
 public ActionResult AddEmployee(SignUpViewModel signUpViewModel)
 {
     try
     {
         var user         = new User();
         var employee     = new Employee();
         var signuphelper = new SignUpHelper();
         user = signuphelper.GetUserobj(signUpViewModel);
         var result = _userService.Save(user);
         var userid = _userService.GetLastId(signUpViewModel.Email);
         signUpViewModel.UserId = userid.Data;
         employee = signuphelper.GetEmployeeobj(signUpViewModel);
         var result2 = _employeeService.Save(employee);
         if (result.HasError)
         {
             ViewBag.Message = result.Message;
             return(Content(result.Message));
         }
         if (result2.HasError)
         {
             ViewBag.Message = result2.Message;
             return(Content(result2.Message));
         }
         return(RedirectToAction("GetAllEmployee"));
     }
     catch (Exception e)
     {
         return(Content(e.Message));
     }
 }
Esempio n. 4
0
 public SignUpPage()
 {
     InitializeComponent();
     LastNameTB.Focus();
     Keyboard.Focus(LastNameTB);
     DataContext = new SignUpViewModel(this);
 }
 public ActionResult EmployeeDetails(int id)
 {
     try
     {
         var result  = _employeeService.GetById(id);
         var result2 = _userService.GetById(id);
         DetailsViewModel details = new DetailsViewModel();
         SignUpViewModel  sg      = new SignUpViewModel();
         sg = details.SignUpViewModel(result.Data, result2.Data);
         if (result.HasError)
         {
             ViewBag.Message = result.Message;
             return(Content(result.Message));
         }
         if (result2.HasError)
         {
             ViewBag.Message = result2.Message;
             return(Content(result2.Message));
         }
         return(View(sg));
     }
     catch (Exception e)
     {
         return(Content(e.Message));
     }
 }
Esempio n. 6
0
        public async Task <IActionResult> SignUp(SignUpViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new IdentityUser
                {
                    UserName = model.Email,
                    Email    = model.Email
                };
                var result = await userManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    if (user.UserName == "*****@*****.**")
                    {
                        IdentityResult roleResult = await roleManager.CreateAsync(new IdentityRole("Admin"));

                        result = await userManager.AddToRoleAsync(user, "Admin");
                    }
                    await signInManager.SignInAsync(user, isPersistent : false);

                    return(RedirectToAction("index", "home"));
                }

                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }

            return(View(model));
        }
Esempio n. 7
0
 public IActionResult UserForm(SignUpViewModel signUp)
 {
     _logger.LogInformation("POST request on UserForm.");
     if (ModelState.IsValid)//validates tour
     {
         // If valid, add the Party to the DB.
         Tour addTour = _repository.Tours
                        .Where(t => t.TourId == signUp.TourId)
                        .FirstOrDefault();
         var party = new Party
         {
             EmailAddress = signUp.EmailAddress,
             PartyName    = signUp.PartyName,
             PhoneNumber  = signUp.PhoneNumber,
             PartySize    = signUp.PartySize,
             Tour         = addTour,
             TourId       = signUp.TourId
         };
         _context.Parties.Add(party);
         addTour.Parties.Add(party);
         _context.SaveChanges();
         return(RedirectToAction("Index"));//if valid returns UserForm
     }
     // If invalid, render the model with errors.
     return(View(signUp));
 }
Esempio n. 8
0
        public SignUpPage()
        {
            InitializeComponent();
            var signUpViewModel = new SignUpViewModel();

            signUpViewModel.OnSignUpResult += async(bool result) =>
            {
                if (result)
                {
                    await DisplayAlert("Sign Up Successful", "You'll soon be emailed with your MyMentor credentials.", "OK");

                    Navigation.InsertPageBefore(new LoginPage(), this);
                    await Navigation.PopAsync();
                }
            };
            signUpViewModel.OnPrivacyPolicyClicked += async() =>
            {
                await DisplayAlert("Privacy",
                                   "MyMentor uses your name for account verification and to better match you with other students and professors." +
                                   "\r\n\r\nYour personal information is private to you. If we ever plan to share this information, we will explicitly ask for your permission.",
                                   "OK");
            };

            BindingContext = signUpViewModel;
        }
Esempio n. 9
0
        internal SignUpView()
        {
            InitializeComponent();
            var signUpViewModel = new SignUpViewModel();

            DataContext = signUpViewModel;
        }
Esempio n. 10
0
        public async Task <IActionResult> SignUp(SignUpViewModel model)
        {
            try
            {
                await Mediator.Send(model.Command);

                HttpContext.Session.Set(SessionKeys.SignUpSuccess, Array.Empty <byte>());

                return(RedirectToAction("SignIn", "Account"));
            }
            catch (AccountAlreadyExistException)
            {
                HttpContext.Session.Set(SessionKeys.AccountAlreadyExistError, Array.Empty <byte>());
            }
            catch (PasswordsNotEqualException)
            {
                HttpContext.Session.Set(SessionKeys.PasswordsNotEqualError, Array.Empty <byte>());
            }
            catch (Exception)
            {
                return(BadRequest());
            }

            return(RedirectToAction("SignUp"));
        }
Esempio n. 11
0
        public async Task <IActionResult> SignUp(SignUpViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var user = new User
            {
                Email      = model.Email,
                UserName   = model.Email,
                FirstName  = model.FirstName,
                LastName   = model.LastName,
                MiddleName = model.MiddleName
            };

            var created = await _userManager.CreateAsync(user, model.Password);

            if (created.Succeeded)
            {
                await _signInManager.SignInAsync(user, false);

                _logger.LogInformation("User success signup!");

                return(RedirectToAction("Index", "Home"));
            }

            foreach (var error in created.Errors)
            {
                _logger.LogError("User don't signup!");
                ModelState.AddModelError(String.Empty, error.Description);
            }

            return(View(model));
        }
Esempio n. 12
0
        public ActionResult SignUp(SignUpViewModel model)
        {
            if (ModelState.IsValid)
            {
                using (DomainContext db = new DomainContext())
                {
                    var obj = db.Users.Where(a => a.EmailAddress.Equals(model.EmailAddress)).FirstOrDefault();
                    if (obj == null)
                    {
                        User user = new User();
                        user.FirstName    = model.FirstName;
                        user.LastName     = model.LastName;
                        user.EmailAddress = model.EmailAddress;
                        user.PassWord     = model.PassWord;

                        db.Users.Add(user);
                        db.SaveChanges();

                        return(RedirectToAction(actionName: "Index", controllerName: "Login"));
                    }
                    else if (obj != null)
                    {
                        model.SignupErrorMessage = "An account already exists with this email address";
                        return(View("Signup", model));
                    }
                }
            }
            return(View("Signup"));
        }
Esempio n. 13
0
        public async Task <IActionResult> SignUp(SignUpViewModel model, string returnUrl)
        {
            returnUrl = returnUrl ?? Url.Content("~/");
            if (ModelState.IsValid)
            {
                var user = new AppUser {
                    UserName = Guid.NewGuid().ToString(), Email = model.Email, FullName = model.FullName, EmailConfirmed = true, PhoneNumberConfirmed = true
                };
                var result = await _userManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    await _userManager.AddToRoleAsync(user, Roles.Customer.ToString());

                    _logger.LogInformation("User created a new account with password.");

                    await _signInManager.SignInAsync(user, isPersistent : false);

                    return(RedirectToAction(nameof(HomeController.Index), nameof(HomeController)));
                }
                else
                {
                    var errorList = new List <string>();
                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError(string.Empty, error.Description);
                        errorList.Add(error.Description);
                    }
                    TempData["IdentityErrors"] = errorList.ToArray();
                }
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
Esempio n. 14
0
        public SignUpViewModel SignUp(SignUpActionData actionData)
        {
            var viewModel = new SignUpViewModel();

            var modelStates = new ModelStateDictionary();

            foreach (var reason in actionData.RegistrationFailureReasons)
            {
                switch (reason)
                {
                case RegistrationFailureReason.UsernameNotAvailable:
                    modelStates.AddModelError("username", GetRegistrationFailureReasonText(RegistrationFailureReason.UsernameNotAvailable));
                    break;

                case RegistrationFailureReason.PasswordsDoNotMatch:
                    modelStates.AddModelError("passwordConfirmation", GetRegistrationFailureReasonText(RegistrationFailureReason.PasswordsDoNotMatch));
                    break;

                case RegistrationFailureReason.EmailsDoNotMatch:
                    modelStates.AddModelError("email", GetRegistrationFailureReasonText(RegistrationFailureReason.EmailsDoNotMatch));
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            IEnumerable <string> errors = actionData.RegistrationFailureReasons.Select(GetRegistrationFailureReasonText);

            viewModel.Errors     = errors;
            viewModel.ModelState = modelStates;
            return(viewModel);
        }
Esempio n. 15
0
        public ActionResult SignUp(SignUpViewModel model)
        {
            if (model.Password != model.ConfirmPassword)
            {
                ModelState.AddModelError("ConfirmPassword", "Passwords don't match");
                return(View(model));
            }
            if (ModelState.IsValid)
            {
                try
                {
                    UserEndpoint ue = new UserEndpoint();
                    ue.Register(model.UserName);
                    WebSecurity.CreateUserAndAccount(model.UserName, model.Password, new { PrivateKey = string.Empty, PublicKey = string.Empty });
                    TempData["Notification"] = new Notification("Please check your e-mail, we sent you access keys.", Nature.success);

                    return(RedirectToAction("Login"));
                }
                catch (Exception ex)
                {
                    return(View("Error"));
                }
            }
            else
            {
                return(View(model));
            }
        }
Esempio n. 16
0
        public async Task <IActionResult> SignUp([FromBody] SignUpViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var newUser = new ApplicationUser
            {
                Email     = model.Email,
                Firstname = model.Firstname,
                Lastname  = model.Lastname
            };

            var result = await _userManager.CreateAsync(newUser, model.Password);

            if (!result.Succeeded)
            {
                return(BadRequest(result.Errors));
            }

            ApplicationUser user = await _userManager.FindByEmailAsync(newUser.Email);

            var roles = await _userManager.GetRolesAsync(user);

            return(Ok(_tokenService.Generate(user, roles.ToList())));
        }
Esempio n. 17
0
		public ActionResult SignUp(SignUpViewModel signUpViewModel)
		{
			this.InitializeFacebookAuth(Url.Action("OAuthLogin", "Auth", null, "https"));

			if(!this.ValidateAndAppendMessages(signUpViewModel))
			{
				return View("Login");
			}

			if(this.UserService.EmailAddressIsInUse(signUpViewModel.NewUserEmailAddress))
			{
				this.AppendMessage(new ErrorMessage { Text = "The email address you entered is already registered" });
				return View("Login");
			}

			try
			{
				var user = this.CreateAccount(signUpViewModel);
				this.ForwardMessage(new SuccessMessage { Text = "Your account has been created.  Welcome to Brewgr!" });
				
				return this.SignInAndRedirect(user);
			}
			catch (Exception ex)
			{
				this.LogHandledException(ex);
				this.AppendMessage(new ErrorMessage { Text = GenericMessages.ErrorMessage });
				return View("Login");
			}
		}
Esempio n. 18
0
        public async Task <IActionResult> SignUp(SignUpViewModel signUpModel)
        {
            if (ModelState.IsValid)
            {
                UserModel user = await _userManager.FindByEmailAsync(signUpModel.Email);

                if (user == null)
                {
                    user          = new UserModel();
                    user.UserName = signUpModel.Email;
                    user.Email    = signUpModel.Email;

                    var result = await _userManager.CreateAsync(user, signUpModel.Password);

                    if (result.Errors.Count() > 0)
                    {
                        foreach (var error in result.Errors)
                        {
                            ModelState.AddModelError("", error.Description);
                        }

                        return(View());
                    }

                    return(RedirectToAction("Signin"));
                }

                ModelState.AddModelError("Email", "Email has already been taken");
                return(View());
            }

            return(View());
        }
Esempio n. 19
0
        public SignUpPage()
        {
            this.InitializeComponent();

            ViewModel   = new SignUpViewModel();
            DataContext = ViewModel;
        }
        public async Task <ActionResult> SignUpUser(SignUpViewModel user)
        {
            if (ModelState.IsValid)
            {
                var appUser = new AppUser
                {
                    UserName = user.Email,
                    Email    = user.Email,
                };

                var result = await _userManager.CreateAsync(appUser, user.Password);

                if (result.Succeeded)
                {
                    // **Uncomment this line of code when you want to generate an new claim(type Role) to a user. Then, run the Application and SignUp.**
                    //await _userManager.AddClaimAsync(appUser, new Claim(ClaimTypes.Role, RoleName.Admin));

                    await _signInManager.SignInAsync(appUser, isPersistent : false);

                    return(RedirectToAction("IndexWhenAuthenticated", "Home"));
                }

                foreach (var identityError in result.Errors)
                {
                    ModelState.AddModelError(identityError.Code, identityError.Description);
                }
            }

            return(View(user));
        }
Esempio n. 21
0
 public SignUpPage(SignUpViewModel signUpViewModel)
 {
     InitializeComponent();
     Init();
     SignUpViewModel     = signUpViewModel;
     this.BindingContext = SignUpViewModel;
 }
Esempio n. 22
0
        //TODO: Figure out how to combine logic with Index
        public ActionResult SignUp(SignUpViewModel model)
        {
            ViewBag.Description =
                "Sign up for How-to's, life hacks and insight into .NET, C#, The Web, Open Source, Programming and more from Chad Ramos. Brought to you by Pioneer Code.";

            ViewBag.PopularPosts = _postService.GetPopularPosts().ToList();
            ViewBag.LatestPosts  = _postService.GetAll(true, false, false, 8).ToList();

            if (!ModelState.IsValid)
            {
                ViewBag.IsValid = false;
                return(View("Index", model));
            }

            //var response = _communicationService.SignUpToMailingList(model);

            //if (response.Status != OperationStatus.Created)
            //{
            //    ViewBag.IsValid = false;
            //    ViewBag.IsValidMessage = response.Message;
            //    return View("Index", model);
            //}

            ViewBag.IsValid = true;

            return(View("Index", model));
        }
Esempio n. 23
0
 public SignUp()
 {
     InitializeComponent();
     SignUpViewModel = new SignUpViewModel();
     //set binding
     BindingContext = SignUpViewModel;
 }
Esempio n. 24
0
        public bool SignUp(SignUpViewModel signUpViewModel)
        {
            var userPasswordDto = new UserPasswordDto
            {
                user = new UserPasswordDto.User
                {
                    userName             = signUpViewModel.Username,
                    email                = signUpViewModel.Email,
                    emailConfirmed       = true,
                    phoneNumber          = signUpViewModel.Phone,
                    phoneNumberConfirmed = true
                },
                password = new UserPasswordDto.Password
                {
                    password        = signUpViewModel.Password,
                    confirmPassword = signUpViewModel.Password
                }
            };

            var token      = GetAdminToken();
            var httpClient = new HttpClient();

            httpClient.DefaultRequestHeaders.Add("Authorization", "bearer " + token);
            var serializedUserPassword = serializerService.Serialize(userPasswordDto);
            var httpContent            = new StringContent(serializedUserPassword, Encoding.UTF8, "application/json");
            var result = httpClient.PostAsync("https://petshop-sergio-iammicroservice-api.azurewebsites.net/api/UsersAndRoles", httpContent).Result;

            if (!result.IsSuccessStatusCode)
            {
                return(false);
            }
            return(true);
        }
Esempio n. 25
0
        public SignUpResult SignUp(SignUpViewModel signUpViewModel)
        {
            var request = new RestSharp.RestRequest(AccountAPI.SignUp)
            {
                JsonSerializer = new NewtonsoftJsonSerializer()
            };

            request.AddJsonBody(signUpViewModel);
            var           user     = new User();
            IRestResponse response = _client.Post(request);
            var           json     = JsonConvert.DeserializeObject <GenericAPIResponse>(response.Content);

            if (json.success)
            {
                user = new User()
                {
                    UserName     = signUpViewModel.UserName,
                    PasswordHash = signUpViewModel.Password,
                    Email        = signUpViewModel.Email,
                    UserId       = signUpViewModel.UserId
                };
            }

            return(new SignUpResult()
            {
                Succeed = json.success,
                ErrorMessage = json.error,
                user = user
            });
        }
Esempio n. 26
0
        public ActionResult EditProfile(SignUpViewModel viewModel)
        {
            try
            {
                ModelState.Remove("FirstName");
                ModelState.Remove("LastName");
                ModelState.Remove("Email");
                ModelState.Remove("Sex");
                ModelState.Remove("Password");
                ModelState.Remove("Age");

                if (ModelState.IsValid)
                {
                    Entity.USER user = GetUserById(viewModel.UserId);
                    if (user != null)
                    {
                        user.Address          = viewModel.Address;
                        user.CreditCardNumber = viewModel.CreditCardNumber;
                        user.PhoneNumber      = viewModel.PhoneNumber;

                        db.Entry(user).State = EntityState.Modified;
                        db.SaveChanges();

                        SetMessage(new Message()
                        {
                            MessageText = "Profile was edited succesfully", MessageCategory = (int)MessageCategory.SUCCESS
                        });
                    }
                }
                return(View(viewModel));
            }
            catch (Exception ex) { throw ex; }
        }
Esempio n. 27
0
        public async Task <IActionResult> SignUp(SignUpViewModel model)
        {
            if (ModelState.IsValid)
            {
                await signInManager.SignOutAsync();

                var result = await userManager.FindByEmailAsync(model.Email);

                if (result == null)
                {
                    ApplicationUser user = new ApplicationUser
                    {
                        UserName = model.UserName,
                        Email    = model.Email
                    };

                    if ((await userManager.CreateAsync(user, model.Password))
                        .Succeeded)
                    {
                        await userManager.AddToRoleAsync(user, Roles.User);

                        await signInManager.PasswordSignInAsync(user,
                                                                model.Password, false, false);

                        return(Redirect("/Profile/Index"));
                    }
                }
            }
            var error = $"A user with the email {model.Email} is already registered.";

            ModelState.AddModelError("", error);
            TempData["message"] = error;

            return(View(model));
        }
        public async Task <IActionResult> SignUpAsync(SignUpViewModel model)
        {
            var user = new ApplicationUser
            {
                Email    = model.EmailAddress,
                UserName = model.UserName
            };

            var result = await _userManager.CreateAsync(user, model.Password);

            if (result.Succeeded)
            {
                // Get database user in order to get userId
                user = await _userManager.FindByEmailAsync(model.EmailAddress);

                return(new JsonResult(new
                {
                    user.Email,
                    user.UserName,
                    user.Id
                }));
            }

            return(BadRequest(JsonSerializer.Serialize(result.Errors.ToArray())));
        }
Esempio n. 29
0
        public async Task <ActionResult> SignUp(SignUpViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new AppUser {
                    UserName = model.UserName, Email = model.Email
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    // --- Sign in the user
                    await SignInManager.SignInAsync(user, false, false);

                    // --- Create the subscription for the user
                    var subscrSrv = ServiceManager.GetService <ISubscriptionService>();
                    var newSubscr = new SubscriptionDto
                    {
                        SubscriberName = user.UserName,
                        PrimaryEmail   = user.Email,
                        CreatedUtc     = DateTimeOffset.UtcNow,
                    };
                    var subscriptionId = await subscrSrv.CreateSubscriptionAsync(newSubscr, user.Id);

                    CreateAuthenticationTicket(false, new Guid(user.Id), user.UserName, false, subscriptionId, true);
                    return(RedirectToAction("SelectSubscriptionPackage"));
                }
                AddErrors(result);
            }
            return(View(model));
        }
Esempio n. 30
0
        public async Task <IActionResult> SignUp(SignUpViewModel model)
        {
            if (User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Logs", "Home"));
            }
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            AppUser u = new()
            {
                Email       = model.Email,
                UserName    = model.UserName,
                DailyTarget = model.DailyTarget
            };

            var res = await _appUsersService.CreateAsync(u, model.Password);

            if (res.Succeeded)
            {
                _signinService.SessionLogin(u);
                return(RedirectToAction("Logs", "Home"));
            }
            else
            {
                res.Errors.ForEach(e => ModelState.AddModelError("", e));
                return(View(model));
            }
        }
        public ActionResult UpdateEmployee(SignUpViewModel signUp)
        {
            try
            {
                var employeeobj = _employeeService.GetById(signUp.UserId);
                var userobj     = _userService.GetById(signUp.UserId);
                var update      = new UpdateInstance();
                var updateUser  = update.GetUpdatedUserObj(signUp, userobj.Data);
                var result      = _userService.Save(updateUser);

                var updateEmployee = update.GetUpdatedEmployeeObj(signUp, employeeobj.Data);
                var result2        = _employeeService.Save(updateEmployee);
                if (result.HasError)
                {
                    ViewBag.Message = result.Message;
                    return(Content(result.Message));
                }
                if (result2.HasError)
                {
                    ViewBag.Message = result.Message;
                    return(Content(result.Message));
                }
                return(RedirectToAction("GetAllEmployee"));
            }
            catch (Exception e)
            {
                return(Content(e.Message));
            }
        }
Esempio n. 32
0
        /// <summary>
        /// Регистрация.
        /// </summary>
        public async Task <Guid> SignUpAsync(SignUpViewModel model)
        {
            if (await _userRepository.GetByEmailAsync(model.Email) != null)
            {
                throw new Exception($"Username '{model.Email}' is already in use.");
            }

            try
            {
                var user = _mapper.Map <User>(model);
                user.Password    = _passwordHashService.GetHash(user.Password);
                user.ConfirmCode = Guid.NewGuid().ToString("N");

                var userId = await _userRepository.InsertAsync(user);

                var confirmUrl = $"/api/account/confirm/{user.ConfirmCode}";
                await _notificationService.SendAccountConfirmationAsync(user.Email, confirmUrl);

                return(userId);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
Esempio n. 33
0
		public override void ViewDidLoad ()
		{
			base.ViewDidLoad ();

			viewModel = App.SignUpViewModel;

			resigner = new FirstResponderResigner (View, Input);

			#if DEBUG
//			debugGesture = new TapGestureAttacher (View, 3, ChangeThemeProps);
			debugGesture = new TapGestureAttacher (View, 3, Theme.SetNextTheme);
			#endif

			ContinueBtn.TouchUpInside += ContinueHandler;
			SwitchSignUpType.TouchUpInside += SwitchSignUpTypeHandler;
			Input.EditingChanged += InputChangedHandler;
			NickName.EditingChanged += NickNameInputHandler;

			SausageButtons.SetUp (ContinueBtn);
			SausageButtons.SetUp (SwitchSignUpType);
			SwitchSignUpType.Layer.BorderWidth = 1.5f;

			#region Theme switcher

			BoyButton.SetTitle("Red", UIControlState.Normal);
			GirlButton.SetTitle("Blue", UIControlState.Normal);

			BoyButton.TouchUpInside += RedThemeSelected;
			GirlButton.TouchUpInside += BlueThemeSelected;

			ThemeSelectorContainerView.BackgroundColor = Theme.Current.BackgroundColor;

			SausageButtons.SetUp (BoyButton);
			SausageButtons.ApplyTheme(AppDelegate.RedTheme, BoyButton);
			SausageButtons.UpdateBackgoundColor(AppDelegate.RedTheme, BoyButton);

			SausageButtons.SetUp (GirlButton);
			SausageButtons.ApplyTheme(AppDelegate.BlueTheme, GirlButton);
			SausageButtons.UpdateBackgoundColor(AppDelegate.BlueTheme, GirlButton);
			#endregion

			UpdateText ();
		}
Esempio n. 34
0
        public ActionResult SignUp(SignUpViewModel signUp)
        {
            if (ModelState.IsValid)
            {
                var createClient = new CreateClientCommand(signUp.Name, signUp.Email, signUp.Password, signUp.Brag,
                    signUp.Latitude, signUp.Longitude, signUp.Source.Value);

                ExecuteCommand(createClient);

                _userMailer.Welcome(signUp.Name, createClient.EmailVerificationCode, signUp.Email).Send();

                return RedirectToAction("SignUpSuccess");
            }

            return View();
        }
Esempio n. 35
0
		/// <summary>
		/// Creates a new Account
		/// </summary>
		UserSummary CreateAccount(SignUpViewModel signUpViewModel)
		{
			using (var unitOfWork = this.UnitOfWorkFactory.NewUnitOfWork())
			{
				var user = this.UserService.RegisterNewUser(signUpViewModel.NewUserFullName, signUpViewModel.NewUserEmailAddress, signUpViewModel.NewUserPassword);
				unitOfWork.Commit();

				// TODO: We need to send a welcome email

				return Mapper.Map(user, new UserSummary());				
			}
		}
Esempio n. 36
0
		public ViewResult SignUpViaDialog(SignUpViewModel signUpViewModel)
		{
			this.InitializeFacebookAuth(Url.Action("OAuthLogin", "Auth", null, "https"));

			if (!this.ValidateAndAppendMessages(signUpViewModel))
			{
				ViewBag.LoginViaDialogSuccess = false;
				return View("LoginViaDialog");
			}

			if (this.UserService.EmailAddressIsInUse(signUpViewModel.NewUserEmailAddress))
			{
				ViewBag.LoginViaDialogSuccess = false;
				this.AppendMessage(new ErrorMessage { Text = "The email address you entered is already registered" });
				return View("LoginViaDialog");
			}

			try
			{
				var userSummary = this.CreateAccount(signUpViewModel);
				ViewBag.LoginViaDialogSuccess = true;
				this.SignIn(userSummary, false);

				this.AppendLoginViaDialogSuccessMessage(userSummary, !string.IsNullOrWhiteSpace(Request["editMode"]));
			}
			catch (Exception ex)
			{
				this.LogHandledException(ex);
				this.AppendMessage(new ErrorMessage { Text = GenericMessages.ErrorMessage });
			}

			return View("LoginViaDialog");
		}
Esempio n. 37
0
		/// <summary>
		/// Creates a new Account
		/// </summary>
		UserSummary CreateAccount(SignUpViewModel signUpViewModel)
		{
			using (var unitOfWork = this.UnitOfWorkFactory.NewUnitOfWork())
			{
				var user = this.UserService.RegisterNewUser(signUpViewModel.NewUserFullName, signUpViewModel.NewUserEmailAddress, signUpViewModel.NewUserPassword);
				unitOfWork.Commit();

                // Send the Email Message
                var newAccountEmailMessage = (NewAccountEmailMessage)this.EmailMessageFactory.Make(EmailMessageType.NewAccount);

                newAccountEmailMessage.ToRecipients.Add(signUpViewModel.NewUserEmailAddress);
                this.EmailSender.Send(newAccountEmailMessage);

                return Mapper.Map(user, new UserSummary());				
			}
		}