public async Task DeserializeEndpointsCorrectly()
{
var client = new HttpClient(new ActionHandler(req => Task.FromResult(
new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(
Utility.ExampleFileContent("Endpoints.json"))
})))
{
BaseAddress = new Uri("https://api.amazonalexa.com", UriKind.Absolute)
};
var api = new EndpointApi(client);
var endpoints = await api.GetEndpoints();
Assert.Equal(2, endpoints.Endpoints.Length);
var first = endpoints.Endpoints.First();
Assert.Equal("amzn1.ask.endpoint.ABC123", first.EndpointId);
var capability = Assert.Single(first.Capabilities);
Assert.Equal("AlexaInterface", capability.Type);
Assert.Equal("Custom.CustomInterface1", capability.Interface);
Assert.Equal("1.0", capability.Version);
}
private void SetupApis()
{
Error = new ErrorApi {
Client = this
};
Account = new AccountApi {
Client = this
};
Application = new ApplicationApi {
Client = this
};
AvailableNumber = new AvailableNumberApi {
Client = this
};
Bridge = new BridgeApi {
Client = this
};
Domain = new DomainApi {
Client = this
};
Call = new CallApi {
Client = this
};
Conference = new ConferenceApi {
Client = this
};
Message = new MessageApi {
Client = this
};
NumberInfo = new NumberInfoApi {
Client = this
};
PhoneNumber = new PhoneNumberApi {
Client = this
};
Recording = new RecordingApi {
Client = this
};
Transcription = new TranscriptionApi {
Client = this
};
Media = new MediaApi {
Client = this
};
Endpoint = new EndpointApi {
Client = this
};
V2 = new ApiV2 {
Message = new Bandwidth.Net.ApiV2.MessageApi {
Client = this
}
};
}
public async Task GetEndpointsHitsCorrectUrl()
{
var client = new HttpClient(new ActionHandler(req =>
{
Assert.Equal("/v1/endpoints", req.RequestUri.PathAndQuery);
}))
{
BaseAddress = new Uri("https://api.amazonalexa.com", UriKind.Absolute)
};
var api = new EndpointApi(client);
await api.GetEndpoints();
client.Dispose();
}
static void Main(string[] args)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
String tgt = getCasTGT();
Console.WriteLine("TGT " + tgt);
String st = getCasSt(tgt);
Console.WriteLine("ST " + st);
Configuration config = new Configuration();
config.BasePath = basepath;
//API Client can be generated via http://generator.swagger.io
EndpointApi api = new EndpointApi(config);
var headers = new List <Header>();
headers.Add(new Header("transactionId", "Unique Identifier"));
headers.Add(new Header("application", "Your Application Name"));
EndpointGetRequest req = new EndpointGetRequest(headers, null);
Console.WriteLine("Request -> " + req.ToJson());
EndpointGetServiceResponse resp = api.Endpointget(st, req);
String listenAddress = resp.Body.BroadcastAddress;
Console.WriteLine("Response <- " + resp.ToJson());
Console.WriteLine("listen <- " + listenAddress);
WebSocket websocket = new WebSocket(listenAddress);
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Opened += Websocket_Opened;
websocket.Closed += Websocket_Closed;
websocket.DataReceived += Websocket_DataReceived;
websocket.Open();
Console.ReadLine();
}
public void Init()
{
instance = new EndpointApi();
}
public SkillResponse FunctionHandler(SkillRequest input, ILambdaContext context)
{
//Catch any incomming Errors
if (input.Request.GetType() == typeof(SessionEndedRequest))
{
return(getError(input));
}
//Intent holen
IntentRequest intent = input.Request as IntentRequest;
//Get Endpoint
EndpointApi api = new EndpointApi(input);
EndpointResponse endpoints = new EndpointResponse();
try
{
endpoints = api.GetEndpoints().Result;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(createEndAnswer("Es wurden keine verbundenen Geräte gefunden."));
}
//Session for SessionAttributes
_session = input.Session;
//Create Attributes if not existend
if (_session.Attributes == null)
{
_session.Attributes = new Dictionary <string, object>();
}
//Check if the current Request is a Multiple Request command
if (_session.Attributes.ContainsKey("isMultipleCommands"))
{
isMultipleCommands = Convert.ToBoolean(_session.Attributes["isMultipleCommands"]);
}
else
{
_session.Attributes.Add("isMultipleCommands", isMultipleCommands);
}
if (_session.Attributes.ContainsKey("cmdPallete"))
{
cmdPallete = JsonConvert.DeserializeObject <CommandPalette>(_session.Attributes["cmdPallete"].ToString());
}
else
{
_session.Attributes.Add("cmdPallete", cmdPallete);
}
//Sicher gehen, dass eine Verbindung steht
if (endpoints.Endpoints.Length <= 0)
{
return(createEndAnswer("Ich konnte keine Verbundenen Geräte finden."));
}
//Verbundenes Gerät aus Liste holen
Endpoint endpoint = new Endpoint();
try
{
endpoint = endpoints.Endpoints[0];
}
catch (Exception)
{
endpoint = new Endpoint()
{
EndpointId = "NullIdHere",
FriendlyName = "Null Endpoint"
};
}
//Intent abfragen und Handeln
if (input.Request is LaunchRequest)
{
return(createAnswer("Was möchtest du tun?", false, _session));
}
else if (input.Request is IntentRequest)
{
if (intent.Intent.Name.Equals("MultipleDirectivesIntent"))
{
isMultipleCommands = true;
_session.Attributes["isMultipleCommands"] = true;
return(createAnswer("Sage immer einen Befehl und warte bis ich dich nach dem nächsten Frage. Sobald du fertig bis sag einfach: Senden", false, _session));
}
else if (intent.Intent.Name.Equals("SendMultipleDirectivesIntent"))
{
if (cmdPallete.DirectiveCount >= 1)
{
isMultipleCommands = false;
_session.Attributes["isMultipleCommands"] = false;
_session.Attributes["cmdPallete"] = new CommandPalette();
return(createRoboterRequest($"Ich schicke {cmdPallete.DirectiveCount} Befehle an den Roboter.", endpoint.EndpointId, "control", cmdPallete, _session));
}
else
{
return(createAnswer("Es sind keine Anfragen verfügbar, welche gesendet werden können. Um Anfragen hinzuzufügen sage dazu einfach: Ich möchte mehrere Anfragen senden.", false, _session, "Was möchtest du nun tun?"));
}
}
else if (intent.Intent.Name.Equals("SetSpeedIntent"))
{
SpeedData speedData = new SpeedData();
if (intent.Intent.Slots["Speed"].Value.Equals("?"))
{
return(createAnswer("Ich habe die von dir angegebene Geschwindkeit nicht verstanden. Bitte wiederhole den Satz.", false, _session));
}
else
{
int _speedVal = Convert.ToInt32(intent.Intent.Slots["Speed"].Value);
if (_speedVal >= 0 || _speedVal <= 100)
{
speedData.Speed = Convert.ToInt32(_speedVal);
//Set or Add Session Attribute
if (_session.Attributes.ContainsKey("Speed"))
{
_session.Attributes["Speed"] = _speedVal;
}
else
{
_session.Attributes.Add("Speed", _speedVal);
}
}
else
{
return(createAnswer("Die Geschwindigkeit darf nur in einem Bereich zwischen 1 und 100 liegen. Bitte wiederhole deine Aussage, mit einem korrekten Wert.", false, _session));
}
}
if (isMultipleCommands)
{
cmdPallete.Directives.Add(speedData);
cmdPallete.DirectiveCount = cmdPallete.Directives.Count;
_session.Attributes["cmdPallete"] = cmdPallete;
return(createAnswer("Der Speed Befehl wurde hinzugefügt. Es wird der nächste erwartet.", false, _session));
}
else
{
return(createRoboterRequest("Die Geschwindigkeit wurde gesetzt", endpoint.EndpointId, "control", speedData, _session));
}
}
else if (intent.Intent.Name.Equals("MoveIntent"))
{
DirectionData dirData = new DirectionData();
try
{
//Get Direction Slot Value
if (intent.Intent.Slots["Direction"].Value.Equals(""))
{
return(createAnswer("Ich habe nicht verstanden, in welche Richtung sich der Roboter bewegen soll. Bitte wiederhole den ganzen Satz.", false, _session));
}
else
{
if (intent.Intent.Slots["Direction"].Value == "gerade aus" || intent.Intent.Slots["Direction"].Value == "vorwärts")
{
dirData.Direction = "forward";
}
else if (intent.Intent.Slots["Direction"].Value == "geradeaus")
{
dirData.Direction = "forward";
}
else
{
dirData.Direction = intent.Intent.Slots["Direction"].Value;
}
}
//Get Duration Slot Value
if (intent.Intent.Slots["Duration"].Value.Equals("?"))
{
return(createAnswer("Ich habe nicht verstanden, wie lange sich der Roboter bewegen soll. Bitte wiederhole den ganzen Satz.", false, _session));
}
else
{
dirData.Duration = Convert.ToInt32(intent.Intent.Slots["Duration"].Value);
}
if (isMultipleCommands)
{
cmdPallete.Directives.Add(dirData);
cmdPallete.DirectiveCount = cmdPallete.Directives.Count;
_session.Attributes["cmdPallete"] = cmdPallete;
return(createAnswer("Der Move Befehl wurde hinzugefügt. Es wird der nächste erwartet.", false, _session));
}
else
{
return(createRoboterRequest("Der Roboter wird bewegt!", endpoint.EndpointId, "control", dirData, _session));
}
}
catch (Exception)
{
return(createAnswer("Um den Roboter zu bewegen, musst du eine Richtung als auch eine Dauer sagen. Versuche es einfach nochmal.", false, _session, "Ich warte auf einen Befehl", "Fehlende Parameter beim Move Intent", "Richtung und Geschwindigkeit"));
}
}
else if (intent.Intent.Name.Equals("DirectionTurnIntent"))
{
DirectionData dirData = new DirectionData();
//Attributes Checkup
if (_session.Attributes.ContainsKey("Speed"))
{
dirData.Speed = Convert.ToInt32(_session.Attributes["Speed"]);
}
else
{
dirData.Speed = 100;
_session.Attributes.Add("Speed", 100);
}
//Direction
if (intent.Intent.Slots.ContainsKey("Direction"))
{
dirData.Direction = intent.Intent.Slots["Direction"].Value;
}
else
{
return(createAnswer("Ich habe nicht verstanden, in welche Richtung sich der Roboter bewegen soll. Bitte wiederhole den ganzen Satz.", false, _session));
}
//Duration
if (intent.Intent.Slots.ContainsKey("Duration"))
{
dirData.Duration = Convert.ToInt32(intent.Intent.Slots["Duration"].Value);
}
else
{
return(createAnswer("Ich habe nicht verstanden, wie lange sich der Roboter bewegen soll. Bitte wiederhole den ganzen Satz.", false, _session));
}
if (isMultipleCommands)
{
cmdPallete.Directives.Add(dirData);
cmdPallete.DirectiveCount = cmdPallete.Directives.Count;
_session.Attributes["cmdPallete"] = cmdPallete;
return(createAnswer("Der drehen Befehl wurde hinzugefügt. Es wird der nächste erwartet.", false, _session));
}
else
{
return(createRoboterRequest($"Der Roboter wird nach {dirData.Direction} gedreht.", endpoint.EndpointId, "control", dirData, _session));
}
}
else if (intent.Intent.Name.Equals("DegreeTurnIntent"))
{
return(createAnswer("DegreeTurn Intent wurde aufgerufen!", false, _session));
}
else if (intent.Intent.Name.Equals("LetGoIntent"))
{
Command cmd = new Command();
cmd.CommandType = "command";
cmd.CmdName = "loslassen";
if (isMultipleCommands)
{
cmdPallete.Directives.Add(cmd);
cmdPallete.DirectiveCount = cmdPallete.Directives.Count;
_session.Attributes["cmdPallete"] = cmdPallete;
return(createAnswer("Der Loslassen Befehl wurde hinzugefügt. Es wird der nächste erwartet.", false, _session));
}
else
{
return(createRoboterRequest("Gegenstand wird losgelassen.", endpoint.EndpointId, "control", cmd, _session));
}
}
else if (intent.Intent.Name.Equals("GrabIntent"))
{
Command cmd = new Command();
cmd.CommandType = "command";
cmd.CmdName = "nimm";
if (isMultipleCommands)
{
cmdPallete.Directives.Add(cmd);
cmdPallete.DirectiveCount = cmdPallete.Directives.Count;
_session.Attributes["cmdPallete"] = cmdPallete;
return(createAnswer("Der Nimm Befehl wurde hinzugefügt. Es wird der nächste erwartet.", false, _session));
}
else
{
return(createRoboterRequest("Gegenstand wird aufgehoben.", endpoint.EndpointId, "control", cmd, _session));
}
}
else if (intent.Intent.Name.Equals("AMAZON.FallbackIntent"))
{
return(createAnswer("Du hast da wohl was vergessen. Wenn du den Roboter bewegen willst, musst du Richtung und Dauer angeben. Versuche es noch einmal?", false, _session, "Was möchtest du tun?"));
}
else if (intent.Intent.Name.Equals("AMAZON.CancelIntent"))
{
return(createAnswer("Die Aktion wird abgebrochen. Was möchtest du tun?", false, _session, "Ich warte auf den nächsten Befehl."));
}
else if (intent.Intent.Name.Equals("AMAZON.HelpIntent"))
{
return(createEndAnswer("Du kannst den Roboter nach vorne, links oder rechts bewegen. Die Geschwindkeit kannst du ebenfalls Anpassen."
+ "Der Roboter ist auch in der Lage Gegestände aufzuheben oder abzulegen. Versuche ganz natürlich dem Roboter einen dieser Befehle zu sagen"));
}
else if (intent.Intent.Name.Equals("AMAZON.StopIntent"))
{
cmdPallete = new CommandPalette();
return(createEndAnswer("Bis zum nächsten mal."));
}
else if (intent.Intent.Name.Equals("AMAZON.NavigateHomeIntent"))
{
return(createEndAnswer("Der Skill wird beendet."));
}
else
{
return(createAnswer("Es wurde ein nicht abgefangener Intent aufgerufen! " + intent.Intent.Name, false, _session));
}
}
else
{
return(createAnswer("Der Skill wurde nicht über einen LaunchRequest oder IntentRequest aufgerufen.", true, _session));
}
}
