public void TestParseSingleClientTarget(string value, int expectedClientId)
{
var target = CommandTargetCollection.Parse(value);
Assert.True(target.IsSingleClient(out var clientId));
Assert.Equal(expectedClientId, clientId);
}
private void WriteAudience(AudienceCollection audienceCollection)
{
_xmlWriter.WriteStartElement(XmlNames.Audience);
if (audienceCollection.IsAll)
{
_xmlWriter.WriteStartElement("AllClients");
_xmlWriter.WriteEndElement();
}
if (audienceCollection.IncludesServer)
{
_xmlWriter.WriteStartElement("Server");
_xmlWriter.WriteEndElement();
}
if (!audienceCollection.IsAll)
{
_xmlWriter.WriteStartElement("Clients");
var targets = new CommandTargetCollection(audienceCollection);
_xmlWriter.WriteAttributeString("id", targets.ToString());
_xmlWriter.WriteEndElement();
}
_xmlWriter.WriteEndElement();
}
public void TestParseServer(string value)
{
var target = CommandTargetCollection.Parse(value);
Assert.Empty(target);
Assert.True(target.TargetsServer);
}
public async Task ExecuteCommand(string path, [FromServices] IMazeRequestExecuter requestExecuter,
[FromServices] ICommandDistributer commandDistributer)
{
Request.Headers.TryGetValue("CommandTarget", out var targetHeader);
CommandTargetCollection targets;
try
{
targets = CommandTargetCollection.Parse(targetHeader.ToString());
}
catch (ArgumentException)
{
Response.StatusCode = StatusCodes.Status400BadRequest;
return;
}
if (targets.TargetsServer)
{
var mazeContext = new HttpMazeContextWrapper(HttpContext)
{
Request = { Path = "/" + path }
};
await requestExecuter.Execute(mazeContext, null /* TODO */);
}
else
{
if (!targets.IsSingleClient(out var clientId))
{
await RestError(BusinessErrors.Commander.SingleCommandTargetRequired).ExecuteResultAsync(ControllerContext);
return;
}
HttpResponseMessage response;
try
{
response = await commandDistributer.Execute(Request.ToHttpRequestMessage(path), clientId, User.GetAccountId(),
HttpContext.RequestAborted);
}
catch (ClientNotFoundException)
{
await RestError(BusinessErrors.Commander.ClientNotFound).ExecuteResultAsync(ControllerContext);
return;
}
catch (Exception)
{
await RestError(BusinessErrors.Commander.ClientNotFound).ExecuteResultAsync(ControllerContext);
return;
}
await response.CopyToHttpResponse(Response);
}
}
private void CompareTargetCollections(CommandTargetCollection actual, CommandTargetCollection expected)
{
Assert.Equal(expected.TargetsServer, actual.TargetsServer);
Assert.Equal(expected.Count, actual.Count);
for (var i = 0; i < expected.Count; i++)
{
var commandTarget = expected[i];
var actualCommandTarget = actual[i];
Assert.Equal(commandTarget.Type, actualCommandTarget.Type);
Assert.Equal(commandTarget.From, actualCommandTarget.From);
Assert.Equal(commandTarget.To, actualCommandTarget.To);
}
}
public AudienceCollection GetAudience()
{
var ns = Xml.Root.GetDefaultNamespace().NamespaceName;
var audienceNode = Xml.Root.Elements(XName.Get(XmlNames.Audience, ns));
var result = new AudienceCollection();
foreach (var audienceElement in audienceNode.Elements())
{
switch (audienceElement.Name.LocalName)
{
case "AllClients":
result.IsAll = true;
result.Clear();
break;
case "Server":
result.IncludesServer = true;
break;
case "Clients":
if (result.IsAll)
{
continue;
}
var ids = GetAttributeValue(audienceElement, "id");
if (ids != null)
{
var targets = CommandTargetCollection.Parse(ids);
result.AddRange(targets);
}
break;
}
}
return(result);
}
public void TestSimplifyCollection(string origin, string expectedResult)
{
var collection = CommandTargetCollection.Parse(origin);
Assert.Equal(expectedResult, collection.ToString());
}
public void TestParseMixedData(string value, CommandTargetCollection expectedTarget)
{
var target = CommandTargetCollection.Parse(value);
CompareTargetCollections(target, expectedTarget);
}
public void TestParseClientRanges(string value, CommandTargetCollection expectedTarget)
{
var target = CommandTargetCollection.Parse(value);
CompareTargetCollections(target, expectedTarget);
}
public Task Execute(MazeRequest request, CommandTargetCollection targets,
CommandExecutionPolicy executionPolicy) =>
throw new NotImplementedException();
