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);
