public async Task Remove(CashAccount entity)
{
_context.CashAccounts.Remove(entity);
await UpdateBalance(entity, false);
await _context.SaveChangesAsync();
}
public async Task <int> UpdateCashAccountAsync(CashAccount model)
{
_dataSource.Entry(model).State = EntityState.Modified;
int res = await _dataSource.SaveChangesAsync();
return(res);
}
public virtual void VendorClass_RowPersisting(PXCache cache, PXRowPersistingEventArgs e)
{
VendorClass row = (VendorClass)e.Row;
PXSelectBase <CashAccount> select = new PXSelect <CashAccount, Where <CashAccount.cashAccountID,
Equal <Required <VendorClass.cashAcctID> > > >(this);
if (!String.IsNullOrEmpty(row.CuryID) && (row.AllowOverrideCury ?? false) != true)
{
CashAccount acct = select.Select(row.CashAcctID);
if (acct != null)
{
if (row.CuryID != acct.CuryID)
{
if (cache.RaiseExceptionHandling <VendorClass.cashAcctID>(e.Row, acct.CashAccountCD, new PXSetPropertyException(Messages.VendorCuryDifferentDefPayCury, typeof(VendorClass.cashAcctID).Name)))
{
throw new PXRowPersistingException(typeof(VendorClass.cashAcctID).Name, null, Messages.VendorCuryDifferentDefPayCury, typeof(VendorClass.cashAcctID).Name);
}
}
}
}
if (VendorClassRecord.Cache.GetStatus(e.Row) == PXEntryStatus.Inserted)
{
EPEmployeeClass e1 = PXSelect <EPEmployeeClass, Where <EPEmployeeClass.vendorClassID, Equal <Current <VendorClass.vendorClassID> > > > .SelectSingleBound(this, new object[] { e.Row });
if (e1 != null)
{
cache.IsDirty = false;
e.Cancel = true;
throw new PXRowPersistingException(typeof(VendorClass.vendorClassID).Name, null, Messages.EmployeeClassExists);
}
}
}
protected virtual void CABatch_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
CABatch row = e.Row as CABatch;
if (row == null)
{
return;
}
CABatchExt rowExt = PXCache <CABatch> .GetExtension <CABatchExt>(row);
bool isReleased = (row.Released == true);
PXUIFieldAttribute.SetEnabled(sender, row, false);
PXUIFieldAttribute.SetEnabled <CABatch.batchNbr>(sender, row, true);
bool isProcessing = row.Processing ?? false;
PXUIFieldAttribute.SetEnabled <CABatch.processing>(sender, row, true);
bool allowDelete = !isReleased;
if (allowDelete)
{
allowDelete = !(this.ReleasedPayments.Select(row.BatchNbr).Count > 0);
}
sender.AllowDelete = allowDelete;
CashAccount cashaccount = (CashAccount)PXSelectorAttribute.Select <CABatch.cashAccountID>(sender, row);
bool clearEnabled = (row.Released != true) && (cashaccount != null) && (cashaccount.Reconcile == true);
if (!isReleased)
{
PXUIFieldAttribute.SetEnabled <CABatch.hold>(sender, row, !isReleased);
PXUIFieldAttribute.SetEnabled <CABatch.tranDesc>(sender, row, !isReleased);
PXUIFieldAttribute.SetEnabled <CABatch.tranDate>(sender, row, !isReleased);
PXUIFieldAttribute.SetEnabled <CABatch.batchSeqNbr>(sender, row, !isReleased);
PXUIFieldAttribute.SetEnabled <CABatch.extRefNbr>(sender, row, !isReleased);
PXUIFieldAttribute.SetEnabled <CABatch.released>(sender, row, true);
bool hasDetails = this.BatchPayments.Select().Count > 0;
PXUIFieldAttribute.SetEnabled <CABatch.paymentMethodID>(sender, row, !hasDetails && !isReleased);
PXUIFieldAttribute.SetEnabled <CABatch.cashAccountID>(sender, row, !hasDetails && !isReleased);
if (hasDetails)
{
decimal?curyTotal = Decimal.Zero, total = Decimal.Zero;
this.CalcDetailsTotal(ref curyTotal, ref total);
row.DetailTotal = total;
row.CuryTotal = curyTotal;
}
}
PXUIFieldAttribute.SetVisible <CABatch.curyDetailTotal>(sender, row, isReleased);
PXUIFieldAttribute.SetVisible <CABatch.curyTotal>(sender, row, !isReleased);
PXUIFieldAttribute.SetEnabled <CABatch.exportFileName>(sender, row, isProcessing);
PXUIFieldAttribute.SetEnabled <CABatch.exportTime>(sender, row, isProcessing);
PXUIFieldAttribute.SetVisible <CABatch.dateSeqNbr>(sender, row, isReleased);
this.Release.SetEnabled(!isReleased && (row.Hold == false));
this.Export.SetEnabled(isReleased);
}
public void ProcessTransactions_ShouldNotRemoveNewCompletedTransaction()
{
// create new cancelled transaction
var newCompletedTransaction = new CashAccountTransaction
{
FinalizationDateTime = DateTime.Now.AddDays(-1),
StatusId = (int)TransactionStatusType.Completed
};
// create account with old transaction
var account = new CashAccount {
Transactions = new Collection <CashAccountTransaction> {
newCompletedTransaction
}
};
// return account when retrieving from the repository
A.CallTo(() => _repository.GetAccountWithTransactions(A <int> .Ignored)).Returns(account);
// process transactions for the account
_accountManager.ProcessTransactions();
// transactions should be retrieved from the repository
A.CallTo(() => _repository.GetAccountWithTransactions(A <int> .Ignored)).MustHaveHappened();
// account should have been updated
var newAccount = _accountManager.GetFieldValue <CashAccount>("_account");
newAccount.Should().Be(account);
// check that transactions are as expected
newAccount.Transactions.Should().Contain(t => t == newCompletedTransaction);
}
public async Task <ActionResult> Post([FromBody] CashAccountInputModel model)
{
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var condition = new QueryCondition <CashAccount>();
condition.QueryPredicates.Add(x => x.AccountName == model.AccountName);
var test = await _service.GetBy(condition);
if (!(test is null))
{
ModelState.AddModelError(typeof(CashAccountInputModel).GetType().GetProperty("AccountName").Name,
"The entity you are trying to save already exists!");
return(new UnprocessableEntityObjectResult(ModelState));
}
var account = new CashAccount()
{
AccountBalance = model.AccountBalance,
AccountName = model.AccountName,
Currency = model.Currency,
IsActivated = model.IsActivated
};
var detail = await _service.AddCashAccount(account);
return(CreatedAtAction(nameof(Get), new { id = detail?.Id }, detail));
}
/// <summary>
/// Создание и заполнение тестового класса Budget.
/// </summary>
/// <returns>Заболненный класс Budget./returns>
private Budget PopulateData()
{
var budget = new Budget();
var cashAccount = new CashAccount {
Description = "Cash account"
};
cashAccount.AddOperation(new MoneyOperation()
{
OperationName = "Зарплата",
OperationDate = DateTime.Today,
Tags = { "Вова" },
Value = 5
});
var nonCashaccount = new NonCashAccount {
Description = "Non-Cash account"
};
nonCashaccount.AddOperation(new MoneyOperation()
{
OperationName = "Налог",
OperationDate = new DateTime(2016, 12, 05),
Tags = { "Даша", "машина", "Вова" },
Value = -2
});
budget.AddAccount(cashAccount);
budget.AddAccount(nonCashaccount);
return(budget);
}
public async Task Create(CashAccount entity)
{
_context.CashAccounts.Add(entity);
await _context.SaveChangesAsync();
await UpdateBalance(entity, true);
}
public async Task ShouldUpdate_CashTransaction_UsingCashAccountAggregate()
{
CashAccount account = await _cashAcctRepo.GetByIdAsync(new Guid("417f8a5f-60e7-411a-8e87-dfab0ae62589"));
CashAccountTransaction transaction = account.CashAccountTransactions.FirstOrDefault(p => p.Id.Equals(25));
transaction.UpdateCashAcctTransactionDate(CashAcctTransactionDate.Create(new DateTime(2021, 10, 16)));
transaction.UpdateCashAcctTransactionAmount(CashAcctTransactionAmount.Create(8664.99M));
//TODO Need to know the business rules for these two.
// transaction.UpdateExternalAgentId(cashAccountTransaction.AgentId);
// transaction.UpdateEconomicEventId(cashAccountTransaction.EventId);
transaction.UpdateCheckNumber(CheckNumber.Create("99999"));
transaction.UpdateRemittanceAdvice("0000000");
transaction.UpdateUserId(UserId.Create(new Guid("4b900a74-e2d9-4837-b9a4-9e828752716e")));
account.UpdateCashAccountTransaction(transaction);
_cashAcctRepo.Update(account);
await _unitOfWork.Commit();
CashAccountTransaction result = account.CashAccountTransactions.FirstOrDefault(p => p.Id.Equals(25));
Assert.Equal(transaction.CashAcctTransactionDate, result.CashAcctTransactionDate);
Assert.Equal(transaction.CashAcctTransactionAmount, result.CashAcctTransactionAmount);
Assert.Equal(transaction.CheckNumber, result.CheckNumber);
Assert.Equal(transaction.RemittanceAdvice, result.RemittanceAdvice);
Assert.Equal(transaction.UserId, result.UserId);
}
public void WithDraw_Successful_On_Sufficient_Fund()
{
IAccount account = new CashAccount("1234123412341234", 100);
ICard card = new CashCard(account, 1234);
var retVal = card.WithDraw(1234, 5);
Assert.IsTrue(retVal == 0);
}
public void WithDrawal_Failed_On_Invalid_Pin()
{
var initBalance = 100;
IAccount account = new CashAccount("1234123412341234", initBalance);
ICard card = new CashCard(account, 1234);
var retVal = card.WithDraw(9999, 5);
}
public string NameOf(VoucherDetail detail)
{
m_CashQuery ??= CashAccounts.Select(sa
=> ParsingF.PureDetailQuery(sa.Query, new() { User = User, Today = DateTime.UtcNow.Date })).ToList();
var id = m_CashQuery.FindIndex(detail.IsMatch);
return(CashAccount.NameOf(detail, id < 0 ? null : CashAccounts[id]));
}
public void WithDraw_Failed_On_Insufficient_Fund()
{
IAccount account = new CashAccount("1234123412341234", 100);
ICard card = new CashCard(account, 1234);
var retVal = card.WithDraw(1234, 200);
Assert.IsFalse(retVal == 0);
}
public void Test_AddingSameAccountReferenceTwice()
{
AccountRepository accRep = AccountRepository.getInstance();
CashAccount cashAcc = new CashAccount(accRep.getNewID(), "Gotovina");
accRep.addAccount(cashAcc);
accRep.addAccount(cashAcc);
}
public void WithDrawal_Successful_On_Valid_Pin()
{
var initBalance = 100;
IAccount account = new CashAccount("1234123412341234", initBalance);
ICard card = new CashCard(account, 1234);
var retVal = card.WithDraw(1234, 5);
Assert.IsTrue(retVal == 0);
}
public void BalanceAtSpecificDateWithNoTransactions()
{
var account = new CashAccount();
account.Deposit(new Date(2000, 01, 01), 100.00m, "");
account.Deposit(new Date(2000, 02, 01), 200.00m, "");
account.Withdraw(new Date(2000, 03, 01), 50.00m, "");
account.Balance(new Date(2000, 02, 15)).Should().Be(300.00m);
}
public void Test_AddingAccountWithSameName()
{
AccountRepository accRep = AccountRepository.getInstance();
CashAccount cashAcc = new CashAccount(accRep.getNewID(), "Gotovina");
CurrentAccount currAcc = new CurrentAccount(accRep.getNewID(), "Gotovina");
accRep.addAccount(cashAcc);
accRep.addAccount(currAcc);
}
public static CashAccountResult ToResult(CashAccount cashAccount)
{
return(new CashAccountResult
{
Identification = cashAccount.Identification,
Name = cashAccount.Name,
SchemeName = cashAccount.SchemeName?.Name,
SecondaryIdentification = cashAccount.SecondaryIdentification
});
}
public void BalanceAfterLastTransaction()
{
var account = new CashAccount();
account.Deposit(new Date(2000, 01, 01), 100.00m, "");
account.Deposit(new Date(2000, 02, 01), 200.00m, "");
account.Withdraw(new Date(2000, 03, 01), 50.00m, "");
account.Balance(new Date(2002, 01, 01)).Should().Be(250.00m);
}
private void UpdateCashAccountFromModel(CashAccount target, CashAccountModel source)
{
target.CashAccountId = source.CashAccountId;
target.CashAccountGuid = source.CashAccountGuid;
target.CashAccountName = source.CashAccountName;
target.IsCashAccountActive = source.IsCashAccountActive;
target.AccountTypeId = source.AccountTypeId;
target.CompanyID = Convert.ToInt32(source.CompanyID);
target.OpeningBalance = Convert.ToDecimal(string.IsNullOrEmpty(source.OpeningBalance) ? "0" : source.OpeningBalance);
}
/// <summary>
/// Instantiates an <see cref="AccountManager"/>
/// </summary>
/// <param name="settings"></param>
/// <param name="transactionProcessor"></param>
/// <param name="repositoryFactory"></param>
/// <param name="account"></param>
public AccountManager(IAccountManagementSettings settings,
ITransactionProcessor transactionProcessor,
IAccountRepositoryFactory repositoryFactory,
CashAccount account)
{
_settings = settings;
_transactionProcessor = transactionProcessor;
_repositoryFactory = repositoryFactory;
_account = account;
}
public void Topup_Successful()
{
var initBalance = 100;
IAccount account = new CashAccount("1234123412341234", initBalance);
ICard card = new CashCard(account, 1234);
decimal topUpVal = 100;
var retVal = card.Topup(topUpVal);
Assert.IsTrue(account.Balance == (initBalance + topUpVal));
}
public async Task <int> DeleteCashAccountAsync(CashAccountModel model)
{
var bankAcc = new CashAccount {
CashAccountId = model.CashAccountId
};
using (var dataService = DataServiceFactory.CreateDataService())
{
return(await dataService.DeleteCashAccountAsync(bankAcc));
}
}
private void OnRemoving(CashAccount account, int operationsCount)
{
var result = MessageBox.Show(string.Format(
AppResources.RemoveAccountMessage, account.Name, operationsCount),
AppResources.AttentionCaption, MessageBoxButton.OKCancel);
if (result == MessageBoxResult.OK)
{
_viewModel.KeepRemoving(account);
}
}
public async Task ShouldDelete_CashTransaction_UsingCashAccountAggregate()
{
CashAccount account = await _cashAcctRepo.GetByIdAsync(new Guid("417f8a5f-60e7-411a-8e87-dfab0ae62589"));
CashAccountTransaction transaction = account.CashAccountTransactions.FirstOrDefault(p => p.Id.Equals(25));
account.DeleteCashAccountTransaction(transaction);
CashAccountTransaction result = account.CashAccountTransactions.FirstOrDefault(p => p.Id.Equals(25));
Assert.Null(result);
}
public void BalanceNoTransactionsOnThatDate()
{
var account = new CashAccount();
account.Deposit(new Date(2000, 01, 01), 100.00m, "");
account.Deposit(new Date(2000, 02, 01), 200.00m, "");
account.Deposit(new Date(2000, 02, 01), 60.00m, "");
account.Withdraw(new Date(2000, 03, 01), 50.00m, "");
account.Balance(new Date(2000, 02, 15)).Should().Be(360.00m);
}
public async Task <IActionResult> Delete(int id)
{
CashAccount cashAccount = await _cashAccountRepository.GetItem(id);
if (cashAccount == null)
{
return(NotFound());
}
await _cashAccountRepository.Remove(cashAccount);
return(Ok());
}
private OperationCurrency InitializeCash(CurrencyName currency, CashAccount account)
{
var cash = new OperationCurrency()
{
Account = account,
Name = currency,
Balance = 0
};
_cash.Add(cash);
return(cash);
}
