public void Init()
{
_vendingMachine = new VendingMachineObj();
_bankAccount = new BankAccount();
_cashCardA = new CashCard(_bankAccount);
_cashCardB = new CashCard(_bankAccount);
}
public CModifyBalanceWnd(SEconomy parent, IBankAccount BankAccount)
{
this.account = BankAccount;
this.parent = parent;
InitializeComponent();
rbTradeWith.CheckedChanged += (sender, args) => SwitchRegions();
rbSetTo.CheckedChanged += (sender, args) => SwitchRegions();
txtSetCurrency.TextChanged += (sender, args) => ParseMoneyFromControl(sender as TextBox);
txtTradeCurrency.TextChanged += (sender, args) => ParseMoneyFromControl(sender as TextBox);
txtSetCurrency.LostFocus += (sender, args) => ConvertMoneyToNumber(sender as TextBox);
txtTradeCurrency.LostFocus += (sender, args) => ConvertMoneyToNumber(sender as TextBox);
txtSetCurrency.Focus();
ddlTradeAccount.DataSource = parent.RunningJournal.BankAccounts.OrderBy(i => i.UserAccountName).ToList();
ddlTradeAccount.DisplayMember = "UserAccountName";
ddlTradeAccount.ValueMember = "BankAccountK";
this.Text = "Modify Balance - " + account.UserAccountName;
lblCurrencyName.Text = Money.CurrencyName;
lblCurrencyName2.Text = Money.CurrencyName;
}
public virtual int AddNewAccount(AccountType accountType, AccountOrigin origin)
{
IBankAccount newBankAccount = IAccountsFactory.CreateAccount(accountType, origin, nextNumber++);
accounts.Add(newBankAccount.AccountNumber, newBankAccount);
return(newBankAccount.AccountNumber);
}
/// <summary>
/// Called after LoadSEconomy, or on PostInitialize, this binds the current SEconomy instance
/// to the currently running terraria world.
/// </summary>
public async Task BindToWorldAsync()
{
IBankAccount account = null;
if ((WorldAccount = RunningJournal.GetWorldAccount()) == null)
{
TShock.Log.ConsoleError("[SEconomy Bind] The journal system did not return a world account. This is an internal error.");
return;
}
await WorldAccount.SyncBalanceAsync();
TShock.Log.ConsoleInfo(string.Format(SEconomyPlugin.Locale.StringOrDefault(1, "[SEconomy World Account] Paid {0} to players."), WorldAccount.Balance.ToLongString()));
await Task.Delay(5000);
foreach (var player in TShockAPI.TShock.Players)
{
if (player == null ||
string.IsNullOrWhiteSpace(player.Name) == true
//|| string.IsNullOrWhiteSpace(player.User.Name) == true
|| (account = GetBankAccount(player)) == null)
{
continue;
}
await account.SyncBalanceAsync();
}
}
ITransaction FinishEndTransaction(MySqlTransaction SQLTransaction, IBankAccount ToAccount, Money Amount, string Message)
{
MySQLTransaction trans = null;
IBankAccount account = null;
long identity = -1;
string query = @"insert into `bank_account_transaction`
(bank_account_fk, amount, message, flags, flags2, transaction_date_utc)
values (@0, @1, @2, @3, @4, @5);" ;
if ((account = GetBankAccount(ToAccount.BankAccountK)) == null)
{
return(null);
}
trans = new MySQLTransaction(account)
{
Amount = Amount,
BankAccountFK = account.BankAccountK,
Flags = BankAccountTransactionFlags.FundsAvailable,
Message = Message,
TransactionDateUtc = DateTime.UtcNow
};
try {
SQLTransaction.Connection.QueryIdentityTransaction(SQLTransaction, query, out identity, trans.BankAccountFK, (long)trans.Amount, trans.Message,
(int)BankAccountTransactionFlags.FundsAvailable, 0, DateTime.UtcNow);
} catch (Exception ex) {
TShock.Log.ConsoleError(" seconomy mysql: Database error in FinishEndTransaction: " + ex.Message);
return(null);
}
trans.BankAccountTransactionK = identity;
return(trans);
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.BankAccount == null))
{
IBankAccount bankAccountCasted = item.As <IBankAccount>();
if ((bankAccountCasted != null))
{
this._parent.BankAccount = bankAccountCasted;
return;
}
}
if ((this._parent.MerchantAccount == null))
{
IMerchantAccount merchantAccountCasted = item.As <IMerchantAccount>();
if ((merchantAccountCasted != null))
{
this._parent.MerchantAccount = merchantAccountCasted;
return;
}
}
if ((this._parent.Vendor == null))
{
IVendor vendorCasted = item.As <IVendor>();
if ((vendorCasted != null))
{
this._parent.Vendor = vendorCasted;
return;
}
}
}
public void TransferFunds(IBankAccount accountOne, IBankAccount accountTwo, int p)
{
m_DatabaseManager.BeginTransaction();
accountTwo.Deposit(p);
accountOne.Withdraw(p);
m_DatabaseManager.Dispose();
}
public Record(IBankAccount originator, IBankAccount destination, TransCode code,
decimal?amount, string reference)
{
if (originator == null)
{
throw new DirectDebitException("Originator must not be null");
}
if (destination == null)
{
throw new DirectDebitException("Destination must not be null");
}
if (string.IsNullOrEmpty(reference))
{
throw new DirectDebitException("Reference must not be null or empty");
}
if (originator.Equals(destination))
{
throw new DirectDebitException("Originator and Destination must not be the same");
}
TransCode = code;
Amount = amount;
Reference = reference;
Originator = originator;
Destination = destination;
}
public async Task DeleteBankAccountAsync(long BankAccountK)
{
IBankAccount account = GetBankAccount(BankAccountK);
int affected = 0;
try {
if (account == null ||
(affected = await Connection.QueryAsync("DELETE FROM `bank_account` WHERE `bank_account_id` = @0", BankAccountK)) == 0)
{
return;
}
} catch (Exception ex) {
TShock.Log.ConsoleError("seconomy mysql: DeleteBankAccount failed: {0}",
ex.Message);
}
if (affected != 1)
{
TShock.Log.ConsoleError("seconomy mysql: DeleteBankAccount affected {0} rows where it should have only been 1.",
affected);
return;
}
lock (BankAccounts) {
BankAccounts.RemoveAll(i => i.BankAccountK == BankAccountK);
}
}
public static void Run()
{
IBankAccount account = Aspects.AddAspects <IBankAccount>(new BankAccount());
account.Deposit(1000);
account.Withdraw(500);
}
public bool AuthorizeLoan(int accountNumber, int loanAmount)
{
IBankAccount bankAccount = bank.GetBankAccount(accountNumber);
// TODO: intermediate checks
return(bankAccount.HasEnoughCollateral(loanAmount));
}
public List <ITransaction> GetTransactions(IBankAccount account)
{
var start = DateTime.Now - new TimeSpan(14, 0, 0, 0);
var end = DateTime.Now;
return(GetTransactions(account, start, end));
}
private static void Deposit(decimal amount, IBankAccount account)
{
if (account.Deposit(amount))
{
Console.WriteLine("Deposit complete: {0:C}", amount);
}
}
private static void Withdraw(decimal amount, IBankAccount account)
{
if (account.Withdraw(amount))
{
Console.WriteLine("Withdrawal complete: {0:C}", amount);
}
}
/// <summary>
/// Removes the given item from the collection
/// </summary>
/// <returns>True, if the item was removed, otherwise False</returns>
/// <param name="item">The item that should be removed</param>
public override bool Remove(IModelElement item)
{
IServiceDeliveryPoint serviceDeliveryPointItem = item.As <IServiceDeliveryPoint>();
if (((serviceDeliveryPointItem != null) &&
this._parent.ServiceDeliveryPoints.Remove(serviceDeliveryPointItem)))
{
return(true);
}
IBankAccount bankAccountItem = item.As <IBankAccount>();
if (((bankAccountItem != null) &&
this._parent.BankAccounts.Remove(bankAccountItem)))
{
return(true);
}
ICustomerAgreement customerAgreementItem = item.As <ICustomerAgreement>();
if (((customerAgreementItem != null) &&
this._parent.CustomerAgreements.Remove(customerAgreementItem)))
{
return(true);
}
return(false);
}
private void createSObutton_Click(object sender, EventArgs e)
{
progressBar1.Value = 0;
Random r = new Random();
for (int j = 0; j < 100; j++)
{
int posSource = r.Next(0, _accounts.Count);
int posTarget = r.Next(0, _accounts.Count);
if (posSource == posTarget)
{
// one less transfer...
continue;
}
ActorId sourceAccountId = new ActorId(_accounts[posSource]);
IBankAccount sourceAccountProxy = ActorProxy.Create <IBankAccount>(sourceAccountId, "fabric:/SFActors.BankAccounts");
sourceAccountProxy.AddStandingOrder(_accounts[posTarget], r.NextDouble() * 500, (short)r.Next(0, 61));
System.Threading.Thread.Sleep(100);
progressBar1.PerformStep();
}
textBox1.Text += "100 Standing orders registered created" + Environment.NewLine;
}
public void TransferFunds(IBankAccount accountOne, IBankAccount accountTwo, int p)
{
m_DatabaseManager.BeginTransaction();
accountTwo.Deposit(p);
accountOne.Withdraw(p);
m_DatabaseManager.Dispose();
}
public CModifyBalanceWnd(SEconomy parent, IBankAccount BankAccount)
{
this.account = BankAccount;
this.parent = parent;
InitializeComponent();
rbTradeWith.CheckedChanged += (sender, args) => SwitchRegions();
rbSetTo.CheckedChanged += (sender, args) => SwitchRegions();
txtSetCurrency.TextChanged += (sender, args) => ParseMoneyFromControl(sender as TextBox);
txtTradeCurrency.TextChanged += (sender, args) => ParseMoneyFromControl(sender as TextBox);
txtSetCurrency.LostFocus += (sender, args) => ConvertMoneyToNumber(sender as TextBox);
txtTradeCurrency.LostFocus += (sender, args) => ConvertMoneyToNumber(sender as TextBox);
txtSetCurrency.Focus();
ddlTradeAccount.DataSource = parent.RunningJournal.BankAccounts.OrderBy(i => i.UserAccountName).ToList();
ddlTradeAccount.DisplayMember = "UserAccountName";
ddlTradeAccount.ValueMember = "BankAccountK";
this.Text = "Modify Balance - " + account.UserAccountName;
lblCurrencyName.Text = Money.CurrencyName;
lblCurrencyName2.Text = Money.CurrencyName;
}
/// <summary>
///
/// </summary>
/// <param name="account"></param>
/// <param name="transferType"></param>
/// <param name="amount"></param>
/// <returns></returns>
public static TransferResult MakeTransfer(IBankAccount account, TransferType transferType, double amount)
{
switch (transferType)
{
case TransferType.deposit:
if (amount > account.MaxTransactionLimit)
{
return(TransferResult.MaxTransactionLimitExceeded);
}
else
{
account.Deposit(amount);
return(TransferResult.TransferOK);
}
// return TransferResult.TransferOK;
case TransferType.withdraw:
if (amount > account.Balance)
{
return(TransferResult.NotEnoughBalance);
}
else
{
account.Withdraw(amount);
return(TransferResult.TransferOK);
}
}
return(TransferResult.TransferOK);
}
public void Setup()
{
consolWrapper = Substitute.For <IConsolWrapper>();
calendarWrapper = Substitute.For <ICalendar>();
bankAccount = Substitute.For <IBankAccount>();
bankAccountController = new BankAccountController(consolWrapper, calendarWrapper, bankAccount);
}
public BankAccount(IBankAccount item, bool deep = false)
{
if (item == null)
{
return;
}
this.BankAccountId = item.BankAccountId;
this.BankAccountNumber = item.BankAccountNumber;
this.Balance = item.Balance;
this.CustomerId = item.CustomerId;
this.Locked = item.Locked;
this.BankTransfers = new List <BankTransfers>();
if (deep)
{
if (item.BankTransfers != null)
{
foreach (var childItem in item.BankTransfers)
{
this.BankTransfers.Add(new BankTransfers(childItem, deep));
}
}
if (item.Customer != null)
{
this.Customer = new Customer(item.Customer, deep);
}
}
}
public void AddInterestToBalance()
{
ICustomer customer = new Customer(1, "Name", "Address", "Phone", "Email");
int accNumber = 1;
double initialBalance = 123.45;
IBankAccount account = BankAccount.CreateBankAccount(customer, accNumber, initialBalance);
double interest = initialBalance * account.InterestRate;
DateTime before = DateTime.Now;
account.AddInterest();
DateTime after = DateTime.Now;
Assert.AreEqual(initialBalance + interest, account.Balance);
Assert.AreEqual(1, account.Transactions.Count);
ITransaction t = account.Transactions[0];
Assert.AreEqual(1, t.Id);
Assert.IsTrue(before <= t.DateTime);
Assert.IsTrue(after >= t.DateTime);
Assert.AreEqual("Interest", t.Message);
Assert.AreEqual(interest, t.Amount);
}
public void ChangeInterestRateOutsideRange()
{
ICustomer customer = new Customer(1, "Name", "Address", "Phone", "Email");
int accNumber = 1;
IBankAccount account = BankAccount.CreateBankAccount(customer, accNumber);
double oldInterestRate = account.InterestRate;
try
{
account.InterestRate = BankAccount.INTEREST_RATE_LOWERBOUND - 0.01;
Assert.Fail("Interest Rate below lowerbound");
}
catch (ArgumentException)
{
Assert.AreEqual(oldInterestRate, account.InterestRate);
}
try
{
account.InterestRate = BankAccount.INTEREST_RATE_UPPERBOUND + 0.01;
Assert.Fail("Interest Rate above upperbound");
}
catch (ArgumentException)
{
Assert.AreEqual(oldInterestRate, account.InterestRate);
}
}
public MainForm()
{
InitializeComponent();
InitializeContainer();
PopulateUserList();
bankAccount = container.Resolve<IBankAccount>();
}
public void WithdrawPositiveAmountNotExceedingBalance()
{
ICustomer customer = new Customer(1, "Name", "Address", "Phone", "Email");
int accNumber = 1;
double initialBalance = 123.45;
IBankAccount account = BankAccount.CreateBankAccount(customer, accNumber, initialBalance);
double amount = 23.45;
DateTime before = DateTime.Now;
account.Withdraw(amount);
DateTime after = DateTime.Now;
Assert.AreEqual(initialBalance - amount, account.Balance);
Assert.AreEqual(1, account.Transactions.Count);
ITransaction t = account.Transactions[0];
Assert.AreEqual(1, t.Id);
Assert.IsTrue(before <= t.DateTime);
Assert.IsTrue(after >= t.DateTime);
Assert.AreEqual("Withdraw", t.Message);
Assert.AreEqual(-amount, t.Amount);
}
public bool AddAccount(IBankAccount account)
{
// 객체를 DataManager에게 넘긴다.
// DataManager는 넘겨받은 객체를 Serialize한다.
// DataManager가 Serialize한 내용을 저장한다.
return true;
}
public IBankAccount CreateNewBankAccount(ICustomer owner, double initialBalance = 0.0)
{
IBankAccount account = BankAccount.CreateBankAccount(owner, nextAccountNumber++, initialBalance);
accounts.Add(account);
return(account);
}
public StripeObject UpdateRecipient(string recipientId, string name = null,
string taxId = null, IBankAccount bankAccount = null, ICreditCard card = null,
string defaultCardId = null, string email = null, string description = null)
{
Require.Argument("recipientId", recipientId);
if (card != null) card.Validate();
if (bankAccount != null) bankAccount.Validate();
var request = new RestRequest();
request.Method = Method.POST;
request.Resource = "recipients/{recipientId}";
request.AddUrlSegment("recipientId", recipientId);
if (name.HasValue()) request.AddParameter("name", name);
if (taxId.HasValue()) request.AddParameter("tax_id", taxId);
if (defaultCardId.HasValue()) request.AddParameter("default_card", defaultCardId);
if (email.HasValue()) request.AddParameter("email", email);
if (description.HasValue()) request.AddParameter("description", description);
if (bankAccount != null) bankAccount.AddParametersToRequest(request);
if (card != null) card.AddParametersToRequest_Old(request);
return ExecuteObject(request);
}
static void Main(string[] args)
{
MyDiv mydiv = new MyDiv("gouzao");
mydiv.Method();
mydiv.YinCang();
mydiv.chouxiang();
mydiv.PrintName();
//用接口存取款
SaverAccount caozuo = new SaverAccount();//定义一个接口操作实例
caozuo.PayIn(200);
caozuo.Withdraw(100);
Console.WriteLine(caozuo.ToString());
//接口可以引用任何实现该接口的类，构造接口数组，数组的每个元素都是不同的类。
IBankAccount[] accounts = new IBankAccount[2];
accounts[0] = new SaverAccount();
accounts[0].PayIn(1000);
accounts[0].Withdraw(500);
Console.WriteLine(accounts[0].ToString());
//用新建转账接口进行转账，并输出转账账户和被转账账户的余额
ITransferAccount[] zhuanzhang = new ITransferAccount[2];
zhuanzhang[0] = new CurrentAccount();
zhuanzhang[1] = new CurrentAccount();
zhuanzhang[0].PayIn(500);
zhuanzhang[1].PayIn(100);
zhuanzhang[0].TransferTo(zhuanzhang[1], 200);
Console.WriteLine("zhuanzhang[0]帐号的钱剩余： " + zhuanzhang[0].ToString());
Console.WriteLine("zhuanzhang[1]帐号的钱剩余： " + zhuanzhang[1].ToString());
}
private static void Deposit(decimal amount, IBankAccount account)
{
if (account.Deposit(amount))
{
Console.WriteLine("Deposit complete: {0:C}", amount);
}
}
private static void Withdraw(decimal amount, IBankAccount account)
{
if (account.Withdraw(amount))
{
Console.WriteLine("Withdrawal complete: {0:C}", amount);
}
}
public void AddOwnerToBankAccount_Existing_Owner_Expect_ArgumentException_Test()
{
//IRepository<IBankAccount, int> repository = new BankAccountRepository();
BankAccountController mgr = new BankAccountController(repository);
ICustomer customer1 = new Customer(1, "Name", "Address", "Phone", "Email");
IBankAccount account1 = mgr.CreateNewBankAccount(customer1);
Assert.AreEqual(1, account1.Owners.Count);
Assert.AreSame(customer1, account1.Owners[0]);
Assert.AreEqual(1, customer1.BankAccounts.Count);
Assert.AreSame(account1, customer1.BankAccounts[0]);
try
{
mgr.AddOwnerToBankAccount(account1, customer1);
}
catch (ArgumentException)
{
Assert.AreEqual(1, account1.Owners.Count);
Assert.AreSame(customer1, account1.Owners[0]);
Assert.AreEqual(1, customer1.BankAccounts.Count);
Assert.AreSame(account1, customer1.BankAccounts[0]);
}
}
public void MovingFundsUsingTransactions_AAA()
{
//Arrange
MockRepository mocks = new MockRepository();
IDatabaseManager databaseManager = mocks.StrictMock <IDatabaseManager>();
IBankAccount accountOne = mocks.StrictMock <IBankAccount>(),
accountTwo = mocks.StrictMock <IBankAccount>();
using (mocks.Ordered())
{
databaseManager.Expect(d => d.BeginTransaction()).Return(databaseManager);
using (mocks.Unordered())
{
accountOne.Expect(a => a.Withdraw(1000));
accountTwo.Expect(a => a.Deposit(1000));
}
databaseManager.Dispose();
}
//Act
mocks.ReplayAll();
Bank bank = new Bank(databaseManager);
bank.TransferFunds(accountOne, accountTwo, 1000);
//Assert
databaseManager.VerifyAllExpectations();
accountOne.VerifyAllExpectations();
accountTwo.VerifyAllExpectations();
}
public CustomerPresenter(IView view, IBankAccount bankaccount)
{
View = view;
Account = bankaccount;
AccountConcrete = bankaccount as BankAccount;
IsViewInjected = true;
}
public void GetTransactionListBetweenValidDates()
{
ICustomer customer = new Customer(1, "Name", "Address", "Phone", "Email");
int accNumber = 1;
IBankAccount account = BankAccount.CreateBankAccount(customer, accNumber);
account.Deposit(1000);
Thread.Sleep(1000);
DateTime from = DateTime.Now;
account.Withdraw(400);
Thread.Sleep(1000);
DateTime to = DateTime.Now;
Thread.Sleep(1000);
account.Deposit(200);
Assert.AreEqual(3, account.Transactions.Count);
IList <ITransaction> result = account.GetTransactions(from, to);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
Assert.AreSame(result[0], account.Transactions[1]);
}
static void Main(string[] args)
{
IBankAccount bankAccount = DynamicLogger <BankAccount> .As <IBankAccount>();
bankAccount.Name = "John Smith";
bankAccount.Deposit(1000);
bankAccount.Withdraw(50);
bankAccount.Withdraw(50);
bankAccount.Withdraw(35);
bankAccount.Deposit(250);
bankAccount.Withdraw(20);
bankAccount.Deposit(3);
bankAccount.Withdraw(100);
bankAccount.Withdraw(5);
bankAccount.Withdraw(50);
bankAccount.Deposit(100);
bankAccount.Withdraw(50);
bankAccount.Deposit(5);
var createdDate = bankAccount.DateCreated;
Console.WriteLine("***** Calling ToString() on proxy object *****");
Console.WriteLine(bankAccount);
Console.ReadLine();
}
public void TransferFunds(IBankAccount account1, IBankAccount account2, int amount)
{
_databaseMapper.BeginTransaction();
account1.Withdraw(amount);
account2.Deposit(amount);
_databaseMapper.Dispose();
}
public void MovingFundsUsingTransactions()
{
MockRepository mocks = new MockRepository();
IDatabaseManager databaseManager = mocks.StrictMock <IDatabaseManager>();
IBankAccount accountOne = mocks.StrictMock <IBankAccount>(),
accountTwo = mocks.StrictMock <IBankAccount>();
using (mocks.Ordered())
{
Expect.Call(databaseManager.BeginTransaction()).Return(databaseManager);
using (mocks.Unordered())
{
Expect.Call(accountOne.Withdraw(1000));
Expect.Call(accountTwo.Deposit(1000));
}
databaseManager.Dispose();
}
mocks.ReplayAll();
Bank bank = new Bank(databaseManager);
bank.TransferFunds(accountOne, accountTwo, 1000);
mocks.VerifyAll();
}
public void Transfer(IBankAccount from, IBankAccount toAccount, double amount)
{
Console.WriteLine("Neft Started");
from.Withdraw(amount);
toAccount.Deposit(amount);
Console.WriteLine("Neft Completed");
}
public IBankAccount AddBankAccount(IBankAccount Account)
{
long id = 0;
string query = @"INSERT INTO `bank_account`
(user_account_name, world_id, flags, flags2, description)
VALUES (@0, @1, @2, @3, @4);" ;
if (string.IsNullOrEmpty(Account.UserAccountName) == true)
{
return(null);
}
try {
if (Connection.QueryIdentity(query, out id, Account.UserAccountName, Account.WorldID,
(int)Account.Flags, 0, Account.Description) < 0)
{
return(null);
}
} catch (Exception ex) {
TShock.Log.ConsoleError(" seconomy mysql: sql error adding bank account: " + ex.ToString());
return(null);
}
Account.BankAccountK = id;
lock (BankAccounts) {
BankAccounts.Add(Account);
}
return(Account);
}
private void CheckIfAccountIsActive()
{
if (this.activeAccount == null)
{
this.activeAccount = new BankAccount();
}
}
public float GetBalance(IBankAccount account)
{
var acc = (AqBankAccount)GetAccountByIdentifier (account.AccountIdentifier);
var job = new AqGetBalanceJob (acc, this.abHandle);
job.Perform ();
return job.RequestedBalance;
}
public bool TransferTo(IBankAccount destination, decimal amount)
{
bool result;
result = Withdraw(amount);
if (result)
destination.PayIn(amount);
return result;
}
public void Transfer(IBankAccount from, IBankAccount toAccount, double amount)
{
Console.WriteLine("MY Transaction Started");
from.Withdraw(amount);
Console.WriteLine("FROM "+from.Balance);
toAccount.Deposit(amount);
Console.WriteLine("TO " + toAccount.Balance);
Console.WriteLine("MY Transaction Started");
}
public XmlTransaction(IBankAccount OwningAccount)
{
if (OwningAccount == null) {
throw new ArgumentNullException("OwningAccount is null");
}
this.owningBankAccount = OwningAccount;
this.BankAccountFK = OwningAccount.BankAccountK;
this.customValues = new Dictionary<string, object>();
}
public PendingTransactionEventArgs(IBankAccount From, IBankAccount To, Money Amount, BankAccountTransferOptions Options, string TransactionMessage, string LogMessage) : base()
{
this.fromAccount = From;
this.toAccount = To;
this.Amount = Amount;
this.Options = Options;
this.TransactionMessage = TransactionMessage;
this.JournalLogMessage = LogMessage;
this.IsCancelled = false;
}
public void updateBank(IBankAccount _account)
{
for (int index = 0; index < accounts.Count(); ++index )
{
if (accounts[index].Name() == _account.Name())
{
accounts[index] = _account;
}
}
}
public bool AddAccount(IBankAccount account)
{
if (accounts.ContainsKey(account.ID()))
{
return false; // duplicate key
}
if (dataManager.AddAccount(account))
{
accounts.Add(account.ID(), account);
}
else
{
return false; // dataManager failed.
}
return true;
}
public Record(IBankAccount originator, IBankAccount destination, TransCode code,
decimal? amount, string reference)
{
if (originator == null)
throw new DirectDebitException("Originator must not be null");
if (destination == null)
throw new DirectDebitException("Destination must not be null");
if (string.IsNullOrEmpty(reference))
throw new DirectDebitException("Reference must not be null or empty");
if (originator.Equals(destination))
throw new DirectDebitException("Originator and Destination must not be the same");
TransCode = code;
Amount = amount;
Reference = reference;
Originator = originator;
Destination = destination;
}
public bool TransferMoney(IBankAccount otherAccount, decimal amount)
{
this.WithDrawMoney(amount);
otherAccount.DepositMoney(amount);
return true;
}
public async Task<BankTransferEventArgs> TransferBetweenAsync(IBankAccount FromAccount, IBankAccount ToAccount, Money Amount, BankAccountTransferOptions Options, string TransactionMessage, string JournalMessage)
{
return await Task.Run(() => TransferBetween(FromAccount, ToAccount, Amount, Options, TransactionMessage, JournalMessage));
}
public void Transfer(IBankAccount toAccount, double amount)
{
Transaction.Transfer(this, toAccount, amount);
}
private static void DisplayBallance(IBankAccount account)
{
Console.WriteLine("{0:C}", account.CurrentBallance());
}
public IBankAccount AddBankAccount(IBankAccount Account)
{
long id = 0;
string query = @"INSERT INTO `bank_account`
(user_account_name, world_id, flags, flags2, description)
VALUES (@0, @1, @2, @3, @4);";
if (string.IsNullOrEmpty(Account.UserAccountName) == true) {
return null;
}
try {
if (Connection.QueryIdentity(query, out id, Account.UserAccountName, Account.WorldID,
(int)Account.Flags, 0, Account.Description) < 0) {
return null;
}
} catch (Exception ex) {
TShock.Log.ConsoleError(" seconomy mysql: sql error adding bank account: " + ex.ToString());
return null;
}
Account.BankAccountK = id;
lock (BankAccounts) {
BankAccounts.Add(Account);
}
return Account;
}
public bool TransferTo(IBankAccount destination, decimal amount)
{
if (Withdraw(amount))
{
destination.PayIn(amount);
return true;
}
else
{
return false;
}
}
bool TransferMaySucceed(IBankAccount FromAccount, IBankAccount ToAccount, Money MoneyNeeded, Journal.BankAccountTransferOptions Options)
{
if (FromAccount == null || ToAccount == null) {
return false;
}
return ((FromAccount.IsSystemAccount || FromAccount.IsPluginAccount
|| ((Options & Journal.BankAccountTransferOptions.AllowDeficitOnNormalAccount) == Journal.BankAccountTransferOptions.AllowDeficitOnNormalAccount))
|| (FromAccount.Balance >= MoneyNeeded && MoneyNeeded > 0));
}
public bool TransferMoney(IBankAccount otherAccount, decimal amount)
{
var fee = CalculateFee(amount, WithDrawType.Transfer);
if (UpdateBalance(amount + fee))
{
otherAccount.DepositMoney(amount);
}
return true;
}
ITransaction FinishEndTransaction(MySqlTransaction SQLTransaction, IBankAccount ToAccount, Money Amount, string Message)
{
MySQLTransaction trans = null;
IBankAccount account = null;
long identity = -1;
string query = @"insert into `bank_account_transaction`
(bank_account_fk, amount, message, flags, flags2, transaction_date_utc)
values (@0, @1, @2, @3, @4, @5);";
if ((account = GetBankAccount(ToAccount.BankAccountK)) == null) {
return null;
}
trans = new MySQLTransaction(account) {
Amount = Amount,
BankAccountFK = account.BankAccountK,
Flags = BankAccountTransactionFlags.FundsAvailable,
Message = Message,
TransactionDateUtc = DateTime.UtcNow
};
try {
SQLTransaction.Connection.QueryIdentityTransaction(SQLTransaction, query, out identity, trans.BankAccountFK, (long)trans.Amount, trans.Message,
(int)BankAccountTransactionFlags.FundsAvailable, 0, DateTime.UtcNow);
} catch (Exception ex) {
TShock.Log.ConsoleError(" seconomy mysql: Database error in FinishEndTransaction: " + ex.Message);
return null;
}
trans.BankAccountTransactionK = identity;
return trans;
}
public MySQLTransaction(IBankAccount bankAccount)
{
this.bankAccount = bankAccount;
}
public BankTransferEventArgs TransferBetween(IBankAccount FromAccount, IBankAccount ToAccount, Money Amount, BankAccountTransferOptions Options, string TransactionMessage, string JournalMessage)
{
long accountCount = -1;
PendingTransactionEventArgs pendingTransaction = new PendingTransactionEventArgs(FromAccount, ToAccount, Amount, Options, TransactionMessage, JournalMessage);
ITransaction sourceTran, destTran;
MySqlConnection conn = null;
MySqlTransaction sqlTrans = null;
BankTransferEventArgs args = new BankTransferEventArgs() {
TransferSucceeded = false
};
string accountVerifyQuery = @"select count(*)
from `bank_account`
where `bank_account_id` = @0;";
Stopwatch sw = new Stopwatch();
if (SEconomyInstance.Configuration.EnableProfiler == true) {
sw.Start();
}
if (ToAccount == null
|| TransferMaySucceed(FromAccount, ToAccount, Amount, Options) == false) {
return args;
}
if ((conn = Connection) == null) {
TShock.Log.ConsoleError(" seconomy mysql: Cannot connect to the SQL server");
return args;
}
conn.Open();
if ((accountCount = Connection.QueryScalar<long>(accountVerifyQuery, FromAccount.BankAccountK)) != 1) {
TShock.Log.ConsoleError(" seconomy mysql: Source account " + FromAccount.BankAccountK + " does not exist.");
conn.Dispose();
return args;
}
if ((accountCount = Connection.QueryScalar<long>(accountVerifyQuery, ToAccount.BankAccountK)) != 1) {
TShock.Log.ConsoleError(" seconomy mysql: Source account " + FromAccount.BankAccountK + " does not exist.");
conn.Dispose();
return args;
}
if (BankTransactionPending != null) {
BankTransactionPending(this, pendingTransaction);
}
if (pendingTransaction == null
|| pendingTransaction.IsCancelled == true) {
return args;
}
args.Amount = pendingTransaction.Amount;
args.SenderAccount = pendingTransaction.FromAccount;
args.ReceiverAccount = pendingTransaction.ToAccount;
args.TransferOptions = Options;
args.TransactionMessage = pendingTransaction.TransactionMessage;
try {
sqlTrans = conn.BeginTransaction();
if ((sourceTran = BeginSourceTransaction(sqlTrans, FromAccount.BankAccountK, pendingTransaction.Amount, pendingTransaction.JournalLogMessage)) == null) {
throw new Exception("BeginSourceTransaction failed");
}
if ((destTran = FinishEndTransaction(sqlTrans, ToAccount, pendingTransaction.Amount, pendingTransaction.JournalLogMessage)) == null) {
throw new Exception("FinishEndTransaction failed");
}
BindTransactions(sqlTrans, sourceTran.BankAccountTransactionK, destTran.BankAccountTransactionK);
sqlTrans.Commit();
} catch (Exception ex) {
if (conn != null
&& conn.State == ConnectionState.Open) {
try {
sqlTrans.Rollback();
} catch {
TShock.Log.ConsoleError(" seconomy mysql: error in rollback:" + ex.ToString());
}
}
TShock.Log.ConsoleError(" seconomy mysql: database error in transfer:" + ex.ToString());
args.Exception = ex;
return args;
} finally {
if (conn != null) {
conn.Dispose();
}
}
FromAccount.SyncBalance();
ToAccount.SyncBalance();
args.TransferSucceeded = true;
if (BankTransferCompleted != null) {
BankTransferCompleted(this, args);
}
if (SEconomyInstance.Configuration.EnableProfiler == true) {
sw.Stop();
TShock.Log.ConsoleInfo("seconomy mysql: transfer took {0} ms", sw.ElapsedMilliseconds);
}
return args;
}
