private void bg_bgAppUpdateLog_DoWork(object sender, DoWorkEventArgs e)
{
config = DropBoxConfiguration.GetStandardConfiguration();
if (IsolatedStorageFile.GetUserStoreForApplication().FileExists(FileName))
{
token = LoadAccessTokenFromIsolatedStorage();
}
else
{
requestToken = DropBoxStorageProviderTools.GetDropBoxRequestToken(config, APP_KEY, APP_SECRET);
//Put a breakpoint in the next line and make sure to visit AuthorizationUrl manually in the web browser
String AuthorizationUrl = DropBoxStorageProviderTools.GetDropBoxAuthorizationUrl(config, requestToken);
token = DropBoxStorageProviderTools.ExchangeDropBoxRequestTokenIntoAccessToken(config, APP_KEY, APP_SECRET, requestToken);
}
m_dropBox.Open(config, token);
//// get a specific directory in the cloud storage, e.g. /Public
//var publicFolder = cloudStorage.GetFolder("/Photos");
//foreach (var fof in publicFolder)
//{
// //check if we have a directory
// Boolean bIsDirectory = fof is ICloudDirectoryEntry;
// //output the info
// Debug.WriteLine("{0}: {1}", bIsDirectory ? "DIR" : "FIL", fof.Name);
//}
//cloudStorage.Close();
}
protected void Page_Load(object sender, EventArgs e)
{
if (Session.IsReadOnly)
{
SubmitError("No session is availible.", Source);
return;
}
var config = CloudStorage.GetCloudConfigurationEasy(nSupportedCloudConfigurations.DropBox) as DropBoxConfiguration;
var callbackUri = new UriBuilder(Request.GetUrlRewriter());
if (!string.IsNullOrEmpty(Request.QueryString[AuthorizationUrlKey]) && Session[RequestTokenSessionKey] != null)
{
//Authorization callback
try
{
var accessToken = DropBoxStorageProviderTools.ExchangeDropBoxRequestTokenIntoAccessToken(config,
ImportConfiguration.DropboxAppKey,
ImportConfiguration.DropboxAppSecret,
Session[RequestTokenSessionKey] as DropBoxRequestToken);
Session[RequestTokenSessionKey] = null; //Exchanged
var storage = new CloudStorage();
var base64token = storage.SerializeSecurityTokenToBase64Ex(accessToken, config.GetType(), new Dictionary <string, string>());
storage.Open(config, accessToken); //Try open storage!
var root = storage.GetRoot();
if (root == null)
{
throw new Exception();
}
SubmitToken(base64token, Source);
}
catch
{
SubmitError("Failed to open storage with token", Source);
}
}
else
{
callbackUri.Query += string.Format("&{0}=1", AuthorizationUrlKey);
config.AuthorizationCallBack = callbackUri.Uri;
// create a request token
var requestToken = DropBoxStorageProviderTools.GetDropBoxRequestToken(config, ImportConfiguration.DropboxAppKey,
ImportConfiguration.DropboxAppSecret);
if (requestToken == null)
{
SubmitError("Failed to open storage with this credentials", Source);
return;
}
var authorizationUrl = DropBoxStorageProviderTools.GetDropBoxAuthorizationUrl(config, requestToken);
Session[RequestTokenSessionKey] = requestToken; //Store token into session!!!
Response.Redirect(authorizationUrl);
}
}
public ulong GetAvailableMemory()
{
if (_accessToken == null)
{
throw new InvalidOperationException("Connection is not established.");
}
var quotaInfo = DropBoxStorageProviderTools.GetAccountInformation(_accessToken).QuotaInfo;
return(quotaInfo.QuotaBytes - quotaInfo.NormalBytes);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Session.IsReadOnly)
{
SubmitError("No session is availible.", Source);
return;
}
if (Boolean.TrueString.Equals(Request.QueryString[AuthorizationNotApproved] ?? "false", StringComparison.InvariantCultureIgnoreCase))
{
SubmitError("Canceled at provider", Source);
return;
}
if (!string.IsNullOrEmpty(Request.QueryString[AuthorizationUrlKey]) && Session[RequestTokenSessionKey] != null)
{
//Authorization callback
try
{
var dropboxToken = Session[RequestTokenSessionKey] as DropBoxRequestToken;
SubmitToken(dropboxToken.ToString(), Source);
}
catch
{
SubmitError("Failed to open storage with token", Source);
}
}
else
{
var callbackUri = new UriBuilder(Request.GetUrlRewriter());
callbackUri.Query += string.Format("&{0}=1", AuthorizationUrlKey);
var config = CloudStorage.GetCloudConfigurationEasy(nSupportedCloudConfigurations.DropBox) as DropBoxConfiguration;
config.AuthorizationCallBack = callbackUri.Uri;
// create a request token
var requestToken = DropBoxStorageProviderTools.GetDropBoxRequestToken(config,
ImportConfiguration.DropboxAppKey,
ImportConfiguration.DropboxAppSecret);
if (requestToken == null)
{
SubmitError("Failed to open storage with this credentials", Source);
return;
}
Session[RequestTokenSessionKey] = requestToken; //Store token into session!!!
var authorizationUrl = DropBoxStorageProviderTools.GetDropBoxAuthorizationUrl(config, requestToken);
Response.Redirect(authorizationUrl);
}
}
string UploadDownlaodable(HttpContext context, CloudStorage storage, string newFileName, string albumId)
{
var downloadFolder = storage.EnsureDownloadFolder(albumId);
using (var img = Image.FromStream(context.Request.InputStream))
{
using (var photoStream = img.ResampleAsStream(img.Width, img.Height))
{
photoStream.Position = 0;
storage.UploadFile(photoStream, newFileName, downloadFolder);
}
}
return(DropBoxStorageProviderTools.GetPublicObjectUrl(storage.CurrentAccessToken,
storage.GetFileSystemObject(newFileName, downloadFolder)).AbsoluteUri);
}
public CloudService(Config config)
{
_config = config;
_storageConfiguration = DropBoxConfiguration.GetStandardConfiguration();
var requestToken = DropBoxStorageProviderTools.GetDropBoxRequestToken(_storageConfiguration,
_config.Cloud.ConsumerKey,
_config.Cloud.ConsumerSecret);
_accessToken = DropBoxStorageProviderTools.ExchangeDropBoxRequestTokenIntoAccessToken(_storageConfiguration,
_config.Cloud.ConsumerKey,
_config.Cloud.ConsumerSecret,
requestToken);
}
private void SetUpDropbox()
{
AllowClose = false;
_UsedConfig = DropBoxConfiguration.GetStandardConfiguration();
_UsedConfig.AuthorizationCallBack = new Uri("http://better-explorer.com/");
_UsedConfig.APIVersion = DropBoxAPIVersion.V1;
_CurrentRequestToken = DropBoxStorageProviderTools.GetDropBoxRequestToken(_UsedConfig, Networks.DropBoxAuth.Key, Networks.DropBoxAuth.Secret);
string AuthUrl = DropBoxStorageProviderTools.GetDropBoxAuthorizationUrl(_UsedConfig, _CurrentRequestToken);
this.Navigated += HandleDropboxAuth;
this.NavigateTo(AuthUrl);
MainMenu.Visibility = System.Windows.Visibility.Collapsed;
this.Width = 900;
this.Height = 650;
BrowserFrame.Visibility = System.Windows.Visibility.Visible;
}
string UploadThumbnail(HttpContext context, CloudStorage storage, string newFileName, string albumId)
{
context.Request.InputStream.Position = 0;
var thumbFolder = storage.EnsureThumbFolder(albumId);
using (var img = Image.FromStream(context.Request.InputStream))
{
using (var thumStream = img.ResampleAsStream(192, 119))
{
thumStream.Position = 0;
storage.UploadFile(thumStream, newFileName, thumbFolder);
}
}
return(DropBoxStorageProviderTools.GetPublicObjectUrl(storage.CurrentAccessToken,
storage.GetFileSystemObject(newFileName, thumbFolder)).AbsoluteUri);
}
private void HandleDropboxAuth(object sender, NavigationRoutedEventArgs e)
{
if (_GeneratedToken == null && e.Uri.ToString().StartsWith(_UsedConfig.AuthorizationCallBack.ToString()))
{
_GeneratedToken = DropBoxStorageProviderTools.ExchangeDropBoxRequestTokenIntoAccessToken(_UsedConfig, Networks.DropBoxAuth.Key, Networks.DropBoxAuth.Secret, _CurrentRequestToken);
(sender as Window).Close();
CloudStorage cs = new CloudStorage();
cs.Open(_UsedConfig, _GeneratedToken);
Complete(cs.IsOpened, "Dropbox");
//cs.SerializeSecurityToken(_GeneratedToken);
cs.Close();
}
//throw new NotImplementedException();
}
/// <summary>
/// Creates a connection to the cloud storage.
/// </summary>
/// <param name="key">Application key.</param>
/// <param name="secret">Application secret.</param>
/// <returns>False if the connection is already established
/// or a user is not authorized on the website.</returns>
public bool CreateConnection(string key, string secret)
{
if (_accessToken == null)
{
try
{
_accessToken =
DropBoxStorageProviderTools.ExchangeDropBoxRequestTokenIntoAccessToken(_configuration, key,
secret, _requestToken);
return(true);
}
catch (UnauthorizedAccessException)
{
return(false);
}
}
return(false);
}
public DropBoxCloudStorageManager(string key, string secret)
{
_configuration =
CloudStorage.GetCloudConfigurationEasy(nSupportedCloudConfigurations.DropBox) as DropBoxConfiguration;
_configuration.AuthorizationCallBack = new Uri("https://www.dropbox.com/home");
_requestToken = DropBoxStorageProviderTools.GetDropBoxRequestToken(_configuration, key, secret);
try
{
_authorizationUrl =
DropBoxStorageProviderTools.GetDropBoxAuthorizationUrl(_configuration, _requestToken);
}
catch (NullReferenceException)
{
throw new ArgumentException("Invalid application key and/or secret");
}
_cloudStorage = new CloudStorage();
ApplicationFolderPath = "/";
}
private static AuthData GetEncodedAccesToken(AuthData authData, ProviderTypes provider)
{
switch (provider)
{
case ProviderTypes.GoogleDrive:
var code = authData.Token;
var token = OAuth20TokenHelper.GetAccessToken(GoogleLoginProvider.GoogleOauthTokenUrl,
GoogleLoginProvider.GoogleOAuth20ClientId,
GoogleLoginProvider.GoogleOAuth20ClientSecret,
GoogleLoginProvider.GoogleOAuth20RedirectUrl,
code);
if (token == null)
{
throw new UnauthorizedAccessException(string.Format(FilesCommonResource.ErrorMassage_SecurityException_Auth, provider));
}
return(new AuthData(token: token.ToJson()));
case ProviderTypes.Box:
code = authData.Token;
token = OAuth20TokenHelper.GetAccessToken(BoxLoginProvider.BoxOauthTokenUrl,
BoxLoginProvider.BoxOAuth20ClientId,
BoxLoginProvider.BoxOAuth20ClientSecret,
BoxLoginProvider.BoxOAuth20RedirectUrl,
code);
if (token == null)
{
throw new UnauthorizedAccessException(string.Format(FilesCommonResource.ErrorMassage_SecurityException_Auth, provider));
}
return(new AuthData(token: token.ToJson()));
case ProviderTypes.DropboxV2:
code = authData.Token;
token = OAuth20TokenHelper.GetAccessToken(DropboxLoginProvider.DropboxOauthTokenUrl,
DropboxLoginProvider.DropboxOAuth20ClientId,
DropboxLoginProvider.DropboxOAuth20ClientSecret,
DropboxLoginProvider.DropboxOAuth20RedirectUrl,
code);
if (token == null)
{
throw new UnauthorizedAccessException(string.Format(FilesCommonResource.ErrorMassage_SecurityException_Auth, provider));
}
return(new AuthData(token: token.ToJson()));
case ProviderTypes.DropBox:
var dropBoxRequestToken = DropBoxRequestToken.Parse(authData.Token);
var config = CloudStorage.GetCloudConfigurationEasy(nSupportedCloudConfigurations.DropBox);
var accessToken = DropBoxStorageProviderTools.ExchangeDropBoxRequestTokenIntoAccessToken(config as DropBoxConfiguration,
ImportConfiguration.DropboxAppKey,
ImportConfiguration.DropboxAppSecret,
dropBoxRequestToken);
var base64Token = new CloudStorage().SerializeSecurityTokenToBase64Ex(accessToken, config.GetType(), new Dictionary <string, string>());
return(new AuthData(token: base64Token));
case ProviderTypes.SkyDrive:
code = authData.Token;
token = OAuth20TokenHelper.GetAccessToken(OneDriveLoginProvider.OneDriveOauthTokenUrl,
OneDriveLoginProvider.OneDriveOAuth20ClientId,
OneDriveLoginProvider.OneDriveOAuth20ClientSecret,
OneDriveLoginProvider.OneDriveOAuth20RedirectUrl,
code);
if (token == null)
{
throw new UnauthorizedAccessException(string.Format(FilesCommonResource.ErrorMassage_SecurityException_Auth, provider));
}
accessToken = AppLimit.CloudComputing.SharpBox.Common.Net.oAuth20.OAuth20Token.FromJson(token.ToJson());
if (accessToken == null)
{
throw new UnauthorizedAccessException(string.Format(FilesCommonResource.ErrorMassage_SecurityException_Auth, provider));
}
config = CloudStorage.GetCloudConfigurationEasy(nSupportedCloudConfigurations.SkyDrive);
var storage = new CloudStorage();
base64Token = storage.SerializeSecurityTokenToBase64Ex(accessToken, config.GetType(), new Dictionary <string, string>());
return(new AuthData(token: base64Token));
case ProviderTypes.SharePoint:
case ProviderTypes.WebDav:
break;
default:
authData.Url = null;
break;
}
return(authData);
}
internal static CloudStorage InitCouldStorage(Form1 form, CloudStorage cloudStorage)
{
if (IsCloudStorageOpen(cloudStorage))
{
return(cloudStorage);
}
ToolStripStatusLabel toolStripStatusLabel = form.toolStripStatusLabel;
try
{
if (ConfigUtil.GetBoolParameter("ProxyEnabled"))
{
if (String.IsNullOrEmpty(ConfigUtil.GetStringParameter("ProxyHost")))
{
WindowManager.ShowAlertBox(form, LanguageUtil.GetCurrentLanguageString("ProxyHostRequired", className));
return(null);
}
WebRequestManager.Instance.SetProxySettings(ConfigUtil.GetStringParameter("ProxyHost"), ConfigUtil.GetIntParameter("ProxyPort"), ProxyUtil.InitNetworkCredential());
}
DropBoxConfiguration standardConfiguration = DropBoxConfiguration.GetStandardConfiguration();
try //I try to authenticate myself with previous access token
{
using (Stream tokenStream = new MemoryStream(Encoding.UTF8.GetBytes(PasswordUtil.GetStringParameter("LastDropboxAccessToken")))) //ConfigUtil.GetStringParameter("LastDropboxAccessToken")
{
if (tokenStream.Length == 0)
{
throw new UnauthorizedAccessException();
}
cloudStorage = new CloudStorage();
cloudStorage.Open(standardConfiguration, cloudStorage.DeserializeSecurityToken(tokenStream)); //cloudStorage.DeserializeSecurityToken(tokenStream, standardConfiguration)
}
}
catch (Exception) //No way, I should renew my access token
{
standardConfiguration.AuthorizationCallBack = new Uri(ConstantUtil.dropboxAuthUrl);
DropBoxRequestToken requestToken = DropBoxStorageProviderTools.GetDropBoxRequestToken(standardConfiguration, ConstantUtil.dropboxConsumerKey, ConstantUtil.dropboxConsumerSecret);
if (requestToken == null)
{
throw new UnauthorizedAccessException();
}
if (WindowManager.ShowInternalBrowser(form, DropBoxStorageProviderTools.GetDropBoxAuthorizationUrl(standardConfiguration, requestToken)) == DialogResult.Cancel)
{
return(null);
}
//OtherManager.StartProcess(form, DropBoxStorageProviderTools.GetDropBoxAuthorizationUrl(standardConfiguration, requestToken));
//if (WindowManager.ShowQuestionBox(form, LanguageUtil.GetCurrentLanguageString("SuccessfullyAuth", className)) != DialogResult.Yes)
//{
// return null;
//}
ICloudStorageAccessToken accessToken = DropBoxStorageProviderTools.ExchangeDropBoxRequestTokenIntoAccessToken(standardConfiguration, ConstantUtil.dropboxConsumerKey, ConstantUtil.dropboxConsumerSecret, requestToken);
if (accessToken == null)
{
throw new UnauthorizedAccessException();
}
cloudStorage = new CloudStorage();
cloudStorage.Open(standardConfiguration, accessToken);
if (ConfigUtil.GetBoolParameter("RememberDropboxAccess"))
{
using (Stream tokenStream = cloudStorage.SerializeSecurityToken(accessToken))
{
PasswordUtil.UpdateParameter("LastDropboxAccessToken", new StreamReader(tokenStream).ReadToEnd()); //ConfigUtil.UpdateParameter("LastDropboxAccessToken", new StreamReader(tokenStream).ReadToEnd());
}
}
else
{
PasswordUtil.UpdateParameter("LastDropboxAccessToken", String.Empty); //ConfigUtil.UpdateParameter("LastDropboxAccessToken", String.Empty);
}
toolStripStatusLabel.Text = LanguageUtil.GetCurrentLanguageString("DropboxLogIn", className);
}
return(cloudStorage);
}
catch (UnauthorizedAccessException)
{
WindowManager.ShowAlertBox(form, LanguageUtil.GetCurrentLanguageString("UnauthorizedAccess", className));
return(null);
}
catch (UriFormatException)
{
WindowManager.ShowAlertBox(form, LanguageUtil.GetCurrentLanguageString("UriFormat", className));
return(null);
}
finally
{
form.Cursor = Cursors.Default;
}
}
