public async Task SerializationExceptionFromClassUsedInStreamsAndAlsoStateTestTest()
{
Guid facilityGuid = Guid.NewGuid();
MessageContract messageReceivedFromStream = null;
#region Stream setup spy
IStreamProvider callpointStreamProvider = _fixture.HostedCluster.StreamProviderManager.GetStreamProvider("StreamProvider");
IAsyncStream <MessageContract> callpointStream = callpointStreamProvider.GetStream <MessageContract>(facilityGuid, "Namespace");
var subHandle = callpointStream.SubscribeAsync((message, token) =>
{
messageReceivedFromStream = message;
return(TaskDone.Done);
});
IStreamProvider streamProvider = _fixture.HostedCluster.StreamProviderManager.GetStreamProvider("StreamProviderOther");
IAsyncStream <SomeOtherMessage> messageStream = streamProvider.GetStream <SomeOtherMessage>(facilityGuid, "NamespaceOther");
#endregion
var aceMessage = new SomeOtherMessage
{
MyProp = "MyProp"
};
await messageStream.OnNextAsync(aceMessage);
await Task.Delay(TimeSpan.FromMilliseconds(1000));
Assert.NotNull(messageReceivedFromStream);
Assert.IsType <MessageContract>(messageReceivedFromStream);
}
public void SerializeMessageContract_ARandomString_DeserializesCorrectly()
{
MessageContractByteSerializer serializer = new MessageContractByteSerializer();
using MemoryStream ms = new MemoryStream();
Random randy = new Random();
for (int i = 0; i < 100; i++)
{
byte[] randBuffer = new byte[randy.Next(32, 1024)];
randy.NextBytes(randBuffer);
string randString = Encoding.ASCII.GetString(randBuffer);
MessageContract contract = new MessageContract
{
Message = randString
};
int bytesWritten = serializer.SerializeMessageContract(contract, ms);
ms.Position -= bytesWritten;
MessageContract deserializedContract = serializer.DeserializeStreamIntoMessageContract(ms);
Assert.AreEqual(contract.Message, deserializedContract.Message);
}
}
public void CreateMessage(MessageContract message)
{
try
{
if (message.EmailAccounts == null || message.EmailAccounts.Count <= 0)
{
throw new InvalidOperationException("Message contract does not have ant emails attahed.");
}
/*using (var _dbcontext = new MessageDbContext())
* {
* var messages = _dbcontext.MessageTables.Include(m => m.User)
* .ToList();
* // System.Data.Entity;
* }*/
MessageTable newMessage = CreateNewMessage(message);
PersistMessage(newMessage);
CreateMessageTransaction(message, newMessage);
PersistMessageToMongoDbService(newMessage);
}
catch (FaultException <MessageQueueErrorContract> exception)
{
throw;
}
catch (Exception exception)
{
RerouteErrorMessage(exception.Message);
}
}
public async Task BuildAsync()
{
if (!_messages.Any())
{
throw new PactException("Cannot build pact. No messages.");
}
var pact = new MessageContract
{
Consumer = new Pacticipant {
Name = _consumer
},
Provider = new Pacticipant {
Name = _provider
},
Messages = _messages
};
if (_pactDir != null)
{
PactWriter.Write(pact, _pactDir);
}
else
{
PactWriter.Write(pact);
}
if (_pactPublisher != null)
{
await _pactPublisher.PublishAsync(pact);
}
}
private void Listen(MessageContract message)
{
Dispatcher.Invoke(() =>
{
// Set property or change UI compomponents.
ChatBox.Text += "\r\n" + message.Value;
});
}
public object Call(MessageContract contract)
{
if (_client.SendAsync(contract).Wait(ConfigurableTimeout))
{
return(_client.ReceiveAsync().Result);
}
throw new Exception(string.Format("Error invoking {0} remote service method.", contract.MethodName));
}
/// <summary>
/// Sends a new <see cref="MessageContract"/>.
/// </summary>
/// <param name="message">The new <see cref="MessageContract"/>.</param>
public void SendMessage(MessageContract message)
{
this.ManageException(
action: () =>
{
var newMessage = message.FromContract();
this.store.AddMessage(message: newMessage);
this.notificationManager.NotifyNewMessage(message: newMessage);
},
description: "SendMessage");
}
private async Task HandleMessage(MessageContract msg, StreamSequenceToken t)
{
_logger.Info($"facility={this.GetPrimaryKey()} Publishing msg={msg}");
var orleansStreamProvider = base.GetStreamProvider("StreamProvider");
var stream = orleansStreamProvider.GetStream <MessageContract>(this.GetPrimaryKey(), "Namespace");
#if CAUSE_THE_TEST_TO_FAIL_WITH_SERIALIZATION_EXCEPTION_SOMETIMES
//this.State.MessageContract = msg;
#endif
await WriteStateAsync();
}
public Task <TResponse> Send <TResponse>(MessageType messageType, object data)
{
var message = MessageContract.Create(messageType, data);
var taskCompletionSource = new TaskCompletionSource <IMessageContract>();
var correlationId = Guid.NewGuid();
pendingMessages.TryAdd(correlationId, taskCompletionSource);
Publish(message, correlationId);
return(taskCompletionSource.Task.ContinueWith(t => (TResponse)t.Result.Data));
}
public static MessageDto ToDto(this MessageContract contract)
{
if (contract == null)
{
return(null);
}
return(new MessageDto()
{
Date = contract.Date,
Id = contract.Id,
Text = contract.Text,
ReceiverId = contract.ReceiverId
});
}
private async Task HandleMessage(SomeOtherMessage msg, StreamSequenceToken t)
{
_logger.Info($"facility={this.GetPrimaryKey()} Publishing msg={msg}");
var orleansStreamProvider = base.GetStreamProvider("StreamProvider");
var stream = orleansStreamProvider.GetStream <MessageContract>(this.GetPrimaryKey(), "Namespace");
MessageContract outboundMessage = new MessageContract
{
MyProp = msg.MyProp
};
await stream.OnNextAsync(outboundMessage);
}
/// <summary>
/// Converts a <see cref="MessageContract"/> to a <see cref="Message"/>.
/// </summary>
/// <param name="contract">The <see cref="MessageContract"/> to convert.</param>
/// <returns>The <see cref="Message"/>.</returns>
public static Message FromContract(this MessageContract contract)
{
if (contract == null)
{
throw new ArgumentNullException(paramName: nameof(contract));
}
if (string.IsNullOrEmpty(value: contract.Content))
{
throw new ArgumentNullException(paramName: nameof(contract), message: "message content can't be null");
}
return(new Message(ownerId: contract.OwnerId, content: contract.Content, dateTime: contract.DateTime));
}
public async Task <IActionResult> SendMessage(MessageContract message)
{
var userId = User.Claims.FirstOrDefault(x => x.Type == "UserID").Value;
if (userId != message.ReceiverId)
{
await _hubContext.Clients.User(userId).SendAsync("Receive", message);
}
await _hubContext.Clients.User(message.ReceiverId).SendAsync("Receive", message);
await _messageService.Create(new MessageDto { Date = DateTime.Now, Text = message.Text, ReceiverId = message.ReceiverId, UserId = userId });
return(Ok());
}
public async Task PingEvent()
{
while (true)
{
if (socket != null && socket.IsConnected)
{
MessageContract ping = new MessageContract();
//ping.Type = "Ping";
await SendMessage(JsonConvert.SerializeObject(ping));
}
Thread.Sleep(2 * 60 * 1000);
}
}
public void TestValidationsRule()
{
GlobalInitalization.Initialize();
SignalGo.Client.ClientProvider client = GlobalInitalization.InitializeAndConnecteClient();
ITestServerModel service = client.RegisterServerServiceInterfaceWrapper <ITestServerModel>();
ArticleInfo result = service.AddArticle(new ArticleInfo()
{
Name = "ali", Detail = "rezxa"
});
Assert.IsTrue(result.CreatedDateTime.HasValue);
MessageContract <ArticleInfo> resultMessage = service.AddArticleMessage(new ArticleInfo());
Assert.IsTrue(resultMessage.Errors.Count == 2);
Assert.IsFalse(resultMessage.IsSuccess);
}
public static UM_Message ToEntity(this MessageContract contract)
{
if (contract == null)
{
return(null);
}
var entity = new UM_Message();
entity.ID = contract.ID;
entity.Text = contract.Text;
entity.ObjectID = contract.ObjectID;
entity.Type = contract.Type;
entity.DateChanged = contract.DateChanged;
entity.DateCreated = contract.DateCreated;
entity.DateDeleted = contract.DateDeleted;
return(entity);
}
public static MessageContract ToContract(this UM_Message entity)
{
if (entity == null)
{
return(null);
}
var contract = new MessageContract();
contract.ID = entity.ID;
contract.Text = entity.Text;
contract.ObjectID = entity.ObjectID;
contract.Type = entity.Type;
contract.DateCreated = entity.DateCreated;
contract.DateChanged = entity.DateChanged;
contract.DateDeleted = entity.DateDeleted;
return(contract);
}
public async Task <object> ProcessWebhook(MessageContract contract)
{
var message = "";
try
{
if (contract.Message.Location != null)
{
var userLocation = contract.Message.Location;
var r = await _weatherRepository.GetWeather(new WeatherRequest { Latitude = userLocation.Latitude, Longitude = userLocation.Longitude });
message = FormatMessage(r.Main.Temp, r.Wind.Speed);
}
else
{
var geocodingResult = await _nominatimSearchRepository.GetPoints(new NominatimSearchRequest { SearchText = contract.Message.Text });
var places = geocodingResult.Where(x => x.ClassName == "place");
if (!places.Any())
{
throw new Exception();
}
var placeLocation = places.FirstOrDefault();
var r = await _weatherRepository.GetWeather(new WeatherRequest { Latitude = placeLocation.Latitude, Longitude = placeLocation.Longitude });
message = FormatMessage(r.Main.Temp, r.Wind.Speed);
}
}
catch
{
message = "К сожалению Я не смог определить температуру рядом с Вами";
}
finally
{
await _telegramMessageRepository.SendMessage(contract.Message.Chat.Id, message);
}
//"*bold text*_italic text_[text](URL)`inline fixed-width code````pre - formatted fixed-width code block```");
return(true);
}
private void HandleResponse(object sender, BasicDeliverEventArgs e)
{
try
{
var responseValue = MessageContract.Deserialize(e.Body.ToArray());
var correlationId = e.BasicProperties.CorrelationId;
logger.LogInformation($"Received {responseValue?.MessageType} message with CorrelationId {correlationId}");
if (pendingMessages.TryRemove(Guid.Parse(correlationId), out var taskCompletionSource))
{
taskCompletionSource.SetResult(responseValue);
}
}
catch (Exception ex)
{
logger.LogError($"Error {ex.Message}");
}
}
public MessageRequestTokenContract CreateMessage(MessageContract message)
{
try
{
CreateMessageBl createMessageL = new CreateMessageBl();
return(createMessageL.CreateMessage(message));
}
catch (TokenValidationException exception)
{
WriteErrorLog("Encontered a token validation error when trying to create a message.", exception);
ErrorContract error = new ErrorContract(exception.Message, StatusList.VALIDATION_ERROR);
throw new FaultException <ErrorContract>(error);
}
catch (Exception exception)
{
WriteErrorLog("Encontered an error when trying to create a message.", exception);
MessageRequestTokenContract tokenContract = CreateMessageStateTokenContract(MessageReceivedState.FailedToProcessRequest, exception.Message);
throw new FaultException <MessageRequestTokenContract>(tokenContract);
}
}
private void HandleMessage(object sender, BasicDeliverEventArgs e)
{
var correlationId = e.BasicProperties.CorrelationId;
try
{
var receivedMessage = MessageContract.Deserialize(e.Body.ToArray());
Console.WriteLine($"Received {receivedMessage?.MessageType} message with CorrelationId {correlationId}");
var responseValue = messageCoordinator.HandleMessage(receivedMessage);
var responseMessage = MessageContract.Create(receivedMessage.MessageType, responseValue);
PublishResponse(responseMessage, correlationId, responseQueueName);
}
catch (Exception ex)
{
Console.WriteLine($"Error occurred during handling of a message with a {correlationId} correlationId - {ex.Message}");
}
}
private bool ShouldDisplayAvatar(MessageContract message, int messageIndex) => !(messageIndex > 0 && messages[messageIndex - 1].User.UserId == message.User.UserId && message.User.UserId != null);
private bool ShouldDisplayName(MessageContract message, int messageIndex) => !(messageIndex + 1 < messages.Count && messages[messageIndex + 1].User.UserId == message.User.UserId && message.User.UserId != null);
/// <summary>
/// Sends a new <see cref="MessageContract"/>.
/// </summary>
/// <param name="message">The new <see cref="MessageContract"/>.</param>
public void SendMessage(MessageContract message)
{
this.Channel.SendMessage(message: message);
}
public abstract void Invoke(MessageContract messageContract);
public void CallBack(MessageContract.MessageSample message)
{
Console.WriteLine("这是WCF回调结果");
Console.WriteLine("Message Header: "+ message.Header);
Console.WriteLine("Message Text: "+ message.Text);
}
public async Task SendMessage(MessageContract message)
{
await _bus.SendAsync <MessageContract>("ApiToWpf", message);
}
public async Task <IActionResult> ProcessPushWebhook([FromBody] MessageContract contract)
{
return(await CallWithErrorHandlingAsync(async() => await _telegramModule.ProcessWebhook(contract)));
}
private IMessageContract CreateTestMessage()
{
var messageData = new { someValue = 1 };
return(MessageContract.Create(MessageType.CalculateAverage, messageData));
}
public async Task Execute(MessageContract message)
{
await _hubContext.Clients.All.SendAsync("SignalRMessageReceived", message.Value);
}
