private Task <Workflow> PassActionResultToHandler(ConversationResult receivedConversationResult, Task <Stream> additionalData)
{
Trace.TraceInformation(
$"CallingBotService: Received the outcome for {receivedConversationResult.OperationOutcome.Type} operation, callId: {receivedConversationResult.OperationOutcome.Id}");
switch (receivedConversationResult.OperationOutcome.Type)
{
case ValidOutcomes.AnswerOutcome:
return(HandleAnswerOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as AnswerOutcome));
case ValidOutcomes.HangupOutcome:
return(HandleHangupOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as HangupOutcome));
case ValidOutcomes.PlayPromptOutcome:
return(HandlePlayPromptOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as PlayPromptOutcome));
case ValidOutcomes.RecognizeOutcome:
return(HandleRecognizeOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as RecognizeOutcome));
case ValidOutcomes.RecordOutcome:
return(HandleRecordOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as RecordOutcome, additionalData));
case ValidOutcomes.RejectOutcome:
return(HandleRejectOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as RejectOutcome));
case ValidOutcomes.WorkflowValidationOutcome:
return(HandleWorkflowValidationOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as WorkflowValidationOutcome));
}
throw new BotCallingServiceException($"Unknown conversation result type {receivedConversationResult.OperationOutcome.Type}");
}
public IEnumerable <ConversationResult <T> > CheckConversion(T fileId, bool start)
{
return(FileStorageService.CheckConversion(new ItemList <ItemList <string> >
{
new ItemList <string> {
fileId.ToString(), "0", start.ToString()
}
})
.Select(r =>
{
var o = new ConversationResult <T>
{
Id = r.Id,
Error = r.Error,
OperationType = r.OperationType,
Processed = r.Processed,
Progress = r.Progress,
Source = r.Source,
};
if (!string.IsNullOrEmpty(r.Result))
{
try
{
var jResult = JsonSerializer.Deserialize <FileJsonSerializerData <T> >(r.Result);
o.File = GetFileInfo(jResult.Id, jResult.Version);
}
catch (Exception e)
{
Logger.Error(e);
}
}
return o;
}));
}
private Task <Workflow> HandleHangupOutcome(ConversationResult conversationResult, HangupOutcome hangupOutcome)
{
var outcomeEvent = new HangupOutcomeEvent(conversationResult, CreateInitialWorkflow(), hangupOutcome);
var eventHandler = OnHangupCompleted;
return(InvokeHandlerIfSet(eventHandler, outcomeEvent));
}
private Task <Workflow> HandleAnswerOutcome(ConversationResult conversationResult, AnswerOutcome answerOutcome)
{
var outcomeEvent = new AnswerOutcomeEvent(conversationResult, CreateInitialWorkflow(), answerOutcome);
var eventHandler = OnAnswerCompleted;
return(InvokeHandlerIfSet(eventHandler, outcomeEvent));
}
private Task <Workflow> HandlePlayPromptOutcome(ConversationResult conversationResult, PlayPromptOutcome playPromptOutcome)
{
var outcomeEvent = new PlayPromptOutcomeEvent(conversationResult, CreateInitialWorkflow(), playPromptOutcome);
var eventHandler = OnPlayPromptCompleted;
return(InvokeHandlerIfSet(eventHandler, outcomeEvent));
}
private Task <Workflow> HandleRecordOutcome(ConversationResult conversationResult, RecordOutcome recordOutcome, Task <Stream> recordedContent)
{
var outcomeEvent = new RecordOutcomeEvent(conversationResult, CreateInitialWorkflow(), recordOutcome, recordedContent);
var eventHandler = OnRecordCompleted;
return(InvokeHandlerIfSet(eventHandler, outcomeEvent));
}
private Task <Workflow> HandleRejectOutcome(ConversationResult conversationResult, RejectOutcome rejectOutcome)
{
var outcomeEvent = new RejectOutcomeEvent(conversationResult, CreateInitialWorkflow(), rejectOutcome);
var eventHandler = OnRejectCompleted;
return(InvokeHandlerIfSet(eventHandler, outcomeEvent));
}
public IEnumerable <ConversationResult <T> > CheckConversion(T fileId, bool start)
{
return(FileStorageService.CheckConversion(new ItemList <ItemList <string> >
{
new ItemList <string> {
fileId.ToString(), "0", start.ToString()
}
})
.Select(r =>
{
var o = new ConversationResult <T>
{
Id = r.Id,
Error = r.Error,
OperationType = r.OperationType,
Processed = r.Processed,
Progress = r.Progress,
Source = r.Source,
};
if (!string.IsNullOrEmpty(r.Result))
{
var jResult = JObject.Parse(r.Result);
o.File = GetFileInfo(jResult.Value <T>("id"), jResult.Value <int>("version"));
}
return o;
}));
}
/// <summary>
/// Invokes handlers for callback on the bot
/// </summary>
/// <param name="conversationResult">ConversationResult that has the details of the callback</param>
/// <returns></returns>
internal async Task <string> ProcessConversationResult(ConversationResult conversationResult)
{
conversationResult.Validate();
var newWorkflowResult = await PassActionResultToHandler(conversationResult).ConfigureAwait(false);
if (newWorkflowResult == null)
{
throw new BotCallingServiceException($"[{CallLegId}]: No workflow returned for AnswerAppHostedMediaOutcome");
}
bool expectEmptyActions = false;
if (conversationResult.OperationOutcome.Type == RealTimeMediaValidOutcomes.AnswerAppHostedMediaOutcome && conversationResult.OperationOutcome.Outcome == Outcome.Success)
{
Uri link;
if (conversationResult.Links.TryGetValue("subscriptions", out link))
{
_subscriptionLink = link;
Trace.TraceInformation($"RealTimeMediaCallService [{CallLegId}]: Caching subscription link {link}");
}
if (conversationResult.Links.TryGetValue("call", out link))
{
_callLink = link;
Trace.TraceInformation($"RealTimeMediaCallService [{CallLegId}]: Caching call link {link}");
}
expectEmptyActions = true;
Trace.TraceInformation($"RealTimeMediaCallService [{CallLegId}]: Disposing call expiry timer");
_timer.Dispose();
}
newWorkflowResult.Validate(expectEmptyActions);
return(RealTimeMediaSerializer.SerializeToJson(newWorkflowResult));
}
public BingSpeech(ConversationResult conversationResult, Action <string> callback, Action <bool> failedCallback,
Func <IDialog <object> > dialog)
{
_conversationResult = conversationResult;
_callback = callback;
_failedCallback = failedCallback;
_dialog = dialog;
}
/// <summary>
/// EventArg for the OnAnswerAppHostedMediaCompleted event raised on <see cref="IRealTimeMediaCallService"/>.
/// </summary>
/// <param name="conversationResult">ConversationResult corresponding to the event</param>
/// <param name="resultingWorkflow">Workflow to be returned on completion</param>
/// <param name="outcome">outcome of the operation</param>
public AnswerAppHostedMediaOutcomeEvent(ConversationResult conversationResult, RealTimeMediaWorkflow resultingWorkflow, AnswerAppHostedMediaOutcome outcome) : base(conversationResult, resultingWorkflow)
{
if (outcome == null)
{
throw new ArgumentNullException(nameof(outcome));
}
AnswerAppHostedMediaOutcome = outcome;
}
public PlayPromptOutcomeEvent(ConversationResult conversationResult, Workflow resultingWorkflow, PlayPromptOutcome outcome)
: base(conversationResult, resultingWorkflow)
{
if (outcome == null)
{
throw new ArgumentNullException(nameof(outcome));
}
PlayPromptOutcome = outcome;
}
private Task <Workflow> HandleWorkflowValidationOutcome(
ConversationResult conversationResult,
WorkflowValidationOutcome workflowValidationOutcome)
{
var outcomeEvent = new WorkflowValidationOutcomeEvent(conversationResult, CreateInitialWorkflow(), workflowValidationOutcome);
var eventHandler = OnWorkflowValidationFailed;
return(InvokeHandlerIfSet(eventHandler, outcomeEvent));
}
public RecognizeOutcomeEvent(ConversationResult conversationResult, Workflow resultingWorkflow, RecognizeOutcome outcome)
: base(conversationResult, resultingWorkflow)
{
if (outcome == null)
{
throw new ArgumentNullException(nameof(outcome));
}
RecognizeOutcome = outcome;
}
public void AnalyzeConversationOrchestrationPredictionConversation()
{
ConversationAnalysisClient client = Client;
Response <AnalyzeConversationTaskResult> response = client.AnalyzeConversation(
"Send an email to Carol about the tomorrow's demo",
TestEnvironment.OrchestrationProject);
CustomConversationalTaskResult customConversationalTaskResult = response.Value as CustomConversationalTaskResult;
var orchestratorPrediction = customConversationalTaskResult.Results.Prediction as OrchestratorPrediction;
#region Snippet:ConversationAnalysis_AnalyzeConversationOrchestrationPredictionConversation
string respondingProjectName = orchestratorPrediction.TopIntent;
TargetIntentResult targetIntentResult = orchestratorPrediction.Intents[respondingProjectName];
if (targetIntentResult.TargetKind == TargetKind.Conversation)
{
ConversationTargetIntentResult cluTargetIntentResult = targetIntentResult as ConversationTargetIntentResult;
ConversationResult conversationResult = cluTargetIntentResult.Result;
ConversationPrediction conversationPrediction = conversationResult.Prediction;
Console.WriteLine($"Top Intent: {conversationResult.Prediction.TopIntent}");
Console.WriteLine($"Intents:");
foreach (ConversationIntent intent in conversationPrediction.Intents)
{
Console.WriteLine($"Intent Category: {intent.Category}");
Console.WriteLine($"Confidence: {intent.Confidence}");
Console.WriteLine();
}
Console.WriteLine($"Entities:");
foreach (ConversationEntity entity in conversationPrediction.Entities)
{
Console.WriteLine($"Entity Text: {entity.Text}");
Console.WriteLine($"Entity Category: {entity.Category}");
Console.WriteLine($"Confidence: {entity.Confidence}");
Console.WriteLine($"Starting Position: {entity.Offset}");
Console.WriteLine($"Length: {entity.Length}");
Console.WriteLine();
foreach (BaseResolution resolution in entity.Resolutions)
{
if (resolution is DateTimeResolution dateTimeResolution)
{
Console.WriteLine($"Datetime Sub Kind: {dateTimeResolution.DateTimeSubKind}");
Console.WriteLine($"Timex: {dateTimeResolution.Timex}");
Console.WriteLine($"Value: {dateTimeResolution.Value}");
Console.WriteLine();
}
}
}
}
#endregion
Assert.That(targetIntentResult.TargetKind, Is.EqualTo(TargetKind.Conversation));
Assert.That(orchestratorPrediction.TopIntent, Is.EqualTo("EmailIntent"));
}
//GET
public async Task <IActionResult> EditConversationResult(int?id)
{
int.TryParse(TempData["ExamId"].ToString(), out int examId);
var passedStudents = await _repository.Query <Student>()
.Include(i => i.Result)
.ThenInclude(u => u.Exam)
.Where(x => x.PassedExam == true)
.Where(y => y.Result.Exam.Id == examId)
.ToListAsync();
if (id == null)
{
return(NotFound());
}
var student = await _repository.Query <Student>()
.Include(x => x.ConversationResult)
.FirstOrDefaultAsync(x => x.Id == id);
TempData["ConversationResultId"] = student.ConversationResultId;
TempData["StudentId"] = student.Id;
if (student.ConversationResult == null)
{
ConversationResult conversationResult = new ConversationResult
{
Student = student
};
student.ConversationResult = conversationResult;
conversationResult = await _repository.InsertAsync(conversationResult);
_logger.LogInformation("New conversation result added to DB. User {User}.", _user);
student.ConversationResultId = conversationResult.Id;
TempData["ConversationResultId"] = student.ConversationResultId;
await _repository.SaveAsync();
ConversationResultViewModel conversationResultViewModel = new ConversationResultViewModel
{
ConversationResultId = conversationResult.Id
};
TempData["ExamId"] = examId;
return(View(ConversationResultMappings.ToViewModel(student, conversationResult, examId)));
}
else
{
var conversationResult = await _repository.FindByIdAsync <ConversationResult>(student.ConversationResultId);
ConversationResultViewModel conversationResultViewModel = new ConversationResultViewModel
{
ConversationResultId = conversationResult.Id
};
TempData["ExamId"] = examId;
return(View(ConversationResultMappings.ToViewModel(student, conversationResult, examId)));
}
}
/// <summary>
/// Method responsible for processing the data sent with POST request to callback URL
/// </summary>
/// <param name="content">The content of request</param>
/// <param name="additionalData">The remaining part of request in case of multi part request</param>
/// <returns>Returns the response that should be sent to the sender of POST request</returns>
public async Task <string> ProcessCallbackAsync(string content, Task <Stream> additionalData)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
ConversationResult conversationResult = ConvertToConversationResult(content);
return(await ProcessConversationResult(conversationResult, additionalData).ConfigureAwait(false));
}
private async Task <string> ProcessConversationResult(ConversationResult conversationResult, Task <Stream> additionalData)
{
conversationResult.Validate();
var newWorkflowResult = await PassActionResultToHandler(conversationResult, additionalData).ConfigureAwait(false);
if (newWorkflowResult == null)
{
return("");
}
newWorkflowResult.Validate();
return(Serializer.SerializeToJson(newWorkflowResult));
}
/// <summary>
/// 初始化会话
/// </summary>
/// <param name="message"></param>
/// <param name="botConnectorKey"></param>
/// <returns></returns>
public async Task <ConversationResult> Conversation(string message, string botConnectorKey)
{
conversationResult = new ConversationResult();
if (await GetToken(botConnectorKey))
{
return(await CreateOrGetConversation(message));
}
conversationResult.resultMessage = "授权失败！";
return(conversationResult);
}
public RecordOutcomeEvent(
ConversationResult conversationResult,
Workflow resultingWorkflow,
RecordOutcome outcome,
Task <Stream> recordedContent) : base(conversationResult, resultingWorkflow)
{
if (outcome == null)
{
throw new ArgumentNullException(nameof(outcome));
}
RecordOutcome = outcome;
RecordedContent = recordedContent;
}
public OutcomeEventBase(ConversationResult conversationResult, Workflow resultingWorkflow)
{
if (conversationResult == null)
{
throw new ArgumentNullException(nameof(conversationResult));
}
if (resultingWorkflow == null)
{
throw new ArgumentNullException(nameof(resultingWorkflow));
}
ConversationResult = conversationResult;
ResultingWorkflow = resultingWorkflow;
}
//GET
public async Task <IActionResult> EditConversationForm(int?studentId)
{
var studentById = await _repository.Query <Student>().FirstOrDefaultAsync(x => x.Id == studentId);
int.TryParse(TempData["ExamId"].ToString(), out int examId);
var conversationForms = await _repository
.Query <ConversationForm>()
.Include(x => x.ConversationResult)
.ThenInclude(x => x.Student)
.Where(x => x.ConversationResultId == studentById.ConversationResultId)
.ToListAsync();
List <ConversationForm> newConversationForms = new List <ConversationForm>();
if (studentById.ConversationResultId == null)
{
ConversationResult conversationResult = new ConversationResult
{
Student = studentById,
StudentForeignKey = studentById.Id
};
await _repository.InsertAsync(conversationResult);
studentById.ConversationResultId = conversationResult.Id;
await _repository.SaveAsync();
}
if (conversationForms.Count() == 0)
{
for (int i = 0; i < 10; i++)
{
newConversationForms.Add(new ConversationForm {
ConversationResultId = studentById.ConversationResultId
});
await _repository.InsertAsync <ConversationForm>(newConversationForms.ElementAt(i));
}
conversationForms = newConversationForms;
conversationForms = await _repository
.Query <ConversationForm>()
.Include(x => x.ConversationResult)
.ThenInclude(x => x.Student)
.Where(x => x.ConversationResultId == studentById.ConversationResultId)
.ToListAsync();
_logger.LogInformation("Successfully created conversation form. User {User}", _user);
}
TempData["ExamId"] = examId;
TempData["ConversationResultId"] = studentById.ConversationResultId;
TempData["StudentId"] = studentById.Id;
return(View(ConversationResultMappings.ToConversationFormViewModel(conversationForms, studentById, examId)));
}
public void AnalyzeConversationOrchestrationPredictionConversation()
{
ConversationAnalysisClient client = Client;
Response <AnalyzeConversationResult> response = client.AnalyzeConversation(
"We'll have 2 plates of seared salmon nigiri.",
TestEnvironment.OrchestrationProject);
OrchestratorPrediction orchestratorPrediction = response.Value.Prediction as OrchestratorPrediction;
#region Snippet:ConversationAnalysis_AnalyzeConversationOrchestrationPredictionConversation
string respondingProjectName = orchestratorPrediction.TopIntent;
TargetIntentResult targetIntentResult = orchestratorPrediction.Intents[respondingProjectName];
if (targetIntentResult.TargetKind == TargetKind.Conversation)
{
ConversationTargetIntentResult cluTargetIntentResult = targetIntentResult as ConversationTargetIntentResult;
ConversationResult conversationResult = cluTargetIntentResult.Result;
ConversationPrediction conversationPrediction = conversationResult.Prediction;
if (!String.IsNullOrEmpty(conversationResult.DetectedLanguage))
{
Console.WriteLine($"Detected Language: {conversationResult.DetectedLanguage}");
}
Console.WriteLine($"Top Intent: {conversationResult.Prediction.TopIntent}");
Console.WriteLine($"Intents:");
foreach (ConversationIntent intent in conversationPrediction.Intents)
{
Console.WriteLine($"Intent Category: {intent.Category}");
Console.WriteLine($"Confidence Score: {intent.ConfidenceScore}");
Console.WriteLine();
}
Console.WriteLine($"Entities:");
foreach (ConversationEntity entitiy in conversationPrediction.Entities)
{
Console.WriteLine($"Entity Text: {entitiy.Text}");
Console.WriteLine($"Entity Category: {entitiy.Category}");
Console.WriteLine($"Confidence Score: {entitiy.ConfidenceScore}");
Console.WriteLine($"Starting Position: {entitiy.Offset}");
Console.WriteLine($"Length: {entitiy.Length}");
Console.WriteLine();
}
}
#endregion
Assert.That(targetIntentResult.TargetKind, Is.EqualTo(TargetKind.Conversation));
Assert.That(orchestratorPrediction.TopIntent, Is.EqualTo("SushiOrder"));
}
public static ConversationResultViewModel ToViewModel(Student studentEntity, ConversationResult conversationResultEntity, int?examId)
{
return(new ConversationResultViewModel
{
StudentId = studentEntity.Id,
FirstName = studentEntity.FirstName,
LastName = studentEntity.LastName,
Email = studentEntity.Email,
PhoneNumber = studentEntity.PhoneNumber,
ConversationResultComment = conversationResultEntity.Comment,
ConversationResultId = (int)studentEntity.ConversationResultId,
Grade = conversationResultEntity.Grade == null ? 0 : conversationResultEntity.Grade,
ExamId = examId
});
}
public static ConversationResultViewModel ToConversationResultViewModel(ConversationResult conversationResultEntity)
{
if (conversationResultEntity == null)
{
return(new ConversationResultViewModel
{
Grade = null,
ConversationResultComment = null,
});
}
return(new ConversationResultViewModel
{
ConversationResultId = conversationResultEntity.Id,
Grade = conversationResultEntity?.Grade,
});
}
private Task <RealTimeMediaWorkflow> PassActionResultToHandler(ConversationResult receivedConversationResult)
{
Trace.TraceInformation(
$"RealTimeMediaCallService [{CallLegId}]: Received the outcome for {receivedConversationResult.OperationOutcome.Type} operation, callId: {receivedConversationResult.OperationOutcome.Id}");
switch (receivedConversationResult.OperationOutcome.Type)
{
case RealTimeMediaValidOutcomes.AnswerAppHostedMediaOutcome:
return(HandleAnswerAppHostedMediaOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as AnswerAppHostedMediaOutcome));
case ValidOutcomes.WorkflowValidationOutcome:
return(HandleWorkflowValidationOutcome(receivedConversationResult, receivedConversationResult.OperationOutcome as WorkflowValidationOutcome));
}
throw new BotCallingServiceException($"[{CallLegId}]: Unknown conversation result type {receivedConversationResult.OperationOutcome.Type}");
}
public async static Task <string> PostMessage(string message)
{
BotClient botClient = new BotClient();
//这里测试的是贩卖机的Bot
string botFrom = "Demo";
string botConnectorKey = "Put your DL3.0 key here";
ConversationResult result = await botClient.Conversation(message, botConnectorKey);
if (result.botActivities != null)
{
foreach (Activities activities in result.botActivities.activities.Where(item => item.from.id == botFrom))
{
replyMessages = activities.text;
}
}
return(replyMessages);
}
public static void ToEntity(Student student, Result result, ConversationResult conversationResult, ImportedStudentsDataModel importedStudentsDataModel)
{
student.FirstName = importedStudentsDataModel.FirstName;
student.LastName = importedStudentsDataModel.LastName;
student.PassedExam = importedStudentsDataModel.PassedExam;
student.InvitedToStudy = importedStudentsDataModel.InvitationToStudy;
student.SignedAContract = importedStudentsDataModel.SignedAContract;
student.ResultId = result.Id;
student.Result = result;
student.ConversationResultId = conversationResult.Id;
student.ConversationResult = conversationResult;
student.Email = importedStudentsDataModel.Email;
student.PhoneNumber = importedStudentsDataModel.PhoneNumber;
result.Student = student;
result.StudentForeignKey = student.Id;
result.Tasks = importedStudentsDataModel.Tasks;
conversationResult.Grade = importedStudentsDataModel.ConversationResult;
conversationResult.StudentForeignKey = student.Id;
conversationResult.Student = student;
}
/// <summary>
/// Makes a Conversational API request
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ConversationResult> Compute(ConversationRequest request)
{
string baseUrl = ApiBaseUrl;
if (!string.IsNullOrWhiteSpace(request?.Host))
{
baseUrl = $"https://{request.Host}/api/";
}
baseUrl += ConversationalApiUrl;
string url = BuildUrl(baseUrl, request);
using (var client = new HttpClient())
{
var httpRequest = await client.GetAsync(url);
var response = await httpRequest.Content.ReadAsStringAsync();
ConversationResult result = JsonConvert.DeserializeObject <ConversationResult>(response);
return(result);
}
}
public IEnumerable <ConversationResult <T> > CheckConversion(T fileId, bool start, bool sync = false)
{
return(FileStorageService.CheckConversion(new List <List <string> >
{
new List <string> {
fileId.ToString(), "0", start.ToString()
}
}, sync)
.Select(r =>
{
var o = new ConversationResult <T>
{
Id = r.Id,
Error = r.Error,
OperationType = r.OperationType,
Processed = r.Processed,
Progress = r.Progress,
Source = r.Source,
};
if (!string.IsNullOrEmpty(r.Result))
{
try
{
var options = new JsonSerializerOptions
{
AllowTrailingCommas = true,
PropertyNameCaseInsensitive = true
};
var jResult = JsonSerializer.Deserialize <FileJsonSerializerData <T> >(r.Result, options);
o.File = GetFileInfo(jResult.Id, jResult.Version);
}
catch (Exception e)
{
Logger.Error(e);
}
}
return o;
}));
}
