public IHttpActionResult PutCredentialType(int id, CredentialType credentialType)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != credentialType.ID)
            {
                return BadRequest();
            }

            db.Entry(credentialType).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CredentialTypeExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

 public Credential(CredentialType credentialType, string applicationName, string userName, string password)
 {
     ApplicationName = applicationName;
     UserName = userName;
     Password = password;
     CredentialType = credentialType;
 }

        public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType , bool retrying)
        {
            if (Credentials.ContainsKey(uri))
                return Credentials[uri];

            return provider.GetCredentials(uri, proxy, credentialType, retrying);
        }

        public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
        {
            if (uri == null)
            {
                throw new ArgumentNullException("uri");
            }

            string message = credentialType == CredentialType.ProxyCredentials ?
                    LocalizedResourceManager.GetString("Credentials_ProxyCredentials") :
                    LocalizedResourceManager.GetString("Credentials_RequestCredentials");
            Console.WriteLine(message, uri.OriginalString);
            Console.Write(LocalizedResourceManager.GetString("Credentials_UserName"));
            string username = Console.ReadLine();
            Console.Write(LocalizedResourceManager.GetString("Credentials_Password"));

            using (SecureString password = new SecureString())
            {
                Console.ReadSecureString(password);
                var credentials = new NetworkCredential
                {
                    UserName = username,
                    SecurePassword = password
                };
                return credentials;
            }
        }

        public static ICredentials CreateCredentials(
            CredentialType credentialType,
            String userName,
            String password,
            Uri url
        )
        {
            if (credentialType == CredentialType.Default
                && IsSharePointOnline(url)
            )
            {
                credentialType = CredentialType.SharePointOnline;
            }

            switch (credentialType)
            {
                case CredentialType.Windows:
                    return new NetworkCredential(
                        userName,
                        password
                    );
                case CredentialType.SharePointOnline:
                    return new SharePointOnlineCredentials(
                        userName,
                        password
                    );
            }

            return null;
        }

       public static PSObject Load(string target, CredentialType type = CredentialType.Generic)
       {
           PSObject cred;
           NativeMethods.CredRead(FixTarget(target), type, 0, out cred);

           return cred;
       }

        public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
        {
            if (uri == null)
            {
                throw new ArgumentNullException("uri");
            }

            if (LaunchedFromVS())
            {
                throw new InvalidOperationException(LocalizedResourceManager.GetString("Error_CannotPromptForCedentials"));
            }

            string message = credentialType == CredentialType.ProxyCredentials ?
                    LocalizedResourceManager.GetString("Credentials_ProxyCredentials") :
                    LocalizedResourceManager.GetString("Credentials_RequestCredentials");
            Console.WriteLine(message, uri.OriginalString);
            Console.Write(LocalizedResourceManager.GetString("Credentials_UserName"));
            string username = Console.ReadLine();
            Console.Write(LocalizedResourceManager.GetString("Credentials_Password"));
            SecureString password = ReadLineAsSecureString();
            var credentials = new NetworkCredential
            {
                UserName = username,
                SecurePassword = password
            };

            return credentials;
        }

        public ICredentials get_credentials_from_user(Uri uri, IWebProxy proxy, CredentialType credentialType)
        {
            if (!_config.Information.IsInteractive)
            {
                return CredentialCache.DefaultCredentials;
            }

            string message = credentialType == CredentialType.ProxyCredentials ?
                                 "Please provide proxy credentials:" :
                                 "Please provide credentials for: {0}".format_with(uri.OriginalString);
            this.Log().Info(ChocolateyLoggers.Important, message);

            Console.Write("User name: ");
            string username = Console.ReadLine();
            Console.Write("Password: ");
            var password = Console.ReadLine();

            //todo: set this up as secure
            //using (var securePassword = new SecureString())
            //{
            //    foreach (var letter in password.to_string())
            //    {
            //        securePassword.AppendChar(letter);
            //    }

            var credentials = new NetworkCredential
                {
                    UserName = username,
                    Password = password,
                    //SecurePassword = securePassword
                };
            return credentials;
            // }
        }

 public Credential(CredentialType credentialType, string applicationName, string userName, string password)
 {
     _applicationName = applicationName;
     _userName = userName;
     _password = password;
     _credentialType = credentialType;
 }

		public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
		{
			var cp = MonoDevelop.Core.WebRequestHelper.CredentialProvider;
			if (cp == null)
				return null;

			return cp.GetCredentials (uri, proxy, (MonoDevelop.Core.Web.CredentialType)credentialType, retrying);
		}

		internal PlaceholderForm (CredentialType type, Uri uri, NetworkCredential currentCredential)
		{
			this.uri = uri;
			this.type = type;
			current = currentCredential;
			Size = new Size (0, 0);
			Visible = false;
		}

 public Credential(string username, string password, string target, CredentialType type)
 {
     Username = username;
     Password = password;
     Target = target;
     Type = type;
     PersistanceType = PersistanceType.Session;
     _lastWriteTime = DateTime.MinValue;
 }

		static ICredentials GetExistingCredentials (Uri uri, CredentialType credentialType)
		{
			var rootUri = new Uri (uri.GetComponents (UriComponents.SchemeAndServer, UriFormat.SafeUnescaped));
			var existing =
				PasswordService.GetWebUserNameAndPassword (uri) ??
				PasswordService.GetWebUserNameAndPassword (rootUri);

			return existing != null ? new NetworkCredential (existing.Item1, existing.Item2) : null;
		}

		public ICredentials GetCredentials (Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
		{
			if (uri == null)
				throw new ArgumentNullException ("uri");

			var form = new PlaceholderForm (credentialType, uri, null);
			var result = GdkWin32.RunModalWin32Form (form, IdeApp.Workbench.RootWindow);
			return result ? new NetworkCredential (form.Username, form.Password, form.Domain) : null;
		}

        public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
        {
            if (uri == null)
            {
                throw new ArgumentNullException("uri");
            }

            return PromptUserForCredentials(uri, forcePrompt: true);
        }

 public CredentialTypeViewModel Build(CredentialType credentialType)
 {
     return new CredentialTypeViewModel()
       {
     Id = credentialType.Id,
     Name = credentialType.Name,
     Position = credentialType.Position
       };
 }

		public ICredentials GetCredentials (Uri uri, IWebProxy proxy, CredentialType credentialType, ICredentials existingCredentials, bool retrying)
		{
			bool result = false;
			DispatchService.GuiSyncDispatch (() => {
				using (var ns = new NSAutoreleasePool ()) {
					var message = string.Format ("{0} needs {1} credentials to access {2}.", BrandingService.ApplicationName, 
					                             credentialType == CredentialType.ProxyCredentials ? "proxy" : "request", uri.Host);

					NSAlert alert = NSAlert.WithMessage ("Credentials Required", "OK", "Cancel", null, message);
					alert.Icon = NSApplication.SharedApplication.ApplicationIconImage;

					NSView view = new NSView (new RectangleF (0, 0, 313, 91));

					var creds = Utility.GetCredentialsForUriFromICredentials (uri, existingCredentials);

					var usernameLabel = new NSTextField (new RectangleF (17, 55, 71, 17)) {
						Identifier = "usernameLabel",
						StringValue = "Username:",
						Alignment = NSTextAlignment.Right,
						Editable = false,
						Bordered = false,
						DrawsBackground = false,
						Bezeled = false,
						Selectable = false,
					};
					view.AddSubview (usernameLabel);

					var usernameInput = new NSTextField (new RectangleF (93, 52, 200, 22));
					usernameInput.StringValue = creds != null ? creds.UserName : string.Empty;
					view.AddSubview (usernameInput);

					var passwordLabel = new NSTextField (new RectangleF (22, 23, 66, 17)) {
						StringValue = "Password:",
						Alignment = NSTextAlignment.Right,
						Editable = false,
						Bordered = false,
						DrawsBackground = false,
						Bezeled = false,
						Selectable = false,
					};
					view.AddSubview (passwordLabel);

					var passwordInput = new NSSecureTextField (new RectangleF (93, 20, 200, 22));
					passwordInput.StringValue = creds != null ? creds.Password : string.Empty;
					view.AddSubview (passwordInput);

					alert.AccessoryView = view;
					result = alert.RunModal () == 1;

					username = usernameInput.StringValue;
					password = passwordInput.StringValue;
				}
			});

			return result ? new NetworkCredential (username, password) : null;
		}

 public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
 {
     NetworkCredential credentials;
     // If we are retrying, the stored credentials must be invalid. 
     if (!retrying && (credentialType == CredentialType.RequestCredentials) && TryGetCredentials(out credentials))
     {
         return credentials;
     }
     return null;
 }

 public AdalClient(
     AppConfig appConfig, 
     CredentialType credentialType, 
     IServiceInfoProvider serviceProvider = null)
     : base(appConfig, credentialType, serviceProvider)
 {
     appConfig.ServiceResource = Constants.Authentication.GraphServiceUrl;
     serviceProvider = new ServiceProvider();
     this.ServiceInformation = _serviceInfoProvider.CreateServiceInfo(appConfig, credentialType).Result;
 }

 public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
 {
     NetworkCredential credentials;
     // If we are retrying, the stored credentials must be invalid. 
     if (!retrying && (credentialType == CredentialType.RequestCredentials) && TryGetCredentials(uri, out credentials))
     {
         _logger.Log(MessageLevel.Info, NuGetResources.SettingsCredentials_UsingSavedCredentials, credentials.UserName);
         return credentials;
     }
     return _credentialProvider.GetCredentials(uri, proxy, credentialType, retrying);
 }