public async Task <ActionResult> AddExistingUserToOrganizationAsync(string userName, string roleIds, string customerNumber)
        {
            var user = await UserManager.QuerySiteUserAsync(userName);

            if (user == null)
            {
                return(new HttpStatusCodeResult(400));
            }

            var roles    = roleIds.Split(',');
            var customer = await _customerSupportRepo.GetCustomerByNumberAsync(customerNumber);

            await _orgUserRepo.AddUserToOrganizationAsync(user, new CustomerBasicInfo
            {
                CustomerName = customer.CustomerName,
                CustomerNo   = customerNumber
            }, roles);

            //fire and forget email
            var link = $"{ConfigurationManager.AppSettings["domainUrl"]}";

            await SendEmailToExistingUserAsync(user.Email, roleIds, link, customer.CustomerName);

            return(Json(true));
        }
Esempio n. 2
0
        private async Task <ActionResult> AddNewUserToOrganizationAsync(CustomerBasicInfo organization, AddUserToOrganizationFormViewModel viewModel)
        {
            var user = await _accountRepo.CreateUserAsync(viewModel.FirstName, viewModel.LastName, viewModel.Telephone,
                                                          viewModel.Mobile, viewModel.Email, string.Empty, string.Empty, string.Empty);

            if (user == null)
            {
                throw new ApplicationException("CreateNewFailed");
            }

            var roles = viewModel.Roles.Split(',');
            await _orgUserRepo.AddUserToOrganizationAsync(user, organization, roles);

            var startPage   = _contentRepo.Get <StartPage>(ContentReference.StartPage);
            var settingPage = _contentRepo.Get <SettingsPage>(startPage.SettingsPage);

            var guid = await _securityRepository.GeneratePasswordGuidAsync(user.UserName);

            var resetPasswordToken = _tokenGenerator.Encrypt(new ResetPasswordConfirmationData
            {
                GuidString = guid,
                UserName   = viewModel.Email
            });

            //fire and forget email
            //var host = Request.Url?.Host + (Request?.Url?.IsDefaultPort == true ? "" : ":" + Request?.Url?.Port);
            var link = $"{ConfigurationManager.AppSettings["publicSitePrefix"]}/p/resetpassword?payload={resetPasswordToken}";

            await SendEmailToNewUserAsync(viewModel.Email, viewModel.Roles, link, organization.CustomerName);

            TempData["reference"] = "NewUserAdded";
            return(RedirectToAction("Index", new { node = settingPage.HandleOrganizationUserPage }));
        }
Esempio n. 3
0
        public async Task <ActionResult> UpdateCustomer(string organizationNumber, string customerNumber, bool isActive)
        {
            if (string.IsNullOrWhiteSpace(organizationNumber))
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, $"{nameof(organizationNumber)} is required"));
            }

            var findCustomerResult = await _customerSupportRepo.GetCustomersByOrganizationNumberAsync(organizationNumber, false);

            var customer = findCustomerResult?.FirstOrDefault(c => c.OrganizationNumber == organizationNumber);

            if (customer == null)
            {
                return(Json(new { error = $"Could not find the specified organization number {organizationNumber}" }));
            }
            if (isActive)
            {
                var verification = await _securityRepo.MatchCustomerNumberAndOrganizationNumberAsync(customerNumber, organizationNumber);

                if (verification == CustomerCheckCode.CustomerNumberNotMatch || verification == CustomerCheckCode.CustomerNumberNotExist)
                {
                    return(Json(new { error = "Kunddata stämmer inte. Försök igen eller avvakta." }));
                }

                customer.IsActive       = true;
                customer.CustomerNumber = customerNumber;
                var user = await UserManager.QuerySiteUserAsync(customer.Email);

                if (user == null)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError, $"Cannot find account {customer.Email}"));
                }
                var saveCustomerResult = await _customerSupportRepo.SaveCustomerAsync(customer);

                if (saveCustomerResult == 0)
                {
                    //the new roles include admin's roles and the CustomerOwner role (1)
                    var adminRoles = await _securityRepo.GetRolesOfProfileAsync("Admin");

                    var ownerRoleIds = new string[adminRoles.Length + 1];
                    for (var i = 0; i < ownerRoleIds.Length; i++)
                    {
                        ownerRoleIds[i] = i == adminRoles.Length ? "1" : adminRoles[i].RoleId.ToString();
                    }

                    await _orgUserRepo.AddUserToOrganizationAsync(user, new CustomerBasicInfo
                    {
                        CustomerName = customer.CustomerName,
                        CustomerNo   = customer.CustomerNumber,
                    }, ownerRoleIds);
                }
                else
                {
                    Response.StatusCode = 500;
                    return(Json(new { error = $"Försök igen eller avvakta med aktiveringsprocessen för denna kund." }));
                }
            }
            else
            {
                await _accountRepo.InactivateUserAsync(customer.Email);
            }

            return(Json(true));
        }