public IActionResult Invite()
        {
            var model = new InviteUserViewModel();

            return(View(model));
        }
        public async Task <IActionResult> InviteUser(string organizationId, [FromBody] InviteUserViewModel value)
        {
            OrganizationMember teamMember;

            value.OrganizationId = new Guid(organizationId);
            var user = new ApplicationUser();

            //Add person to organization only if you are admin or add it to access request table
            var requestingUser = repository.Find(null, a => a.PersonId == SecurityContext.PersonId && a.OrganizationId == Guid.Parse(organizationId))?.Items.FirstOrDefault();
            var isRequestingUserAdministrator = requestingUser.IsAdministrator.GetValueOrDefault(false);

            // If the requesting user is NOT an Administrator then the user cannot skip Email Verification
            // Only Administrators can allow that. However this can be skipped for now
            //if (value.SkipEmailVerification && !isRequestingUserAdministrator)
            //    value.SkipEmailVerification = false;

            try
            {
                bool IsEmailAllowed = emailSender.IsEmailAllowed();

                var organizationMember = repository.Find(null, a => a.PersonId == SecurityContext.PersonId && a.OrganizationId == Guid.Parse(organizationId))?.Items.FirstOrDefault();
                if (organizationMember == null)
                {
                    throw new UnauthorizedAccessException();
                }

                //This is to check if the user is already in the system and where is part of the organization
                teamMember = membershipManager.InviteUser(value, SecurityContext);
                if (teamMember == null)
                {
                    user.UserName = value.Email;
                    user.Email    = value.Email;
                    string passwordString = value.Password;

                    if (IsEmailAllowed)
                    {
                        if (string.IsNullOrEmpty(passwordString))
                        {
                            RandomPassword randomPass = new RandomPassword();
                            passwordString = randomPass.GenerateRandomPassword();
                        }
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(passwordString))
                        {
                            ModelState.AddModelError("Invite User", "Email is disabled.  Must provide a password.");
                            return(BadRequest(ModelState));
                        }
                    }

                    var loginResult = await userManager.CreateAsync(user, passwordString).ConfigureAwait(false);

                    if (!loginResult.Succeeded)
                    {
                        return(GetErrorResult(loginResult));
                    }
                    else
                    {
                        //Add person email
                        var emailIds    = new List <EmailVerification>();
                        var personEmail = new EmailVerification()
                        {
                            PersonId   = Guid.Empty,
                            Address    = value.Email,
                            IsVerified = false
                        };

                        if (value.SkipEmailVerification)
                        {
                            personEmail.IsVerified = true;
                        }
                        emailIds.Add(personEmail);

                        Person newPerson = new Person()
                        {
                            Company            = value.Company,
                            Department         = value.Department,
                            Name               = value.Name,
                            EmailVerifications = emailIds
                        };
                        var person = personRepository.Add(newPerson);

                        if (!value.SkipEmailVerification)
                        {
                            if (IsEmailAllowed)
                            {
                                string code = await userManager.GenerateEmailConfirmationTokenAsync(user).ConfigureAwait(false);

                                EmailMessage emailMessage = new EmailMessage();
                                emailMessage.Body    = SendConfirmationEmail(code, user.Id, passwordString, "en");
                                emailMessage.Subject = "Confirm your account at " + Constants.PRODUCT;
                                await emailSender.SendEmailAsync(emailMessage).ConfigureAwait(false);
                            }
                            else
                            {
                                value.SkipEmailVerification = true;
                                ModelState.AddModelError("Email", "Email is disabled.  Verification email was not sent.");
                            }
                        }

                        //Update the user
                        if (person != null)
                        {
                            var registeredUser = userManager.FindByNameAsync(user.UserName).Result;
                            registeredUser.PersonId             = person.Id.GetValueOrDefault();
                            registeredUser.ForcedPasswordChange = true;
                            await userManager.UpdateAsync(registeredUser).ConfigureAwait(false);

                            //Add person to organization only if you are admin or add it to access request table
                            if (isRequestingUserAdministrator)
                            {
                                OrganizationMember newOrgMember = new OrganizationMember()
                                {
                                    PersonId       = person.Id,
                                    OrganizationId = Guid.Parse(organizationId),
                                    IsAutoApprovedByEmailAddress = true,
                                    IsInvited = true
                                };
                                await base.PostEntity(newOrgMember).ConfigureAwait(false);
                            }
                            else
                            {
                                //Add it to access requests
                                AccessRequest accessRequest = new AccessRequest()
                                {
                                    OrganizationId    = Guid.Parse(organizationId),
                                    PersonId          = person.Id,
                                    IsAccessRequested = true,
                                    AccessRequestedOn = DateTime.UtcNow
                                };

                                accessRequestManager.AddAccessRequest(accessRequest);
                            }
                        }
                    }
                }
                if (IsEmailAllowed)
                {
                    return(Ok());
                }
                else
                {
                    return(Ok(ModelState));
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }