public void TestLoginAsyncNullScopes()
{
var authClient = new LiveAuthClient();
try
{
authClient.LoginAsync(null);
Assert.Fail("Expected ArgumentNullException to be thrown.");
}
catch (ArgumentNullException)
{
}
}
public async void TestLoginAsyncNullScopes()
{
var authClient = new LiveAuthClient("SomeClientId");
try
{
LiveLoginResult result = await authClient.LoginAsync(null);
Assert.Fail("Expected ArgumentNullException to be thrown.");
}
catch (ArgumentNullException)
{
}
}
private static ZumoTest CreateLiveSDKLoginTest()
{
return(new ZumoTest("Login via token with Live SDK", async delegate(ZumoTest test)
{
var client = ZumoTestGlobals.Instance.Client;
#if !WINDOWS_PHONE
var uri = client.ApplicationUri.ToString();
var liveIdClient = new LiveAuthClient(uri);
#else
string clientId;
testPropertyBag.TryGetValue(ClientIdKeyName, out clientId);
if (clientId == null)
{
test.AddLog("ClientId of Microsoft application not entered correctly.");
return false;
}
var liveIdClient = new LiveAuthClient(clientId);
#endif
var liveLoginResult = await liveIdClient.LoginAsync(new string[] { "wl.basic" });
if (liveLoginResult.Status == LiveConnectSessionStatus.Connected)
{
var liveConnectClient = new LiveConnectClient(liveLoginResult.Session);
var me = await liveConnectClient.GetAsync("me");
test.AddLog("Logged in as {0}", me.RawResult);
if (liveLoginResult.Session.AuthenticationToken == null)
{
test.AddLog("Error, authentication token in the live login result is null");
return false;
}
else
{
var token = new JObject(new JProperty("authenticationToken", liveLoginResult.Session.AuthenticationToken));
var user = await client.LoginAsync(MobileServiceAuthenticationProvider.MicrosoftAccount, token);
test.AddLog("Logged in as {0}", user.UserId);
return true;
}
}
else
{
test.AddLog("Login failed.");
return false;
}
}, ZumoTestGlobals.RuntimeFeatureNames.LIVE_LOGIN));
}
public async Task <UserInfo> Authenticate()
{
var authClient = new LiveAuthClient();
var authResult = await authClient.LoginAsync(new List <string>() { "wl.signin", "wl.basic", "wl.skydrive" });
if (authResult.Status == LiveConnectSessionStatus.Connected)
{
var session = authResult.Session;
var client = new LiveConnectClient(session);
var liveOpResult = await client.GetAsync("me");
dynamic dynResult = liveOpResult.Result;
return(new UserInfo {
Id = dynResult.id, UserName = dynResult.name, Name = dynResult.name
});
}
return(null);
}
public async Task <LiveConnectClient> Login()
{
_authClient = new LiveAuthClient("**your client id here**");
LiveLoginResult result = await _authClient.InitializeAsync(Scopes);
if (result.Status == LiveConnectSessionStatus.Connected)
{
return(new LiveConnectClient(result.Session));
}
result = await _authClient.LoginAsync(Scopes);
if (result.Status == LiveConnectSessionStatus.Connected)
{
return(new LiveConnectClient(result.Session));
}
return(null);
}
public async Task <LiveConnectClient> Login()
{
AuthClient = new LiveAuthClient("000000004015B444");
LiveLoginResult result = await AuthClient.InitializeAsync(new string[] { "wl.signin", "wl.skydrive" });
if (result.Status == LiveConnectSessionStatus.Connected)
{
return(new LiveConnectClient(result.Session));
}
result = await AuthClient.LoginAsync(new string[] { "wl.signin", "wl.skydrive" });
if (result.Status == LiveConnectSessionStatus.Connected)
{
return(new LiveConnectClient(result.Session));
}
return(null);
}
public override async Task LoginAsync(IList <string> scopes)
{
if (string.IsNullOrEmpty(ClientId))
{
EtcUtility.Instance.MsgBox("ClientId Required");
return;
}
if (AuthClient == null)
{
AuthClient = authClient = new LiveAuthClient(ClientId);
}
else
{
authClient = (LiveAuthClient)AuthClient;
}
try
{
IsBusy = true;
await TaskEx.Run(() =>
{
StaticFunctions.InvokeIfRequiredAsync(StaticFunctions.BaseContext,
para =>
{
//authClient.LoginCompleted +=
// (s, e) =>
// {
// if (e.Status == LiveConnectSessionStatus.Connected)
// {
// LoadUser();
// }
// };
//두번째 접속 시도
authClient.LoginAsync(scopes);
}, null);
});
}
catch (Exception ex)
{
EtcUtility.Instance.MsgBox("NotConnectLiveID " + ex.Message);
}
}
private async void SignIn(object sender, RoutedEventArgs e)
{
try
{
LiveAuthClient auth = new LiveAuthClient();
LiveLoginResult loginResult =
await auth.LoginAsync(new string[] { "wl.basic" });
if (loginResult.Status == LiveConnectSessionStatus.Connected)
{
this.infoTextBlock.Text = "Signed in.";
}
}
catch (LiveAuthException exception)
{
this.infoTextBlock.Text = "Error signing in: "
+ exception.Message;
}
}
/// <summary>
/// Upload a file to OneDrive
/// </summary>
/// <param name="Filename"></param>
/// <param name="Content"></param>
/// <returns></returns>
public static async Task <int> UploadFileAsync(String Foldername, String Filename)
{
try
{
// create OneDrive auth client
var authClient = new LiveAuthClient();
// ask for both read and write access to the OneDrive
LiveLoginResult result = await authClient.LoginAsync(new string[] { "wl.signin", "wl.skydrive", "wl.skydrive_update" });
// if login successful
if (result.Status == LiveConnectSessionStatus.Connected)
{
// create a OneDrive client
liveClient = new LiveConnectClient(result.Session);
// create a local file
StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(Filename);
// create a folder
string folderID = await GetFolderIDAsync(Foldername, true);
if (string.IsNullOrEmpty(folderID))
{
// return error
return(0);
}
// upload local file to OneDrive
await liveClient.BackgroundUploadAsync(folderID, file.Name, file, OverwriteOption.Overwrite);
return(1);
}
}
catch (Exception e)
{
return(e.Message.Length);
}
// return error
return(0);
}
private async void signInButton_Click(object sender, RoutedEventArgs e)
{
try
{
LiveLoginResult loginResult = await _liveAuthClient.LoginAsync(_scopes);
if (loginResult.Status == LiveConnectSessionStatus.Connected)
{
_liveConnectClient = new LiveConnectClient(loginResult.Session);
responseTextBlock.Text = "signed in";
createPageButton.IsEnabled = true;
}
}
catch (LiveAuthException ex)
{
responseTextBlock.Text = ex.ToString();
}
}
private async void downButton_Click_1(object sender, RoutedEventArgs e) //下载
{
try
{
msgText.Text = "亲：正在下载";
string id = string.Empty;
var authClient = new LiveAuthClient();
var authResult = await authClient.LoginAsync(new string[] { "wl.skydrive" });
if (authResult.Session != null)
{
var connectClient = new LiveConnectClient(authResult.Session);
LiveOperationResult operationResult = await connectClient.GetAsync("me/skydrive/search?q=WorkBook.xml");
List <object> items = operationResult.Result["data"] as List <object>;
IDictionary <string, object> file = items.First() as IDictionary <string, object>;
id = file["id"].ToString();
LiveDownloadOperation operation = await connectClient.CreateBackgroundDownloadAsync(string.Format("{0}/content", id));
var result = await operation.StartAsync();
Stream stream = result.Stream.AsStreamForRead();
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
StorageFile files = await localFolder.GetFileAsync(App.WordBookFileName);
XDocument xBook = XDocument.Load(stream);
await FileIO.WriteTextAsync(files, xBook.ToString());
msgText.Text = "恭喜：您已成功从OneDrive下载生词!";
}
}
catch (Exception ex)
{
msgText.Text = ex.Message;
}
}
private async Task Authenticate()
{
try
{
var liveIdClient = new LiveAuthClient("000000004810306D");
var initResult = await liveIdClient.InitializeAsync(scopes);
_session = initResult.Session;
if (null == _session)
{
LiveLoginResult result = await liveIdClient.LoginAsync(scopes);
if (result.Status == LiveConnectSessionStatus.Connected)
{
_session = result.Session;
if (AuthenticationSuccessful != null)
{
AuthenticationSuccessful();
}
}
else
{
_session = null;
if (AuthenticationFailed != null)
{
AuthenticationFailed();
}
//MessageBox.Show("Unable to authenticate with Windows Live.", "Login failed :(", MessageBoxButton.OK);
}
}
if (AuthenticationSuccessful != null)
{
AuthenticationSuccessful();
}
}
catch (Exception)
{
}
}
private async System.Threading.Tasks.Task Authenticate()
{
LiveAuthClient liveIdClient = new LiveAuthClient("https://idb.azure-mobile.net/");
while (session == null)
{
// Force a logout to make it easier to test with multiple Microsoft Accounts
if (liveIdClient.CanLogout)
{
liveIdClient.Logout();
}
LiveLoginResult result = await liveIdClient.LoginAsync(new[] { "wl.basic" });
if (result.Status == LiveConnectSessionStatus.Connected)
{
session = result.Session;
LiveConnectClient client = new LiveConnectClient(result.Session);
LiveOperationResult meResult = await client.GetAsync("me");
MobileServiceUser loginResult = await App.MobileService.LoginAsync(result.Session.AuthenticationToken);
//string title = string.Format("Welcome {0}!", meResult.Result["first_name"]);
App.LoginName = string.Format("{0}", meResult.Result["name"]);
App.Gender = string.Format("{0}", meResult.Result["gender"]);
App.UserID = string.Format("{0}", loginResult.UserId);
//var message = string.Format("You are now logged in - {0}", loginResult.UserId);
//var dialog = new MessageDialog(message, title);
//dialog.Commands.Add(new UICommand("OK"));
//await dialog.ShowAsync();
}
else
{
session = null;
var dialog = new MessageDialog("You must log in.", "Login Required");
dialog.Commands.Add(new UICommand("OK"));
await dialog.ShowAsync();
}
}
}
private async void btnGreetUser_Click(object sender, RoutedEventArgs e)
{
try
{
LiveAuthClient auth = new LiveAuthClient();
LiveLoginResult initializeResult = await auth.InitializeAsync();
try
{
LiveLoginResult loginResult = await auth.LoginAsync(new string[] { "wl.basic" });
if (loginResult.Status == LiveConnectSessionStatus.Connected)
{
LiveConnectClient connect = new LiveConnectClient(auth.Session);
LiveOperationResult operationResult = await connect.GetAsync("me");
dynamic result = operationResult.Result;
if (result != null)
{
this.infoTextBlock.Text = string.Join(" ", "Hello", result.name, "!");
}
else
{
this.infoTextBlock.Text = "Error getting name.";
}
}
}
catch (LiveAuthException exception)
{
this.infoTextBlock.Text = "Error signing in: " + exception.Message;
}
catch (LiveConnectException exception)
{
this.infoTextBlock.Text = "Error calling API: " + exception.Message;
}
}
catch (LiveAuthException exception)
{
this.infoTextBlock.Text = "Error initializing: " + exception.Message;
}
}
/// <summary>
/// Login mit einem entsprechenden Dialog.
/// </summary>
/// <returns>Ein MobileServiceUser, der awaited werden kann oder null bei Misserfolg.</returns>
internal async static Task <MobileServiceUser> Authenticate(MobileServiceClient mobileService)
{
LiveAuthClient liveAuthClient = new LiveAuthClient(APIKeys.LiveClientId);
var source = new TaskCompletionSource <MobileServiceUser>();
liveAuthClient.Logout();
var scopes = new string[] { "wl.basic", "wl.offline_access", "wl.signin" };
App.Current.RootVisual.Visibility = System.Windows.Visibility.Collapsed;
try
{
session = (await liveAuthClient.LoginAsync(scopes)).Session;
}
finally
{
App.Current.RootVisual.Visibility = System.Windows.Visibility.Visible;
}
return(await mobileService.LoginWithMicrosoftAccountAsync(session.AuthenticationToken));
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
getGpsLocation();
try
{
LiveAuthClient auth = new LiveAuthClient();
LiveLoginResult initializeResult = await auth.InitializeAsync();
try
{
LiveLoginResult loginResult = await auth.LoginAsync(new string[] { "wl.basic", "wl.emails" });
if (loginResult.Status == LiveConnectSessionStatus.Connected)
{
LiveConnectClient connect = new LiveConnectClient(auth.Session);
LiveOperationResult operationResult = await connect.GetAsync("me");
dynamic result = operationResult.Result;
if (result != null)
{
User u = new User();
u.FirstName = result.first_name;
u.LastName = result.last_name;
u.Email = result.emails.account;
_vm.SaveUser(u);
_vm.ActiveUser = u;
}
}
}
catch (LiveAuthException exception)
{
}
catch (LiveConnectException exception)
{
}
}
catch (LiveAuthException exception)
{
}
}
private async void downButton_Click_1(object sender, RoutedEventArgs e)//下载
{
try
{
msgText.Text = "亲：正在下载";
string id = string.Empty;
var authClient = new LiveAuthClient();
var authResult = await authClient.LoginAsync(new string[] { "wl.skydrive" });
if (authResult.Session != null)
{
var connectClient = new LiveConnectClient(authResult.Session);
LiveOperationResult operationResult = await connectClient.GetAsync("me/skydrive/search?q=notes.json");
List <object> items = operationResult.Result["data"] as List <object>;
IDictionary <string, object> file = items.First() as IDictionary <string, object>;
id = file["id"].ToString();
LiveDownloadOperation operation = await connectClient.CreateBackgroundDownloadAsync(string.Format("{0}/content", id));
var result = await operation.StartAsync();
Stream stream = result.Stream.AsStreamForRead();
Notes = (ObservableCollection <Note>)jsonSerializer.ReadObject(stream);
StorageFile files = await ApplicationData.Current.LocalFolder.GetFileAsync(fileName);
using (var streamJson = await ApplicationData.Current.LocalFolder.OpenStreamForWriteAsync(fileName,
CreationCollisionOption.ReplaceExisting))
{
jsonSerializer.WriteObject(streamJson, Notes);
}
msgText.Text = "恭喜：您已成功从OneDrive下载记事!";
Frame.Navigate(typeof(MainPage));
}
}
catch (Exception ex)
{
msgText.Text = ex.Message;
}
}
private async void login()
{
try
{
string clientId = "000000004C10C962";
LiveAuthClient auth = new LiveAuthClient(clientId);
LiveLoginResult initializeResult = await auth.InitializeAsync();
try
{
LiveLoginResult loginResult = await auth.LoginAsync(new string[] { "wl.basic", "wl.emails" });
if (loginResult.Status == LiveConnectSessionStatus.Connected)
{
LiveConnectClient connect = new LiveConnectClient(auth.Session);
LiveOperationResult operationResult = await connect.GetAsync("me");
dynamic result = operationResult.Result;
if (result != null)
{
u.FirstName = result.first_name;
u.LastName = result.last_name;
u.Email = result.emails.account;
_vm.SaveUser(u);
_vm.ActiveUser = u;
}
}
}
catch (LiveAuthException exception)
{
}
catch (LiveConnectException exception)
{
}
}
catch (LiveAuthException exception)
{
}
}
public async Task <ConnectionResult> ShowLogin()
{
var authClient = new LiveAuthClient();
LiveLoginResult loginResult;
try
{
// IMPORTANT! The app MUST be associated with the store, or a (otherwise unhelpful) NullReferenceException
// will be raised when calling the AuthClient methods.
loginResult = await authClient.LoginAsync(_scopes);
}
catch (NullReferenceException)
{
// This is basically for the sake of example only, since an actual app obtained through the store will not have
// the probnlem of not having been associated with the Windows Store.
AppNotAssociatedWithStoreError(this, EventArgs.Empty);
return(new ConnectionResult {
SessionStatus = LiveConnectSessionStatus.NotConnected, CanLogout = false
});
}
catch (LiveAuthException ex)
{
throw new InvalidOperationException("An error occurred during initialization.", ex);
}
// Set the current instance session based on the login
var currentSession = loginResult.Status == LiveConnectSessionStatus.Connected ? loginResult.Session : null;
UpdateSession(currentSession);
var result = new ConnectionResult
{
SessionStatus = loginResult.Status,
CanLogout = authClient.CanLogout,
};
return(result);
}
private void OnAuthClientInitializeCompleted(System.Threading.Tasks.Task <LiveLoginResult> task)
{
if (!CheckTaskCompleted(task, "Not connected. Failed to initialize client."))
{
RaiseLinkAbort(task.Exception);
return;
}
LiveLoginResult result = task.Result;
if (result.Status == LiveConnectSessionStatus.Connected)
{
Log("Connected. Moving on with client.");
// We're online, get the client.
MakeClientFromSession(result.Session);
}
else
{
// Checks if we need to auto login.
bool shouldAutoLogin = false;
lock (_syncRoot)
{
shouldAutoLogin = _autoLoginOnInitFail;
}
// If we need to auto-login, do it.
if (shouldAutoLogin)
{
Log("Not connected. Starts LoginAsync (auto-login)");
StartTaskAndContinueWith(() => _authClient.LoginAsync(_Scopes), OnAuthClientLoginCompleted);
}
else
{
Log("Not connected. Auto-login not requested.");
}
}
}
public async Task InitializeAsync()
{
shouldUploadPlots = applicationSettings.Get <bool>("ShouldAutomaticallyUploadPlots").GetOrElse(false);
Message = "Authenticating";
var auth = new LiveAuthClient("000000004C0EC1AB");
var result = await auth.InitializeAsync(new[] { "wl.basic", "wl.offline_access", "wl.signin", "wl.skydrive_update" });
if (result.Status != LiveConnectSessionStatus.Connected)
{
Message = "Logging in";
result =
await
auth.LoginAsync(new[] { "wl.basic", "wl.offline_access", "wl.signin", "wl.skydrive_update" });
}
if (result.Status == LiveConnectSessionStatus.Connected)
{
client = new LiveConnectClient(result.Session);
IsInitialized = true;
}
}
public static async Task <LiveConnectSessionStatus> LoginAsync()
{
try
{
var result = await _authClient.InitializeAsync(_scopes);
if (result.Status != LiveConnectSessionStatus.Connected)
{
result = await _authClient.LoginAsync(_scopes);
}
if (result.Status == LiveConnectSessionStatus.Connected)
{
_session = result.Session;
}
return(result.Status);
}
catch (LiveAuthException ex)
{
throw new LiveAuthException(ex.ErrorCode, ex.Message, ex.InnerException);
}
}
private async void initialize()
{
try
{
authClient = new LiveAuthClient();
LiveLoginResult authLogResult = await authClient.LoginAsync(new List <string>() { "wl.signin", "wl.basic", "wl.skydrive_update" });
if (authLogResult.Status == LiveConnectSessionStatus.Connected)
{
client = new Microsoft.Live.LiveConnectClient(authClient.Session);
LiveOperationResult opResult = await client.GetAsync("me");
dynamic result = opResult.Result;
//tblUserName.Text = result.name;
}
}
catch (Exception e)
{
//tblUserName.Text = "Error";
}
}
public override async Task <AuthenticationResult> AuthenticateAsync()
{
var result = await _authClient.LoginAsync(this.AuthorizationScopesList.ToArray());
if (result != null && result.Status == LiveConnectSessionStatus.Connected)
{
_result = result;
return(AuthenticationResult.Success);
}
if (result.Status == LiveConnectSessionStatus.Unknown)
{
return(AuthenticationResult.Unknown);
}
else if (result.Status == LiveConnectSessionStatus.NotConnected)
{
return(AuthenticationResult.Failed);
}
return(AuthenticationResult.Unknown);
//A really bad status to talk about!
//var client = new LiveConnectClient(result.Session);
//dynamic result2 = await client.GetAsync("me/skydrive/files");
}
private async void uploadButton_Click(object sender, RoutedEventArgs e)//上传
{
try
{
msgText.Text = "亲：正在上传";
var authClient = new LiveAuthClient();
var authResult = await authClient.LoginAsync(new string[] { "wl.skydrive", "wl.skydrive_update" });
if (authResult.Session != null)
{
var liveConnectClient = new LiveConnectClient(authResult.Session);
StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(fileName);
//String fileText = await FileIO.ReadTextAsync(file);
LiveUploadOperation uploadOperation = await liveConnectClient.CreateBackgroundUploadAsync(
"me/skydrive", file.Name, file, OverwriteOption.Overwrite);
LiveOperationResult uploadResult = await uploadOperation.StartAsync();
if (uploadResult.Result != null)
{
msgText.Text = "恭喜：您已成功同步记事至OneDrive!";
}
}
}
catch (LiveAuthException ex)
{
msgText.Text = ex.Message;
}
catch (LiveConnectException ex)
{
msgText.Text = ex.Message;
}
}
public async static Task <bool> LoginAsync()
{
try
{
_auth = new LiveAuthClient(ClientId);
LiveLoginResult result = await _auth.InitializeAsync(Scopes);
if (result.Status != LiveConnectSessionStatus.Connected)
{
result = await _auth.LoginAsync(Scopes);
}
if (result.Status == LiveConnectSessionStatus.Connected)
{
_client = new LiveConnectClient(result.Session);
CurrentUserName = await GetUserNameAsync();
return(true);
}
}
catch (Exception) { }
_client = null;
_auth = null;
return(false);
}
private async void Button_Click_1(object sender, RoutedEventArgs e)
{
//if (this.liveClient == null) return;
if (this.SkySignInBtn.Session == null)
{
MessageBox.Show("session is null"); return;
}
//this.liveClient = new LiveConnectClient(this.SkySignInBtn.Session);
try
{
LiveAuthClient auth = new LiveAuthClient("00000000440FBD35");
LiveLoginResult loginResult = await auth.LoginAsync(new string[] { "wl.basic" });
if (loginResult.Status == LiveConnectSessionStatus.Connected)
{
MessageBox.Show("signed in");
this.liveClient = new LiveConnectClient(loginResult.Session);
}
}
catch (LiveAuthException exception)
{
MessageBox.Show("error: " + exception.Message);
}
}
public async Task SignIn()
{
// you should call this from UI thread
if (_liveSession == null)
{
_liveAuth = new LiveAuthClient(_clientId);
_liveResult = await _liveAuth.InitializeAsync(_requiredScopes);
if (_liveResult.Status != LiveConnectSessionStatus.Connected)
{
_liveResult = await _liveAuth.LoginAsync(_requiredScopes);
}
_liveSession = _liveResult.Session;
_liveClient = new LiveConnectClient(_liveSession);
_liveClient.BackgroundTransferPreferences = BackgroundTransferPreferences.AllowCellularAndBattery;
}
if (_folderId == null)
{
await GetSkyDriveFolder();
}
}
/// <summary>
/// Performs login via Live Connect and then via Mobile Services
/// </summary>
private async Task Login()
{
// Force the user to login on app startup
LiveLoginResult result = await _liveAuthClient.LoginAsync(new string[] { "wl.signin", "wl.basic", "wl.postal_addresses" });
if (result.Session == null)
{
await _popupService.ShowDialogAsync("You must login to use doto.", "Not logged in");
SetViewState(ViewState.LoggedOut);
return;
}
await _mobileServiceClient.LoginAsync(result.Session.AuthenticationToken);
var profiles = await _profilesTable.Where(p => p.UserId == _mobileServiceClient.CurrentUser.UserId).ToListAsync();
if (profiles.Count == 0)
{
LiveConnectClient lcc = new LiveConnectClient(result.Session);
var me = await lcc.GetAsync("me");
dynamic pic = await lcc.GetAsync("me/picture");
RegisterUser(me.Result, pic.Result, _mobileServiceClient.CurrentUser.UserId);
}
else
{
User = profiles.First();
RegisterDevice();
LoadLists(true);
LoadInvites();
}
return;
}
private async void RunButton_Click(object sender, RoutedEventArgs e)
{
try
{
// Validate parameters
string path = pathTextBox.Text;
string destination = destinationTextBox.Text;
string requestBody = requestBodyTextBox.Text;
var scope = (authScopesComboBox.SelectedValue as ComboBoxItem).Content as string;
var method = (methodsComboBox.SelectedValue as ComboBoxItem).Content as string;
// acquire auth permissions
var authClient = new LiveAuthClient();
var authResult = await authClient.LoginAsync(new string[] { scope });
if (authResult.Session == null)
{
throw new InvalidOperationException("You need to login and give permission to the app.");
}
var liveConnectClient = new LiveConnectClient(authResult.Session);
LiveOperationResult operationResult = null;
switch (method)
{
case "GET":
operationResult = await liveConnectClient.GetAsync(path);
break;
case "POST":
operationResult = await liveConnectClient.PostAsync(path, requestBody);
break;
case "PUT":
operationResult = await liveConnectClient.PutAsync(path, requestBody);
break;
case "DELETE":
operationResult = await liveConnectClient.DeleteAsync(path);
break;
case "COPY":
operationResult = await liveConnectClient.CopyAsync(path, destination);
break;
case "MOVE":
operationResult = await liveConnectClient.MoveAsync(path, destination);
break;
}
if (operationResult != null)
{
Log("Operation succeeded: \r\n" + operationResult.RawResult);
}
}
catch (Exception ex)
{
Log("Got error: " + ex.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SkydriveSignIn_Click(object sender, System.Windows.RoutedEventArgs e)
{
_auth = new LiveAuthClient(SkydriveSignIn.ClientId);
_auth.LoginCompleted += new System.EventHandler <LoginCompletedEventArgs>(auth_LoginCompleted);
_auth.LoginAsync(new string[] { "wl.signin", "wl.basic" });
}
private async Task <LiveConnectSessionStatus> Connect(bool includeEmailAddress = false)
{
if (client != null)
{
return(LiveConnectSessionStatus.Connected);
}
LiveAuthException liveConnectException = null;
try
{
var liveAuth = new LiveAuthClient(Constants.MICROSOFT_LIVE_CLIENTID);
var liveAuthResult = includeEmailAddress
? await liveAuth.InitializeAsync(new[]
{
Constants.MICROSOFT_LIVE_SCOPE_BASIC,
Constants.MICROSOFT_LIVE_SCOPE_EMAILS,
Constants.MICROSOFT_LIVE_SCOPE_SIGNIN,
Constants.MICROSOFT_LIVE_SCOPE_OFFLINEACCESS,
Constants.MICROSOFT_LIVE_SCOPE_SKYDRIVE,
Constants.MICROSOFT_LIVE_SCOPE_SKYDRIVEUPDATE
})
: await liveAuth.InitializeAsync(new[]
{
Constants.MICROSOFT_LIVE_SCOPE_BASIC,
Constants.MICROSOFT_LIVE_SCOPE_SIGNIN,
Constants.MICROSOFT_LIVE_SCOPE_OFFLINEACCESS,
Constants.MICROSOFT_LIVE_SCOPE_SKYDRIVE,
Constants.MICROSOFT_LIVE_SCOPE_SKYDRIVEUPDATE
});
if (liveAuthResult.Status == LiveConnectSessionStatus.Connected)
{
client = CreateClientForSession(liveAuth.Session);
}
else
{
liveAuthResult = includeEmailAddress
? await liveAuth.LoginAsync(new[]
{
Constants.MICROSOFT_LIVE_SCOPE_BASIC,
Constants.MICROSOFT_LIVE_SCOPE_EMAILS,
Constants.MICROSOFT_LIVE_SCOPE_SIGNIN,
Constants.MICROSOFT_LIVE_SCOPE_OFFLINEACCESS,
Constants.MICROSOFT_LIVE_SCOPE_SKYDRIVE,
Constants.MICROSOFT_LIVE_SCOPE_SKYDRIVEUPDATE
})
: await liveAuth.LoginAsync(new[]
{
Constants.MICROSOFT_LIVE_SCOPE_BASIC,
Constants.MICROSOFT_LIVE_SCOPE_SIGNIN,
Constants.MICROSOFT_LIVE_SCOPE_OFFLINEACCESS,
Constants.MICROSOFT_LIVE_SCOPE_SKYDRIVE,
Constants.MICROSOFT_LIVE_SCOPE_SKYDRIVEUPDATE
});
client = liveAuthResult.Status == LiveConnectSessionStatus.Connected ? CreateClientForSession(liveAuth.Session) : null;
meResult = null;
}
return(liveAuthResult.Status);
}
catch (TaskCanceledException)
{
client = null;
return(LiveConnectSessionStatus.NotConnected);
}
catch (LiveAuthException ex)
{
if (ex.ErrorCode.Equals("access_denied", StringComparison.OrdinalIgnoreCase))
{
client = null;
return(LiveConnectSessionStatus.NotConnected);
}
liveConnectException = ex;
}
if (liveConnectException != null)
{
var extraCrashData = new BugSense.Core.Model.LimitedCrashExtraDataList();
extraCrashData.Add("ErrorCode", liveConnectException.ErrorCode);
extraCrashData.Add("Message", liveConnectException.Message);
await BugSenseHandler.Instance.LogExceptionAsync(liveConnectException, extraCrashData);
}
return(LiveConnectSessionStatus.Unknown);
}