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