/// <summary>
/// Invite new user or connect exists
/// </summary>
/// <param name="model">Provider create user model</param>
/// <returns>UserDisplayModel</returns>
public async Task <UserDisplayModel> InviteUser(ProviderUserCreateModel model)
{
var currentUser = await GetCurrentUser();
if (!await _providerRepository.ExistsWithOwner(model.ProviderId, currentUser.Id))
{
throw new AccessDeniedException(currentUser.Id, typeof(AppUser));
}
if (model.Roles == null || !model.Roles.Any())
{
throw new AccessDeniedException("", typeof(AppUser));
}
model.Roles = model.Roles.Select(x => x.ToUpper()).ToList();
var pShort = await _providerRepository.GetShortById(model.ProviderId);
var roles = await _providerRepository.GetRolesById(model.ProviderId);
var rolesToUse = roles.Where(x => model.Roles.Contains(x.Name)).ToList();
var existsUser = await _appUserRepository.FindByEmailAsync(model.Email.ToLower(), new System.Threading.CancellationToken());
if (existsUser == null)
{
existsUser = new AppUser
{
Email = model.Email.ToLower(),
FirstName = model.FirstName,
LastName = model.LastName,
Tels = new List <MRUserTel>(),
Status = UserStatus.Invited,
UserName = model.Email.ToLower(),
};
existsUser.ConnectedProviders = new List <AppUserProvider>
{
new AppUserProvider
{
ProviderId = pShort.Id,
ProviderName = pShort.Name,
Roles = rolesToUse,
Metadata = new List <AppUserProviderMeta>(),
UpdatedTime = DateTime.UtcNow
}
};
var insertResult = await _appUserManager.CreateAsync(existsUser);
if (!insertResult.Succeeded)
{
throw new MRException();
}
await _appUserManager.AddToRoleAsync(existsUser, AppUserRoleList.USER);
}
else if (!existsUser.ConnectedProviders.Any(x => x.ProviderId == pShort.Id))
{
AppUserProvider provider = new AppUserProvider
{
ProviderId = pShort.Id,
Metadata = new List <AppUserProviderMeta>(),
ProviderName = pShort.Name,
Roles = rolesToUse,
UpdatedTime = DateTime.UtcNow
};
if ((await _appUserRepository.AddProvider(existsUser.Id, provider)).ModifiedCount != 1)
{
throw new MRException();
}
}
else
{
throw new MRException();
}
Infrastructure.Model.Template.User.ProviderInviteTemplate templateModel = new Infrastructure.Model.Template.User.ProviderInviteTemplate
{
FirstName = existsUser.FirstName,
LastName = existsUser.LastName,
LoginLink = "https://google.com",
ProviderName = pShort.Name
};
var email = await _templateParser.Render("Email", "ProviderInvite", templateModel);
await _emailSendTaskRepository.InsertEmail(existsUser.Email, "Mad Rat Studio invite", email, Infrastructure.Entities.Tasks.EmailTaskBot.MadRatBot);
return(_mapper.Map <UserDisplayModel>(existsUser));
}
public async Task <ProviderWorkerDisplayModel> CreateBySlug(string slug, ProviderWorkerCreateModel model)
{
if (!await _providerRepository.IsWorkerInRoleBySlug(slug, _userId, ProviderWorkerRole.USER_MANAGER))
{
throw new AccessDeniedException(slug, typeof(ProviderWorker));
}
model.Email = model.Email.ToLower();
ProviderWorker worker = null;
var existsUser = await _appUserRepository.FindByEmailAsync(model.Email, new System.Threading.CancellationToken());
if (existsUser == null)
{
existsUser = new AppUser
{
CreateTime = DateTime.UtcNow,
State = MREntityState.Active,
Status = UserStatus.Invited,
Tels = new List <MRUserTel>(),
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
UpdateTime = DateTime.UtcNow,
};
existsUser = await _appUserRepository.Insert(existsUser);
await _appUserManager.AddToRolesAsync(existsUser, new List <string>()
{
AppUserRoleList.MANAGER,
AppUserRoleList.USER
});
var providerShort = await _providerRepository.GetShortBySlug(slug);
var invite = await _userInviteRepository.Insert(new UserInvite
{
Code = UserInviteCodeGenerator.Generate(),
IsByIdentity = false,
ProviderId = providerShort.Id,
ProviderName = providerShort.Name,
State = MREntityState.Active,
UserId = existsUser.Id
});
_logger.LogInformation("Created new user {0} from provider {1}", existsUser.Email, providerShort.Slug);
// TODO add invite user email
}
else
{
if (await _providerRepository.IsWorkerExistsBySlug(slug, existsUser.Id))
{
throw new EntityExistsException("Id", existsUser.Id, typeof(AppUser));
}
if (!await _appUserManager.IsInRoleAsync(existsUser, AppUserRoleList.MANAGER))
{
await _appUserManager.AddToRoleAsync(existsUser, AppUserRoleList.MANAGER);
}
// TODO add welcome to provider user email
}
worker = new ProviderWorker
{
Roles = model.Roles,
UserEmail = model.Email,
UserId = existsUser.Id
};
await _providerRepository.InsertWorkersBySlug(slug, worker);
_logger.LogInformation("Added new worker {0} to provider {1} by user {2}", worker.UserEmail, slug, _userEmail);
return(_mapper.Map <ProviderWorkerDisplayModel>(worker).ApplyUser(existsUser));
}