public void JoinTraceErrorDescription(int errorCode)
{
if (!SentMessages.Contains(Step))
{
GetTraceErrorDescription?.Invoke(CycleID, errorCode);
}
}
public void StartRFID(string name)
{
if (!SentMessages.Contains(Step))
{
TriggerRFID?.Invoke(name, true);
}
}
public void SendMessage(MessagePayload message)
{
lock (SendLock)
{
lock (AliveLock)
{
if (DeathException != null)
{
throw DeathException;
}
}
try
{
Byte[] data = message.ToBytes();
Stream.Write(data, 0, data.Length);
SentMessages.Add(message);
}
catch
{
lock (AliveLock)
{
if (DeathException == null)
{
Alive = false;
DeathException = new ConnectionDeadException("SendMessage threw exception.");
}
}
throw DeathException;
}
}
}
public void JoinMessage(string text)
{
if (!SentMessages.Contains(Step))
{
NewInstructionTextByText?.Invoke(CycleID, text);
}
}
public void StopRFID(string name)
{
if (!SentMessages.Contains(Step))
{
TriggerRFID?.Invoke(name, false);
SentMessages.Remove(Step);
}
}
void EndMessage()
{
Ended = true;
message.endTime = StepCount;
SentMessages.Add(message);
AllTime += message.delayTime;
Form1.AverageTime = AllTime / SentMessages.Count;
}
public void EndMessage()
{
if (!SentMessages.Contains(Step))
{
SentMessages.Add(Step);
EndOfInstructionText?.Invoke(CycleID);
}
}
public void BookingDeletedMessage(string receiverId)
{
var content = $"Your booking at {Name} was deleted.";
var messageData = new MessageData("Booking Deleted", content);
var metadata = new MessageMetadata(false, false);
SentMessages.Add(new Message(Id, receiverId, messageData, MessageType.BookingDeleted, metadata));
}
public void StopScanner(string name)
{
if (!SentMessages.Contains(Step))
{
TriggerScanner?.Invoke(name, false);
SentMessages.Remove(Step);
CounterTimeout = 0;
}
}
public void ShowPotiResultPicture(Dictionary <EngineData.AI, int> analogResults = null, Dictionary <EngineData.DI, int> digiResults = null, string resourceName = null)
{
if (!SentMessages.Contains(Step))
{
ShowPotiPicture?.Invoke(CycleId, analogResults, digiResults, resourceName);
SentMessages.Add(Step);
HMI.PanelStatus(EngineData.Screens.ImageMachineResults);
}
}
public bool SendMessage(string channel, string message)
{
SentToChannel = channel;
SentMessages.Add(message);
// TODO: Implement some kind of event trigger when a message is sent so
// that unit tests can use longer timeouts but still complete as soon
// as a message is sent..
return(true);
}
public async Task ReadHandshakeAndSendResponseAsync()
{
await SentMessages.ReadAsync();
var output = new MemoryStream();
HandshakeProtocol.WriteResponseMessage(HandshakeResponseMessage.Empty, output);
await _receivedMessages.Writer.WriteAsync(output.ToArray());
}
public virtual UserMessage SendMessage(User to, string subject, string body, bool highPriority)
{
ParamIs.NotNull(() => to);
var msg = new UserMessage(this, to, subject, body, highPriority);
SentMessages.Add(msg);
to.ReceivedMessages.Add(msg);
return(msg);
}
// UWP App (Device Client) -> IoT Device
public static async Task SendMessageAsync(DeviceClient deviceClient, SentMessages sentMessages)
{
// Anropa och vänta in resultat från OpenWeatherMap via WeatherService
var data = await WeatherService.FetchWeatherData();
// Konvertera till JSON & vidare till bytes
string json = JsonConvert.SerializeObject(data);
await deviceClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes(json)));
sentMessages.Insert(0, new SentMessageModel(data.Temperature, data.Humidity));
}
public void ClearSentMessage(string index)
{
int msgIndex = Convert.ToInt32(index);
foreach (Message sentMsg in SentMessages)
{
if (sentMsg.Index == msgIndex)
{
SentMessages.Remove(sentMsg);
break;
}
}
}
void Listener_Notify(object sender, NotifyEventArgs e)
{
if (e.Type == NotifyType.Received)
{
ReceivedMessages.Add(e.Message);
}
else if (e.Type == NotifyType.Sent)
{
SentMessages.Add(e.Message);
}
else
{
Messages.Add(e.Message);
}
}
internal Task PostMessageAsync(OutgoingMessage message, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
SentMessages.Add(message);
if (SimulateFailure)
{
throw new JsonApiException(new Error(HttpStatusCode.ServiceUnavailable)
{
Title = "Message delivery failed."
});
}
return(Task.CompletedTask);
}
public virtual Tuple <UserMessage, UserMessage> SendMessage(User to, string subject, string body, bool highPriority)
{
ParamIs.NotNull(() => to);
var received = UserMessage.CreateReceived(this, to, subject, body, highPriority);
to.ReceivedMessages.Add(received);
to.Messages.Add(received);
var sent = UserMessage.CreateSent(this, to, subject, body, highPriority);
SentMessages.Add(sent);
Messages.Add(sent);
return(Tuple.Create(received, sent));
}
public ZenBotMessageQueue(ILoopBreaker loopBreaker, ChatBotConnection connection, int queueSize = 4)
{
QueueSize = queueSize;
LoopBreaker = loopBreaker;
Connection = connection;
for (int i = 0; i < queueSize; i++)
{
SentMessages.Add(new ZenBotMessage()
{
Message = ""
});
ReceivedAnswers.Add(new ZenBotMessage()
{
Message = ""
});
}
}
public IAsyncResult BeginDispatch(TimeSpan timeout, IMessage msg, object state, AsyncCallback callback)
{
var r = new GenericAsyncResult(state)
{
Callback = callback,
UniqueIdentifier = msg.UniqueIdentifier
};
_syncro.WaitOne();
_activeMessages.Add(msg.UniqueIdentifier, r);
_syncro.Set();
SentMessages.Inc(1);
var obuff = GZip.SerializeAndCompress(msg);
SentBytes.Inc((ulong)obuff.GetLength(0));
_outChannel.Send(obuff);
return(r);
}
public bool StartScanner(string name)
{
if (!SentMessages.Contains(Step))
{
if (CounterTimeout < 100)
{
TriggerScanner?.Invoke(name, true);
SentMessages.Add(Step);
CounterTimeout++;
}
else
{
CounterTimeout = 0;
return(false);
}
return(true);
}
CounterTimeout = 0;
return(false);
}
public void SendMessage(ZenBotMessage message)
{
if (SentMessages.Contains(message))
{
message.Message = LoopBreaker.GetRandomMessage();
}
SentMessages.Add(message);
var answer = Connection.SendMessage(message.Message).Result;
ReceivedAnswers.Add(new ZenBotMessage()
{
Message = answer
});
if (ReceivedAnswers.Count > QueueSize)
{
ReceivedAnswers.RemoveAt(0);
}
if (SentMessages.Count > QueueSize)
{
SentMessages.RemoveAt(0);
}
}
public void ReleaseCycleMessages()
{
SentMessages.Clear();
}
public override void Send(string queue, Message message)
{
SentMessages.Add(message);
}
public async Task <string> ReadSentTextMessageAsync()
{
var message = await SentMessages.ReadAsync();
return(Encoding.UTF8.GetString(message));
}
public void ClearInstructions()
{
SentMessages.Add(Step);
ClearInstructionText?.Invoke(CycleID);
}
internal void Reset()
{
SimulateFailure = false;
SentMessages.Clear();
}
public void SendMessage(SmsMessage sendMessage)
{
SentMessages.Add(sendMessage);
System.Diagnostics.Trace.WriteLine($"SendMessage: {sendMessage.phone} - {sendMessage.message}");
}
public void Send(RealtimeTransportData data)
{
SendAction(data);
SentMessages.Add(data);
}
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
SentMessages.Add(message);
return(Task.CompletedTask);
}
