public async Task <ActionResult> Startup()
{
var apiStatus = new ApiStatusBO
{
ApplicationName = Assembly.GetEntryAssembly()?.GetName().Name?.Split(".")[0],
StartupTime = DateTime.Now,
Environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"),
Host = new HostBO
{
Platform = Environment.OSVersion.Platform.ToString(),
MachineName = Environment.MachineName,
ProccessorCount = Environment.ProcessorCount,
Is64BitOperatingSystem = Environment.Is64BitOperatingSystem,
Is64BitProccess = Environment.Is64BitProcess,
SystemPageSize = Environment.SystemPageSize,
TickCount64 = Environment.TickCount64,
Version = Environment.OSVersion.ToString(),
RuntimeVersion = Assembly.GetEntryAssembly()?.GetCustomAttribute <TargetFrameworkAttribute>()?.FrameworkName
},
Status = "Running"
};
var entity = new CreateIdentityRequest()
{
FirstName = "Jay Test 111",
LastName = "Eraldo"
};
var result = await StreamFlowWrapper.InvokeAsync <ApiStatusBO>(new(entity)
{
CommandName = "TestSignalR",
ExchangeType = MessageExchangeType.Direct,
Recipient = new Guid("3902761a-822d-4c6b-8e2d-323fd501bcd6")
});
public async Task CreateDeleteGet()
{
var create = new CreateIdentityRequest
{
Description = "abcd",
Email = "*****@*****.**",
UserName = "******",
};
var createResponse = await _client.PostJsonAsync <OpenAAP.Context.Identity>($"/identity", create);
createResponse.Should().BeEquivalentTo(create);
var getResponse = await _client.GetJsonAsync <OpenAAP.Context.Identity>($"/identity/{createResponse.Id}");
getResponse.Should().BeEquivalentTo(create);
getResponse.Should().BeEquivalentTo(createResponse);
var deleteResponse = await _client.DeleteAsync($"/identity/{createResponse.Id}");
deleteResponse.EnsureSuccessStatusCode();
var getResponse2 = await _client.GetAsync($"/identity/{createResponse.Id}");
getResponse2.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public async Task CreateGetUpdate()
{
var create = new CreateIdentityRequest
{
Description = "abcd",
Email = "*****@*****.**",
UserName = "******",
};
var createResponse = await _client.PostJsonAsync <OpenAAP.Context.Identity>($"/identity", create);
createResponse.Should().BeEquivalentTo(create);
var getResponse = await _client.GetJsonAsync <OpenAAP.Context.Identity>($"/identity/{createResponse.Id}");
getResponse.Should().BeEquivalentTo(create);
getResponse.Should().BeEquivalentTo(createResponse);
var update = new UpdateIdentityRequest
{
Description = "abcdx",
UserName = "******",
};
var putResponse = await _client.PutJsonAsync <OpenAAP.Context.Identity>($"/identity/{createResponse.Id}", update);
putResponse.Description.Should().Be(update.Description);
putResponse.UserName.Should().Be(update.UserName);
putResponse.Email.Should().Be(null);
var getResponse2 = await _client.GetJsonAsync <OpenAAP.Context.Identity>($"/identity/{createResponse.Id}");
getResponse2.Should().BeEquivalentTo(putResponse);
}
public async Task CreateIdentityRequestHandler_Handle_Returns_InvalidUserKey()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
CreateIdentityResponse response;
var request = new CreateIdentityRequest();
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new CreateIdentityRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsFalse(context.Users.Any());
Assert.IsNull(response.ActivationToken);
Assert.IsFalse(response.IsSuccess);
Assert.AreEqual(ErrorType.InvalidKey, response.ErrorType);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public override Task <CreateIdentityResponse> CreateIdentity(CreateIdentityRequest request, ServerCallContext context)
{
if (registry.Register(request.Email, request.Passcode) == null)
{
throw new RpcException(new Status(StatusCode.AlreadyExists, "Already exists."));
}
return(Task.FromResult(new CreateIdentityResponse()));
}
public async Task Create()
{
var create = new CreateIdentityRequest
{
Description = "abcd",
Email = "*****@*****.**",
UserName = "******",
};
var response = await _client.PostJsonAsync <OpenAAP.Context.Identity>($"/identity", create);
response.Should().BeEquivalentTo(create);
}
public async Task CreateIdentityRequestHandler_Handle_Returns_EmailExists()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
using (var context = AuthenticationContext.GetInMemoryContext())
{
var user = new User
{
Id = Guid.NewGuid(),
Name = "John Doe"
};
context.Credentials.Add(new Credential
{
Id = Guid.NewGuid(),
CredentialType = CredentialType.Email,
Identifier = "*****@*****.**",
User = user
});
context.Users.Add(user);
context.SaveChanges();
}
CreateIdentityResponse response;
var request = new CreateIdentityRequest
{
UserKey = Guid.NewGuid(),
Identifier = "*****@*****.**",
CredentialType = CredentialType.Email
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new CreateIdentityRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsTrue(context.Users.Count() == 1);
Assert.IsNull(response.ActivationToken);
Assert.IsFalse(response.IsSuccess);
Assert.AreEqual(ErrorType.EmailExists, response.ErrorType);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task <IActionResult> Create([FromBody] CreateIdentityRequest create)
{
var identity = new Identity
{
Description = create.Description,
Email = create.Email,
UserName = create.UserName
};
ctx.Identities.Add(identity);
await ctx.SaveChangesAsync();
return(Ok(identity));
}
public async Task CreateIdentityRequestHandler_Handle_Returns_ActivationCode()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
CreateIdentityResponse response;
var request = new CreateIdentityRequest
{
CredentialType = CredentialType.Email,
Identifier = "*****@*****.**",
Role = Role.Donator,
Secret = "password",
UserKey = Guid.NewGuid(),
UserName = "******"
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new CreateIdentityRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsNotNull(response.ActivationToken);
Assert.IsTrue(response.IsSuccess);
Assert.IsTrue(context.Users.Count() == 1);
Assert.AreEqual(request.UserName, context.Users.Single().Name);
Assert.AreEqual(request.UserKey, context.Users.Single().UserKey);
Assert.AreEqual(request.Role, context.Users.Single().Role);
Assert.IsTrue(context.Credentials.Count() == 1);
Assert.AreEqual(request.CredentialType, context.Credentials.Single().CredentialType);
Assert.AreEqual(request.Identifier, context.Credentials.Single().Identifier);
Assert.AreEqual(request.Secret, context.Credentials.Single().Secret);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
/// <summary>
/// Create a ClaimsIdentity representing an existing user.
/// </summary>
/// <param name="request">Instance of CreateRequest</param>
/// <returns>Instance of CreateResponse</returns>
public async Task <CreateIdentityResponse> CreateIdentityAsync(CreateIdentityRequest request)
{
CreateIdentityResponse response = new CreateIdentityResponse();
try
{
string authType = EnumStringValue.GetStringValue(request.AuthenticationType);
AspNetUser user = await this.UserManager.FindByNameAsync(request.UserName);
ClaimsIdentity identity = await this.UserManager.CreateIdentityAsync(user, authType);
response.ClaimIdentityView = identity.ConvertToClaimIdentityView();
response.Success = true;
}
catch (Exception e)
{
response.Success = false;
response.Errors.Add(e.Message);
}
return(response);
}
public async Task <CmdResponse> CreateIdentity(CreateIdentityRequest request)
{
return(await SendVoidAsync <CreateIdentityRequest, CmdResponse>("CreateIdentity", request));
}
/// <summary>
/// Create a ClaimsIdentity representing an existing user.
/// </summary>
/// <param name="request">Instance of CreateRequest</param>
/// <returns>Instance of CreateResponse</returns>
public async Task<CreateIdentityResponse> CreateIdentityAsync(CreateIdentityRequest request)
{
CreateIdentityResponse response = new CreateIdentityResponse();
try
{
string authType = EnumStringValue.GetStringValue(request.AuthenticationType);
AspNetUser user = await this.UserManager.FindByNameAsync(request.UserName);
ClaimsIdentity identity = await this.UserManager.CreateIdentityAsync(user, authType);
response.ClaimIdentityView = identity.ConvertToClaimIdentityView();
response.Success = true;
}
catch (Exception e)
{
response.Success = false;
response.Errors.Add(e.Message);
}
return response;
}
