public Response(string JSONResponse)
{
this.JSONString = JSONResponse;
JObject baseObject = JObject.Parse(JSONResponse);
this.Action = baseObject["ACTION"].ToObject <string>();
this.Payloads = new Collection <IResponsePayload>();
this.Errors = new Collection <ErrorPayload>();
JEnumerable <JToken> errChildrens = baseObject["ERRORARRAY"].Children();
foreach (JToken child in errChildrens)
{
ErrorPayload errPayload = new ErrorPayload();
errPayload.Deserialize(child);
this.Errors.Add(errPayload);
}
JEnumerable <JToken> childrens = baseObject["DATA"].Children();
foreach (JToken child in childrens)
{
IResponsePayload payload = Utils.GetPayloadClass(this.Action);
if (payload != null)
{
payload.Deserialize(child);
this.Payloads.Add(payload);
}
}
}
public void WriteFile(uint flashOffset, BufferedStream file)
{
byte[] buffer = new byte[1024];
uint localOffset = flashOffset;
int read = 0;
log.DebugFormat("Writing file to offset {0:X8}", flashOffset);
while ((read = file.Read(buffer, 0, 1024)) > 0)
{
PreloaderCommand response;
PreloaderCommand cmd = new PreloaderCommand(new WriteFlashPayload(localOffset, buffer));
byte[] data = cmd.Serialize();
if (!transmitCommand(cmd, 1000, out response))
{
throw new Exception("Failure during transmitting writeflash command");
}
if (response.payload is WriteFlashPayload)
{
localOffset += (uint)read;
}
else if (response.payload is ErrorPayload)
{
ErrorPayload errorpl = (ErrorPayload)response.payload;
log.ErrorFormat("Error received from device: {0} with Message: {1}", errorpl.ErrorCode, errorpl.Message);
throw new Exception(String.Format("Error received from device: {0} with Message: {1}", errorpl.ErrorCode, errorpl.Message));
}
else if (response.payload is MessagePayload)
{
MessagePayload msgpl = (MessagePayload)response.payload;
log.ErrorFormat("Message received from device: {0}", msgpl.Message);
throw new Exception(String.Format("Message received from device: {0}", msgpl.Message));
}
}
}
internal SharedErrorEventArgs(ErrorPayload data)
{
this.Error = data.Error;
this.Name = data.Name;
this.Description = data.Description;
this.SourceId = data.ClientId;
}
// Continues a conversation with the server by receiving a response to a packet sent with 'Send' or 'SendReply'.
public ValueTask <PayloadData> ReceiveReplyAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)
{
ValueTask <ArraySegment <byte> > task;
try
{
VerifyConnected();
task = m_payloadHandler.ReadPayloadAsync(m_payloadCache, ProtocolErrorBehavior.Throw, ioBehavior);
}
catch (Exception ex)
{
if ((ex as MySqlException)?.Number == (int)MySqlErrorCode.CommandTimeoutExpired)
{
HandleTimeout();
}
task = ValueTaskExtensions.FromException <ArraySegment <byte> >(ex);
}
if (task.IsCompletedSuccessfully)
{
var payload = new PayloadData(task.Result);
if (payload.HeaderByte != ErrorPayload.Signature)
{
return(new ValueTask <PayloadData>(payload));
}
var exception = ErrorPayload.Create(payload).ToException();
return(ValueTaskExtensions.FromException <PayloadData>(exception));
}
return(new ValueTask <PayloadData>(task.AsTask().ContinueWith(TryAsyncContinuation, cancellationToken, TaskContinuationOptions.LazyCancellation | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)));
}
public async Task <PostBitmapResponse> PostBitmap(string url, Dictionary <string, string> json)
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders
.Accept
.Add(new MediaTypeWithQualityHeaderValue("application/json"));
StringContent content = new StringContent(JsonConvert.SerializeObject(json).ToString(), Encoding.UTF8, "application/json");
HttpResponseMessage resp = await client.PostAsync(url, content);
int statusCode = (int)resp.StatusCode;
if (statusCode == 400 || statusCode == 429 || statusCode == 500)
{
ErrorPayload err = JsonConvert.DeserializeObject <ErrorPayload>(await resp.Content.ReadAsStringAsync());
string errorText = $"[{err.Title}] - {err.ErrorCode} : {err.Description}";
ConsoleEx.WriteColoredLine(Discord.LogSeverity.Critical, ConsoleTextFormat.TimeAndText, errorText);
return(new PostBitmapResponse(null, new ResponseStatus(false, errorText)));
}
Stream stream = await resp.Content.ReadAsStreamAsync();
stream.Seek(0, SeekOrigin.Begin);
Image <Rgba32> img = Image.Load(stream);
return(new PostBitmapResponse(img, new ResponseStatus(true, "")));
}
}
public void T_ErrorPayload_1()
{
var model = new ErrorPayload()
{
Data = new Dictionary <string, string>(),
Message = "message",
StackTrace = "stack trace",
StatusCode = 200
};
model.Data.Add("k1", "v1");
model.Data.Add("k2", "v2");
Helpers.AssertHelper.AssertSerialization <ErrorPayload>(model, this.TestContext);
}
public static PreloaderCommand Deserialize(byte[] packet, int length)
{
if (packet[0] != DELIMITER || packet[length - 1] != DELIMITER)
{
throw new ArgumentException("Not a valid Preloader command");
}
byte[] alldata = unescapeBuf(packet, 1, length - 2);
byte[] payload = new byte[alldata.Length - 2];
Array.Copy(alldata, payload, payload.Length);
ushort crc = Utilities.crc16(payload);
ushort packetCrc = (ushort)(alldata[alldata.Length - 2] << 8 | (alldata[alldata.Length - 1] & 0xFF));
if (crc != packetCrc)
{
Console.WriteLine("Crc not equal!? {0} {1}", crc, packetCrc);
}
CommandType commandtype = (CommandType)Enum.ToObject(typeof(CommandType), payload[0]);
IPreloaderPayload preloaderPayload;
switch (commandtype)
{
case CommandType.MagicRsp:
preloaderPayload = MagicPayload.Deserialize(payload);
break;
case CommandType.WriteFlashCmd:
case CommandType.WriteFlashRsp:
preloaderPayload = WriteFlashPayload.Deserialize(payload);
break;
case CommandType.MessageRsp:
preloaderPayload = MessagePayload.Deserialize(payload);
break;
case CommandType.ErrorRsp:
preloaderPayload = ErrorPayload.Deserialize(payload);
break;
default:
preloaderPayload = BytePayload.Deserialize(payload);
break;
}
return(new PreloaderCommand(preloaderPayload));
}
private void RaiseMessageReceived(IEnumerable <Payload> events)
{
foreach (Payload payload in events)
{
MessagePayload messagePayload = (MessagePayload)payload;
if (this.MessageReceived == null)
{
var error = new ErrorPayload(SharedObjects.Error.General, "Message ignored.",
"Your client received a message. The message was ignored because the MessageReceived handler is not registered.", messagePayload.ClientId, Payload.NextId);
RaiseError(error);
}
else
{
this.MessageReceived(this, new MessageEventArgs(messagePayload.ClientId, messagePayload.Message));
}
}
}
public async Task Post()
{
//Arrange
ErrorPayload pushed = null;
var inbox = new SerializedErrorsInbox();
inbox.GetErrorsStream().Subscribe(p =>
{
pushed = p;
});
//Act
await inbox.Post(new ErrorPayload("sourceId", new Error(), "errorId", string.Empty));
//Assert
Assert.NotNull(pushed);
Assert.Equal("errorId", pushed.ErrorId);
}
public void TestGeneralErrorResponse()
{
SmartHomeResponse responseFromString = JsonConvert.DeserializeObject<SmartHomeResponse>(GENERAL_ERROR);
//Context check
Assert.Null(responseFromString.Context);
//Event Check
Assert.Equal(typeof(Event), responseFromString.Event.GetType());
Event e = responseFromString.Event as Event;
TestFunctionsV3.TestHeaderV3(e.Header, "5f8a426e-01e4-4cc9-8b79-65f8bd0fd8a4", Namespaces.ALEXA, HeaderNames.ERROR_RESPONSE);
Assert.Equal("dFMb0z+PgpgdDmluhJ1LddFvSqZ/jCc8ptlAKulUj90jSqg==", e.Header.CorrelationToken);
//Endpoint
TestFunctionsV3.TestEndpointV3(e.Endpoint, "endpoint-001");
TestFunctionsV3.TestBearerTokenV3(e.Endpoint.Scope, "access-token-from-Amazon");
//Payload
Assert.Equal(typeof(ErrorPayload), responseFromString.GetPayloadType());
ErrorPayload p = e.Payload as ErrorPayload;
Assert.Equal(ErrorTypes.ENDPOINT_UNREACHABLE, p.Type);
Assert.Equal("Unable to reach endpoint-001 because it appears to be offline", p.Message);
}
public static ObjectResult Error(HttpStatusCode httpStatusCode, string code, string messageToDeveloper, string messageToUserTh, string messageToUserEn)
{
var error = new ErrorPayload
{
errorId = Guid.NewGuid().ToString(),
code = code,
messageToDeveloper = messageToDeveloper,
messageToUser = new ErrorPayloadMessageToUserDetail
{
langTh = messageToUserTh,
langEn = messageToUserEn
},
created = DateTimes.GetCurrentUtcDateTimeInThaiTimeZone(DateTimes.DateTimeFormat.YearMonthDayByDashTHourMinuteSecondByColonZ, DateTimes.LanguageCultureName.ENGLISH_UNITED_STATES, DateTimes.DateTimeUtcOffset.HHMM)
};
var objResult = new ObjectResult(new { error });
objResult.StatusCode = (int)httpStatusCode;
return(objResult);
}
public void TestGeneralErrorResponse()
{
SmartHomeResponse responseFromString = JsonConvert.DeserializeObject <SmartHomeResponse>(GENERAL_ERROR);
//Context check
Assert.Null(responseFromString.Context);
//Event Check
Assert.Equal(typeof(Event), responseFromString.Event.GetType());
Event e = responseFromString.Event as Event;
TestFunctionsV3.TestHeaderV3(e.Header, "5f8a426e-01e4-4cc9-8b79-65f8bd0fd8a4", Namespaces.ALEXA_THERMOSTATCONTROLLER, HeaderNames.ERROR_RESPONSE);
Assert.Equal("dFMb0z+PgpgdDmluhJ1LddFvSqZ/jCc8ptlAKulUj90jSqg==", e.Header.CorrelationToken);
//Endpoint
TestFunctionsV3.TestEndpointV3(e.Endpoint, "endpoint-001");
TestFunctionsV3.TestBearerTokenV3(e.Endpoint.Scope, "access-token-from-Amazon");
//Payload
Assert.Equal(typeof(ErrorPayload), responseFromString.GetPayloadType());
ErrorPayload p = e.Payload as ErrorPayload;
Assert.Equal(ErrorTypes.THERMOSTAT_IS_OFF, p.Type);
Assert.Equal("The thermostat is off, cannot turn on due to safety reasons", p.Message);
}
public ErrorsMiddleware(OwinMiddleware next, IErrorsInbox inbox, string prefix)
: base(next)
{
Router.Build(builder => builder
.WithPrefix(prefix)
.ForRoute("post-error", route => route
.Post(async(environment, keys, form) =>
{
var errorText = Encoding.UTF8.GetString(Convert.FromBase64String(form.Get("error")));
var sourceId = RetrieveSourceId(form);
var errorId = form.Get("errorId");
var infoUrl = form.Get("infoUrl");
var payload = new ErrorPayload(sourceId, JsonConvert.DeserializeObject <Error>(errorText), errorId, infoUrl);
await inbox.Post(payload);
return(payload);
})
)
);
}
public void ResponseCreation_GeneralError_Test()
{
SmartHomeRequest request = JsonConvert.DeserializeObject <SmartHomeRequest>(SET_T_TEMPERATURE_TRIPLEMODE_REQUEST);
SmartHomeResponse response = SmartHomeResponse.CreateErrorResponse(request.Directive.Header, ErrorTypes.THERMOSTAT_IS_OFF);
Assert.Null(response.Context);
Assert.NotNull(response.Event);
Assert.Equal(typeof(Event), response.Event.GetType());
Event e = response.Event as Event;
TestFunctionsV3.CheckResponseCreatedBaseHeader(e.Header, request.Directive.Header, Namespaces.ALEXA_THERMOSTATCONTROLLER, HeaderNames.ERROR_RESPONSE);
Assert.Null(e.Endpoint);
e.Endpoint = new Endpoint("endpoint-001", new NET.JsonObjects.Scopes.BearerToken("access-token-from-Amazon"));
Assert.NotNull(e.Payload);
Assert.Equal(typeof(ErrorPayload), response.GetPayloadType());
ErrorPayload p = response.Event.Payload as ErrorPayload;
Assert.Equal(ErrorTypes.THERMOSTAT_IS_OFF, p.Type);
Assert.Null(p.Message);
Assert.Throws <JsonSerializationException>(() => JsonConvert.SerializeObject(response));
p.Message = "The thermostat is off, cannot turn on due to safety reasons";
Assert.NotNull(JsonConvert.SerializeObject(response));
Util.Util.WriteJsonToConsole("GeneralErrorThermostat", response);
}
public Task Post(ErrorPayload payload)
{
return(_errorsBacklog
.Store(payload)
.ContinueWith(_ => _queue.Add(payload)));
}
public void Error(ErrorPayload payload)
{
}
public void Error(string user, ErrorPayload payload)
{
ErrorsHub.Error(user, payload);
}
public static void Error(string user, ErrorPayload payload)
{
GlobalHost.ConnectionManager.GetHubContext <ErrorsHub>().Clients.User(user).error(payload);
}
internal void RaiseError(ErrorPayload payload)
{
RaiseError(payload.ToSharedErrorEventsArgs());
}
public Task Store(ErrorPayload payload)
{
return(Task.Factory.StartNew(() => _errors.Add(payload)));
}
public void Error(ErrorPayload payload)
{
_context.Clients.All.Error(payload);
}
internal void RaiseError(ErrorPayload payload)
{
RaiseError(payload.ToSharedErrorEventsArgs());
}
public Task Post(ErrorPayload payload)
{
return(_errorsBacklog
.Store(payload)
.ContinueWith(_ => _errors.OnNext(payload)));
}
public void Error(ErrorPayload payload)
{
Clients.Others.error(payload);
}
public void Error(ErrorPayload payload)
{
_proxy.Invoke("Error", payload);
}
public Task Store(ErrorPayload payload)
{
return(Task.FromResult((object)null));
}
