/// <summary>
/// Get multiple users' account info through a mass query search
/// </summary>
public static IEnumerable <AccountInfo> GetUsers <T>(this T client, Platform platform, LookupMethod lookupMethod, IEnumerable <string> queries, CancellationToken token = default)
where T : Dragon6Client
{
var request = new AccountInfoRequest(platform, lookupMethod, queries);
return(client.Perform <JObject>(request, token).DeserializeAccountInfo());
}
public void Test_GetUserAvatar_Error()
{
var request = new AccountInfoRequest("");
var message = new HttpResponseMessage(HttpStatusCode.Forbidden);
Assert.IsFalse(request.WasSuccessful(message));
}
public static async Task <AccountInfoResponse> GetAccountInfoAsync(string accessToken)
{
var request = new AccountInfoRequest();
string response = await SendApiRequestAsync(request, accessToken);
return(JsonConvert.DeserializeObject <AccountInfoResponse>(response));
}
public void Test_AccountInfo_Error()
{
var request = new AccountInfoRequest("");
var message = new HttpResponseMessage(HttpStatusCode.Forbidden);
Assert.IsFalse(request.WasSuccessful(message));
Assert.AreEqual(SeafErrorCode.InvalidToken, request.GetSeafError(message).SeafErrorCode);
}
public void Test_AccountInfo_HttpRequest()
{
var request = new AccountInfoRequest(FakeToken);
var httpRequest = TestConnection.CreateHttpRequestMessage(DummyServerUri, request);
Assert.AreEqual(HttpMethod.Get, httpRequest.Method);
Assert.AreEqual(DummyServerUri + "api2/account/info/", httpRequest.RequestUri.ToString());
}
/// <summary>
/// Returns the mailing account info.
/// </summary>
/// <param name="authKey"></param>
/// <returns>The <see cref="AccountInfo"/>.</returns>
public AccountInfo AccountInfo(string authKey)
{
var request = new AccountInfoRequest {
AuthKey = authKey,
ApiKey = ApiKey
};
return(ServiceClient.Post <AccountInfo>(request, AccountInfoApiPath));
}
//
public async Task <AccountInfo> GetAccountInfo(long?recvWindow = null)
{
var req = new AccountInfoRequest()
{
RecvWindow = recvWindow
};
var resp = await _connecter.PrivateRequest(req);
return(JsonConvert.DeserializeObject <AccountInfo>(resp.Content));
}
// Token: 0x060003AE RID: 942 RVA: 0x0003FFD4 File Offset: 0x0003E1D4
public static async Task <double?> GetYandexBalanceAsync()
{
AccountInfoRequest <AccountInfoResult> accountInfoRequest = new AccountInfoRequest <AccountInfoResult>(YandexMoney.Connection, new JsonSerializer <AccountInfoResult>());
AccountInfoResult accountInfoResult2 = await accountInfoRequest.Perform();
AccountInfoResult accountInfoResult = accountInfoResult2;
accountInfoResult2 = null;
return(new double?(accountInfoResult.Balance));
}
private async Task <StatusResponse> OnBoard()
{
var onBoardRequest = new AccountInfoRequest(_userRepository.UserInfo.PublicAddress);
Console.WriteLine($"onBoardRequest:\n{JsonConvert.SerializeObject(onBoardRequest, Formatting.Indented)}\n");
StatusResponse onBoardResponse = await _onboardingApi.OnBoard(_userRepository.UserInfo.Id, onBoardRequest).ConfigureAwait(false);
Console.WriteLine($"onBoardResponse:\n {JsonConvert.SerializeObject(onBoardResponse, Formatting.Indented)}");
Console.WriteLine();
return(onBoardResponse);
}
public DraftsBuilderMetaRequest(
SenderRequest sender,
AccountInfoRequest payer,
RecipientInfoRequest recipient,
DraftBuilderType builderType,
DraftsBuilderData?builderData)
{
Sender = sender ?? throw new ArgumentNullException(nameof(sender));
Payer = payer ?? throw new ArgumentNullException(nameof(payer));
Recipient = recipient ?? throw new ArgumentNullException(nameof(recipient));
BuilderType = builderType;
BuilderData = builderData;
}
public Task <AccountInfo> AccountInfo(AccountInfoRequest request)
{
var command = JsonConvert.SerializeObject(request, serializerSettings);
TaskCompletionSource <AccountInfo> task = new TaskCompletionSource <AccountInfo>();
TaskInfo taskInfo = new TaskInfo();
taskInfo.TaskId = request.Id;
taskInfo.TaskCompletionResult = task;
taskInfo.Type = typeof(AccountInfo);
tasks.TryAdd(request.Id, taskInfo);
client.SendMessage(command);
return(task.Task);
}
static async Task Main(string[] args)
{
// Create the network client
var address = new Uri("https://s.altnet.rippletest.net:51234");
var httpClient = new HttpClient();
httpClient.BaseAddress = address;
var xrplClient = new JsonRpcApi(httpClient);
// Create a wallet using the testnet faucet
var faucetClient = new FaucetClient();
var testSeed = await faucetClient.Generate();
Console.WriteLine(testSeed);
// Create an account string from the wallet
// N.B rootKeyPair will be null for ED25519 keys
testSeed.GetKeyPairs(out var rootKeyPair, out var keyPair);
var accountId = AccountId.FromPublicKey(keyPair.PublicKey.GetCanoncialBytes());
Console.WriteLine(accountId);
// Look up info about your account, need to do this in a loop because it will take some time for the account to actually be present in a validated ledger
while (true)
{
var infoRequest = new AccountInfoRequest()
{
Account = accountId,
Ledger = LedgerSpecification.Validated
};
try
{
var infoResponse = await xrplClient.AccountInfo(infoRequest);
Console.WriteLine("Balance: {0}", infoResponse.AccountData.Balance);
break;
}
catch (RippleRequestException exc)
{
if (exc.Error == "actNotFound")
{
continue;
}
throw;
}
}
}
/// <summary>
/// The account_info command retrieves information about an account, its activity, and its XRP balance.
/// All information retrieved is relative to a particular version of the ledger.
/// </summary>
public async Task <AccountInfoResponse> AccountInfo(AccountInfoRequest request, CancellationToken cancellationToken = default)
{
jsonBuffer.Clear();
jsonWriter.Reset();
jsonWriter.WriteStartObject();
var requestId = WriteHeader(jsonWriter, "account_info");
LedgerSpecification.Write(jsonWriter, request.Ledger);
jsonWriter.WriteString("account", request.Account.ToString());
jsonWriter.WriteBoolean("queue", request.Queue);
jsonWriter.WriteBoolean("signer_lists", request.SignerLists);
WriteFooter(jsonWriter);
jsonWriter.WriteEndObject();
jsonWriter.Flush();
var response = await SendReceiveAsync(requestId, jsonBuffer.WrittenMemory, cancellationToken);
return(new AccountInfoResponse(response));
}
public void AccountInfo()
{
// Arrange
var request = new AccountInfoRequest();
request.Params.Add(new AccountInfoRequestParams
{
Account = "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
LedgerIndex = LedgerIndex.Validated.ToLower(),
Strict = true
});
// Act
var response = _client.AccountInformation.AccountInfoAsync(request).Result;
// Assert
Assert.AreEqual(Status.Success, response.Result.Status);
}
public void Test_AccountInfo_Success()
{
var req = new AccountInfoRequest(FakeToken);
var message = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{\"usage\": 26038531,\"total\": 104857600,\"email\": \"[email protected]\"}")
};
Assert.IsTrue(req.WasSuccessful(message));
var result = ExecuteSync(() => req.ParseResponseAsync(message));
Assert.IsNotNull(result);
Assert.IsFalse(result.HasUnlimitedSpace);
Assert.AreEqual(26038531, result.Usage);
Assert.AreEqual(104857600, result.Quota);
Assert.AreEqual("*****@*****.**", result.Email);
}
protected void load()
{
string str = "";
string str1 = "";
AccountInfoRequest accountinforequest = new AccountInfoRequest();
accountinforequest.api_password = SessionKey.apipass;
accountinforequest.api_username = SessionKey.apiuser;
accountinforequest.merchant_id = SessionKey.merchantid;
AccountInfoResponse accountinforespone = new AccountInfoResponse();
BKPaymentProService2 bk=new BKPaymentProService2();
accountinforespone=bk.GetAccountInfo(accountinforequest);
if (accountinforespone.error_code == "0")
{
PaymentMethod[] paymnet_id = accountinforespone.account_info.payment_methods;
foreach (var item in paymnet_id)
{
string url = item.logo_url;
string id = item.id;
string name = item.name;
/*1 =>"Các loại thẻ ATM trong nước",
2 =>"Các loại thẻ Tín dụng quốc tế",
3 =>"Chuyển khoản bằng Internet Banking",
4 =>"Chuyển khoản bằng máy ATM",
5 =>"Chuyển khoản tiền mặt tại quầy giao dịch"
* */
if (item.payment_method_type == "1")//so sanh xem nó là hình thức nào có 5 hình thức là atm, interbanking
{
str = str + " <div class='bank'><a title='"+name+"' href='Pay.aspx?payment_method_id=" + id + "' style='padding-left:5px; padding-bottom:5px;'><img class='img-v' src='" + url + "' /></a></div>";
Literal2.Text = str;
//... anh lấy nó ra
}
else if (item.payment_method_type == "2")
{
str1 = str1 + " <div class='bank'><a title='"+name+"' href='Pay.aspx?payment_method_id=" + id + "' style='padding-left:5px; padding-bottom:5px;'><img class='img-v' src='" + url + "' /></a></div>";
Literal3.Text = str1;
}
}
}
else
Literal2.Text = accountinforespone.error_message;
}
public AccountInfoRequest ToRequest()
{
var request = new AccountInfoRequest
{
Inn = inn,
RegistrationNumberFss = fssRegNumber,
RegistrationNumberPfr = pfrRegNumber
};
if (kpp != null)
{
request.Organization = new OrganizationInfoRequest
{
Kpp = kpp
};
}
return(request);
}
/// <summary>
/// Create a seafile session for the given authentication token
/// Will automatically connect to the seafile server and check if the token is valid
/// and retrieve the username for the given token using the given ISeafWebConnection
/// </summary>
public static async Task <SeafSession> FromToken(ISeafWebConnection seafWebConnection, Uri serverUri, string authToken)
{
if (seafWebConnection == null)
{
throw new ArgumentNullException(nameof(seafWebConnection));
}
if (serverUri == null)
{
throw new ArgumentNullException(nameof(serverUri));
}
if (authToken == null)
{
throw new ArgumentNullException(nameof(authToken));
}
// get the user for the token and check if the token is valid at the same time
var infoRequest = new AccountInfoRequest(authToken);
var accInfo = await seafWebConnection.SendRequestAsync(serverUri, infoRequest);
return(new SeafSession(seafWebConnection, accInfo.Email, serverUri, authToken));
}
/// <summary>
/// Wait for the account to exist in a validated ledger, then return current information.
/// </summary>
public static async Task <AccountInfoResponse> WaitForAccount(Api api, AccountId account)
{
var terminationTimeout = DateTime.UtcNow + TimeSpan.FromMinutes(5.0);
var infoRequest = new AccountInfoRequest()
{
Ledger = LedgerSpecification.Validated,
Account = account,
};
AccountInfoResponse infoResponse = null;
while (infoResponse == null)
{
try
{
infoResponse = await api.AccountInfo(infoRequest);
}
catch (RippleRequestException exc)
{
if (DateTime.UtcNow > terminationTimeout)
{
throw new Exception(string.Format("Could not find account {0} within 5 minutes", account));
}
if (exc.Error != "actNotFound")
{
throw;
}
}
if (infoResponse == null)
{
System.Threading.Thread.Sleep(1000);
}
}
infoRequest.Ledger = LedgerSpecification.Current;
return(await api.AccountInfo(infoRequest));
}
public Task <AccountInfo> AccountInfo(string account)
{
AccountInfoRequest request = new AccountInfoRequest(account);
return(AccountInfo(request));
}
/// <summary>
/// Get detailed information about user payment account
/// </summary>
/// <remarks>
/// User identification based on access token
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='getAccountRequest'>
/// Data for Account Request
/// </param>
public static object GetAccount(this IPolishAPI operations, AccountInfoRequest getAccountRequest)
{
return(operations.GetAccountAsync(getAccountRequest).GetAwaiter().GetResult());
}
/// <summary>
/// Get detailed information about user payment account
/// </summary>
/// <remarks>
/// User identification based on access token
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='getAccountRequest'>
/// Data for Account Request
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> GetAccountAsync(this IPolishAPI operations, AccountInfoRequest getAccountRequest, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.GetAccountWithHttpMessagesAsync(getAccountRequest, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// List all accounts available from the service
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <Account> > ListAccounts()
{
// Ensure service catalog is populated
await PopulateServiceProfiles();
// Retrieve request profile for this message set
var requestProfile = GetMessageSetRequestProfile(typeof(SignupMessageSetV1));
// Populate the account info request
var accountInfoRequest = new AccountInfoRequest {
DTACCTUP = "19970101"
};
// Use an early date for "last update" so we always retrieve information
// Wrap the request in a transaction
var transaction = new AccountInfoTransactionRequest
{
TRNUID = GetNextTransactionId(),
ACCTINFORQ = accountInfoRequest
};
var messageSet = new SignupRequestMessageSetV1 {
Items = new AbstractRequest[1] {
transaction
}
};
// Gather all message sets in the request
var requestMessageSets = new List <AbstractTopLevelMessageSet>
{
CreateSignonRequest(userCredentials, requestProfile),
messageSet
};
// Send to service and await response
Protocol.OFX response = await new Transport(requestProfile.ServiceEndpoint).sendRequestAsync(requestMessageSets.ToArray());
// TODO: Check response for errors
// Walk nested elements to find accounts
List <Account> accountList = new List <Account>();
foreach (var responseMessageSet in response.Items.Where(item => item.GetType() == typeof(SignupResponseMessageSetV1)).Select(item => (SignupResponseMessageSetV1)item))
{
foreach (
var transactionResponse in
responseMessageSet.Items.Where(item => item.GetType() == typeof(AccountInfoTransactionResponse))
.Select(item => (AccountInfoTransactionResponse)item))
{
// Iterate each account
foreach (var accountInfo in transactionResponse.ACCTINFORS.ACCTINFO)
{
var specificAccountInfo = accountInfo.Items[0];
// Create appropriate account type entry
if (specificAccountInfo.GetType() == typeof(BankAccountInfo))
{
// There are multiple types of bank accounts we support
var bankAccountInfo = (BankAccountInfo)specificAccountInfo;
accountList.Add(Account.Create(bankAccountInfo.BANKACCTFROM));
}
if (specificAccountInfo.GetType() == typeof(CreditCardAccountInfo))
{
var creditAccountInfo = (CreditCardAccountInfo)specificAccountInfo;
accountList.Add(Account.Create(creditAccountInfo.CCACCTFROM));
}
}
}
}
return(accountList);
}
public async Task <RpcJsonResponse <AccountInfoResult> > AccountInfoAsync(AccountInfoRequest request)
{
return(await PostAsync <RpcJsonResponse <AccountInfoResult>, AccountInfoResult>(request));
}
/// <summary>
/// Retrieve the account info for the current session
/// </summary>
/// <returns></returns>
public async Task <AccountInfo> CheckAccountInfo()
{
var req = new AccountInfoRequest(AuthToken);
return(await _webConnection.SendRequestAsync(ServerUri, req));
}
// GET: UserLogged
public async Task <ActionResult> Logged(string code, string state, string error, string redirect)
{
if (redirect == null)
{
return(new EmptyResult());
}
var client = new HttpClient();
var payload = new Dictionary <string, string>()
{
{ "sub", "*****@*****.**" }
};
this._signCertificate.Import(ReadFile(this.signCertPath), "millennium", X509KeyStorageFlags.DefaultKeySet);
string tokenSigned = JWT.Encode(payload, this._signCertificate.GetRSAPrivateKey(), JwsAlgorithm.RS256);
var link = string.Format(
"https://bm-devportal-testwebapp03.azurewebsites.net/tokens?code={0}&redirect_uri={1}&client_id={2}&client_assertion={3}",
code, "http://*****:*****@bankmillennium.pl", tokenSigned);
var result = await client.GetAsync(link);
var token = await result.Content.ReadAsAsync <TokenModel>();
this.Session["userTokenData"] = token;
this._tlsCertificate.Import(ReadFile(this.tlsCertPath), "millennium", X509KeyStorageFlags.DefaultKeySet);
this._signCertificate.Import(ReadFile(this.signCertPath), "millennium", X509KeyStorageFlags.DefaultKeySet);
var httpHandler = new WebRequestHandler();
httpHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
httpHandler.ClientCertificates.Add(this._tlsCertificate);
var api = new PolishAPI(httpHandler, new RequestSigningHandler(this._signCertificate));
var request = new AccountsRequest(
new RequestHeaderAIS(token.accessToken, Guid.NewGuid().ToString(), sendDate: DateTime.Now.ToString(), tppId: "*****@*****.**", isDirectPsu: true),
true,
null,
0);
api.BaseUri = new Uri("https://bm-devportal-testwebapp02.azurewebsites.net");
api.AcceptLanguage = "pl-PL";
api.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", "Bearer " + token.accessToken);
api.XJWSSIGNATURE = JWT.Encode(JsonConvert.SerializeObject(request), this._signCertificate.GetRSAPrivateKey(),
JwsAlgorithm.RS256);
var result2 = await api.GetAccountsWithHttpMessagesAsync(request);
var model = result2.Body as AccountsResponse;
var account = model.Accounts.First();
var request2 = new AccountInfoRequest
{
AccountNumber = account.AccountNumber,
RequestHeader =
new RequestHeaderAIS(token.accessToken, Guid.NewGuid().ToString(),
sendDate: DateTime.Now.ToString(), tppId: "*****@*****.**", isDirectPsu: true)
};
var result3 = await api.GetAccountWithHttpMessagesAsync(request2);
var accountInfo = result3.Body as AccountResponse;
return(View(accountInfo.Account));
}
private void SendSelectedRequest()
{
switch (DataContainer.Data[_listBoxSelectedIndexNo].MsgType)
{
case "U1000":
MsgAIR requestData = (MsgAIR)DataContainer.Data[_listBoxSelectedIndexNo];
AccountInfoRequest request = new AccountInfoRequest();
request.Set(new Account(Properties.Settings.Default.Account));
request.Set(new AccReqID(requestData.AccReqID));
//testforJack
//request.Set(new SubscriptionRequestType('1'));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "D":
MsgNOSR requestData1 = (MsgNOSR)DataContainer.Data[_listBoxSelectedIndexNo];
NewOrderSingle request1 = new NewOrderSingle();
request1.Set(new Account(Properties.Settings.Default.Account));
request1.Set(new ClOrdID(requestData1.ClOrdID));
request1.Set(new OrderQty(decimal.Parse(requestData1.OrderQty)));
request1.Set(new OrdType(char.Parse(requestData1.OrdType)));
request1.Set(new Side(char.Parse(requestData1.Side)));
request1.Set(new Symbol(requestData1.Symbol));
request1.Set(new TransactTime(DateTime.Now));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request1, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "H":
MsgOSR requestData2 = (MsgOSR)DataContainer.Data[_listBoxSelectedIndexNo];
OrderStatusRequest request2 = new OrderStatusRequest();
request2.Set(new Account(Properties.Settings.Default.Account));
request2.Set(new ClOrdID(requestData2.ClOrdID));
request2.Set(new Side(char.Parse(requestData2.Side)));
request2.Set(new Symbol(requestData2.Symbol));
request2.Set(new OrderID(requestData2.OrderID));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request2, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "AF2":
MsgBOIR requestData3 = (MsgBOIR)DataContainer.Data[_listBoxSelectedIndexNo];
OrderMassStatusRequest request3 = new OrderMassStatusRequest();
request3.Set(new Account(Properties.Settings.Default.Account));
request3.Set(new Symbol(requestData3.Symbol));
request3.Set(new MassStatusReqID(requestData3.MassStatusReqID));
//request3.Set(new NoStatuses(int.Parse(requestData3.GroupNums)));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request3, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "G":
MsgOCRR requestData4 = (MsgOCRR)DataContainer.Data[_listBoxSelectedIndexNo];
OrderCancelReplaceRequest request4 = new OrderCancelReplaceRequest();
request4.Set(new Account(Properties.Settings.Default.Account));
request4.Set(new ClOrdID(requestData4.ClOrdID));
request4.Set(new OrderQty(decimal.Parse(requestData4.OrderQty)));
request4.Set(new OrderID(requestData4.OrderID));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request4, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "F":
MsgOCR requestData5 = (MsgOCR)DataContainer.Data[_listBoxSelectedIndexNo];
OrderCancelRequest request5 = new OrderCancelRequest();
request5.Set(new Account(Properties.Settings.Default.Account));
request5.Set(new ClOrdID(requestData5.ClOrdID));
request5.Set(new OrderID(requestData5.OrderID));
request5.Set(new Symbol(requestData5.Symbol));
request5.Set(new TransactTime(DateTime.Now));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request5, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
default:
break;
}
}
// Token: 0x060003AD RID: 941 RVA: 0x0003FF88 File Offset: 0x0003E188
private async void YandexMoney_LoadAsync(object sender, EventArgs e)
{
this.labelProxy.Text = YandexMoney._proxyStatus;
this.ClientId = Settings.Default.YansexClientId;
this.RedirectUri = Settings.Default.YandexRedirectUri;
YandexMoney.auth.Token = Settings.Default.YandexToken;
bool flag = string.IsNullOrEmpty(this.ClientId) || string.IsNullOrEmpty(this.RedirectUri);
if (flag)
{
this.label1.Text = "Заполните настройки.";
}
else
{
try
{
this.webBrowser1.Visible = false;
this.label1.Text = "Проверка подключения.";
Label label = this.label1;
double?num = await YandexMoney.GetYandexBalanceAsync();
label.Text = "Подключено. Баланс = " + num;
label = null;
num = null;
string text = await YandexMoney.GetYandexOrderHistoryAsync();
string hist = text;
text = null;
this.labelHist.Text = hist;
return;
}
catch (Exception ex)
{
this.label1.Text = "Не подключено: " + ex.Message;
this.webBrowser1.Visible = true;
}
this.webBrowser1.Refresh();
YandexMoney.Wrapper wrapper = new YandexMoney.Wrapper(this.webBrowser1);
YandexMoney.AuthorizationBroker ab = new YandexMoney.AuthorizationBroker();
string text2 = await ab.AuthorizeAsync(YandexMoney.Connection, wrapper, YandexMoney.hp.AuthorizationdUri.ToString(), new AuthorizationRequestParams
{
ClientId = this.ClientId,
RedirectUri = this.RedirectUri,
Scope = Scopes.Compose(new string[]
{
Scopes.AccountInfo,
Scopes.OperationHistory,
Scopes.OperationDetails
})
});
string token = text2;
text2 = null;
YandexMoney.auth.Token = token;
Settings.Default.YandexToken = token;
Settings.Default.Save();
AccountInfoRequest <AccountInfoResult> accountInfoRequest = new AccountInfoRequest <AccountInfoResult>(YandexMoney.Connection, new JsonSerializer <AccountInfoResult>());
AccountInfoResult accountInfoResult2 = await accountInfoRequest.Perform();
AccountInfoResult accountInfoResult = accountInfoResult2;
accountInfoResult2 = null;
this.label1.Text = "Подключено. Баланс = " + accountInfoResult.Balance;
}
}