public void TestExecute()
{
WebRequestFactory.Current = new TestWebRequestFactory();
LiveConnectClient connectClient = new LiveConnectClient(new LiveConnectSession());
Uri requestUri = new Uri("http://foo.com");
ApiMethod apiMethod = ApiMethod.Copy;
string body = string.Empty;
SynchronizationContextWrapper syncContextWrapper = SynchronizationContextWrapper.Current;
var apiOperation =
new ApiOperation(connectClient, requestUri, apiMethod, body, syncContextWrapper);
}
private Task<LiveOperationResult> ExecuteApiOperation(ApiOperation op, CancellationToken ct)
{
if (this.Session == null)
{
throw new LiveConnectException(ApiOperation.ApiClientErrorCode, ResourceHelper.GetString("UserNotLoggedIn"));
}
var tcs = new TaskCompletionSource<LiveOperationResult>();
op.OperationCompletedCallback = (LiveOperationResult opResult) =>
{
if (opResult.IsCancelled)
{
tcs.TrySetCanceled();
}
else if (opResult.Error != null)
{
tcs.TrySetException(opResult.Error);
}
else
{
tcs.TrySetResult(opResult);
}
};
ct.Register(op.Cancel);
op.Execute();
return tcs.Task;
}
private ApiOperation GetApiOperation(string path, ApiMethod method, string body)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentException("path");
}
if (IsAbsolutePath(path))
{
throw new ArgumentException(
String.Format(CultureInfo.CurrentUICulture, ResourceHelper.GetString("RelativeUrlRequired"), "path"),
"path");
}
Uri apiUri = this.GetResourceUri(path, method);
if (this.Session == null)
{
throw new LiveConnectException(ApiOperation.ApiClientErrorCode, ResourceHelper.GetString("UserNotLoggedIn"));
}
ApiOperation operation = null;
switch (method)
{
case ApiMethod.Get:
case ApiMethod.Delete:
operation = new ApiOperation(this, apiUri, method, null, null);
break;
case ApiMethod.Post:
case ApiMethod.Put:
case ApiMethod.Copy:
case ApiMethod.Move:
if (body == null)
{
throw new ArgumentNullException("body");
}
if (string.IsNullOrWhiteSpace(body))
{
throw new ArgumentException("body");
}
operation = new ApiWriteOperation(this, apiUri, method, body, null);
break;
default:
Debug.Assert(false, "method not suppported.");
break;
}
return operation;
}
private async void OnGetUploadLinkCompleted(LiveOperationResult result)
{
if (this.Status == OperationStatus.Cancelled)
{
base.OnCancel();
return;
}
if (result.Error != null || result.IsCancelled)
{
this.OnOperationCompleted(result);
return;
}
var uploadUrl = new Uri(result.RawResult, UriKind.Absolute);
// NOTE: the GetUploadLinkOperation will return a uri with the overwite, suppress_response_codes,
// and suppress_redirect query parameters set.
Debug.Assert(uploadUrl.Query != null);
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.Overwrite));
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.SuppressRedirects));
Debug.Assert(uploadUrl.Query.Contains(QueryParameters.SuppressResponseCodes));
var uploader = new BT.BackgroundUploader();
uploader.Group = LiveConnectClient.LiveSDKUploadGroup;
if (this.LiveClient.Session != null)
{
uploader.SetRequestHeader(
ApiOperation.AuthorizationHeader,
AuthConstants.BearerTokenType + " " + this.LiveClient.Session.AccessToken);
}
uploader.SetRequestHeader(ApiOperation.LibraryHeader, Platform.GetLibraryHeaderValue());
uploader.Method = HttpMethods.Put;
this.uploadOpCts = new CancellationTokenSource();
Exception webError = null;
LiveOperationResult opResult = null;
try
{
if (this.InputStream != null)
{
this.uploadOp = await uploader.CreateUploadFromStreamAsync(uploadUrl, this.InputStream);
}
else
{
this.uploadOp = uploader.CreateUpload(uploadUrl, this.InputFile);
}
var progressHandler = new Progress <BT.UploadOperation>(this.OnUploadProgress);
this.uploadOp = await this.uploadOp.StartAsync().AsTask(this.uploadOpCts.Token, progressHandler);
}
catch (TaskCanceledException exception)
{
opResult = new LiveOperationResult(exception, true);
}
catch (Exception exp)
{
// This might be an server error. We will read the response to determine the error message.
webError = exp;
}
if (opResult == null)
{
try
{
IInputStream responseStream = this.uploadOp.GetResultStreamAt(0);
if (responseStream == null)
{
var error = new LiveConnectException(
ApiOperation.ApiClientErrorCode,
ResourceHelper.GetString("ConnectionError"));
opResult = new LiveOperationResult(error, false);
}
else
{
var reader = new DataReader(responseStream);
uint length = await reader.LoadAsync(MaxUploadResponseLength);
opResult = ApiOperation.CreateOperationResultFrom(reader.ReadString(length), ApiMethod.Upload);
if (webError != null && opResult.Error != null && !(opResult.Error is LiveConnectException))
{
// If the error did not come from the api service,
// we'll just return the error thrown by the uploader.
opResult = new LiveOperationResult(webError, false);
}
}
}
catch (COMException exp)
{
opResult = new LiveOperationResult(exp, false);
}
catch (FileNotFoundException exp)
{
opResult = new LiveOperationResult(exp, false);
}
}
this.OnOperationCompleted(opResult);
}
private Task<LiveOperationResult> ExecuteApiOperation(ApiOperation op, CancellationToken ct)
{
var tcs = new TaskCompletionSource<LiveOperationResult>();
op.OperationCompletedCallback = (LiveOperationResult opResult) =>
{
if (opResult.IsCancelled)
{
tcs.TrySetCanceled();
}
else if (opResult.Error != null)
{
tcs.TrySetException(opResult.Error);
}
else
{
tcs.TrySetResult(opResult);
}
};
ct.Register(op.Cancel);
op.Execute();
return tcs.Task;
}
