public async Task <InvokeResult> CreateNewOrganizationAsync(CreateOrganizationViewModel organizationViewModel, EntityHeader user)
{
var result = new InvokeResult();
ValidationCheck(organizationViewModel, Core.Validation.Actions.Create);
//HACK: Very, small chance, but it does exist...two entries could be added at exact same time and check would fail...need to make progress, can live with risk for now.
if (await _organizationRepo.QueryNamespaceInUseAsync(organizationViewModel.Namespace))
{
result.Errors.Add(new ErrorMessage(UserAdminResources.Organization_NamespaceInUse.Replace(Tokens.NAMESPACE, organizationViewModel.Namespace)));
return(result);
}
var organization = new Organization();
organization.SetId();
organization.SetCreationUpdatedFields(user);
organizationViewModel.MapToOrganization(organization);
organization.Status = UserAdminResources.Organization_Status_Active;
organization.TechnicalContact = user;
organization.AdminContact = user;
organization.BillingContact = user;
/* Create the Organization in Storage */
await _organizationRepo.AddOrganizationAsync(organization);
var currentUser = await _appUserRepo.FindByIdAsync(user.Id);
var addUserResult = await AddUserToOrgAsync(currentUser.ToEntityHeader(), organization.ToEntityHeader(), currentUser.ToEntityHeader(), true, true);
if (!addUserResult.Successful)
{
return(addUserResult);
}
if (currentUser.Organizations == null)
{
currentUser.Organizations = new List <EntityHeader>();
}
/* add the organization ot the newly created user */
currentUser.Organizations.Add(organization.ToEntityHeader());
//In this case we are creating a new org for first time through, make sure they have all the correct privelages.
if (EntityHeader.IsNullOrEmpty(currentUser.CurrentOrganization))
{
currentUser.IsOrgAdmin = true;
currentUser.IsAppBuilder = true;
currentUser.CurrentOrganization = organization.ToEntityHeader();
}
/* Final update of the user */
await _appUserRepo.UpdateAsync(currentUser);
await _orgInitializer.Init(organization.ToEntityHeader(), currentUser.ToEntityHeader(), organizationViewModel.CreateGettingsStartedData);
await LogEntityActionAsync(organization.Id, typeof(Organization).Name, "Created Organization", organization.ToEntityHeader(), user);
return(result);
}
public async Task <InvokeResult> DeleteUserAsync(String id, EntityHeader deletedByUser)
{
var appUser = await _appUserRepo.FindByIdAsync(id);
await _appUserRepo.DeleteAsync(appUser);
return(default(InvokeResult));
}
public async Task <DependentObjectCheckResult> CheckInUse(string id, EntityHeader org, EntityHeader user)
{
var appUser = await _appUserRepo.FindByIdAsync(id);
await AuthorizeAsync(appUser, AuthorizeResult.AuthorizeActions.Read, user, org);
return(await CheckForDepenenciesAsync(appUser));
}
public async Task SendEmailNotification(string subject, string message, string distroListId, EntityHeader org, EntityHeader user)
{
var distroList = await _distroListRepo.GetDistroListAsync(distroListId);
await AuthorizeAsync(distroList, AuthorizeResult.AuthorizeActions.Perform, user, org, "sendEmail");
foreach (var appUser in distroList.AppUsers)
{
var appUserDetail = await _appuserRepo.FindByIdAsync(appUser.Id);
await _emailSender.SendAsync(appUserDetail.Email, subject, message);
}
}
public async Task <InvokeResult> SetUserSMSValidated(string userId, EntityHeader orgHeader, EntityHeader userHeader)
{
var appUser = await _appUserRepo.FindByIdAsync(userHeader.Id);
if (!appUser.IsSystemAdmin)
{
return(InvokeResult.FromError("Must be a system admin to set a users phone number as verified."));
}
var user = await _appUserRepo.FindByIdAsync(userId);
user.PhoneNumber = "5555551212";
user.PhoneNumberConfirmed = true;
await _appUserRepo.UpdateAsync(user);
return(InvokeResult.Success);
}
public async Task <InvokeResult> AddTeamMemberAsync(string teamId, string userId, EntityHeader org, EntityHeader addedByMemberId)
{
var team = await _teamRepo.GetTeamAsync(teamId);
await AuthorizeAsync(team, AuthorizeResult.AuthorizeActions.Update, addedByMemberId, org);
var member = await _appUserRepo.FindByIdAsync(userId);
var teamMember = new TeamUser(team.ToEntityHeader(), member.ToEntityHeader());
await _teamUserRepo.AddTeamMemberAsync(teamMember);
return(InvokeResult.Success);
}
public async Task <AppUser> GetUserByIdAsync(string id, EntityHeader org, EntityHeader requestedByUser)
{
var appUser = await _appUserRepo.FindByIdAsync(id);
appUser.PasswordHash = null;
/* The user should always be able to get it's own account */
if (requestedByUser.Id != id)
{
await AuthorizeAsync(appUser, AuthorizeResult.AuthorizeActions.Read, requestedByUser, org);
}
return(appUser);
}
public async Task CreateNewOrganizationAsync(CreateOrganizationViewModel organizationViewModel, EntityHeader user)
{
ValidationCheck(organizationViewModel, Core.Validation.Actions.Create);
//HACK: Very, small chance, but it does exist...two entries could be added at exact same time and check would fail...need to make progress, can live with rish for now.
if (await _organizationRepo.QueryNamespaceInUseAsync(organizationViewModel.Namespace))
{
throw new ValidationException(Resources.UserManagementResources.Organization_CantCreate, false,
UserManagementResources.Organization_NamespaceInUse.Replace(Tokens.NAMESPACE, organizationViewModel.Namespace));
}
var organization = new Organization();
organization.SetId();
organization.SetCreationUpdatedFields(user);
organizationViewModel.MapToOrganization(organization);
organization.Status = UserManagementResources.Organization_Status_Active;
organization.TechnicalContact = user;
organization.AdminContact = user;
organization.BillingContact = user;
var location = new OrganizationLocation();
location.SetId();
organizationViewModel.MapToOrganizationLocation(location);
location.SetCreationUpdatedFields(user);
location.AdminContact = user;
location.TechnicalContact = user;
location.Organization = organization.ToEntityHeader();
organization.PrimaryLocation = location.ToEntityHeader();
if (organization.Locations == null)
{
organization.Locations = new List <EntityHeader>();
}
organization.Locations.Add(location.ToEntityHeader());
var currentUser = await _appUserRepo.FindByIdAsync(user.Id);
var locationUser = new LocationAccount(organization.Id, location.Id, user.Id)
{
Email = currentUser.Email,
OrganizationName = organization.Name,
AccountName = currentUser.Name,
ProfileImageUrl = currentUser.ProfileImageUrl.ImageUrl,
LocationName = location.Name
};
locationUser.SetCreationUpdatedFields(user);
await _organizationRepo.AddOrganizationAsync(organization);
await AddAccountToOrgAsync(currentUser.ToEntityHeader(), organization.ToEntityHeader(), currentUser.ToEntityHeader());
await _locationRepo.AddLocationAsync(location);
await _locationAccountRepo.AddAccountToLocationAsync(locationUser);
if (EntityHeader.IsNullOrEmpty(currentUser.CurrentOrganization))
{
currentUser.CurrentOrganization = organization.ToEntityHeader();
}
if (currentUser.Organizations == null)
{
currentUser.Organizations = new List <EntityHeader>();
}
currentUser.Organizations.Add(organization.ToEntityHeader());
await _appUserRepo.UpdateAsync(currentUser);
}
public Task <AppUser> FindByIdAsync(string userId, CancellationToken token)
{
return(_userRepo.FindByIdAsync(userId));
}