protected override AliceResponse CreateResponse(AliceRequest request)
{
AliceResponse resp = base.CreateResponse(request);
resp.Response.EndSession = true;
return(resp);
}
public Task Post()
{
CreateTimer();
using var reader = new StreamReader(Request.Body);
var body = reader.ReadToEnd();
var aliceRequest = JsonConvert.DeserializeObject <AliceRequest>(body, ConverterSettings);
var userId = aliceRequest.Session.UserId;
var token = ExtractToken(Request);
Console.WriteLine(JsonConvert.SerializeObject(aliceRequest, ConverterSettings));
Console.WriteLine("Token: " + token);
if (token.IsNullOrEmpty() && !aliceRequest.HasScreen())
{
// auth needed
var authResponse = new AliceResponse(aliceRequest).ToAuthorizationResponse();
var stringAuthResponse = JsonConvert.SerializeObject(authResponse, ConverterSettings);
return(Response.WriteAsync(stringAuthResponse));
}
var session = GetOrCreateSession(userId, token, aliceRequest.HasScreen());
var aliceResponse = session.HandleRequest(aliceRequest);
var stringResponse = JsonConvert.SerializeObject(aliceResponse, ConverterSettings);
Console.WriteLine(stringResponse);
return(Response.WriteAsync(stringResponse));
}
public Task Post()
{
using var reader = new StreamReader(Request.Body);
var body = reader.ReadToEnd();
var request = JsonConvert.DeserializeObject<AliceRequest>(body, Utils.ConverterSettings);
if (request == null)
{
Console.WriteLine("Request is null:");
Console.WriteLine(body);
return Response.WriteAsync("Request is null");
}
if (request.IsPing())
{
var pong = new AliceResponse(request).ToPong();
var pongResponse = JsonConvert.SerializeObject(pong, Utils.ConverterSettings);
return Response.WriteAsync(pongResponse);
}
Console.WriteLine($"REQUEST:\n{JsonConvert.SerializeObject(request, Utils.ConverterSettings)}\n");
var response = _aliceService.HandleRequest(request);
var stringResponse = JsonConvert.SerializeObject(response, Utils.ConverterSettings);
Console.WriteLine($"RESPONSE:\n{stringResponse}\n");
return Response.WriteAsync(stringResponse);
}
protected override AliceResponse CreateResponse(AliceRequest request)
{
var response = new AliceResponse(request);
Example example = FindExample(request.Request.Command);
request.State.Session.Step = Step.None;
response.Response.Text = example.Description + " По кнопке подробная видеоинструкция о том, как это сделать.";
response.Response.Tts = example.DescriptionTts + " - По кнопке подробная видеоинструкция о том, как это сделать.";
response.Response.Buttons = new List <Button>
{
new Button
{
Title = "Открыть видео",
Hide = false,
Url = example.Link
}
};
var suggests = new [] { "Добавить вебхук", "Примеры", "Список", "Выход" };
response.Response.Buttons.AddRange(suggests.Select(x => new Button {
Title = x
}));
return(response);
}
public AliceResponse HandleRequest(AliceRequest aliceRequest, string token)
{
SaveWebhooksToState(aliceRequest, token);
// respond
AliceResponse response = null;
try
{
if (!Modifiers.Any(modifier => modifier.Run(aliceRequest, out response)))
{
throw new NotSupportedException("No default modifier");
}
}
catch (Exception e)
{
Console.WriteLine("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ERROR");
Console.WriteLine(e);
response = new AliceResponse(aliceRequest)
{
Response = new Response
{
Text = "Произошла какая-то ошибка на сервере навыка, разработчик уже уведомлён. " +
"Приносим извинения."
}
};
Console.WriteLine("");
}
return(response);
}
public Task Post()
{
using var reader = new StreamReader(Request.Body);
string body = reader.ReadToEnd();
var aliceRequest = JsonConvert.DeserializeObject <AliceRequest>(body, ConverterSettings);
if (aliceRequest?.IsPing() == true)
{
AliceResponseBase <UserState, SessionState> pongResponse = new AliceResponse(aliceRequest).ToPong();
string stringPong = JsonConvert.SerializeObject(pongResponse, ConverterSettings);
return(Response.WriteAsync(stringPong));
}
string userId = aliceRequest.Session.UserId;
string token = ExtractToken(Request);
Console.WriteLine($"REQUEST FROM {userId}:\n{body}\n");
AliceResponse aliceResponse = _aliceService.HandleRequest(aliceRequest, token);
string stringResponse = JsonConvert.SerializeObject(aliceResponse, ConverterSettings);
Console.WriteLine($"RESPONSE:\n{stringResponse}\n");
return(Response.WriteAsync(stringResponse));
}
protected override AliceResponse CreateResponse(AliceRequest request)
{
AliceResponse response = base.CreateResponse(request);
ModifierHelp.AddExamplesTo(response);
return(response);
}
protected override AliceResponse CreateResponse(AliceRequest request)
{
AliceResponse response = base.CreateResponse(request);
bool isOutsideCommand = !request.Request.Command.IsNullOrEmpty() && request.Session?.New == true;
response.Response.EndSession = request.State.Session.Step != Step.AwaitWebhookResponse && isOutsideCommand;
return(response);
}
public void Alice_GetResponseFromPing_Success()
{
string requestJson = File.ReadAllText(TestsConstants.Assets.AliceRequestPingFilePath);
var aliceRequest = JsonSerializer.Deserialize <AliceRequest <object, object, object> >(requestJson);
var response = new AliceResponse(aliceRequest, string.Empty);
Assert.NotNull(response);
}
public IAliceResponse Handle(IAliceRequest request)
{
IAliceResponse response = new AliceResponse();
response.Message = "Booking service could not serve this request.";
return(response);
}
private AliceResponse Exit(AliceRequest request)
{
var phrase = new Phrase("Выхожу из игры. Возвращайся!");
AliceResponse response = phrase.Generate(request);
response.Response.EndSession = true;
return(response);
}
public AliceResponse HandleRequest(AliceRequest aliceRequest, State state)
{
AliceResponse response = null;
if (!Services.Any(Service => Service.Run(aliceRequest, state, out response)))
{
throw new NotSupportedException("No default Service");
}
return(response);
}
internal AliceResponse HandleRequest(AliceRequest aliceRequest)
{
AliceResponse response = null;
if (!Modiffiers.Any(modifier => modifier.Run(aliceRequest, State, out response)))
{
throw new NotSupportedException("No default modifier");
}
return(response);
}
public bool Run(AliceRequest request, State state, out AliceResponse response)
{
if (!Check(request, state))
{
response = null;
return(false);
}
response = CreateResponse(request, state);
return(true);
}
protected override AliceResponse CreateResponse(AliceRequest request)
{
AliceResponse response = base.CreateResponse(request);
if (request.State.User.Webhooks.Count == 0)
{
ModifierHelp.AddExamplesTo(response);
}
return(response);
}
public IAliceResponse Handle(IAliceRequest aliceRequest)
{
IAliceResponse response = new AliceResponse();
IList <Room> rooms = _roomRepository.List();
AliceListRoomParser parser = new AliceListRoomParser();
response.Message = parser.Parse(rooms);
return(response);
}
protected override AliceResponse CreateResponse(AliceRequest request)
{
AliceResponse response = base.CreateResponse(request);
if (request.State.Session.Step == Step.None && request.HasScreen())
{
AddExamplesTo(response);
}
return(response);
}
private IAliceResponse AddToUnhandled()
{
UnhandledMessage unhandledMessage = new UnhandledMessage();
unhandledMessage.UserMessage = _aliceRequest.RequestMessage;
UnhandledMessageRepository repository = new UnhandledMessageRepository("UnhandledMessages.json");
repository.Add(unhandledMessage);
IAliceResponse response = new AliceResponse();
response.Message = "I did not get it but noted down. I will learn it soon. Show <a {aliceRequestAct}>Help</a>";
return response;
}
public AliceResponse HandleRequest(AliceRequest aliceRequest)
{
_lastActive = DateTime.Now;
AliceResponse response = null;
if (!Modifiers.Any(modifier => modifier.Run(aliceRequest, _state, out response)))
{
throw new NotSupportedException("No default modifier");
}
return(response);
}
public static void AddExamplesTo(AliceResponse response)
{
response.Response.Buttons ??= new List <Button>();
response.Response.Buttons.AddRange(
Example.List().Select(
x => new Button
{
Title = x.Title,
Hide = false
}
)
);
}
public static AliceResponse CreateAliceResponse(ProcessingResult result, Session session, Func <int, int> variantSelector)
{
var responseArgs = GetResponseArgs(result);
var response = CreateResponse(responseArgs, result.CultureInfo, variantSelector);
var aliceResponse = new AliceResponse()
{
Response = response,
Session = session,
Version = "1.0"
};
return(aliceResponse);
}
public IAliceResponse Handle(IAliceRequest request)
{
IAliceResponse response = new AliceResponse();
DateTime date = DateTime.Now;
if (request.Parameters.Count == 3)
{
date = Utility.ConvertToDate(request.Parameters[2].Value);
}
response.Message = ListBookings(date, string.Empty, request.UserProfile);
return(response);
}
private AliceResponse CreateResponse(AliceRequest request, State state)
{
var response = new AliceResponse(request);
var simple = Respond(request, state);
response.Response.Text = simple.Text;
response.Response.Tts = string.IsNullOrEmpty(simple.Tts) ? simple.Text : simple.Tts;
if (simple.Buttons != null)
{
response.Response.Buttons = simple.Buttons.Select(t => new Button {
Title = t
}).ToList();
}
return(response);
}
internal AliceResponse HandleRequest(AliceRequest aliceRequest, ref State state)
{
_state.Step = state.Step;
AliceResponse response = null;
if (!Modifiers.Any(modifier => modifier.Run(aliceRequest, _state, schedulesRepository, out response)))
{
throw new NotSupportedException("No default modifier");
}
_state.User = usersRepository.UpdateUser(_state.User);
state = _state;
return(response);
}
public Task AliceWebhook()
{
Console.WriteLine("Alice request got");
try
{
// read request
string body;
using (var reader = new StreamReader(Request.Body)) body = reader.ReadToEnd();
// Console.WriteLine("http got: " + body);
var aliceRequest = JsonConvert.DeserializeObject <AliceRequest>(body, Utils.ConverterSettings);
Response.Headers.Add("Content-Type", "application/json");
//var userId = aliceRequest.Session.UserId;
// ping
if (aliceRequest.Request.OriginalUtterance == "ping")
{
var pong = new AliceResponse
{
Response = new ResponseModel
{
Text = "pong"
},
Session = aliceRequest.Session
};
return(Response.WriteAsync(JsonConvert.SerializeObject(pong, Utils.ConverterSettings)));
}
// parse request
Console.WriteLine($"\nRequest got: {body}");
// return response
var aliceResponse = HandleRequest(aliceRequest);
var stringResponse = JsonConvert.SerializeObject(aliceResponse, Utils.ConverterSettings);
Console.WriteLine($"\nResponse: {stringResponse}");
return(Response.WriteAsync(stringResponse));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void AliceResponse_KeepSession_HasSession()
{
var aliceRequest = new AliceRequest <object, TestSession, object>
{
State = new AliceStateModel <TestSession, object>
{
Session = new TestSession()
{
TestProperty = 1
}
}
};
var aliceResponse = new AliceResponse <TestSession, object>(aliceRequest, string.Empty);
Assert.NotNull(aliceResponse.SessionState);
Assert.Equal(aliceRequest.State.Session.TestProperty, aliceResponse.SessionState.TestProperty);
}
public IAliceResponse Process()
{
IAliceResponse response;
if (string.IsNullOrEmpty(_command.ServerAction))
{
response = new AliceResponse();
response.ActionToPerform = _command.ClientAction;
response.Message = _command.GetRandomSuccessResponse();
}
else
{
IAliceRequest request = CreateRequest();
response = _handler.Handle(request);
}
return(response);
}
public Task Post()
{
using var reader = new StreamReader(Request.Body);
string body = reader.ReadToEnd();
var request = JsonConvert.DeserializeObject <AliceRequest>(body, ConverterSettings);
if (request == null)
{
Console.WriteLine("Request is null:");
Console.WriteLine(body);
return(Response.WriteAsync("Request is null"));
}
if (request.IsPing())
{
AliceResponseBase <UserState, SessionState> pong = new AliceResponse(request).ToPong();
string pongResponse = JsonConvert.SerializeObject(pong, ConverterSettings);
return(Response.WriteAsync(pongResponse));
}
Console.WriteLine($"REQUEST:\n{JsonConvert.SerializeObject(request, ConverterSettings)}\n");
try
{
AliceResponse response = _aliceService.HandleRequest(request);
string stringResponse = JsonConvert.SerializeObject(response, ConverterSettings);
Console.WriteLine($"RESPONSE:\n{stringResponse}\n");
return(Response.WriteAsync(stringResponse));
}
catch (Exception e)
{
Console.WriteLine(e);
return(Response.WriteAsync(
JsonConvert.SerializeObject(
new Phrase("Возникла какая-то ошибка, разработчик уже уведомлён").Generate(request),
ConverterSettings
)
));
}
}
protected virtual AliceResponse CreateResponse(AliceRequest request, State state)
{
var response = new AliceResponse(request);
var simple = Respond(request, state);
if (simple.IsAuthorize)
{
return(response.ToAuthorizationResponse());
}
response.Response.Text = simple.Text;
response.Response.Tts = string.IsNullOrEmpty(simple.Tts) ? simple.Text : simple.Tts;
if (simple.Buttons != null)
{
response.Response.Buttons = simple.Buttons.Select(t => new Button {
Title = t
}).ToList();
}
return(response);
}
public static AliceResponse MakeResponse(AliceRequest aliceRequest, BoxesContext dataBase)
{
var user = dataBase.GetUserById(aliceRequest.session.session_id);
var session = new SessionResponse
{
session_id = aliceRequest.session.session_id,
message_id = aliceRequest.session.message_id,
user_id = aliceRequest.session.user_id
};
var aliceResponse = new AliceResponse {
session = session
};
aliceResponse.response.text = GetAnswer(aliceRequest, dataBase, user);
aliceResponse.response.tts = aliceResponse.response.text;
aliceResponse.response.end_session = false;
return(aliceResponse);
}
