private async Task SetLoginPage(BanjoPage page)
{
using var managementClient = await _managementApiClientFactory.CreateAsync();
var getClientsRequest = new GetClientsRequest
{
IsGlobal = true, Fields = "client_id,name", IncludeFields = true
};
var globalClients = managementClient.Clients.GetAllAsync(getClientsRequest, Reporter);
var globalClient = await globalClients.FirstOrDefaultAsync();
if (globalClient == null)
{
throw new Auth0ResourceNotFoundException("No global client found.");
}
var clientUpdateRequest = new ClientUpdateRequest()
{
CustomLoginPage = page.Html, IsCustomLoginPageOn = true
};
await Update(async() =>
{
await managementClient.Clients.UpdateAsync(globalClient.ClientId, clientUpdateRequest);
return(page);
},
page.PageType.ToString());
}
public override async Task Preprocess(Auth0ResourceTemplate template)
{
//Connection templates have a property enabled_clients_match_conditions that contains regexes or string
//literals of client names that the connection should be associated with.
//This preprocessing step looks up all the deployed clients and
var matchConditions = new JsonSerializer().Deserialize <ConnectionClientMatchConditions>(
new JTokenReader(template.Template))
?.EnabledClientsMatchConditions?.ToList() ?? new List <string>();
if (matchConditions.Count == 0)
{
template.Preprocessed = true;
return;
}
using var managementClient = await _managementApiClientFactory.CreateAsync();
var getClientsRequest = new GetClientsRequest()
{
IsGlobal = false, IncludeFields = true, Fields = "name,client_id"
};
var clients = await managementClient.Clients.GetAllAsync(getClientsRequest, new PaginationInfo());
var matchConditionsRegexes = matchConditions.Select(x => new Regex(x));
var matchingClientIds = clients.Where(x =>
//check for exact string match OR regex match
matchConditionsRegexes.Any(regex => string.Equals(regex.ToString(), x.Name) || regex.IsMatch(x.Name))
).Select(x => (object)new JValue(x.ClientId)).ToList();
if (!(template.Template is JObject t))
{
throw new InvalidOperationException(
$"{Type.Name} template {template.Filename} processed type is not of type JObject." +
$" Found {template.Template.GetType().Name}");
}
//add the enabled_clients
t.Add("enabled_clients", new JArray(matchingClientIds.ToArray()));
//remove the enabled_clients_match_conditions
t.Remove("enabled_clients_match_conditions");
if (_args.CurrentValue.DryRun)
{
Reporter.Warn(
"Dry-run flag is set. Any clients that do not exist but that will be created by " +
"these templates when run without the dry-run flag may not be found and included in this " +
"connections\' enabled_clients list. The complete list of matching clients will be found when " +
"run without the dry-run flag.");
}
template.Preprocessed = true;
}
public override async Task ProcessAsync(Auth0ResourceTemplate template)
{
using var managementClient = await _managementApiClientFactory.CreateAsync();
var rule = _converter.Convert(template);
//todo support proper pagination - how to do this where every api call is different?!
var getRulesRequest = new GetRulesRequest
{
IncludeFields = true, Fields = "name,id"
};
var results = managementClient.Rules.GetAllAsync(getRulesRequest, Reporter);
var matchingRule = await results.FirstOrDefaultAsync(x => string.Equals(x.Name, rule.Name));
if (matchingRule == null)
{
var createRequest = Reflectorisor.CopyMembers <Rule, RuleCreateRequest>(rule);
await Create(
async() => await managementClient.Rules.CreateAsync(createRequest),
request => request.Id,
rule.Name);
}
else
{
var updateRequest = Reflectorisor.CopyMembers <Rule, RuleUpdateRequest>(rule);
await Update(
async() => await managementClient.Rules.UpdateAsync(matchingRule.Id, updateRequest),
matchingRule.Id,
rule.Name
);
}
}
public override async Task ProcessAsync(Auth0ResourceTemplate template)
{
using var managementClient = await _managementApiClientFactory.CreateAsync();
var templatedResourceServer = _converter.Convert(template);
var results = managementClient.ResourceServers.GetAllAsync(_reporter);
FixIllegalOptions(templatedResourceServer);
var matchingResourceServer = await results.FirstOrDefaultAsync(x => string.Equals(x.Name, templatedResourceServer.Name));
if (matchingResourceServer == null)
{
var createRequest = Reflectorisor.CopyMembers <ResourceServer, ResourceServerCreateRequest>(templatedResourceServer);
await Create(
async() => await managementClient.ResourceServers.CreateAsync(createRequest),
request => request.Id,
templatedResourceServer.Name
);
}
else
{
var updateRequest = Reflectorisor.CopyMembers <ResourceServer, ResourceServerUpdateRequest>(templatedResourceServer);
await Update(
async() => await managementClient.ResourceServers.UpdateAsync(matchingResourceServer.Id, updateRequest),
matchingResourceServer.Id,
templatedResourceServer.Name
);
}
}
public override async Task ProcessAsync(Auth0ResourceTemplate template)
{
using var managementClient = await _managementApiClientFactory.CreateAsync();
var client = _converter.Convert(template);
var getClientsRequest = new GetClientsRequest
{
IsGlobal = false, IncludeFields = true, Fields = "name,client_id"
};
var results = managementClient.Clients.GetAllAsync(getClientsRequest, Reporter);
FixIllegalOptions(client);
var matchingClient = await results.FirstOrDefaultAsync(x => string.Equals(x.Name, client.Name));
if (matchingClient == null)
{
var createRequest = Reflectorisor.CopyMembers <Client, ClientCreateRequest>(client);
await Create(
async() => await managementClient.Clients.CreateAsync(createRequest),
request => request.ClientId,
client.Name);
}
else
{
var updateRequest = Reflectorisor.CopyMembers <Client, ClientUpdateRequest>(client);
await Update(
async() => await managementClient.Clients.UpdateAsync(matchingClient.ClientId, updateRequest),
matchingClient.ClientId,
client.Name
);
}
}
public override async Task ProcessAsync(Auth0ResourceTemplate template)
{
using var managementClient = await _managementApiClientFactory.CreateAsync();
var role = _converter.Convert(template);
var results = managementClient.Roles.GetAllAsync(new GetRolesRequest(), Reporter);
var matchingRole = await results.FirstOrDefaultAsync(x => string.Equals(x.Name, role.Name));
if (matchingRole == null)
{
var createRequest = Reflectorisor.CopyMembers <Role, RoleCreateRequest>(role);
await Create(
async() => await managementClient.Roles.CreateAsync(createRequest),
request => request.Id,
role.Name);
}
else
{
var updateRequest = Reflectorisor.CopyMembers <Role, RoleUpdateRequest>(role);
await Update(
async() => await managementClient.Roles.UpdateAsync(matchingRole.Id, updateRequest),
matchingRole.Id,
role.Name
);
}
}
public override async Task ProcessAsync(Auth0ResourceTemplate template)
{
var settings = _converter.Convert(template);
using var managementClient = await _managementApiClientFactory.CreateAsync();
var updateRequest = Reflectorisor.CopyMembers <TenantSettings, TenantSettingsUpdateRequest>(settings);
await Update(async() => await managementClient.TenantSettings.UpdateAsync(updateRequest),
template.Type.Name);
}
public override async Task ProcessAsync(Auth0ResourceTemplate template)
{
//get the client that matches the ClientGrant.ClientId so we get Client.Id
using var managementClient = await _managementApiClientFactory.CreateAsync();
var templatedGrant = _converter.Convert(template);
var getClientsRequest = new GetClientsRequest
{
IsGlobal = false, IncludeFields = true, Fields = "name,client_id"
};
var allClients = await managementClient.Clients.GetAllAsync(getClientsRequest, new PaginationInfo());
var matchingClient = allClients.FirstOrDefault(x => x.Name == templatedGrant.ClientId);
if (matchingClient == null)
{
throw new Auth0ResourceNotFoundException($"No {ResourceType.Clients.Name} exists with name " +
$"{templatedGrant.ClientId}. Cannot create/update " +
$"{ResourceType.ClientGrants.Name} {template.Filename}");
}
templatedGrant.ClientId = matchingClient.ClientId;
var allGrants = managementClient.ClientGrants.GetAllAsync(new GetClientGrantsRequest(), Reporter);
var existingGrant = await allGrants.FirstOrDefaultAsync(
x => string.Equals(x.ClientId, templatedGrant.ClientId) &&
string.Equals(x.Audience, templatedGrant.Audience));
if (existingGrant == null)
{
var createRequest = Reflectorisor.CopyMembers <ClientGrant, ClientGrantCreateRequest>(templatedGrant);
await Create(
async() => await managementClient.ClientGrants.CreateAsync(createRequest),
request => request.Id,
$"[{matchingClient.Name}|{createRequest.Audience}]");
}
else
{
var updateRequest = Reflectorisor.CopyMembers <ClientGrant, ClientGrantUpdateRequest>(templatedGrant);
await Update(
async() => await managementClient.ClientGrants.UpdateAsync(existingGrant.Id, updateRequest),
existingGrant.Id,
$"[{matchingClient.Name}|{existingGrant.Audience}]");
}
}
public async Task <User> Handle(CreateAuth0UserCommand request, CancellationToken cancellationToken)
{
if (request.Emails.Length == 0)
{
throw new InvalidOperationException("No emails provided.");
}
using var client = await managementApiClientFactory.CreateAsync();
var createdUsers = new List <User>();
foreach (var email in request.Emails)
{
var createdUser = await client.CreateUserAsync(new UserCreateRequest()
{
Connection = "Username-Password-Authentication",
Email = email,
EmailVerified = true,
Password = Guid.NewGuid().ToString()
});
if (createdUsers.Count > 0)
{
var firstUser = createdUsers.First();
try
{
await client.LinkUserAccountAsync(firstUser.UserId, new UserAccountLinkRequest()
{
UserId = createdUser.UserId,
Provider = "auth0"
});
}
catch
{
await client.DeleteUserAsync(createdUser.UserId);
throw;
}
}
createdUsers.Add(createdUser);
}
return(createdUsers.First());
}
public async Task <User?> Handle(GetAuth0UserFromGitHubUserIdQuery request, CancellationToken cancellationToken)
{
if (request.GitHubUserId == default)
{
throw new InvalidOperationException("No GitHub ID is given.");
}
using var client = await managementApiClientFactory.CreateAsync();
var users = await client.GetAllUsersAsync(
new GetUsersRequest()
{
SearchEngine = "v3",
Query = $"user_metadata.dogger_github_user_id: {request.GitHubUserId}"
},
new PaginationInfo(0, 1, true));
return(users.SingleOrDefault());
}
public async Task <User?> Handle(GetAuth0UserFromEmailsQuery request, CancellationToken cancellationToken)
{
if (request.Emails.Length == 0)
{
throw new InvalidOperationException("No emails provided.");
}
using var client = await managementApiClientFactory.CreateAsync();
foreach (var email in request.Emails)
{
var users = await client.GetUsersByEmailAsync(email);
var user = users.FirstOrDefault();
if (user != null)
{
return(user);
}
}
return(null);
}
