public App()
{
APIConnector = new APIConnector();
User = new User();
InitializeComponent();
}
public bool SendE2ETextMessage(ThreemaE2ETextMessage threemaE2ETextMessage)
{
try
{
try
{
_log.LogDebug("ThreemaController.SendE2ETextMessage: ModelState {0}, ThreemaE2ETextMessage {1}", ModelState.IsValid, threemaE2ETextMessage.ToString());
}
catch (Exception ex)
{
_log.LogError("ThreemaController.SendE2ETextMessage 1 " + ex.Message);
}
string myPrivateKey = this._configuration["Threema:PrivateKey"];
string myThreemaId = this._configuration["Threema:ThreemaId"];
string mySecret = this._configuration["Threema:Secret"];
APIConnector apiConnector = new APIConnector(myThreemaId, mySecret, null);
string text = DataUtils.Utf8Endcode(threemaE2ETextMessage.Text.Trim());
Key privateKey = Key.DecodeKey(myPrivateKey);
E2EHelper e2EHelper = new E2EHelper(apiConnector, privateKey.key);
String messageId = e2EHelper.SendTextMessage(threemaE2ETextMessage.To, text);
_log.LogDebug("ThreemaController.SendE2ETextMessage: messege sendet to {0}", threemaE2ETextMessage.To);
return(true);
}
catch (Exception ex)
{
_log.LogError("ThreemaController.SendE2ETextMessage 2 " + ex.Message);
return(false);
}
}
public ServiceResult Get()
{
string url = _configuration.GetSection("Bank").GetSection("URL").Value;
APIConnector connector = new APIConnector(_configuration);
ServiceResult result = connector.GetObjectFromRemote();
return(result);
}
private async Task CleanupUnitTest()
{
TestStatusMsg("Cleaning up test...");
string basepath = txtFolderPath.Text;
if (basepath.EndsWith("/"))
{
basepath.TrimEnd(new char[] { '/' });
}
string tfoldername = basepath + "/Cloud Elements API Test Folder";
//check for file on disk
string fn = System.IO.Path.Combine(WorkPath, "SFCE_test_file_1.txt");
if (System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(fn)))
{
if (System.IO.File.Exists(fn))
{
try
{
System.IO.File.Delete(fn);
TestStatusMsg("Downloaded test file deleted");
}
catch (System.IO.IOException ix)
{
TestStatusMsg("Downloaded test file NOT deleted - " + ix.Message);
}
}
}
//check for folder
try
{
List <Cloud_Elements_API.CloudFile> fe = await APIConnector.ListFolderContents(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, tfoldername, chkWithTags.Checked);
//if exists, delete
try
{
bool Result = await APIConnector.DeleteFolder(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, tfoldername, false);
TestStatusMsg("Test folder deleted");
}
catch (Exception e)
{
TestStatusMsg("Delete Folder failed: " + e.Message);
throw e;
}
}
catch (System.Net.Http.HttpRequestException e)
{
TestStatusMsg("Nothing to clean: " + e.Message);
}
TestStatusMsg("Test cleanup complete");
}
void Start()
{
Screen.orientation = ScreenOrientation.Portrait;
//Make Connectivity Check
apiConnector = new APIConnector(this);
string jsonToSend = @"{'email':'" + "null" + "', 'password':'******'}";
apiConnector.makeRequest(CheckConnectivity, "test", jsonToSend);
}
/// <summary>
/// Wrapper to lookup/fetch public key <see cref="Threema.MsgApi.APIConnector.LookupKey"/>
/// </summary>
/// <param name="threemaId">Id for lookup</param>
/// <param name="from">Sender id</param>
/// <param name="secret">Sender secret</param>
/// <param name="apiUrl">Optional api url</param>
/// <returns>public key has hex-string</returns>
public string LookupKey(string threemaId, string from, string secret, string apiUrl = APIConnector.DEFAULTAPIURL)
{
APIConnector apiConnector = this.CreateConnector(from, secret, apiUrl);
byte[] publicKey = apiConnector.LookupKey(threemaId);
if (publicKey != null)
{
return(new Key(Key.KeyType.PUBLIC, publicKey).Encode());
}
return(null);
}
public async System.Threading.Tasks.Task GetEmptyUsernameTest()
{
APIConnector Connector = new APIConnector();
APIDataGrabber Grabber = new APIDataGrabber(); // download data from API
User EmptyUser = new User("");
await Connector.ConnectWithAPI();
Connector.GiveSpotifyAccessFor(Grabber);
Grabber.UploadUserData(EmptyUser);
Assert.IsNull(EmptyUser.Name);
}
protected override void Execute()
{
string threemaId = this.threemaIdField.Value;
string from = this.fromField.Value;
string secret = this.secretField.Value;
APIConnector apiConnector = this.CreateConnector(from, secret);
byte[] publicKey = apiConnector.LookupKey(threemaId);
if (publicKey != null)
{
System.Console.WriteLine(new Key(Key.KeyType.PUBLIC, publicKey).Encode());
}
}
protected override void Execute()
{
string phoneNo = this.phoneNoField.Value;
string from = this.fromField.Value;
string secret = this.secretField.Value;
APIConnector apiConnector = this.CreateConnector(from, secret);
string id = apiConnector.LookupPhone(phoneNo);
if (id != null)
{
System.Console.WriteLine(id);
}
}
protected override void Execute()
{
string to = this.threemaId.Value;
string from = this.fromField.Value;
string secret = this.secretField.Value;
//string text = ReadStream(System.Console.In, Encoding.UTF8).Trim();
string text = DataUtils.Utf8Endcode(System.Console.ReadLine().Trim());
APIConnector apiConnector = this.CreateConnector(from, secret);
string messageId = apiConnector.SendTextMessageSimple(to, text);
System.Console.WriteLine(messageId);
}
public async System.Threading.Tasks.Task GetPlaylistsImagesURLTest()
{
APIConnector Connector = new APIConnector();
APIDataGrabber Grabber = new APIDataGrabber(); // download data from API
User User = new User("213pado37eomvngbs4vac5qra"); // Paweł Tomaszewski
await Connector.ConnectWithAPI();
Connector.GiveSpotifyAccessFor(Grabber);
Grabber.UploadUserData(User);
string expectedURL = "https://i.scdn.co/image/2654511f372969510abf52e52fee458ceeb15bed";
Assert.AreEqual(expectedURL, User.Playlists[1].ImageURL);
}
public async System.Threading.Tasks.Task GetPlaylistsNamesTest()
{
APIConnector Connector = new APIConnector();
APIDataGrabber Grabber = new APIDataGrabber(); // download data from API
User User = new User("213pado37eomvngbs4vac5qra"); // Paweł Tomaszewski
await Connector.ConnectWithAPI();
Connector.GiveSpotifyAccessFor(Grabber);
Grabber.UploadUserData(User);
string expectedPlaylistName = "Music";
Assert.AreEqual(expectedPlaylistName, User.Playlists[1].Name);
}
public async System.Threading.Tasks.Task GetCorrectUsernameTest()
{
APIConnector Connector = new APIConnector();
APIDataGrabber Grabber = new APIDataGrabber(); // download data from API
User User = new User("213pado37eomvngbs4vac5qra"); // Paweł Tomaszewski
await Connector.ConnectWithAPI();
Connector.GiveSpotifyAccessFor(Grabber);
Grabber.UploadUserData(User);
Assert.IsNotNull(User.Name);
string expected = "Paweł Tomaszewski";
Assert.AreEqual(expected, User.Name);
}
private string GetPublicKey(string threemaId)
{
string myThreemaId = this._configuration["Threema:ThreemaId"];
string mySecret = this._configuration["Threema:Secret"];
APIConnector apiConnector = new APIConnector(myThreemaId, mySecret, null);
byte[] publicKey = apiConnector.LookupKey(threemaId);
if (publicKey != null)
{
string publicKeyEncoded = new Key(Key.KeyType.PUBLIC, publicKey).Encode();
return(publicKeyEncoded);
}
else
{
throw new Exception(String.Format("public key for {0} not found", threemaId));
}
}
public async Task RetryHandler_CanRetry()
{
var apiResponse = new Mock <IAPIResponse <string> >();
apiResponse.SetupGet(a => a.Body).Returns("Hello World");
var response = new Mock <IResponse>();
response.SetupGet(r => r.ContentType).Returns("application/json");
response.SetupGet(r => r.StatusCode).Returns(HttpStatusCode.OK);
response.SetupGet(r => r.Body).Returns("\"Hello World\"");
var authenticator = new Mock <IAuthenticator>();
var serializer = new Mock <IJSONSerializer>();
serializer.Setup(s => s.DeserializeResponse <string>(It.IsAny <IResponse>())).Returns(apiResponse.Object);
var httpClient = new Mock <IHTTPClient>();
httpClient.Setup(h => h.DoRequest(It.IsAny <IRequest>())).Returns(Task.FromResult(response.Object));
var retryHandler = new Mock <IRetryHandler>();
retryHandler.Setup(r =>
r.HandleRetry(
It.IsAny <IRequest>(),
It.IsAny <IResponse>(),
It.IsAny <IRetryHandler.RetryFunc>()
)
).Returns((IRequest request, IResponse _, IRetryHandler.RetryFunc retry) => retry(request));
var apiConnector = new APIConnector(
new Uri("https://spotify.com"),
authenticator.Object,
serializer.Object,
httpClient.Object,
retryHandler.Object,
null
);
await apiConnector.SendAPIRequest <string>(new Uri("/me", UriKind.Relative), HttpMethod.Get).ConfigureAwait(false);
serializer.Verify(s => s.SerializeRequest(It.IsAny <IRequest>()), Times.Once);
authenticator.Verify(a => a.Apply(It.IsAny <IRequest>(), It.IsAny <IAPIConnector>()), Times.Exactly(2));
httpClient.Verify(h => h.DoRequest(It.IsAny <IRequest>()), Times.Exactly(2));
serializer.Verify(s => s.DeserializeResponse <string>(response.Object), Times.Once);
}
public IActionResult Index()
{
string myThreemaId = this._configuration["Threema:ThreemaId"];
string mySecret = this._configuration["Threema:Secret"];
APIConnector apiConnector = new APIConnector(myThreemaId, mySecret, null);
CreditsViewModel creditsViewModel;
try
{
creditsViewModel = new CreditsViewModel()
{
Credits = apiConnector.LookupCredits()
};
}
catch (Exception ex)
{
creditsViewModel = new CreditsViewModel()
{
ErrorMessage = ex.Message
};
}
return(View(creditsViewModel));
}
protected void ClearToken()
{
APIConnector.ClearAuthHeader();
}
async Task <string> TestAsyncGetFileMeta()
{
string tfoldername = AsyncBasePath; // as set at start of tests
System.Collections.Generic.Queue <Task <Cloud_Elements_API.CloudFile> > MetaTasks = new System.Collections.Generic.Queue <Task <Cloud_Elements_API.CloudFile> >();
System.Collections.Generic.List <Cloud_Elements_API.CloudElementsConnector> ConnectorsUsed = new System.Collections.Generic.List <Cloud_Elements_API.CloudElementsConnector>();
DateTime Started = DateTime.Now;
int MetaCount = 0;
for (int rr = 1; rr <= 4; rr++)
{
for (int i = 1; i <= 16; i++)
{
string TargetPath = tfoldername + string.Format("/SFCE_test_file_{0}.txt", i);
Cloud_Elements_API.CloudElementsConnector ViaConnector = null;
ViaConnector = APIConnector.Clone();
Task <Cloud_Elements_API.CloudFile> OneMeta = Cloud_Elements_API.FileOperations.GetCloudFileInfo(ViaConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, TargetPath);
ConnectorsUsed.Add(ViaConnector);
MetaTasks.Enqueue(OneMeta);
if (SerializeGetFileMetadataRequests)
{
OneMeta.Wait();
}
MetaCount += 1;
}
}
int rewaitCnt = 0;
System.Text.StringBuilder Summary = new System.Text.StringBuilder();
while (MetaTasks.Count > 0)
{
Task <Cloud_Elements_API.CloudFile> AnUpload = MetaTasks.Dequeue();
if (AnUpload.GetAwaiter().IsCompleted)
{
try
{
Cloud_Elements_API.CloudFile Result = await AnUpload;
if (Result != null)
{
Summary.AppendFormat("\t{5}: Task {2} File Info for {0}, id={1}, ok={3} \r\n", Result.name, Result.id, AnUpload.Id, !AnUpload.IsFaulted,
0, Cloud_Elements_API.Tools.TraceTimeNow());
}
else
{
Summary.AppendFormat("\t{5}: Task {2} did not obtain file Info for {0}, id={1}, ok={3} \r\n", "", "", AnUpload.Id, !AnUpload.IsFaulted,
0, Cloud_Elements_API.Tools.TraceTimeNow());
}
}
catch (Exception ex)
{
Summary.AppendFormat("\t{5}: Task {2} File Info Exception {0}, ok={3} \r\n", ex.Message, 0, AnUpload.Id, !AnUpload.IsFaulted,
0, Cloud_Elements_API.Tools.TraceTimeNow());
}
}
else
{
// if (AnUpload.Status == TaskStatus.WaitingForActivation) AnUpload.ci
MetaTasks.Enqueue(AnUpload);
rewaitCnt += 1;
System.Threading.Thread.Sleep(128);
}
}
foreach (Cloud_Elements_API.CloudElementsConnector ViaConnector in ConnectorsUsed)
{
ViaConnector.Close();
}
ConnectorsUsed.Clear();
Summary.AppendFormat("\t{0}: Finished \r\n", Cloud_Elements_API.Tools.TraceTimeNow());
double RequiredMS = DateTime.Now.Subtract(Started).TotalMilliseconds;
Summary.Insert(0, string.Format("Got {0} file infos in {1:F2}s, average {2:F2}s / file; Async Waits: {3} \r\n", MetaCount, RequiredMS / 1000d, RequiredMS / (1000d * MetaCount),
rewaitCnt, 0));
return(Summary.ToString());
}
async Task <string> TestMultiFileAsyncUploads()
{
string tfoldername = AsyncBasePath; // set at start of tests
System.Collections.Generic.Queue <Task <Cloud_Elements_API.CloudFile> > UploadTasks = new System.Collections.Generic.Queue <Task <Cloud_Elements_API.CloudFile> >();
System.Collections.Generic.List <Cloud_Elements_API.CloudElementsConnector> ConnectorsUsed = new System.Collections.Generic.List <Cloud_Elements_API.CloudElementsConnector>();
DateTime Started = DateTime.Now;
int uploadCount = 0;
System.IO.Stream teststream;
string RandomContent = GenerateRandomContent(256 * 1024 * 8);
if (NumberOfFilesAlreadyUploaded == 0)
{
DownloadTestExpectedHash = RandomContent.GetHashCode();
}
long TotalBytes = 0;
for (int i = 1; i <= 8; i++)
{
teststream = GenerateStreamFromString(RandomContent);
RandomContent = RandomContent.Substring(RandomContent.Length / 2);
string MIMEType = Cloud_Elements_API.Tools.FileTypeToMimeContentType("txt");
List <String> TagList = new List <String>();
long sizeInBytes = teststream.Length;
TotalBytes += sizeInBytes;
string TargetPath = tfoldername + string.Format("/SFCE_test_file_{0}.txt", i + NumberOfFilesAlreadyUploaded);
Cloud_Elements_API.CloudElementsConnector ViaConnector = APIConnector.Clone();
ConnectorsUsed.Add(ViaConnector);
Task <Cloud_Elements_API.CloudFile> AnUpload = ViaConnector.PostFile(teststream, MIMEType,
TargetPath, "Temporary test file",
TagList.ToArray(), false, sizeInBytes);
//System.Runtime.CompilerServices.ConfiguredTaskAwaitable<Cloud_Elements_API.CloudFile> AwaitableUpload;
//AwaitableUpload = AnUpload.ConfigureAwait(false);
UploadTasks.Enqueue(AnUpload);
uploadCount += 1;
}
int rewaitCnt = 0;
System.Text.StringBuilder Summary = new System.Text.StringBuilder();
while (UploadTasks.Count > 0)
{
Task <Cloud_Elements_API.CloudFile> AnUpload = UploadTasks.Dequeue();
if (AnUpload.GetAwaiter().IsCompleted)
{
try
{
Cloud_Elements_API.CloudFile Result = await AnUpload;
Summary.AppendFormat("\t{5}: Task {2} Uploaded {4:F1}KB to {0}, id={1}, ok={3} \r\n", Result.name, Result.id, AnUpload.Id, !AnUpload.IsFaulted,
Result.size / 1024d, Cloud_Elements_API.Tools.TraceTimeNow());
}
catch (Exception ex)
{
Summary.AppendFormat("\t{5}: Task {2} Upload Exception {0}, ok={3} \r\n", ex.Message, 0, AnUpload.Id, !AnUpload.IsFaulted,
0, Cloud_Elements_API.Tools.TraceTimeNow());
}
}
else
{
// if (AnUpload.Status == TaskStatus.WaitingForActivation) AnUpload.ci
UploadTasks.Enqueue(AnUpload);
rewaitCnt += 1;
System.Threading.Thread.Sleep(128);
}
}
foreach (Cloud_Elements_API.CloudElementsConnector ViaConnector in ConnectorsUsed)
{
ViaConnector.Close();
}
ConnectorsUsed.Clear();
Summary.AppendFormat("\t{0}: Finished \r\n", Cloud_Elements_API.Tools.TraceTimeNow());
double RequiredMS = DateTime.Now.Subtract(Started).TotalMilliseconds;
Summary.Insert(0, string.Format("Uploaded {0} files in {1:F2}s, average {2:F2}s / file, {4:F2}ms/KB; Async Waits: {3} \r\n", uploadCount, RequiredMS / 1000d, RequiredMS / (1000d * uploadCount),
rewaitCnt, (RequiredMS) / (TotalBytes / 1024d)));
return(Summary.ToString());
}
protected async Task <ResponseConsult <T> > PutAsJsonAsync <T>(string _path, object _requestData)
{
return(await APIConnector.PutAsJsonAsync <T>(_path, _requestData));
}
APIConnector()
{
ApiConnector = this;
}
protected async Task <ResponseConsult <T> > DeleteAsync <T>(string _path)
{
return(await APIConnector.DeleteAsync <T>(_path));
}
protected void Button1_Click(object sender, EventArgs e)
{
JObject jo = JObject.Parse(APIConnector.Get(tbUrl.Text));
lbImg.Text = "<img src='data: image / png; base64, " + jo.GetValue("image") + "' />";
}
/// <summary>
/// Wrapper to send simple message <see cref="Threema.MsgApi.APIConnector.SendTextMessageSimple"/>
/// </summary>
/// <param name="to">Recipient id</param>
/// <param name="from">Sender id</param>
/// <param name="secret">Sender sercret</param>
/// <param name="text">Text message</param>
/// <param name="apiUrl">Optional api url</param>
/// <returns>Message id</returns>
public string SendTextMessageSimple(string to, string from, string secret, string text, string apiUrl = APIConnector.DEFAULTAPIURL)
{
APIConnector apiConnector = this.CreateConnector(from, secret, apiUrl);
return(apiConnector.SendTextMessageSimple(to, DataUtils.Utf8Endcode(text)));
}
private int activeMap = 0; //Country Map(default), 1=Provinces Map
void Start()
{
apiConnector = new APIConnector(this);
StartCoroutine(UpdateTime());
}
/// <summary>
/// Wrapper to id lookup via email <see cref="Threema.MsgApi.APIConnector.LookupEmail"/>
/// </summary>
/// <param name="email">Email for lookup</param>
/// <param name="from">Sender id</param>
/// <param name="secret">Sender secret</param>
/// <param name="apiUrl">Optional api url</param>
/// <returns>id</returns>
public string LookupEmail(string email, string from, string secret, string apiUrl = APIConnector.DEFAULTAPIURL)
{
APIConnector apiConnector = this.CreateConnector(from, secret, apiUrl);
return(apiConnector.LookupEmail(email));
}
void Start()
{
apiConnector = new APIConnector(this);
}
private async Task RunUnitTest()
{
TestStatusMsg("Beginning test suite...");
TestStatusMsg("Testing with " + toolStripTxtConnectionNow.Text);
string basepath = txtFolderPath.Text;
SerializeGetFileMetadataRequests = chkSerializeGetFileInfoReq.Checked;
APIConnector.EndpointMaxRequestsPerSecond = (int)spnRequestsPerSecond.Value;
if (basepath.EndsWith("/"))
{
basepath.TrimEnd(new char[] { '/' });
}
string tfoldername = basepath + "/Cloud Elements API Test Folder";
AsyncBasePath = tfoldername;
Boolean remnant = false;
Boolean fremnant = false;
DateTime StartTime = DateTime.Now;
Cloud_Elements_API.CloudFile TestFileStore;
//FIRST TEST: Check for folder. If no folder, create test folder.
try
{
// List<Cloud_Elements_API.CloudFile> fe = await APIConnector.ListFolderContents(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, tfoldername, chkWithTags.Checked);
Cloud_Elements_API.CloudFile Result = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, tfoldername);
if (Result != null)
{
remnant = true;
TestStatusMsg("Using existing test folder");
}
else
{
remnant = false;
}
}
//catch (System.Net.Http.HttpRequestException e)
//{
// //NOTE: handle different http exceptions!
// remnant = false;
//}
catch (Exception ex)
{
TestStatusMsg("Problem checking if test folder exists: " + ex.Message);
throw ex;
}
if (!remnant)
{
TestStatusMsg("Test: Creating folder...");
try
{
Cloud_Elements_API.CloudFile newFolder = new Cloud_Elements_API.CloudFile();
newFolder.path = tfoldername;
//newFolder.tags = new string[] { "sfCE.NET" };
Cloud_Elements_API.CloudFile Result = await APIConnector.CreateFolder(newFolder);
TestStatusMsg(string.Format("Created {0}, id={1}", Result.path, Result.id));
Task ignoredRefreshFolderTask = RefreshCurrentFolder(); // very naughty, ignore exceptions; ref http://stackoverflow.com/questions/14903887/warning-this-call-is-not-awaited-execution-of-the-current-method-continues
}
catch (Exception ec)
{
TestStatusMsg("Create Folder failed: " + ec.Message);
throw ec;
}
}
TestStatusMsg("Checking for test file...");
try
{
string TargetPath = tfoldername + "/SFCE_test_file_prime.txt";
Cloud_Elements_API.CloudFile Result = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, TargetPath);
if (Result != null)
{
TestStatusMsg(string.Format("Test file exists: {0}, id={1}", Result.path, Result.id));
fremnant = true;
TestFileStore = Result;
}
else
{
TestStatusMsg("Test file not found"); TestFileStore = null;
}
}
catch (Exception ec)
{
TestStatusMsg("Check for file failed: " + ec.Message);
TestFileStore = null;
// throw ec;
}
double UploadRequiredMS = 0d;
if (!fremnant)
{
//SECOND TEST: Create file.
TestStatusMsg("Test: Uploading file...");
try
{
using (System.IO.Stream teststream = GenerateStreamFromString("This is a dummy test file; its diminutive size is quite reasonable."))
{
string MIMEType = Cloud_Elements_API.Tools.FileTypeToMimeContentType("txt");
List <String> TagList = new List <String>();
var sizeInBytes = teststream.Length;
string TargetPath = tfoldername + "/SFCE_test_file_prime.txt";
DateTime Started = DateTime.Now;
Cloud_Elements_API.CloudFile Result = await APIConnector.PostFile(teststream, MIMEType,
TargetPath, "Temporary test file",
TagList.ToArray(), false, sizeInBytes);
UploadRequiredMS = DateTime.Now.Subtract(Started).TotalMilliseconds;
TestStatusMsg(string.Format("Uploaded {0}, id={1}", Result.path, Result.id));
TestFileStore = Result;
}
}
catch (Exception eu)
{
TestStatusMsg("Upload file failed: " + eu.Message);
TestFileStore = null;
}
}
else
{
TestStatusMsg("Skipping file upload");
}
//THIRD TEST: Copy File.
TestStatusMsg("Test: Copying file...");
double CopyRequiredMS = 0d;
try
{
if (TestFileStore == null)
{
TestFileStore = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, tfoldername + "/SFCE_test_file_prime.txt");
}
string CopyFileName = tfoldername + "/SFCE_test_file_copy.txt";
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
DateTime Started = DateTime.Now;
Cloud_Elements_API.CloudFile Result = await Cloud_Elements_API.FileOperations.Copy(APIConnector, currentRow, CopyFileName);
if (Result == null)
{
TestStatusMsg(string.Format("?? Copy did not return CloudFile object ", 0));
}
else
{
CopyRequiredMS = DateTime.Now.Subtract(Started).TotalMilliseconds;
TestStatusMsg(string.Format("Copied [{0}] to {1}", currentRow.name, Result.path));
if (UploadRequiredMS > 0)
{
TestStatusMsg(string.Format("Comparison: Upload {0:F1}ms; Copy {1:F1}ms; Pct {2:P2} ", UploadRequiredMS, CopyRequiredMS, CopyRequiredMS / UploadRequiredMS));
}
}
}
catch (Exception ecopy)
{
TestStatusMsg("Copy File failed: " + ecopy.Message);
}
//FOURTH TEST: Rename File.
TestStatusMsg("Test: Renaming file (by path)...");
try
{
string oldName = "SFCE_test_file_prime.txt";
string oldPath = tfoldername + "/" + oldName;
Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType ceType = Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType.File;
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
currentRow.path = tfoldername + "/SFCE_test_file_rename_path.txt";
Cloud_Elements_API.CloudFile Result = await APIConnector.PatchDocEntryMetaData(ceType, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, oldPath, currentRow);
TestStatusMsg(string.Format("Renamed [{0}] to {1}", oldName, Result.name));
TestFileStore = Result;
}
catch (Exception er)
{
TestStatusMsg("Rename file by path failed: " + er.Message);
}
TestStatusMsg("Test: Renaming file (by ID)...");
try
{
Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType ceType = Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType.File;
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
string oldName = TestFileStore.name;
currentRow.path = tfoldername + "/SFCE_test_file_rename_id.txt";
Cloud_Elements_API.CloudFile PatchData = new Cloud_Elements_API.CloudFile();
PatchData.id = currentRow.id;
PatchData.path = currentRow.path;
Cloud_Elements_API.CloudFile Result = await APIConnector.PatchDocEntryMetaData(ceType, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.ID, TestFileStore.id, PatchData);
TestStatusMsg(string.Format("Renamed [{0}] to {1}", oldName, Result.name));
TestFileStore = Result;
}
catch (Exception er)
{
TestStatusMsg("Rename file failed: " + er.Message);
}
//FIFTH TEST: Add two Tags
TestStatusMsg("Test: Adding Tags...");
try
{
for (int i = 1; i <= 2; i++)
{
string TagToSet = "API Test Tag #" + i.ToString();
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
TestFileStore = await Cloud_Elements_API.TagOperations.SetTag(APIConnector, currentRow, TagToSet);
TestStatusMsg(string.Format("Tag <{0}> added to [{1}] ", TagToSet, currentRow.name));
}
}
catch (Exception etag)
{
TestStatusMsg("Add Tag failed: " + etag.Message);
}
//SIXTH TEST: Remove a Tag
TestStatusMsg("Test: Deleting Tags...");
try
{
for (int i = 1; i <= 2; i++)
{
string TagToDel = "API Test Tag #" + i.ToString();
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
TestFileStore = await Cloud_Elements_API.TagOperations.DeleteTag(APIConnector, currentRow, TagToDel);
TestStatusMsg(string.Format("Tag <{0}> removed from [{1}] ", TagToDel, currentRow.name));
}
}
catch (Exception edt)
{
TestStatusMsg("Delete Tag failed: " + edt.Message);
}
//SEVENTH TEST: Async Uploads
TestStatusMsg("Test: Multiple ASYNC uploads...");
NumberOfFilesAlreadyUploaded = 0;
bool AsyncUploadPassed = false;
System.Func <Task <string> > UploadTestAction;
Task <Task <string> > AsyncUploadTest = null;
Task <string> FinalAwaitableTestTask = null;
System.Runtime.CompilerServices.ConfiguredTaskAwaitable <Task <string> > AwaitableTestTask;
try
{
string info;
// we need to run away from the UI
UploadTestAction = new System.Func <Task <string> >(TestMultiFileAsyncUploads);
AsyncUploadTest = new Task <Task <string> >(UploadTestAction);
AsyncUploadTest.Start();
AwaitableTestTask = AsyncUploadTest.ConfigureAwait(false);
FinalAwaitableTestTask = await AwaitableTestTask;
info = await FinalAwaitableTestTask;
TestStatusMsg(info);
AsyncUploadPassed = true;
NumberOfFilesAlreadyUploaded = 8;
}
catch (Exception eu)
{
TestStatusMsg("Async Uploads failed: " + eu.Message);
}
if (AsyncUploadPassed)
{
//SEVENTH TEST: repeat Async Uploads
UploadTestAction = new System.Func <Task <string> >(TestMultiFileAsyncUploads);
AsyncUploadTest = new Task <Task <string> >(UploadTestAction);
TestStatusMsg("Test: Repeat Multiple ASYNC uploads, without waiting...");
AsyncUploadTest.Start();
AwaitableTestTask = AsyncUploadTest.ConfigureAwait(false);
}
//EIGHTH TEST: Download File
TestStatusMsg("Test: Downloading file...");
System.IO.Stream Target = null;
try
{
string TargetPath = tfoldername + string.Format("/SFCE_test_file_{0}.txt", "1");
Cloud_Elements_API.CloudFile FileRow = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, TargetPath);
if (FileRow != null)
{
Cloud_Elements_API.FileContent Result = await APIConnector.GetFile(FileRow);
string fn = System.IO.Path.Combine(WorkPath, Result.Disposition);
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(fn)))
{
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(fn));
}
if (System.IO.File.Exists(fn))
{
System.IO.File.Delete(fn);
}
Target = new System.IO.FileStream(fn, System.IO.FileMode.Create, System.Security.AccessControl.FileSystemRights.FullControl, System.IO.FileShare.None, 16384, System.IO.FileOptions.Asynchronous, null);
await Cloud_Elements_API.Tools.StreamCopyWithProgress(Result.ContentStream, Target, Result.ContentLength);
Result.ContentStream.Close();
Result.Dispose();
Target.Close();
Target = null;
System.IO.FileInfo finfo = new System.IO.FileInfo(fn);
TestStatusMsg(string.Format("Stored {1}: {0}", Cloud_Elements_API.Tools.SizeInBytesToString(finfo.Length), Result.Disposition));
int DownloadedHash = Cloud_Elements_API.Tools.FileToString(fn).GetHashCode();
if (DownloadedHash != DownloadTestExpectedHash)
{
TestStatusMsg(string.Format("Warning: Hash of {0} does not match", fn));
}
}
else
{
TestStatusMsg(string.Format("Could not find file to download ({0})", TargetPath));
}
}
catch (Exception ed)
{
TestStatusMsg("*** >>>> File download failed: " + ed.Message);
}
finally
{
if (Target != null)
{
Target.Close();
}
}
if (AsyncUploadPassed)
{
//NINETH TEST: Async Meta Info
TestStatusMsg("Test: Multiple ASYNC File Meta Info reads ...");
NumberOfFilesAlreadyUploaded = 0;
System.Func <Task <string> > TestMetaInfoAction;
Task <Task <string> > AsyncMetaInfoTest = null;
Task <string> FinalAwaitableMetaInfoTask = null;
System.Runtime.CompilerServices.ConfiguredTaskAwaitable <Task <string> > AwaitableMetaInfoTask;
try
{
// we need to run away from the UI
TestMetaInfoAction = new System.Func <Task <string> >(TestAsyncGetFileMeta);
AsyncMetaInfoTest = new Task <Task <string> >(TestMetaInfoAction);
AsyncMetaInfoTest.Start();
AwaitableMetaInfoTask = AsyncMetaInfoTest.ConfigureAwait(false);
FinalAwaitableMetaInfoTask = await AwaitableMetaInfoTask;
}
catch (Exception eu)
{
TestStatusMsg("Async Meta Info failed: " + eu.Message);
}
AwaitableTestTask = AsyncUploadTest.ConfigureAwait(false);
FinalAwaitableTestTask = await AwaitableTestTask;
string FinalInfo = await FinalAwaitableTestTask;
TestStatusMsg(FinalInfo);
FinalInfo = await FinalAwaitableMetaInfoTask;
TestStatusMsg(FinalInfo);
}
TestStatusMsg(string.Format("Test suite complete: Elapsed time: {0:F1}s", DateTime.Now.Subtract(StartTime).TotalSeconds));
}
void Start()
{
//Initialize APIConnector obj
apiConnector = new APIConnector(this);
}
/// <summary>
/// Wrapper to id lookup via phone number <see cref="Threema.MsgApi.APIConnector.LookupPhone"/>
/// </summary>
/// <param name="phoneNo">Phone number for lookup</param>
/// <param name="from">Sender id</param>
/// <param name="secret">Sender secret</param>
/// <param name="apiUrl">Optional api url</param>
/// <returns>id</returns>
public string LookupPhone(string phoneNo, string from, string secret, string apiUrl = APIConnector.DEFAULTAPIURL)
{
APIConnector apiConnector = this.CreateConnector(from, secret, apiUrl);
return(apiConnector.LookupPhone(phoneNo));
}
