public static async Task <IMqttClient> StartClient(BaseMessageHandler handler)
{
var client = new MqttFactory().CreateMqttClient();
client.UseApplicationMessageReceivedHandler(e =>
{
var Payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
if (Payload.IndexOf('|') != -1)
{
var Channel = e.ApplicationMessage.Topic;
var Type = Payload.Split("|")[0];
var Context = Payload.Substring(Type.Length + 1);
GeneratedMessage.Dispatch(handler, Channel, Type, Context);
}
});
var clientOptions = new MqttClientOptionsBuilder()
.WithClientId("ClientID")
.WithTcpServer("127.0.0.1")
.WithCleanSession()
.Build();
await client.ConnectAsync(clientOptions);
foreach (var channel in GeneratedMessage.channels)
{
await client.SubscribeAsync(new TopicFilterBuilder().WithTopic(channel).Build());
}
return(client);
}
public void ShouldSerializeArrays()
{
var serializer = BaseMessageHandler.CreateSerializer();
var arr = new[]
{
new MonsterPartModel
{
Health = 32.42f,
Index = 0
},
new MonsterPartModel
{
Health = 23.42f,
Index = 1
}
};
var serialized = SerializeToString(serializer, arr);
this.testOutput.WriteLine(serialized);
var deserialized = DeserializeFromString <MonsterPartModel[]>(serializer, serialized);
Assert.Equal(arr, deserialized);
}
protected virtual void ClearMessageHandler()
{
if (_messageHandler != null)
{
_messageHandler.OnReceiveMessage -= MessageHandler_OnReceiveMessage;
_messageHandler = null;
}
}
public static void Handle(BaseMessageHandler handler, string channel, string text)
{
if (text.IndexOf('|') != -1)
{
var type = text.Split("|")[0];
var context = text.Substring(type.Length + 1);
GeneratedMessage.Dispatch(handler, channel, type, context);
}
}
public virtual void Inject(
SignalBus signalBus,
BaseMessageHandler messageHandler,
ISelectedListener <WriterSceneInfoSelectedEventArgs> sceneInfoSelectedListener,
[Inject(Id = SaveType.Autosave)] IEncounterWriter encounterWriter)
{
SignalBus = signalBus;
MessageHandler = messageHandler;
SceneInfoSelectedListener = sceneInfoSelectedListener;
EncounterWriter = encounterWriter;
}
public MenuEncounterEditStarter(
BaseMessageHandler messageHandler,
IEncounterLocker encounterLocker,
IWriterSceneStarter sceneStarter,
IEncounterReader encounterReader,
BaseMenuEncounterMetadataSelector metadataSelector)
{
MessageHandler = messageHandler;
EncounterLocker = encounterLocker;
SceneStarter = sceneStarter;
EncounterReader = encounterReader;
MetadataSelector = metadataSelector;
}
public void Should_be_able_to_send_to_both_using_base_type()
{
var newMessageHandler = new NewMessageHandler();
var baseMessageHandler = new BaseMessageHandler();
var eventAggregator = new EventAggregator();
eventAggregator.AddListener(newMessageHandler);
eventAggregator.AddListener(baseMessageHandler);
eventAggregator.SendMessage <BaseMessage>(new NewMessage());
baseMessageHandler.WasHandled.ShouldBeTrue();
newMessageHandler.WasHandled.ShouldBeTrue();
}
public void Should_be_able_to_send_using_object_type()
{
var newMessageHandler = new NewMessageHandler();
var baseMessageHandler = new BaseMessageHandler();
var eventAggregator = new EventAggregator();
eventAggregator.AddListener(newMessageHandler);
eventAggregator.AddListener(baseMessageHandler);
eventAggregator.SendMessage <object>(new BaseMessage());
baseMessageHandler.BaseMessageWasHandled.ShouldBeTrue();
newMessageHandler.NewMessageWasHandled.ShouldBeFalse();
}
public void Should_match_same_type_only()
{
var newMessageHandler = new NewMessageHandler();
var baseMessageHandler = new BaseMessageHandler();
var eventAggregator = new EventAggregator();
eventAggregator.AddListener(newMessageHandler);
eventAggregator.AddListener(baseMessageHandler);
eventAggregator.SendMessage(new BaseMessage());
baseMessageHandler.BaseMessageWasHandled.ShouldBeTrue();
newMessageHandler.NewMessageWasHandled.ShouldBeFalse();
}
public void Message_inheritance_default_should_not_be_able_to_send_class_using_inheritance()
{
var newMessageHandler = new NewMessageHandler();
var baseMessageHandler = new BaseMessageHandler();
var eventAggregator = new EventAggregator();
eventAggregator.AddListener(newMessageHandler);
eventAggregator.AddListener(baseMessageHandler);
eventAggregator.SendMessage <object>(new NewMessage());
baseMessageHandler.BaseMessageWasHandled.ShouldBeFalse();
newMessageHandler.NewMessageWasHandled.ShouldBeTrue();
}
public void Message_inheritance_enabled_should_be_able_to_send_class_using_inheritance()
{
var newMessageHandler = new NewMessageHandler();
var baseMessageHandler = new BaseMessageHandler();
var eventAggregator = new EventAggregator(new EventAggregator.Config {
SupportMessageInheritance = true
});
eventAggregator.AddListener(newMessageHandler);
eventAggregator.AddListener(baseMessageHandler);
eventAggregator.SendMessage <object>(new NewMessage());
baseMessageHandler.BaseMessageWasHandled.ShouldBeTrue();
newMessageHandler.NewMessageWasHandled.ShouldBeTrue();
}
public void AilmentsShouldSerialize()
{
var serializer = BaseMessageHandler.CreateSerializer();
var initialValue = new AilmentModel
{
Buildup = 41.23f,
Index = 42
};
var serialized = SerializeToString(serializer, initialValue);
this.testOutput.WriteLine(serialized);
var deserialized = DeserializeFromString <AilmentModel>(serializer, serialized);
Assert.Equal(initialValue, deserialized);
}
public void PartShouldSerialize()
{
var serializer = BaseMessageHandler.CreateSerializer();
var initialValue = new MonsterPartModel
{
Health = 32.42f,
Index = 42
};
var serialized = SerializeToString(serializer, initialValue);
this.testOutput.WriteLine(serialized);
var deserialized = DeserializeFromString <MonsterPartModel>(serializer, serialized);
Assert.Equal(initialValue, deserialized);
}
public void Message_inheritance_default_should_not_be_able_to_listen_using_interface()
{
var newMessageHandler = new NewMessageHandler();
var baseMessageHandler = new BaseMessageHandler();
var messageHandler = new InterfaceHandler();
var eventAggregator = new EventAggregator();
eventAggregator.AddListener(newMessageHandler);
eventAggregator.AddListener(baseMessageHandler);
eventAggregator.AddListener(messageHandler);
eventAggregator.SendMessage(new BaseMessage());
baseMessageHandler.BaseMessageWasHandled.ShouldBeTrue();
newMessageHandler.NewMessageWasHandled.ShouldBeFalse();
messageHandler.MessageWasHandled.ShouldBeFalse();
}
public void Should_be_able_to_send_subclass_using_interface()
{
var newMessageHandler = new NewMessageHandler();
var baseMessageHandler = new BaseMessageHandler();
var messageHandler = new InterfaceHandler();
var eventAggregator = new EventAggregator();
eventAggregator.AddListener(newMessageHandler);
eventAggregator.AddListener(baseMessageHandler);
eventAggregator.AddListener(messageHandler);
eventAggregator.SendMessage <IMessage>(new BaseMessage());
baseMessageHandler.BaseMessageWasHandled.ShouldBeTrue();
newMessageHandler.NewMessageWasHandled.ShouldBeFalse();
messageHandler.MessageWasHandled.ShouldBeTrue();
}
public Task Handler <TMessage>(ConsumeContext <TMessage> context) where TMessage : class
{
var messageHandlerType = _messageHandlersDictionary[typeof(TMessage)].MessageHandlerType;
var constructorInfo = messageHandlerType.GetConstructors()[0];
BaseMessageHandler <TMessage> messageHandler = null;
if (DependencyResolver.Current != null)
{
messageHandler = DependencyResolver.Current.ResolveHandler <TMessage>(messageHandlerType);
}
else
{
messageHandler = (BaseMessageHandler <TMessage>)constructorInfo.Invoke(new object[] {});
}
Console.WriteLine($"Task created for handle message {typeof(TMessage)}.");
return(messageHandler.MessageHandle(context.Message, context));
}
public void StartClient()
{
Skin skin = new Skin
{
Slim = false,
Texture = Encoding.Default.GetBytes(new string('Z', 8192)),
SkinType = "Standard_Custom"
};
var nodeServer = new NodeServer(_endPoint);
PlayerInfo playerInfo = new PlayerInfo
{
Username = _username,
ClientUuid = new UUID(Guid.NewGuid().ToString()),
ClientId = ClientId,
ServerAddress = "localhost",
Skin = skin
};
_fromNodeHander = new MockNetworkHandler(this);
_toNodeHandler = (BaseMessageHandler)nodeServer.CreatePlayer(_fromNodeHander, playerInfo);
if (_toNodeHandler == null)
{
IsRunning = false;
return;
}
_toNodeHandler.HandleMcpeClientToServerHandshake(null);
McpeRequestChunkRadius radius = McpeRequestChunkRadius.CreateObject();
radius.chunkRadius = ChunkRadius;
_toNodeHandler.WriteBytes(radius.Encode());
radius.PutPool();
IsRunning = true;
}
public static void Dispatch(BaseMessageHandler handler, string Channel, string Type, string Context)
{
if (Channel == "chat" && Type == "PublicChatMessage")
{
var msg = JsonConvert.DeserializeObject <PublicChatMessage>(Context);
handler.OnPublicChatEvent(msg);
}
else if (Channel == "chat" && Type == "WhisperMessage")
{
var msg = JsonConvert.DeserializeObject <WhisperMessage>(Context);
handler.OnWhisperEvent(msg);
}
else if (Channel == "notice" && Type == "NoticeMessage")
{
var msg = JsonConvert.DeserializeObject <NoticeMessage>(Context);
handler.OnNoticeEvent(msg);
}
else
{
throw new ArgumentOutOfRangeException();
}
}
public virtual MessageCollectionData Process(MessageCollectionData messageCollection)
{
if (messageCollection == null)
{
return(null);
}
//heartbeat
User u = UserModule.Instance.GetUserByName(messageCollection.UserFrom);
if (u != null)
{
u.HeartBeat();
}
if (messageCollection.MessageList == null || messageCollection.MessageList.Count == 0)
{
return(BaseMessageHandler.GetMessage(messageCollection.Sequence, messageCollection.UserFrom));
}
MessageCollectionData collectionData = new MessageCollectionData()
{
MessageList = new List <MessageData>()
};
List <MessageData> dataList = BaseMessageHandler.PreProcess(messageCollection);
dataList.ForEach(t =>
{
var handler = BaseMessageHandler.CreateHandler(t.MessageType);
MessageCollectionData tmpCollection = handler.HandleMessage(t, messageCollection.Sequence);
collectionData.Sequence = tmpCollection.Sequence;
collectionData.UserFrom = tmpCollection.UserFrom;
collectionData.MessageList.AddRange(tmpCollection.MessageList);
});
return(collectionData);
}
public void ShouldSerializeMonster()
{
var serializer = BaseMessageHandler.CreateSerializer();
var initialValue = new MonsterModel
{
Id = "em_001",
Ailments = new List <AilmentModel>
{
new AilmentModel
{
Buildup = 41.23f,
Index = 42
}
},
Parts = new List <MonsterPartModel>
{
new MonsterPartModel
{
Health = 32.42f,
Index = 0
},
new MonsterPartModel
{
Health = 23.42f,
Index = 1
}
}
};
var serialized = SerializeToString(serializer, initialValue);
this.testOutput.WriteLine(serialized);
var deserialized = DeserializeFromString <MonsterModel>(serializer, serialized);
Assert.Equal(initialValue, deserialized);
}
public async Task <MessageListModel> Send(SendMessageModel model, int userId, Language language, string deviceId)
{
string sentMessage;
var caller = await _repository.Filter <User>(u => u.Id == userId).FirstOrDefaultAsync();
if (caller == null)
{
throw new Exception("caller not found");
}
var conversation = await _repository.Filter <Conversation>(x => x.Id == model.ConversationId)
.FirstOrDefaultAsync();
if (conversation.AnnouncementCreatorId != caller.Id && conversation.QuestionerId != caller.Id)
{
throw new Exception(_optionsBinder.Error().NotParticipating);
}
if (conversation.AnnouncementCreatorConversationIsDeleted || conversation.QuestionerConversationIsDeleted)
{
conversation.QuestionerConversationIsDeleted = false;
conversation.AnnouncementCreatorConversationIsDeleted = false;
_repository.Update(conversation);
}
var body = model.MessageText;
var messageBodyType = MessageBodyType.Text;
long length = 0;
if (model.File != null)
{
messageBodyType = MessageBodyType.Image;
body = await _accessor.Upload(model.File, UploadType.MessageFiles, conversation.Id);
var extension = Path.GetExtension(body);
if (extension != ".jpg" && extension != ".jpeg" && extension != ".png")
{
messageBodyType = MessageBodyType.File;
}
length = await _accessor.GetLength(body, UploadType.MessageFiles, conversation.Id);
}
int?replayValue = null;
var receiverId = conversation.AnnouncementCreatorId == caller.Id
? conversation.QuestionerId
: conversation.AnnouncementCreatorId;
var message = _repository.Create(new Message
{
ConversationId = conversation.Id,
MessageBodyType = messageBodyType,
MessageText = body,
SenderId = caller.Id,
FileLength = length,
ReciverId = receiverId,
ReplayMessageId = model.ReplayMessageId.HasValue ? model.ReplayMessageId.Value : replayValue
});
await _repository.SaveChangesAsync();
int unreadConversationCount = _repository.Filter <Message>(m => m.ReciverId == receiverId && !m.IsSeen).GroupBy(m => m.ConversationId).Count();
var success = _repository.FilterAsNoTracking <PersonSetting>(x => x.UserId == receiverId).Where(x =>
x.SubscriptionsType == SubscriptionsType.EnableMessageNotification).Count();
var notify = (new MessageListModel
{
SenderId = caller.Id,
FullName = message.User != null ? message.User.FullName : "User",
Photo = message.User != null ? new ImageOptimizer
{
Photo = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
UploadType.ProfilePhoto, message.User.ProfilePhoto, ConstValues.Width, ConstValues.Height, false, 0),
PhotoBlur = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
UploadType.ProfilePhoto, message.User.ProfilePhoto, 100, 100, true, 0)
} : new ImageOptimizer(),
CreatedDate = new DateTime(message.CreatedDt.Ticks),
IsSentFromMe = false,
MessageId = message.Id,
MessageBodyType = messageBodyType,
MessageText = message.MessageBodyType == MessageBodyType.Image
? Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
UploadType.MessageFiles, message.MessageText, 200, 200, false, conversation.Id) : message.MessageText,
FileSize = length,
FileUrl = messageBodyType == MessageBodyType.File
? Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaDownload,
UploadType.MessageFiles, message.MessageText, false, conversation.Id) : null,
ReplayMessage = message.ReplayMessageId != null ? await _repository.Filter <Message>(s => s.Id == message.ReplayMessageId)
.Select(s => new MessageListModel
{
MessageBodyType = s.MessageBodyType,
Photo = s.User != null ? new ImageOptimizer
{
Photo = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
UploadType.ProfilePhoto, s.User.ProfilePhoto, ConstValues.Width, ConstValues.Height, false, 0),
PhotoBlur = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
UploadType.ProfilePhoto, s.User.ProfilePhoto, 100, 100, true, 0)
} : new ImageOptimizer(),
SenderId = s.SenderId,
FullName = s.User != null ? s.User.FullName : "User",
MessageId = s.Id,
MessageText = s.MessageBodyType == MessageBodyType.Image ?
Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
UploadType.MessageFiles, s.MessageText, 1000, 1000, false, conversation.Id) : s.MessageText,
CreatedDate = s.CreatedDt,
IsSentFromMe = s.SenderId == caller.Id,
FileUrl = s.MessageBodyType == MessageBodyType.File ?
Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaDownload,
UploadType.MessageFiles, s.MessageText, false, conversation.Id) : null,
FileSize = s.FileLength
}).FirstOrDefaultAsync() : null
});
var ann = _repository.Filter <Announcement>(a => a.Id == model.AnnouncementId).FirstOrDefault();
if (ann != null)
{
await _activityService.AddOrUpdate(ann, caller.Id, false, ActivityType.Contacted);
}
var notifyToString = Utilities.SerializeObject(notify);
var isSent = await ChatMessageHandler.SendMessageAsync(conversation.Id, caller.Id, notifyToString, deviceId);
if (isSent)
{
message.IsSeen = true;
await _repository.SaveChangesAsync();
}
if (!isSent)
{
var receiverLanguage = await _repository.Filter <PersonOtherSetting>(x => x.UserId == receiverId)
.Select(x => x.Language).FirstOrDefaultAsync();
if (receiverLanguage == Language.English)
{
sentMessage = "sent you a message";
}
else
{
sentMessage = "ارسلت لك رساله";
}
await BaseMessageHandler.SendMessageAsync(conversation.Id, receiverId);
if (success > 0)
{
await _firebaseRepository.SendIndividualNotification(new NewMessageNotificationModel
{
SenderId = caller.Id,
Description = messageBodyType == MessageBodyType.Image ? "Image" :
messageBodyType == MessageBodyType.File ? "Photo" : model.MessageText,
GenericId = conversation.Id,
NotificationType = NotificationType.NewMessage,
ReceiverId = receiverId,
Title = $"{caller.FullName} {sentMessage}",
UnreadConversationCount = unreadConversationCount
}, false);
}
await _firebaseRepository.SendIndividualNotification(new NewMessageNotificationModel
{
SenderId = caller.Id,
Description = messageBodyType == MessageBodyType.Image ? "Image" :
messageBodyType == MessageBodyType.File ? "Photo" : model.MessageText,
GenericId = conversation.Id,
NotificationType = NotificationType.NewMessageGeneralInformation,
ReceiverId = receiverId,
Title = $"{caller.FullName} {sentMessage}",
UnreadConversationCount = unreadConversationCount
}, false);
}
return(notify);
}
protected virtual void InitMessageHandler()
{
_messageHandler = MessageHandlerFactory.GetNoMessageHandler();
}
private static void TestHandlerAndMessageWithHeader <T>(BaseMessageHandler <T> handler, T message, string tenantId = TenantId) where T : ActionMessage
{
Test.Handler(handler).SetIncomingHeader(ActionMessageHeaders.TenantId, tenantId).SetIncomingHeader(Headers.MessageId, "0").SetIncomingHeader(Headers.TimeSent, "0").OnMessage(message);
}
public static async Task Map(this HttpContext context, IEntityRepository repository)
{
var socket = await context.WebSockets.AcceptWebSocketAsync();
context.Request.Query.TryGetValue("conversationId", out var conversationStringValues);
if (conversationStringValues.Count == 0)
{
context.Request.Headers.TryGetValue("conversationId", out conversationStringValues);
}
int.TryParse(conversationStringValues, out var conversationId);
var path = context.Request.Path.Value;
if (conversationId == 0 && !path.Contains("supportBaseHub") && !path.Contains("baseHub") && !path.Contains("progressHub"))
{
return;
}
var userName = context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
// var userId = int.Parse(context.User.Claims.Single(u => u.Type == "userId").Value);//check
context.Request.Headers.TryGetValue("deviceId", out var deviceIdString);
if (deviceIdString.Count == 0)
{
context.Request.Query.TryGetValue("deviceId", out deviceIdString);
}
var deviceId = deviceIdString.FirstOrDefault();
User user = null;
if (!string.IsNullOrEmpty(userName))
{
user = await repository.Filter <User>(x => x.Email == userName || // add verfiedBy
(x.PhoneCode + x.Phone) == userName).FirstOrDefaultAsync();
}
if (path.Contains("supportChatHub", StringComparison.InvariantCulture))
{
var guest = await repository.Filter <Guest>(x => x.DeviceId == deviceId).FirstOrDefaultAsync();
if (user == null && guest == null)
{
return;
}
await SupportChatMessageHandler.OnConnected(conversationId, user?.Id ?? guest.Id, socket, user == null, deviceId);
await WebSocketManagerMapper.Receive(socket, async (result, buffer) =>
{
if (result.MessageType == WebSocketMessageType.Close)
{
await SupportChatMessageHandler.OnDisconnected(conversationId, user?.Id ?? guest.Id, user == null, deviceId);
}
});
}
else
{
if (user == null)
{
return;
}
if (path.Contains("chatHub", StringComparison.InvariantCulture))
{
await ChatMessageHandler.OnConnected(conversationId, user.Id, socket, deviceId);
await WebSocketManagerMapper.Receive(socket, async (result, buffer) =>
{
if (result.MessageType == WebSocketMessageType.Close)
{
await ChatMessageHandler.OnDisconnected(conversationId, user.Id, deviceId);
}
});
}
if (path.Contains("supportBaseHub", StringComparison.InvariantCulture))
{
await SupportBaseMessageHandler.OnConnected(user.Id, socket, false, deviceId);
await WebSocketManagerMapper.Receive(socket, async (result, buffer) =>
{
if (result.MessageType == WebSocketMessageType.Close)
{
await SupportBaseMessageHandler.OnDisconnected(user.Id, false, deviceId);
}
});
}
if (path.Contains("baseHub", StringComparison.InvariantCulture))
{
await BaseMessageHandler.OnConnected(user.Id, socket, false, deviceId);
await WebSocketManagerMapper.Receive(socket, async (result, buffer) =>
{
if (result.MessageType == WebSocketMessageType.Close)
{
await BaseMessageHandler.OnDisconnected(user.Id, false, deviceId);
}
});
}
if (path.Contains("progressHub", StringComparison.InvariantCulture))
{
await AnnouncementProgressHandler.OnConnected(user.Id, socket, deviceId);
await WebSocketManagerMapper.Receive(socket, async (result, buffer) =>
{
if (result.MessageType == WebSocketMessageType.Close)
{
await AnnouncementProgressHandler.OnDisconnected(user.Id, deviceId);
}
});
}
}
}
