[InlineData(new[] { "something something %%unreplacedTOKEN%% something else" }, new[] { "%%unreplacedTOKEN%%" })] //one unreplaced token with other ok content public async Task Test(IEnumerable <string> jtokenValues, IEnumerable <string> requiredTokens) { var messageCollector = new TestReporter(); var stage = new UnresolvedTokenVerifierStage(messageCollector); var json = new JObject(); foreach (var value in jtokenValues) { json.Add(Guid.NewGuid().ToString(), new JValue(value)); } var t = new Auth0ResourceTemplate { Type = ResourceType.Clients, Template = json }; await stage.Process(t); var requiredTokenList = requiredTokens.ToList(); if (!requiredTokenList.Any()) { messageCollector.Messages.ShouldBeEmpty(); } else { foreach (var token in requiredTokenList) { messageCollector.ErrorMessages.ShouldHaveMessageThatContains(token); } } }
public override async Task ProcessAsync(Auth0ResourceTemplate template) { var page = _converter.Convert(template); if (!template.Preprocessed) { throw new Auth0InvalidTemplateException( $"{template.Type.Name} template {template.Filename} has not been preprocessed prior to being executed."); } switch (page.PageType) { case PageType.Login: await SetLoginPage(page); break; case PageType.PasswordReset: await SetPasswordResetPage(page); break; case PageType.GuardianMultifactor: await SetGuardianMfaPage(page); break; default: throw new Auth0InvalidTemplateException("Page name must be one of [login, reset_password]"); } }
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 Preprocess(Auth0ResourceTemplate template) { var scriptToken = template.Template.SelectTokens("script").OfType <JValue>().FirstOrDefault(x => x.Type == JTokenType.String); if (scriptToken == null) { throw new Auth0InvalidTemplateException( $"{Type.Name} template {template.Filename} does not contain a required property \'script\' " + $"of type String."); } var scriptFilename = scriptToken.Value as string; if (string.IsNullOrWhiteSpace(scriptFilename)) { throw new Auth0InvalidTemplateException( $"{Type.Name} template {template.Filename} does not contain a valid value for property " + $"\'script\'. Must not be null or empty."); } var scriptPath = Path.Combine(Directory.GetParent(template.Location.FullName).FullName, scriptFilename); if (!File.Exists(scriptPath)) { throw new Auth0InvalidTemplateException( $"{Type.Name} template {template.Filename} does not contain a valid value for property " + $"\'script\'. The file must exist but does not: {scriptPath}"); } scriptToken.Replace(await File.ReadAllTextAsync(scriptPath)); }
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) { 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) { 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 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) { //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 override async Task ProcessAsync(Auth0ResourceTemplate template) { using var managementClient = await _managementApiClientFactory.CreateAsync(); var templatedConnection = _converter.Convert(template); var getConnectionsRequest = new GetConnectionsRequest { IncludeFields = true, Fields = "name,id" }; var allConnections = managementClient.Connections.GetAllAsync(getConnectionsRequest, Reporter); var matchingConnection = await allConnections.FirstOrDefaultAsync(x => string.Equals(x.Name, templatedConnection.Name)); if (matchingConnection == null) { var createRequest = Reflectorisor.CopyMembers <Connection, ConnectionCreateRequest>(templatedConnection); await Create( async() => await managementClient.Connections.CreateAsync(createRequest), request => request.Id, templatedConnection.Name ); } else { var updateRequest = Reflectorisor.CopyMembers <Connection, ConnectionUpdateRequest>(templatedConnection); //Remove the name property. It's not allowed on an update. updateRequest.Name = null; await Update( async() => await managementClient.Connections.UpdateAsync(matchingConnection.Id, updateRequest), matchingConnection.Id, templatedConnection.Name ); } }
public override async Task <Auth0ResourceTemplate> Process(Auth0ResourceTemplate t) { _reporter.Output(JsonConvert.SerializeObject(t.Template, Formatting.Indented)); return(t); }
public abstract Task ProcessAsync(Auth0ResourceTemplate template);
public virtual async Task Preprocess(Auth0ResourceTemplate template) { //no-op }
public virtual async Task Validate(Auth0ResourceTemplate template) { _converter.Convert(template); }
public override async Task <Auth0ResourceTemplate> Process(Auth0ResourceTemplate t) { return(t); }
public To Convert(Auth0ResourceTemplate @from) { return(new JsonSerializer().Deserialize <To>(new JTokenReader(@from.Template))); }