public async Task CheckRequest(ChatRequest request, ChatResponse expected, int step)
{
var actual = await chatEngine.HandleRequest(request);
Assert.IsNull(actual.Error, "API Error triggered. {0}", actual.Error);
MatchResponse(actual, expected, step);
}
public async Task <IActionResult> Post([FromForm] CreateMessageRequest request)
{
var result = await SaveMessage(request);
if (result == null)
{
return(BadRequest("Can not send message now!"));
}
var sender = await _context.Users.FindAsync(request.SenderId);
var receiver = await _context.Users.FindAsync(request.ReceiverId);
var display = new UserDisplay(sender, _storageService);
var response = new ChatResponse()
{
SenderId = result.SenderId,
ReceiverId = result.ReceiverId,
Content = result.Content,
SentAt = result.SentAt,
Id = result.Id,
FullName = display.FullName,
Avatar = display.AvatarPath
};
await _hub.Clients.Clients(receiver.ConnectionId, sender.ConnectionId).SendAsync("transferData", response);
return(Ok(new { Message = "Request complete!" }));
}
public async Task RemoveUserFromGroup(GroupUserRequest request)
{
try
{
var result = await _chatService.RemoveUserFromGroup(Context.UserIdentifier, request.Group, request.User);
ChatResponse response = new ChatResponse();
if (result.Success)
{
response.Type = ChatResponseType.UpdateGroupView;
response.Data = result.Data;
await SendResponseToGroup(request.Group, response);
await GroupUserConnection(request.Group, request.User, false);
}
else
{
response.Type = ChatResponseType.SystemErrorMessage;
response.Data = result.Message;
await SendResponseToCaller(response);
}
}
catch (Exception)
{
}
}
public async void reactionResponse(MessageCreateEventArgs e, ChatResponse chatResponse, ChannelSettings channelSettings)
{
if (chatResponse.confidence > channelSettings.ReactionConfidenceThreshold)
{
var reactions = 0;
foreach (var chat in chatResponse.response)
{
DiscordEmoji emoji = emojiService.getEmoji(chat.Trim());
if (emoji != null)
{
try
{
await e.Message.CreateReactionAsync(emoji);
}
catch (Exception)
{
}
reactions++;
if (reactions >= configuration.MaximumReactionsPerMessage)
{
return;
}
}
}
}
}
public async Task <List <ChatResponse> > GetAllMessages()
{
try
{
List <ChatResponse> listOfChat = new List <ChatResponse>();
SQLConnection();
using (SqlCommand cmd = new SqlCommand("GetAllMessages", conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
conn.Open();
SqlDataReader dataReader = await cmd.ExecuteReaderAsync();
while (dataReader.Read())
{
var responseData = new ChatResponse
{
MessageID = Convert.ToInt32(dataReader["MessageID"]),
UserID = Convert.ToInt32(dataReader["UserID"]),
Message = dataReader["Message"].ToString(),
ReceiverID = Convert.ToInt32(dataReader["ReceiverID"])
};
listOfChat.Add(responseData);
}
};
return(listOfChat);
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public string MessageDetails(string id)
{
var token = Session["token"] == null ? "XXXXXXX" : Session["token"].ToString();
ChatResponse chatResponse = messageRequest.Chat(token, id);
//ChatResponse chatResponse = new ChatResponse();
if (chatResponse.data != null)
{
//chatResponse = JsonHelper.DeserializeJsonToObject<ChatResponse>(apiResponse);
chatResponse.data.data.Sort((left, right) =>
{
if (int.Parse(left.id) > int.Parse(right.id))
{
return(1);
}
else if (int.Parse(left.id) == int.Parse(right.id))
{
return(0);
}
else
{
return(-1);
}
});
}
//UserProfileResponse currentUser = userRequest.profile(token, "");
//ViewBag.currrentUserid = currentUser.data.id;
//chatResponse.data.data
string jsonResponse = JsonHelper.SerializeObject(chatResponse);
return(jsonResponse);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (!float.TryParse(command[0], out float x))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}"));
return;
}
if (!float.TryParse(command[1], out float y))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[1]}"));
return;
}
if (!float.TryParse(command[2], out float z))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[2]}"));
return;
}
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(client.character.instanceId);
res.WriteFloat(x);
res.WriteFloat(y);
res.WriteFloat(z);
res.WriteByte(client.character.heading);
res.WriteByte(client.character.movementAnim);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
}
public override void Handle(NecClient client, ChatMessage message, ChatResponse response,
List <ChatResponse> responses)
{
if (client == null)
{
return;
}
if (message.message == null || message.message.Length <= 1)
{
return;
}
if (!message.message.StartsWith(CHAT_COMMAND_START))
{
return;
}
string commandMessage = message.message.Substring(1);
string[] command = commandMessage.Split(CHAT_COMMAND_SEPARATOR);
if (command.Length <= 0)
{
_Logger.Error(client, $"Command '{message.message}' is invalid");
return;
}
string commandKey = command[0].ToLowerInvariant();
if (!_commands.ContainsKey(commandKey))
{
_Logger.Error(client, $"Command '{commandKey}' does not exist");
responses.Add(ChatResponse.CommandError(client, $"Command does not exist: {commandKey}"));
return;
}
ChatCommand chatCommand = _commands[commandKey];
if (client.account.state < chatCommand.accountState)
{
_Logger.Error(client,
$"Not entitled to execute command '{chatCommand.key}' (State < Required: {client.account.state} < {chatCommand.accountState})");
return;
}
int cmdLength = command.Length - 1;
string[] subCommand;
if (cmdLength > 0)
{
subCommand = new string[cmdLength];
Array.Copy(command, 1, subCommand, 0, cmdLength);
}
else
{
subCommand = new string[0];
}
chatCommand.Execute(subCommand, client, message, responses);
}
/// <summary>
/// Send a chat message
/// </summary>
public void Send(ChatResponse response)
{
RecvChatNotifyMessage notifyMessage = new RecvChatNotifyMessage(response);
notifyMessage.AddClients(response.Recipients);
Send(notifyMessage);
}
public ChatResponse GetResponse(Conversation analyzedConversation, List <string> requiredTypes, List <string> requiredProperyMatches, List <string> excludedTypes, List <string> subjectGoals)
{
//TODO: change type to list of types, pass that in. if it's empty do any
var conversationChatResponse = conversationMatchService.GetConversationMatch(analyzedConversation, requiredTypes, requiredProperyMatches, excludedTypes, subjectGoals);
var userPropertyChatResponse = userPropertyMatchService.GetUserPropertyMatch(analyzedConversation);
var matchChat = conversationChatResponse;
if (userPropertyChatResponse.confidence > conversationChatResponse.matchConfidence) //TODO: check the uniqueness of reply (if it was already used)
{
userPropertyChatResponse.response = salutationService.GetProperlyAddressedResponse(analyzedConversation, userPropertyChatResponse.response);
return(userPropertyChatResponse);
}
if (matchChat.responseChat == null)
{
return(new ChatResponse {
confidence = 0, response = new List <string>()
});
}
var response = responseConversionService.ConvertResponse(analyzedConversation.responses.Last(), matchChat);
var chatResponse = new ChatResponse
{
confidence = matchChat.matchConfidence,
response = salutationService.GetProperlyAddressedResponse(analyzedConversation, response)
};
//TODO: alter reply to match sophistication
return(chatResponse);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command.Length < 1)
{
responses.Add(ChatResponse.CommandError(client, "To few arguments"));
return;
}
switch (command[0])
{
case "bags":
SpawnBags(client);
break;
case "a_darkmerchant":
SpawnAvatarDarkMerchant(client);
break;
case "charmed":
SpawnCharmedGear(client);
break;
default:
responses.Add(ChatResponse.CommandError(client, $"Invalid Package: {command[0]}"));
return;
}
}
public async Task TestFTFormatObjectMessage()
{
ChatRequest request = new ChatRequest()
{
Channel = "chatweb",
Partner = "AsurionLabs",
Context = "Test",
TimeZone = "-0400" // EDT
};
var actual = await framework.HandleRequest(request);
Assert.IsNotNull(actual, "Initial response is null");
Assert.IsNull(actual.Status.Error, "API Error triggered. {0}", actual.Status.Error);
Assert.IsNotNull(actual.ChatId, "Initial response did not give Chat Id");
request.ChatId = actual.ChatId;
request.UserInput = "ft-FormatObjectMessage";
int step = 1;
var expected = new ChatResponse
{
Steps = new ChatStepId[] {
new ChatStepId("ft-FormatObjectMessage", "1"),
new ChatStepId("ft-FormatObjectMessage", "2"),
new ChatStepId("GetIntent-AsurionLabs-Test", "10000318")
},
Messages = new string[]
{
"field1Val",
"What flow would you like to test?"
}
};
await framework.CheckRequest(request, expected, step ++);
}
public static ChatResponse createOkResponse()
{
ChatResponse response = ChatResponse.CreateBuilder()
.SetType(ChatResponse.Types.Type.Ok).Build();
return(response);
}
void MatchResponse(ChatResponse actual, ChatResponse expected, int step)
{
// Compare Steps
if (expected.Steps != null)
{
Assert.AreEqual(actual.Steps.Length, expected.Steps.Length, $"{step} - Step length different");
for (int i = 0; i < actual.Steps.Length; i++)
{
Assert.AreEqual(actual.Steps[i].FlowName, expected.Steps[i].FlowName, $"{step} - Step {i} different FlowName");
Assert.AreEqual(actual.Steps[i].StepId, expected.Steps[i].StepId, $"{step} - Step {i} different StepId");
}
}
// Compare messages
if (expected.Messages?.Length > 0)
{
Assert.AreEqual(actual.Messages?.Length, expected.Messages?.Length, $"{step} - Message length different");
for (int i = 0; i < expected.Messages.Length; i++)
{
Assert.AreEqual(expected.Messages[i], actual.Messages[i], $"{step} - Message {i} different");
}
}
Assert.AreEqual(expected.TransferToAgent, actual.TransferToAgent, $"{step} - TransferToAgent different");
}
/// <summary>
/// Join user to chat that
/// already exists.
/// </summary>
/// <param name="chatId"></param>
/// <param name="userId"></param>
/// <returns></returns>
public async Task <ChatResponse> JoinUserToChat(string chatId, string userId)
{
var realChatId = Guid.Parse(chatId);
var userChat = new ApplicationUserChat
{
ChatId = realChatId,
UserId = userId
};
var alreadyJoined = _repository.CheckUserChatExistance(userChat);
if (alreadyJoined)
{
return(ChatResponse.Successfull());
}
var success = await _repository.SaveUserChat(userChat);
if (!success)
{
return(ChatResponse.Unsuccessful("Error saving userchat relation."));
}
return(ChatResponse.Successfull());
}
/// <summary>
/// Gets all chat messages
/// </summary>
/// <returns>Object containing all chat messages</returns>
public ChatResponse GetAllChatMessages()
{
try
{
string URL = string.Format("https://api.boldchat.com/aid/{0}/data/rest/json/v1/getAllChatMessages?auth={1}", apiSettings.accountId, apiSettings.authHash);
WebRequest request = WebRequest.Create(URL);
request.Method = "GET";
HttpWebResponse response = null;
response = (HttpWebResponse)request.GetResponse();
string result = null;
using (Stream stream = response.GetResponseStream())
{
StreamReader sr = new StreamReader(stream);
result = sr.ReadToEnd();
sr.Close();
}
allChatMessages = JsonConvert.DeserializeObject <ChatResponse>(result);
return(allChatMessages);
}
catch (Exception ex)
{
throw new Exception("Exception at GetAllChatMessages", ex);
}
}
/// <summary>
/// Get all active chats for user.
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public async Task <ChatResponse> GetActiveChats(ApplicationUser user)
{
var chats = new List <Chat>();
var userChats = await _repository.GetActiveChatsByUserId(user.Id);
foreach (var userChat in userChats)
{
var chat = await _repository.FindChatById(userChat.ChatId);
if (chat == null)
{
return(ChatResponse.Unsuccessful("Error finding chat."));
}
chat.Name = await SetChatName(chat, user);
chats.Add(chat);
}
chats = chats
.OrderByDescending(x => x.LastActivityAt)
.ToList();
return(ChatResponse.Successfull(chats));
}
IEnumerator UpdateCurrentChat()
{
using (UnityWebRequest request = UnityWebRequest.Get(APIprefix + "chat/"))
{
if (PlayerPrefs.HasKey("Token"))
{
request.SetRequestHeader("Authorization", "Token " + PlayerPrefs.GetString("Token"));
}
yield return(request.SendWebRequest());
if (!request.isNetworkError)
{
//Debug.Log(request.downloadHandler.text);
if (!request.isHttpError)
{
ChatResponse response = JsonUtility.FromJson <ChatResponse>(request.downloadHandler.text);
string msg = "";
foreach (var item in response.data)
{
msg += item.timestamp;
msg += "\n";
msg += "<b>" + item.author.username + "</b>: ";
msg += item.text + "\n";
}
ChatText.text = msg;
}
}
}
}
private void ProcessFacebookResponse(ChatResponse response, Activity reply)
{
if (response?.PossibleUserAnswers != null)
{
reply.ChannelData = MakeFakeFacebookButtonsData(reply.Text, response.PossibleUserAnswers);
}
}
public ChatResponse GetReaction(Conversation analyzedConversation, List <string> excludedTypes, List <string> subjectGoals)
{
if (analyzedConversation.responses.Count == 0)
{
return(new ChatResponse()
{
confidence = 0, response = new List <string>()
});
}
var conversationChatResponse = _conversationMatchService.GetConversationMatch(analyzedConversation, excludedTypes, subjectGoals);
var matchChat = conversationChatResponse;
if (matchChat.responseChat == null)
{
return(new ChatResponse {
confidence = 0, response = new List <string>()
});
}
var chatResponse = new ChatResponse
{
confidence = matchChat.matchConfidence,
response = GetResponse(matchChat)
};
return(chatResponse);
}
public static chat.model.Message getMessage(ChatResponse response)
{
chat.model.User sender = new chat.model.User(response.Message.SenderId);
chat.model.User receiver = new chat.model.User(response.Message.ReceiverId);
chat.model.Message message = new chat.model.Message(sender, receiver, response.Message.Text);
return(message);
}
public async Task GetChats(GetGroupChatsRequest request)
{
try
{
var result = await _chatService.GetChatsByGroupId(request.Group, request.Position, request.Limit);
ChatResponse response = new ChatResponse();
if (result.Success)
{
response.Type = ChatResponseType.UpdateChats;
response.Data = new
{
Group = request.Group,
Chats = result.Data
};
}
else
{
response.Type = ChatResponseType.SystemErrorMessage;
response.Data = result.Message;
}
// TODO: Update read last chat
await SendResponseToCaller(response);
}
catch (Exception)
{
}
}
private void sendResponse(ChatResponse response)
{
Console.WriteLine("sending response " + response);
//formatter.Serialize(stream, response);
response.WriteDelimitedTo(stream);
stream.Flush();
}
public async Task CreateGroup(CreateGroupRequest request)
{
try
{
var result = await _chatService.CreateGroup(request.Name, request.Users);
ChatResponse response = new ChatResponse();
if (result.Success)
{
var group = (GroupView)result.Data;
foreach (string user in group.Users)
{
await GroupUserConnection(group.Id, user, true);
}
response.Type = ChatResponseType.UpdateGroup;
response.Data = result.Data;
await SendResponseToGroup(group.Id, response);
}
else
{
response.Type = ChatResponseType.SystemErrorMessage;
response.Data = result.Message;
await SendResponseToCaller(response);
}
}
catch (Exception)
{
}
}
/// <summary>
/// Add Message data into the database
/// </summary>
/// <param name="userID">UserID</param>
/// <param name="chatRequest">Chat Data</param>
/// <returns>If Data Added return Response Data else null or Exception</returns>
public async Task <ChatResponse> SendMessage(int userID, ChatRequest chatRequest)
{
try
{
ChatResponse responseData = null;
SQLConnection();
using (SqlCommand cmd = new SqlCommand("AddMessageData", conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@UserID", userID);
cmd.Parameters.AddWithValue("@Message", chatRequest.Message);
cmd.Parameters.AddWithValue("@ReceiverID", chatRequest.ReceiverID);
conn.Open();
SqlDataReader dataReader = await cmd.ExecuteReaderAsync();
while (dataReader.Read())
{
responseData = new ChatResponse
{
MessageID = Convert.ToInt32(dataReader["MessageID"]),
UserID = Convert.ToInt32(dataReader["UserID"]),
Message = dataReader["Message"].ToString(),
ReceiverID = Convert.ToInt32(dataReader["ReceiverID"])
};
}
};
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task DeleteGroup(string group)
{
try
{
var result = await _chatService.DeleteGroup(Context.UserIdentifier, group);
ChatResponse response = new ChatResponse();
if (result.Success)
{
response.Type = ChatResponseType.DeleteGroup;
response.Data = group;
// TODO: Remove users from hub group ?????
await SendResponseToGroup(group, response);
}
else
{
response.Type = ChatResponseType.SystemErrorMessage;
response.Data = result.Message;
await SendResponseToCaller(response);
}
}
catch (Exception)
{
}
}
public override Task <ChatResponse> GetChat(ChatRequest request, ServerCallContext context)
{
User user = _userService.GetFromToken(request.Token);
Chat chat = _chatService.Get(request.Id);
if (user == null)
{
throw new RpcException(new Status(StatusCode.Unauthenticated, "Could not validate token"));
}
if (chat == null)
{
throw new RpcException(new Status(StatusCode.NotFound, "Could not find chat"));
}
if (!chat.Members.Contains(user.Id))
{
throw new RpcException(new Status(StatusCode.PermissionDenied, "Could not access chat"));
}
ChatResponse response = new ChatResponse()
{
Id = chat.Id,
MessageCount = chat.MessageCount
};
response.Members.AddRange(chat.Members);
return(Task.FromResult(response));
}
public async Task GetChatResponseAsyncReturnsApiResponse()
{
var chatResponse = new ChatResponse();
chatResponse.response = new List <string>();
chatResponse.response.Add("hello world");
chatResponse.confidence = .42;
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock.Protected().Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
).ReturnsAsync(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(chatResponse)),
}).Verifiable();
var httpClient = new HttpClient(handlerMock.Object)
{
BaseAddress = new Uri("http://test.com/"),
};
var botConfiguration = new BotConfiguration();
var service = new ChatResponseService(httpClient, botConfiguration);
var result = await service.GetChatResponseAsync("test");
Assert.Equal(chatResponse.response, result.response);
Assert.Equal(chatResponse.confidence, result.confidence);
}
IEnumerator SendMessageCoroutine(string message)
{
WWWForm form = new WWWForm();
form.AddField("text", message);
using (UnityWebRequest request = UnityWebRequest.Post(APIprefix + "chat/" + currentRoom.ToString(), form)) {
if (PlayerPrefs.HasKey("Token"))
{
request.SetRequestHeader("Authorization", "Token " + PlayerPrefs.GetString("Token"));
}
yield return(request.SendWebRequest());
if (!request.isNetworkError)
{
//Debug.Log(request.downloadHandler.text);
if (!request.isHttpError)
{
ChatResponse response = JsonUtility.FromJson <ChatResponse>(request.downloadHandler.text);
string msg = "";
foreach (var item in response.data)
{
msg += item.when;
msg += "\n";
msg += "<b>" + item.author.username + "</b>: ";
msg += item.text + "\n";
}
ChatText.text = msg;
}
}
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
IBuffer res36 = BufferProvider.Provide();
switch (command[0])
{
case "start":
IBuffer res21 = BufferProvider.Provide();
res21.WriteInt32(1); // 0 = normal 1 = cinematic
res21.WriteByte(0);
router.Send(client, (ushort)AreaPacketId.recv_event_start, res21, ServerType.Area);
IBuffer res22 = BufferProvider.Provide();
res22.WriteCString(command[1]); // lable
res22.WriteUInt32(client.character.instanceId); //newjp ObjectId
router.Send(client, (ushort)AreaPacketId.recv_event_script_play, res22, ServerType.Area);
break;
default:
_Logger.Error($"There is no script of type : {command[1]} ");
break;
}
}
public override Response DoWork(string request)
{
var workRequest = JsonConvert.DeserializeObject<ChatRequest>(request);
var workResponse = new ChatResponse();
if (Server.Games.ContainsKey(workRequest.GameID))
{
if (Server.Games[workRequest.GameID].PlayerWhite.Name == workRequest.From)
{
var blackName = Server.Games[workRequest.GameID].PlayerBlack.Name;
var geted = Server.Users.Values.FirstOrDefault(user => user.Name == blackName);
if (geted != null)
{
Server.Messages.GetOrAdd(geted.Name, i => new List<Message>()).Add(MessageSender.ChatMessage(workRequest.From, workRequest.SayString));
}
}
else
{
if (Server.Games[workRequest.GameID].PlayerBlack.Name == workRequest.From)
{
var whiteName = Server.Games[workRequest.GameID].PlayerWhite.Name;
var geted = Server.Users.Values.FirstOrDefault(user => user.Name == whiteName);
if (geted != null)
{
Server.Messages.GetOrAdd(geted.Name, i => new List<Message>()).Add(MessageSender.ChatMessage(workRequest.From, workRequest.SayString));
}
}
}
workResponse.Status = Statuses.Ok;
}
else
{
workResponse.Status = Statuses.GameNotFound;
}
return workResponse;
}
