public bool Store(AuthData data) { GD.Delete (m_realm, new string[1] {"UUID"}, new object[1] { data.PrincipalID }); return GD.Insert (m_realm, new string[] { "UUID", "passwordHash", "passwordSalt", "webLoginKey", "accountType" }, new object[] { data.PrincipalID, data.PasswordHash, data.PasswordSalt, data.WebLoginKey, data.AccountType }); }
public static Task<string> AddUserDailyTask(AuthData authData, UserDailyVM d) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<string>(); EventHandler<AddUserDailyCompletedEventArgs> handler = null; handler = (sender, e) => { client.AddUserDailyCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.AddUserDailyCompleted += handler; client.AddUserDailyAsync(authData, d); return tcs.Task; }
public static Task<LebensmittelConsumedVM> AddConsumedTask(AuthData authData, string p1, float p2, int daytime, DateTime currentDate) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<LebensmittelConsumedVM>(); AddConsumedResponse a; EventHandler<AddConsumedCompletedEventArgs> handler = null; handler = (sender, e) => { client.AddConsumedCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.AddConsumedCompleted += handler; client.AddConsumedAsync(authData, p1, p2, daytime, currentDate); return tcs.Task; }
public static Task<LebensmittelVM> AddFoodTask(AuthData authData, LebensmittelVM lebensmittelItem) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<LebensmittelVM>(); EventHandler<AddFoodCompletedEventArgs> handler = null; handler = (sender, e) => { client.AddFoodCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.AddFoodCompleted += handler; client.AddFoodAsync(authData, lebensmittelItem); return tcs.Task; }
public AuthData Get(UUID principalID, string authType) { List<string> query = GD.Query (new string[2] { "UUID", "accountType" }, new object[2] { principalID.ToString (), authType }, m_realm, "*"); AuthData data = null; for (int i = 0; i < query.Count; i += 5) { data = new AuthData(); data.PrincipalID = UUID.Parse(query[i]); data.PasswordHash = query[i + 1]; data.PasswordSalt = query[i + 2]; data.AccountType = query[i + 3]; } return data; }
public AuthData Get(UUID principalID) { List<string> query = GD.Query("UUID", principalID.ToString(), m_realm, "*"); AuthData data = null; for (int i = 0; i < query.Count; i += 5) { data = new AuthData(); data.PrincipalID = UUID.Parse(query[i]); data.PasswordHash = query[i + 1]; data.PasswordSalt = query[i + 2]; data.WebLoginKey = query[i + 3]; data.AccountType = query[i + 4]; } return data; }
/* ************************************ * FACEBOOK * ************************************** */ private void onFacebookAccessTokenChange(AccessToken token) { if (token != null) { mAuthProgressDialog.show(); mFirebaseRef.authWithOAuthToken("facebook", token.Token, new AuthResultHandler(this, "facebook")); } else { // Logged out of Facebook and currently authenticated with Firebase using Facebook, so do a logout if (this.mAuthData != null && this.mAuthData.Provider.Equals("facebook")) { mFirebaseRef.unauth(); AuthenticatedUser = null; } } }
private void CheckToken() { if (_token == null) { throw new UnauthorizedAccessException("Cannot create GoogleDrive session with given token"); } if (_token.IsExpired) { _token = OAuth20TokenHelper.RefreshToken <GoogleLoginProvider>(_token); using (var dbDao = new CachedProviderAccountDao(CoreContext.TenantManager.GetCurrentTenant().TenantId, FileConstant.DatabaseId)) { var authData = new AuthData(token: _token.ToJson()); dbDao.UpdateProviderInfo(ID, authData); } } }
public static void MakeGetRequest(AuthData authData, string url, Dictionary<string, string> param, DownloadStringCompletedEventHandler handler) { url += "?"; foreach (KeyValuePair<string, string> keyValuePair in param) { url += String.Format("{0}={1}&", keyValuePair.Key, keyValuePair.Value); } if (url[url.Length - 1] == '&') { url = url.Substring(0, url.Length - 1); } WebClient wc = new WebClient(); wc.DownloadStringCompleted += handler; wc.DownloadStringAsync(new Uri(url)); }
public virtual bool SetPasswordHashed(UUID principalID, string authType, string Hashedpassword) { string passwordSalt = Util.Md5Hash(UUID.Random().ToString()); string md5PasswdHash = Util.Md5Hash(Hashedpassword + ":" + passwordSalt); AuthData auth = m_Database.Get(principalID, authType); if (auth == null) { auth = new AuthData { PrincipalID = principalID, AccountType = authType }; } auth.PasswordHash = md5PasswdHash; auth.PasswordSalt = passwordSalt; return(SaveAuth(auth, principalID)); }
public IActionResult Login([FromBody] AuthData authData) { string passwordHash = usersRep.GetUserPassHashForCompare(authData.Email); if (passwordHash == "0" || !BCrypt.Net.BCrypt.Verify(authData.Password, passwordHash)) { _logger.LogInformation("User with email " + authData.Email + " Signed in"); return(BadRequest()); } int reqData = usersRep.GetUserIdForAuth(authData.Email); Response.Cookies.Append("userId", reqData.ToString()); _logger.LogInformation("User with email " + authData.Email + " Signed in"); return(Ok()); }
public async Task <AuthData> AuthenticateAsync() { var authContext = new AuthenticationContext(azureSettings.Authority); var clientCred = new ClientCredential(azureSettings.ClientId, azureSettings.Secret); var result = await authContext.AcquireTokenAsync(azureSettings.ResourceId, clientCred); if (result == null) { throw new InvalidOperationException("Failed to obtain the JWT token"); } var authData = new AuthData { Scheme = AuthScheme.BEARER, PasswordOrToken = result.AccessToken }; return(authData); }
public AuthResult Post(AuthData data) { var adminUsername = WebConfigurationManager.AppSettings["adminUsername"]; var adminPassword = WebConfigurationManager.AppSettings["adminPassword"]; if (adminUsername != data.Username || adminPassword != data.Password) { log.Warn($"Invalid credentials on authentication. Username: { data.Username }"); return(new AuthResult(false, string.Empty, DateTime.UtcNow)); } var result = this.jwtTools.GetToken(data.Username); log.Info($"Successful authentication. Username: { data.Username }"); return(new AuthResult(true, result.Token, result.ExpirationTime)); }
public void SignUp(AuthData authData_, Action onSuccess_, Action onFail_) { ParseUser user = new ParseUser(); user.Add("Username", authData_.username); user.Add("Email", authData_.email); user.Add("Password", authData_.password); user.SignUpAsync().ContinueWith((Task task_) => { if (task_.IsCanceled || task_.IsFaulted) { onFail_(); } else { onSuccess_(); } }); }
public AuthData AuthById(int id) { using (StreamReader r = new StreamReader("/home/student/data/users.json")) { string json = r.ReadToEnd(); try { UserData user = JsonConvert.DeserializeObject <Dictionary <string, UserData> >(json)[id.ToString()]; var data = new AuthData { email = user.email, password = user.password, salt = user.salt }; return(data); } catch (System.Collections.Generic.KeyNotFoundException e) { return(new AuthData()); } } }
public bool Store(AuthData data) { GD.Delete(m_realm, new string[2] { "UUID", "accountType" }, new object[2] { data.PrincipalID, data.AccountType }); return(GD.Insert(m_realm, new[] { "UUID", "passwordHash", "passwordSalt", "accountType" }, new object[] { data.PrincipalID, data.PasswordHash.MySqlEscape(1024), data.PasswordSalt.MySqlEscape(1024), data.AccountType.MySqlEscape(32) })); }
public virtual int UpdateProviderInfo(int linkId, AuthData authData) { var forUpdate = FilesDbContext.ThirdpartyAccount .Where(r => r.Id == linkId) .Where(r => r.TenantId == TenantID) .ToList(); foreach (var f in forUpdate) { f.UserName = authData.Login ?? ""; f.Password = EncryptPassword(authData.Password); f.Token = EncryptPassword(authData.Token ?? ""); f.Url = authData.Url ?? ""; } FilesDbContext.SaveChanges(); return(forUpdate.Count == 1 ? linkId : default);
public static void MakeGetRequest(AuthData authData, string url, Dictionary <string, string> param, DownloadStringCompletedEventHandler handler) { url += "?"; foreach (KeyValuePair <string, string> keyValuePair in param) { url += String.Format("{0}={1}&", keyValuePair.Key, keyValuePair.Value); } if (url[url.Length - 1] == '&') { url = url.Substring(0, url.Length - 1); } WebClient wc = new WebClient(); wc.DownloadStringCompleted += handler; wc.DownloadStringAsync(new Uri(url)); }
/// <summary> /// Gets the Auth Data to pass to Poniverse for proper login /// </summary> private static AuthData GetAuthData(CookieAwareWebClient c = null) { string url = "http://canterlotavenue.com/ponauth/"; //Get the Poniverse URL //window\.location\.replace\("(.+)"\); if (c == null) { c = new CookieAwareWebClient(); } string s = c.DownloadString(url); string poniverse_oauth = ExtractPoniverseOauth(s); AuthData d = new AuthData(poniverse_oauth); return(d); }
public override int GetHashCode() { int hash = 1; if (MechName.Length != 0) { hash ^= MechName.GetHashCode(); } if (AuthData.Length != 0) { hash ^= AuthData.GetHashCode(); } if (InitialResponse.Length != 0) { hash ^= InitialResponse.GetHashCode(); } return(hash); }
public async Task <Answer> GetOrderState(AuthData authData, string visit_id) { if (!Initialized) { Init(baseUrl); } Answer answer = new Answer(); try { answer = await api.GetOrderState(authData, visit_id); } catch (Exception e) { return(ErrorHandler.HandleException(e)); } return(answer); }
public async Task <Answer> GetQRCode(AuthData authData, Geoposition geopos) { if (!Initialized) { Init(baseUrl); } Answer answer = new Answer(); try { answer = await api.GetQRCode(authData, geopos); } catch (Exception e) { return(ErrorHandler.HandleException(e)); } return(answer); }
public async Task LoginUser([FromBody] AuthData user) { TokenProvider _tokenProvider = new TokenProvider(db); var userToken = _tokenProvider.LoginUser(user.Login.Trim(), user.Password.Trim()); if (userToken == null) { Response.StatusCode = 401; await Response.WriteAsync("Invalid username or password."); } else { Response.ContentType = "application/json"; await Response.WriteAsync(JsonConvert.SerializeObject(userToken, new JsonSerializerSettings { Formatting = Formatting.Indented })); } }
/// <summary> /// HTTPs the client request. /// </summary> /// <param name="bodyEntity">The body entity.</param> /// <param name="request">The request.</param> /// <returns>The uniqueidentifer</returns> /// <exception cref="System.Exception"> /// Unable to create the journal entry. /// or /// Error creating the journal entry. /// </exception> private async static Task <String> RequestData(string request, AuthData authData) { try { HttpResponseMessage responseContent = await Utils.HttpClientRequest(null, request, authData); if (responseContent.IsSuccessStatusCode) { var result = await responseContent.Content.ReadAsStringAsync(); dynamic oDataResponse = JsonConvert.DeserializeObject(result); List <JournalEntry> journalEntry = oDataResponse.data.ToObject <List <JournalEntry> >(); List <(string, string, string, double, double)> lst = new List <(string, string, string, double, double)>(); foreach (var i in journalEntry) { lst.Add((i.PostingDate, i.NaturalKey, i.Company, i.TotalCredit.Value, i.TotalDebit.Value)); } Console.WriteLine(lst.ToStringTable( new[] { "Posting Date", "Journal", "Company", "T. Credit", "T. Debit" }, a => a.Item1, a => a.Item2, a => a.Item3, a => a.Item4, a => a.Item5)); return(result.ToString()); } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(string.Concat("Failed. ", responseContent.ToString())); string result = await(responseContent.Content).ReadAsStringAsync(); Console.WriteLine(string.Concat("Content: ", result)); throw new Exception("Unable to create the invoice."); } } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; throw new Exception("Error creating the invoice."); } }
public static AuthResult Authorize(AuthData data) { Keys keys = GetKeys(); if (data != null && keys != null && keys.Public.Equals(data.PublicKey)) { var privateKey = keys.Private; var hashCheck = General.Sha1Hash(data.Data + privateKey + data.PublicKey); if (hashCheck != null && hashCheck.Equals(data.Hash)) { var newToken = General.Sha1Hash(privateKey + hashCheck + GetDateTimeFormatted()); var computersJsonFile = GetFile("~/App_Data/", "computers.json"); var computers = new List <ComputerData>(); try { computers = JsonConvert.DeserializeObject <List <ComputerData> >(GetFileContents(computersJsonFile)); } catch { } var computerData = GetComputerData(data); var computer = computers.Where(c => c.Hash == computerData.Hash).FirstOrDefault(); if (computer == null) { computerData.IsOnline = true; computers.Add(computerData); } else { computer.IsOnline = true; } var computersJson = JsonConvert.SerializeObject(computers); try { File.WriteAllText(computersJsonFile, computersJson); } catch { } return(new AuthResult() { Token = newToken, IpExternal = data.IpExternal }); } } return(null); }
/// <summary> /// HTTPs the client request. /// </summary> /// <param name="bodyEntity">The body entity.</param> /// <param name="request">The request.</param> /// <returns>The uniqueidentifer</returns> /// <exception cref="System.Exception"> /// Unable to create the journal entry. /// or /// Error creating the journal entry. /// </exception> private async static Task <String> RequestData(string request, AuthData authData) { try { HttpResponseMessage responseContent = await Utils.HttpClientRequest(null, request, authData); if (responseContent.IsSuccessStatusCode) { var result = await responseContent.Content.ReadAsStringAsync(); dynamic oDataResponse = JsonConvert.DeserializeObject(result); List <Invoice> invoices = oDataResponse.data.ToObject <List <Invoice> >(); List <(string, string, string, string)> lst = new List <(string, string, string, string)>(); foreach (var i in invoices) { lst.Add((i.DueDate, i.NaturalKey, i.AccountingPartyName, i.Company)); } Console.WriteLine(lst.ToStringTable( new[] { "Invoice", "Date", "Customer", "Company" }, a => a.Item1, a => a.Item2, a => a.Item3, a => a.Item4)); return(result.ToString()); } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(string.Concat("Failed. ", responseContent.ToString())); string result = await(responseContent.Content).ReadAsStringAsync(); Console.WriteLine(string.Concat("Content: ", result)); throw new Exception("Unable to create the invoice."); } } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; throw new Exception("Error creating the invoice."); } }
private async static Task <String> RequestData(string request, AuthData authData) { try { HttpResponseMessage responseContent = await Utils.HttpClientRequest(null, request, authData); if (responseContent.IsSuccessStatusCode) { var result = await responseContent.Content.ReadAsStringAsync(); dynamic oDataResponse = JsonConvert.DeserializeObject(result); List <Order> orders = oDataResponse.data.ToObject <List <Order> >(); List <Tuple <string, string, string, string> > lst = new List <Tuple <string, string, string, string> >(); foreach (var i in orders) { Tuple <string, string, string, string> item = new Tuple <string, string, string, string>(i.PostingDate, i.NaturalKey, i.BuyerCustomerPartyDescription, i.PayableAmount.Value.ToString()); lst.Add(item); } Console.WriteLine(lst.ToStringTable( new[] { "Date", "Order", "Customer", "Total" }, a => a.Item1, a => a.Item2, a => a.Item3, a => a.Item4)); return(result.ToString()); } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(string.Concat("Failed. ", responseContent.ToString())); string result = await(responseContent.Content).ReadAsStringAsync(); Console.WriteLine(string.Concat("Content: ", result)); throw new Exception("Unable to create the order."); } } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; throw new Exception("Error creating the order."); } }
private void btnReg2serv_Click(object sender, EventArgs e) { string pass1 = TBPass1.Text; string pass2 = TBPass2.Text; if (pass1 == pass2) { WebRequest req = WebRequest.Create("http://localhost:5000/api/reg"); req.Method = "POST"; AuthData auth_data = new AuthData(); auth_data.login = fieldUserName.Text; auth_data.password = pass1; string postData = JsonConvert.SerializeObject(auth_data); req.ContentType = "application/json"; StreamWriter reqStream = new StreamWriter(req.GetRequestStream()); reqStream.Write(postData); reqStream.Close(); HttpWebResponse resp = (HttpWebResponse)req.GetResponse(); StreamReader sr = new StreamReader(resp.GetResponseStream(), Encoding.GetEncoding("utf-8")); string content = sr.ReadToEnd(); sr.Close(); int int_token = Convert.ToInt32(content, 10); if (int_token != -1) { mForm.int_token = int_token; mForm.TextBox_username.Text = auth_data.login; mForm.Show(); this.Visible = false; SendMessage(new Message() { username = auth_data.login, text = " присоединился к чату", }); } else { MessageBox.Show("Такой пользователь уже зарегистрирован, обратитесь к администратору"); } } else { MessageBox.Show("Passwords don't match"); } }
public void UpdateUserAuthData(AuthData userData) { if (userData == null) { throw new ArgumentNullException("UserRegister object is null!"); } var user = _userRepository.Find(x => x.EmailAddress.Equals(userData.EmailAddress)).SingleOrDefault(); if (user == null) { throw new ItemNotFoundException(); } user.EmailAddress = userData.EmailAddress; user.PasswordHash = userData.PasswordHash; _userRepository.Update(user); }
private async void btnLogin_Click(object sender, RoutedEventArgs e) { AuthData data = new AuthData() { user = txtLogin.Text, password = txtPass.Password }; var response = await ApiHelper.RequestInternalJson <AuthResponse>("api/v1/login", data, null); if (response.status == "success") { AppPersistent.Token = new AuthTokens() { UserId = response.data.userId, Token = response.data.authToken }; PageNavigationManager.SwitchToPage(new RoomsPage()); } }
public AuthData Get(UUID principalID, string authType) { QueryFilter filter = new QueryFilter(); filter.andFilters["UUID"] = principalID; filter.andFilters["accountType"] = authType; List<string> query = GD.Query(new string[1] {"*"}, m_realm, filter, null, null, null); AuthData data = null; for (int i = 0; i < query.Count; i += 5) { data = new AuthData { PrincipalID = UUID.Parse(query[i]), PasswordHash = query[i + 1], PasswordSalt = query[i + 2], AccountType = query[i + 3] }; } return data; }
public async Task GetDHLPackages() { DHL24WebapiPortClient service = new DHL24WebapiPortClient(); AuthData auth = new AuthData(); auth.username = dhl_login; //"BALTICAD"; auth.password = dhl_password; //"r#Q,rwwJdh6IJQJ"; progressBar.Maximum = 3; progressBar.Value = 1; try { getMyShipmentsResponse response = await service.getMyShipmentsAsync(auth, dateTimePickerDHL.Value.ToString("yyyy-MM-dd"), DateTime.Today.ToString("yyyy-MM-dd"), 0); progressBar.PerformStep(); listViewDHL.Items.Clear(); foreach (ShipmentBasicData shipmentData in response.getMyShipmentsResult) { String[] arr = new String[7]; ListViewItem itm; arr[0] = shipmentData.receiver.name; arr[1] = shipmentData.receiver.contactPerson; arr[2] = shipmentData.receiver.street + " " + shipmentData.receiver.houseNumber; arr[3] = shipmentData.receiver.city; arr[4] = shipmentData.receiver.contactEmail; arr[5] = shipmentData.shipmentId; arr[6] = ""; itm = new ListViewItem(arr); listViewDHL.Items.Add(itm); } progressBar.PerformStep(); listViewPocztaPolska.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent); listViewPocztaPolska.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize); } catch (Exception e) { MessageBox.Show("Wystąpił błąd podczas pobierania danych z API DHL. Treść błędu: " + e.Message); } }
public ActionResult Login(string authData) { if (string.IsNullOrEmpty(authData)) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var authDataDecoded = AuthData.Decode(authData); // basic scenarios perform well using in-memory session // advanced scenarios, please check session store Session.Add("BotId", authDataDecoded.BotId); Session.Add("userBotId", authDataDecoded.UserId); Session.Add("channelId", authDataDecoded.ChannelId); Session.Add("conversationId", authDataDecoded.ConversationId); Session.Add("serviceUrl", authDataDecoded.ServiceUrl); return(View()); }
public void SetUser(string username, string password) { username = username.ToLower().Trim(); var salt = Hasher.GenerateSalt(); _userDictionary[username] = new AuthData() { PasswordHash = Hasher.HashPassword(password, salt), PasswordSalt = salt, Username = username }; foreach (var k in _sessionMap) { if (k.Value.Username == username) { _sessionMap.Remove(k.Key); } } }
private AuthData GetUserData() { AuthData authData = null; try { authData = Helpers.JsonSerializer.DeserializeFromFile <AuthData>(m_AuthDataFile); } catch { } if (authData == null) { authData = new AuthData(); } return(authData); }
public static async Task <GameData> getGameData(AuthData data) { var httpClient = new HttpClient(); HttpContent sendContent = Json.generateRequestGameDataJson(data); var response = await httpClient.PostAsync(QueryApi.SERVER + QueryApi.QUERY_GET_DATA, sendContent); var respBody = await response.Content.ReadAsStringAsync(); respBody.Remove(0, 1); if (response.IsSuccessStatusCode) { GameData constructedData = Json.parseGameDataJson(respBody); return(constructedData); } Message.show((int)response.StatusCode); return(null); }
private IEnumerator executeLogin() { Debug.Log("clicked"); AuthData auth = new AuthData(loginText.text, passwordText.text); String requestString = auth.toJson(); Debug.Log("requestString: " + requestString); System.Collections.Generic.Dictionary <string, string> headers = new System.Collections.Generic.Dictionary <string, string>(); headers.Add("Content-Type", "application/json"); var encoding = new System.Text.UTF8Encoding(); WWW request = new WWW(LOGIN_URI, encoding.GetBytes(requestString), headers); yield return(request); LoginResponse jResponse = JsonUtility.FromJson <LoginResponse>(request.text); hideProgress(); // Print the error to the console if (request.error != null) { Debug.Log("request error: " + request.error); showDialog("request error: " + request.error); } else { if (!String.IsNullOrEmpty(jResponse.message)) { Debug.Log("request error: " + jResponse.message); showDialog(jResponse.message); } else { AppGlobal.token = jResponse.token; AppGlobal.finalText = jResponse.finalText; AppGlobal.finalTextUrl = jResponse.finalTextUrl; AppGlobal.youtubeUrl = jResponse.youtubeUrl; SceneManager.LoadScene("MainMenu"); } } }
public virtual bool SetPassword(UUID principalID, string authType, string password) { string passwordSalt = Util.Md5Hash(UUID.Random().ToString()); string md5PasswdHash = Util.Md5Hash(Util.Md5Hash(password) + ":" + passwordSalt); AuthData auth = m_Database.Get(principalID, authType); if (auth == null) { auth = new AuthData {PrincipalID = principalID, AccountType = authType}; } auth.PasswordHash = md5PasswdHash; auth.PasswordSalt = passwordSalt; if (!m_Database.Store(auth)) { MainConsole.Instance.DebugFormat("[AUTHENTICATION DB]: Failed to store authentication data"); return false; } MainConsole.Instance.InfoFormat("[AUTHENTICATION DB]: Set password for principalID {0}", principalID); return true; }
public override int UpdateProviderInfo(int linkId, string customerTitle, AuthData authData, FolderType folderType) { ProviderCache.Reset(_rootKey, linkId.ToString(CultureInfo.InvariantCulture)); return base.UpdateProviderInfo(linkId, customerTitle, authData, folderType); }
private static AuthData GetEncodedAccesToken(AuthData authData, string providerName) { var prName = (nSupportedCloudConfigurations) Enum.Parse(typeof (nSupportedCloudConfigurations), providerName, true); if (prName != nSupportedCloudConfigurations.Google) return authData; var tokenSecret = ImportConfiguration.GoogleTokenManager.GetTokenSecret(authData.Token); var consumerKey = ImportConfiguration.GoogleTokenManager.ConsumerKey; var consumerSecret = ImportConfiguration.GoogleTokenManager.ConsumerSecret; var accessToken = GoogleDocsAuthorizationHelper.BuildToken(authData.Token, tokenSecret, consumerKey, consumerSecret); var storage = new CloudStorage(); authData.Token = storage.SerializeSecurityTokenToBase64Ex(accessToken, typeof (GoogleDocsConfiguration), null); return authData; }
private static IProviderInfo ToProviderInfo(int id, string providerName, string customerTitle, AuthData authData, string owner, FolderType type, DateTime createOn) { return ToProviderInfo(new object[] {id, providerName, customerTitle, authData.Login, EncryptPassword(authData.Password), authData.Token, owner, (int) type, createOn}); }
public static Task<AsyncCompletedEventArgs> SendFeedbackTask(AuthData authData, string feedback) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<AsyncCompletedEventArgs>(); EventHandler<AsyncCompletedEventArgs> handler = null; handler = (sender, e) => { client.SendFeedbackCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e); } }; client.SendFeedbackCompleted += handler; client.SendFeedbackAsync(authData, feedback); return tcs.Task; }
public static Task<ObservableCollection<LebensmittelConsumedVM>> GetConsumedTask(AuthData token, int daytime, DateTime date) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<ObservableCollection<LebensmittelConsumedVM>>(); //GetConsumedResponse a; EventHandler<GetConsumedCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetConsumedCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetConsumedCompleted += handler; client.GetConsumedAsync(token, daytime, date); return tcs.Task; }
public static Task<ObservableCollection<NutritionPlanVM>> GetNutritionPlans(AuthData a) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<ObservableCollection<NutritionPlanVM>>(); EventHandler<GetNutritionPlansCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetNutritionPlansCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetNutritionPlansCompleted += handler; client.GetNutritionPlansAsync(a); return tcs.Task; }
public static Task<ObservableCollection<UserDailyVM>> GetUserDailyRangeTask(AuthData authData, int i, int p) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<ObservableCollection<UserDailyVM>>(); EventHandler<GetUserDailyRangeCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetUserDailyRangeCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetUserDailyRangeCompleted += handler; client.GetUserDailyRangeAsync(authData, i, p); return tcs.Task; }
public override void onAuthenticated(AuthData authData) { Log.v(TAG, "Authentication worked"); }
public static Task<string> UpdateUserGoalTask(AuthData a, UserGoalVM data) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<string>(); EventHandler<UpdateUserGoalCompletedEventArgs> handler = null; handler = (sender, e) => { client.UpdateUserGoalCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.UpdateUserGoalCompleted += handler; client.UpdateUserGoalAsync(a, data); return tcs.Task; }
public static Task SetTrainingExerciseTask(AuthData authData, TrainingExerciseVM item) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<TrainingDayVM>(); EventHandler<SetTrainingExerciseCompletedEventArgs> handler = null; handler = (sender, e) => { client.SetTrainingExerciseCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.SetTrainingExerciseCompleted += handler; client.SetTrainingExerciseAsync(authData, item); return tcs.Task; }
public static Task<NutritionPlanFavoriteVM> SetNutritionPlanFavoriteTask(AuthData a, NutritionPlanFavoriteVM fav) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<NutritionPlanFavoriteVM>(); EventHandler<SetNutritionPlanFavoriteCompletedEventArgs> handler = null; handler = (sender, e) => { client.SetNutritionPlanFavoriteCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.SetNutritionPlanFavoriteCompleted += handler; client.SetNutritionPlanFavoriteAsync(a, fav); return tcs.Task; }
public static Task<int> SetFoodTask(AuthData authData, LebensmittelVM lebensmittelItem) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<int>(); tcs.SetResult(0); client.SetFoodAsync(authData, lebensmittelItem); return tcs.Task; }
public static Task<bool> SetConsumedTask(AuthData authData, LebensmittelConsumedVM cons) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<bool>(); AddConsumedResponse a; EventHandler<SetConsumedCompletedEventArgs> handler = null; handler = (sender, e) => { client.SetConsumedCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.SetConsumedCompleted += handler; client.SetConsumedAsync(authData, cons); return tcs.Task; }
public bool Store(AuthData data) { GD.Delete (m_realm, new string[2] {"UUID", "accountType"}, new object[2] { data.PrincipalID, data.AccountType }); return GD.Insert (m_realm, new string[] { "UUID", "passwordHash", "passwordSalt", "accountType" }, new object[] { data.PrincipalID, data.PasswordHash.MySqlEscape(), data.PasswordSalt.MySqlEscape(), data.AccountType.MySqlEscape() }); }
public static Task<Plan1PointsVM> GetRemainingPlan1PointsTask(AuthData a, DateTime date) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<Plan1PointsVM>(); EventHandler<GetRemainingPlan1PointsCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetRemainingPlan1PointsCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetRemainingPlan1PointsCompleted += handler; client.GetRemainingPlan1PointsAsync(a, date); return tcs.Task; }
public static Task<SummaryData> GetSummaryTask(AuthData authData, int p, DateTime date) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<SummaryData>(); EventHandler<GetSummaryCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetSummaryCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetSummaryCompleted += handler; client.GetSummaryAsync(authData, p,date); return tcs.Task; }
public static Task<ObservableCollection<TrainingExerciseVM>> GetExerciseHistoryTask(AuthData authData, TrainingExerciseVM trainingExerciseItem) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<ObservableCollection<TrainingExerciseVM>>(); EventHandler<GetExerciseHistoryCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetExerciseHistoryCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetExerciseHistoryCompleted += handler; client.GetExerciseHistoryAsync(authData, trainingExerciseItem); return tcs.Task; }
public virtual int SaveProviderInfo(string providerName, string customerTitle, AuthData authData, FolderType folderType) { var prName = (nSupportedCloudConfigurations) Enum.Parse(typeof (nSupportedCloudConfigurations), providerName, true); //for google docs authData = GetEncodedAccesToken(authData, providerName); if (!CheckProviderInfo(ToProviderInfo(0, providerName, customerTitle, authData, SecurityContext.CurrentAccount.ID.ToString(), folderType, TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow())))) throw new UnauthorizedAccessException("Can't authorize at " + providerName + " provider with given credentials"); var queryInsert = new SqlInsert(TableTitle, true) .InColumnValue("id", 0) .InColumnValue("tenant_id", TenantID) .InColumnValue("provider", prName.ToString()) .InColumnValue("customer_title", customerTitle) .InColumnValue("user_name", authData.Login) .InColumnValue("password", EncryptPassword(authData.Password)) .InColumnValue("folder_type", (int) folderType) .InColumnValue("create_on", TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow())) .InColumnValue("user_id", SecurityContext.CurrentAccount.ID.ToString()) .InColumnValue("token", authData.Token) .Identity(0, 0, true); return Int32.Parse(DbManager.ExecuteScalar<string>(queryInsert)); }
public static Task<ArrayOfString> GetClassesTask(AuthData authData) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<ArrayOfString>(); EventHandler<GetClassesCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetClassesCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetClassesCompleted += handler; client.GetClassesAsync(authData); return tcs.Task; }
public virtual int UpdateProviderInfo(int linkId, string customerTitle, AuthData authData, FolderType folderType) { var oldprovider = GetProviderInfoInernal(linkId); //for google docs authData = GetEncodedAccesToken(authData, oldprovider.ProviderName); if (!CheckProviderInfo(ToProviderInfo(0, oldprovider.ProviderName, customerTitle, authData, SecurityContext.CurrentAccount.ID.ToString(), folderType, TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow())))) throw new UnauthorizedAccessException("Can't authorize at " + oldprovider.ProviderName + " provider with given credentials"); var queryUpdate = new SqlUpdate(TableTitle) .Set("customer_title", customerTitle) .Set("user_name", authData.Login) .Set("password", EncryptPassword(authData.Password)) .Set("folder_type", (int) folderType) .Set("create_on", TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow())) .Set("user_id", SecurityContext.CurrentAccount.ID.ToString()) .Set("token", authData.Token) .Where("id", linkId) .Where("tenant_id", TenantID); return DbManager.ExecuteNonQuery(queryUpdate) == 1 ? linkId : default(int); }
public static Task<NutritionPlanVM> GetNewNutritionPlanTask(AuthData a, string plan, float cals, DateTime date) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<NutritionPlanVM>(); EventHandler<GetNewNutritionPlanCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetNewNutritionPlanCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetNewNutritionPlanCompleted += handler; client.GetNewNutritionPlanAsync(a, plan,cals,date); return tcs.Task; }
public static Task<UserVM> GetUserProfileTask(AuthData a) { var client = WebService.Instance.WS; var tcs = new TaskCompletionSource<UserVM>(); EventHandler<GetUserProfileCompletedEventArgs> handler = null; handler = (sender, e) => { client.GetUserProfileCompleted -= handler; if (e.Error != null) { tcs.SetException(e.Error); } else { tcs.SetResult(e.Result); } }; client.GetUserProfileCompleted += handler; client.GetUserProfileAsync(a); return tcs.Task; }