public static byte[] CreateResponse(ControlResponse param)
{
List <byte> message = new List <byte>();
message.Add((byte)param);
return(message.ToArray());
}
public void Process(ControlResponse data)
{
var device = data.ToPiDeviceStatus();
if (_rabbitTracker.DevicesByName.TryGetValue(device.Hostname, out var tmp))
{
//Debug.WriteLine("Master processor device found");
//_backgroundHandler.SendMessage(new UpdateViewMessage());
UpdateDeviceStatus((IBoontonPi)tmp, device);
}
else
{
//Debug.WriteLine("Master processor device not found");
//_backgroundHandler.SendMessage(new UpdateViewMessage());
AddDevice(device);
}
//switch (data.Header.Command)
//{
// case "status_check_response":
// UpdateDevices(data);
// break;
// case "boonton_startup_response":
// case "start_poll_response":
// case "stop_poll_response":
// UpdateDeviceStatus(data);
// break;
// default:
// break;
//}
}
public static string CreateResponseStr(ControlResponse param)
{
List <byte> message = new List <byte>();
message.Add((byte)param);
return(Encoding.ASCII.GetString(message.ToArray()));
}
public static ControlResponse getResponseParamAndDelete(ref string payload)
{
ControlResponse output = (ControlResponse)Encoding.ASCII.GetBytes(payload)[0];
payload = DeleteParam(payload);
return(output);
}
private async Task <ControlResponse> ProcessControlRequestInternalAsync(ControlRequest request)
{
ControlRequestInfo requestInfo = null;
using (var streamReader = new StreamReader(request.InputXml))
{
var readerSettings = new XmlReaderSettings()
{
ValidationType = ValidationType.None,
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
Async = true
};
using var reader = XmlReader.Create(streamReader, readerSettings);
requestInfo = await ParseRequestAsync(reader).ConfigureAwait(false);
}
Logger.LogDebug("Received control request {0}", requestInfo.LocalName);
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
CloseOutput = false
};
StringWriter builder = new StringWriterWithEncoding(Encoding.UTF8);
using (var writer = XmlWriter.Create(builder, settings))
{
writer.WriteStartDocument(true);
writer.WriteStartElement("SOAP-ENV", "Envelope", NsSoapEnv);
writer.WriteAttributeString(string.Empty, "encodingStyle", NsSoapEnv, "http://schemas.xmlsoap.org/soap/encoding/");
writer.WriteStartElement("SOAP-ENV", "Body", NsSoapEnv);
writer.WriteStartElement("u", requestInfo.LocalName + "Response", requestInfo.NamespaceURI);
WriteResult(requestInfo.LocalName, requestInfo.Headers, writer);
writer.WriteFullEndElement();
writer.WriteFullEndElement();
writer.WriteFullEndElement();
writer.WriteEndDocument();
}
var xml = builder.ToString().Replace("xmlns:m=", "xmlns:u=", StringComparison.Ordinal);
var controlResponse = new ControlResponse
{
Xml = xml,
IsSuccessful = true
};
controlResponse.Headers.Add("EXT", string.Empty);
return(controlResponse);
}
private void EnsureSuccess(ControlResponse response)
{
if (response is ErrorResponse err)
{
throw err.Exception;
}
}
private void OpenPassiveDataSocket()
{
Debug.Assert(socketControl != null);
Debug.Assert(socketData == null);
Thread.Sleep(10);
SendCommand("PASV", null);
ControlResponse response = RecieveControlResponse();
if (!response.PositiveCompletion)
{
throw new Exception("Server returned error when requesting passive connection.");
}
IPEndPoint dataEndPoint = ParsePassiveIPAddress(response.Response);
Trace.WriteLine("Opening passive data connection to: " + dataEndPoint.ToString());
try
{
socketData = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socketData.Connect(dataEndPoint);
}
catch (Exception)
{
if (socketData != null)
{
socketData.Close();
}
socketData = null;
throw;
}
}
public static byte[] CreateResponse(ControlResponse param, string payload)
{
List <byte> message = new List <byte>();
message.Add((byte)param);
message.AddRange(Encoding.ASCII.GetBytes(payload));
return(message.ToArray());
}
private ControlResponse ProcessControlRequestInternal(ControlRequest request)
{
var soap = new XmlDocument();
soap.LoadXml(request.InputXml);
var sparams = new Headers();
var body = soap.GetElementsByTagName("Body", NS_SOAPENV).Item(0);
var method = body.FirstChild;
foreach (var p in method.ChildNodes)
{
var e = p as XmlElement;
if (e == null)
{
continue;
}
sparams.Add(e.LocalName, e.InnerText.Trim());
}
Logger.Debug("Received control request {0}", method.LocalName);
IEnumerable <KeyValuePair <string, string> > result = GetResult(method.LocalName, sparams);
var env = new XmlDocument();
env.AppendChild(env.CreateXmlDeclaration("1.0", "utf-8", string.Empty));
var envelope = env.CreateElement("SOAP-ENV", "Envelope", NS_SOAPENV);
env.AppendChild(envelope);
envelope.SetAttribute("encodingStyle", NS_SOAPENV, "http://schemas.xmlsoap.org/soap/encoding/");
var rbody = env.CreateElement("SOAP-ENV:Body", NS_SOAPENV);
env.DocumentElement.AppendChild(rbody);
var response = env.CreateElement(String.Format("u:{0}Response", method.LocalName), method.NamespaceURI);
rbody.AppendChild(response);
foreach (var i in result)
{
var ri = env.CreateElement(i.Key);
ri.InnerText = i.Value;
response.AppendChild(ri);
}
var controlResponse = new ControlResponse
{
Xml = env.OuterXml,
IsSuccessful = true
};
controlResponse.Headers.Add("EXT", string.Empty);
return(controlResponse);
}
private void LogResponse(ControlResponse response)
{
if (!Config.GetDlnaConfiguration().EnableDebugLog)
{
return;
}
Logger.LogDebug("Control response. Headers: {@Headers}\n{Xml}", response.Headers, response.Xml);
}
public void Decode()
{
ControlResponse response = new ControlResponse();
response.wireDecode(TestControlResponse1);
Assert.AssertEquals(response.getStatusCode(), 404);
Assert.AssertEquals(response.getStatusText(), "Nothing not found");
Assert.AssertEquals(response.getBodyAsControlParameters().getFaceId(), 10);
}
private void LogResponse(ControlResponse response)
{
var builder = new StringBuilder();
var headers = string.Join(", ", response.Headers.Select(i => string.Format("{0}={1}", i.Key, i.Value)).ToArray());
builder.AppendFormat("Headers: {0}", headers);
builder.AppendLine();
builder.Append(response.Xml);
Logger.LogMultiline("Control response", LogSeverity.Debug, builder);
}
public void Encode()
{
ControlResponse response = new ControlResponse();
response.setStatusCode(404);
response.setStatusText("Nothing not found");
response.setBodyAsControlParameters(new ControlParameters());
response.getBodyAsControlParameters().setFaceId(10);
Blob wire = response.wireEncode();
Assert.AssertEquals(wire.buf(), TestControlResponse1);
}
public void Put(string fileName, string remoteFile, UploadCallback callback)
{
Socket localDataSocket = null;
OpenDataSocket();
try
{
SendCommand("TYPE", "I");
ControlResponse response = RecieveControlResponse();
SendCommand("STOR", remoteFile);
response = RecieveControlResponse();
if (!response.PositivePreliminary)
{
throw new Exception("Error returned by error for LIST command");
}
localDataSocket = ActivateDataSocket();
Byte[] sendBuffer = new Byte[8096];
int totalSizeRead = 0;
using (FileStream strm = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
int sizeRead;
while (0 != (sizeRead = strm.Read(sendBuffer, 0, 8096)))
{
totalSizeRead += sizeRead;
localDataSocket.Send(sendBuffer, 0, sizeRead, SocketFlags.None);
if (callback != null)
{
callback((float)totalSizeRead / (float)strm.Length);
}
Trace.WriteLine(String.Format("Writing file, {0:f2}% complete.", ((float)totalSizeRead / (float)strm.Length) * 100.0f), "FTPDataResponse");
}
}
CloseDataSocket(localDataSocket);
localDataSocket = null;
response = RecieveControlResponse();
Trace.WriteLine("File written successfully", "FTPDataResponse");
}
finally
{
CloseDataSocket(localDataSocket);
}
}
private void LogResponse(ControlResponse response)
{
if (!Config.GetDlnaConfiguration().EnableDebugLog)
{
return;
}
var originalHeaders = response.Headers;
var headers = string.Join(", ", originalHeaders.Select(i => string.Format("{0}={1}", i.Key, i.Value)).ToArray());
//builder.Append(response.Xml);
_logger.LogDebug("Control response. Headers: {0}", headers);
}
public async Task <ControlResponse> FindAsync(int code)
{
try
{
var exist = await _controlRepository.FindByIdAsync(code);
ControlResponse response = exist == null ? new ControlResponse($"Control {code} not found") : new ControlResponse(exist);
return(response);
}
catch (Exception e)
{
return(new ControlResponse($"An error occurred when finding the control: { e.Message }"));
}
}
public string List()
{
Socket localDataSocket = null;
OpenDataSocket();
try
{
SendCommand("TYPE", "A");
ControlResponse response = RecieveControlResponse();
SendCommand("LIST", "-aL");
response = RecieveControlResponse();
if (!response.PositivePreliminary)
{
throw new Exception("Error returned by error for LIST command");
}
localDataSocket = ActivateDataSocket();
Byte[] recvBuffer = new Byte[256];
StringBuilder sbData = new StringBuilder();
while (true)
{
int bytesRead = localDataSocket.Receive(recvBuffer);
if (bytesRead <= 0)
{
break;
}
sbData.Append(Encoding.ASCII.GetString(recvBuffer, 0, bytesRead));
}
Trace.Write(sbData.ToString(), "FTPDataResponse");
return(sbData.ToString());
}
finally
{
CloseDataSocket(localDataSocket);
}
}
private void OpenControlSocket()
{
Debug.Assert(socketControl == null);
socketControl = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
IPAddress hostAddr = Dns.Resolve(server).AddressList[0];
IPEndPoint endpointHost = new IPEndPoint(hostAddr, port);
socketControl.Connect(endpointHost);
if (!socketControl.Connected)
{
throw new Exception("Could not connect to FTP host");
}
}
catch (Exception)
{
socketControl.Close();
socketControl = null;
throw;
}
RecieveControlResponse();
SendCommand("USER", userName);
ControlResponse response = RecieveControlResponse();
if (response.SCode != 331)
{
throw new Exception("USER command rejected");
}
SendCommand("PASS", password);
response = RecieveControlResponse();
if (response.SCode != 230)
{
throw new Exception("PASS command rejected");
}
}
private ControlResponse CreateControlResponse(ControlRequestInfo requestInfo)
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
CloseOutput = false
};
StringWriter builder = new StringWriterWithEncoding(Encoding.UTF8);
using (var writer = XmlWriter.Create(builder, settings))
{
writer.WriteStartDocument(true);
writer.WriteStartElement("SOAP-ENV", "Envelope", NsSoapEnv);
writer.WriteAttributeString(string.Empty, "encodingStyle", NsSoapEnv, "http://schemas.xmlsoap.org/soap/encoding/");
writer.WriteStartElement("SOAP-ENV", "Body", NsSoapEnv);
writer.WriteStartElement("u", requestInfo.LocalName + "Response", requestInfo.NamespaceURI);
WriteResult(requestInfo.LocalName, requestInfo.Headers, writer);
writer.WriteFullEndElement();
writer.WriteFullEndElement();
writer.WriteFullEndElement();
writer.WriteEndDocument();
}
var xml = builder.ToString().Replace("xmlns:m=", "xmlns:u=", StringComparison.Ordinal);
var controlResponse = new ControlResponse(xml, true);
controlResponse.Headers.Add("EXT", string.Empty);
return(controlResponse);
}
private void OpenRegularDataSocket()
{
Debug.Assert(socketControl != null);
Debug.Assert(socketData == null);
try
{
IPEndPoint epLocalData;
socketData = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
epLocalData = new IPEndPoint(((IPEndPoint)socketControl.LocalEndPoint).Address.Address, 0);
socketData.Bind(epLocalData);
socketData.Listen(1);
epLocalData = (IPEndPoint)socketData.LocalEndPoint;
String stringAddress = FormatAddress(epLocalData.Address.Address, epLocalData.Port);
SendCommand("PORT", stringAddress);
ControlResponse response = RecieveControlResponse();
if (!response.PositiveCompletion)
{
throw new Exception("Server returned error when setting up regular data connection.");
}
}
catch (Exception)
{
if (socketData != null)
{
socketData.Close();
}
socketData = null;
throw;
}
}
public async Task <ControlResponse> UpdateAsync(int code, Control control)
{
try
{
var exist = await _controlRepository.FindByIdAsync(code);
ControlResponse response = exist == null ? new ControlResponse($"Control {code} not found") : new ControlResponse(exist);
exist.Description = control.Description != "" ? control.Description : exist.Description;
exist.Entry = control.Entry != "" ? control.Entry : exist.Entry;
exist.Exit = control.Exit != "" ? control.Exit : exist.Exit;
_controlRepository.Update(exist);
await _unitOfWork.CompleteAsync();
return(response);
}
catch (Exception e)
{
return(new ControlResponse($"An error occurred when updating the control: { e.Message }"));
}
}
public void Process(ControlResponse data)
{
Debug.WriteLine("None Master Control Processor, process");
}
/// <summary>
/// Decode input as a control parameters and set the fields of the
/// controlResponse object. Your derived class should override.
/// </summary>
///
/// <param name="controlResponse"></param>
/// <param name="input"></param>
/// <exception cref="System.NotSupportedException">for unimplemented if the derivedclass does not override.</exception>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public virtual void decodeControlResponse(ControlResponse controlResponse,
ByteBuffer input)
{
throw new NotSupportedException(
"decodeControlResponse is not implemented");
}
/// <summary>
/// Encode controlResponse and return the encoding.
/// Your derived class should override.
/// </summary>
///
/// <param name="controlResponse">The ControlResponse object to encode.</param>
/// <returns>A Blob containing the encoding.</returns>
/// <exception cref="System.NotSupportedException">for unimplemented if the derivedclass does not override.</exception>
public virtual Blob encodeControlResponse(ControlResponse controlResponse)
{
throw new NotSupportedException(
"encodeControlResponse is not implemented");
}
public ControlResponse Control(ControlRequest alexaRequest)
{
//IPremiseObject PremiseServer.HomeObject, rootObject;
var response = new ControlResponse();
#region CheckRequest
if ((alexaRequest == null) || (alexaRequest.header == null) || (alexaRequest.header.payloadVersion != "2"))
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.UnexpectedInformationReceivedError;
response.payload.exception = new ExceptionResponsePayload
{
faultingParameter = "alexaRequest"
};
return(response);
}
#endregion CheckRequest
#region BuildResponse
try
{
response.header.messageId = alexaRequest.header.messageId;
response.header.@namespace = alexaRequest.header.@namespace;
response.header.name = alexaRequest.header.name.Replace("Request", "Confirmation");
}
catch (Exception)
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.UnexpectedInformationReceivedError;
response.payload.exception = new ExceptionResponsePayload
{
faultingParameter = "alexaRequest.header.name"
};
return(response);
}
#endregion BuildResponse
//SYSClient client = new SYSClient();
#region ConnectToPremise
if (PremiseServer.HomeObject == null)
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.DependentServiceUnavailableError;
response.payload.exception = new ExceptionResponsePayload
{
dependentServiceName = "Premise Server"
};
return(response);
}
#endregion ConnectToPremise
try
{
if (!CheckAccessToken(alexaRequest.payload.accessToken).GetAwaiter().GetResult())
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.InvalidAccessTokenError;
response.payload.exception = new ExceptionResponsePayload();
return(response);
}
InformLastContact("ControlRequest:" + alexaRequest.payload.appliance.additionalApplianceDetails.path).GetAwaiter().GetResult();
// check request types
ControlRequestType requestType = ControlRequestType.Unknown;
DeviceType deviceType = DeviceType.Unknown;
string command = alexaRequest.header.name.Trim().ToUpper();
switch (command)
{
case "TURNOFFREQUEST":
requestType = ControlRequestType.TurnOffRequest;
deviceType = DeviceType.OnOff;
break;
case "TURNONREQUEST":
requestType = ControlRequestType.TurnOnRequest;
deviceType = DeviceType.OnOff;
break;
case "SETTARGETTEMPERATUREREQUEST":
requestType = ControlRequestType.SetTargetTemperature;
deviceType = DeviceType.Thermostat;
break;
case "INCREMENTTARGETTEMPERATUREREQUEST":
requestType = ControlRequestType.IncrementTargetTemperature;
deviceType = DeviceType.Thermostat;
break;
case "DECREMENTTARGETTEMPERATUREREQUEST":
requestType = ControlRequestType.DecrementTargetTemperature;
deviceType = DeviceType.Thermostat;
break;
case "SETPERCENTAGEREQUEST":
requestType = ControlRequestType.SetPercentage;
deviceType = DeviceType.Dimmer;
break;
case "INCREMENTPERCENTAGEREQUEST":
requestType = ControlRequestType.IncrementPercentage;
deviceType = DeviceType.Dimmer;
break;
case "DECREMENTPERCENTAGEREQUEST":
requestType = ControlRequestType.DecrementPercentage;
deviceType = DeviceType.Dimmer;
break;
case "SETCOLORREQUEST":
requestType = ControlRequestType.SetColorRequest;
deviceType = DeviceType.ColorLight;
break;
case "SETCOLORTEMPERATUREREQUEST":
requestType = ControlRequestType.SetColorTemperatureRequest;
deviceType = DeviceType.ColorLight;
break;
case "INCREMENTCOLORTEMPERATUREREQUEST":
requestType = ControlRequestType.IncrementColorTemperature;
deviceType = DeviceType.ColorLight;
break;
case "DECREMENTCOLORTEMPERATUREREQUEST":
requestType = ControlRequestType.DecrementColorTemperature;
deviceType = DeviceType.ColorLight;
break;
default:
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.UnsupportedOperationError;
response.payload.exception = new ExceptionResponsePayload();
return(response);
}
// get the object
IPremiseObject applianceToControl = null;
try
{
Guid premiseId = new Guid(alexaRequest.payload.appliance.applianceId);
applianceToControl = PremiseServer.RootObject.GetObject(premiseId.ToString("B")).GetAwaiter().GetResult();
if (applianceToControl == null)
{
throw new Exception();
}
}
catch
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.NoSuchTargetError;
response.payload.exception = new ExceptionResponsePayload();
return(response);
}
if (deviceType == DeviceType.OnOff)
{
switch (requestType)
{
case ControlRequestType.TurnOnRequest:
applianceToControl.SetValue("PowerState", "True").GetAwaiter().GetResult();
break;
case ControlRequestType.TurnOffRequest:
applianceToControl.SetValue("PowerState", "False").GetAwaiter().GetResult();
break;
default:
break;
}
}
else if (deviceType == DeviceType.Dimmer)
{
double currentValue = 0.0;
double adjustValue = 0.0;
double valueToSend = 0.0;
switch (requestType)
{
case ControlRequestType.SetPercentage:
// obtain the adjustValue
adjustValue = Math.Round(double.Parse(alexaRequest.payload.percentageState.value), 2).LimitToRange(0.00, 100.00);
// convert from percentage and maintain fractional accuracy
valueToSend = Math.Round(adjustValue / 100.00, 4);
applianceToControl.SetValue("Brightness", valueToSend.ToString()).GetAwaiter().GetResult();
break;
case ControlRequestType.IncrementPercentage:
// obtain the adjustValue
adjustValue = Math.Round(double.Parse(alexaRequest.payload.deltaPercentage.value) / 100.00, 2).LimitToRange(0.00, 100.00);
currentValue = Math.Round(applianceToControl.GetValue <Double>("Brightness").GetAwaiter().GetResult(), 2);
// maintain fractional accuracy
valueToSend = Math.Round(currentValue + adjustValue, 2).LimitToRange(0.00, 1.00);
applianceToControl.SetValue("Brightness", valueToSend.ToString()).GetAwaiter().GetResult();
break;
case ControlRequestType.DecrementPercentage:
// obtain the adjustValue
adjustValue = Math.Round(double.Parse(alexaRequest.payload.deltaPercentage.value) / 100.00, 2).LimitToRange(0.00, 100.00);
currentValue = Math.Round(applianceToControl.GetValue <Double>("Brightness").GetAwaiter().GetResult(), 2);
// maintain fractional accuracy
valueToSend = Math.Round(currentValue - adjustValue, 2).LimitToRange(0.00, 1.00);
applianceToControl.SetValue("Brightness", valueToSend.ToString()).GetAwaiter().GetResult();
break;
default:
break;
}
}
else if (deviceType == DeviceType.ColorLight)
{
const double adjustValue = 100.0;
double currentValue = 0.0;
double valueToSend = 0.0;
response.payload.achievedState = new AchievedState();
switch (requestType)
{
case ControlRequestType.SetColorRequest:
// obtain the adjustValue
double hue = Math.Round(alexaRequest.payload.color.hue.LimitToRange(0, 360), 1);
double saturation = Math.Round(alexaRequest.payload.color.saturation, 4);
double brightness = Math.Round(alexaRequest.payload.color.brightness, 4);
// set the values
applianceToControl.SetValue("Hue", hue.ToString()).GetAwaiter().GetResult();
applianceToControl.SetValue("Saturation", saturation.ToString()).GetAwaiter().GetResult();
applianceToControl.SetValue("Brightness", brightness.ToString()).GetAwaiter().GetResult();
// read them back for achieved state
response.payload.achievedState.color = new ApplianceColorValue
{
hue = Math.Round(applianceToControl.GetValue <Double>("Hue").GetAwaiter().GetResult(), 1),
saturation = Math.Round(applianceToControl.GetValue <Double>("Saturation").GetAwaiter().GetResult(), 4),
brightness = Math.Round(applianceToControl.GetValue <Double>("Brightness").GetAwaiter().GetResult(), 4)
};
break;
case ControlRequestType.SetColorTemperatureRequest:
valueToSend = alexaRequest.payload.colorTemperature.value.LimitToRange(1000, 10000);
// set the value
applianceToControl.SetValue("Temperature", Math.Round(valueToSend, 0).ToString()).GetAwaiter().GetResult();
// read it back
response.payload.achievedState.colorTemperature = new ApplianceColorTemperatureValue
{
value = applianceToControl.GetValue <int>("Temperature").GetAwaiter().GetResult()
};
break;
case ControlRequestType.IncrementColorTemperature:
currentValue = applianceToControl.GetValue <int>("Temperature").GetAwaiter().GetResult();
valueToSend = Math.Round(currentValue + adjustValue, 0).LimitToRange(1000, 10000);
// set the value
applianceToControl.SetValue("Temperature", valueToSend.ToString()).GetAwaiter().GetResult();
// read it back
response.payload.achievedState.colorTemperature = new ApplianceColorTemperatureValue
{
value = applianceToControl.GetValue <int>("Temperature").GetAwaiter().GetResult()
};
break;
case ControlRequestType.DecrementColorTemperature:
currentValue = Math.Round(applianceToControl.GetValue <Double>("Temperature").GetAwaiter().GetResult(), 2);
valueToSend = Math.Round(currentValue - adjustValue, 0).LimitToRange(1000, 10000);
// set the value
applianceToControl.SetValue("Temperature", valueToSend.ToString()).GetAwaiter().GetResult();
// read it back
response.payload.achievedState.colorTemperature = new ApplianceColorTemperatureValue
{
value = applianceToControl.GetValue <int>("Temperature").GetAwaiter().GetResult()
};
break;
default:
break;
}
}
else if (deviceType == DeviceType.Thermostat)
{
int previousTemperatureMode;
int temperatureMode;
Temperature previousTargetTemperature = null;
Temperature targetTemperature = null;
double deltaTemperatureC = 0.0; // in C
// obtain previous state (sys stores temperatures as K)
previousTemperatureMode = applianceToControl.GetValue <int>("TemperatureMode").GetAwaiter().GetResult();
previousTargetTemperature = new Temperature(applianceToControl.GetValue <double>("CurrentSetPoint").GetAwaiter().GetResult());
switch (requestType)
{
case ControlRequestType.SetTargetTemperature:
// get target temperature in C
targetTemperature = new Temperature
{
Celcius = double.Parse(alexaRequest.payload.targetTemperature.value)
};
break;
case ControlRequestType.IncrementTargetTemperature:
// get delta temp in C
deltaTemperatureC = double.Parse(alexaRequest.payload.deltaTemperature.value);
// increment the targetTemp
targetTemperature = new Temperature
{
Celcius = previousTargetTemperature.Celcius + deltaTemperatureC
};
break;
case ControlRequestType.DecrementTargetTemperature:
// get delta temp in C
deltaTemperatureC = double.Parse(alexaRequest.payload.deltaTemperature.value);
// decrement the targetTemp
targetTemperature = new Temperature
{
Celcius = previousTargetTemperature.Celcius - deltaTemperatureC
};
break;
default:
targetTemperature = new Temperature(0.00);
previousTemperatureMode = 10; // error
break;
}
// set new target temperature
applianceToControl.SetValue("CurrentSetPoint", targetTemperature.Kelvin.ToString()).GetAwaiter().GetResult();
response.payload.targetTemperature = new ApplianceValue
{
value = targetTemperature.Celcius.ToString()
};
// get new mode
temperatureMode = applianceToControl.GetValue <int>("TemperatureMode").GetAwaiter().GetResult();
// report new mode
response.payload.temperatureMode = new ApplianceValue
{
value = TemperatureMode.ModeToString(temperatureMode)
};
// alloc a previousState object
response.payload.previousState = new AppliancePreviousState
{
// report previous mode
mode = new ApplianceValue
{
value = TemperatureMode.ModeToString(previousTemperatureMode)
},
// report previous targetTemperature in C
targetTemperature = new ApplianceValue
{
value = previousTargetTemperature.Celcius.ToString()
}
};
}
else
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.UnsupportedOperationError;
response.payload.exception = new ExceptionResponsePayload();
}
}
catch
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.DriverpublicError;
response.payload.exception = new ExceptionResponsePayload();
}
return(response);
}
private ControlResponse ProcessControlRequestInternal(ControlRequest request)
{
ControlRequestInfo requestInfo = null;
using (var streamReader = new StreamReader(request.InputXml))
{
var readerSettings = XmlReaderSettingsFactory.Create(false);
readerSettings.CheckCharacters = false;
readerSettings.IgnoreProcessingInstructions = true;
readerSettings.IgnoreComments = true;
using (var reader = XmlReader.Create(streamReader, readerSettings))
{
requestInfo = ParseRequest(reader);
}
}
_logger.LogDebug("Received control request {0}", requestInfo.LocalName);
var result = GetResult(requestInfo.LocalName, requestInfo.Headers);
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
CloseOutput = false
};
StringWriter builder = new StringWriterWithEncoding(Encoding.UTF8);
using (var writer = XmlWriter.Create(builder, settings))
{
writer.WriteStartDocument(true);
writer.WriteStartElement("SOAP-ENV", "Envelope", NS_SOAPENV);
writer.WriteAttributeString(string.Empty, "encodingStyle", NS_SOAPENV, "http://schemas.xmlsoap.org/soap/encoding/");
writer.WriteStartElement("SOAP-ENV", "Body", NS_SOAPENV);
writer.WriteStartElement("u", requestInfo.LocalName + "Response", requestInfo.NamespaceURI);
foreach (var i in result)
{
writer.WriteStartElement(i.Key);
writer.WriteString(i.Value);
writer.WriteFullEndElement();
}
writer.WriteFullEndElement();
writer.WriteFullEndElement();
writer.WriteFullEndElement();
writer.WriteEndDocument();
}
var xml = builder.ToString().Replace("xmlns:m=", "xmlns:u=");
var controlResponse = new ControlResponse
{
Xml = xml,
IsSuccessful = true
};
//logger.LogDebug(xml);
controlResponse.Headers.Add("EXT", string.Empty);
return(controlResponse);
}
private ControlResponse ProcessControlRequestInternal(ControlRequest request)
{
var soap = new XmlDocument();
soap.LoadXml(request.InputXml);
var sparams = new Headers();
var body = soap.GetElementsByTagName("Body", NS_SOAPENV).Item(0);
var method = body.FirstChild;
foreach (var p in method.ChildNodes)
{
var e = p as XmlElement;
if (e == null)
{
continue;
}
sparams.Add(e.LocalName, e.InnerText.Trim());
}
var deviceId = "test";
IEnumerable <KeyValuePair <string, string> > result;
_logger.Debug("Received control request {0}", method.Name);
var user = _user;
if (string.Equals(method.LocalName, "GetSearchCapabilities", StringComparison.OrdinalIgnoreCase))
{
result = HandleGetSearchCapabilities();
}
else if (string.Equals(method.LocalName, "GetSortCapabilities", StringComparison.OrdinalIgnoreCase))
{
result = HandleGetSortCapabilities();
}
else if (string.Equals(method.LocalName, "GetSystemUpdateID", StringComparison.OrdinalIgnoreCase))
{
result = HandleGetSystemUpdateID();
}
else if (string.Equals(method.LocalName, "Browse", StringComparison.OrdinalIgnoreCase))
{
result = HandleBrowse(sparams, user, deviceId);
}
else if (string.Equals(method.LocalName, "X_GetFeatureList", StringComparison.OrdinalIgnoreCase))
{
result = HandleXGetFeatureList();
}
else if (string.Equals(method.LocalName, "X_SetBookmark", StringComparison.OrdinalIgnoreCase))
{
result = HandleXSetBookmark(sparams, user);
}
else if (string.Equals(method.LocalName, "Search", StringComparison.OrdinalIgnoreCase))
{
result = HandleSearch(sparams, user, deviceId);
}
else
{
throw new ResourceNotFoundException("Unexpected control request name: " + method.LocalName);
}
var env = new XmlDocument();
env.AppendChild(env.CreateXmlDeclaration("1.0", "utf-8", "yes"));
var envelope = env.CreateElement("SOAP-ENV", "Envelope", NS_SOAPENV);
env.AppendChild(envelope);
envelope.SetAttribute("encodingStyle", NS_SOAPENV, "http://schemas.xmlsoap.org/soap/encoding/");
var rbody = env.CreateElement("SOAP-ENV:Body", NS_SOAPENV);
env.DocumentElement.AppendChild(rbody);
var response = env.CreateElement(String.Format("u:{0}Response", method.LocalName), method.NamespaceURI);
rbody.AppendChild(response);
foreach (var i in result)
{
var ri = env.CreateElement(i.Key);
ri.InnerText = i.Value;
response.AppendChild(ri);
}
var controlResponse = new ControlResponse
{
Xml = env.OuterXml,
IsSuccessful = true
};
controlResponse.Headers.Add("EXT", string.Empty);
return(controlResponse);
}
/// <summary>
/// Decode input as a control parameters and set the fields of the
/// controlResponse object. Copy from the input when making new Blob values.
/// Your derived class should override.
/// </summary>
///
/// <param name="controlResponse"></param>
/// <param name="input"></param>
/// <exception cref="System.NotSupportedException">for unimplemented if the derivedclass does not override.</exception>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public void decodeControlResponse(ControlResponse controlResponse,
ByteBuffer input)
{
decodeControlResponse(controlResponse, input, true);
}
