public async Task DeleteAsync(FlightUser flightUser)
{
if (HasAccessToken(out string token))
{
var accessToken = JsonConvert.DeserializeObject <JsonAccessToken>(token);
var client = new ManagementApiClient(accessToken.access_token, AppServices.Auth0Settings["Domain"]);
var user = ReadByEmailAsync(flightUser.Email).Result;
if (user == null)
{
return;
}
else
{
var userUpdateRequest = new UserUpdateRequest()
{
Connection = AppServices.Auth0Settings["Connection"],
ClientId = AppServices.Auth0Settings["ManagementClientId"],
Blocked = true
};
await client.Users.UpdateAsync(user.UserId, userUpdateRequest);
}
}
else
{
return;
}
}
public static async Task ManagementApiMainAsync(string[] args)
{
string token = "";
var api = new ManagementApiClient(token, "jerrie.auth0.com");
ClientCreateRequest clientCreateRequest = new ClientCreateRequest()
{
Name = "Test name",
ApplicationType = ClientApplicationType.NonInteractive,
ResourceServers = new[]
{
new ClientResourceServerAssociation
{
Identifier = "urn:test-api",
Scopes = new[] { "read:appointments", "create:appointments" }
}
},
JwtConfiguration = new JwtConfiguration
{
SigningAlgorithm = "RS256",
LifetimeInSeconds = 3600
}
};
await api.Clients.CreateAsync(clientCreateRequest);
}
public async Task InitializeAsync()
{
string token = await GenerateManagementApiToken();
_managementApiClient = new ManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
// We will need a connection to add the users to...
_connection = await _managementApiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
// Add a new user
var newUserRequest = new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
_newUser = await _managementApiClient.Users.CreateAsync(newUserRequest);
_authenticationApiClient = new AuthenticationApiClient(GetVariable("AUTH0_AUTHENTICATION_API_URL"));
}
public async Task SetUp()
{
var scopes = new
{
users = new
{
actions = new string[] { "create", "delete" }
},
connections = new
{
actions = new string[] { "create", "delete" }
}
};
string token = GenerateToken(scopes);
managementApiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// We will need a connection to add the users to...
connection = await managementApiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { clientId }
});
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="managementClient">Auth0 用户管理API Client实例</param>
/// <param name="dataContext">用户数据的数据库上下文</param>
/// <param name="configuration">程序配置文件</param>
/// <param name="roleGetter">可用用户身份获取服务接口</param>
public UserManagementService(ManagementApiClient managementClient, UserDataContext dataContext, IConfiguration configuration, IAvailableRoleGetterService roleGetter)
{
this.dataContext = dataContext;
this.configuration = configuration;
this.roleGetter = roleGetter;
userClient = managementClient.Users;
}
private static async void MainAsync(string[] args)
{
var apiClient = new ManagementApiClient(ConfigurationManager.AppSettings["ApiToken"], new Uri(ConfigurationManager.AppSettings["ApiBaseUrl"]));
// Test client methods
//await TestClientMethods(apiClient);
// Test connection methods
//await TestConnectionMethods(apiClient);
// Test device credentials
//await TestDeviceCredentialsMethods(apiClient);
// Test rules
//await TestRuleMethods(apiClient);
// Test users
//await TestUserMethods(apiClient);
// Test user account linking
//await TestUserAccountLinkMethods(apiClient);
// Test emails
//await TestEmailsMethods(apiClient);
// Test jobs
//await TestJobsMethods(apiClient);
// Test stats
//await TestStatsMethods(apiClient);
// Test tickets
//await TestTicketsMethods(apiClient);
}
public async Task SetUp()
{
var scopes = new
{
users = new
{
actions = new string[] { "read", "create", "update", "delete" }
},
connections = new
{
actions = new string[] { "create", "delete" }
},
users_app_metadata = new
{
actions = new string[] { "update" }
},
logs = new
{
actions = new string[] { "read" }
}
};
string token = GenerateToken(scopes);
apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// We will need a connection to add the users to...
connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { "rLNKKMORlaDzrMTqGtSL9ZSXiBBksCQW" }
});
}
public ManagementApiClientTests()
{
management = new ManagementApiClient("fake", GetVariable("AUTH0_MANAGEMENT_API_URL"), grabber);
management.TenantSettings.GetAsync(); // Cause headers to be "sent" to the grabber for testing
payload = JObject.Parse(Encoding.ASCII.GetString(Utils.Base64UrlDecode(grabber.LastHeaders["Auth0-Client"])));
}
public async Task SetUp()
{
var scopes = new
{
users = new
{
actions = new string[] { "create", "delete", "update" }
},
connections = new
{
actions = new string[] { "create", "delete" }
}
};
string token = GenerateToken(scopes);
apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Create a connection
connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { "rLNKKMORlaDzrMTqGtSL9ZSXiBBksCQW" }
});
// Create a user
user = await apiClient.Users.CreateAsync(new UserCreateRequest
{
Connection = connection.Name,
Email = $"{Guid.NewGuid().ToString("N")}@nonexistingdomain.aaa",
EmailVerified = true,
Password = "******"
});
}
public async Task SetUp()
{
var scopes = new
{
users = new
{
actions = new string[] { "create", "delete", "update" }
},
connections = new
{
actions = new string[] { "create", "delete" }
}
};
string token = GenerateToken(scopes);
apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Create a connection
connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { "rLNKKMORlaDzrMTqGtSL9ZSXiBBksCQW" }
});
// Create a user
user = await apiClient.Users.CreateAsync(new UserCreateRequest
{
Connection = connection.Name,
Email = $"{Guid.NewGuid().ToString("N")}@nonexistingdomain.aaa",
EmailVerified = true,
Password = "******"
});
}
private static async Task TestUserMethods(ManagementApiClient apiClient)
{
// Create a new user
//var newUserRequest = new UserCreateRequest
//{
// Connection = "Username-Password-Authentication",
// Email = "*****@*****.**",
// EmailVerified = true,
// Password = "******"
//};
//var newUser = await apiClient.Users.Create(newUserRequest);
// Get a single user
//var user = await apiClient.Users.Get(newUser.UserId);
// Get all users
//var users = await apiClient.Users.GetAll();
// Update the user
//var updateUserRequest = new UserUpdateRequest
//{
// Email = "*****@*****.**",
// VerifyEmail = false
//};
//var updatedUser = await apiClient.Users.Update(newUser.UserId, updateUserRequest);
// Delete the user
//await apiClient.Users.Delete(newUser.UserId);
// Delete all users
//await apiClient.Users.DeleteAll();
}
public IActionResult NewUser([FromBody] NewUser user)
{
if (ModelState.IsValid)
{
switch (ds.AddNewUser(user, Convert.ToInt32(GetSchoolIdForCurrentUser())))
{
case ObjectManipulationResult.Success:
using (var managementClient = new ManagementApiClient())
{
var userAuth0 = managementClient.CreateUser(user);
if (userAuth0 != null)
{
managementClient.RequestVerifyEmail(userAuth0?.UserId);
}
}
return(StatusCode(200, "New user created successfully"));
case ObjectManipulationResult.Exists:
return(StatusCode(409, "User exists"));
case ObjectManipulationResult.ErrorOccured:
return(StatusCode(503, "Error occured"));
default:
return(StatusCode(503, "Error occured"));
}
}
return(StatusCode(400, "Model is not valid"));
}
private static async Task TestRuleMethods(ManagementApiClient apiClient)
{
// Create a new rule
var newRuleRequest = new RuleCreateRequest
{
Name = "New rule",
Script = @"function (user, context, callback) {
// TODO: implement your rule
callback(null, user, context);
}"
};
var newRule = await apiClient.Rules.CreateAsync(newRuleRequest);
// Get a single rule
var rule = await apiClient.Rules.GetAsync(newRule.Id);
// Get all rules
var rules = await apiClient.Rules.GetAllAsync();
// Update a rule
var updateRuleRequest = new RuleUpdateRequest
{
Name = "Updated rule"
};
var updatedRule = await apiClient.Rules.UpdateAsync(newRule.Id, updateRuleRequest);
// Delete a rule
await apiClient.Rules.DeleteAsync(newRule.Id);
}
public async Task Test_device_credentials_crud_sequence()
{
var apiClient = new ManagementApiClient(GetVariable("AUTH0_TOKEN_DEVICE_CREDENTIALS"), new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
//Get all the device credentials
var credentialsBefore = await apiClient.DeviceCredentials.GetAllAsync();
//Create a new device credential
var newCredentialRequest = new DeviceCredentialCreateRequest
{
DeviceName = Guid.NewGuid().ToString("N"),
DeviceId = Guid.NewGuid().ToString("N"),
ClientId = client.ClientId,
Type = "public_key",
Value = "new-key-value"
};
var newCredentialResponse = await apiClient.DeviceCredentials.CreateAsync(newCredentialRequest);
newCredentialResponse.Should().NotBeNull();
newCredentialResponse.DeviceId.Should().Be(newCredentialRequest.DeviceId);
newCredentialResponse.DeviceName.Should().Be(newCredentialRequest.DeviceName);
// Check that we now have one more device credential
var credentialsAfterCreate = await apiClient.DeviceCredentials.GetAllAsync();
credentialsAfterCreate.Count.Should().Be(credentialsBefore.Count + 1);
// Delete the device credential
await apiClient.DeviceCredentials.DeleteAsync(newCredentialResponse.Id);
// Check that we now have one less device credential
var credentialsAfterDelete = await apiClient.DeviceCredentials.GetAllAsync();
credentialsAfterDelete.Count.Should().Be(credentialsAfterCreate.Count - 1);
}
public async Task InitializeAsync()
{
string token = await GenerateManagementApiToken();
_apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
_authConnection = await _apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = "Temp-Int-Test-" + MakeRandomName(),
Strategy = "auth0",
EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
_emailConnection = await _apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = "Temp-Int-Test-" + MakeRandomName(),
Strategy = "email",
EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
_auth0User = await _apiClient.Users.CreateAsync(new UserCreateRequest
{
Connection = _authConnection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
});
_emailUser = await _apiClient.Users.CreateAsync(new UserCreateRequest
{
Connection = _emailConnection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
});
}
private static async Task TestEmailsMethods(ManagementApiClient apiClient)
{
// Get the email provider
var provider = await apiClient.EmailProvider.GetAsync("name,enabled,credentials,settings");
// Delete the email provider
await apiClient.EmailProvider.DeleteAsync();
// Configure the email provider
var configureRequest = new EmailProviderConfigureRequest
{
Name = "mandrill",
IsEnabled = true,
Credentials = new EmailProviderCredentials
{
ApiKey = "ABC"
}
};
var configureResponse = await apiClient.EmailProvider.ConfigureAsync(configureRequest);
// Update the email provider
var updateRequest = new EmailProviderUpdateRequest
{
Name = "mandrill",
IsEnabled = true,
Credentials = new EmailProviderCredentials
{
ApiKey = "XYZ"
}
};
var updateResponse = await apiClient.EmailProvider.UpdateAsync(updateRequest);
}
public async Task InitializeAsync()
{
var apiClient = new ManagementApiClient(GetVariable("AUTH0_TOKEN_DEVICE_CREDENTIALS"), GetVariable("AUTH0_MANAGEMENT_API_URL"));
// Set up the correct Client, Connection and User
_client = await apiClient.Clients.CreateAsync(new ClientCreateRequest
{
Name = Guid.NewGuid().ToString("N")
});
_connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { _client.ClientId }
});
_user = await apiClient.Users.CreateAsync(new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
});
}
public static async Task ManagementApiMainAsync(string[] args)
{
try
{
string token = "";
var api = new ManagementApiClient(token, "jerrie.auth0.com");
ClientCreateRequest clientCreateRequest = new ClientCreateRequest()
{
Name = "Test name",
ApplicationType = ClientApplicationType.NonInteractive,
ResourceServers = new ClientResourceServerAssociation[]
{
new ClientResourceServerAssociation
{
Identifier = "urn:test-api",
Scopes = new string[] { "read:appointments", "create:appointments" }
}
},
JwtConfiguration = new JwtConfiguration
{
SigningAlgorithm = "RS256",
LifetimeInSeconds = 3600
}
};
var createTask = await api.Clients.CreateAsync(clientCreateRequest);
//Console.WriteLine($"The tenant has {clients.Count} clients");
}
catch (Exception ex)
{
throw;
}
}
public async Task Disposes_Connection_it_creates_on_dispose()
{
var diposeManagement = new ManagementApiClient("token", "test");
diposeManagement.Dispose();
await Assert.ThrowsAsync <ObjectDisposedException>(() => diposeManagement.Clients.GetAsync("1"));
}
public async Task Test_tenant_settings_sequence()
{
string token = await GenerateManagementApiToken();
var apiClient = new ManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
// Get the current settings
var settings = apiClient.TenantSettings.GetAsync();
settings.Should().NotBeNull();
// Update the tenant settings
var settingsUpdateRequest = new TenantSettingsUpdateRequest
{
ErrorPage = new TenantErrorPage
{
Html = null,
ShowLogLink = false,
Url = $"www.{Guid.NewGuid():N}.aaa/error"
},
FriendlyName = Guid.NewGuid().ToString("N"),
PictureUrl = $"www.{Guid.NewGuid():N}.aaa/picture.png",
SupportEmail = $"support@{Guid.NewGuid():N}.aaa",
SupportUrl = $"www.{Guid.NewGuid():N}.aaa/support"
};
var settingsUpdateResponse = await apiClient.TenantSettings.UpdateAsync(settingsUpdateRequest);
settingsUpdateResponse.Should().BeEquivalentTo(settingsUpdateRequest);
}
public async Task <(Result Result, ShowcaseUser User)> EditUserAsync(string userId, string userName, string name, string description)
{
try
{
if (tokenExpiresOn <= DateTime.Now)
{
RenewAccessToken();
}
var managementClient = new ManagementApiClient(apiToken.AccessToken, Options.Auth0TenantDomain);
var userMetadata = new Dictionary <string, object>();
userMetadata.Add("description", description);
var editedUser = await managementClient.Users.UpdateAsync(userId, new UserUpdateRequest
{
UserName = userName,
FullName = name,
UserMetadata = userMetadata,
});
var toReturnUser = _mapper.Map <ShowcaseUser>(editedUser);
return(Result.Success(), toReturnUser);
} catch (Exception ex)
{
return(Result.Failure(new List <string>(new string[] { ex.Message })), null);
}
}
public async Task SetUp()
{
var scopes = new
{
users = new
{
actions = new string[] { "read", "create", "update", "delete" }
},
connections = new
{
actions = new string[] { "create", "delete" }
},
users_app_metadata = new
{
actions = new string[] { "update" }
}
};
string token = GenerateToken(scopes);
apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// We will need a connection to add the users to...
connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new[] { "rLNKKMORlaDzrMTqGtSL9ZSXiBBksCQW" }
});
}
public async Task InitializeAsync()
{
string token = await GenerateManagementApiToken();
_managementApiClient = new ManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
var tenantSettings = await _managementApiClient.TenantSettings.GetAsync();
if (string.IsNullOrEmpty(tenantSettings.DefaultDirectory))
{
throw new Exception("Tests require a tenant with a Default Directory selected.\r\n" +
"Enable OAuth 2.0 API Authorization under Account Settings | General and " +
"select a Default Directory under Account Settings | General");
}
// We will need a connection to add the users to...
_connection = await _managementApiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0",
EnabledClients = new [] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
// And add a dummy user to test against
_user = await _managementApiClient.Users.CreateAsync(new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
});
}
public async Task <UserModel> GetUserModel(string token, Auth0ConfigModel objAuth0Config, User user)
{
if (user != null)
{
var managementApiClient = new ManagementApiClient(token, objAuth0Config.Domain);
PaginationInfo pagination = new PaginationInfo();
IPagedList <Role> userRoles = await managementApiClient.Users.GetRolesAsync(user.UserId, pagination);
UserMetadata meta = !string.IsNullOrEmpty(Convert.ToString(user.UserMetadata)) ? JsonConvert.DeserializeObject <UserMetadata>(user.UserMetadata.ToString()) : null;
var userRole = userRoles.Count > 0 ? userRoles[0].Name : "n/a";;
UserModel objUser = new UserModel
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber,
PictureUrl = meta?.Picture,
ReportsTo = meta?.ReportsTo,
Role = userRole
};
return(objUser);
}
return(null);
}
public async Task Test_tenant_settings_sequence()
{
var scopes = new
{
tenant_settings = new
{
actions = new string[] { "read", "update" }
}
};
string token = GenerateToken(scopes);
var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Get the current settings
var settings = apiClient.TenantSettings.Get();
settings.Should().NotBeNull();
// Update the tenant settings
var settingsUpdateRequest = new TenantSettingsUpdateRequest
{
ErrorPage = new TenantErrorPage
{
Html = null,
ShowLogLink = false,
Url = $"www.{Guid.NewGuid().ToString("N")}.aaa/error"
},
FriendlyName = Guid.NewGuid().ToString("N"),
PictureUrl = $"www.{Guid.NewGuid().ToString("N")}.aaa/picture.png",
SupportEmail = $"support@{Guid.NewGuid().ToString("N")}.aaa",
SupportUrl = $"www.{Guid.NewGuid().ToString("N")}.aaa/support"
};
var settingsUpdateResponse = await apiClient.TenantSettings.Update(settingsUpdateRequest);
settingsUpdateResponse.ShouldBeEquivalentTo(settingsUpdateRequest);
}
public async Task <IPagedList <Rule> > GetRules()
{
//var CLIENTMANAGEMENTSECRET = Environment.GetEnvironmentVariable("CLIENTMANAGEMENTSECRET");
var CLIENTMANAGEMENTSECRET = Configuration["Auth0:ClientManagementSecret"];
using (var client = new HttpClient())
{
client.BaseAddress = new System.Uri("https://dev-tslblzvb.eu.auth0.com/");
var response = await client.PostAsync("oauth/token", new FormUrlEncodedContent(
new Dictionary <string, string>
{
{ "grant_type", "client_credentials" },
{ "client_id", "HArPMSSDB2kMPClUwIgPXs6X4QKJ46HE" },
{ "client_secret", CLIENTMANAGEMENTSECRET },
{ "audience", "https://dev-tslblzvb.eu.auth0.com/api/v2/" }
}
));
var content = await response.Content.ReadAsStringAsync();
var jsonResult = JObject.Parse(content);
//get access token for the management api
var mgmtToken = jsonResult["access_token"].Value <string>();
using (var mgmtClient = new ManagementApiClient(mgmtToken, new System.Uri("https://dev-tslblzvb.eu.auth0.com/api/v2")))
{
return(await mgmtClient.Rules.GetAllAsync(new GetRulesRequest(), new PaginationInfo()));
}
}
}
/// <summary>
/// Registers a new user in Auth0 and assigns it the role 'Student'.
/// </summary>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="ArgumentException">Email or password is missing</exception>
/// <exception cref="ApiException">Auth0 reported an error during registration</exception>
public static async Task <string> CreateUserAsync(UserRegistrationArgs args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
if (string.IsNullOrEmpty(args.Email))
{
throw new ArgumentException("Email is required", nameof(args));
}
if (string.IsNullOrEmpty(args.Password))
{
throw new ArgumentException("Password is required", nameof(args));
}
var accessToken = await GetAccessTokenAsync();
var management = new ManagementApiClient(accessToken, _authConfig.Domain);
var user = await management.Users.CreateAsync(new UserCreateRequest
{
Email = args.Email,
FirstName = args.FirstName,
LastName = args.LastName,
FullName = string.Join(' ', args.FirstName.Trim() ?? "", args.LastName.Trim() ?? ""),
Password = args.Password,
AppMetadata = new { roles = new[] { UserRoles.Student.ToString() } },
Connection = "Username-Password-Authentication" // TODO: Make configurable
});
return(user.UserId);
}
public async Task Test_device_credentials_crud_sequence()
{
var apiClient = new ManagementApiClient(GetVariable("AUTH0_TOKEN_DEVICE_CREDENTIALS"), new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
//Get all the device credentials
var credentialsBefore = await apiClient.DeviceCredentials.GetAllAsync();
//Create a new device credential
var newCredentialRequest = new DeviceCredentialCreateRequest
{
DeviceName = Guid.NewGuid().ToString("N"),
DeviceId = Guid.NewGuid().ToString("N"),
ClientId = client.ClientId,
UserId = user.UserId,
Type = "public_key",
Value = "new-key-value"
};
var newCredentialResponse = await apiClient.DeviceCredentials.CreateAsync(newCredentialRequest);
newCredentialResponse.Should().NotBeNull();
newCredentialResponse.DeviceId.Should().Be(newCredentialRequest.DeviceId);
newCredentialResponse.DeviceName.Should().Be(newCredentialRequest.DeviceName);
// Check that we now have one more device credential
var credentialsAfterCreate = await apiClient.DeviceCredentials.GetAllAsync();
credentialsAfterCreate.Count.Should().Be(credentialsBefore.Count + 1);
// Delete the device credential
await apiClient.DeviceCredentials.DeleteAsync(newCredentialResponse.Id);
// Check that we now have one less device credential
var credentialsAfterDelete = await apiClient.DeviceCredentials.GetAllAsync();
credentialsAfterDelete.Count.Should().Be(credentialsAfterCreate.Count - 1);
}
public IActionResult Create([FromBody] SchoolEditionData model)
{
if (ModelState.IsValid)
{
var schoolCreationResult = ds.CreateSchool(model);
UserRecord schoolAdmin = model.SchoolAdmins.First();
using (var managementClient = new ManagementApiClient())
{
var userAuth0 = managementClient.CreateUser(schoolAdmin);
if (userAuth0 != null)
{
managementClient.RequestVerifyEmail(userAuth0?.UserId);
}
}
if (schoolCreationResult == ObjectManipulationResult.Success)
{
return(Ok("School successfully created"));
}
else if (schoolCreationResult == ObjectManipulationResult.Exists)
{
return(BadRequest("School was not created because school admin account already exists"));
}
return(BadRequest("Error occured while creating school"));
}
return(BadRequest("Model is not valid"));
}
public async Task InitializeAsync()
{
string token = await GenerateManagementApiToken();
_apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
_authenticationApiClient = new TestAuthenticationApiClient(GetVariable("AUTH0_AUTHENTICATION_API_URL"));
// We will need a connection to add the users to...
_connection = await _apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = "Temp-Int-Test-" + MakeRandomName(),
Strategy = "auth0",
EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
// Add a new user
var newUserRequest = new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
_user = await _apiClient.Users.CreateAsync(newUserRequest);
// Now try and sign in with a wrong password until we get "too many attempts"
bool userBlocked = false;
int attempts = 0;
do
{
try
{
attempts++;
await _authenticationApiClient.GetTokenAsync(new ResourceOwnerTokenRequest
{
ClientId = GetVariable("AUTH0_CLIENT_ID"),
ClientSecret = GetVariable("AUTH0_CLIENT_SECRET"),
Realm = _connection.Name,
Scope = "openid",
Username = _user.Email,
Password = "******"
});
}
catch (RateLimitApiException)
{
await Task.Delay(1000);
}
catch (ErrorApiException ex)
{
if (ex.ApiError.Error == "too_many_attempts")
{
userBlocked = true;
}
}
} while (!userBlocked && attempts < 20); // Add failsafe to stop if we go over 20 attempts. User should be blocked by then, but just to make sure...
}
public async Task Test_rules_crud_sequence()
{
var scopes = new
{
rules = new
{
actions = new string[] { "read", "create", "delete", "update" }
}
};
string token = GenerateToken(scopes);
var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Get all rules
var rulesBefore = await apiClient.Rules.GetAllAsync();
// Add a new rule
var newRuleRequest = new RuleCreateRequest
{
Name = $"integration-test-rule-{Guid.NewGuid().ToString("N")}",
Script = @"function (user, context, callback) {
// TODO: implement your rule
callback(null, user, context);
}"
};
var newRuleResponse = await apiClient.Rules.CreateAsync(newRuleRequest);
newRuleResponse.Should().NotBeNull();
newRuleResponse.Name.Should().Be(newRuleRequest.Name);
// Get all the rules again, and check that we now have one more
var rulesAfter = await apiClient.Rules.GetAllAsync();
rulesAfter.Count.Should().Be(rulesBefore.Count + 1);
// Update the Rule
var updateRuleRequest = new RuleUpdateRequest
{
Name = $"integration-test-rule-{Guid.NewGuid().ToString("N")}"
};
var updateRuleResponse = await apiClient.Rules.UpdateAsync(newRuleResponse.Id, updateRuleRequest);
updateRuleResponse.Should().NotBeNull();
updateRuleResponse.Name.Should().Be(updateRuleRequest.Name);
// Get a single rule
var rule = await apiClient.Rules.GetAsync(newRuleResponse.Id);
rule.Should().NotBeNull();
rule.Name.Should().Be(updateRuleRequest.Name);
// Delete the rule, and ensure we get exception when trying to fetch it again
await apiClient.Rules.DeleteAsync(rule.Id);
Func <Task> getFunc = async() => await apiClient.Rules.GetAsync(rule.Id);
getFunc.ShouldThrow <ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_rule");
}
public async Task Test_connection_crud_sequence()
{
string token = await GenerateManagementApiToken();
var apiClient = new ManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
// Get all connections before
var connectionsBefore = await apiClient.Connections.GetAllAsync("github");
// Create a new connection
var newConnectionRequest = new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "github"
};
var newConnectionResponse = await apiClient.Connections.CreateAsync(newConnectionRequest);
newConnectionResponse.Should().NotBeNull();
newConnectionResponse.Name.Should().Be(newConnectionRequest.Name);
newConnectionResponse.Strategy.Should().Be(newConnectionRequest.Strategy);
// Get all connections again
var connectionsAfter = await apiClient.Connections.GetAllAsync("github");
connectionsAfter.Count.Should().Be(connectionsBefore.Count + 1);
// Update a connection
var updateConnectionRequest = new ConnectionUpdateRequest
{
Options = new
{
a = "123"
},
Metadata = new
{
b = "456"
}
};
var updateConnectionResponse = await apiClient.Connections.UpdateAsync(newConnectionResponse.Id, updateConnectionRequest);
string a = updateConnectionResponse.Options.a;
a.Should().Be("123");
string b = updateConnectionResponse.Metadata.b;
b.Should().Be("456");
// Get a single connection
var connection = await apiClient.Connections.GetAsync(newConnectionResponse.Id);
connection.Should().NotBeNull();
// Delete the connection and ensure we get exception when trying to get connection again
await apiClient.Connections.DeleteAsync(newConnectionResponse.Id);
Func <Task> getFunc = async() => await apiClient.Connections.GetAsync(newConnectionResponse.Id);
getFunc.ShouldThrow <ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_connection");
}
public async Task Cleanup()
{
var apiClient = new ManagementApiClient(GetVariable("AUTH0_TOKEN_DEVICE_CREDENTIALS"), new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
await apiClient.Clients.DeleteAsync(client.ClientId);
await apiClient.Connections.DeleteAsync(connection.Id);
await apiClient.Users.DeleteAsync(user.UserId);
}
public async Task Test_rules_crud_sequence()
{
var scopes = new
{
rules = new
{
actions = new string[] { "read", "create", "delete", "update" }
}
};
string token = GenerateToken(scopes);
var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Get all rules
var rulesBefore = await apiClient.Rules.GetAll();
// Add a new rule
var newRuleRequest = new RuleCreateRequest
{
Name = $"integration-test-rule-{Guid.NewGuid().ToString("N")}",
Script = @"function (user, context, callback) {
// TODO: implement your rule
callback(null, user, context);
}"
};
var newRuleResponse = await apiClient.Rules.Create(newRuleRequest);
newRuleResponse.Should().NotBeNull();
newRuleResponse.Name.Should().Be(newRuleRequest.Name);
// Get all the rules again, and check that we now have one more
var rulesAfter = await apiClient.Rules.GetAll();
rulesAfter.Count.Should().Be(rulesBefore.Count + 1);
// Update the Rule
var updateRuleRequest = new RuleUpdateRequest
{
Name = $"integration-test-rule-{Guid.NewGuid().ToString("N")}"
};
var updateRuleResponse = await apiClient.Rules.Update(newRuleResponse.Id, updateRuleRequest);
updateRuleResponse.Should().NotBeNull();
updateRuleResponse.Name.Should().Be(updateRuleRequest.Name);
// Get a single rule
var rule = await apiClient.Rules.Get(newRuleResponse.Id);
rule.Should().NotBeNull();
rule.Name.Should().Be(updateRuleRequest.Name);
// Delete the rule, and ensure we get exception when trying to fetch it again
await apiClient.Rules.Delete(rule.Id);
Func<Task> getFunc = async () => await apiClient.Rules.Get(rule.Id);
getFunc.ShouldThrow<ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_rule");
}
public async Task Test_client_crud_sequence()
{
var scopes = new
{
clients = new
{
actions = new string[] { "read", "create", "delete", "update" }
},
client_keys = new
{
actions = new string[] { "read", "update" }
}
};
string token = GenerateToken(scopes);
var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Get all clients
var clientsBefore = await apiClient.Clients.GetAllAsync();
// Add a new client
var newClientRequest = new ClientCreateRequest
{
Name = $"Integration testing {Guid.NewGuid().ToString("N")}"
};
var newClientResponse = await apiClient.Clients.CreateAsync(newClientRequest);
newClientResponse.Should().NotBeNull();
newClientResponse.Name.Should().Be(newClientRequest.Name);
// Get all clients again, and ensure we have one client more
var clientsAfter = await apiClient.Clients.GetAllAsync();
clientsAfter.Count.Should().Be(clientsBefore.Count + 1);
// Update the client
var updateClientRequest = new ClientUpdateRequest
{
Name = $"Integration testing {Guid.NewGuid().ToString("N")}"
};
var updateClientResponse = await apiClient.Clients.UpdateAsync(newClientResponse.ClientId, updateClientRequest);
updateClientResponse.Should().NotBeNull();
updateClientResponse.Name.Should().Be(updateClientRequest.Name);
// Get a single client
var client = await apiClient.Clients.GetAsync(newClientResponse.ClientId);
client.Should().NotBeNull();
client.Name.Should().Be(updateClientResponse.Name);
// Delete the client, and ensure we get exception when trying to fetch client again
await apiClient.Clients.DeleteAsync(client.ClientId);
Func<Task> getFunc = async () => await apiClient.Clients.GetAsync(client.ClientId);
getFunc.ShouldThrow<ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_client");
}
public async Task Test_connection_crud_sequence()
{
var scopes = new
{
connections = new
{
actions = new string[] { "read", "create", "delete", "update" }
}
};
string token = GenerateToken(scopes);
var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Get all connections before
var connectionsBefore = await apiClient.Connections.GetAllAsync("github");
// Create a new connection
var newConnectionRequest = new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "github"
};
var newConnectionResponse = await apiClient.Connections.CreateAsync(newConnectionRequest);
newConnectionResponse.Should().NotBeNull();
newConnectionResponse.Name.Should().Be(newConnectionRequest.Name);
newConnectionResponse.Strategy.Should().Be(newConnectionRequest.Strategy);
// Get all connections again
var connectionsAfter = await apiClient.Connections.GetAllAsync("github");
connectionsAfter.Count.Should().Be(connectionsBefore.Count + 1);
// Update a connection
var updateConnectionRequest = new ConnectionUpdateRequest
{
Options = new
{
a = "123"
}
};
var updateConnectionResponse = await apiClient.Connections.UpdateAsync(newConnectionResponse.Id, updateConnectionRequest);
//updateConnectionResponse.Name.Should().Be(updateConnectionRequest.Name);
// Get a single connection
var connection = await apiClient.Connections.GetAsync(newConnectionResponse.Id);
connection.Should().NotBeNull();
//connection.Name.Should().Be(updateConnectionResponse.Name);
// Delete the connection and ensure we get exception when trying to get connection again
await apiClient.Connections.DeleteAsync(newConnectionResponse.Id);
Func<Task> getFunc = async () => await apiClient.Connections.GetAsync(newConnectionResponse.Id);
getFunc.ShouldThrow<ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_connection");
}
public async Task Test_blacklist_sequence()
{
string apiKey = GetVariable("AUTH0_API_KEY");
var apiClient = new ManagementApiClient(GetVariable("AUTH0_TOKEN_BLACKLISTED_TOKENS"), new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Get all the blacklisted tokens
var tokensBefore = await apiClient.BlacklistedTokens.GetAll(apiKey);
// Generate a token which allows us to list all clients
var scopes = new
{
clients = new
{
actions = new string[] { "read" }
}
};
string jti = Guid.NewGuid().ToString("N");
string token = GenerateToken(scopes, jti);
// Confirm that the token is working
var confirmationApiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
var clients = await confirmationApiClient.Clients.GetAll();
clients.Should().NotBeNull();
// Now blacklist that new token
var blacklistRequest = new BlacklistedTokenCreateRequest
{
Aud = apiKey,
Jti = jti
};
await apiClient.BlacklistedTokens.Create(blacklistRequest);
// Get all the blacklisted tokens and check that we have one more
var tokensAfter = await apiClient.BlacklistedTokens.GetAll(apiKey);
tokensAfter.Count.Should().Be(tokensBefore.Count + 1);
// Try and get all the clients again with that token
Func<Task> getFunc = async () => await confirmationApiClient.Clients.GetAll();
getFunc.ShouldThrow<ApiException>().And.ApiError.StatusCode.Should().Be(401);
}
public async Task Test_stats_sequence()
{
var scopes = new
{
stats = new
{
actions = new string[] { "read" }
}
};
string token = GenerateToken(scopes);
var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Get stats for the past 10 days
var dailyStats = await apiClient.Stats.GetDailyStatsAsync(DateTime.Now.AddDays(-10), DateTime.Now);
dailyStats.Should().NotBeNull();
// Get the active users
var activeUsers = await apiClient.Stats.GetActiveUsersAsync();
activeUsers.Should().BeGreaterOrEqualTo(0);
}
public async Task Initialize()
{
var apiClient = new ManagementApiClient(GetVariable("AUTH0_TOKEN_DEVICE_CREDENTIALS"), new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Set up the correct Client, Connection and User
client = await apiClient.Clients.CreateAsync(new ClientCreateRequest
{
Name = Guid.NewGuid().ToString("N")
});
connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = Guid.NewGuid().ToString("N"),
Strategy = "auth0"
});
user = await apiClient.Users.CreateAsync(new UserCreateRequest
{
Connection = connection.Name,
Email = $"{Guid.NewGuid().ToString("N")}@nonexistingdomain.aaa",
EmailVerified = true,
Password = "******"
});
}
public async Task Test_email_provider_crud_sequence()
{
var scopes = new
{
email_provider = new
{
actions = new string[] { "read", "create", "delete", "update" }
}
};
string token = GenerateToken(scopes);
var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL")));
// Delete the email provider to ensure we start on a clean slate
await apiClient.EmailProvider.DeleteAsync();
// Getting the email provider now should throw, since none is configured
Func<Task> getFunc = async () => await apiClient.EmailProvider.GetAsync("name,enabled,credentials,settings");
getFunc.ShouldThrow<ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_email_provider");
// Configure the email provider
var configureRequest = new EmailProviderConfigureRequest
{
Name = "mandrill",
IsEnabled = true,
Credentials = new EmailProviderCredentials
{
ApiKey = "ABC"
}
};
var configureResponse = await apiClient.EmailProvider.ConfigureAsync(configureRequest);
configureResponse.Name.Should().Be(configureRequest.Name);
configureResponse.IsEnabled.Should().Be(configureRequest.IsEnabled);
configureResponse.Credentials.ApiKey.Should().Be(configureRequest.Credentials.ApiKey);
// Check that we can get the email provider details
var provider = await apiClient.EmailProvider.GetAsync("name,enabled,credentials,settings");
provider.Name.Should().Be(configureRequest.Name);
provider.IsEnabled.Should().Be(configureRequest.IsEnabled);
provider.Credentials.ApiKey.Should().Be(configureRequest.Credentials.ApiKey);
// Update the email provider
var updateRequest = new EmailProviderUpdateRequest
{
Name = "mandrill",
IsEnabled = true,
Credentials = new EmailProviderCredentials
{
ApiKey = "XYZ"
}
};
var updateResponse = await apiClient.EmailProvider.UpdateAsync(updateRequest);
updateResponse.Name.Should().Be(updateRequest.Name);
updateResponse.IsEnabled.Should().Be(updateRequest.IsEnabled);
updateResponse.Credentials.ApiKey.Should().Be(updateRequest.Credentials.ApiKey);
// Delete the email provider again
await apiClient.EmailProvider.DeleteAsync();
// Check than once again the email provider should throw, since none is configured
getFunc = async () => await apiClient.EmailProvider.GetAsync("name,enabled,credentials,settings");
getFunc.ShouldThrow<ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_email_provider");
}
