private void uploadToCloud(string filename, string uploadFileName, Stream fileStream, Message msg, Channel chan, string file)
{
if (filename.EndsWith("png") || filename.EndsWith("jpeg") || filename.EndsWith("jpg") || filename.EndsWith("gif") || filename.EndsWith("bmp"))
{
try
{
msg.Type = MessageTypes.Image;
var configuration = new AccountConfiguration("hscl3sr21", "773858917884263", "RWVBnZhCDPyOrKAYihbubppmZ4E");
var uploader = new Uploader(configuration);
string publicId = Path.GetFileNameWithoutExtension(filename);
var uploadResult = uploader.Upload(new UploadInformation(filename, fileStream)
{
PublicId = publicId,
Format = filename.Substring(filename.Length - 3),
});
//msg.Content = uploadResult.Url;
msg.Content = filename;
}
catch (Exception ex)
{
//context.Response.Write("{ 'success': " + ex.Message + " }");
return;
}
}
else
{
//upload to dropbox
string cloudPath = "/" + chan.Name + "/" + filename;
var result = _sessionState.DropboxShareFile(file, cloudPath);
//_sessionState.AuthClient();
//var result = _sessionState.DropboxClient.UploadFileAsync(new FileResource(file), cloudPath).Result;
msg.Content = result;//cloudPath;
}
}
public async Task <AccountConfiguration> CreateAccount()
{
_oAuthHelper = new OAuthHelper();
var isOk = OAuth2Flow.TryAuthenticate(this);
if (!isOk)
{
return(null);
}
var api = await OneDriveHelper.GetApi(_accountSession);
var drive = await api.Drive.Request().GetAsync().ConfigureAwait(false);
var account = new AccountConfiguration
{
Type = StorageType.OneDrive,
Name = drive.Owner.User.DisplayName,
Id = drive.Owner.User.Id,
Secret = _accountSession.RefreshToken
};
return(account);
}
public ActionResult Edit(int?id)
{
try
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AccountConfiguration accountconfiguration = configRepo.GetById((int)id);
if (accountconfiguration == null)
{
return(HttpNotFound());
}
ViewBag.SavingsInterestExpenseGl_GlAccountId = new SelectList(glaRepo.GetByMainCategory(MainGlCategory.Expenses), "ID", "AccountName", accountconfiguration.SavingsInterestExpenseGl != null ? accountconfiguration.SavingsInterestExpenseGl.ID : 0);
ViewBag.SavingsInterestPayableGl_Id = new SelectList(glaRepo.GetByMainCategory(MainGlCategory.Liability), "ID", "AccountName", accountconfiguration.SavingsInterestPayableGl != null ? accountconfiguration.SavingsInterestPayableGl.ID : 0);
ViewBag.CurrentIntExpGlId = new SelectList(glaRepo.GetByMainCategory(MainGlCategory.Expenses), "ID", "AccountName", accountconfiguration.CurrentInterestExpenseGl != null ? accountconfiguration.CurrentInterestExpenseGl.ID : 0);
ViewBag.CurrentCotIncGlId = new SelectList(glaRepo.GetByMainCategory(MainGlCategory.Income), "ID", "AccountName", accountconfiguration.CurrentCotIncomeGl != null ? accountconfiguration.CurrentCotIncomeGl.ID : 0);
ViewBag.LoanIntIncomeGlId = new SelectList(glaRepo.GetByMainCategory(MainGlCategory.Income), "ID", "AccountName", accountconfiguration.LoanInterestIncomeGl != null ? accountconfiguration.LoanInterestIncomeGl.ID : 0);
//ViewBag.LoanIntExpGlId = new SelectList(glaRepo.GetByMainCategory(MainGlCategory.Expenses), "ID", "AccountName", accountconfiguration.LoanInterestExpenseGl != null ? accountconfiguration.LoanInterestExpenseGl.ID : 0);
ViewBag.LoanInterestReceivableGl_Id = new SelectList(glaRepo.GetByMainCategory(MainGlCategory.Asset), "ID", "AccountName", accountconfiguration.LoanInterestReceivableGl != null ? accountconfiguration.LoanInterestReceivableGl.ID : 0);
return(View(accountconfiguration));
}
catch (Exception)
{
//ErrorLogger.Log("Message= " + ex.Message + "\nInner Exception= " + ex.InnerException + "\n");
return(PartialView("Error"));
}
}
public EmailVerifier(AccountConfiguration config, AccountRepository repo)
{
if (config == null) throw new ArgumentNullException("config");
this.config = config;
this.repo = new AccountRepositoryWrapper(config.RequireDependency(repo));
}
static void Main(string[] args)
{
string filename = string.Empty;
bool showHelp = false;
var options = new OptionSet()
{
{ "filename=|f=", "File to upload",(v) => filename = v },
{ "help|h", "Show help",(v) => showHelp = true }
};
options.Parse(args);
if(string.IsNullOrEmpty(filename) || showHelp)
{
options.WriteOptionDescriptions(Console.Out);
return;
}
if (!File.Exists(filename))
{
Console.WriteLine("File does not exist. Exiting...");
return;
}
var settings = ConfigurationManager.AppSettings;
var configuration = new AccountConfiguration(settings["cloudinary.cloud"],
settings["cloudinary.apikey"],
settings["cloudinary.apisecret"]);
var uploader = new Uploader(configuration);
string publicId = Path.GetFileNameWithoutExtension(filename);
using(var stream =new FileStream(filename, FileMode.Open))
{
var uploadResult = uploader.Upload(new UploadInformation(filename, stream)
{
PublicId = publicId,
Transformation = new Transformation(120, 120)
{
Crop = CropMode.Scale
},
Eager = new[]
{
new Transformation(240, 240),
new Transformation(120, 360) { Crop = CropMode.Limit },
}
});
Console.WriteLine("Version: {0}, PublicId {1}", uploadResult.Version, uploadResult.PublicId);
Console.WriteLine("Url: {0}", uploadResult.Url);
}
Console.WriteLine("Successfully uploaded file");
uploader.Destroy(publicId);
if(Debugger.IsAttached)
Console.ReadLine();
}
public async Task <AccountConfiguration> CreateAccount()
{
var isOk = OAuth2Flow.TryAuthenticate(this);
if (!isOk)
{
return(null);
}
var api = await GoogleDriveHelper.GetClient(_token);
var query = api.About.Get();
query.Fields = "user";
var about = await query.ExecuteAsync();
var account = new AccountConfiguration()
{
Type = StorageType.GoogleDrive,
Id = about.User.PermissionId,
Name = about.User.DisplayName,
Secret = _token.RefreshToken
};
return(account);
}
public async Task <AccountConfiguration> CreateAccount()
{
var isOk = OAuth2Flow.TryAuthenticate(this);
if (!isOk)
{
return(null);
}
var client = HiDriveHelper.GetClient(_authenticator);
//var fields = new[]
//{
// User.Fields.Account, User.Fields.Alias, User.Fields.Description, User.Fields.Protocols, User.Fields.IsAdmin,
// User.Fields.EMail, User.Fields.IsEncrypted, User.Fields.Home, User.Fields.HomeId, User.Fields.IsOwner, User.Fields.Language,
//};
var user = await client.User.Me.Get().ExecuteAsync();
var account = new AccountConfiguration()
{
Type = StorageType.HiDrive,
Id = user.Account,
Name = user.Alias,
Secret = _authenticator.Token.RefreshToken,
};
return(account);
}
static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var accountConfig = new AccountConfiguration();
var projectConfig = new ProjectConfiguration();
config.GetSection("Account").Bind(accountConfig);
config.GetSection("Project").Bind(projectConfig);
Console.WriteLine($"{accountConfig.Username} {accountConfig.Email} {accountConfig.Website}");
Console.WriteLine($"{projectConfig.ProjectName} {projectConfig.GithubUrl}");
var services = new ServiceCollection()
.AddOptions()
.Configure <AccountConfiguration>(config.GetSection("Account"))
.Configure <ProjectConfiguration>(config.GetSection("Project"))
.AddScoped(cfg => cfg.GetService <IOptions <AccountConfiguration> >().Value)
.AddScoped(cfg => cfg.GetService <IOptions <ProjectConfiguration> >().Value)
.BuildServiceProvider();
var accountConfig2 = services.GetService <AccountConfiguration>();
var projectConfig2 = services.GetService <ProjectConfiguration>();
Console.WriteLine($"{accountConfig2.Username} {accountConfig2.Email} {accountConfig2.Website}");
Console.WriteLine($"{projectConfig2.ProjectName} {projectConfig2.GithubUrl}");
}
/// <summary>
/// Создаем запись в таблице AccountConfiguration
/// </summary>
/// <returns></returns>
public static void CreateNoteInAccountConfiguration(Guid accId)
{
AccountConfiguration accConf = new AccountConfiguration();
accConf.Id = accId;
accConf.LastTspTestDate = DateTime.Now;
accConf.TspTested = false;
accConf.TspService = "test";
accConf.RufrSynchronization = true;
accConf.UsedDiscSpace = 10234494;
accConf.PersonalAccountPacketSize = 9999999;
accConf.TotalPacketSize = 2147483648;
accConf.PersonalAccountQuota = 9999999;
accConf.TotalQuota = 5368709120;
accConf.CryptographyType = CryptographyTypes.Russian;
try
{
using (var context = new DatabaseContext())
{
context.Set <AccountConfiguration>().Add(accConf);
context.SaveChanges();
}
}
catch
{
Console.WriteLine($"Не удалось сохранить аккаунт в БД");
}
}
private async Task Loged(AccountConfiguration account)
{
Header.TabItems.Clear();
foreach (var wallet in account.Wallets)
{
if (wallet.IsActive)
{
var tabItem = new Models.TabItem()
{
Name = wallet.Name,
IsSelected = false,
};
var walletProvider = new Iota.IotaWalletManager(wallet, tabItem);
tabItem.Selected = (t) => View = walletProvider.Wallet;
Header.TabItems.Add(tabItem);
}
}
var tab = Header.TabItems.FirstOrDefault();
if (tab != null)
{
tab.IsSelected = true;
}
else
{
View = null;
}
}
private void uploadToCloud(string filename, string uploadFileName, Stream fileStream, Message msg, Channel chan, string file)
{
if (filename.EndsWith("png") || filename.EndsWith("jpeg") || filename.EndsWith("jpg") || filename.EndsWith("gif") || filename.EndsWith("bmp"))
{
try
{
msg.Type = MessageTypes.Image;
var configuration = new AccountConfiguration("saykor", "277334748579534", "mUjzZ-X3jOuNKGswrAjocB-D-Rc");
var uploader = new Uploader(configuration);
string publicId = Path.GetFileNameWithoutExtension(filename);
var uploadResult = uploader.Upload(new UploadInformation(filename, fileStream)
{
PublicId = publicId,
Format = filename.Substring(filename.Length - 3),
});
//msg.Content = uploadResult.Url;
msg.Content = filename;
}
catch (Exception ex)
{
//context.Response.Write("{ 'success': " + ex.Message + " }");
return;
}
}
else
{
//upload to dropbox
string cloudPath = "/" + chan.Name + "/" + filename;
_sessionState.AuthClient();
var result = _sessionState.DropboxClient.UploadFileAsync(new FileResource(file), cloudPath).Result;
msg.Content = cloudPath;
}
}
private void gestionDeAccountsToolStripMenuItem_Click(object sender, EventArgs e)
{
using (GestionAccounts gestion_cuentas = new GestionAccounts())
{
if (gestion_cuentas.ShowDialog() == DialogResult.OK)
{
List <AccountConfiguration> cuentas_para_cargar = gestion_cuentas.get_Accounts_Cargadas();
if (cuentas_para_cargar.Count < 2)
{
AccountConfiguration cuentaConfiguration = cuentas_para_cargar[0];
cuentas_cargadas.Add(cuentaConfiguration.nombre_cuenta, agregar_Nueva_Tab_Pagina(cuentaConfiguration.nombre_cuenta, new UI_Principal(new Account(cuentaConfiguration)), "Ninguno"));
}
else
{
AccountConfiguration configuracion_lider = cuentas_para_cargar.First();
Account lider = new Account(configuracion_lider);
Grupo grupo = new Grupo(lider);
cuentas_cargadas.Add(configuracion_lider.nombre_cuenta, agregar_Nueva_Tab_Pagina(configuracion_lider.nombre_cuenta, new UI_Principal(lider), configuracion_lider.nombre_cuenta));
cuentas_para_cargar.Remove(configuracion_lider);
foreach (AccountConfiguration cuenta_conf in cuentas_para_cargar)
{
Account cuenta = new Account(cuenta_conf);
grupo.agregar_Miembro(cuenta);
cuentas_cargadas.Add(cuenta_conf.nombre_cuenta, agregar_Nueva_Tab_Pagina(cuenta_conf.nombre_cuenta, new UI_Principal(cuenta), grupo.Leader.AccountConfiguration.nombre_cuenta));
}
}
}
}
}
private static string GetBaseUrl(AccountConfiguration accountConfiguration)
{
if (accountConfiguration.SharedCdn)
return "http://res.cloudinary.com/" + accountConfiguration.CloudName;
return string.Format("http://{0}-res.cloudinary.com/", accountConfiguration.CloudName);
}
public async Task <AccountConfiguration> CreateAccount()
{
var dlg = new AmazonS3AccountForm();
var result = UIUtil.ShowDialogAndDestroy(dlg);
if (result != DialogResult.OK)
{
return(null);
}
var account = new AccountConfiguration
{
Type = StorageType.AmazonS3,
Id = dlg.AccessKey,
Name = "S3 Account",
Secret = dlg.SecretKey,
};
account.AdditionalSettings = new Dictionary <string, string>()
{
{ "AWSRegion", dlg.AWSRegion.SystemName }
};
account.AdditionalSettings.Add("UseSessionToken", Convert.ToString(dlg.UseSessionToken));
account.AdditionalSettings.Add("SessionToken", dlg.SessionToken);
return(account);
}
public async Task <AccountConfiguration> CreateAccount_Oidc()
{
var f = new OidcWaitForm();
f.InitEx(StorageType.HiDrive);
f.Show();
var browser = new OidcSystemBrowser(Enumerable.Range(50001, 50020));
var redirectUri = browser.RedirectUri;
var uri = _authenticator.GetAuthorizationCodeRequestUrl(new AuthorizationScope(AuthorizationRole.User, AuthorizationPermission.ReadWrite), redirectUri);
var query = await browser.GetQueryStringAsync(uri.ToString(), f.CancellationToken);
var code = query["code"];
var token = await _authenticator.AuthenticateByAuthorizationCodeAsync(code);
var client = HiDriveHelper.GetClient(_authenticator);
var user = await client.User.Me.Get().ExecuteAsync();
var account = new AccountConfiguration()
{
Type = StorageType.HiDrive,
Id = user.Account,
Name = user.Alias,
Secret = _authenticator.Token.RefreshToken,
};
f.Close();
return(account);
}
public static AmazonS3Client GetApi(AccountConfiguration account)
{
AWSCredentials credentials;
if (account.AdditionalSettings != null && account.AdditionalSettings.ContainsKey("UseSessionToken") && Convert.ToBoolean(account.AdditionalSettings["UseSessionToken"]) == true && account.AdditionalSettings.ContainsKey("SessionToken"))
{
credentials = new SessionAWSCredentials(account.Id, account.Secret, account.AdditionalSettings["SessionToken"]);
}
else
{
credentials = new BasicAWSCredentials(account.Id, account.Secret);
}
var region = RegionEndpoint.USWest1;
if (account.AdditionalSettings != null && account.AdditionalSettings.ContainsKey("AWSRegion"))
{
var regionName = account.AdditionalSettings["AWSRegion"];
region = RegionEndpoint.GetBySystemName(regionName);
}
var api = GetApi(credentials, region);
return(api);
}
public async Task <AccountConfiguration> CreateAccount()
{
var dlg = new AzureAccountForm(_storageType);
var result = await Task.Run(() => UIUtil.ShowDialogAndDestroy(dlg));
if (result != DialogResult.OK)
{
return(null);
}
var configurationName = AzureResources.Configuration_Name_Blob;
if (_storageType == StorageType.AzureFile)
{
configurationName = AzureResources.Configuration_Name_File;
}
var account = new AccountConfiguration
{
Type = _storageType,
Id = configurationName,
Name = dlg.AccountName,
Secret = dlg.AccessToken,
AdditionalSettings = new Dictionary <string, string>()
{
{ "AzureItemName", dlg.ItemName }
}
};
return(account);
}
public Task UpdateAsync(AccountConfiguration configuration)
{
_configuration[configuration.CollectionId] = configuration;
File.WriteAllText(DatabaseFileName, JsonConvert.SerializeObject(_configuration));
return(Task.FromResult(0));
}
protected override void Seed(HealthTrackerContext context)
{
TenantConfiguration.Seed(context);
RoleConfiguration.Seed(context);
UserConfiguration.Seed(context);
AccountConfiguration.Seed(context);
ProfileConfiguration.Seed(context);
}
public AccountDataStore(AccountConfiguration account)
{
if (account == null)
{
throw new ArgumentNullException("account");
}
_account = account;
}
public Account(AccountConfiguration accountConfiguration)
{
AccountConfiguration = accountConfiguration;
Logger = new Logger();
Game = new Game.Game(this);
CombatExtensions = new CombatExtensions(this);
ScriptHandler = new ScriptHandler(this);
}
private async Task<CloudBlockBlob> GetBlob(AccountConfiguration account, string path)
{
var blobContainer = await GetContainer(account);
// Get specific blob reference
var blockBlob = blobContainer.GetBlockBlobReference(path);
return blockBlob;
}
public GoogleDriveStorageProvider(AccountConfiguration account)
{
if (account == null)
{
throw new ArgumentNullException("account");
}
_account = account;
}
public HubiCStorageProvider(AccountConfiguration account)
{
if (account == null)
{
throw new ArgumentNullException("account");
}
this._account = account;
}
public ActionResult DeleteConfirmed(int id)
{
AccountConfiguration accountConfiguration = db.AccountConfigurations.Find(id);
db.AccountConfigurations.Remove(accountConfiguration);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//public async Task<AccountConfiguration> CreateAccount()
//{
// var type = _isAccessRestricted ? StorageType.DropboxRestricted : StorageType.Dropbox;
// var clientId = _isAccessRestricted ? DropboxHelper.DropboxAppFolderOnlyClientId : DropboxHelper.DropboxFullAccessClientId;
// var clientSecret = _isAccessRestricted ? DropboxHelper.DropboxAppFolderOnlyClientSecret : DropboxHelper.DropboxFullAccessClientSecret;
// string[] scopes =
// {
// "account_info.read",
// "files.metadata.write",
// "files.metadata.read",
// "files.content.write",
// "files.content.read"
// };
// var flow = new OidcFlow(type, clientId, clientSecret, scopes, 50001, 50005);
// return await flow.AuthorizeOauth2Async("https://www.dropbox.com/oauth2/authorize", "https://api.dropboxapi.com/oauth2/token");
//}
public async Task <AccountConfiguration> CreateAccount()
{
var f = new OidcWaitForm();
f.InitEx(_isAccessRestricted ? StorageType.DropboxRestricted : StorageType.Dropbox);
f.Show();
var clientId = _isAccessRestricted ? DropboxHelper.DropboxAppFolderOnlyClientId : DropboxHelper.DropboxFullAccessClientId;
var clientSecret = _isAccessRestricted ? DropboxHelper.DropboxAppFolderOnlyClientSecret : DropboxHelper.DropboxFullAccessClientSecret;
string[] scopes =
{
"account_info.read",
"files.metadata.write",
"files.metadata.read",
"files.content.write",
"files.content.read"
};
var browser = new OidcSystemBrowser(50001, 50005);
var redirectUri = browser.RedirectUri;
var state = Guid.NewGuid().ToString("N");
var codeVerifier = db.DropboxOAuth2Helper.GeneratePKCECodeVerifier();
var codeChallenge = db.DropboxOAuth2Helper.GeneratePKCECodeChallenge(codeVerifier);
var uri = db.DropboxOAuth2Helper.GetAuthorizeUri(db.OAuthResponseType.Code, clientId, redirectUri, state, false, false, null, false, db.TokenAccessType.Offline, scopes, db.IncludeGrantedScopes.None, codeChallenge);
var query = await browser.GetQueryStringAsync(uri.ToString(), f.CancellationToken);
var resultState = query["state"];
if (state != resultState)
{
throw new Exception("MiM-Attack?");
}
var code = query["code"];
var response = await db.DropboxOAuth2Helper.ProcessCodeFlowAsync(code, clientId, null, redirectUri, null, codeVerifier);
var api = DropboxHelper.GetApi(response.AccessToken);
var owner = await api.Users.GetCurrentAccountAsync();
var account = new AccountConfiguration()
{
Id = owner.AccountId,
Name = owner.Name.DisplayName,
Type = _isAccessRestricted ? StorageType.DropboxRestricted : StorageType.Dropbox,
Secret = response.RefreshToken,
};
f.Close();
return(account);
}
public void Constructor_NotActivated_ShouldReturnNotActivated()
{
var projectId = Guid.NewGuid().ToString();
var accountConfiguration = new AccountConfiguration();
accountConfiguration.IsActivated(projectId).Should().BeFalse();
accountConfiguration.GetServiceHookIds(projectId).Should().BeEmpty();
}
public PasswordChanger(AccountConfiguration config, IAccountContext context, AccountRepository repo, PasswordService passServ)
{
if (config == null) throw new ArgumentNullException("config");
if (context == null) throw new ArgumentNullException("context");
this.context = context;
this.repo = new AccountRepositoryWrapper(config.RequireDependency(repo));
this.passServ = config.RequireDependency(passServ);
}
private void MainForm_Load(object sender, EventArgs e)
{
try
{
GlobalConfiguration.Instance.Initialize();
AccountConfiguration accountToConnect = null;
using (AccountsForm af = new AccountsForm())
{
if (af.ShowDialog() != DialogResult.OK)
{
Environment.Exit(-1);
}
accountToConnect = af.AccountToConnect;
}
Task.Factory.StartNew(() =>
{
CommandManager.Build();
ProtocolTypeManager.Initialize();
Logger.Default.OnLog += Logger_OnLog;
Settings.Default.DofusPath = GlobalConfiguration.Instance.DofusPath;
Settings.Default.Save();
MapsManager.Init(Settings.Default.DofusPath + @"\app\content\maps");
IconsManager.Instance.Initialize(Settings.Default.DofusPath + @"\app\content\gfx\items");
ObjectDataManager.Instance.AddReaders(Settings.Default.DofusPath + @"\app\data\common");
FastD2IReader.Instance.Init(Settings.Default.DofusPath + @"\app\data\i18n" +
"\\i18n_fr.d2i");
ImageManager.Init(Settings.Default.DofusPath);
}).ContinueWith(p =>
{
var fullSocketConfiguration = new FullSocketConfiguration
{
RealAuthHost = "213.248.126.40",
RealAuthPort = 443
};
var messageReceiver = new MessageReceiver();
messageReceiver.Initialize();
_fullSocket = new FullSocket.FullSocket(fullSocketConfiguration, messageReceiver);
var dispatcherTask = new DispatcherTask(new MessageDispatcher(), _fullSocket);
_account = _fullSocket.Connect(accountToConnect.Username, accountToConnect.Password, this);
});
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
Environment.Exit(-1);
}
}
public void DeactivateProject_NotActivated_ShouldReturnNotActivated()
{
var projectId = Guid.NewGuid().ToString();
var accountConfiguration = new AccountConfiguration();
accountConfiguration.Deactivate(projectId);
accountConfiguration.IsActivated(projectId).Should().BeFalse();
}
// GET: AccountConfig/EditSavings
public ActionResult EditSavings()
{
AccountConfiguration accountConfiguration = db.AccountConfigurations.First();
if (accountConfiguration == null)
{
return(HttpNotFound());
}
SetGetGlActViewBags(accountConfiguration);
return(View(accountConfiguration));
}
// GET: AccountConfig/Details
public ActionResult Details()
{
AccountConfiguration accountConfiguration = db.AccountConfigurations.First();
//AccountConfiguration accountConfiguration = db.AccountConfigurations.Include(a => a.CurrentCotIncomeGl).Include(a => a.CurrentInterestExpenseGl).Include(a => a.LoanInterestExpenseGl).Include(a => a.LoanInterestIncomeGl).Include(a => a.LoanInterestReceivableGl).Include(a => a.SavingsInterestExpenseGl).Include(a => a.SavingsInterestPayableGl).First();
if (accountConfiguration == null)
{
return(HttpNotFound());
}
return(View(accountConfiguration));
}
public EmailChanger(AccountConfiguration config, IAccountContext context, AccountRepository repo, PasswordService passwordService, FormsAuthenticationService formsAuthService)
{
if (config == null) throw new ArgumentNullException("config");
if (context == null) throw new ArgumentNullException("context");
this.config = config;
this.context = context;
this.repo = new AccountRepositoryWrapper(config.RequireDependency(repo));
this.passServ = config.RequireDependency(passwordService);
this.formsAuthService = config.RequireDependency(formsAuthService);
}
private async Task <CloudFile> GetFile(AccountConfiguration account, string path)
{
var fileShare = await GetShare(account);
// Get specific file
var rootDir = fileShare.GetRootDirectoryReference();
var directory = rootDir.GetDirectoryReference(path);
var file = directory.GetFileReference(path);
return(file);
}
async public Task <AccountConfiguration> AuthorizeAsync()
{
var f = CreateWaitForm();
f.Show();
var options = CreateBaseOptions();
var browser = CreateBrowser();
options.RedirectUri = browser.RedirectUri;
options.Browser = browser;
var client = new OidcClient(options);
LoginResult credential = null;
try
{
var request = new LoginRequest();
if (PrepareLoginRequest != null)
{
PrepareLoginRequest(request);
}
credential = await client.LoginAsync(request, f.CancellationToken);
}
catch (OperationCanceledException)
{
credential = null;
}
f.Close();
if (credential == null || credential.IsError)
{
MessageService.ShowWarning("Authorization failed:", credential.Error);
return(null);
}
var userId = credential.User.FindFirst(JwtClaimTypes.Subject).Value;
var userName = credential.User.FindFirst(JwtClaimTypes.Name).Value;
var refreshToken = credential.RefreshToken;
var account = new AccountConfiguration()
{
Type = this.m_type,
Id = userId,
Name = userName,
Secret = refreshToken
};
return(account);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
var settings = ConfigurationManager.AppSettings;
var configuration = new AccountConfiguration(settings["cloudinary.cloud"],
settings["cloudinary.apikey"],
settings["cloudinary.apisecret"]);
AccountConfiguration.Initialize(configuration);
}
/// <summary>
/// Initializes data that might not be available when the constructor is called.
/// </summary>
/// <param name="requestContext">The HTTP context and route data.</param>
protected override void Initialize(RequestContext requestContext)
{
base.Initialize(requestContext);
_Configuration = AccountConfiguration.Current(requestContext);
}
public static MvcHtmlString CloudinaryImage(this UrlHelper url, AccountConfiguration configuration, string publicId)
{
return CloudinaryImage(url, configuration, publicId, "jpg");
}
public static MvcHtmlString CloudinaryImage(this UrlHelper url, AccountConfiguration configuration, string publicId, string format)
{
string baseUrl = GetBaseUrl(configuration) + "/image/upload";
return _(string.Format("{0}/{1}.{2}", baseUrl, publicId, format));
}
public static MvcHtmlString CloudinaryImage(this UrlHelper url, AccountConfiguration configuration, string publicId, ITransformation transformation)
{
string baseUrl = GetBaseUrl(configuration) + "/image/upload";
return _(string.Format("{0}/{1}/{2}.{3}", baseUrl, transformation.ToCloudinary(), publicId, transformation.GetFormat()));
}
public EmailVerifier(AccountConfiguration config)
: this(config, null)
{
}
public PasswordChanger(AccountConfiguration config, IAccountContext context)
: this(config, context, null, null)
{
}
public EmailChanger(AccountConfiguration config, IAccountContext context)
: this(config, context, null, null, null)
{
}
