public static void ChangeConfigValue(string property, string value)
{
bool success = false;
string propertyLower = property.ToLower();
Plugin.Log("Config Change Attempt: " + property + " " + value);
object inifile = Plugin.ConfigSettings.GetField <object>("_instance");
IniParser.Model.IniData data = inifile.GetField <IniParser.Model.IniData>("data");
foreach (var section in data.Sections)
{
if (success)
{
break;
}
foreach (var key in section.Keys)
{
if (key.KeyName.ToLower() == propertyLower && !data.Sections[section.SectionName].ContainsKey("ChargeCost"))
{
inifile.InvokeMethod("IniWriteValue", section.SectionName, property, value);
ChatMessageHandler.TryAsyncMessage("Changed Value");
Config.Load();
success = true;
break;
}
}
}
}
public WebSocketRequestHandler(IConnectionManager connectionManager,
ChatCommandHandler chatCommandHandler,
ChatMessageHandler chatMessageHandler,
ChatRegistrationHandler chatRegistrationHandler)
{
_connectionManager = connectionManager ?? throw new ArgumentNullException(nameof(connectionManager));
_chatCommandHandler = chatCommandHandler ?? throw new ArgumentNullException(nameof(chatCommandHandler));
_chatMessageHandler = chatMessageHandler ?? throw new ArgumentNullException(nameof(chatMessageHandler));
_chatRegistrationHandler = chatRegistrationHandler ?? throw new ArgumentNullException(nameof(chatRegistrationHandler));
}
public AdminController(
ApplicationContext dbContext,
IAuthService authService,
ChatMessageHandler webSocketHandler
)
{
DbContext = dbContext;
AuthService = authService;
WebSocketHandler = webSocketHandler;
}
// Start is called before the first frame update
private void Start()
{
logger = GameObject.FindObjectOfType <GameUILog>();
gameClient = IoCContainer.Instance.Resolve <IRavenClient>();
Auth = gameClient.Modules.GetModule <Authentication>();
PlayerHandler = gameClient.Modules.GetModule <PlayerHandler>();
ObjectHandler = gameClient.Modules.GetModule <ObjectHandler>();
NpcHandler = gameClient.Modules.GetModule <NpcHandler>();
CharacterHandler = gameClient.Modules.GetModule <CharacterHandler>();
ChatMessageHandler = gameClient.Modules.GetModule <ChatMessageHandler>();
//Connect();
}
public RavenClient(ILogger logger, IModuleManager moduleManager, INetworkPacketController controller)
{
this.logger = logger;
this.Modules = moduleManager;
this.client = new RavenNetworkClient(logger, RegisterPacketHandlers(controller));
this.auth = this.Modules.AddModule(new Authentication(this.client));
this.playerHandler = this.Modules.AddModule(new PlayerHandler());
this.npcHandler = this.Modules.AddModule(new NpcHandler());
this.objectHandler = this.Modules.AddModule(new ObjectHandler());
this.npcHandler = this.Modules.AddModule(new NpcHandler());
this.characterHandler = this.Modules.AddModule(new CharacterHandler());
this.chatMessageHandler = this.Modules.AddModule(new ChatMessageHandler());
}
public async Task GivenAMessageToAllWhenExecutingHandleThanReturnTheFormattedMessage()
{
var nickname = "foo";
var message = "message";
var expected = ServerMessageConstants.GetMessage(ServerMessageConstants.GENERAL_MESSAGE, nickname, message);
Mock <WebSocket> originSocketMock = new Mock <WebSocket>();
Mock <ISocketHandler> socketHandlerMock = new Mock <ISocketHandler>();
var chatMessageHandler = new ChatMessageHandler(socketHandlerMock.Object);
var taskResult = await chatMessageHandler.Handle(originSocketMock.Object, nickname, message);
Assert.Equal(taskResult, expected);
}
public static void ChangeConfigValue(string command, string property, string value)
{
Plugin.Log("Config Change Attempt: " + command + " " + property + " " + value);
object inifile = Plugin.ConfigSettings.GetField <object>("_instance");
IniParser.Model.IniData data = inifile.GetField <IniParser.Model.IniData>("data");
if (data.Sections.ContainsSection(command))
{
if (data.Sections[command].ContainsKey(property))
{
inifile.InvokeMethod("IniWriteValue", command, property, value);
ChatMessageHandler.TryAsyncMessage("Changed Value");
Config.Load();
}
}
}
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);
}
public CarController(IHostingEnvironment env, ChatMessageHandler chatMessageHandler)
{
this._hostingEnv = env;
this._chatMessageHandler = chatMessageHandler;
}
public ChatController(ApplicationContext dbContext, ChatMessageHandler webSocketHandler)
{
this.DbContext = dbContext;
WebSocketHandler = webSocketHandler;
}
public void InitChatCore()
{
ChatMessageHandler.Load();
}
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);
}
});
}
}
}
public RoomController(ChatMessageHandler handler)
{
ChatMessageHandler = handler;
}
public WebSocketController(ChatMessageHandler handler)
{
_handler = handler;
}
public ChatRoomRepository(FakeDbContext context, ChatMessageHandler chatMessageHandler)
{
this.context = context;
this.chatMessageHandler = chatMessageHandler;
}
