// GET: Login
public ActionResult Index()
{
var credentials = new CredentialsManager();
if (Session["AdminUser"] == null)
{
var cookie = Request.Cookies["MNFCMS"];
if (cookie == null)
{
return(View());
}
var token = cookie["Token"];
var result = credentials.ValidateAdminToken(token);
if (!result.Success)
{
return(View());
}
var user = (AdministratorEntity)result.Entity;
user.Token = token;
Session["AdminUser"] = user;
return(RedirectToAction("Index", "Home"));
}
else
{
var user = (AdministratorEntity)Session["AdminUser"];
var result = credentials.ValidateAdminToken(user.Token);
if (result.Success)
{
return(RedirectToAction("Index", "Home"));
}
}
return(View());
}
public void ReadsAllCredentials()
{
var cm = new CredentialsManager();
var credentials = cm.GetCredentials().ToList();
Assert.That(credentials.Count, Is.GreaterThan(0));
}
public async Task TestStoreCredential()
{
var testSecret = "This is a secret";
var test = new StoredCredential
{
ProviderType = "DNS01.API.Route53",
Title = "A test credential",
StorageKey = Guid.NewGuid().ToString(),
Secret = testSecret
};
var credentialsManager = new CredentialsManager();
credentialsManager.StorageSubfolder = "Tests\\credentials";
var result = await credentialsManager.UpdateCredential(test);
Assert.IsNotNull(result, "Credential stored OK");
var list = await credentialsManager.GetStoredCredentials();
Assert.IsTrue(list.Any(l => l.StorageKey == test.StorageKey), "Credential retrieved");
var secret = await credentialsManager.GetUnlockedCredential(test.StorageKey);
Assert.IsNotNull(secret);
Assert.IsTrue(secret == testSecret, "Credential decrypted");
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
cm.AddPasswordCredential(TargetName, UserName, Password, "Created by Poshring.");
WriteVerbose(string.Format("Added credentials for {0} at {1} to credential store.", UserName, TargetName));
}
public LastSensorDataPage()
{
mainService = new MainService();
mainService.OnSensorDataUpdated += MainService_OnSensorDataUpdated;
credentialManager = new CredentialsManager();
var button = new Button
{
Text = "Get sensor data",
VerticalOptions = new LayoutOptions {
Alignment = LayoutAlignment.Center
},
HorizontalOptions = new LayoutOptions {
Alignment = LayoutAlignment.Center
}
};
button.Clicked += Button_Clicked;
Content = button;
Padding = new Thickness(5, 5, 5, 5);
Device.OnPlatform(iOS: () =>
{
Padding = new Thickness(5, 25, 5, 5);
});
}
public void ManagesPasswordCredential()
{
var cm = new CredentialsManager();
try
{
cm.AddPasswordCredential("test", "testy McTester", "dothetestydance", "test credential");
var credential = cm.GetCredentials().Single(s => s.TargetName == "test");
Assert.That(credential.UserName, Is.EqualTo("testy McTester"));
Assert.That(credential.Comment, Is.EqualTo("test credential"));
Assert.That(credential.CredentialBlob, Is.EqualTo("dothetestydance"));
credential.Comment = "Hobos ride the train.";
credential.UserName = "******";
credential.CredentialBlob = "sekret";
credential.Save();
credential = cm.GetCredentials().Single(s => s.TargetName == "test");
Assert.That(credential.Comment, Is.EqualTo("Hobos ride the train."));
Assert.That(credential.UserName, Is.EqualTo("Biscut"));
Assert.That(credential.CredentialBlob, Is.EqualTo("sekret"));
}
finally
{
var credentials = cm.GetCredentials().Where(s => s.TargetName == "test").ToList();
credentials.ForEach(s => cm.DeleteCredential(s));
}
}
public async Task LetsEncryptRenewerTimerTriggerAsync([TimerTrigger("%LetsEncryptRenewerWebJobSettings:TimerSettings%", RunOnStartup = true, UseMonitor = true)] TimerInfo timerInfo, ILogger logger)
{
if (_letsEncryptConfig.IsJobEnabled)
{
PublishingCredentials publishingCredentials = null;
try
{
logger.LogInformation($"LetsEncryptRenewerWebJob started!");
logger.LogInformation($"Trying to obtain token...");
var token = await CredentialsManager.GetAccessToken(_letsEncryptConfig.AzureEnvironment);
logger.LogInformation($"Token obtain completed!");
logger.LogInformation($"Trying to obtain publishing credentials...");
publishingCredentials = await CredentialsManager.GetPublishingCredentials(_letsEncryptConfig.AzureEnvironment, token);
logger.LogInformation($"Publishing credentials were retrieved successfully!");
}
catch (Exception ex)
{
_appInsightLogger.TrackException(ex);
logger.LogInformation($"Failed to obtain credentials!");
}
if (publishingCredentials != null)
{
try
{
logger.LogInformation($"Proceed lets encrypt renewer api...");
var client = new HttpClient();
var renewUrl = string.Format(Constants.LetsEncryptApiUrlTemplate, _letsEncryptConfig.AzureEnvironment.WebAppName);
client.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{publishingCredentials.Properties.PublishingUserName}:{publishingCredentials.Properties.PublishingPassword}")));
var res = await client.PostAsync(renewUrl, new StringContent(JsonConvert.SerializeObject(_letsEncryptConfig, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}), Encoding.UTF8, "application/json"));
switch (res.StatusCode)
{
case HttpStatusCode.OK:
logger.LogInformation($"Lets encrypt certificate succsessfully renewed...");
break;
default:
logger.LogInformation($"Failed to renew certificate, something wrong with lets encrypt renewer api or configuration!");
var ex = new Exception(string.Format("Failed to renew certificate! : Response: {0}", await res.Content.ReadAsStringAsync()));
_appInsightLogger.TrackException(ex);
break;
}
}
catch (Exception ex)
{
_appInsightLogger.TrackException(ex);
logger.LogInformation($"Exception during lets encrypt renewer api call!");
}
}
}
else
{
logger.LogInformation($"Job disabled by settings!");
}
}
///<summary>
///when users input all data to textBoxes clicked on this button user go to workWindow but before system will checked all data in textBoxes and checked if this user exist
///</summary>
private void button_sign_in_Click(object sender, RoutedEventArgs e)
{
// here you will need to check that a username and password exist in dB it should be done in a separate function which will check it
//a function that checks if there is a user with such data entered in the fields
// здесь нужно будет проверить что такой логи и пароль существуют в бд это нужно сделать в отдельной фукции которая будет проверять это
//функция которая проверяет если есть такой пользователь с такими данными введенными в поля
if (InputFieldsManager.CheckPasswordValidity(passwordBox_enter))
{
//these functions return a string with the maintained data in their textbooks
//данные функции возвращают строку с веденными данными в их текстБоксы
string login = InputFieldsManager.ReturnStringFromTextBox(textBox_login),
password = InputFieldsManager.ReturnPasswordFromTextBox(passwordBox_enter);
//if all is OK, so we go to the Work window
long userID = CredentialsManager.Authorize(login, password);
if (userID != -1)
{
using (StreamWriter writer = new StreamWriter("id.txt"))
{
writer.Write(userID);
}
GoToWork(LibrarianDataManager.GetUserById(userID));
}
else
{
MessageBox.Show("Error. Can not find user with current login and password");
}
}
else
{
MessageBox.Show("Such user doesn't exist");
}
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
var credentials = cm.GetCredentials();
var isTargetValid = !string.IsNullOrWhiteSpace(TargetName);
if (isTargetValid)
{
credentials = credentials.Where(c => c.TargetName == TargetName);
}
var isUserValid = !string.IsNullOrWhiteSpace(UserName);
if (isUserValid)
{
credentials = credentials.Where(c => c.UserName == UserName);
}
var isCommentValid = !string.IsNullOrWhiteSpace(Comment);
if (isCommentValid)
{
credentials = credentials.Where(c => c.Comment == Comment);
}
WriteObject(credentials, true);
}
private async Task Run()
{
UserCredential credential;
string clientSecretsPath = CredentialsManager.GetClientSecretsLocation();
using (FileStream stream = new FileStream(clientSecretsPath, FileMode.Open, FileAccess.Read))
{
// This OAuth 2.0 access scope allows for read-only access to the authenticated
// user's account, but not other types of account access.
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
new[] { YouTubeService.Scope.YoutubeReadonly },
"user",
CancellationToken.None,
new FileDataStore(GetType().ToString())
);
}
BaseClientService.Initializer baseClientServiceInitializer = new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = GetType().ToString()
};
YouTubeService youtubeService = new YouTubeService(baseClientServiceInitializer);
ChannelsResource.ListRequest channelsListRequest = youtubeService.Channels.List("contentDetails");
channelsListRequest.Mine = true;
// Retrieve the contentDetails part of the channel resource for the authenticated user's channel.
ChannelListResponse channelsListResponse = await channelsListRequest.ExecuteAsync();
foreach (Channel channel in channelsListResponse.Items)
{
// From the API response, extract the playlist ID that identifies the list
// of videos uploaded to the authenticated user's channel.
string uploadsListId = channel.ContentDetails.RelatedPlaylists.Uploads;
Console.WriteLine("Videos in list {0}", uploadsListId);
string nextPageToken = "";
while (nextPageToken != null)
{
PlaylistItemsResource.ListRequest playlistItemsListRequest = youtubeService.PlaylistItems.List("snippet");
playlistItemsListRequest.PlaylistId = uploadsListId;
playlistItemsListRequest.MaxResults = 50;
playlistItemsListRequest.PageToken = nextPageToken;
// Retrieve the list of videos uploaded to the authenticated user's channel.
PlaylistItemListResponse playlistItemsListResponse = await playlistItemsListRequest.ExecuteAsync();
foreach (PlaylistItem playlistItem in playlistItemsListResponse.Items)
{
// Print information about each video.
Console.WriteLine("{0} ({1})", playlistItem.Snippet.Title, playlistItem.Snippet.ResourceId.VideoId);
}
nextPageToken = playlistItemsListResponse.NextPageToken;
}
}
}
public void ReadsAllCredentials()
{
var cm = new CredentialsManager();
var credentials = cm.GetCredentials().ToList();
Assert.That(credentials.Count, Is.GreaterThan(0));
}
public static async Task <string> GetVideo(string id, string part = ChannelPartParams.Default, string fields = ChannelFieldParams.Default)
{
StringBuilder url = new StringBuilder(YouTubeApi.ApiBase);
url.Append("/videos?");
url.Append("id=");
url.Append(id);
url.Append("&key=");
url.Append(CredentialsManager.GetApiKey());
if (!string.IsNullOrEmpty(fields))
{
url.Append("&fields=");
url.Append(fields);
}
if (!string.IsNullOrEmpty(part))
{
url.Append("&part=");
url.Append(part);
}
HttpResponseMessage httpResponseMessage = await HttpClient.GetAsync(url.ToString());
string result = await httpResponseMessage.Content.ReadAsStringAsync();
return(result);
}
public void ManagesPasswordCredential()
{
var cm = new CredentialsManager();
try
{
cm.AddPasswordCredential("test", "testy McTester", "dothetestydance", "test credential");
var credential = cm.GetCredentials().Single(s => s.TargetName == "test");
Assert.That(credential.UserName, Is.EqualTo("testy McTester"));
Assert.That(credential.Comment, Is.EqualTo("test credential"));
Assert.That(credential.CredentialBlob, Is.EqualTo("dothetestydance"));
credential.Comment = "Hobos ride the train.";
credential.UserName = "******";
credential.CredentialBlob = "sekret";
credential.Save();
credential = cm.GetCredentials().Single(s => s.TargetName == "test");
Assert.That(credential.Comment, Is.EqualTo("Hobos ride the train."));
Assert.That(credential.UserName, Is.EqualTo("Biscut"));
Assert.That(credential.CredentialBlob, Is.EqualTo("sekret"));
}
finally
{
var credentials = cm.GetCredentials().Where(s => s.TargetName == "test").ToList();
credentials.ForEach(s => cm.DeleteCredential(s));
}
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
var credentials = cm.GetCredentials();
var isTargetValid = !string.IsNullOrWhiteSpace(TargetName);
if (isTargetValid)
{
credentials = credentials.Where(c => c.TargetName == TargetName);
}
var isUserValid = !string.IsNullOrWhiteSpace(UserName);
if (isUserValid)
{
credentials = credentials.Where(c => c.UserName == UserName);
}
var isCommentValid = !string.IsNullOrWhiteSpace(Comment);
if (isCommentValid)
{
credentials = credentials.Where(c => c.Comment == Comment);
}
WriteObject(credentials, true);
}
public void GetSessionTypesTest()
{
foreach (var sessionType in CredentialsManager.GetSessionTypes(CredType.Generic))
{
System.Diagnostics.Debug.WriteLine($"{sessionType.Key}:{sessionType.Value}");
}
}
public async Task TestStoreCredentialDictionary()
{
var secrets = new Dictionary <string, string>();
secrets.Add("zoneid", "ABC123");
secrets.Add("secretid", "thereisnosecret");
var test = new StoredCredential
{
ProviderType = "DNS01.API.Route53",
Title = "A test credential",
StorageKey = Guid.NewGuid().ToString(),
Secret = Newtonsoft.Json.JsonConvert.SerializeObject(secrets)
};
var credentialsManager = new CredentialsManager();
credentialsManager.StorageSubfolder = "Tests\\credentials";
var result = await credentialsManager.UpdateCredential(test);
Assert.IsNotNull(result, "Credential stored OK");
var list = await credentialsManager.GetStoredCredentials();
Assert.IsTrue(list.Any(l => l.StorageKey == test.StorageKey), "Credential retrieved");
var secret = await credentialsManager.GetUnlockedCredentialsDictionary(test.StorageKey);
Assert.IsNotNull(secret);
Assert.IsTrue(secret["zoneid"] == "ABC123", "Credential decrypted");
}
/// <summary>
/// Adds new Patron to the database.
/// </summary>
/// <param name="user">Patron, which is going to be added.</param>
/// <param name="login">Login of the patron.</param>
/// <param name="password">Password of the patron.</param>
public static bool AddUser(IUser user, string login, string password)
{
if (user == null)
{
throw new ArgumentNullException();
}
using (IDbConnection connection = new System.Data.SqlClient.SqlConnection(Helper.CnnVal("LibraryDB")))
{
var output = connection.Query <bool>("dbo.spUsers_IsUserInTable @FirstName, @SecondName, @Phone",
new
{ FirstName = user.FirstName, SecondName = user.SecondName, Phone = user.Phone }).ToList();
if (!output[0])
{
long cardNumber = CredentialsManager.AddUserCredentials(login, password);
user.CardNumber = cardNumber;
connection.Execute("dbo.spUsers_AddUser @FirstName, @SecondName, @CardNumber, @Phone, @Address, @Type",
new
{
FirstName = user.FirstName,
SecondName = user.SecondName,
CardNumber = user.CardNumber,
Phone = user.Phone,
Address = user.Address,
Type = user.GetType().ToString().Split('.').Last()
});
return(true);
}
else
{
return(false);
}
}
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
using (var credential = cm.GetCredentials().Single(c => c.UserName == UserName && c.TargetName == TargetName))
{
cm.DeleteCredential(credential);
}
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
using (var credential = cm.GetCredentials().SingleOrDefault(c => c.UserName == UserName && c.TargetName == TargetName))
{
WriteObject(credential);
}
}
public static void Start()
{
LocalLogger.Log($"Method {nameof(HubService)} is running");
try
{
var credentialsManager = new CredentialsManager(Settings.ApiUrl, Settings.UserRelatedStoragePath,
Settings.SystemRelatedStoragePath, "ArktinMonitor");
var bearerToken = credentialsManager.LoadJsonWebToken().AccessToken;
if (!HubConnection.Headers.TryGetValue("Authorization", out var value))
{
HubConnection.Headers.Add("Authorization", "Bearer " + bearerToken);
}
if (value != "Bearer " + bearerToken)
{
HubConnection.Headers["Authorization"] = "Bearer " + bearerToken;
}
if (_myHubProxy == null)
{
_myHubProxy = HubConnection.CreateHubProxy("MyComputerHub");
HubConnection.StateChanged += state =>
{
_connectionId = HubConnection.ConnectionId;
if (state.NewState == ConnectionState.Connected)
{
Pong(_connectionId);
}
LocalLogger.Log(
$"State of connection to hub changed from {state.OldState} to {state.NewState}");
};
_myHubProxy.On <string, string>("command", ExecuteCommand);
_myHubProxy.On <string, int>("powerAction", PowerAction);
_myHubProxy.On <string>("ping", Pong);
_myHubProxy.On("requestProcesses", GetProcesses);
}
LocalLogger.Log("Starting hub connection");
HubConnection.Start().Wait();
LocalLogger.Log("Joining to group");
JoinToGroup();
//Pong(_connectionId);
}
catch (Exception e)
{
LocalLogger.Log(nameof(Start), e);
}
HubConnection.Error += exception =>
{
if (!(exception is System.TimeoutException))
{
LocalLogger.Log(nameof(HubConnection.Error), exception);
}
};
}
private async Task Run()
{
UserCredential credential;
string clientSecretsPath = CredentialsManager.GetClientSecretsLocation();
using (FileStream stream = new FileStream(clientSecretsPath, FileMode.Open, FileAccess.Read))
{
ClientSecrets clientSecrets = GoogleClientSecrets.Load(stream).Secrets;
// This OAuth 2.0 access scope allows for full read/write access to the
// authenticated user's account.
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
clientSecrets,
new[] { YouTubeService.Scope.Youtube },
"user",
CancellationToken.None,
new FileDataStore(GetType().ToString())
);
}
YouTubeService youtubeService = new YouTubeService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = GetType().ToString()
});
// Create a new, private playlist in the authorized user's channel.
Playlist newPlaylist = new Playlist
{
Snippet = new PlaylistSnippet
{
Title = "Test Playlist",
Description = "A playlist created with the YouTube API v3"
},
Status = new PlaylistStatus
{
PrivacyStatus = "public"
}
};
newPlaylist = await youtubeService.Playlists.Insert(newPlaylist, "snippet,status").ExecuteAsync();
// Add a video to the newly created playlist.
PlaylistItem newPlaylistItem = new PlaylistItem
{
Snippet = new PlaylistItemSnippet
{
PlaylistId = newPlaylist.Id,
ResourceId = new ResourceId
{
Kind = "youtube#video",
VideoId = "GNRMeaz6QRI"
}
}
};
newPlaylistItem = await youtubeService.PlaylistItems.Insert(newPlaylistItem, "snippet").ExecuteAsync();
Console.WriteLine("Playlist item id {0} was added to playlist id {1}.", newPlaylistItem.Id, newPlaylist.Id);
}
public void TestToken()
{
var cred = new CredentialsManager();
var result =
cred.ValidateAdminToken(
"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJBZG1pbnRyYXRvcklkIjoxLCJVc2VybmFtZSI6ImFkbWluIiwiZXhwIjoxNTAxNjgxNzIxLCJpYXQiOjE0OTkwODk3MjF9.WYthz69O9h-kyj5LNw0J3ob3XvJOrHbjSzGFjljtcnA");
Assert.AreEqual(result.Success, true);
}
public async Task InitTest()
{
var credentialsManager = new CredentialsManager();
_credentials = await credentialsManager.GetUnlockedCredentialsDictionary(_credStorageKey);
_provider = new Providers.DNS.Cloudflare.DnsProviderCloudflare(_credentials);
await _provider.InitProvider();
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
using (var credential = cm.GetCredentials().SingleOrDefault(c => c.UserName == UserName && c.TargetName == TargetName))
{
WriteObject(credential);
}
}
private void Auth()
{
var manager = new CredentialsManager();
var message = manager.Auth(
loginInput.Text,
passwordInput.Text);
MessageBox.Show(message);
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
using (var credential = cm.GetCredentials().Single(c => c.UserName == UserName && c.TargetName == TargetName))
{
credential.CredentialBlob = Password;
credential.Save();
}
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
using (var credential = cm.GetCredentials().Single(c => c.UserName == UserName && c.TargetName == TargetName))
{
cm.DeleteCredential(credential);
}
}
public HttpResponseMessage TestAPICredentials(string username, string password, string environment, bool awardLetterUploadEnabled = false)
{
try
{
string stsURL = string.Empty;
List <string> apiURLs = new List <string>();
switch (environment)
{
case EnvironmentConstants.SANDBOX:
{
apiURLs.Add(ApiUrlConstants.SV_API_URL_SANDBOX);
apiURLs.Add(ApiUrlConstants.PM_API_URL_SANDBOX);
if (awardLetterUploadEnabled)
{
apiURLs.Add(ApiUrlConstants.AL_API_URL_SANDBOX);
}
stsURL = ApiUrlConstants.STS_URL_SANDBOX;
break;
}
case EnvironmentConstants.PRODUCTION:
{
apiURLs.Add(ApiUrlConstants.SV_API_URL_PRODUCTION);
apiURLs.Add(ApiUrlConstants.PM_API_URL_PRODUCTION);
if (awardLetterUploadEnabled)
{
apiURLs.Add(ApiUrlConstants.AL_API_URL_PRODUCTION);
}
stsURL = ApiUrlConstants.STS_URL_PRODUCTION;
break;
}
default:
{
apiURLs.Add(ApiUrlConstants.SV_API_URL_SANDBOX);
apiURLs.Add(ApiUrlConstants.PM_API_URL_SANDBOX);
if (awardLetterUploadEnabled)
{
apiURLs.Add(ApiUrlConstants.AL_API_URL_SANDBOX);
}
stsURL = ApiUrlConstants.STS_URL_SANDBOX;
break;
}
}
CredentialsManager credentialsManager = new CredentialsManager();
HttpResponseMessage response = credentialsManager.GetAuthorizationToken(username, password, apiURLs, stsURL);
return(response);
}
catch (Exception ex)
{
logger.ErrorFormat("TestAPICredentials Get Error: {0}", ex);
return(Request.CreateResponse(HttpStatusCode.ExpectationFailed));
}
}
/// <summary>
/// Validate API Credentials
/// </summary>
/// <param name="applicationAppSettingsSection"></param>
public static HttpResponseMessage ValidateApiCredentials(Dictionary <string, string> applicationAppSettingsSection, bool awardLetterUploadEnabled = false)
{
string stsUrl;
List <string> apiURLs = new List <string>();
switch (applicationAppSettingsSection["environment"])
{
case EnvironmentConstants.SANDBOX:
{
apiURLs.Add(ApiUrlConstants.SV_API_URL_SANDBOX);
apiURLs.Add(ApiUrlConstants.PM_API_URL_SANDBOX);
if (awardLetterUploadEnabled)
{
apiURLs.Add(ApiUrlConstants.AL_API_URL_SANDBOX);
}
stsUrl = ApiUrlConstants.STS_URL_SANDBOX;
break;
}
case EnvironmentConstants.PRODUCTION:
{
apiURLs.Add(ApiUrlConstants.SV_API_URL_PRODUCTION);
apiURLs.Add(ApiUrlConstants.PM_API_URL_PRODUCTION);
if (awardLetterUploadEnabled)
{
apiURLs.Add(ApiUrlConstants.AL_API_URL_PRODUCTION);
}
stsUrl = ApiUrlConstants.STS_URL_PRODUCTION;
break;
}
default:
{
apiURLs.Add(ApiUrlConstants.SV_API_URL_SANDBOX);
apiURLs.Add(ApiUrlConstants.PM_API_URL_SANDBOX);
if (awardLetterUploadEnabled)
{
apiURLs.Add(ApiUrlConstants.AL_API_URL_SANDBOX);
}
stsUrl = ApiUrlConstants.STS_URL_SANDBOX;
break;
}
}
CredentialsManager credentialsManager = new CredentialsManager();
//Ensure ALL Credentials are valid
var credentialsResponse = credentialsManager.GetAuthorizationToken(applicationAppSettingsSection["apiUsername"], applicationAppSettingsSection["apiPassword"], apiURLs, stsUrl);
if (!credentialsResponse.IsSuccessStatusCode)
{
logger.Fatal($"API Credentials are not valid, username: {applicationAppSettingsSection["apiUsername"]}, password: {applicationAppSettingsSection["apiPassword"]}");
return(new HttpResponseMessage(HttpStatusCode.ExpectationFailed));
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
private void Recover()
{
var manager = new CredentialsManager();
var message = manager.PasswordRecovery(
loginInput.Text,
mailInput.Text,
passwordInput.Text);
MessageBox.Show(message);
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
using (var credential = cm.GetCredentials().Single(c => c.UserName == UserName && c.TargetName == TargetName))
{
credential.CredentialBlob = Password;
credential.Save();
}
}
// Sign up user with passed credentials. RSA key pair will be generated automatically.
public static bool SignUp(string name, string login, string password)
{
// Generate new key pair.
var keyPair = RsaKeyPair.GenerateKeyPair();
// Persist private key. Not the best place to do it, but it doesn't matter.
CredentialsManager.Store(login, keyPair.PrivateKeyXml);
// Client method call.
return(AppUser.GetInstance().Client.SignUp(login, name, password, keyPair.PublicKeyXml));
}
public async Task InitTest()
{
var credentialsManager = new CredentialsManager();
_credentials = await credentialsManager.GetUnlockedCredentialsDictionary(_credStorageKey);
_provider = new Providers.DNS.Azure.DnsProviderAzure(_credentials);
await _provider.InitProvider(new Dictionary <string, string> {
});
}
private void Register()
{
var manager = new CredentialsManager();
var message = manager.Register(
loginInput.Text,
passwordInput.Text,
mailInput.Text,
(Sex)Enum.Parse(typeof(Sex), sexInput.Text));
MessageBox.Show(message);
}
public App()
{
InitializeComponent();
CredentialsManager = new CredentialsManager(new CredentialsService());
CarpoolManager = new CarpoolManager(new CarpoolService());
CabManager = new CabManager(new CabService());
DriverManager = new DriverManager(new DriverService());
PassengerManager = new PassengerManager(new PassengerService());
LocationManager = new LocationManager(new LocationService());
MainPage = new NavigationPage(new LM.PassengerMainPage());
}
// Sign in user and restore RSA key from local storage.
// Therefore user should be signed up on local device for successful sign in.
// Otherwise generated private key should be transferred to a new device.
public static bool SignIn(string login, string password)
{
if (AppUser.GetInstance().Client.SignIn(login, password))
{
Logger.Info("Signed in as {0}.", login);
FetchMyself(login);
// Restore private key.
AppUser.GetInstance().PrivateKeyXml = CredentialsManager.Retrieve(login);
return(true);
}
return(false);
}
protected override void ProcessRecord()
{
var cm = new CredentialsManager();
cm.AddPasswordCredential(TargetName, UserName, Password, "Created by Poshring.");
WriteVerbose(string.Format("Added credentials for {0} at {1} to credential store.", UserName, TargetName));
}
