public bool IsConnected()
{
try
{
var accountInfo = _dropBoxClient.AccountInfo();
return(accountInfo.uid > 0);
}
catch
{
return(false);
}
}
public async Task <string> ReceiveAccountEmail()
{
if (!SignedIn)
{
return(null);
}
else
{
var info = client.AccountInfo();
string emailname = info.email;
return(emailname);
}
}
public DropNetClient Connect(TokenAndSecretModel model)
{
_client = new DropNetClient("token", "secret", model.Token, model.Secret);
var info = _client.AccountInfo();
return(_client);
}
public async Task <long[]> DetermineAvailableCloudSpace(object DriveServiceClient)
{
long[] space = new long[2];
DropNetClient client = DriveServiceClient as DropNetClient;
try
{
//Das ganze ist aber erst möglich nach der fix fertigen anmeldung!!!
var info = client.AccountInfo();
long totalSpace = info.quota_info.quota; //Gesamtverfügbare Speicher in byte
long neededSpace = info.quota_info.normal; //belegter Speichermomentan in byte
//string str2 = info.quota_info.shared.ToString(); //freigegebener SPeicher(geteilt mit anderen usern) in byte
long availableSpace = totalSpace - neededSpace;
space[0] = totalSpace; //totalspace
space[1] = availableSpace; //availablespace
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(space);
}
private void WebBrowser1OnDocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
{
webBrowser1.Hide();
if (e.Url.Host.Contains("google"))
{
client.GetAccessTokenAsync(
user =>
{
userLogin = user;
Invoke((MethodInvoker)
delegate
{
webBrowser1.Visible = false;
});
AccountInfo x = client.AccountInfo();
MessageBox.Show(x.display_name.ToString());
},
error =>
{
var xError = error as DropboxRestException;
if (xError != null)
{
MessageBox.Show(xError.Response.Content);
}
else
{
MessageBox.Show(error.Message);
}
});
}
}
private bool Dropbox(User user, byte[] data)
{
try
{
OnAccountStart(new BackupEventArgs(AccountEnum.Dropbox.ToString()));
var dropClient = new DropNetClient(DropboxConfigurationSection.DropboxApiKey,
DropboxConfigurationSection.DropboxAppSecret);
dropClient.UserLogin = new UserLogin
{
Secret = user.DropboxAccount.UserSecret,
Token = user.DropboxAccount.UserToken
};
dropClient.AccountInfo();
try
{
dropClient.UploadFile("/List Defender", "ListDefender " + DateTime.Now + ".zip", data);
}
catch (Exception)
{
dropClient.CreateFolder("List Defender");
dropClient.UploadFile("/List Defender", "ListDefender " + DateTime.Now + ".zip", data);
}
OnAccountComplete(new BackupEventArgs(AccountEnum.Dropbox.ToString()));
return(true);
}
catch (Exception ex)
{
OnShowError(new BackupEventArgs(AccountEnum.Dropbox.ToString()));
logger.Error("Problems with Dropbox");
_unitOfWork.DropboxRepository.Delete(user.Id);
_unitOfWork.Commit();
return(false);
}
}
public async Task Given_A_Clent_Get_User_Account_Infromation()
{
var client = new DropNetClient(AppKey, AppSecret, UserToken, UserSecret);
var accountInfromation = await client.AccountInfo();
Assert.NotNull(accountInfromation);
Assert.NotNull(accountInfromation.QuotaInfo);
}
public void Can_Get_AccountInfo()
{
_client.UserLogin = new Models.UserLogin {
Token = TestVariables.Token, Secret = TestVariables.Secret
};
var accountInfo = _client.AccountInfo();
Assert.IsNotNull(accountInfo);
Assert.IsNotNull(accountInfo.display_name);
Assert.IsNotNull(accountInfo.uid);
}
public Task <Account> Identify()
{
return(Task.Run(() =>
{
var accountInfo = _client.AccountInfo();
Console.WriteLine(accountInfo.display_name);
Console.WriteLine(accountInfo.email);
Console.WriteLine(accountInfo.quota_info);
return accountInfo.ToAccount();
}));
}
private void AddAccountButton_Click(object sender, RoutedEventArgs e)
{
var serviceConfig = XDocument.Load(_dropboxfsAppConfig);
if (serviceConfig.Root == null)
{
return;
}
var appKey = serviceConfig.Root.XPathSelectElement("//appSettings/add[@key='ApplicationKey']").Attribute("value").Value;
var appSecret = serviceConfig.Root.XPathSelectElement("//appSettings/add[@key='ApplicationSecret']").Attribute("value").Value;
if (string.IsNullOrWhiteSpace(appKey) || string.IsNullOrWhiteSpace(appSecret))
{
return;
}
var dropNetclient = new DropNetClient(appKey, appSecret);
dropNetclient.GetToken();
var url = dropNetclient.BuildAuthorizeUrl("http://127.0.0.1:64646/callback/");
var callbackResult = new DropboxCallbackListener(dropNetclient);
ThreadPool.QueueUserWorkItem(DropboxCallbackListener.ProcessDropboxCallback, callbackResult);
Process.Start(url);
var count = 0; // we'll count how long the process can wait. 4 mins seems more than enough
do
{
count++;
} while (!WaitHandle.WaitAll(new WaitHandle[] { callbackResult.Done }, 5000) || count < 48);
if (callbackResult.UserLogin == null)
{
throw new Exception("Timed out waiting for Dropbox oAuth callback. Try again");
}
// if everything is alright - update the config with a new authorized account
dropNetclient.UserLogin = callbackResult.UserLogin;
var info = dropNetclient.AccountInfo();
var name = info.display_name ?? info.email;
var accountsRoot = serviceConfig.Root.XPathSelectElement("//clientAccounts");
var account = new XElement("add");
account.SetAttributeValue("name", name);
account.SetAttributeValue("key", callbackResult.UserLogin.Token);
account.SetAttributeValue("secret", callbackResult.UserLogin.Secret);
accountsRoot.Add(account);
serviceConfig.Save(_dropboxfsAppConfig);
UpdateAccountList();
}
internal void checkLogin()
{
if (_login == null)
{
_login = _loginFunc();
if (_login == null)
{
throw new Exception("Login failed.");
}
var client = new DropNetClient(_clientId, _clientSecret)
{
UserLogin = _login
};
Alias = String.Format(_aliasMask, client.AccountInfo().display_name);
}
}
protected void Page_Load(object sender, EventArgs e)
{
get_totals();
DropNetClient _client = new DropNetClient(_settings.dropbox_api_key(), _settings.dropbox_api_secret());
permissions();
if (Session["request_token"] != null)
{
Event ev = _events.@select(Convert.ToInt32(Session["dropbox_event_id"] as string));
_client.UserLogin = Session["request_token"] as DropNet.Models.UserLogin;
var access_token = _client.GetAccessToken();
var account_info = _client.AccountInfo();
ev.request_token = access_token.Token.ToString();
ev.access_token = access_token.Secret.ToString();
ev.dropbox_country = account_info.country;
ev.dropbox_email = account_info.email;
ev.dropbox_quota = account_info.quota_info.quota.ToString();
ev.dropbox_referral = account_info.referral_link;
ev.dropbox_uid = account_info.uid;
ev.dropbox_username = account_info.display_name;
ev = _events.update(ev);
username.Attributes.Add("placeholder", account_info.display_name);
email.Attributes.Add("placeholder", ev.dropbox_email);
quota.Attributes.Add("placeholder", ev.dropbox_quota);
referral.Attributes.Add("placeholder", ev.dropbox_referral);
uid.Attributes.Add("placeholder", ev.dropbox_uid.ToString());
country.Attributes.Add("placeholder", ev.dropbox_country);
}
else
{
Response.Redirect("/events");
}
}
private void LoadData()
{
try
{
if (!string.IsNullOrEmpty(AccessToken))
{
_client = new DropNetClient(AppKey, AppSecret, AccessToken, Secret);
var data = _client.AccountInfo();
UserName = data.display_name;
IsLogedIn = true;
}
else
{
IsLogedIn = false;
}
}
catch (Exception)
{
IsLogedIn = false;
}
}
public ActionResult ConnectCallBack()
{
try
{
dropNetClient.UserLogin = UserLoginInfo;
var dropboxAccessToken = dropNetClient.GetAccessToken();
var accountInfo = dropNetClient.AccountInfo();
CurrentUser.DropboxAccount = new DropboxAccount
{
ConnectingDate = DateTime.UtcNow,
Enabled = true,
UserSecret = dropboxAccessToken.Secret,
UserToken = dropboxAccessToken.Token,
AccountName = accountInfo.display_name
};
UnitOfWork.Commit();
}
catch
{
ModelState.AddModelError("", "Can't connect to DropBox.");
}
return(RedirectToAction <UserController>(c => c.Index()));
}