private void GetToneAnalyzerResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
ToneAnalyzerResponse response = new ToneAnalyzerResponse();
if (resp.Success)
{
try
{
fsData data = null;
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = response;
r = sm_Serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
}
catch (Exception e)
{
Log.Error("ToneAnalyzer", "GetToneAnalyzerResponse Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (((GetToneAnalyzerRequest)req).Callback != null)
{
((GetToneAnalyzerRequest)req).Callback(resp.Success ? response : null, ((GetToneAnalyzerRequest)req).Data);
}
}
private void ToSpeechResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
ToSpeechRequest speechReq = req as ToSpeechRequest;
if (speechReq == null)
{
throw new WatsonException("Wrong type of request object.");
}
//Log.Debug( "TextToSpeech", "Request completed in {0} seconds.", resp.ElapsedTime );
AudioClip clip = resp.Success ? ProcessResponse(speechReq.TextId, resp.Data) : null;
if (clip == null)
{
Log.Error("TextToSpeech", "Request Failed: {0}", resp.Error);
}
if (m_SpeechCache != null && clip != null)
{
m_SpeechCache.Save(speechReq.TextId, resp.Data);
}
if (speechReq.Callback != null)
{
speechReq.Callback(clip);
}
}
private void OnAskQuestionResp(RESTConnector.Request req, RESTConnector.Response resp)
{
Response response = null;
if (resp.Success)
{
try
{
response = ProcessAskResp(resp.Data);
if (m_QuestionCache != null && response != null)
{
m_QuestionCache.Save(((AskQuestionReq)req).QuestionID, resp.Data);
}
}
catch (Exception e)
{
Log.Error("Natural Language Classifier", "GetClassifiers Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (((AskQuestionReq)req).Callback != null)
{
if (resp.Success && response != null)
{
response.question.questionId = ((AskQuestionReq)req).QuestionID;
((AskQuestionReq)req).Callback(response.question);
}
else
{
((AskQuestionReq)req).Callback(null);
}
}
}
private void OnAnalyzeResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
DetailedResponse <AnalysisResults> response = new DetailedResponse <AnalysisResults>();
foreach (KeyValuePair <string, string> kvp in resp.Headers)
{
response.Headers.Add(kvp.Key, kvp.Value);
}
response.StatusCode = resp.HttpResponseCode;
try
{
string json = Encoding.UTF8.GetString(resp.Data);
response.Result = JsonConvert.DeserializeObject <AnalysisResults>(json);
response.Response = json;
}
catch (Exception e)
{
Log.Error("NaturalLanguageUnderstandingService.OnAnalyzeResponse()", "Exception: {0}", e.ToString());
resp.Success = false;
}
if (((RequestObject <AnalysisResults>)req).Callback != null)
{
((RequestObject <AnalysisResults>)req).Callback(response, resp.Error);
}
}
private void OnDeleteClassifierResp(RESTConnector.Request req, RESTConnector.Response resp)
{
if (((DeleteClassifierReq)req).Callback != null)
{
((DeleteClassifierReq)req).Callback(resp.Success);
}
}
private void OnRefreshIamTokenResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
DetailedResponse <IamTokenData> response = new DetailedResponse <IamTokenData>();
response.Result = new IamTokenData();
foreach (KeyValuePair <string, string> kvp in resp.Headers)
{
response.Headers.Add(kvp.Key, kvp.Value);
}
response.StatusCode = resp.HttpResponseCode;
try
{
string json = Encoding.UTF8.GetString(resp.Data);
response.Result = JsonConvert.DeserializeObject <IamTokenData>(json);
response.Response = json;
}
catch (Exception e)
{
Log.Error("Credentials.OnRefreshIamTokenResponse()", "Exception: {0}", e.ToString());
resp.Success = false;
}
if (((RefreshIamTokenRequest)req).Callback != null)
{
((RefreshIamTokenRequest)req).Callback(response, resp.Error);
}
}
private void OnTrainClassifierResp(RESTConnector.Request req, RESTConnector.Response resp)
{
Classifier classifier = new Classifier();
if (resp.Success)
{
try
{
fsData data = null;
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = classifier;
r = sm_Serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
}
catch (Exception e)
{
Log.Error("Natural Language Classifier", "GetClassifiers Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (((TrainClassifierReq)req).Callback != null)
{
((TrainClassifierReq)req).Callback(resp.Success ? classifier : null);
}
}
private void OnRecognizeResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
RecognizeRequest recognizeReq = req as RecognizeRequest;
if (recognizeReq == null)
{
throw new WatsonException("Unexpected request type.");
}
SpeechResultList result = null;
if (resp.Success)
{
result = ParseRecognizeResponse(resp.Data);
if (result == null)
{
Log.Error("SpeechToText", "Failed to parse json response: {0}",
resp.Data != null ? Encoding.UTF8.GetString(resp.Data) : "");
}
else
{
Log.Status("SpeechToText", "Received Recognize Response, Elapsed Time: {0}, Results: {1}",
resp.ElapsedTime, result.Results.Length);
}
}
else
{
Log.Error("SpeechToText", "Recognize Error: {0}", resp.Error);
}
if (recognizeReq.Callback != null)
{
recognizeReq.Callback(result);
}
}
private void MessageResp(RESTConnector.Request req, RESTConnector.Response resp)
{
object dataObject = null;
string data = "";
if (resp.Success)
{
try
{
// For deserializing into a generic object
data = Encoding.UTF8.GetString(resp.Data);
dataObject = Json.Deserialize(data);
}
catch (Exception e)
{
Log.Error("Conversation", "MessageResp Exception: {0}", e.ToString());
data = e.Message;
resp.Success = false;
}
}
string customData = ((MessageReq)req).Data;
if (((MessageReq)req).Callback != null)
{
((MessageReq)req).Callback(resp.Success ? dataObject : null, !string.IsNullOrEmpty(customData) ? customData : data.ToString());
}
}
private void OnDeleteClassifierResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
DetailedResponse <object> response = new DetailedResponse <object>();
foreach (KeyValuePair <string, string> kvp in resp.Headers)
{
response.Headers.Add(kvp.Key, kvp.Value);
}
response.StatusCode = resp.HttpResponseCode;
try
{
string json = Encoding.UTF8.GetString(resp.Data);
response.Result = JsonConvert.DeserializeObject <object>(json);
response.Response = json;
}
catch (Exception e)
{
Log.Error("VisualRecognitionService.OnDeleteClassifierResponse()", "Exception: {0}", e.ToString());
resp.Success = false;
}
if (((RequestObject <object>)req).Callback != null)
{
((RequestObject <object>)req).Callback(response, resp.Error);
}
}
private void DeleteModelResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
string customData = ((DeleteModelReq)req).Data;
if (((DeleteModelReq)req).Callback != null)
{
((DeleteModelReq)req).Callback(resp.Success, customData);
}
}
private void OnClassifyResp(RESTConnector.Request req, RESTConnector.Response resp)
{
ClassifyTopLevelMultiple classify = null;
if (resp.Success)
{
classify = ProcessClassifyResult(resp.Data);
}
if (((ClassifyReq)req).Callback != null)
{
((ClassifyReq)req).Callback(classify);
}
}
private void OnDetectFacesResp(RESTConnector.Request req, RESTConnector.Response resp)
{
FacesTopLevelMultiple faces = null;
if (resp.Success)
{
faces = ProcessDetectFaceResult(resp.Data);
}
if (((DetectFacesReq)req).Callback != null)
{
((DetectFacesReq)req).Callback(faces);
}
}
private void OnGetModelsResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
ListModelsResults result = new ListModelsResults();
fsData data = null;
Dictionary <string, object> customData = ((GetModelsRequest)req).CustomData;
customData.Add(Constants.String.RESPONSE_HEADERS, resp.Headers);
if (resp.Success)
{
try
{
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = result;
r = _serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
customData.Add("json", data);
}
catch (Exception e)
{
Log.Error("Discovery.OnGetModelsResponse()", "OnGetModelssResponse Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (resp.Success)
{
if (((GetModelsRequest)req).SuccessCallback != null)
{
((GetModelsRequest)req).SuccessCallback(result, customData);
}
}
else
{
if (((GetModelsRequest)req).FailCallback != null)
{
((GetModelsRequest)req).FailCallback(resp.Error, customData);
}
}
}
private void OnRecognizeTextResp(RESTConnector.Request req, RESTConnector.Response resp)
{
TextRecogTopLevelMultiple text = null;
if (resp.Success)
{
text = ProcessRecognizeTextResult(resp.Data);
}
if (((RecognizeTextReq)req).Callback != null)
{
((RecognizeTextReq)req).Callback(text);
}
}
private void OnClassifyResp(RESTConnector.Request req, RESTConnector.Response resp)
{
ClassifyResult result = new ClassifyResult();;
fsData data = null;
Dictionary <string, object> customData = ((ClassifyReq)req).CustomData;
customData.Add(Constants.String.RESPONSE_HEADERS, resp.Headers);
if (resp.Success)
{
try
{
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = result;
r = _serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
customData.Add("json", data);
}
catch (Exception e)
{
Log.Error("NaturalLanguageClassifier.OnTrainClassifierResp()", "GetClassifiers Exception: {0}", e.ToString());
}
}
if (resp.Success)
{
if (((ClassifyReq)req).SuccessCallback != null)
{
((ClassifyReq)req).SuccessCallback(result, customData);
}
}
else
{
if (((ClassifyReq)req).FailCallback != null)
{
((ClassifyReq)req).FailCallback(resp.Error, customData);
}
}
}
private void GetDilemmaResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
DilemmasResponse result = new DilemmasResponse();
fsData data = null;
Dictionary <string, object> customData = ((GetDilemmaRequest)req).CustomData;
if (resp.Success)
{
try
{
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = result;
r = _serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
customData.Add("json", data);
}
catch (Exception e)
{
Log.Error("TradeoffAnalytics.GetDilemmaResponse()", "GetDilemmaResponse Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (resp.Success)
{
if (((GetDilemmaRequest)req).SuccessCallback != null)
{
((GetDilemmaRequest)req).SuccessCallback(result, customData);
}
}
else
{
if (((GetDilemmaRequest)req).FailCallback != null)
{
((GetDilemmaRequest)req).FailCallback(resp.Error, customData);
}
}
}
private void OnGetTranslatedDocumentResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
DetailedResponse <byte[]> response = new DetailedResponse <byte[]>();
foreach (KeyValuePair <string, string> kvp in resp.Headers)
{
response.Headers.Add(kvp.Key, kvp.Value);
}
response.StatusCode = resp.HttpResponseCode;
response.Result = resp.Data;
if (((RequestObject <byte[]>)req).Callback != null)
{
((RequestObject <byte[]>)req).Callback(response, resp.Error);
}
}
private void OnProfileAsCsvResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
DetailedResponse <System.IO.MemoryStream> response = new DetailedResponse <System.IO.MemoryStream>();
foreach (KeyValuePair <string, string> kvp in resp.Headers)
{
response.Headers.Add(kvp.Key, kvp.Value);
}
response.StatusCode = resp.HttpResponseCode;
response.Result = new System.IO.MemoryStream(resp.Data);
if (((RequestObject <System.IO.MemoryStream>)req).Callback != null)
{
((RequestObject <System.IO.MemoryStream>)req).Callback(response, resp.Error);
}
}
private void ConvertDocumentResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
ConvertedDocument response = new ConvertedDocument();
fsData data = null;
fsResult r;
if (resp.Success)
{
if ((req as ConvertDocumentRequest).ConversionTarget == ConversionTarget.Answerunits)
{
try
{
r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = response;
r = _serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
}
catch (Exception e)
{
Log.Error("DocumentConversion", "ConvertDocumentResponse Exception: {0}", e.ToString());
resp.Success = false;
}
}
else if ((req as ConvertDocumentRequest).ConversionTarget == ConversionTarget.NormalizedHtml)
{
response.htmlContent = System.Text.Encoding.Default.GetString(resp.Data);
}
else if ((req as ConvertDocumentRequest).ConversionTarget == ConversionTarget.NormalizedText)
{
response.textContent = System.Text.Encoding.Default.GetString(resp.Data);
}
}
if (((ConvertDocumentRequest)req).Callback != null)
{
((ConvertDocumentRequest)req).Callback(resp.Success ? response : null, ((ConvertDocumentRequest)req).Data);
}
}
private void OnRefreshIamTokenResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
DetailedResponse <IamTokenData> response = new DetailedResponse <IamTokenData>();
response.Result = new IamTokenData();
fsData data = null;
foreach (KeyValuePair <string, string> kvp in resp.Headers)
{
response.Headers.Add(kvp.Key, kvp.Value);
}
if (resp.Success)
{
try
{
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new IBMException(r.FormattedMessages);
}
object obj = response.Result;
r = _serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new IBMException(r.FormattedMessages);
}
response.Response = data.ToString();
}
catch (Exception e)
{
Log.Error("TokenManager.OnRefreshTokenResponse()", "Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (((RefreshIamTokenRequest)req).Callback != null)
{
((RefreshIamTokenRequest)req).Callback(response, resp.Error);
}
}
private void OnIdentifyResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
IdentifyReq identifyRequest = req as IdentifyReq;
if (identifyRequest == null)
{
throw new WatsonException("Unexpected Request type.");
}
string identifiedLanguages;
if (resp.Success)
{
identifiedLanguages = Encoding.UTF8.GetString(resp.Data);
string customData = identifyRequest.Data;
if (((IdentifyReq)req).Callback != null)
{
((IdentifyReq)req).Callback(resp.Success ? identifiedLanguages : null, (!string.IsNullOrEmpty(customData) ? customData : identifiedLanguages));
}
}
}
private void OnDeleteClassifierResp(RESTConnector.Request req, RESTConnector.Response resp)
{
Dictionary <string, object> customData = ((DeleteClassifierReq)req).CustomData;
if (resp.Success)
{
customData.Add("json", "code: " + resp.HttpResponseCode + ", success: " + resp.Success);
if (((DeleteClassifierReq)req).SuccessCallback != null)
{
((DeleteClassifierReq)req).SuccessCallback(resp.Success, customData);
}
}
else
{
if (((DeleteClassifierReq)req).FailCallback != null)
{
((DeleteClassifierReq)req).FailCallback(resp.Error, customData);
}
}
}
private void MessageResp(RESTConnector.Request req, RESTConnector.Response resp)
{
object result = null;
string data = "";
Dictionary <string, object> customData = ((MessageReq)req).CustomData;
customData.Add(Constants.String.RESPONSE_HEADERS, resp.Headers);
if (resp.Success)
{
try
{
// For deserializing into a generic object
data = Encoding.UTF8.GetString(resp.Data);
result = Json.Deserialize(data);
customData.Add("json", data);
}
catch (Exception e)
{
Log.Error("Conversation.MessageResp()", "MessageResp Exception: {0}", e.ToString());
data = e.Message;
resp.Success = false;
}
}
if (resp.Success)
{
if (((MessageReq)req).SuccessCallback != null)
{
((MessageReq)req).SuccessCallback(result, customData);
}
}
else
{
if (((MessageReq)req).FailCallback != null)
{
((MessageReq)req).FailCallback(resp.Error, customData);
}
}
}
private void MessageResp(RESTConnector.Request req, RESTConnector.Response resp)
{
object dataObject = null;
string data = "";
//MessageResponse response = new MessageResponse();
//fsData data = null;
if (resp.Success)
{
try
{
// For deserializing into a generic object
data = Encoding.UTF8.GetString(resp.Data);
dataObject = Json.Deserialize(data);
// For deserializing into fixed data model
// fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
// if (!r.Succeeded)
// throw new WatsonException(r.FormattedMessages);
// object obj = response;
// r = sm_Serializer.TryDeserialize(data, obj.GetType(), ref obj);
// if (!r.Succeeded)
// throw new WatsonException(r.FormattedMessages);
}
catch (Exception e)
{
Log.Error("Conversation", "MessageResp Exception: {0}", e.ToString());
data = e.Message;
resp.Success = false;
}
}
if (((MessageReq)req).Callback != null)
{
((MessageReq)req).Callback(resp.Success ? dataObject : null, !string.IsNullOrEmpty(((MessageReq)req).Data) ? ((MessageReq)req).Data : data.ToString());
}
}
private void OnClassifyResp(RESTConnector.Request req, RESTConnector.Response resp)
{
ClassifyResult classify = null;
if (resp.Success)
{
classify = ProcessClassifyResult(resp.Data);
if (classify != null)
{
DataCache cache = null;
if (m_ClassifyCache.TryGetValue(((ClassifyReq)req).ClassiferId, out cache))
{
cache.Save(((ClassifyReq)req).TextId, resp.Data);
}
}
}
if (((ClassifyReq)req).Callback != null)
{
((ClassifyReq)req).Callback(classify);
}
}
private void OnCreateDialogResp(RESTConnector.Request req, RESTConnector.Response resp)
{
string id = null;
if (resp.Success)
{
try
{
IDictionary json = Json.Deserialize(Encoding.UTF8.GetString(resp.Data)) as IDictionary;
id = (string)json["dialog_id"];
}
catch (Exception e)
{
Log.Error("Natural Language Classifier", "UploadDialog Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (((UploadDialogReq)req).Callback != null)
{
((UploadDialogReq)req).Callback(id);
}
}
private void OnGetModelsResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
GetModelsRequest gmr = req as GetModelsRequest;
if (gmr == null)
{
throw new WatsonException("Unexpected request type.");
}
SpeechModel[] models = null;
if (resp.Success)
{
models = ParseGetModelsResponse(resp.Data);
if (models == null)
{
Log.Error("SpeechToText", "Failed to parse GetModels response.");
}
}
if (gmr.Callback != null)
{
gmr.Callback(models);
}
}
private void OnDeleteModelResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
Dictionary <string, object> customData = ((DeleteModelRequest)req).CustomData;
customData.Add(Constants.String.RESPONSE_HEADERS, resp.Headers);
if (resp.Success)
{
customData.Add("json", "code: " + resp.HttpResponseCode + ", success: " + resp.Success);
if (((DeleteModelRequest)req).SuccessCallback != null)
{
((DeleteModelRequest)req).SuccessCallback(resp.Success, customData);
}
}
else
{
if (((DeleteModelRequest)req).FailCallback != null)
{
((DeleteModelRequest)req).FailCallback(resp.Error, customData);
}
}
}
private void OnCreateModelResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
TranslationModel result = new TranslationModel();
fsData data = null;
if (resp.Success)
{
try
{
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = result;
r = _serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
}
catch (Exception e)
{
Log.Error("Discovery", "Create model Exception: {0}", e.ToString());
resp.Success = false;
}
}
string customData = ((CreateModelRequest)req).Data;
if (((CreateModelRequest)req).Callback != null)
{
((CreateModelRequest)req).Callback(resp.Success ? result : null, !string.IsNullOrEmpty(customData) ? customData : data.ToString());
}
}
