public async Task TestAccountUpdate_Fail(string accountId, string updatedTradingConditionId,
decimal updatedWithdrawTransferLimit, bool isDisabled, bool isWithdrawalDisabled, string failMessage)
{
var account = Accounts.Single(x => x.Id == accountId);
var time = DateService.Now();
var accountsProjection = AssertEnv(failMessage: failMessage);
var updatedContract = new AccountContract()
{
Id = accountId,
ClientId = account.ClientId,
TradingConditionId = updatedTradingConditionId,
BaseAssetId = account.BaseAssetId,
Balance = account.Balance,
WithdrawTransferLimit = updatedWithdrawTransferLimit,
LegalEntity = account.LegalEntity,
IsDisabled = isDisabled,
ModificationTimestamp = account.ModificationTimestamp,
IsWithdrawalDisabled = account.IsWithdrawalDisabled,
IsDeleted = false,
AdditionalInfo = "{}"
};
await accountsProjection.Handle(new AccountChangedEvent(time, "test",
updatedContract, AccountChangedEventTypeContract.Updated));
Assert.AreEqual(1, _logCounter);
}
private void GetAccount(AccountContract accountContract)
{
var connect = new Connector.Banking.GenericConnect <AccountResponse>();
var request = new Types.Banking.AccountRequest();
request.accountContract = accountContract;
request.MethodName = "GetAccounts";
var response = connect.Execute(request);
if (response.IsSuccess == true)
{
/*
* _accountId = response.accountContracts[0].Id;
* txtIban.Text = response.accountContracts[0].IBAN;
* cbCurrencyCode.SelectedValue = response.accountContracts[0].FECId;
* txtBalance.Text = response.accountContracts[0].Balance.ToString();
*/
return;
}
else
{
MessageBox.Show("Hesap getirilirken hata oluştu!");
}
return;
}
public async Task <AccountContract> CreateAccount(string login, string password)
{
try
{
await Db.ExecuteAsync("insert into accounts (Login,Password,LastActive,access_level,LastServer) Values (@login,@pass,@lastactive,@access,@lastServer)", new
{
login = login,
pass = password,
lastactive = DateTime.Now.Ticks,
access = 0,
lastServer = 1
}); //to be edited
var accContract = new AccountContract
{
Login = login,
Password = password,
LastActive = DateTime.Now.Ticks,
AccessLevel = 0,
LastServer = 1
};
return(accContract);
}
catch (MySqlException ex)
{
Log.Error($"Method: {nameof(CreateAccount)}. Message: '{ex.Message}' (Error Number: '{ex.Number}')");
return(null);
}
}
public bool GetAccount(AccountContract accountContract)
{
var connect = new Connector.Banking.GenericConnect <AccountResponse>();
var request = new Types.Banking.AccountRequest();
request.accountContract = accountContract;
request.MethodName = "GetAccount";
var response = connect.Execute(request);
if (response.IsSuccess == true)
{
ucCustomer.selectedComboboxValue = accountContract.AccountOwnerId;
txtAccountSuffix.Text = response.accountContract.Suffix.ToString();
cbCurrencyCode.SelectedValue = response.accountContract.FECId;
cbAccounBranchCode.SelectedValue = response.accountContract.BranchId;
dpOpenDate.SelectedDate = response.accountContract.OpenDate;
if (response.accountContract.CloseDate != null)
{
dpClosureDate.SelectedDate = response.accountContract.CloseDate;
}
txtAccountReasonForClosing.Text = response.accountContract.ReasonForClosing;
txtAccountIBAN.Text = response.accountContract.IBAN;
txtAccountName.Text = response.accountContract.AccountName;
txtAccountDesc.Text = response.accountContract.AccountDescription;
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// OperationId is defined optional just to extend the message pack object - the parameter is still mandatory.
/// </summary>
public AccountChangedEvent(DateTime changeTimestamp,
[NotNull] string source,
[NotNull] AccountContract account,
AccountChangedEventTypeContract eventType,
AccountBalanceChangeContract balanceChange = null,
string operationId = null,
string activitiesMetadata = null)
{
if (!Enum.IsDefined(typeof(AccountChangedEventTypeContract), eventType))
{
throw new InvalidEnumArgumentException(
nameof(eventType),
(int)eventType,
typeof(AccountChangedEventTypeContract));
}
if (changeTimestamp == default(DateTime))
{
throw new ArgumentOutOfRangeException(nameof(changeTimestamp));
}
Source = source;
ChangeTimestamp = changeTimestamp;
Account = account ?? throw new ArgumentNullException(nameof(account));
EventType = eventType;
ActivitiesMetadata = activitiesMetadata;
BalanceChange = balanceChange;
OperationId = operationId;
}
public ActionResult UploadAction()
{
string fileName = Guid.NewGuid().ToString();
//遍历所有文件域
foreach (string fieldName in Request.Files.AllKeys)
{
HttpPostedFileBase file = Request.Files[fieldName];
string virtualPath = string.Format("~/Images/HeadImage/{0}.jpg", fileName);
string imagePath = string.Format("../../Images/HeadImage/{0}.jpg", fileName);
file.SaveAs(Server.MapPath(virtualPath));
MemberView updateInfo = new MemberView();
updateInfo.HeadImage = imagePath;
updateInfo.UserName = ((SystemUser)Session["SystemUser"]).UserName;
updateInfo.IsDeleted = ((SystemUser)Session["SystemUser"]).IsDeleted;
updateInfo.IsStartUse = ((SystemUser)Session["SystemUser"]).IsStartUse;
updateInfo.Id = ((SystemUser)Session["SystemUser"]).Id;
updateInfo.NickName = ((SystemUser)Session["SystemUser"]).NickName;
updateInfo.Password = ((SystemUser)Session["SystemUser"]).Password;
updateInfo.AddDate = ((SystemUser)Session["SystemUser"]).AddDate;
updateInfo.ContactNumber = ((SystemUser)Session["SystemUser"]).ContactNumber;
updateInfo.Email = ((SystemUser)Session["SystemUser"]).Email;
((SystemUser)Session["SystemUser"]).HeadImage = imagePath;
AccountContract.Update(updateInfo);
}
OperationResultType result = OperationResultType.Success;
return(Json(result));
}
private void btnAccountFilter_Click(object sender, RoutedEventArgs e)
{
_accountContract = new AccountContract();
if (txtAccountCustomerNo.Text == null || txtAccountCustomerNo.Text == "")
{
_accountContract.AccountOwnerId = 0;
}
else
{
_accountContract.AccountOwnerId = Convert.ToInt32(txtAccountCustomerNo.Text);
}
if (txtAccountSuffix.Text == null || txtAccountSuffix.Text == "")
{
_accountContract.Suffix = 0;
}
else
{
_accountContract.Suffix = Convert.ToInt32(txtAccountSuffix.Text);
}
if (_accountContract.AccountOwnerId == 0 && _accountContract.Suffix == 0)
{
AccountAll(); return;
}
GetAccounts(_accountContract);
}
private void btnKaydet_Click(object sender, RoutedEventArgs e)
{
Account.CustomerId = cusComCustomer.Customer.CustomerId;
if (isEditingOption)
{
if (MessageBox.Show("Yaptığınız değişlikler hesaba yansısın mı?", "Onay", MessageBoxButton.YesNoCancel, MessageBoxImage.Question) == MessageBoxResult.Yes)
{
if (UpdateAccount(Account) != null)
{
MessageBox.Show("Değişiklikler uygulandı!", "Başarılı", MessageBoxButton.OK, MessageBoxImage.Information);
btnVazgec_Click(new object(), new RoutedEventArgs());
cusComCustomer.Customer = new CustomerContract();
}
}
return;
}
Account.FormedUserId = Login.LoginScreen._userId;
if (AddAccount(Account) != null)
{
MessageBox.Show("Hesap eklendi!", "Başarılı", MessageBoxButton.OK, MessageBoxImage.Information);
Account = new AccountContract();
cusComCustomer.Customer = new CustomerContract();
}
}
private void GetAccountLastSuffixNumber(AccountContract accountContract)
{
var connect = new Connector.Banking.GenericConnect <AccountResponse>();
var request = new Types.Banking.AccountRequest();
request.accountContract = accountContract;
request.MethodName = "GetAccountLastSuffixNumber";
var response = connect.Execute(request);
suffix = response.suffix;
if (accountContract.FECId == 1)
{
suffix = suffix + 1;
return;
}
else if (suffix == 0 && accountContract.FECId == 2)
{
suffix = 200;
return;
}
else if (accountContract.FECId == 2)
{
suffix = response.suffix + 1;
return;
}
}
private void GetSuffix(AccountContract accountContract)
{
//tüm hesaplar
var connect = new Connector.Banking.GenericConnect <AccountResponse>();
var request = new Types.Banking.AccountRequest();
request.accountContract = accountContract;
request.MethodName = "GetAccounts";
var response = connect.Execute(request);
if (response.IsSuccess == true)
{
_accountContracts = response.accountContracts;
cbAccountSuffix.ItemsSource = response.accountContracts;
cbAccountSuffix.Items.Refresh();
cbAccountSuffix.DisplayMemberPath = "Suffix";
cbAccountSuffix.SelectedValuePath = "Suffix";
cbAccountSuffix.IsEnabled = true;
return;
}
else
{
MessageBox.Show("Hesaplar getirilirken hata oluştu!");
}
return;
}
private void GetAccount(AccountContract accountContract)
{
var connect = new BOA.Connector.Banking.GenericConnect <AccountResponse>();
var request = new BOA.Types.Banking.AccountRequest();
request.accountContract = accountContract;
request.MethodName = "GetAccounts";
var response = connect.Execute(request);
if (response.IsSuccess)
{
txtBranchName.Text = response.accountContracts[0].branchContract.Name;
txtCustomerName.Text = response.accountContracts[0].customerDetailContract.Name + " " + response.accountContracts[0].customerDetailContract.SurName;
txtFECName.Text = response.accountContracts[0].fecContract.Name;
txtBalance.Text = response.accountContracts[0].Balance.ToString();
txtAvaibleBalance.Text = response.accountContracts[0].Balance.ToString();
txtTCNo.Text = response.accountContracts[0].customerDetailContract.TaxNumber;
txtIBAN.Text = response.accountContracts[0].IBAN;
GetSuffix(response.accountContracts[0].AccountOwnerId);
return;
}
else
{
MessageBox.Show("Müşteri bulunamadı!", "Message", MessageBoxButton.OK, MessageBoxImage.Error);
clearContent();
}
return;
}
public bool DeleteAccount(AccountContract accountContract)
{
SqlDataReader dr;
dr = dbOperation.SpGetData("acc.del_account", new SqlParameter[] {
new SqlParameter("@Id", accountContract.Id),
});
return(true);
/*
* while (dr.Read())
* {
*
* account.Id = (int)dr[0];
* account.AccountOwnerId = (int)dr[1];
* account.Suffix = (int)dr[2];
* account.FECId = (int)dr[3];
* account.BranchId = (int)dr[4];
* account.Balance = (decimal)dr[5];
* account.OpenDate = (DateTime)dr[6];
* if (dr[7] != DBNull.Value) { account.CloseDate = (DateTime)dr[7]; }
* account.ReasonForClosing = dr[8].ToString();
* account.IBAN = dr[9].ToString();
* account.AccountName = dr[10].ToString();
* account.AccountDescription = dr[11].ToString();
* account.Username = (int)dr[12];
* account.SystemDate = (DateTime)dr[13];
*
* }*/
}
private object RouteRegisterName(HTTPRequest request)
{
var name = request.GetVariable("name");
var context = InitContext(request);
if (AccountContract.ValidateName(name))
{
if (context["holdings"] is Holding[] balance)
{
var soulBalance = balance.SingleOrDefault(b => b.Symbol == "SOUL");
if (soulBalance.Amount > 0.1m) //RegistrationCost
{
var keyPair = GetLoginKey(request);
var registerTx = AccountController.RegisterName(keyPair, name).Result;
if (SendUtils.IsTxHashValid(registerTx))
{
return(registerTx);
}
PushError(request, registerTx);
}
else
{
PushError(request, "You need a small drop of SOUL (+0.1) to register a name.");
}
}
}
else
{
PushError(request, "Error while registering name.");
}
return("");
}
public async Task TestAccountBalanceUpdate_Success(string accountId, decimal changeAmount,
AccountBalanceChangeReasonTypeContract balanceChangeReasonType)
{
var account = Accounts.Single(x => x.Id == accountId);
var time = DateService.Now().AddMinutes(1);
var accountsProjection = AssertEnv(accountId: accountId);
var updatedContract = new AccountContract(accountId, account.ClientId, account.TradingConditionId,
account.BaseAssetId, changeAmount, account.WithdrawTransferLimit, account.LegalEntity,
account.IsDisabled, account.ModificationTimestamp, account.IsWithdrawalDisabled, false);
await accountsProjection.Handle(new AccountChangedEvent(time, "test",
updatedContract, AccountChangedEventTypeContract.BalanceUpdated,
new AccountBalanceChangeContract("test", time, accountId, account.ClientId, changeAmount,
account.Balance + changeAmount, account.WithdrawTransferLimit, "test", balanceChangeReasonType,
"test", "Default", null, null, time)));
var resultedAccount = _accountsCacheService.Get(accountId);
Assert.AreEqual(account.Balance + changeAmount, resultedAccount.Balance);
if (balanceChangeReasonType == AccountBalanceChangeReasonTypeContract.Withdraw)
{
_accountUpdateServiceMock.Verify(s => s.UnfreezeWithdrawalMargin(accountId, "test"), Times.Once);
}
if (balanceChangeReasonType == AccountBalanceChangeReasonTypeContract.UnrealizedDailyPnL)
{
_fakePosition.Verify(s => s.ChargePnL("test", changeAmount), Times.Once);
}
_accountBalanceChangedEventChannelMock.Verify(s => s.SendEvent(It.IsAny <object>(),
It.IsAny <AccountBalanceChangedEventArgs>()), Times.Once);
}
private void btnClearFilter_Click(object sender, RoutedEventArgs e)
{
_accountContract = new AccountContract();
txtAccountCustomerNo.Text = "";
txtAccountSuffix.Text = "";
AccountAll();
}
public static async Task <AccountContract> EnsureAccountState(decimal neededBalance = 0)
{
var account = await ClientUtil.AccountsApi.GetById(AccountId);
if (account == null)
{
account = await ClientUtil.AccountsApi.Create(new CreateAccountRequest
{
AccountId = AccountId,
BaseAssetId = "EUR",
});
}
if (account.Balance != neededBalance)
{
await ChargeManually(neededBalance - account.Balance);
account = new AccountContract(account.Id, account.ClientId, account.TradingConditionId,
account.BaseAssetId, neededBalance, account.WithdrawTransferLimit, account.LegalEntity,
account.IsDisabled, account.ModificationTimestamp, account.IsWithdrawalDisabled);
}
if (account.IsDisabled)
{
account = await ClientUtil.AccountsApi.Change(AccountId, new ChangeAccountRequest
{
IsDisabled = false,
});
}
return(account);
}
public void CreateNewAccount(string name)
{
AccountContract acc = new AccountContract();
acc.Name = name;
acc.Balance = 0;
accounts.Add(acc);
}
private static MarginTradingAccount Convert(AccountContract accountContract)
{
return(ConvertService.Convert <AccountContract, MarginTradingAccount>(accountContract,
o => o.ConfigureMap(MemberList.Source)
.ForMember(d => d.LastUpdateTime,
a => a.MapFrom(x =>
x.ModificationTimestamp))));
}
public SmartContract FindContract(string contractName)
{
Throw.IfNullOrEmpty(contractName, nameof(contractName));
if (_contractCache.ContainsKey(contractName))
{
return(_contractCache[contractName]);
}
SmartContract contract;
switch (contractName)
{
case "nexus": contract = new NexusContract(); break;
case "consensus": contract = new ConsensusContract(); break;
case "governance": contract = new GovernanceContract(); break;
case "account": contract = new AccountContract(); break;
case "friends": contract = new FriendContract(); break;
case "exchange": contract = new ExchangeContract(); break;
case "market": contract = new MarketContract(); break;
case "energy": contract = new EnergyContract(); break;
case "token": contract = new TokenContract(); break;
case "swap": contract = new SwapContract(); break;
case "gas": contract = new GasContract(); break;
case "relay": contract = new RelayContract(); break;
case "storage": contract = new StorageContract(); break;
case "vault": contract = new VaultContract(); break;
case "bank": contract = new BankContract(); break;
case "apps": contract = new AppsContract(); break;
case "dex": contract = new ExchangeContract(); break;
case "nacho": contract = new NachoContract(); break;
case "casino": contract = new CasinoContract(); break;
default:
throw new Exception("Unknown contract: " + contractName);
}
_contractCache[contractName] = contract;
return(contract);
}
public ActionResult updateUserInfo(MemberView user)
{
SystemUser SystemUser = AccountContract.SysUsers.FirstOrDefault(m => m.Id == user.Id);
user.AddDate = SystemUser.AddDate;
user.HeadImage = SystemUser.HeadImage;
AccountContract.Update(user);
return(View());
}
public void AwaitAccount(AccountContract ta)
{
if (_awaitingAccounts.ContainsKey(ta.Login))
{
_awaitingAccounts.Remove(ta.Login);
}
_awaitingAccounts.Add(ta.Login, ta);
}
public void AwaitAddAccount(AccountContract account, SessionKey key)
{
if (_awaitingAccounts.ContainsKey(account.Login))
{
_awaitingAccounts.Remove(account.Login);
}
_awaitingAccounts.Add(account.Login, new Tuple <AccountContract, SessionKey, DateTime>(account, key, DateTime.UtcNow));
}
private MarginTradingAccount Convert(AccountContract accountContract, DateTime eventTime)
{
var retVal = _convertService.Convert <AccountContract, MarginTradingAccount>(accountContract,
o => o.ConfigureMap(MemberList.Source)
.ForSourceMember(x => x.ModificationTimestamp, c => c.Ignore()));
retVal.LastBalanceChangeTime = eventTime;
return(retVal);
}
public override void RunImpl()
{
AccountContract ta = new AccountContract
{
Login = _account
};
_login.AwaitAccount(ta);
}
public override void RunImpl()
{
AccountContract ta = new AccountContract
{
Login = _account
};
AuthThread.Instance.AwaitAccount(ta);
}
public AccountContract GetAccount(AccountContract accountContract)
{
SqlDataReader dr;
dr = dbOperation.SpGetData("acc.sel_account", new SqlParameter[] {
new SqlParameter("@Id", accountContract.Id),
});
AccountContract account = new AccountContract();
while (dr.Read())
{
account.Id = (int)dr[0];
account.AccountOwnerId = (int)dr[1];
account.Suffix = (int)dr[2];
account.FECId = (int)dr[3];
account.BranchId = (int)dr[4];
account.Balance = (decimal)dr[5];
account.OpenDate = (DateTime)dr[6];
if (dr[7] != DBNull.Value)
{
account.CloseDate = (DateTime)dr[7];
}
account.ReasonForClosing = dr[8].ToString();
account.IBAN = dr[9].ToString();
account.AccountName = dr[10].ToString();
account.AccountDescription = dr[11].ToString();
account.Username = (int)dr[12];
account.SystemDate = (DateTime)dr[13];
account.customerDetailContract.Id = (int)dr[14];
account.customerDetailContract.Name = dr[15].ToString();
account.customerDetailContract.SurName = dr[16].ToString();
account.customerDetailContract.TaxNumber = dr[17].ToString();
account.customerDetailContract.BirthPlace = dr[18].ToString();
account.customerDetailContract.BirthDate = (DateTime)dr[19];
account.customerDetailContract.MomName = dr[20].ToString();
account.customerDetailContract.FatherName = dr[21].ToString();
account.customerDetailContract.jobContract.Id = (int)dr[22];
account.customerDetailContract.jobContract.Name = dr[23].ToString();
account.customerDetailContract.educationContract.Id = (int)dr[24];
account.customerDetailContract.educationContract.Name = dr[25].ToString();
account.fecContract.Id = (int)dr[26];
account.fecContract.Code = dr[27].ToString();
account.fecContract.Name = dr[28].ToString();
account.fecContract.Symbol = dr[29].ToString();
account.branchContract.Id = (int)dr[30];
account.branchContract.Code = dr[31].ToString();
account.branchContract.Name = dr[32].ToString();
}
return(account);
}
public async Task TestAccountBalanceUpdate_Success(string accountId, decimal changeAmount,
AccountBalanceChangeReasonTypeContract balanceChangeReasonType, string auditLog)
{
var account = Accounts.Single(x => x.Id == accountId);
var time = DateService.Now().AddMinutes(1);
var accountsProjection = AssertEnv(accountId: accountId);
var updatedContract = new AccountContract()
{
Id = accountId,
ClientId = account.ClientId,
TradingConditionId = account.TradingConditionId,
BaseAssetId = account.BaseAssetId,
Balance = account.Balance,
WithdrawTransferLimit = account.WithdrawTransferLimit,
LegalEntity = account.LegalEntity,
IsDisabled = account.IsDisabled,
ModificationTimestamp = account.ModificationTimestamp,
IsWithdrawalDisabled = account.IsWithdrawalDisabled,
IsDeleted = false,
AdditionalInfo = "{}"
};
await accountsProjection.Handle(new AccountChangedEvent(time, "test",
updatedContract, AccountChangedEventTypeContract.BalanceUpdated,
new AccountBalanceChangeContract("test", time, accountId, account.ClientId, changeAmount,
account.Balance + changeAmount, account.WithdrawTransferLimit, "test", balanceChangeReasonType,
"test", "Default", auditLog, null, time)));
var resultedAccount = _accountsCacheService.Get(accountId);
Assert.AreEqual(account.Balance + changeAmount, resultedAccount.Balance);
if (balanceChangeReasonType == AccountBalanceChangeReasonTypeContract.Withdraw)
{
_accountUpdateServiceMock.Verify(s => s.UnfreezeWithdrawalMargin(accountId, "test"), Times.Once);
}
if (balanceChangeReasonType == AccountBalanceChangeReasonTypeContract.UnrealizedDailyPnL)
{
var metadata = auditLog?.DeserializeJson <UnrealizedPnlMetadataContract>();
if (metadata == null || metadata.RawTotalPnl == 0)
{
_fakePosition.Verify(s => s.ChargePnL("test", changeAmount), Times.Once);
}
else
{
_fakePosition.Verify(s => s.SetChargedPnL("test", metadata.RawTotalPnl), Times.Once);
}
}
_accountBalanceChangedEventChannelMock.Verify(s => s.SendEvent(It.IsAny <object>(),
It.IsAny <AccountBalanceChangedEventArgs>()), Times.Once);
}
public int GetBalance(string accountName)
{
AccountContract acc = accounts.Find(x => x.Name == accountName);
if (acc == null)
{
throw new KeyNotFoundException("Account not found");
}
return(acc.Balance);
}
public override async Task RunImpl()
{
if (_client.State != LoginClientState.AuthedGG)
{
await _client.SendAsync(LoginFail.ToPacket(LoginFailReason.ReasonAccessFailed));
_client.Close();
return;
}
byte[] decrypt = DecryptPacket();
string username = Encoding.ASCII.GetString(decrypt, 0x5e, 14).Replace("\0", string.Empty);
string password = Encoding.ASCII.GetString(decrypt, 0x6c, 16).Replace("\0", string.Empty);
AccountContract account = await _accountService.GetAccountByLogin(username);
if (account == null)
{
if (_config.ServerConfig.AutoCreate)
{
account = await _accountService.CreateAccount(username, password);
}
else
{
await _client.SendAsync(LoginFail.ToPacket(LoginFailReason.ReasonUserOrPassWrong));
_client.Close();
return;
}
}
else
{
if (!await _accountService.CheckIfAccountIsCorrect(username, password))
{
await _client.SendAsync(LoginFail.ToPacket(LoginFailReason.ReasonUserOrPassWrong));
_client.Close();
return;
}
if (LoginServer.ServiceProvider.GetService <ServerThreadPool>().LoggedAlready(account.AccountId))
{
await _client.SendAsync(LoginFail.ToPacket(LoginFailReason.ReasonAccountInUse));
_client.Close();
return;
}
}
_client.ActiveAccount = account;
_client.State = LoginClientState.AuthedLogin;
_client.SendAsync(LoginOk.ToPacket(_client));
}
public Address LookUpName(string name)
{
if (!AccountContract.ValidateName(name))
{
return(Address.Null);
}
var chain = RootChain;
return((Address)chain.InvokeContract("account", "LookUpName", name));
}
