public string MaintainConversation(UserRequest userRequest)
{
Person person = PersonService.GetPersonByUserRequest(userRequest);
Conversation conversation = ConversationService.GetActiveConversationForPerson(person);
if (conversation == null)
{ // TODO clean up / look for reactive chatbot
return("You do not have an active conversation");
}
AiResponseExtract response = AiService.ProcessUserRequest(conversation, userRequest);
// Handle incoming Text
Communication comm = CommunicationService.CreateIncomingCommunication(conversation, userRequest, response);
conversation.Communications.Add(comm);
// Change State (Message)
DataClasses.Message nextMessage = MessageService.GetNextMessage(conversation, response);
ConversationService.UpdateCurrentMessage(conversation, nextMessage, response);
// Handle outbound Text
Communication newComm = CommunicationService.CreateOutgoingCommunication(conversation, nextMessage);
conversation.Communications.Add(newComm);
Context.SaveChanges();
return(nextMessage.Body);
}
/// <summary>
/// Method that validates whether or not a Messages Transitioners are set up correctly. Returns
/// a boolean that represents whether or not this Message needs to have a new Message created for
/// the misunderstoodIntentType.
/// </summary>
/// <param name="message"></param>
/// <returns>a boolean that represents whether or not this Message needs to have a new Message
/// created for the misunderstood IntentType. Always returns false if this is the misunderstood
/// Message.</returns>
private bool HandleTransitionerList(DataClasses.Message message)
{
List <DataClasses.Transition> transitioners = message.Transitions;
bool isFallback = transitioners.Find(t => t.IntentId ==
IntentService.GetMoveOnIntent().Id) == null ? false : true;
if (isFallback)
{
if (transitioners.Count > 1)
{
throw new OmniBotException(INVALID_MISUNDERSTOOD_MESSAGE);
}
return(false);
}
bool hasAcceptAny = transitioners.Find(t => t.IntentId ==
IntentService.GetAcceptAnyIntent().Id) == null ? false : true;
bool hasMisunderstood = transitioners.Find(t => t.IntentId ==
IntentService.GetMisunderstoodIntent().Id) == null ? false : true;
if (hasAcceptAny && hasMisunderstood)
{
throw new OmniBotException(MULTIPLE_FALLBACKS);
}
if (!hasAcceptAny && !hasMisunderstood && !message.IsEnd)
{
System.Diagnostics.Trace.WriteLine("Setting to create a new misunderstood");
return(true);
}
return(false);
}
internal void FinalizeTransitioners(List <DataClasses.Message> messages)
{
List <DataClasses.Message> newMisunderstoodMessages = new List <DataClasses.Message>();
foreach (DataClasses.Message message in messages)
{
bool createMisunderstood = HandleTransitionerList(message);
if (createMisunderstood)
{
DataClasses.Message misunderstoodMessage = CreateMisunderstoodMessage(message);
newMisunderstoodMessages.Add(misunderstoodMessage);
message.Transitions.Add(new DataClasses.Transition()
{
CurrentMessage = message,
Intent = IntentService.GetMisunderstoodIntent(),
NextMessage = misunderstoodMessage
});
}
}
messages.AddRange(newMisunderstoodMessages);
UpdateNullNextMessages(messages);
}
private DataClasses.Message CreateSmallTalkMessage(Conversation conversation, AiResponseExtract response)
{
DataClasses.Message smallTalkMessage = new DataClasses.Message()
{
Name = conversation.CurrentMessage.Name + "-smalltalk",
Body = response.Speech,
IsStart = false,
IsEnd = false
};
return(smallTalkMessage);
}
public Communication CreateOutgoingCommunication(Conversation conversation, DataClasses.Message message)
{
Communication comm = new Communication()
{
Conversation = conversation,
Outbound = true,
Body = message.Body,
Context = message.Name
};
return(comm);
}
public void StartConversation(ConversationStarter conversationStarter) // TODO put this here?
{
Person person = PersonService.GetPersonByPhoneNumber(conversationStarter.PhoneNumber);
Conversation conversation = ConversationService.CreateConversation(conversationStarter, person);
DataClasses.Message firstMessage = ScriptService.GetFirstMessageFromScript(conversation.Script);
conversation.CurrentMessage = firstMessage;
Communication text = CommunicationService.CreateOutgoingCommunication(conversation, firstMessage);
conversation.Communications.Add(text);
Context.SaveChanges();
MessagingService.SendMessage(person.PhoneNumber, firstMessage.Body);
}
public Message(DataClasses.Message message)
{
Id = message.Id;
Name = message.Name;
Body = message.Body;
IsStart = message.IsStart;
IsEnd = message.IsEnd;
if (message.Transitions != null)
{
foreach (DataClasses.Transition transition in message.Transitions)
{
this.AddTransistion(new Transition(transition));
}
}
}
public void UpdateCurrentMessage(Conversation conversation, DataClasses.Message nextMessage, AiResponseExtract response)
{
if (response.Intent.Equals(IntentTypeService.GetMisunderstoodIntent().Name) ||
response.SmallTalk)
{
// TODO increment times user got stuck. If at a certain amount, Trigger move on.
// Move on will send an extra message. Need to determine how to store the extra message in the DB.
return;
}
conversation.CurrentMessage = nextMessage;
if (nextMessage.IsEnd)
{
conversation.Active = false;
}
}
public DataClasses.Message GetNextMessage(Conversation conversation, AiResponseExtract response)
{
DataClasses.Message nextMessage = null;
var query = from MessageTransitioner in Context.Transitions
where MessageTransitioner.CurrentMessage.Name == conversation.CurrentMessage.Name &&
MessageTransitioner.Intent.Name == response.Intent
select MessageTransitioner.NextMessage;
nextMessage = query.SingleOrDefault();
if (nextMessage == null)
{
nextMessage = CreateSmallTalkMessage(conversation, response);
}
return(nextMessage);
}
public void Save(ref MessageDTO messageDTO)
{
using (var dc = new DataContext())
{
var recId = messageDTO.ReceiverId;
var sId = messageDTO.SenderId;
var message = new DataClasses.Message
{
Receiver = (from m in dc.Members where m.MemberId == recId select m).First(),
Sender = (from m in dc.Members where m.MemberId == sId select m).First(),
Text = messageDTO.Text,
Time = messageDTO.Time,
IsDeleted = false
};
dc.Messages.Add(message);
dc.SaveChanges();
messageDTO.MessageId = message.MessageId;
}
}
internal void MergeMessages(List <DataClasses.Message> currentMessages, List <DataClasses.Message> uploadedMessages)
{
List <DataClasses.Message> deleteMessages = new List <DataClasses.Message>();
// Update existing messages
foreach (DataClasses.Message currentMessage in currentMessages)
{
DataClasses.Message uploadedMessage = uploadedMessages.FirstOrDefault(m => m.Id == currentMessage.Id);
if (uploadedMessage == null)
{ // Delete message
deleteMessages.Add(currentMessage);
}
else
{ // Update message
currentMessage.Name = uploadedMessage.Name;
currentMessage.Body = uploadedMessage.Body;
currentMessage.IsStart = uploadedMessage.IsStart;
currentMessage.IsEnd = uploadedMessage.IsEnd;
currentMessage.Transitions = uploadedMessage.Transitions;
uploadedMessages.Remove(uploadedMessage);
}
}
Context.Messages.RemoveRange(deleteMessages);
List <DataClasses.Message> newMessages = new List <DataClasses.Message>();
// Add new messages
foreach (DataClasses.Message uploadedMessage in uploadedMessages)
{
if (currentMessages.FirstOrDefault(m => m.Name.Equals(uploadedMessage.Name)) == null)
{
newMessages.Add(uploadedMessage);
}
}
currentMessages.AddRange(newMessages);
}
private DataClasses.Message CreateMisunderstoodMessage(DataClasses.Message parentMessage)
{
DataClasses.Message misunderstoodMessage = new DataClasses.Message()
{
Name = parentMessage.Name + "-misunderstood",
Body = DEFAULT_MISUNDERSTOOD_BODY + " " + parentMessage.Name, // TODO remove test code on body
IsStart = false,
IsEnd = false
};
DataClasses.Transition transition = new DataClasses.Transition()
{
CurrentMessage = misunderstoodMessage,
Intent = IntentService.GetMoveOnIntent(),
NextMessage = parentMessage // Default, move on to the current message
};
misunderstoodMessage.Transitions = new List <DataClasses.Transition>
{
transition
};
return(misunderstoodMessage);
}
