public async Task <NegotiationResponse> NegotiateAsync(string hubName, HttpContext httpContext = null, string userId = null, IEnumerable <Claim> claims = null, TimeSpan?lifetime = null, bool isDiagnosticClient = false, CancellationToken cancellationToken = default)
{
try
{
if (cancellationToken == default && httpContext != null)
{
cancellationToken = httpContext.RequestAborted;
}
var candidateEndpoints = _serviceEndpointManager.GetEndpoints(hubName);
var selectedEndpoint = _router.GetNegotiateEndpoint(httpContext, candidateEndpoints);
var provider = _serviceEndpointManager.GetEndpointProvider(selectedEndpoint);
Func <IEnumerable <Claim> > claimProvider = null;
if (claims != null)
{
claimProvider = () => claims;
}
var claimsWithUserId = ClaimsUtility.BuildJwtClaims(httpContext?.User, userId: userId, claimProvider, isDiagnosticClient: isDiagnosticClient);
var tokenTask = provider.GenerateClientAccessTokenAsync(hubName, claimsWithUserId, lifetime);
await tokenTask.OrTimeout(cancellationToken, Timeout, GeneratingTokenTaskDescription);
return(new NegotiationResponse
{
Url = provider.GetClientEndpoint(hubName, null, null),
AccessToken = tokenTask.Result
});
}
catch (Exception e)
{
throw new AzureSignalRException(ErrorMsg, e);
}
}
public async Task Call_NegotiateAsync_After_WithEndpoints(ServiceTransportType serviceTransportType)
{
var serviceManager = new ServiceManagerBuilder()
.WithOptions(o =>
{
o.ServiceTransportType = serviceTransportType;
o.ServiceEndpoints = ServiceEndpoints;
})
.BuildServiceManager();
var hubContext = await serviceManager.CreateHubContextAsync(Hub, default);
for (var i = 0; i < 5; i++)
{
var randomEndpoint = ServiceEndpoints[StaticRandom.Next(0, Count)];
var negotiationResponse = await(hubContext as IInternalServiceHubContext)
.WithEndpoints(new ServiceEndpoint[] { randomEndpoint })
.NegotiateAsync();
Assert.Equal(ClientEndpointUtils.GetExpectedClientEndpoint(Hub, null, randomEndpoint.Endpoint), negotiationResponse.Url);
var tokenString = negotiationResponse.AccessToken;
var token = JwtTokenHelper.JwtHandler.ReadJwtToken(tokenString);
var expectedToken = JwtTokenHelper.GenerateJwtBearer(
ClientEndpointUtils.GetExpectedClientEndpoint(Hub, null, randomEndpoint.Endpoint),
ClaimsUtility.BuildJwtClaims(null, null, null), token.ValidTo, token.ValidFrom, token.ValidFrom, randomEndpoint.AccessKey);
Assert.Equal(expectedToken, tokenString);
}
}
public async Task <IActionResult> Create(CreateWorkflowCommand command)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
if (command.Inputs == null)
{
//Set to an empty dictionary if null
command.Inputs = new Dictionary <string, object>();
}
try
{
command.CreatedBy = ClaimsUtility.GetId(User);
var result = await Mediator.Send(command);
return(Ok(new HttpCommandResult <Workflow>("workflow", result, result.Result)));
}
catch (BaseException e)
{
Logger.LogError(e.Message);
stopwatch.Stop();
return(BadRequest(e.ToExceptionResult(stopwatch.ElapsedMilliseconds)));
}
}
public async Task <IActionResult> Create([FromBody] CreateExecutionTemplateVM command)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var result = await Mediator.Send(new CreateExecutionTemplateCommand()
{
CreatedBy = ClaimsUtility.GetId(User),
Description = command.Description,
ExecutionTemplateType = command.ExecutionTemplateType.ToLower(),
Inputs = command.Inputs,
Name = command.Name,
ReferenceId = command.ReferenceId
});
return(Ok(new HttpCommandResult <ExecutionTemplate>("/api/execution-template/" + command.Name, result, null)));
}
catch (BaseException e)
{
Logger.LogError(e.Message);
stopwatch.Stop();
return(BadRequest(e.ToExceptionResult(stopwatch.ElapsedMilliseconds)));
}
}
public async Task <IActionResult> Create([FromBody] CreateWorkflowTemplateCommand command)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
if (command.InputDefinitions == null)
{
command.InputDefinitions = new Dictionary <string, Domain.ValueObjects.DynamicDataDescription>();
}
if (command.LogicBlocks == null)
{
command.InputDefinitions = new Dictionary <string, Domain.ValueObjects.DynamicDataDescription>();
}
try
{
command.CreatedBy = ClaimsUtility.GetId(User);
var result = await Mediator.Send(command);
return(Ok(new HttpCommandResult <WorkflowTemplate>("/api/workflowTemplate/" + command.Name + "/" + command.Version, result, null)));
}
catch (BaseException e)
{
Logger.LogError(e.Message);
stopwatch.Stop();
return(BadRequest(e.ToExceptionResult(stopwatch.ElapsedMilliseconds)));
}
}
public async Task <IActionResult> Create([FromBody] CreateStepTemplateCommand command)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
if (command.ReferenceId == null && (command.Name == null || command.Version == null))
{
return(BadRequest("Either referenceId needs to be set or name and version must be set."));
}
try
{
if (command.OutputDefinitions == null)
{
command.OutputDefinitions = new Dictionary <string, Domain.ValueObjects.DynamicDataDescription>();
}
command.CreatedBy = ClaimsUtility.GetId(User);
var result = await Mediator.Send(command);
return(Ok(new HttpCommandResult <StepTemplate>("/api/steptemplates/" + command.Name + "/" + command.Version, result, null)));
}
catch (BaseException e)
{
Logger.LogError(e.Message);
stopwatch.Stop();
return(BadRequest(e.ToExceptionResult(stopwatch.ElapsedMilliseconds)));
}
}
public async Task <IActionResult> Create([FromBody] CreateExecutionScheduleVM command, bool?runImmediately = false)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var result = await Mediator.Send(new CreateExecutionScheduleCommand()
{
CreatedBy = ClaimsUtility.GetId(User),
Description = command.Description,
Name = command.Name,
RunImmediately = runImmediately.HasValue ? runImmediately.Value : false,
ExecutionTemplateName = command.ExecutionTemplateName,
Schedule = command.Schedule
});
return(Ok(new HttpCommandResult <ExecutionSchedule>("/api/execution-schedules/" + command.Name, result, null)));
}
catch (BaseException e)
{
Logger.LogError(e.Message);
stopwatch.Stop();
return(BadRequest(e.ToExceptionResult(stopwatch.ElapsedMilliseconds)));
}
}
public async Task <IActionResult> ScanWorkflow(Guid id)
{
return(Ok(await Mediator.Send(new ScanWorkflowCommand()
{
CreatedBy = ClaimsUtility.GetId(User),
WorkflowId = id
})));
}
public async Task <IActionResult> Execute(string name)
{
return(Ok(await Mediator.Send(new ExecuteExecutionTemplateCommand()
{
Name = name,
CreatedBy = ClaimsUtility.GetId(User)
})));
}
public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
{
var user = await UserService.GetAsync(context.UserName, context.Password);
if (user != null)
{
var claims = ClaimsUtility.GetClaims(user);
context.Result = new GrantValidationResult(user.Id.ToString(), "password", claims);
}
}
public async Task <IActionResult> Get()
{
var username = ClaimsUtility.GetUsername(User);
var user = (await Mediator.Send(new GetEntityQuery <User>()
{
Expression = u => u.Username == username
}));
return(Ok(new HttpQueryResult <User, UserVM>(user, Mapper.Map <UserVM>(user.Result))));
}
public async Task <IActionResult> UpdateStepStatus(Guid id, PutStepStatus putModel)
{
IRequest <CommandResult> request;
switch (putModel.Status)
{
case StepStatuses.Suspended:
request = new SuspendStepCommand()
{
StepId = id,
CreatedBy = ClaimsUtility.GetId(User),
SuspendedUntil = putModel.SuspendedUntil
};
break;
case StepStatuses.Cancelled:
request = new CancelStepCommand()
{
StepId = id,
CreatedBy = ClaimsUtility.GetId(User)
};
break;
case StepStatuses.Unassigned:
request = new UnassignStepCommand()
{
StepId = id,
CreatedBy = ClaimsUtility.GetId(User)
};
break;
default:
return(BadRequest(new ExceptionResult()
{
ExceptionName = "InvalidStepStatusException",
Message = "Step status given was not valid. Steps can only be suspended, unassigned or cancelled by users"
}));
}
var result = await Mediator.Send(request);
if (result.ObjectRefId != "")
{
var resolvedStep = (await Mediator.Send(new GetEntityQuery <Step>()
{
Expression = s => s.Id == new Guid(result.ObjectRefId)
})).Result;
return(Ok(new HttpCommandResult <Step>("step", result, resolvedStep)));
}
else
{
return(Ok(new HttpCommandResult <Step>("", result, null)));
}
}
public async Task <ActionResult> RolesCheck(FormCollection form)
{
var UserName = (String)form["UserName"];
var pools = await this.Svc.GetPoolsAsync();
var ClaimsUtil = new ClaimsUtility(Auth, await this.Svc.GetPoolsAsync(), Properties.Settings.Default.AdministratorADGroup);
var identity = ClaimsUtil.BuildClaimsIdentityForUser(UserName);
ViewBag.User = new ClaimsPrincipal(identity);
return(View("Roles", pools));
}
public async Task <IActionResult> Put(string name, [FromBody] UpdateGlobalValueVM globalValue)
{
var result = await Mediator.Send(new UpdateGlobalValueCommand()
{
Description = globalValue.Description,
Name = name,
Value = globalValue.Value,
CreatedBy = ClaimsUtility.GetId(User)
});
return(Ok(new HttpCommandResult <GlobalValue>("//api//global-values//" + result.ObjectRefId, result, result.Result)));
}
public async Task <IActionResult> Post([FromBody] CreateGlobalValueVM globalValue)
{
var result = await Mediator.Send(new CreateGlobalValueCommand()
{
Description = globalValue.Description,
Name = globalValue.Name,
Type = globalValue.Type.ToLower(),
Value = globalValue.Value,
CreatedBy = ClaimsUtility.GetId(User)
});
return(Ok(new HttpCommandResult <GlobalValue, GlobalValueVM>("//api//global-values//" + result.ObjectRefId, result, Mapper.Map <GlobalValueVM>(result.Result))));
}
private IEnumerable <Claim> BuildClaims(IOwinContext owinContext, IRequest request)
{
// Pass appname through jwt token to client, so that when client establishes connection with service, it will also create a corresponding AppName-connection
yield return(new Claim(Constants.ClaimType.AppName, _appName));
var user = owinContext.Authentication?.User;
var userId = _provider?.GetUserId(request);
var claims = ClaimsUtility.BuildJwtClaims(user, userId, GetClaimsProvider(owinContext));
foreach (var claim in claims)
{
yield return(claim);
}
}
private IEnumerable <Claim> BuildClaims(HostContext context)
{
// Pass appname through jwt token to client, so that when client establishes connection with service, it will also create a corresponding AppName-connection
yield return(new Claim(Constants.ClaimType.AppName, _appName));
var user = new Owin.OwinContext(context.Environment).Authentication?.User;
var userId = UserIdProvider?.GetUserId(context.Request);
var claims = ClaimsUtility.BuildJwtClaims(user, userId, null);
foreach (var claim in claims)
{
yield return(claim);
}
}
private IEnumerable <Claim> BuildClaims(IOwinContext owinContext, IRequest request)
{
// Pass appname through jwt token to client, so that when client establishes connection with service, it will also create a corresponding AppName-connection
yield return(new Claim(Constants.ClaimType.AppName, _appName));
var user = owinContext.Authentication?.User;
var userId = _provider?.GetUserId(request);
var claims = ClaimsUtility.BuildJwtClaims(user, userId, GetClaimsProvider(owinContext), _serverName, _mode, _enableDetailedErrors, _endpointsCount, _maxPollInterval, IsDiagnosticClient(owinContext));
yield return(new Claim(Constants.ClaimType.Version, AssemblyVersion));
foreach (var claim in claims)
{
yield return(claim);
}
}
public async Task <NegotiationResponse> NegotiateAsync(string hubName, NegotiationOptions negotiationOptions, CancellationToken cancellationToken = default)
{
negotiationOptions ??= NegotiationOptions.Default;
var httpContext = negotiationOptions.HttpContext;
var userId = negotiationOptions.UserId;
var claims = negotiationOptions.Claims;
var isDiagnosticClient = negotiationOptions.IsDiagnosticClient;
var enableDetailedErrors = negotiationOptions.EnableDetailedErrors;
var lifetime = negotiationOptions.TokenLifetime;
try
{
if (cancellationToken == default && httpContext != null)
{
cancellationToken = httpContext.RequestAborted;
}
var candidateEndpoints = _serviceEndpointManager.GetEndpoints(hubName);
var selectedEndpoint = _router.GetNegotiateEndpoint(httpContext, candidateEndpoints);
var provider = _serviceEndpointManager.GetEndpointProvider(selectedEndpoint);
Func <IEnumerable <Claim> > claimProvider = null;
if (claims != null)
{
claimProvider = () => claims;
}
var claimsWithUserId = ClaimsUtility.BuildJwtClaims(httpContext?.User, userId: userId, claimProvider, enableDetailedErrors: enableDetailedErrors, isDiagnosticClient: isDiagnosticClient);
var tokenTask = provider.GenerateClientAccessTokenAsync(hubName, claimsWithUserId, lifetime);
await tokenTask.OrTimeout(cancellationToken, Timeout, GeneratingTokenTaskDescription);
return(new NegotiationResponse
{
Url = provider.GetClientEndpoint(hubName, null, null),
AccessToken = tokenTask.Result
});
}
catch (Exception e) when(e is OperationCanceledException || e is TimeoutException)
{
throw new AzureSignalRException(ErrorMsg, e);
}
}
public async Task <IActionResult> UnencryptStepSecret(Guid id, string fieldName, string type)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
return(Ok(await Mediator.Send(new UnencryptStepFieldQuery()
{
StepId = id,
FieldName = fieldName,
UserId = ClaimsUtility.GetId(User),
Type = type.ToLower()
})));
}
catch (BaseException e)
{
Logger.LogError(e.Message);
return(BadRequest(e.ToExceptionResult(stopwatch.ElapsedMilliseconds)));
}
}
public async Task <IActionResult> GetNextStep(AssignStepCommand command)
{
try
{
command.BotId = new Guid(ClaimsUtility.GetId(User));
var result = await Mediator.Send(command);
if (result.ObjectRefId != "")
{
return(Ok(new HttpCommandResult <Step>("step", result, result.Result)));
}
else
{
return(Ok(new HttpCommandResult <Step>("", result, null)));
}
}
catch (BotKeyAssignmentException e)
{
return(BadRequest(command.BotId + " has been disabled for assignment."));
}
}
public async Task <IActionResult> Create(CreateStepCommand command, bool?wait_for_completion, string timeout = "30s")
{
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
command.CreatedBy = ClaimsUtility.GetId(User);
var result = await Mediator.Send(command);
Step step = (await Mediator.Send(new GetEntityQuery <Step>()
{
Expression = s => s.Id == new Guid(result.ObjectRefId),
Exclude = (s) => s.Journal
})).Result;
if (wait_for_completion.HasValue && wait_for_completion.Value)
{
var ms = DateTimeMathsUtility.GetMs(timeout);
while (!StepStatuses.IsCompleteStatus(step.Status) && stopwatch.ElapsedMilliseconds < ms)
{
step = (await Mediator.Send(new GetEntityQuery <Step>()
{
Expression = s => s.Id == new Guid(result.ObjectRefId)
})).Result;
}
}
return(Ok(new HttpCommandResult <Step>("step", result, step)));
}
catch (BaseException e)
{
Logger.LogError(e.Message);
stopwatch.Stop();
return(BadRequest(e.ToExceptionResult(stopwatch.ElapsedMilliseconds)));
}
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (Auth.Authenticate(model.UserName, model.Password))
{
// Build the set of claims for the authenticated user for the various Pools & application administrator
var ClaimsUtil = new ClaimsUtility(Auth, await this.Svc.GetPoolsAsync(), Properties.Settings.Default.AdministratorADGroup);
var identity = ClaimsUtil.BuildClaimsIdentityForUser(model.UserName);
await SignInAsync(identity, false);
return(RedirectToLocal(returnUrl));
}
else
{
ModelState.AddModelError("", Properties.Resources.InvalidUserNameOrPassword);
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> AddLog(Guid id, AppendStepLogVM command)
{
var appendCommand = new AppendStepLogCommand()
{
StepId = id,
Log = command.Log,
CreatedBy = ClaimsUtility.GetId(User)
};
var result = await Mediator.Send(appendCommand);
if (result.ObjectRefId != "")
{
var resolvedStep = (await Mediator.Send(new GetEntityQuery <Step>()
{
Expression = s => s.Id == new Guid(result.ObjectRefId)
})).Result;
return(Ok(new HttpCommandResult <Step>("step", result, resolvedStep)));
}
else
{
return(Ok(new HttpCommandResult <Step>("", result, null)));
}
}
public async Task <IActionResult> Register(CreateBotKeyCommand command)
{
if (!_clusterState.GetSettings.AllowAutoRegistration)
{
if (ClaimsUtility.GetId(User) == null)
{
return(Unauthorized());
}
}
var keyCreationResult = await Mediator.Send(command);
var key = await Mediator.Send(new GetEntityQuery <BotKey>()
{
Expression = bk => bk.Id == new Guid(keyCreationResult.ObjectRefId)
});
return(Ok(new HttpCommandResult <NewBotKeyVM>("", keyCreationResult, new NewBotKeyVM()
{
// BotName = key.Result.BotName,
IdKey = keyCreationResult.ObjectRefId
})));
}
public async Task <IActionResult> Post(CreateUserVM request)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var command = new CreateUserCommand()
{
Username = request.Username,
Password = request.Password,
CreatedBy = ClaimsUtility.GetId(User)
};
var result = await Mediator.Send(command);
return(Ok(new HttpCommandResult <User>("user", result, null)));
}
catch (BaseException e)
{
Logger.LogError(e.Message);
stopwatch.Stop();
return(BadRequest(e.ToExceptionResult(stopwatch.ElapsedMilliseconds)));
}
}
public async Task GenerateClientEndpoint(string userId, Claim[] claims, string appName)
{
var endpoints = FakeEndpointUtils.GetFakeEndpoint(3).ToArray();
var routerMock = new Mock <IEndpointRouter>();
routerMock.SetupSequence(router => router.GetNegotiateEndpoint(null, endpoints))
.Returns(endpoints[0])
.Returns(endpoints[1])
.Returns(endpoints[2]);
var router = routerMock.Object;
var provider = new ServiceCollection().AddSignalRServiceManager()
.Configure <ServiceManagerOptions>(o =>
{
o.ApplicationName = appName;
o.ServiceEndpoints = endpoints;
})
.AddSingleton(router).BuildServiceProvider();
var negotiateProcessor = provider.GetRequiredService <NegotiateProcessor>();
for (int i = 0; i < 3; i++)
{
var negotiationResponse = await negotiateProcessor.NegotiateAsync(HubName, null, userId, claims, _tokenLifeTime);
var tokenString = negotiationResponse.AccessToken;
var token = JwtTokenHelper.JwtHandler.ReadJwtToken(tokenString);
string expectedToken = JwtTokenHelper.GenerateJwtBearer(ClientEndpointUtils.GetExpectedClientEndpoint(HubName, appName, endpoints[i].Endpoint), ClaimsUtility.BuildJwtClaims(null, userId, () => claims), token.ValidTo, token.ValidFrom, token.ValidFrom, endpoints[i].AccessKey);
Assert.Equal(ClientEndpointUtils.GetExpectedClientEndpoint(HubName, appName, endpoints[i].Endpoint), negotiationResponse.Url);
Assert.Equal(expectedToken, tokenString);
}
}
public async Task <IActionResult> CompleteAssignment(Guid id, CompleteStepVM commandVM)
{
//TODO check that the bot who is updating is the same as the one who was assigned
if (commandVM.Status == StepStatuses.Suspended)
{
var result = await Mediator.Send(new SuspendStepCommand()
{
StepId = id,
CreatedBy = ClaimsUtility.GetId(User),
SuspendedUntil = DateTime.Now.AddMilliseconds(_option.DefaultSuspensionTimeMs)
});
if (result.ObjectRefId != "")
{
var resolvedStep = (await Mediator.Send(new GetEntityQuery <Step>()
{
Expression = s => s.Id == new Guid(result.ObjectRefId)
})).Result;
return(Ok(new HttpCommandResult <Step>("step", result, resolvedStep)));
}
else
{
return(Ok(new HttpCommandResult <Step>("", result, null)));
}
}
else
{
var completeStepCommand = new CompleteStepCommand()
{
Id = id,
Status = commandVM.Status.ToLower(),
StatusCode = commandVM.StatusCode,
Log = commandVM.Logs,
Outputs = commandVM.Outputs,
CreatedBy = ClaimsUtility.GetId(User),
BotId = new Guid(ClaimsUtility.GetId(User))
};
try
{
var result = await Mediator.Send(completeStepCommand);
if (result.ObjectRefId != "")
{
var resolvedStep = (await Mediator.Send(new GetEntityQuery <Step>()
{
Expression = s => s.Id == new Guid(result.ObjectRefId)
})).Result;
return(Ok(new HttpCommandResult <Step>("step", result, resolvedStep)));
}
else
{
return(Ok(new HttpCommandResult <Step>("", result, null)));
}
}
catch (DuplicateStepUpdateException exception)
{
return(Ok(new HttpCommandResult <Step>("step", new CommandResult()
{
Type = CommandResultTypes.None
}, (await Mediator.Send(new GetEntityQuery <Step>()
{
Expression = s => s.Id == id
})).Result)));
}
}
}
