public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequest req,
[StorageAccount("StorageConnectionString")] CloudStorageAccount storageAccount,
TraceWriter log
)
{
var client = storageAccount.CreateCloudTableClient();
string partitionKey = await Authenticator.Authenticate(client, req);
if (string.IsNullOrEmpty(partitionKey))
{
return(new UnauthorizedResult());
}
var itemTable = client.GetTableReference(PartitionV2.TableName);
await itemTable.CreateIfNotExistsAsync();
var query = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey);
var exQuery = new TableQuery <PartitionV2>().Where(query);
var domainPartitions = await QueryHelper.ListAll(itemTable, exQuery);
var partitions = domainPartitions
.Select(p => new PartitionResponse {
Partition = p.RowKey.Replace(partitionKey, ""), IsActive = p.IsActive
})
.ToList();
log.Info($"A total of {partitions.Count} partitions were returned");
return(new OkObjectResult(partitions));
//return req.CreateResponse(HttpStatusCode.OK, partitions, Json.JsonFormatter);
}
public async Task <string> Get()
{
var authenticator = new Authenticator();
var response = await authenticator.Authenticate();
return(await response.Content.ReadAsStringAsync());
}
/// <summary>
/// List documents.
///
/// Lists documents that have been submitted for translation.
/// </summary>
/// <param name="callback">The callback function that is invoked when the operation completes.</param>
/// <returns><see cref="DocumentList" />DocumentList</returns>
public bool ListDocuments(Callback <DocumentList> callback)
{
if (callback == null)
{
throw new ArgumentNullException("`callback` is required for `ListDocuments`");
}
RequestObject <DocumentList> req = new RequestObject <DocumentList>
{
Callback = callback,
HttpMethod = UnityWebRequest.kHttpVerbGET,
DisableSslVerification = DisableSslVerification
};
foreach (KeyValuePair <string, string> kvp in customRequestHeaders)
{
req.Headers.Add(kvp.Key, kvp.Value);
}
ClearCustomRequestHeaders();
foreach (KeyValuePair <string, string> kvp in Common.GetSdkHeaders("language_translator", "V3", "ListDocuments"))
{
req.Headers.Add(kvp.Key, kvp.Value);
}
req.Parameters["version"] = VersionDate;
req.OnResponse = OnListDocumentsResponse;
Connector.URL = GetServiceUrl() + "/v3/documents";
Authenticator.Authenticate(Connector);
return(Connector.Send(req));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
[StorageAccount("StorageConnectionString")] CloudStorageAccount storageAccount,
TraceWriter log
)
{
try {
var client = storageAccount.CreateCloudTableClient();
string userKey = await Authenticator.Authenticate(client, req);
if (string.IsNullOrEmpty(userKey))
{
return(new UnauthorizedResult());
}
var subPartition = req.Query["partition"];
if (string.IsNullOrWhiteSpace(subPartition))
{
return(new BadRequestObjectResult("The query parameter \"partition\" empty or missing"));
}
log.Info($"User {userKey} has requested an item download for sub partition {subPartition}");
var itemTable = client.GetTableReference(ItemV2.TableName);
var query = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal,
userKey + "-" + subPartition);
var exQuery = new TableQuery <ItemV2>().Where(query);
var unfilteredItems = await QueryHelper.ListAll(itemTable, exQuery);
var filteredItems = unfilteredItems.Where(m => m.IsActive).ToList();
log.Info($"A total of {filteredItems.Count} items were returned");
var deleted = await GetDeletedItems(userKey + subPartition, client);
log.Info($"A total of {deleted.Count} items were marked for deletion");
if (filteredItems.Count > 80)
{
log.Info($"Disabling partition {subPartition} for {userKey} (may already be disabled)");
var table = client.GetTableReference(PartitionV2.TableName);
await table.CreateIfNotExistsAsync();
DisablePartition(userKey, subPartition, table);
}
var result = new DownloadResponse {
Items = filteredItems.Select(m => Map(userKey, m)).ToList(),
Removed = deleted
};
return(new OkObjectResult(result));
}
catch (Exception ex) {
log.Error(ex.Message, ex);
return(new ExceptionResult(ex, false));
}
}
private void DoAuthentication()
{
if (Authenticator != null)
{
Authenticator.Authenticate(this, null);
}
}
static void Main(string[] args)
{
Authenticator auth = Authenticator.Instance;
auth.Authenticate(authUrl, clientId, clientSecret); //Pass auth url, username, and password to authenticate to auth server
foreach (Endpoint e in auth.GetEndpoints(providerId)) //For the provided endpoint
{
XPress xPress = new XPress(e.href); //Pass endpoint info to data API (token, href)
foreach (XLeaType l in xPress.GetXLeas().Data) //Iterate through each xLea
{
for (int i = 1; i <= xPress.GetLastPage(ServicePath.GetXRostersByXLea, l.refId, navigationPageSize); i++) //Get max page size for rosters by lea
{
foreach (XRosterType r in xPress.GetXRostersByXLea(l.refId, i, navigationPageSize).Data) //Get each roster for each lea refId w/ paging
{
Console.WriteLine("courseTitle: " + r.courseTitle);
foreach (XPersonReferenceType p in r.students.studentReference) //Students for each course
{
Console.WriteLine("refId: " + p.refId);
Console.WriteLine("localId: " + p.localId);
Console.WriteLine("givenName: " + p.givenName);
Console.WriteLine("familyName: " + p.familyName);
}
}
Console.WriteLine("######## PAGE " + i + " ########");
}
}
}
Console.Read();
}
private async Task ReconnectImpl()
{
await CloseProto();
Debug.WriteLine("Creating new transport..");
if (ClientSettings.Session.AuthKey == null)
{
Step3_Response result = await Authenticator.Authenticate(ClientSettings.Session.ServerAddress, ClientSettings.Session.Port);
ClientSettings.Session.AuthKey = result.authKey;
ClientSettings.Session.TimeOffset = result.timeOffset;
ClientSettings.Session.Salt = result.serverSalt;
}
_protoSender = new MtProtoSender(ClientSettings.Session);
Subscribe();
_protoSender.Start();
var request = new InitConnectionAndGetConfigRequest(s_apiLayer, ClientSettings.AppId, _deviceInfo);
await SendRpcRequest(request);
_configuration = request.config;
_dcOptions = new DcOptionsCollection(request.config.dcOptions);
OnConnectionStateChanged(ConnectionStateEventArgs.Connected());
}
/// <summary>
/// List classifiers.
///
/// Returns an empty array if no classifiers are available.
/// </summary>
/// <param name="callback">The callback function that is invoked when the operation completes.</param>
/// <returns><see cref="ClassifierList" />ClassifierList</returns>
public bool ListClassifiers(Callback <ClassifierList> callback)
{
if (callback == null)
{
throw new ArgumentNullException("`callback` is required for `ListClassifiers`");
}
RequestObject <ClassifierList> req = new RequestObject <ClassifierList>
{
Callback = callback,
HttpMethod = UnityWebRequest.kHttpVerbGET,
DisableSslVerification = DisableSslVerification
};
foreach (KeyValuePair <string, string> kvp in customRequestHeaders)
{
req.Headers.Add(kvp.Key, kvp.Value);
}
ClearCustomRequestHeaders();
foreach (KeyValuePair <string, string> kvp in Common.GetSdkHeaders("natural_language_classifier", "V1", "ListClassifiers"))
{
req.Headers.Add(kvp.Key, kvp.Value);
}
req.OnResponse = OnListClassifiersResponse;
Connector.URL = GetServiceUrl() + "/v1/classifiers";
Authenticator.Authenticate(Connector);
return(Connector.Send(req));
}
public void Setup()
{
var authenticator = new Authenticator();
authenticator.Authenticate("test");
var serviceProvider = new GoogleDriveServiceProvider(authenticator);
this.testee = new FolderSynchronizer(new FilesGetter(serviceProvider), new FileDownloader(serviceProvider));
}
public void Setup()
{
var driveAuthenticator = new Authenticator();
driveAuthenticator.Authenticate("test");
this.googleDriveServiceProvider = new GoogleDriveServiceProvider(driveAuthenticator);
this.testee = new FileDownloader(this.googleDriveServiceProvider);
}
static void Main(string[] args)
{
Authenticator auth = Authenticator.Instance;
auth.Authenticate(authUrl, clientId, clientSecret);
//Get endpoints by provider
foreach (Endpoint e in auth.GetEndpoints(providerId))
{
XPress xPress = new XPress(e.href);
//Staff
//xPress.CreateXStaffUsers(SCHOOL_REFID);
//xPress.DeleteXStaffUsers(SCHOOL_REFID);
//xPress.DeleteXStaffUsernamesPasswords(SCHOOL_REFID);
//XStaffs_GetXStaffsAccounts(xPress);
//Student
//xPress.CreateXStudentUsers(SCHOOL_REFID);
//xPress.DeleteXStudentUsers(SCHOOL_REFID);
//xPress.DeleteXStudentUsernamesPasswords(SCHOOL_REFID);
//XStudents_GetXStudentsAccounts(xPress);
Console.Read();
}
}
protected virtual void AuthenticateIfNeeded(IRestRequest request)
{
if (Authenticator != null)
{
Authenticator.Authenticate(request);
}
}
/// <summary>
/// Analyze customer-engagement tone.
///
/// Use the customer-engagement endpoint to analyze the tone of customer service and customer support
/// conversations. For each utterance of a conversation, the method reports the most prevalent subset of the
/// following seven tones: sad, frustrated, satisfied, excited, polite, impolite, and sympathetic.
///
/// If you submit more than 50 utterances, the service returns a warning for the overall content and analyzes
/// only the first 50 utterances. If you submit a single utterance that contains more than 500 characters, the
/// service returns an error for that utterance and does not analyze the utterance. The request fails if all
/// utterances have more than 500 characters. Per the JSON specification, the default character encoding for
/// JSON content is effectively always UTF-8.
///
/// **See also:** [Using the customer-engagement
/// endpoint](https://cloud.ibm.com/docs/tone-analyzer?topic=tone-analyzer-utco#utco).
/// </summary>
/// <param name="callback">The callback function that is invoked when the operation completes.</param>
/// <param name="utterances">An array of `Utterance` objects that provides the input content that the service is
/// to analyze.</param>
/// <param name="contentLanguage">The language of the input text for the request: English or French. Regional
/// variants are treated as their parent language; for example, `en-US` is interpreted as `en`. The input
/// content must match the specified language. Do not submit content that contains both languages. You can use
/// different languages for **Content-Language** and **Accept-Language**.
/// * **`2017-09-21`:** Accepts `en` or `fr`.
/// * **`2016-05-19`:** Accepts only `en`. (optional, default to en)</param>
/// <param name="acceptLanguage">The desired language of the response. For two-character arguments, regional
/// variants are treated as their parent language; for example, `en-US` is interpreted as `en`. You can use
/// different languages for **Content-Language** and **Accept-Language**. (optional, default to en)</param>
/// <returns><see cref="UtteranceAnalyses" />UtteranceAnalyses</returns>
public bool ToneChat(Callback <UtteranceAnalyses> callback, List <Utterance> utterances, string contentLanguage = null, string acceptLanguage = null)
{
if (callback == null)
{
throw new ArgumentNullException("`callback` is required for `ToneChat`");
}
if (utterances == null)
{
throw new ArgumentNullException("`utterances` is required for `ToneChat`");
}
RequestObject <UtteranceAnalyses> req = new RequestObject <UtteranceAnalyses>
{
Callback = callback,
HttpMethod = UnityWebRequest.kHttpVerbPOST,
DisableSslVerification = DisableSslVerification
};
foreach (KeyValuePair <string, string> kvp in customRequestHeaders)
{
req.Headers.Add(kvp.Key, kvp.Value);
}
ClearCustomRequestHeaders();
foreach (KeyValuePair <string, string> kvp in Common.GetSdkHeaders("tone_analyzer", "V3", "ToneChat"))
{
req.Headers.Add(kvp.Key, kvp.Value);
}
req.Parameters["version"] = VersionDate;
req.Headers["Content-Type"] = "application/json";
req.Headers["Accept"] = "application/json";
if (!string.IsNullOrEmpty(contentLanguage))
{
req.Headers["Content-Language"] = contentLanguage;
}
if (!string.IsNullOrEmpty(acceptLanguage))
{
req.Headers["Accept-Language"] = acceptLanguage;
}
JObject bodyObject = new JObject();
if (utterances != null && utterances.Count > 0)
{
bodyObject["utterances"] = JToken.FromObject(utterances);
}
req.Send = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(bodyObject));
req.OnResponse = OnToneChatResponse;
Connector.URL = GetServiceUrl() + "/v3/tone_chat";
Authenticator.Authenticate(Connector);
return(Connector.Send(req));
}
public ActionResult Login(string username, string password, string captcha)
{
if (String.IsNullOrEmpty(username) || String.IsNullOrEmpty(password))
{
return(View("Index"));
}
ViewBag.Username = username;
// check possible brute-force attacks
int failedtries = 1;
if (HttpContext.Session.GetInt32(FAILED_ATTEMPTS).HasValue)
{
failedtries = HttpContext.Session.GetInt32(FAILED_ATTEMPTS).Value;
}
else
{
HttpContext.Session.SetInt32(FAILED_ATTEMPTS, 0);
}
if (failedtries >= 2)
{
if (Authenticator.CheckCaptcha(captcha))
{
if (Authenticator.Authenticate(username, password))
{
HttpContext.Session.SetInt32(FAILED_ATTEMPTS, 0);
return(View("Success"));
}
else
{
ViewBag.ShowCaptcha = true;
ViewBag.Result = "Username or password is wrong, please enter again!";
}
}
else
{
ViewBag.ShowCaptcha = true;
ViewBag.Result = "Please enter correct CAPTCHA!";
}
}
else
{
if (Authenticator.Authenticate(username, password))
{
HttpContext.Session.SetInt32(FAILED_ATTEMPTS, 0);
return(View("Success"));
}
else
{
failedtries = HttpContext.Session.GetInt32(FAILED_ATTEMPTS).Value;
HttpContext.Session.SetInt32(FAILED_ATTEMPTS, ++failedtries);
ViewBag.Result = "Username or password is wrong, please enter again!";
}
}
return(View("Index"));
}
/// <summary>
/// Update a classifier.
///
/// Update a custom classifier by adding new positive or negative classes or by adding new images to existing
/// classes. You must supply at least one set of positive or negative examples. For details, see [Updating
/// custom
/// classifiers](https://cloud.ibm.com/docs/visual-recognition?topic=visual-recognition-customizing#updating-custom-classifiers).
///
/// Encode all names in UTF-8 if they contain non-ASCII characters (.zip and image file names, and classifier
/// and class names). The service assumes UTF-8 encoding if it encounters non-ASCII characters.
///
/// **Tips about retraining:**
///
/// - You can't update the classifier if the **X-Watson-Learning-Opt-Out** header parameter was set to `true`
/// when the classifier was created. Training images are not stored in that case. Instead, create another
/// classifier. For more information, see [Data collection](#data-collection).
///
/// - Don't make retraining calls on a classifier until the status is ready. When you submit retraining requests
/// in parallel, the last request overwrites the previous requests. The `retrained` property shows the last time
/// the classifier retraining finished.
/// </summary>
/// <param name="callback">The callback function that is invoked when the operation completes.</param>
/// <param name="classifierId">The ID of the classifier.</param>
/// <param name="positiveExamples">A dictionary that contains the value for each classname. The value is a .zip
/// file of images that depict the visual subject of a class in the classifier. The positive examples create or
/// update classes in the classifier. You can include more than one positive example file in a call.
///
/// Specify the parameter name by appending `_positive_examples` to the class name. For example,
/// `goldenretriever_positive_examples` creates the class `goldenretriever`. The string cannot contain the
/// following characters: ``$ * - { } \ | / ' " ` [ ]``.
///
/// Include at least 10 images in .jpg or .png format. The minimum recommended image resolution is 32X32 pixels.
/// The maximum number of images is 10,000 images or 100 MB per .zip file.
///
/// Encode special characters in the file name in UTF-8. (optional)</param>
/// <param name="negativeExamples">A .zip file of images that do not depict the visual subject of any of the
/// classes of the new classifier. Must contain a minimum of 10 images.
///
/// Encode special characters in the file name in UTF-8. (optional)</param>
/// <param name="negativeExamplesFilename">The filename for negativeExamples. (optional)</param>
/// <returns><see cref="Classifier" />Classifier</returns>
public bool UpdateClassifier(Callback <Classifier> callback, string classifierId, Dictionary <string, System.IO.MemoryStream> positiveExamples = null, System.IO.MemoryStream negativeExamples = null, string negativeExamplesFilename = null)
{
if (callback == null)
{
throw new ArgumentNullException("`callback` is required for `UpdateClassifier`");
}
if (string.IsNullOrEmpty(Version))
{
throw new ArgumentNullException("`Version` is required");
}
if (string.IsNullOrEmpty(classifierId))
{
throw new ArgumentNullException("`classifierId` is required for `UpdateClassifier`");
}
RequestObject <Classifier> req = new RequestObject <Classifier>
{
Callback = callback,
HttpMethod = UnityWebRequest.kHttpVerbPOST,
DisableSslVerification = DisableSslVerification
};
foreach (KeyValuePair <string, string> kvp in customRequestHeaders)
{
req.Headers.Add(kvp.Key, kvp.Value);
}
ClearCustomRequestHeaders();
foreach (KeyValuePair <string, string> kvp in Common.GetSdkHeaders("watson_vision_combined", "V3", "UpdateClassifier"))
{
req.Headers.Add(kvp.Key, kvp.Value);
}
req.Forms = new Dictionary <string, RESTConnector.Form>();
if (positiveExamples != null && positiveExamples.Count > 0)
{
foreach (KeyValuePair <string, System.IO.MemoryStream> entry in positiveExamples)
{
var partName = string.Format("{0}_positive_examples", entry.Key);
req.Forms[partName] = new RESTConnector.Form(entry.Value, entry.Key + ".zip", "application/octet-stream");
}
}
if (negativeExamples != null)
{
req.Forms["negative_examples"] = new RESTConnector.Form(negativeExamples, negativeExamplesFilename, "application/octet-stream");
}
if (!string.IsNullOrEmpty(Version))
{
req.Parameters["version"] = Version;
}
req.OnResponse = OnUpdateClassifierResponse;
Connector.URL = GetServiceUrl() + string.Format("/v3/classifiers/{0}", classifierId);
Authenticator.Authenticate(Connector);
return(Connector.Send(req));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req,
[StorageAccount("StorageConnectionString")] CloudStorageAccount storageAccount,
TraceWriter log
)
{
var client = storageAccount.CreateCloudTableClient();
string partitionKey = await Authenticator.Authenticate(client, req);
if (string.IsNullOrEmpty(partitionKey))
{
return(new UnauthorizedResult());
}
string json = await req.ReadAsStringAsync();
var items = JsonConvert.DeserializeObject <List <ItemJson> >(json);
if (items == null)
{
return(new BadRequestObjectResult("Could not correctly parse the request parameters"));
}
else if (items.Count > 100)
{
return(new BadRequestObjectResult("Too many items to store, maximum 100 per call"));
}
else if (items.Count <= 0)
{
return(new BadRequestObjectResult("No items to store"));
}
var partition = await PartionUtility.GetUploadPartitionV2(log, client, partitionKey);
log.Info($"Received a request from {partitionKey} to upload {items.Count} items to {partition.RowKey}");
var itemTable = client.GetTableReference(ItemV2.TableName);
await itemTable.CreateIfNotExistsAsync();
var itemMapping = await Insert(partitionKey, partition.RowKey, itemTable, items);
log.Info($"Inserted {items.Count} items over {itemMapping.Count} batches");
bool shouldClosePartition = items.Count >= 90;
if (shouldClosePartition)
{
log.Info($"Closing partition {partition.PartitionKey}, due to received count at {items.Count}");
partition.IsActive = false;
await client.GetTableReference(PartitionV2.TableName).ExecuteAsync(TableOperation.Replace(partition));
}
var result = new UploadResultDto {
Partition = itemMapping.First().Partition,
IsClosed = shouldClosePartition,
Items = itemMapping
};
return(new OkObjectResult(result));
}
public ValidationResult Validate(HttpRequest req)
{
var result = _auth.Authenticate(new JwtBearerToken(req).Token);
return(result.Item1 == Token.Verified
? ValidationResult.Valid
: new ValidationResult(result.Item1.ToString()));
}
public void Test_AuthenticateReturnsNoUserWhenEmptyListOfUsers()
{
Authenticator authenticator = new Authenticator(new List <User>());
User authenticatedUser = authenticator.Authenticate("test", "test");
Assert.Null(authenticatedUser);
}
public void Setup()
{
var driveAuthenticator = new Authenticator();
driveAuthenticator.Authenticate("test");
this.googleDriveServiceProvider = new GoogleDriveServiceProvider(driveAuthenticator);
this.testee = new FileDownloader(this.googleDriveServiceProvider);
}
public void Authenticate_ExistingUser_UserHasAuthenticated()
{
var ar = new Authenticator(new StubService());
string result = ar.Authenticate("User1", "p1");
Assert.IsNotNullOrEmpty(result, "Empty string response after authentication method.");
Console.WriteLine(result);
}
private RestRequest CreateRequest(Method method)
{
Authenticator.Authenticate();
RestRequest request = new RestRequest(method);
request.AddHeader("Authorization", "Bearer " + AccessToken);
return(request);
}
public void Test_SearchingForAUserNotInTheListReturnsNull()
{
Authenticator authenticator = new Authenticator(new List <User>());
User result = authenticator.Authenticate("Test", "Test");
Assert.IsNull(result);
}
public void Test_AuthenticateUserNotFound()
{
var users = createUsersList();
var authenticator = new Authenticator(users);
var user = authenticator.Authenticate("Sara", "password");
Assert.Null(user);
}
public void Test_AuthenticateInvalidPassword()
{
var users = createUsersList();
var authenticator = new Authenticator(users);
var user = authenticator.Authenticate("Jane", "password");
Assert.Null(user);
}
public void Test_AuthenticateNullUsername()
{
var users = createUsersList();
var authenticator = new Authenticator(users);
var user = authenticator.Authenticate(null, "password");
Assert.Null(user);
}
public void Setup()
{
var authenticator = new Authenticator();
authenticator.Authenticate("test");
var serviceProvider = new GoogleDriveServiceProvider(authenticator);
this.testee = new FolderSynchronizer(new FilesGetter(serviceProvider), new FileDownloader(serviceProvider));
}
public void Test_AuthenticateWithEmptyUserList()
{
List <User> users = new List <User>();
Authenticator authenticator = new Authenticator(users);
User authenticatedUser = authenticator.Authenticate("User Test", "");
Assert.AreNotEqual(authenticatedUser, "User Test", "");
}
public void Test_AuthenticateNullUser()
{
User user = createTestUser("Test User", "", 100);
Authenticator authenticator = CreateAuthenticator(user);
User authenticatedUser = authenticator.Authenticate(null, null);
Assert.AreNotEqual(authenticatedUser, user);
}
public void Test_AuthenticateEmptyStringUser()
{
User user = createTestUser("Test User", "", 100);
Authenticator authenticator = CreateAuthenticator(user);
User authenticatedUser = authenticator.Authenticate("", "");
Assert.AreNotEqual(authenticatedUser, user);
}
public void Test_AuthenticateUserThatDoesNotExist()
{
User user = createTestUser("Test User", "", 100);
Authenticator authenticator = CreateAuthenticator(user);
User authenticatedUser = authenticator.Authenticate("User", "");
Assert.AreNotEqual(authenticatedUser, user);
}
/// <summary>
/// Send user input to assistant (stateful).
///
/// Send user input to an assistant and receive a response, with conversation state (including context data)
/// stored by Watson Assistant for the duration of the session.
///
/// There is no rate limit for this operation.
/// </summary>
/// <param name="callback">The callback function that is invoked when the operation completes.</param>
/// <param name="assistantId">Unique identifier of the assistant. To find the assistant ID in the Watson
/// Assistant user interface, open the assistant settings and click **API Details**. For information about
/// creating assistants, see the
/// [documentation](https://cloud.ibm.com/docs/assistant?topic=assistant-assistant-add#assistant-add-task).
///
/// **Note:** Currently, the v2 API does not support creating assistants.</param>
/// <param name="sessionId">Unique identifier of the session.</param>
/// <param name="input">An input object that includes the input text. (optional)</param>
/// <param name="context">Context data for the conversation. You can use this property to set or modify context
/// variables, which can also be accessed by dialog nodes. The context is stored by the assistant on a
/// per-session basis.
///
/// **Note:** The total size of the context data stored for a stateful session cannot exceed 100KB.
/// (optional)</param>
/// <returns><see cref="MessageResponse" />MessageResponse</returns>
public bool Message(Callback <MessageResponse> callback, string assistantId, string sessionId, MessageInput input = null, MessageContext context = null)
{
if (callback == null)
{
throw new ArgumentNullException("`callback` is required for `Message`");
}
if (string.IsNullOrEmpty(assistantId))
{
throw new ArgumentNullException("`assistantId` is required for `Message`");
}
if (string.IsNullOrEmpty(sessionId))
{
throw new ArgumentNullException("`sessionId` is required for `Message`");
}
RequestObject <MessageResponse> req = new RequestObject <MessageResponse>
{
Callback = callback,
HttpMethod = UnityWebRequest.kHttpVerbPOST,
DisableSslVerification = DisableSslVerification
};
foreach (KeyValuePair <string, string> kvp in customRequestHeaders)
{
req.Headers.Add(kvp.Key, kvp.Value);
}
ClearCustomRequestHeaders();
foreach (KeyValuePair <string, string> kvp in Common.GetSdkHeaders("conversation", "V2", "Message"))
{
req.Headers.Add(kvp.Key, kvp.Value);
}
req.Parameters["version"] = VersionDate;
req.Headers["Content-Type"] = "application/json";
req.Headers["Accept"] = "application/json";
JObject bodyObject = new JObject();
if (input != null)
{
bodyObject["input"] = JToken.FromObject(input);
}
if (context != null)
{
bodyObject["context"] = JToken.FromObject(context);
}
req.Send = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(bodyObject));
req.OnResponse = OnMessageResponse;
Connector.URL = GetServiceUrl() + string.Format("/v2/assistants/{0}/sessions/{1}/message", assistantId, sessionId);
Authenticator.Authenticate(Connector);
return(Connector.Send(req));
}
/// <summary>
/// Classify images.
///
/// Classify images with built-in or custom classifiers.
/// </summary>
/// <param name="callback">The callback function that is invoked when the operation completes.</param>
/// <param name="imagesFile">An image file (.gif, .jpg, .png, .tif) or .zip file with images. Maximum image size
/// is 10 MB. Include no more than 20 images and limit the .zip file to 100 MB. Encode the image and .zip file
/// names in UTF-8 if they contain non-ASCII characters. The service assumes UTF-8 encoding if it encounters
/// non-ASCII characters.
///
/// You can also include an image with the **url** parameter. (optional)</param>
/// <param name="imagesFilename">The filename for imagesFile. (optional)</param>
/// <param name="imagesFileContentType">The content type of imagesFile. (optional)</param>
/// <param name="url">The URL of an image (.gif, .jpg, .png, .tif) to analyze. The minimum recommended pixel
/// density is 32X32 pixels, but the service tends to perform better with images that are at least 224 x 224
/// pixels. The maximum image size is 10 MB.
///
/// You can also include images with the **images_file** parameter. (optional)</param>
/// <param name="threshold">The minimum score a class must have to be displayed in the response. Set the
/// threshold to `0.0` to return all identified classes. (optional)</param>
/// <param name="owners">The categories of classifiers to apply. The **classifier_ids** parameter overrides
/// **owners**, so make sure that **classifier_ids** is empty.
/// - Use `IBM` to classify against the `default` general classifier. You get the same result if both
/// **classifier_ids** and **owners** parameters are empty.
/// - Use `me` to classify against all your custom classifiers. However, for better performance use
/// **classifier_ids** to specify the specific custom classifiers to apply.
/// - Use both `IBM` and `me` to analyze the image against both classifier categories. (optional)</param>
/// <param name="classifierIds">Which classifiers to apply. Overrides the **owners** parameter. You can specify
/// both custom and built-in classifier IDs. The built-in `default` classifier is used if both
/// **classifier_ids** and **owners** parameters are empty.
///
/// The following built-in classifier IDs require no training:
/// - `default`: Returns classes from thousands of general tags.
/// - `food`: Enhances specificity and accuracy for images of food items.
/// - `explicit`: Evaluates whether the image might be pornographic. (optional)</param>
/// <param name="acceptLanguage">The desired language of parts of the response. See the response for details.
/// (optional, default to en)</param>
/// <returns><see cref="ClassifiedImages" />ClassifiedImages</returns>
public bool Classify(Callback <ClassifiedImages> callback, System.IO.MemoryStream imagesFile = null, string imagesFilename = null, string imagesFileContentType = null, string url = null, float?threshold = null, List <string> owners = null, List <string> classifierIds = null, string acceptLanguage = null)
{
if (callback == null)
{
throw new ArgumentNullException("`callback` is required for `Classify`");
}
RequestObject <ClassifiedImages> req = new RequestObject <ClassifiedImages>
{
Callback = callback,
HttpMethod = UnityWebRequest.kHttpVerbPOST,
DisableSslVerification = DisableSslVerification
};
foreach (KeyValuePair <string, string> kvp in customRequestHeaders)
{
req.Headers.Add(kvp.Key, kvp.Value);
}
ClearCustomRequestHeaders();
foreach (KeyValuePair <string, string> kvp in Common.GetSdkHeaders("watson_vision_combined", "V3", "Classify"))
{
req.Headers.Add(kvp.Key, kvp.Value);
}
req.Parameters["version"] = VersionDate;
req.Forms = new Dictionary <string, RESTConnector.Form>();
if (imagesFile != null)
{
req.Forms["images_file"] = new RESTConnector.Form(imagesFile, imagesFilename, imagesFileContentType);
}
if (!string.IsNullOrEmpty(url))
{
req.Forms["url"] = new RESTConnector.Form(url);
}
if (threshold != null)
{
req.Forms["threshold"] = new RESTConnector.Form(threshold.ToString());
}
if (owners != null && owners.Count > 0)
{
req.Forms["owners"] = new RESTConnector.Form(string.Join(", ", owners.ToArray()));
}
if (classifierIds != null && classifierIds.Count > 0)
{
req.Forms["classifier_ids"] = new RESTConnector.Form(string.Join(", ", classifierIds.ToArray()));
}
req.OnResponse = OnClassifyResponse;
Connector.URL = GetServiceUrl() + "/v3/classify";
Authenticator.Authenticate(Connector);
return(Connector.Send(req));
}
public async Task Authenticate_WhereDownstreamResultEmpty_ReturnsFalse()
{
// arrange
var proxy = new AuthenticatorProxyWithResult("");
authenticator = new Authenticator(proxy);
// act
var result = await authenticator.Authenticate("url");
Assert.IsFalse(result.IsSuccess);
}
public async Task Authenticate_WhereDownstreamResultOccurs_ReturnsSuccess()
{
// arrange
var proxy = new AuthenticatorProxyWithResult("foo");
authenticator = new Authenticator(proxy);
// act
var result = await authenticator.Authenticate("url");
Assert.IsTrue(result.IsSuccess);
}
public void Synchronize_WhenFolderIsSynchronize_ThenStructureIsCorrect()
{
// Arrange
var authenticator = new Authenticator();
authenticator.Authenticate("test");
var filesGetter = new FilesGetter(new GoogleDriveServiceProvider(authenticator));
var files = filesGetter.GetDriveFiles(GoogleDriveConstants.FolderMimeType).ToList();
// Act
string rootFolder = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + "\\TestGoogle";
this.testee.SynchronizeFolder(
files[1],
rootFolder);
// Assert
Directory.Exists(rootFolder).Should().BeTrue();
Directory.GetDirectories(rootFolder).Length.Should().Be(1);
}
public void Setup()
{
Authenticator driveAuthenticator = new Authenticator();
driveAuthenticator.Authenticate("test");
this.testee = new FilesGetter(new GoogleDriveServiceProvider(driveAuthenticator));
}
public async Task Authenticate_WhereDownstreamResultOccurs_ReturnsToken()
{
// arrange
var proxy = new AuthenticatorProxyWithResult("foo");
authenticator = new Authenticator(proxy);
// act
var result = await authenticator.Authenticate("url");
Assert.AreEqual("foo", result.AccessToken);
}
protected override void InnerRun()
{
Succeeded = false;
PendingUserActivation = true;
ShouldRetry = true;
DoxApi api = new DoxApi(_serviceUrl);
IDoxSession session = null;
if (!string.IsNullOrEmpty(DeviceToken))
{
session = api.CreateSessionFromDeviceToken(_loginName, DeviceToken, ApiHelper);
if (session == null && api.Error.IsConnectionError())
{
PendingUserActivation = false;
ErrorMessage = Properties.Resources.ConnectionErrorDuringUpload;
return;
}
}
if (session == null)
{
// show login dialog
var nativeWindow = new NativeWindow();
nativeWindow.AssignHandle(IntPtr.Zero);
_loginUi.NativeWindow = nativeWindow;
_loginUi.RegisterTabVisible = false;
_loginUi.LoginFieldEnabled = false;
var authenticator = new Authenticator(_loginUi);
authenticator.Api = api;
authenticator.ApiHelper = ApiHelper;
bool cancelSend;
session = authenticator.Authenticate(_loginName, null, out cancelSend);
if (cancelSend)
{
ShouldRetry = false;
PendingUserActivation = false;
Logger.LogInfo("User cancelled send");
ErrorMessage = "Unable to log in.";
return;
}
}
if (session == null)
{
return; // something weird is happening, try again later
}
DeviceToken = session.Credentials.DeviceToken;
OptionApi.SetEncrypted("SendLinkDeviceToken", DeviceToken, _entropy);
OptionApi.SetEncrypted("SendLinkAccountId", session.CurrentUser.AccountId, _entropy);
OptionApi.SetEncrypted("SendLinkUserId", session.CurrentUser.Id, _entropy);
if (session.CurrentUser.IsValidated)
{
PendingUserActivation = false;
Succeeded = true;
ErrorMessage = string.Empty;
}
}