/// <summary>
/// TODO: Turn request validation back on before going live.
/// </summary>
public override bool OnRequestValidation(
SpeechletRequestValidationResult result,
DateTime referenceTimeUtc,
SpeechletRequestEnvelope requestEnvelope)
{
return(true);
}
/// <summary>
/// Verifies request timestamp
/// </summary>
public static bool VerifyRequestTimestamp(SpeechletRequestEnvelope requestEnvelope, DateTime referenceTimeUtc)
{
// verify timestamp is within tolerance
var diff = referenceTimeUtc - requestEnvelope.Request.Timestamp;
Debug.WriteLine("Request was timestamped {0:0.00} seconds ago.", diff.TotalSeconds);
return(Math.Abs((decimal)diff.TotalSeconds) <= Sdk.TIMESTAMP_TOLERANCE_SEC);
}
public async Task <SpeechletResponseEnvelope> GetPostRequest(SpeechletRequestEnvelope requestMsg)
{
HttpResponseMessage response = await server.CreateRequest("/Alexa")
.And(request => request.Content = new ObjectContent(typeof(SpeechletRequestEnvelope), requestMsg, new JsonMediaTypeFormatter()))
.PostAsync();
return(await response.Content.ReadAsAsync <SpeechletResponseEnvelope>());
}
/// <summary>
///
/// </summary>
/// <param name="requestEnvelope"></param>
/// <returns></returns>
public async Task <string> DoProcessRequestAsync(SpeechletRequestEnvelope requestEnvelope)
{
Session session = requestEnvelope.Session;
Context context = requestEnvelope.Context;
SpeechletResponse response = null;
switch (requestEnvelope.Request)
{
case LaunchRequest request:
{
if (requestEnvelope.Session.IsNew)
{
await OnSessionStartedAsync(requestEnvelope);
}
response = await OnLaunchAsync(request, session, context);
}
break;
case AudioPlayerRequest request:
{
response = await OnAudioIntentAsync(request, session, context);
}
break;
// process intent request
case IntentRequest request:
{
// Do session management prior to calling OnSessionStarted and OnIntentAsync
// to allow dev to change session values if behavior is not desired
DoSessionManagement(request, session);
if (requestEnvelope.Session.IsNew)
{
await OnSessionStartedAsync(requestEnvelope);
}
response = await OnIntentAsync(request, session, context);
}
break;
// process session ended request
case SessionEndedRequest request:
{
await OnSessionEndedAsync(request, session, context);
}
break;
}
if (response == null)
{
return new SpeechletResponseEnvelope
{
Version = requestEnvelope.Version,
Response = new SpeechletResponse()
{
ShouldEndSession = null
}
}
}
public async Task <SpeechletRequestEnvelope> GetRequestAsync(string content, string chainUrl, string signature)
{
var validationResult = SpeechletRequestValidationResult.OK;
if (string.IsNullOrEmpty(chainUrl))
{
validationResult |= SpeechletRequestValidationResult.NoCertHeader;
}
if (string.IsNullOrEmpty(signature))
{
validationResult |= SpeechletRequestValidationResult.NoSignatureHeader;
}
// attempt to verify signature only if we were able to locate certificate and signature headers
if (validationResult == SpeechletRequestValidationResult.OK)
{
var alexaBytes = Encoding.UTF8.GetBytes(content);
if (!await SpeechletRequestSignatureVerifier.VerifyRequestSignatureAsync(alexaBytes, signature, chainUrl))
{
validationResult |= SpeechletRequestValidationResult.InvalidSignature;
}
}
SpeechletRequestEnvelope result = null;
try {
result = SpeechletRequestEnvelope.FromJson(content);
}
catch (Exception ex)
when(ex is Newtonsoft.Json.JsonReaderException || ex is InvalidCastException || ex is FormatException)
{
validationResult |= SpeechletRequestValidationResult.InvalidJson;
}
var success = false;
// attempt to verify timestamp only if we were able to parse request body
if (result != null)
{
var now = DateTime.UtcNow; // reference time for this request
if (!SpeechletRequestTimestampVerifier.VerifyRequestTimestamp(result, now))
{
validationResult |= SpeechletRequestValidationResult.InvalidTimestamp;
}
success = speechlet?.OnRequestValidation(validationResult, now, result) ?? (validationResult == SpeechletRequestValidationResult.OK);
}
if (!success)
{
throw new SpeechletValidationException(validationResult);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="requestContent"></param>
/// <returns></returns>
public async virtual Task <string> DoProcessRequestAsync(SpeechletRequestEnvelope requestEnvelope)
{
Session session = requestEnvelope.Session;
SpeechletResponse response = null;
// verify timestamp is within tolerance
var diff = DateTime.UtcNow - requestEnvelope.Request.Timestamp;
Debug.WriteLine("Request was timestamped {0:0.00} seconds ago.", diff.TotalSeconds);
if (Math.Abs((decimal)diff.TotalSeconds) > Sdk.TIMESTAMP_TOLERANCE_SEC)
{
return(String.Empty);
}
// process launch request
if (requestEnvelope.Request is LaunchRequest)
{
var request = requestEnvelope.Request as LaunchRequest;
if (requestEnvelope.Session.IsNew)
{
await OnSessionStartedAsync(
new SessionStartedRequest(request.RequestId, request.Timestamp), session);
}
response = await OnLaunchAsync(request, session);
}
// process intent request
else if (requestEnvelope.Request is IntentRequest)
{
var request = requestEnvelope.Request as IntentRequest;
// Do session management prior to calling OnSessionStarted and OnIntentAsync
// to allow dev to change session values if behavior is not desired
DoSessionManagement(request, session);
if (requestEnvelope.Session.IsNew)
{
await OnSessionStartedAsync(
new SessionStartedRequest(request.RequestId, request.Timestamp), session);
}
response = await OnIntentAsync(request, session);
}
// process session ended request
else if (requestEnvelope.Request is SessionEndedRequest)
{
var request = requestEnvelope.Request as SessionEndedRequest;
await OnSessionEndedAsync(request, session);
}
var responseEnvelope = new SpeechletResponseEnvelope {
Version = requestEnvelope.Version,
Response = response,
SessionAttributes = session.Attributes
};
return(responseEnvelope.ToJson());
}
/// <summary>
///
/// </summary>
/// <param name="requestEnvelope"></param>
/// <returns></returns>
private string DoProcessRequest(SpeechletRequestEnvelope requestEnvelope)
{
Session session = requestEnvelope.Session;
Context context = requestEnvelope.Context;
SpeechletResponse response = null;
// process launch request
if (requestEnvelope.Request is LaunchRequest)
{
var request = requestEnvelope.Request as LaunchRequest;
if (requestEnvelope.Session.IsNew)
{
OnSessionStarted(
new SessionStartedRequest(request.RequestId, request.Timestamp), session);
}
response = OnLaunch(request, session);
}
else if (requestEnvelope.Request is AudioPlayerRequest)
{
var request = requestEnvelope.Request as AudioPlayerRequest;
response = OnAudioIntent(request, context);
}
// process intent request
else if (requestEnvelope.Request is IntentRequest)
{
var request = requestEnvelope.Request as IntentRequest;
// Do session management prior to calling OnSessionStarted and OnIntentAsync
// to allow dev to change session values if behavior is not desired
DoSessionManagement(request, session);
if (requestEnvelope.Session.IsNew)
{
OnSessionStarted(
new SessionStartedRequest(request.RequestId, request.Timestamp), session);
}
response = OnIntent(request, session, requestEnvelope.Context);
}
// process session ended request
else if (requestEnvelope.Request is SessionEndedRequest)
{
var request = requestEnvelope.Request as SessionEndedRequest;
OnSessionEnded(request, session);
}
var responseEnvelope = new SpeechletResponseEnvelope {
Version = requestEnvelope.Version,
Response = response,
SessionAttributes = session?.Attributes ?? new Dictionary <string, string>()//requestEnvelope.Session?.Attributes
};
return(responseEnvelope.ToJson());
}
public void Parse_AlexaRequest()
{
var requestContent = File.ReadAllText(@"Json\request.json");
var requestEnvelope = SpeechletRequestEnvelope.FromJson(requestContent);
Assert.IsNotNull(requestEnvelope);
Assert.IsNotNull(requestEnvelope.Context);
Assert.IsNotNull(requestEnvelope.Request);
Assert.IsNotNull(requestEnvelope.Session);
Assert.IsNotNull(requestEnvelope.Version);
Assert.AreEqual(requestEnvelope.Version, Sdk.VERSION);
// intentRequest
Assert.IsInstanceOfType(requestEnvelope.Request, typeof(IntentRequest));
var intentRequest = requestEnvelope.Request as IntentRequest;
Assert.AreEqual(intentRequest.RequestId, "amzn1.echo-api.request.00000000-0000-0000-0000-000000000000");
Assert.AreEqual(intentRequest.DialogState, DialogStateEnum.IN_PROGRESS);
Assert.AreEqual(intentRequest.Timestamp, new DateTime(2017, 1, 2, 3, 4, 5, DateTimeKind.Utc));
// Intent
Assert.IsNotNull(intentRequest.Intent);
Assert.AreEqual(intentRequest.Intent.ConfirmationStatus, ConfirmationStatusEnum.CONFIRMED);
Assert.AreEqual(intentRequest.Intent.Name, "test");
// Slots
Assert.IsNotNull(intentRequest.Intent.Slots);
Assert.AreEqual(intentRequest.Intent.Slots.Count, 1);
Assert.IsTrue(intentRequest.Intent.Slots.ContainsKey("Testslot"));
var slot = intentRequest.Intent.Slots["Testslot"];
Assert.IsNotNull(slot);
Assert.AreEqual(slot.Name, "Testslot");
Assert.AreEqual(slot.Value, "Testvalue");
Assert.AreEqual(slot.ConfirmationStatus, ConfirmationStatusEnum.CONFIRMED);
// resolutions
Assert.IsNotNull(slot.Resolutions);
Assert.IsNotNull(slot.Resolutions.ResolutionsPerAuthority);
Assert.AreEqual(slot.Resolutions.ResolutionsPerAuthority.Count, 1);
Assert.AreEqual(slot.Resolutions.ResolutionsPerAuthority[0].Authority, "amzn1.er-authority.echo-sdk.amzn1.ask.skill.00000000-0000-0000-0000-000000000000.Testslot");
Assert.IsNotNull(slot.Resolutions.ResolutionsPerAuthority[0].Status);
Assert.AreEqual(slot.Resolutions.ResolutionsPerAuthority[0].Status.Code, Resolution.ResolutionStatusCodeEnum.ER_SUCCESS_MATCH);
Assert.AreEqual(slot.Resolutions.ResolutionsPerAuthority[0].Values.Count, 1);
Assert.AreEqual(slot.Resolutions.ResolutionsPerAuthority[0].Values[0].Value.Id, "1");
Assert.AreEqual(slot.Resolutions.ResolutionsPerAuthority[0].Values[0].Value.Name, "Testvalue");
}
/// <summary>
///
/// </summary>
/// <param name="requestEnvelope"></param>
/// <returns></returns>
private async Task <string> DoProcessRequestAsync(SpeechletRequestEnvelope requestEnvelope)
{
Session session = requestEnvelope.Session;
SpeechletResponse response = null;
// process launch request
if (requestEnvelope.Request is LaunchRequest)
{
var request = requestEnvelope.Request as LaunchRequest;
if (requestEnvelope.Session.IsNew)
{
await OnSessionStartedAsync(
new SessionStartedRequest(request.RequestId, request.Timestamp), session);
}
response = await OnLaunchAsync(request, session);
}
// process intent request
else if (requestEnvelope.Request is IntentRequest)
{
var request = requestEnvelope.Request as IntentRequest;
// Do session management prior to calling OnSessionStarted and OnIntentAsync
// to allow dev to change session values if behavior is not desired
DoSessionManagement(request, session);
if (requestEnvelope.Session.IsNew)
{
await OnSessionStartedAsync(
new SessionStartedRequest(request.RequestId, request.Timestamp), session);
}
response = await OnIntentAsync(request, session);
}
// process session ended request
else if (requestEnvelope.Request is SessionEndedRequest)
{
var request = requestEnvelope.Request as SessionEndedRequest;
await OnSessionEndedAsync(request, session);
}
var responseEnvelope = new SpeechletResponseEnvelope {
Version = requestEnvelope.Version,
Response = response,
SessionAttributes = session.Attributes
};
return(responseEnvelope.ToJson());
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public SpeechletResponseEnvelope FunctionHandler(SpeechletRequestEnvelope input, ILambdaContext context)
{
context.Logger.Log(JsonConvert.SerializeObject(input));
return(new SpeechletResponseEnvelope
{
Response = new SpeechletResponse
{
OutputSpeech = new PlainTextOutputSpeech
{
Text = ((IntentRequest)input.Request).Intent.Slots["Word"].Value
}
}
});
}
public void RequestWithInvalidTimestampTest()
{
const string TestDataFile = @"TestData\RequestWithInvalidTimestamp.json";
SpeechletRequestValidationResult validationResult = SpeechletRequestValidationResult.OK;
SpeechletRequestEnvelope alexaRequest = null;
var alexaContent = File.ReadAllText(TestDataFile);
try {
alexaRequest = SpeechletRequestEnvelope.FromJson(alexaContent);
}
catch (Exception ex)
when(ex is Newtonsoft.Json.JsonReaderException || ex is InvalidCastException || ex is FormatException)
{
validationResult = validationResult | SpeechletRequestValidationResult.InvalidJson;
}
Assert.True(validationResult == SpeechletRequestValidationResult.InvalidJson);
}
/// <summary>
///
/// </summary>
/// <param name="requestEnvelope"></param>
/// <returns></returns>
public async Task <SpeechletResponseEnvelope> ProcessRequestAsync(SpeechletRequestEnvelope requestEnvelope)
{
var session = requestEnvelope.Session;
var context = requestEnvelope.Context;
var request = requestEnvelope.Request;
var response = !(request is ExtendedSpeechletRequest) ?
await HandleStandardRequestAsync(request, session, context) :
await HandleExtendedRequestAsync(request as ExtendedSpeechletRequest, context);
if (response == null)
{
response = new SpeechletResponse();
}
var responseEnvelope = new SpeechletResponseEnvelope {
Version = requestEnvelope.Version,
Response = response,
SessionAttributes = session?.Attributes
};
return(responseEnvelope);
}
/// <summary>
/// Processes Alexa request AND validates request signature
/// </summary>
/// <param name="httpRequest"></param>
/// <returns></returns>
public virtual async Task <HttpResponseMessage> GetResponseAsync(HttpRequestMessage httpRequest)
{
DateTime now = DateTime.UtcNow; // reference time for this request
RequestHeader requestHeader = new RequestHeader();
requestHeader.Read(httpRequest);
await OnRequestIncomeAsync(requestHeader);
#if HasBouncyCastle
var cerValidator = new BouncyCastleCertValidator();
#else
var cerValidator = new DotNetCertValidator();
#endif
var validationResult = await cerValidator.VerifyAsync(requestHeader);
if (!await OnRequestValidationAsync(requestHeader, validationResult))
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = validationResult.ToString()
});
}
try
{
RequestEnvelope = SpeechletRequestEnvelope.FromJson(requestHeader.RequestAsString);
if (!SpeechletRequestTimestampVerifier.VerifyRequestTimestamp(RequestEnvelope, now))
{
validationResult = validationResult | SpeechletRequestValidationResult.InvalidTimestamp;
}
}
catch (Exception e1)
{
await OnParsingErrorAsync(e1);
validationResult = SpeechletRequestValidationResult.InvalidJson;
}
try
{
string alexaResponsejson = await DoProcessRequestAsync(RequestEnvelope);
if (alexaResponsejson == null)
{
await OnResponseOutgoingAsync("->alexaResponsejson == null");
return(null);
}
await OnResponseOutgoingAsync(alexaResponsejson);
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(alexaResponsejson, Encoding.UTF8, "application/json")
});;
}
catch (NotImplementedException)
{
return(null);
}
catch (Exception e2)
{
await OnParsingErrorAsync(e2);
return(new HttpResponseMessage(HttpStatusCode.InternalServerError));
}
}
/// <summary>
/// Processes Alexa request AND validates request signature
/// </summary>
/// <param name="httpRequest"></param>
/// <returns></returns>
public virtual HttpResponseMessage GetResponse(HttpRequestMessage httpRequest)
{
SpeechletRequestValidationResult validationResult = SpeechletRequestValidationResult.OK;
DateTime now = DateTime.UtcNow; // reference time for this request
string chainUrl = null;
if (!httpRequest.Headers.Contains(Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER) ||
String.IsNullOrEmpty(chainUrl = httpRequest.Headers.GetValues(Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER).First()))
{
validationResult = validationResult | SpeechletRequestValidationResult.NoCertHeader;
}
string signature = null;
if (!httpRequest.Headers.Contains(Sdk.SIGNATURE_REQUEST_HEADER) ||
String.IsNullOrEmpty(signature = httpRequest.Headers.GetValues(Sdk.SIGNATURE_REQUEST_HEADER).First()))
{
validationResult = validationResult | SpeechletRequestValidationResult.NoSignatureHeader;
}
var alexaBytes = AsyncHelpers.RunSync <byte[]>(() => httpRequest.Content.ReadAsByteArrayAsync());
Debug.WriteLine(httpRequest.ToLogString());
// attempt to verify signature only if we were able to locate certificate and signature headers
if (validationResult == SpeechletRequestValidationResult.OK)
{
if (!SpeechletRequestSignatureVerifier.VerifyRequestSignature(alexaBytes, signature, chainUrl))
{
validationResult = validationResult | SpeechletRequestValidationResult.InvalidSignature;
}
}
SpeechletRequestEnvelope alexaRequest = null;
try {
var alexaContent = UTF8Encoding.UTF8.GetString(alexaBytes);
alexaRequest = SpeechletRequestEnvelope.FromJson(alexaContent);
}
catch (Newtonsoft.Json.JsonReaderException) {
validationResult = validationResult | SpeechletRequestValidationResult.InvalidJson;
}
catch (InvalidCastException) {
validationResult = validationResult | SpeechletRequestValidationResult.InvalidJson;
}
// attempt to verify timestamp only if we were able to parse request body
if (alexaRequest != null)
{
if (!SpeechletRequestTimestampVerifier.VerifyRequestTimestamp(alexaRequest, now))
{
validationResult = validationResult | SpeechletRequestValidationResult.InvalidTimestamp;
}
}
if (alexaRequest == null || !OnRequestValidation(validationResult, now, alexaRequest))
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = validationResult.ToString()
});
}
string alexaResponse = DoProcessRequest(alexaRequest);
HttpResponseMessage httpResponse;
if (alexaResponse != null)
{
httpResponse = new HttpResponseMessage(HttpStatusCode.OK);
httpResponse.Content = new StringContent(alexaResponse, Encoding.UTF8, "application/json");
// Debug.WriteLine(httpResponse.ToLogString());
}
else
{
httpResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError);
}
return(httpResponse);
}
/// <summary>
/// Processes Alexa request AND validates request signature
/// </summary>
/// <returns></returns>
public virtual string GetResponse(Dictionary <string, string[]> Headers, byte[] Content, out HttpStatusCode HttpStatusCode)
{
SpeechletRequestValidationResult validationResult = SpeechletRequestValidationResult.OK;
DateTime now = DateTime.UtcNow; // reference time for this request
string chainUrl = null;
if (!Headers.ContainsKey(Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER) ||
String.IsNullOrEmpty(chainUrl = Headers[Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER].First()))
{
validationResult = validationResult | SpeechletRequestValidationResult.NoCertHeader;
}
string signature = null;
if (!Headers.ContainsKey(Sdk.SIGNATURE_REQUEST_HEADER) ||
String.IsNullOrEmpty(signature = Headers[Sdk.SIGNATURE_REQUEST_HEADER].First()))
{
validationResult = validationResult | SpeechletRequestValidationResult.NoSignatureHeader;
}
// attempt to verify signature only if we were able to locate certificate and signature headers
if (validationResult == SpeechletRequestValidationResult.OK)
{
if (!SpeechletRequestSignatureVerifier.VerifyRequestSignature(Content, signature, chainUrl))
{
validationResult = validationResult | SpeechletRequestValidationResult.InvalidSignature;
}
}
SpeechletRequestEnvelope alexaRequest = null;
try
{
var alexaContent = UTF8Encoding.UTF8.GetString(Content);
alexaRequest = SpeechletRequestEnvelope.FromJson(alexaContent);
}
catch (Newtonsoft.Json.JsonReaderException)
{
validationResult = validationResult | SpeechletRequestValidationResult.InvalidJson;
}
catch (InvalidCastException)
{
validationResult = validationResult | SpeechletRequestValidationResult.InvalidJson;
}
// attempt to verify timestamp only if we were able to parse request body
if (alexaRequest != null)
{
if (!SpeechletRequestTimestampVerifier.VerifyRequestTimestamp(alexaRequest, now))
{
validationResult = validationResult | SpeechletRequestValidationResult.InvalidTimestamp;
}
}
if (alexaRequest == null || !OnRequestValidation(validationResult, now, alexaRequest))
{
HttpStatusCode = HttpStatusCode.BadRequest;
return(validationResult.ToString());
}
string alexaResponse = DoProcessRequest(alexaRequest);
if (alexaResponse == null)
{
HttpStatusCode = HttpStatusCode.InternalServerError;
return(null);
}
else
{
HttpStatusCode = HttpStatusCode.OK;
return(alexaResponse);
}
}
/// <summary>
///
/// </summary>
/// <param name="requestJson"></param>
/// <returns></returns>
public virtual string ProcessRequest(JObject requestJson)
{
var requestEnvelope = SpeechletRequestEnvelope.FromJson(requestJson);
return(DoProcessRequest(requestEnvelope));
}
/// <summary>
/// Opportunity to set policy for handling requests with invalid signatures and/or timestamps
/// </summary>
/// <returns>true if request processing should continue, otherwise false</returns>
public virtual bool OnRequestValidation(
SpeechletRequestValidationResult result, DateTime referenceTimeUtc, SpeechletRequestEnvelope requestEnvelope)
{
return(result == SpeechletRequestValidationResult.OK);
}
/// <summary>
///
/// </summary>
/// <param name="requestEnvelope"></param>
/// <returns></returns>
private async Task <string> DoProcessRequestAsync(SpeechletRequestEnvelope requestEnvelope)
{
Session session = requestEnvelope.Session;
SpeechletResponse response = null;
Trace.TraceInformation("In DoProcessRequestAsync");
// process launch request
if (requestEnvelope.Request is LaunchRequest)
{
var request = requestEnvelope.Request as LaunchRequest;
if (requestEnvelope.Session.IsNew)
{
await OnSessionStartedAsync(
new SessionStartedRequest(request.RequestId, request.Timestamp), session);
}
Trace.TraceInformation("request is LaunchRquest--about to call OnLaunchAsync");
response = await OnLaunchAsync(request, session);
}
// process intent request
else if (requestEnvelope.Request is IntentRequest)
{
var request = requestEnvelope.Request as IntentRequest;
Trace.TraceInformation("In DoProcessRequestAsync, request is IntentRequest");
// Do session management prior to calling OnSessionStarted and OnIntentAsync
// to allow dev to change session values if behavior is not desired
DoSessionManagement(request, session);
if (requestEnvelope.Session.IsNew)
{
await OnSessionStartedAsync(
new SessionStartedRequest(request.RequestId, request.Timestamp), session);
}
Trace.TraceInformation("--about to call OnIntentAsync");
response = await OnIntentAsync(request, session);
}
// perform enqueue next audio request (to-do: others as well)
else if (requestEnvelope.Request is AudioIntentRequest)
{
var request = requestEnvelope.Request as AudioIntentRequest;
Context context = requestEnvelope.Context;
response = await OnAudioIntentAsync(request, context);
session = new Session();
}
// perform enqueue next audio request (to-do: others as well)
else if (requestEnvelope.Request is AudioPlayerRequest)
{
var request = requestEnvelope.Request as AudioPlayerRequest;
Context context = requestEnvelope.Context;
response = await OnAudioPlayerAsync(request, context);
session = new Session();
}
// process session ended request
else if (requestEnvelope.Request is SessionEndedRequest)
{
var request = requestEnvelope.Request as SessionEndedRequest;
await OnSessionEndedAsync(request, session);
}
var responseEnvelope = new SpeechletResponseEnvelope
{
Version = requestEnvelope.Version,
Response = response,
SessionAttributes = session.Attributes
};
Trace.TraceInformation($"Reached the bottom of DoProcessRequestAsync, requestEnvelope.Request is {requestEnvelope.Request.ToString()}");
return(responseEnvelope.ToJson());
}
/// <summary>
///
/// </summary>
/// <param name="requestContent"></param>
/// <returns></returns>
public virtual string ProcessRequest(string requestContent)
{
var requestEnvelope = SpeechletRequestEnvelope.FromJson(requestContent);
return(DoProcessRequest(requestEnvelope));
}
/// <summary>
/// Processes Alexa request but does NOT validate request signature
/// </summary>
/// <param name="requestJson"></param>
/// <returns></returns>
public async virtual Task <string> ProcessRequestAsync(JObject requestJson)
{
var requestEnvelope = SpeechletRequestEnvelope.FromJson(requestJson);
return(await DoProcessRequestAsync(requestEnvelope));
}
/// <summary>
///
/// </summary>
/// <param name="requestEnvelope"></param>
/// <returns></returns>
private string DoProcessRequest(SpeechletRequestEnvelope requestEnvelope)
{
Session session = requestEnvelope.Session;
Context context = requestEnvelope.Context;
SpeechletResponse response = null;
switch (requestEnvelope.Request)
{
case LaunchRequest request:
{
if (requestEnvelope.Session.IsNew)
{
OnSessionStarted(requestEnvelope);
}
response = OnLaunch(request, session, context);
}
break;
case AudioPlayerRequest request:
{
response = OnAudioIntent(request, session, context);
}
break;
// process intent request
case IntentRequest request:
{
// Do session management prior to calling OnSessionStarted and OnIntentAsync
// to allow dev to change session values if behavior is not desired
DoSessionManagement(request, session);
if (requestEnvelope.Session.IsNew)
{
OnSessionStarted(requestEnvelope);
}
response = OnIntent(request, session, context);
}
break;
// process session ended request
case SessionEndedRequest request:
{
OnSessionEnded(request, session, context);
}
break;
}
if (response == null)
{
return(new SpeechletResponseEnvelope
{
Version = requestEnvelope.Version,
Response = new SpeechletResponse()
{
ShouldEndSession = null
}
}.ToJson());
}
var responseEnvelope = new SpeechletResponseEnvelope
{
Version = requestEnvelope.Version,
Response = response,
SessionAttributes = requestEnvelope.Session?.Attributes ?? new Dictionary <string, string>()
};
return(responseEnvelope.ToJson());
}
public override bool OnRequestValidation(SpeechletRequestValidationResult result, DateTime referenceTimeUtc, SpeechletRequestEnvelope requestEnvelope)
{
if (requestEnvelope?.Session?.Application?.Id?.Equals("amzn1.ask.skill.77ffa04a-699d-452d-b8d5-4c128079a1b2") == false)
{
WebApiApplication.telemetry.TrackEvent("Request envelope does not contain the appid");
return(false);
}
return(base.OnRequestValidation(result, referenceTimeUtc, requestEnvelope));
}
/// <summary>
/// Processes Alexa request but does NOT validate request signature
/// </summary>
/// <param name="requestContent"></param>
/// <returns></returns>
public async virtual Task <string> ProcessRequestAsync(string requestContent)
{
var requestEnvelope = SpeechletRequestEnvelope.FromJson(requestContent);
return(await DoProcessRequestAsync(requestEnvelope));
}
/// <summary>
///
/// </summary>
/// <param name="requestEnvelope"></param>
/// <returns></returns>
private async Task <string> DoProcessRequestAsync(SpeechletRequestEnvelope requestEnvelope)
{
Session session = requestEnvelope.Session;
var context = requestEnvelope.Context;
var request = requestEnvelope.Request;
ISpeechletResponse response = null;
if (session != null)
{
// Do session management prior to calling OnSessionStarted and OnIntentAsync
// to allow dev to change session values if behavior is not desired
DoSessionManagement(request as IntentRequest, session);
if (session.IsNew)
{
await OnSessionStartedAsync(
new SessionStartedRequest(request.RequestId, request.Timestamp, request.Locale), session);
}
}
// process launch request
if (requestEnvelope.Request is LaunchRequest)
{
response = await OnLaunchAsync(request as LaunchRequest, session);
}
// process audio player request
else if (requestEnvelope.Request is AudioPlayerRequest)
{
response = await OnAudioPlayerAsync(request as AudioPlayerRequest, context);
}
// process playback controller request
else if (requestEnvelope.Request is PlaybackControllerRequest)
{
response = await OnPlaybackControllerAsync(request as PlaybackControllerRequest, context);
}
// process display request
else if (requestEnvelope.Request is DisplayRequest)
{
response = await OnDisplayAsync(request as DisplayRequest, context);
}
// process system request
else if (requestEnvelope.Request is SystemExceptionEncounteredRequest)
{
await OnSystemExceptionEncounteredAsync(request as SystemExceptionEncounteredRequest, context);
}
// process intent request
else if (requestEnvelope.Request is IntentRequest)
{
response = await OnIntentAsync(request as IntentRequest, session, context);
}
// process session ended request
else if (requestEnvelope.Request is SessionEndedRequest)
{
await OnSessionEndedAsync(request as SessionEndedRequest, session);
}
var responseEnvelope = new SpeechletResponseEnvelope {
Version = requestEnvelope.Version,
Response = response,
SessionAttributes = session?.Attributes
};
return(responseEnvelope.ToJson());
}
public override bool OnRequestValidation(SpeechletRequestValidationResult result, DateTime referenceTimeUtc, SpeechletRequestEnvelope requestEnvelope)
{
//if (requestEnvelope?.Session?.Application?.Id?.Equals("<your Alexa skill's application id here>") == false)
//{
// //WebApiApplication.telemetry.TrackEvent("Request envelope does not contain the appid");
// return false;
//}
return(base.OnRequestValidation(0, referenceTimeUtc, requestEnvelope));
}
public override bool OnRequestValidation(SpeechletRequestValidationResult result, DateTime referenceTimeUtc, SpeechletRequestEnvelope requestEnvelope)
{
//return true;
return(base.OnRequestValidation(result, referenceTimeUtc, requestEnvelope));
}
public override bool OnRequestValidation(SpeechletRequestValidationResult result, DateTime referenceTimeUtc, SpeechletRequestEnvelope requestEnvelope)
{
if (requestEnvelope?.Session?.Application?.Id?.Equals("amzn1.ask.skill.052afe5d-6417-4e89-b6aa-b4ee3c0bb75a") == false)
{
return(false);
}
return(base.OnRequestValidation(result, referenceTimeUtc, requestEnvelope));
}
public async Task <string> ProcessRequestAsync(JObject requestJson)
{
var requestEnvelope = SpeechletRequestEnvelope.FromJson(requestJson);
return((await Service.ProcessRequestAsync(requestEnvelope))?.ToJson());
}
public bool OnRequestValidation(
SpeechletRequestValidationResult result, DateTime referenceTimeUtc, SpeechletRequestEnvelope requestEnvelope)
{
return(speechlet.OnRequestValidation(result, referenceTimeUtc, requestEnvelope));
}
public virtual void OnSessionStarted(SpeechletRequestEnvelope requestEnvelope)
{
}
