public AccountResponse GetAcountByUserClientData(string Email, int userId, string DeviceId) { bool res = default(bool); IEnumerable <Account> userData = null; int OpMode = default(int); string LoginTokenKey = string.Empty; AccountResponse iresponse = null; try { using (var connection = GetConnection()) { connection.Open(); userData = GetRecord("GetAcountByUserClientData", Email, userId); if (userData != null && userData.Count() > default(int)) { iresponse = new AccountResponse(); iresponse.EmailId = userData.FirstOrDefault().EmailId; iresponse.FirstName = userData.FirstOrDefault().FirstName; iresponse.LastName = userData.FirstOrDefault().LastName; iresponse.Address = userData.FirstOrDefault().Address; iresponse.IsAdmin = userData.FirstOrDefault().IsAdmin; } return(iresponse); } } catch (Exception ex) { AggieGlobalLogManager.Fatal("AccountRepository :: GetAcountByUserId failed :: " + ex.Message); } return(null); }
public async Task <IActionResult> GetAccount([FromRoute] Guid accountId) { if (!HttpContext.User.IsInRole("Admin")) { if (!HttpContext.HasAccountId(accountId.ToString())) { throw new ForbiddenException(); } } var queryAccountCommand = new QueryAccountCommand { Offset = 0, Limit = 1, AccountId = new AccountId(accountId) }; PaginatedCollection <AccountResponse> paginatedCollection = await _executionContext.ExecuteAsync(queryAccountCommand, CancellationToken.None); AccountResponse accountResponse = paginatedCollection.Data.First(); AccountHttpResponse result = new AccountHttpResponse { AccountId = accountResponse.AccountId.Value, Username = accountResponse.Username.Value, FirstName = accountResponse.Name.FirstName, LastName = accountResponse.Name.LastName }; return(StatusCode((int)HttpStatusCode.OK, result)); }
private void Button_Click(object sender, RoutedEventArgs e) { bool isValid = ValidateUsernameAndPassword(UsernameTextField.Text, PasswordField.Password); if (isValid) { LoginService login = new LoginService(); login.Username = UsernameTextField.Text; login.Password = PasswordField.Password; AccountResponse response = login.ValidateLogin(); bool check = response.IsValid; if (check) { UIRemote remote = new UIRemote(); ViewMainMenu viewMenu = new ViewMainMenu(response); remote.SetCommand(viewMenu); remote.ExecuteCommand(); this.Close(); } else { MessageBox.Show("Account not valid! " + response.Message, "Alert", MessageBoxButton.OK, MessageBoxImage.Error); } } else { MessageBox.Show("Invalid username or password! ", "Alert", MessageBoxButton.OK, MessageBoxImage.Error); } }
internal void ValidateLocalUser(string password, bool rememberEmail, bool rememberPassword) { MainWindowVM.SigninPassword = password; if (string.IsNullOrWhiteSpace(MainWindowVM.SigninEmail.Value) || string.IsNullOrWhiteSpace(password)) { MessageBox.Show("Invalid email/password", "MTGAHelper"); return; } AccountResponse info = Api.ValidateLocalUser(MainWindowVM.SigninEmail.Value, password); if (info == null) { MessageBox.Show("Cannot sign-in", "MTGAHelper"); } else if (info.IsAuthenticated) { var signinPassword = ""; if (rememberPassword) { string salt = Api.GetAccountSalt(MainWindowVM.SigninEmail.Value); signinPassword = PasswordHasher.Hash(password, salt); } ConfigModel.SigninEmail = rememberEmail || rememberPassword ? MainWindowVM.SigninEmail.Value : ""; ConfigModel.SigninPassword = signinPassword; SetSignedIn(info); // This saves the configApp } else { MessageBox.Show(info.Message, "MTGAHelper"); } }
public void DoubledTransaction(Account account, Transaction first, Transaction second, Transaction third, Transaction fourth) { var correctAccount = account.Clone(); correctAccount.AvailableLimit -= first.Amount; var correctResponse = new AccountResponse { Account = correctAccount, Violations = new List <string>() }; operationLogic.Process(account); var actualResponse = operationLogic.Process(first) as AccountResponse; Assert.Equal(correctResponse, actualResponse, new AccountResponseComparer()); correctAccount.AvailableLimit -= second.Amount; operationLogic.Process(account); actualResponse = operationLogic.Process(second) as AccountResponse; Assert.Equal(correctResponse, actualResponse, new AccountResponseComparer()); correctAccount.AvailableLimit -= third.Amount; operationLogic.Process(account); actualResponse = operationLogic.Process(third) as AccountResponse; Assert.Equal(correctResponse, actualResponse, new AccountResponseComparer()); correctResponse.Violations.Add(DoubledTransactionValidation.name); operationLogic.Process(account); actualResponse = operationLogic.Process(fourth) as AccountResponse; Assert.Equal(correctResponse, actualResponse, new AccountResponseComparer()); }
public async Task PostAsyncTestHappy() { // Arrange var mockAccountRepository = GetDefaultIAccountRepositoryInstance(); var mockIUnitOfWork = GetDefaultIUnitOfWorkInstance(); var mockUniversityRepository = GetDefaultIUniversityRepositoryInstance(); var accountId = 1; Account a = new Account(); a.Id = accountId; University u = new University(); u.Id = accountId; mockUniversityRepository.Setup(r => r.FindById(accountId)) .Returns(Task.FromResult <University>(u)); var service = new AccountService(mockAccountRepository.Object, mockUniversityRepository.Object, mockIUnitOfWork.Object); // Act AccountResponse result = await service.SaveAsync(a); // Assert Assert.AreEqual(a, result.Resource); }
public async Task <AccountResponse> CreateAsync(CreateRequest model) { // validate var jwtUserEntity = await jwtUserService.GetByEmailAsync(model.Email); if (jwtUserEntity != null) { throw new JwtAppException($"Email '{model.Email}' is already registered"); } // map model to new account object JwtUserEntity <TKey> account = convertService.CreateRequestToUser(model); account.Created = DateTime.UtcNow; account.Verified = DateTime.UtcNow; // hash password account.PasswordHash = passwordService.HashPassword(model.Password); // save account await jwtUserService.AddAsync(account); AccountResponse accountResponse = convertService.UserToAccountResponse(account); return(accountResponse); }
public AccountResponse CheckBalance(string accountNumber) { AccountResponse response = new AccountResponse(); try { if (accountNumber != null) { using (var db = new ATMDbContext()) { response.Account = db.Accounts.Where(p => p.AccountNumber == accountNumber).First(); return(response); } } response.ErrorCode = 100; response.ErrorMessage = "String is null"; response.IsSuccess = false; return(response); } catch (Exception) { response.IsSuccess = false; response.ErrorCode = 222; response.ErrorMessage = $"An error occurred with account, {accountNumber}"; } return(null); }
private async void Window_Loaded(object sender, RoutedEventArgs e) { UpdateCardPopupPosition(); if (string.IsNullOrWhiteSpace(ViewModel.Config.SigninProvider) == false) { string token = ViewModel.Config.SigninProvider switch { "Google" => await TokenManager.GoogleSignin(), "Facebook" => TokenManager.FacebookSignin(this), _ => null }; ValidateExternalToken(ViewModel.Config.SigninProvider, token); } else if (string.IsNullOrWhiteSpace(ViewModel.Config.SigninEmail) == false) { if (string.IsNullOrWhiteSpace(ViewModel.Config.SigninPassword) == false) { AccountResponse info = Api.AutoSigninLocalUser(ViewModel.Config.SigninEmail, ViewModel.Config.SigninPassword); if (info == null) { MessageBox.Show("Cannot auto sign in the local account", "MTGAHelper"); } else if (info.IsAuthenticated) { SetSignedIn(info); } } else { ViewModel.SigninEmail = ViewModel.Config.SigninEmail; } } }
public async Task <AccountResponse> CreateAccountAsync(AccountRequest request) { var customer = new Customer { CustomerId = Guid.NewGuid(), FirstName = request.FirstName, LastName = request.LastName, Email = request.Email, Address = request.Address }; await customerRepository.AddCustomerAsync(customer); var account = new Account { AccountId = Guid.NewGuid(), CustomerId = customer.CustomerId, AccountIban = request.AccountIban, Balance = request.Balance }; await accountRepository.AddAccountAsync(account); var accountResponse = new AccountResponse { AccountIban = account.AccountIban, Balance = account.Balance }; return(accountResponse); }
private IEnumerable <AccountResponse> GetAllMockAccounts() { var accountList = new List <AccountResponse>(); var accountResponseItem1 = new AccountResponse(); accountResponseItem1.Id = 1; accountResponseItem1.Name = "Krishna Credit"; accountResponseItem1.UserId = 1; var accountResponseItem2 = new AccountResponse(); accountResponseItem2.Id = 2; accountResponseItem2.Name = "Luke Credit"; accountResponseItem2.UserId = 2; var accountResponseItem3 = new AccountResponse(); accountResponseItem3.Id = 3; accountResponseItem3.Name = "Lucas Credit"; accountResponseItem3.UserId = 3; accountList.Add(accountResponseItem1); accountList.Add(accountResponseItem2); accountList.Add(accountResponseItem3); return(accountList); }
/// <summary> /// взять баланс /// </summary> public AccountResponse GetBalance() { lock (_lock) { try { var res = CreateQuery(Method.GET, "api/v3/account", null, true); if (res == null) { return(null); } AccountResponse resp = JsonConvert.DeserializeAnonymousType(res, new AccountResponse()); if (NewPortfolio != null) { NewPortfolio(resp); } return(resp); } catch (Exception ex) { SendLogMessage(ex.ToString(), LogMessageType.Error); return(null); } } }
internal void CreateDomain(string domainName) { RunTest(() => { // Get root domain... var rootDomain = Guid.Parse(_client.ListDomains(new ListDomainsRequest { Level = 0 }).Results.Single().Id); var domainResponse = _client.CreateDomain(new CreateDomainRequest { Name = domainName, ParentDomainId = rootDomain }); AccountResponse accountResponse = _client.CreateAccount(new CreateAccountRequest { DomainId = Guid.Parse(domainResponse.Id), UserName = domainName, FirstName = domainName, LastName = "(Test)", Email = "*****@*****.**", AccountType = 0 }); Guid userId = Guid.Parse(accountResponse.User.Single().Id); return(domainResponse.ToString()); }); }
public BaseResponse <AccountResponse> GetAccount(long id) { var response = new BaseResponse <AccountResponse>(); try { if (id == 0) { throw new BaseException(ErrorCode.CustomerNotFound); } var data = new AccountResponse(); var account = accountDomainService.GetAccountById(id); data.id = account.Id; data.amount = account.Amount; response.SetData(data); } catch (Exception e) { response.SetError(e); } return(response); }
public async Task <IActionResult> CreateTrustline(string issuerSeed, string receiverSeed) { Network.UseTestNetwork(); Server server = new Server("https://horizon-testnet.stellar.org"); KeyPair issuingKeys = KeyPair.FromSecretSeed(issuerSeed); KeyPair receivingKeys = KeyPair.FromSecretSeed(receiverSeed); Asset eCoin = Asset.CreateNonNativeAsset("eCoin", issuingKeys.Address); AccountResponse receiving = await server.Accounts.Account(receivingKeys.Address); Transaction allowECoin = new Transaction.Builder(receiving) .AddOperation(new ChangeTrustOperation.Builder(eCoin, "1000").Build()) .Build(); allowECoin.Sign(receivingKeys); var response = await server.SubmitTransaction(allowECoin); if (response.IsSuccess()) { return(Ok(response)); } else { return(BadRequest(response)); } }
private Transaction BuildTransaction(string destinationAccountId, Operation[] operations, Memo memo = null, bool skipDefaultOp = false) { var keypair = KeyPair.Random(); var destination = KeyPair.FromAccountId(destinationAccountId); var account = new AccountResponse(destinationAccountId, 56199647068161); var builder = new TransactionBuilder(account); if (!skipDefaultOp) { builder.AddOperation( new PaymentOperation.Builder(destination, new AssetTypeNative(), "100.50") .Build()); } if (memo != null) { builder.AddMemo(memo); } foreach (var operation in operations) { builder.AddOperation(operation); } var tx = builder.Build(); tx.Sign(keypair); return(tx); }
public async Task <IActionResult> Send(string issuerSeed, string receiverSeed, string amount) { Network.UseTestNetwork(); Server server = new Server("https://horizon-testnet.stellar.org"); KeyPair issuingKeys = KeyPair.FromSecretSeed(issuerSeed); KeyPair receivingKeys = KeyPair.FromSecretSeed(receiverSeed); Asset eCoin = Asset.CreateNonNativeAsset("eCoin", issuingKeys.Address); AccountResponse issuing = await server.Accounts.Account(issuingKeys.Address); Transaction sendECoin = new Transaction.Builder(issuing) .AddOperation( new PaymentOperation.Builder(receivingKeys, eCoin, amount).Build()) .Build(); sendECoin.Sign(issuingKeys); try { var response = await server.SubmitTransaction(sendECoin); return(Ok(response)); } catch (Exception e) { return(BadRequest(e.Message)); } }
public async Task <IActionResult> RegisterAsync([FromBody] AccountRequest accountRequest) { AccountBl accountBl = _mapper.Map <AccountBl>(accountRequest); AccountBl registerAccountBl = await _accountService.RegisterAsync(accountBl); if (registerAccountBl == null) { return(BadRequest()); } Account registerAccount = _mapper.Map <Account>(registerAccountBl); string token = _jwtService.CreateTokenAsync(registerAccount); AccountResponse accountResponse = new AccountResponse( registerAccount.Id, registerAccount.FirstName, registerAccount.SecondName, registerAccount.Email, registerAccount.Password, (int)registerAccount.Role, token ); return(Ok(accountResponse)); }
public async void CreateAccountStellarAsync() { KeyPair keypairtest = KeyPair.Random(); var newAccount = new CreateAccountOperation(keypairtest, "1000"); var Acc = newAccount.ToOperationBody(); Network network = new Network("Test SDF Network ; September 2015"); Server server = new Server("https://horizon-testnet.stellar.org"); //Generate a keypair from the account id. KeyPair keypair = KeyPair.FromAccountId(keypairtest.AccountId); //Load the account AccountResponse accountResponse = await server.Accounts.Account(keypairtest.AccountId); //Get the balance Balance[] balances = accountResponse.Balances; //Show the balance for (int i = 0; i < balances.Length; i++) { Balance asset = balances[i]; Console.WriteLine("Asset Code: " + asset.AssetCode); Console.WriteLine("Asset Amount: " + asset.BalanceString); } }
public RiotHttpClientTests() { _mockAccountResponse = new AccountResponse() { Puuid = "test", GameName = "SevenZ", TagLine = "2070" }; _mockHttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(_mockAccountResponse)) }; _mockHttpMessageHandler = new Mock <HttpMessageHandler>(); _mockHttpMessageHandler .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .ReturnsAsync(_mockHttpResponseMessage) .Verifiable(); _mockRiotTokenResolver = new Mock <IRiotTokenResolver>(); _mockRiotTokenResolver.Setup(x => x.Resolve()) .Returns("test") .Verifiable(); }
public AccountResponse GetUserDetails() { AccountResponse userData = null; var httpContent = Request.Content; try { string userId = string.Empty; if (HttpContext.Current.Session[ApplicationConstant.UserSession] != null) { SessionData sessionObject = (SessionData)HttpContext.Current.Session[ApplicationConstant.UserSession]; AggieGlobalLogManager.Info("FarmDetailsController :: GetFarmsDetails started "); var connectionString = "AggieGlobal"; var repo = new AccountManager(connectionString); userData = repo.GetAcountByUserClientData(sessionObject._email, sessionObject._userId, sessionObject._deviceid); userData.Status = ResponseStatus.Successful; return(userData); } else { userData = new AccountResponse(); userData.Error = "Invalid credentials"; userData.Status = ResponseStatus.Failed; } } catch (Exception ex) { userData = new AccountResponse(); userData.Error = "failed to retreive user data"; userData.Status = ResponseStatus.Failed; AggieGlobalLogManager.Fatal("FarmDetailsController :: GetFarmsDetails failed :: " + ex.Message); } return(userData); }
public async Task PutAsyncTest() { // Arrange var mockAccountRepository = GetDefaultIAccountRepositoryInstance(); var mockIUnitOfWork = GetDefaultIUnitOfWorkInstance(); var accountId = 1; Account a = new Account(); a.Id = accountId; a.AccountName = "roko123"; a.Password = "******"; Account expected = new Account(); expected.AccountName = "rodrigocg"; expected.Password = "******"; mockAccountRepository.Setup(r => r.FindById(accountId)) .Returns(Task.FromResult <Account>(a)); var service = new AccountService(mockAccountRepository.Object, null, mockIUnitOfWork.Object); // Act AccountResponse result = await service.UpdateAsync(accountId, expected); // Assert Assert.AreEqual(expected.Password, result.Resource.Password); }
public AccountResponse UpdateSession() { int ret = default(int); AccountResponse ibase = new AccountResponse(); try { if (HttpContext.Current.Session[ApplicationConstant.UserSession] != null) { SessionData sessionObject = (SessionData)HttpContext.Current.Session[ApplicationConstant.UserSession]; AggieGlobalLogManager.Info("FarmDetailsController :: GetFarmsDetails started "); var connectionString = "AggieGlobal"; var repo = new AccountManager(connectionString); ret = repo.UpdateSession(sessionObject._email, sessionObject._userId, sessionObject._deviceid); if (ret == 0) { ibase.Status = ResponseStatus.Successful; ibase.Error = "Invalid credentials"; } } } catch (Exception ex) { ibase.Status = ResponseStatus.Failed; ibase.Error = "Invalid credentials"; AggieGlobalLogManager.Fatal("FarmDetailsController :: GetFarmsDetails failed :: " + ex.Message); } return(ibase); }
/// <summary> /// Gets the accounts. /// </summary> /// <param name="request">The request.</param> /// <returns></returns> public AccountResponse GetAccounts(AccountRequest request) { var response = new AccountResponse(); if (request.LoadOptions.Contains("Accounts")) { if (request.LoadOptions.Contains("IsActive")) { response.Accounts = request.LoadOptions.Contains("ForComboTree") ? AccountDao.GetAccountsForComboTree(request.AccountId) : AccountDao.GetAccountsActive(); } else if (request.LoadOptions.Contains("IsDetail")) { response.Accounts = AccountDao.GetAccountsIsDetail(request.IsDetail); } else { response.Accounts = AccountDao.GetAccounts(); } } if (request.LoadOptions.Contains("InventoryItem")) { response.Accounts = AccountDao.GetAccountsForIsInventoryItem(); } if (request.LoadOptions.Contains("Account")) { response.Account = AccountDao.GetAccount(request.AccountId); } if (request.LoadOptions.Contains("AccountCode")) { response.Account = AccountDao.GetAccountCode(request.AccountCode); } return(response); }
public async Task <AccountResponse> Login(LoginModel loginModel) { try { var user = await this.userManager.FindByEmailAsync(loginModel.EmailId); var password = await this.userManager.CheckPasswordAsync(user, loginModel.Password); if (user != null) { var data = new AccountResponse() { UserID = user.Id, FirstName = user.FirstName, LastName = user.LastName, EmailID = user.Email, ServiceType = user.ServiceType, UserName = user.UserName, UserType = user.UserType }; return(data); } else { return(null); } } catch (Exception e) { throw new Exception(e.Message); } }
private void SetSignedIn(AccountResponse account) { ConfigModel.SigninProvider = account.Provider; ConfigModel.Save(); MainWindowVM.SetSignedIn(account); Api.SetUserId(account.MtgaHelperUserId); if (MainWindowVM.CanUpload == false || MainWindowVM.Account.IsAuthenticated == false) { return; } Task.Factory.StartNew(() => { try { MainWindowVM.WrapNetworkStatus(NetworkStatusEnum.Downloading, () => { CollectionResponse collection = Api.GetCollection(MainWindowVM.Account.MtgaHelperUserId); MainWindowVM.SetCollection(collection); RefreshRareDraftingInfo(); }); UploadLogFile(); } catch (HttpRequestException) { MainWindowVM.SetProblemServerUnavailable(); } }); }
private TResponse ToResponse <TResponse>(AccountEntity entity) where TResponse : AccountRequestResponse { var res = new AccountResponse { AccountId = entity.Id, AccountName = entity.AccountName, Password = entity.Password, SuperPassword = entity.Password, Token = entity.Token, LastLoginDateTime = entity.LastLoginDateTime, Name = entity.Name, ProfileImage = entity.ProfileImage, ProfileThumbnail = entity.ProfileThumbnail, Sex = entity.Sex, IdentityNum = entity.IdentityNum, PhoneNum = entity.PhoneNum, Email = entity.Email }; var response = Activator.CreateInstance <TResponse>(); response.ApplyEntity(res); return(response); }
public ActionResult <string> Get(string user_id) { var client = new RestClient(); var request = new RestRequest(Method.GET); request.Resource = "https://sandbox.bind.com.ar/v1/banks/322/accounts/owner"; request.RequestFormat = DataFormat.Json; string MyToken = "eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJxVjhWQ2tvY05KSmNDaXd1VFBlTEtRemVBMFZ0d0g4alVIeUtWU0l3YnlrPSIsImNyZWF0ZWQiOjE1NzA4NjUxMDc2MzEsIm5hbWUiOiJFemVxdWllbCBBY2lhciIsImV4cCI6MTU3MDg5MzkwN30.HATfoE4pt1KOpqOlX4BeIUsXdXvABjRaOMMU_tqN4gehJ0BdidaNz4xlIOajs-2bj1YlzJGZuaaOr3_X4MdbfA"; request.AddHeader("Authorization", "JWT " + MyToken); IRestResponse response = client.Execute(request); List <Model.Account> userObj = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Model.Account> >(response.Content); List <Model.AccountResponse> listResponse = new List <Model.AccountResponse>(); try { foreach (Model.Account acc in userObj) { AccountResponse aux = new AccountResponse(); aux.amount = acc.balance.amount; aux.bank = "BIND"; aux.type = acc.type; aux.cbu = acc.account_routing.address; aux.id = acc.id; listResponse.Add(aux); } } catch (Exception ex) { throw ex; } listResponse.AddRange(GetFakeAccounts()); return(JsonConvert.SerializeObject(listResponse)); }
public ActionResult MakeTransaction(int amount, String option) { String username = Session["username"].ToString(); AccountResponse accountResponse = JsonConvert.DeserializeObject <AccountResponse>(makeTransactionAPI(username, amount, option)); return(View("Index", accountResponse)); }
public BalanceResponse GetBalance(AccountResponse account) { if (!_isValid) { return(new BalanceResponse()); } string json = String.Empty; switch (account.BranchNumber) { case 135: json = MockData.HapoalimBalance1; break; case 345: json = MockData.HapoalimBalance2; break; case 545: json = MockData.HapoalimBalance3; break; } return(JsonConvert.DeserializeObject <BalanceResponse>(json)); }
private AccountResponse AccountFromMobileServiceUser(MobileServiceUser user) { if (user == null) { throw new ArgumentNullException(nameof(user)); } IDictionary<string, string> claims = JwtUtility.GetClaims(user.MobileServiceAuthenticationToken); var account = new AccountResponse(); account.Success = true; account.User = new User { Email = claims[JwtClaimNames.Subject], FirstName = claims[JwtClaimNames.GivenName], LastName = claims[JwtClaimNames.FamilyName] }; return account; }