private static string HandleTickRequest(APIRequest req, ServerState serverState)
{
var scenario = serverState.Scenarios[req.ScenarioName][req.ScenarioInstance];
if (req.Method == HTTPMethod.GET)
{
return(JsonConvert.SerializeObject(scenario.Characters.First().Tick));
}
if (req.Method == HTTPMethod.POST)
{
int ticks = 0;
if (string.IsNullOrEmpty(req.RequestBody))
{
foreach (var rpc in scenario.Characters)
{
rpc.Update();
}
}
else
{
try
{
ticks = JsonConvert.DeserializeObject <int>(req.RequestBody);
foreach (var rpc in scenario.Characters)
{
for (int i = 0; i < ticks; i++)
{
rpc.Update();
}
}
}
catch (Exception)
{
return(JsonConvert.SerializeObject(APIErrors.ERROR_EXCEPTION_UPDATE));
}
}
return(JsonConvert.SerializeObject(string.Format("Updated {0} ticks!", ticks)));
}
return(JsonConvert.SerializeObject("Error: Invalid Request"));
}
private static string HandleDecisionsRequest(APIRequest req, ServerState serverState)
{
if (req.Method != HTTPMethod.GET)
{
return(JsonConvert.SerializeObject("Error: Invalid operation"));
}
List <DecisionDTO> resultDTO = new List <DecisionDTO>();
var scenario = serverState.Scenarios[req.ScenarioName][req.ScenarioInstance];
var rpc = scenario.Characters.Where(r => r.CharacterName.ToString().EqualsIgnoreCase(req.CharacterName)).FirstOrDefault();
var decisions = rpc?.Decide();
if (decisions.Any())
{
foreach (var d in decisions)
{
string utterance = null;
if (string.Equals(d.Key.ToString(), IATConsts.DIALOG_ACTION_KEY, StringComparison.OrdinalIgnoreCase))
{
try
{
utterance = scenario.GetDialogAction(d, out utterance).Utterance;
}
catch (Exception)
{
return(JsonConvert.SerializeObject(string.Format(APIErrors.ERROR_UNKOWN_SPEAK_ACTION, d)));
}
utterance = rpc.ProcessWithBeliefs(utterance);
}
resultDTO.Add(new DecisionDTO {
Action = d.Name.ToString(), Target = d.Target.ToString(), Utterance = utterance, Utility = d.Utility
});
}
}
return(JsonConvert.SerializeObject(resultDTO));
}
private static string HandleKeyRequest(APIRequest req, ServerState serverState)
{
return(JsonConvert.SerializeObject(serverState.ScenarioKeys[req.ScenarioName]));
}
public void Run()
{
ServerState state = new ServerState();
try
{
server = new HttpListener();
server.Prefixes.Add("http://*:" + this.Port + "/");
server.Prefixes.Add("https://*:" + this.HTTPSPort + "/");
server.Start();
OnServerEvent(this, new ServerEventArgs
{
Message = "FAtiMA server started on port '" + this.Port + "'",
Type = MessageTypes.Status
});
}
catch (Exception ex)
{
server.Close();
OnServerEvent(this, new ServerEventArgs
{
Message = ex.Message,
Type = MessageTypes.Error
});
return;
}
while (true)
{
HttpListenerContext context = server.GetContext();
string responseJson = "";
try
{
var rq = new APIRequest(context.Request);
if (!string.IsNullOrEmpty(rq.ErrorMessage))
{
responseJson = JsonConvert.SerializeObject(rq.ErrorMessage);
OnServerEvent(this, new ServerEventArgs
{
Message = "Error: " + responseJson,
Type = MessageTypes.Error
});
}
else
{
OnServerEvent(this, new ServerEventArgs
{
Message = rq.Method + " request: " + context.Request.RawUrl + " [" + DateTime.Now + "]",
Type = MessageTypes.Request
});
if (!rq.Resource.IsHttpMethodValid(rq))
{
responseJson = JsonConvert.SerializeObject(APIErrors.ERROR_INVALID_HTTP_METHOD);
}
else if (!rq.Resource.HasAuthorization(rq.Key, rq.ScenarioName, state))
{
responseJson = JsonConvert.SerializeObject(APIErrors.ERROR_ACCESS_DENIED);
}
else
{
responseJson = rq.Resource.Execute(rq, state);
}
OnServerEvent(this, new ServerEventArgs
{
Message = "Result: " + responseJson,
Type = MessageTypes.Output
});
}
}catch (Exception ex)
{
responseJson = JsonConvert.SerializeObject(ex.Message);
}
HttpListenerResponse response = context.Response;
response.ContentType = "application/json";
byte[] buffer = Encoding.UTF8.GetBytes(responseJson);
response.ContentLength64 = buffer.Length;
Stream st = response.OutputStream;
st.Write(buffer, 0, buffer.Length);
context.Response.Close();
}
}
