public IActionResult Post([FromBody] CredentialViewModel param) { User requestor = _context.Users.SingleOrDefault(u => u.ApiKey == Request.Headers["X-ApiKey"]); if (requestor.IsAdmin) { if (ModelState.IsValid) { Credential cred = new Credential { UserName = param.UserName, Password = _cryptoService.Encrypt(param.Password) }; _context.Credentials.Add(cred); _context.SaveChanges(); return(Ok(cred)); } else { return(BadRequest(ModelState)); } } else { throw new Exception("Only administrator users can add new credentials."); } }
private void Vm_CredentialSelected(CredentialViewModel credVM) { var passStringLength = credVM?.PasswordFieldVM?.Value?.Length ?? 0; PasswordsControl.CredentialsDialog.PasswordFieldBox.Password = new string('*', passStringLength); PasswordsControl.CredentialsListBox.ScrollIntoView(credVM); }
public virtual CredentialViewModel DescribeCredential(Credential credential) { var kind = GetCredentialKind(credential.Type); Authenticator auther = null; if (kind == CredentialKind.External) { string providerName = credential.Type.Split('.')[1]; Authenticators.TryGetValue(providerName, out auther); } var credentialViewModel = new CredentialViewModel { Key = credential.Key, Type = credential.Type, TypeCaption = FormatCredentialType(credential.Type), Identity = credential.Identity, Created = credential.Created, Expires = credential.Expires, Kind = kind, AuthUI = auther?.GetUI(), // Set the description as the value for legacy API keys Description = credential.Description, Value = kind == CredentialKind.Token && credential.Description == null ? credential.Value : null, Scopes = credential.Scopes.Select(s => new ScopeViewModel(s.Subject, NuGetScopes.Describe(s.AllowedAction))).ToList(), ExpirationDuration = credential.ExpirationTicks != null ? new TimeSpan?(new TimeSpan(credential.ExpirationTicks.Value)) : null }; credentialViewModel.HasExpired = credential.HasExpired || (credentialViewModel.IsNonScopedV1ApiKey && !credential.HasBeenUsedInLastDays(_config.ExpirationInDaysForApiKeyV1)); return(credentialViewModel); }
private async void AddAction() { CustomDialog customDialog = new CustomDialog() { Title = Application.Current.Resources["String_Header_AddCredential"] as string }; CredentialViewModel credentialViewModel = new CredentialViewModel(instance => { dialogCoordinator.HideMetroDialogAsync(this, customDialog); CredentialInfo credentialInfo = new CredentialInfo { ID = instance.ID, Name = instance.Name, Username = instance.Username, Password = instance.Password }; CredentialManager.AddCredential(credentialInfo); TimerLockUIStart(); // Reset timer }, instance => { dialogCoordinator.HideMetroDialogAsync(this, customDialog); }, CredentialManager.GetNextID()); customDialog.Content = new CredentialDialog { DataContext = credentialViewModel }; await dialogCoordinator.ShowMetroDialogAsync(this, customDialog); }
public async Task <CredentialViewModel> Assemble(CredentialRecord credentialRecord) { if (credentialRecord == null) { return(null); } var context = await _agentContextProvider.GetContextAsync(); CredentialViewModel credential = _scope.Resolve <CredentialViewModel>(new NamedParameter("credential", credentialRecord)); var credentialDefinitionId = CredentialDefinitionId.Parse(credentialRecord.CredentialDefinitionId); credential.CredentialName = credentialDefinitionId.Tag; var connectionRecord = await _connectionService.GetAsync(context, credentialRecord.ConnectionId); credential.CredentialSubtitle = connectionRecord.Alias.Name; credential.IssuedAt = connectionRecord.CreatedAtUtc.HasValue ? connectionRecord.CreatedAtUtc.Value.ToLocalTime() : (DateTime?)null; if (credentialRecord.State == CredentialState.Offered) { var attributes = new List <CredentialAttribute>(); credential.Attributes = attributes; foreach (var credentialPreviewAttribute in credentialRecord.CredentialAttributesValues) { var attribute = new CredentialAttribute { Name = credentialPreviewAttribute.Name, Value = credentialPreviewAttribute.Value.ToString(), Type = "Text" }; attribute.Type = attribute.Value != null && (attribute.Value.ToString().StartsWith("data:image/jpeg;base64") || attribute.Value.ToString().StartsWith("data:image/png;base64")) ? "Image" : "Text"; attribute.Image = attribute.Value != null && (attribute.Value.ToString().StartsWith("data:image/jpeg;base64") || attribute.Value.ToString().StartsWith("data:image/png;base64")) ? ImageSource.FromStream(() => new MemoryStream(Convert.FromBase64String(attribute.Value.ToString().Replace("data:image/jpeg;base64,", "").Replace("data:image/png;base64,", "")))) : null; attributes.Add(attribute); } } return(credential); }
public bool Validate(int cardIndex = 0) { switch (cardIndex) { case 0: return(CredentialViewModel.Validate()); case 1: return(AccountViewModel.Validate()); case 2: return(true); // Optional case 3: return(UserViewModel.Validate()); case 4: return(PaymentViewModel.Validate()); case 5: return(false); default: return(false); } }
public async Task <IActionResult> Post([FromBody] CredentialViewModel credentials) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await GetUser(credentials.UserName, credentials.Password); if (user == null) { return(BadRequest(Errors.AddErrorToModelState("login failure", "Invalid username or password", ModelState))); } if (!await userManager.IsEmailConfirmedAsync(user)) { return(BadRequest(Errors.AddErrorToModelState("login failure", "You haven't confirm your email", ModelState))); } var identity = GetClaimsIdentity(user); var jwt = await Tokens.GenerateJwt(identity, jwtFactory, credentials.UserName, jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented }); return(new OkObjectResult(jwt)); }
public async Task <IActionResult> Login(CredentialViewModel model) { if (!ModelState.IsValid || model == null) { ModelState.AddModelError("Authorization error", "Invalid data"); return(View(new CredentialViewModel(Database, model))); } CredentialModel user = Database.Users.FirstOrDefault(i => i.Email == model.Credential.Email); if (user == null || !Encryptor.VerifyHash(model?.Credential.Password, user.Password)) { if (!Database.Users.Any()) { goto Authorize; } ModelState.AddModelError("Authorization error", "Invaild e-mail or password"); return(View(new CredentialViewModel(Database, model))); } Authorize: Claim claim = new Claim(ClaimsIdentity.DefaultNameClaimType, user?.Email ?? "root"); ClaimsIdentity id = new ClaimsIdentity(new Claim[] { claim }, "ApplicationCookie", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType); await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(id)).ConfigureAwait(false); return(Redirect(model.ReturnUrl ?? "/Admin")); }
public IActionResult add(CredentialViewModel model) { Response oReply = new Response(); oReply.Result = 0; string convertString = this.HMACSHA256(model.UserKey); try { if (!verificarToken(model.UserKey)) { using (masterDevContext db = new masterDevContext()) { Credential oModel = new Credential(); oModel.Userkey = model.UserKey; oModel.Sharedsecret = convertString; db.Credential.Add(oModel); db.SaveChanges(); oReply.Result = 204; oReply.Data = convertString; } } else { oReply.Result = 403; oReply.Data = convertString; } }catch (Exception s) { Console.WriteLine(s.Message); } return(Ok(oReply)); }
private CredentialViewModel GetApiKeyCredentialViewModel(string apiKeyType, string revocationSource) { var credentialViewModel = new CredentialViewModel(); credentialViewModel.Type = apiKeyType; credentialViewModel.RevocationSource = revocationSource; credentialViewModel.Scopes = new List <ScopeViewModel>(); return(credentialViewModel); }
private CredentialViewModel GetCredentialViewModel(string apiKeyType, bool hasExpired) { var credentialViewModel = new CredentialViewModel(); credentialViewModel.Type = apiKeyType; credentialViewModel.HasExpired = hasExpired; credentialViewModel.Scopes = new List <ScopeViewModel>(); return(credentialViewModel); }
public CredentialWindow() { InitializeComponent(); // Setup viewmodel for bindings _viewmodel = new CredentialViewModel(); DataContext = _viewmodel; // Load default settings _user = null; }
public async Task <IActionResult> Authenticate([FromBody] CredentialViewModel credential) { var user = await _authenticationService.Authenticate(credential.UserName, credential.Password); if (user == null) { return(BadRequest(new { message = "Username or password is incorrect!" })); } return(Ok(user)); }
public async Task <IActionResult> View(Guid?id) { try { CredentialViewModel resultView = _credentialManager.GetCredentialDetails(id); return(Ok(resultView)); } catch (Exception ex) { return(ex.GetActionResult()); } }
public virtual CredentialViewModel DescribeCredential(Credential credential) { var kind = GetCredentialKind(credential.Type); Authenticator authenticator = null; if (kind == CredentialKind.External) { if (string.IsNullOrEmpty(credential.TenantId)) { string providerName = credential.Type.Split('.')[1]; Authenticators.TryGetValue(providerName, out authenticator); } else { authenticator = Authenticators .Values .FirstOrDefault(provider => provider.Name.Equals(AzureActiveDirectoryV2Authenticator.DefaultAuthenticationType, StringComparison.OrdinalIgnoreCase)); } } var credentialViewModel = new CredentialViewModel { Key = credential.Key, Type = credential.Type, TypeCaption = FormatCredentialType(credential.Type), Identity = credential.Identity, Created = credential.Created, Expires = credential.Expires, Kind = kind, AuthUI = authenticator?.GetUI(), // Set the description as the value for legacy API keys Description = credential.Description, Value = kind == CredentialKind.Token && credential.Description == null ? credential.Value : null, Scopes = credential.Scopes.Select(s => new ScopeViewModel( s.Owner?.Username ?? credential.User.Username, s.Subject, NuGetScopes.Describe(s.AllowedAction))) .ToList(), ExpirationDuration = credential.ExpirationTicks != null ? new TimeSpan?(new TimeSpan(credential.ExpirationTicks.Value)) : null }; credentialViewModel.HasExpired = credential.HasExpired || (credentialViewModel.IsNonScopedApiKey && !credential.HasBeenUsedInLastDays(_config.ExpirationInDaysForApiKeyV1)); credentialViewModel.Description = credentialViewModel.IsNonScopedApiKey ? Strings.NonScopedApiKeyDescription : credentialViewModel.Description; return(credentialViewModel); }
public void Execute(object parameter) { var shell = IoC.Get<IShell>(); var context = IoC.Get<EnvironmentExplorerViewModel>().GetCurrentContext(); var viewModel = default(CredentialViewModel); //var viewModel = new CredentialViewModel(new CredentialModelProxy(new SMA.Credential(), context)); if (context.Service is AzureService || context.Service is AzureRMService) viewModel = new CredentialViewModel(new CredentialModelProxy(new Vendor.Azure.Credential(), context)); else viewModel = new CredentialViewModel(new CredentialModelProxy(new SMA.Credential(), context)); shell.OpenDocument(viewModel); }
public async Task <IActionResult> Details(string id) { var agentContext = await _agentContextProvider.GetContextAsync(); var credentialRecord = await _credentialService.GetAsync(agentContext, id); var model = new CredentialViewModel { Name = credentialRecord.CredentialId, CreatedAt = credentialRecord.CreatedAtUtc.Value.ToLocalTime(), State = credentialRecord.State, CredentialAttributesValues = credentialRecord.CredentialAttributesValues, }; return(View(model)); }
public CredentialViewModel GetCredentialDetails(Guid?credentialId) { Credential existingCredential = _repo.Find(null, c => c.Id == credentialId).Items.FirstOrDefault(); if (existingCredential == null) { throw new EntityDoesNotExistException("No credential was found for the specified id"); } CredentialViewModel credentialView = new CredentialViewModel(); credentialView = credentialView.Map(existingCredential); credentialView.AgentName = _agentRepository.Find(null, a => a.Id == credentialView.AgentId).Items.FirstOrDefault()?.Name; return(credentialView); }
public virtual CredentialViewModel DescribeCredential(Credential credential) { var kind = GetCredentialKind(credential.Type); Authenticator authenticator = null; if (kind == CredentialKind.External) { if (string.IsNullOrEmpty(credential.TenantId)) { string providerName = credential.Type.Split('.')[1]; Authenticators.TryGetValue(providerName, out authenticator); } else { authenticator = Authenticators .Values .FirstOrDefault(provider => provider.Name.Equals(AzureActiveDirectoryV2Authenticator.DefaultAuthenticationType, StringComparison.OrdinalIgnoreCase)); } } var credentialViewModel = new CredentialViewModel { Key = credential.Key, Type = credential.Type, TypeCaption = FormatCredentialType(credential.Type), Identity = credential.Identity, Created = credential.Created, Expires = credential.Expires, Kind = kind, AuthUI = authenticator?.GetUI(), Description = credential.Description, Scopes = credential.Scopes.Select(s => new ScopeViewModel( s.Owner?.Username ?? credential.User.Username, s.Subject, NuGetScopes.Describe(s.AllowedAction))) .ToList(), ExpirationDuration = credential.ExpirationTicks != null ? new TimeSpan?(new TimeSpan(credential.ExpirationTicks.Value)) : null, RevocationSource = credential.RevocationSourceKey != null?Enum.GetName(typeof(CredentialRevocationSource), credential.RevocationSourceKey) : null, }; credentialViewModel.HasExpired = IsCredentialExpiredOrNonScopedApiKeyNotUsedInLastDays(credential); credentialViewModel.Description = credentialViewModel.IsNonScopedApiKey ? ServicesStrings.NonScopedApiKeyDescription : credentialViewModel.Description; return(credentialViewModel); }
public async Task <IActionResult> Post([FromBody] CredentialViewModel credentials) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var identity = await GetClaimsIdentity(credentials.UserName, credentials.Password); if (identity == null) { return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid username or password.", ModelState))); } var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, credentials.UserName, _jwtOptions); return(new OkObjectResult(jwt)); }
public Credential Update([FromRoute] Guid Id, [FromBody] CredentialViewModel param) { User requestor = _context.Users.SingleOrDefault(u => u.ApiKey == Request.Headers["X-ApiKey"]); if (requestor.IsAdmin) { Credential credential = _context.Credentials.SingleOrDefault(cred => cred.Id == Id); credential.UserName = param.UserName; credential.Password = _cryptoService.Encrypt(param.Password); _context.Credentials.Update(credential); _context.SaveChanges(); return(credential); } else { throw new Exception("Only administrator users can update credentials."); } }
public SignUpViewModel( CredentialViewModel credentialViewModel, AccountViewModel accountViewModel, GenreViewModel genreViewModel, UserViewModel userViewModel, SubscriptionViewModel subscriptionViewModel, IProfileService profileService, IAuthenticationService authenticationService) { _credentialViewModel = credentialViewModel; _accountViewModel = accountViewModel; _genreViewModel = genreViewModel; _userViewModel = userViewModel; _subscriptionViewModel = subscriptionViewModel; _profileService = profileService; _authenticationService = authenticationService; }
public void Execute(object parameter) { var shell = IoC.Get <IShell>(); var context = IoC.Get <EnvironmentExplorerViewModel>().GetCurrentContext(); var viewModel = default(CredentialViewModel); //var viewModel = new CredentialViewModel(new CredentialModelProxy(new SMA.Credential(), context)); if (context.Service is AzureService || context.Service is AzureRMService) { viewModel = new CredentialViewModel(new CredentialModelProxy(new Vendor.Azure.Credential(), context)); } else { viewModel = new CredentialViewModel(new CredentialModelProxy(new SMA.Credential(), context)); } shell.OpenDocument(viewModel); }
public async Task <IActionResult> Login([FromBody] CredentialViewModel model) { var user = await userManager.FindByEmailAsync(model.Email); if (user == null || !user.EmailConfirmed) { return(BadRequest()); } var passwordVerificationResult = passwordHasher.VerifyHashedPassword(user, user.PasswordHash, model.Password); if (passwordVerificationResult != PasswordVerificationResult.Success) { return(BadRequest()); } var token = await identityTokenService.CreateTokenAsync(user); return(Ok(new { token })); }
/// <summary> /// Initializes a new instance of the MainViewModel class. /// </summary> public MainViewModel() { //if (IsInDesignMode) //{ // // Code runs in Blend --> create design time data. //} //else //{ // // Code runs "for real" //} TemplateFolder = StatePersister.Instance.Load <String>("main.TemplateFolder") ?? @"C:\develop\GitHub\AzureDevopsWordPlayground\src\WordExporter\Templates"; Connect = new RelayCommand(ConnectMethod); GetQueries = new RelayCommand(GetQueriesMethod); Export = new RelayCommand(ExportMethod); Dump = new RelayCommand(DumpMethod); GetIterations = new RelayCommand(GetIterationsMethod); Address = StatePersister.Instance.Load <String>("main.Address") ?? String.Empty; CredentialViewModel = new CredentialViewModel(); CredentialViewModel.UserName = StatePersister.Instance.Load <String>("userName"); UseNetworkCredential = "true".Equals(StatePersister.Instance.Load <String>("useNetworkCredential"), StringComparison.OrdinalIgnoreCase); }
private CredentialViewModel UpdateCredential(CredentialViewModel model) { var sql = "insert into tcredential (CredentialID, Description, Username, Password, Url, UserDefined1Label, UserDefined1, UserDefined2Label, UserDefined2, Notes, UserID) values " + "(@CredentialID, @Description, @Username, @Password, @Url, @UserDefined1Label, @UserDefined1, @UserDefined2Label, @UserDefined2, @Notes, @UserID); select @CredentialID as id;"; if (model.CredentialID != null) { sql = "update tcredential set Description = @Description, Username = @Username, Password = @Password, Url = @Url, UserDefined1Label = @UserDefined1Label, " + "UserDefined1 = @UserDefined1, UserDefined2Label = @UserDefined2Label, UserDefined2 = @UserDefined2, Notes = @Notes, UserID = @UserID where credentialid = @CredentialID; select @CredentialID as id;"; } if (model.CredentialID == null) model.CredentialID = Guid.NewGuid().ToString(); using (var conn = _cf.GetConnection()) { conn.Open(); conn.Execute(sql, model); } return model; }
public ActionResult Update(CredentialViewModel model) { var updated = UpdateCredential(model); return Json(new { updated.CredentialID }); }
private async Task SignUpAsync() { var success = false; try { switch (PersonType) { case PersonType.NaturalPerson: // set naturalPerson values NaturalPersonViewModel.NaturalPerson.PrimaryEmail = CredentialViewModel.UserCredential.PrimaryEmail; NaturalPersonViewModel.Password = CredentialViewModel.UserCredential.Password; // first validate naturalPersonViewModel and credentialViewModel // this.IsPersonValid = NaturalPersonViewModel.ValidateForm(); this.IsCredentialValid = CredentialViewModel.ValidateForm(); // if validation is true signup person if (this.IsPersonValid && this.IsCredentialValid) { await NaturalPersonViewModel.ProcessFormAsync(); success = true; } break; case PersonType.LegalPerson: // set legalPerson values LegalPersonViewModel.LegalPerson.PrimaryEmail = CredentialViewModel.UserCredential.PrimaryEmail; LegalPersonViewModel.Password = CredentialViewModel.UserCredential.Password; // first validate naturalPersonViewModel and credentialViewModel // this.IsPersonValid = LegalPersonViewModel.ValidateForm(); this.IsCredentialValid = CredentialViewModel.ValidateForm(); // if validation is true signup person if (this.IsPersonValid && this.IsCredentialValid) { await LegalPersonViewModel.ProcessFormAsync(); success = true; } break; case PersonType.None: break; default: throw new ArgumentOutOfRangeException(); } //if success clear sencetive information from memory and navigate to confirm registration page if (success) { NaturalPersonViewModel.Password = LegalPersonViewModel.Password = null; _navigationService.Navigate(ViewNames.ConfirmRegistration, null); } } catch (Exception) { await _alertMessageService.ShowAsync(_resourceLoader.GetString("ErrorServiceUnreachable"), null, DialogCommands.CloseDialogCommand); } }
public async Task SelectCredential(CredentialViewModel credential) => await NavigationService.NavigateToAsync(credential, null, NavigationType.Modal);