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) { }