public async Task <Unit> Handle(UpdateTransactionCommand request, CancellationToken cancellationToken)
{
var cardStatement = await _context.CardStatements.FindAsync(new object[] { Guid.Parse(request.CardStatementId) }, cancellationToken);
if (cardStatement == null || cardStatement.UserId != _userService.UserId)
{
throw new NotFoundException(nameof(Transaction), request.Id);
}
var bankCard =
await _context.BankCards.FindAsync(new object[] { Guid.Parse(cardStatement.BankCardId) }, cancellationToken);
cardStatement.UpdateTransaction(new Transaction
{
Id = Guid.Parse(request.Id),
Amount = request.Amount,
Description = request.Description,
Date = request.Date,
PaymentType = PaymentType.From(request.PaymentType),
TransactionCategory = TransactionCategory.From(request.TransactionCategory)
});
cardStatement.UpdateStatementReward(bankCard.GetEffectiveRewardVersion(cardStatement.MonthYear));
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public async Task <int> CreateAsync(
TransactionCategoryCreateDto transactionCategoryCreateDto)
{
var user = this.loggedInUserInfoProvider.GetLoggedInUser();
var validParent = transactionCategoryCreateDto.ParentId == null ||
await this.transactionCategoryRepository.AnyAsync(
c => c.Id == transactionCategoryCreateDto.ParentId &&
c.UserId == user.Id);
if (!validParent)
{
throw new BadRequestException("Invalid parent category");
}
var transactionCategory = new TransactionCategory(
transactionCategoryCreateDto.Name,
transactionCategoryCreateDto.iconName,
transactionCategoryCreateDto.type,
user.Id)
{
ParentId = transactionCategoryCreateDto.ParentId
};
this.transactionCategoryRepository.Create(transactionCategory);
await this.wmDbTransaction.CommitAsync();
return(transactionCategory.Id);
}
public GetTransactionsResponse GetTransactions(GetTransactionsRequest request, IAuthContext authContext)
{
var transactionsRepo = _unitOfWork.GetRepository <Transaction>();
var transactions = transactionsRepo.GetList(x => x.AccountId.ToString() == request.AccountId);
GetTransactionsResponse response = new GetTransactionsResponse();
response.Items = new List <GetTransactionsResponseItem>();
foreach (Transaction trn in transactions)
{
response.Items.Add(new GetTransactionsResponseItem()
{
Amount = trn.Amount,
Date = trn.Date.ToString(),
Description = trn.Description,
MerchantCategory = MerchantCategory.GetInstance(trn.MerchantCategory).Text,
ProviderTransactionId = trn.ProviderTransactionId,
TransactionCategory = TransactionCategory.GetInstance(trn.TransactionCategory).Text,
TransactionStatus = TransactionStatus.GetInstance(trn.TransactionStatus).Text,
TransactionType = TransactionType.GetInstance(trn.TransactionType).Text
});
}
return(response);
}
public IActionResult Edit(int id, [Bind("Name,Id")] TransactionCategory transactionCategory)
{
if (id != transactionCategory.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_categoryService.EditCategory(transactionCategory);
}
catch (DbUpdateConcurrencyException)
{
if (!TransactionCategoryExists(transactionCategory.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(transactionCategory));
}
public async Task <string> Handle(CreateTransactionCommand request, CancellationToken cancellationToken)
{
var cardStatement =
await _context.CardStatements.FindAsync(new object[] { Guid.Parse(request.CardStatementId) }, cancellationToken);
if (cardStatement == null)
{
throw new NotFoundException(nameof(CardStatement), request.CardStatementId);
}
var bankCard =
await _context.BankCards.FindAsync(new object[] { Guid.Parse(cardStatement.BankCardId) }, cancellationToken);
var transactionEntity = new Transaction
{
Id = Guid.NewGuid(),
PaymentType = PaymentType.From(request.PaymentType),
TransactionCategory = TransactionCategory.From(request.TransactionCategory),
Description = request.Description,
Date = request.Date,
Amount = request.Amount
};
cardStatement.Transactions.Add(transactionEntity);
cardStatement.UpdateStatementReward(bankCard.GetEffectiveRewardVersion(cardStatement.MonthYear));
await _context.SaveChangesAsync(cancellationToken);
return(transactionEntity.Id.ToString());
}
public void GivenAnInvalidValueShouldReturnANotification()
{
var transactionCategory = new TransactionCategory("Supermercado", ETransactionType.Out);
var transaction = new FinancialTransaction("Compra do Mês", 0, ETransactionRecursion.Monthly, transactionCategory);
Assert.IsFalse(transaction.Valid);
}
internal bool IsValidTransactionCategory(string tranCategory, string BankCode, out BaseObject valObj)
{
valObj = new BaseObject();
TransactionCategory category = dh.GetTransactionCategoryById(tranCategory, BankCode);
if (category.StatusCode == "0")
{
if (category.IsActive.ToUpper() == "TRUE")
{
valObj.StatusCode = "0";
valObj.StatusDesc = "SUCCESS";
return(true);
}
else
{
valObj.StatusCode = "100";
valObj.StatusDesc = "FAILED: TRANSACTION CATEGORY [" + tranCategory + "] IS NOT ACTIVATED";
return(false);
}
}
else
{
valObj = category;
return(false);
}
}
public async Task <TransactionCategory> CreateCategory(TransactionCategory category)
{
var res = _context.TransactionCategories.Add(category);
await _context.SaveChangesAsync();
return(res.Entity);
}
private void cmbCategory_DropDownClosed(object sender, EventArgs e)
{
if (cmbCategory.SelectedItem != null)
{
_selectedTransactionCategory = _transactionCategoryManager.GetByName(cmbCategory.SelectedItem.ToString());
}
}
public async Task <int> CreateAsync(TransactionCreateDto transactionCreateDto)
{
var user = this.loggedInUserInfoProvider.GetLoggedInUser();
var wallet = await this.walletRepository.GetByIdAsync(transactionCreateDto.WalletId);
TransactionCategory category = null;
if (transactionCreateDto.CategoryId != null)
{
category =
await this.transactionCategoryRepository.GetByIdAsync(
transactionCreateDto.CategoryId.Value);
}
var transactionType = TransactionCategoryType.Expense;
if (category != null)
{
transactionType = category.Type;
}
if (wallet.UserId != user.Id)
{
throw new ForbiddenException("Wallet not belong to user");
}
if (wallet.Balance < transactionCreateDto.Amount)
{
throw new BadRequestException("Balance in wallet not enought");
}
var newTransaction = new Transaction(transactionType)
{
Amount = transactionCreateDto.Amount,
UserId = user.Id,
WalletId = transactionCreateDto.WalletId,
CategoryId = transactionCreateDto.CategoryId,
CreatedAt = transactionCreateDto.CreatedAt,
};
if (transactionType == TransactionCategoryType.Expense)
{
wallet.Balance -= transactionCreateDto.Amount;
}
else if (transactionType == TransactionCategoryType.Income)
{
wallet.Balance += transactionCreateDto.Amount;
}
else
{
throw new NotSupportedException("Transaction category type not supported");
}
this.transactionRepository.Create(newTransaction);
this.walletRepository.Update(wallet);
await this.wmDbTransaction.CommitAsync();
return(newTransaction.Id);
}
public void AddTransactionCategory(TransactionCategoryDTO transactionCategoryDTO)
{
TransactionCategory transactionCategory = new TransactionCategory();
transactionCategory = _mapper.Map <TransactionCategory>(transactionCategoryDTO);
_context.Add(transactionCategory);
_context.SaveChanges();
}
public void Update(TransactionCategory entity)
{
using (var context = new BudgetContext())
{
context.Entry(entity).State = EntityState.Modified;
context.SaveChanges();
}
}
public ActionResult DeleteConfirmed(int id)
{
TransactionCategory transactionCategory = db.TransactionCategories.Find(id);
db.TransactionCategories.Remove(transactionCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public TransactionCategoryModel MapTransactionCategory(TransactionCategory category)
{
return(new TransactionCategoryModel
{
CategoryId = category.CategoryId,
Name = category.Name
});
}
public Transaction(long id, int clientId, long amount, TransactionCategory transactionCategory, DateTime createdDateTime, Client client)
{
Id = id;
ClientId = clientId;
Amount = amount;
TransactionCategory = transactionCategory;
CreatedDateTime = createdDateTime;
Client = client;
}
public BaseObject GetById(string className, string objectId, string bankCode, string Password)
{
BaseObject result = new BaseObject();
if (string.IsNullOrEmpty(className))
{
return(result);
}
else if (string.IsNullOrEmpty(objectId))
{
return(result);
}
else if (className.ToUpper() == "BANKUSER")
{
result = GetBankUser(objectId, bankCode, Password);
return(result);
}
else if (className.ToUpper() == "BANK")
{
result = dh.GetBankById(objectId);
return(result);
}
else if (className.ToUpper() == "USERTYPE")
{
UserType user = dh.GetUserTypeById(objectId, bankCode);
result = user;
return(result);
}
else if (className.ToUpper() == "TRANSACTIONCATEGORY")
{
TransactionCategory category = dh.GetTransactionCategoryById(objectId, bankCode);
result = category;
return(result);
}
else if (className.ToUpper() == "BANKACCOUNT")
{
BankAccount category = dh.GetBankAccountById(objectId, bankCode);
result = category;
return(result);
}
else if (className.ToUpper() == "ACCOUNTTYPE")
{
AccountType category = dh.GetAccountTypeById(objectId, bankCode);
result = category;
return(result);
}
else if (className.ToUpper() == "ACCESSRULE")
{
AccessRule rule = dh.GetAccessRuleById(objectId, bankCode);
result = rule;
return(result);
}
else
{
return(result);
}
}
public IActionResult Create([Bind("Name,Id")] TransactionCategory transactionCategory)
{
if (ModelState.IsValid)
{
_categoryService.Add(transactionCategory);
return(RedirectToAction(nameof(Index)));
}
return(View(transactionCategory));
}
/// <summary>
/// Add a new transaction at current date
/// </summary>
/// <param name="type"></param>
/// <param name="category"></param>
/// <param name="amount"></param>
/// <param name="description"></param>
/// <param name="addedAutomaticly"></param>
public Transaction(Stolon stolon, TransactionType type, TransactionCategory category, decimal amount, string description, bool addedAutomaticly = true)
{
Stolon = stolon;
AddedAutomaticly = addedAutomaticly;
Date = DateTime.Now;
Type = type;
Category = category;
Amount = amount;
Description = description;
}
public RecurringTransactionModel(string userId, string walletId, string name, double amount, int recurringDate, TransactionCategory category, RecurringType type)
{
UserId = userId;
WalletId = walletId;
Name = name;
Amount = amount;
BillingDate = recurringDate;
Category = category;
Type = type;
}
public ActionResult Edit([Bind(Include = "Id,Name,Decription")] TransactionCategory transactionCategory)
{
if (ModelState.IsValid)
{
db.Entry(transactionCategory).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(transactionCategory));
}
public void CreateTransactionCategory(string categoryName, string bpCategoryName)
{
ApplicationUser user = db.Users.Find(HttpContext.Current.User.Identity.GetUserId());
TransactionCategory category = new TransactionCategory();
category.Category = categoryName;
category.HouseholdId = user.HouseholdId.Value;
db.TransactionCategories.Add(category);
db.SaveChanges();
}
public TransactionModel(string userId, string walletId, double amount, DateTime date, TransactionCategory category, string name, string store, string goods)
{
UserId = userId;
WalletId = walletId;
Amount = amount;
Date = date;
Category = category;
Name = name;
Store = store;
Goods = goods;
}
public ActionResult Create([Bind(Include = "Id,Name,Description,CreatedDate,UpdatedDate")] TransactionCategory transactionCategory)
{
if (ModelState.IsValid)
{
db.TransactionCategories.Add(transactionCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(transactionCategory));
}
public bool Exists(Object obj)
{
string className = GetClassNameByReflection(obj);
switch (className.ToUpper())
{
case "ACCOUNTTYPE":
AccountType type = obj as AccountType;
return(TrueIfExists(className, type.AccTypeCode, type.BankCode));
case "BANK":
Bank bank = obj as Bank;
return(TrueIfExists(className, bank.BankCode, bank.BankCode));
case "BANKACCOUNT":
BankAccount bankAcc = obj as BankAccount;
return(TrueIfExists(className, bankAcc.AccountNumber, bankAcc.BankCode));
case "BANKBRANCH":
BankBranch branch = obj as BankBranch;
return(TrueIfExists(className, branch.BranchCode, branch.BankCode));
case "BANKCHARGE":
BankCharge charge = obj as BankCharge;
return(TrueIfExists(className, charge.ChargeCode, charge.BankCode));
case "BANKUSER":
BankUser user = obj as BankUser;
return(TrueIfExists(className, user.Id, user.BankCode));
case "CHARGETYPE":
ChargeType chargeType = obj as ChargeType;
return(TrueIfExists(className, chargeType.ChargeTypeCode, chargeType.BankCode));
case "CURRENCY":
Currency currency = obj as Currency;
return(TrueIfExists(className, currency.CurrencyCode, currency.BankCode));
case "PAYMENTTYPE":
PaymentType payType = obj as PaymentType;
return(TrueIfExists(className, payType.PaymentTypeCode, payType.BankCode));
case "TRANSACTIONCATEGORY":
TransactionCategory tranCategory = obj as TransactionCategory;
return(TrueIfExists(className, tranCategory.TranCategoryCode, tranCategory.BankCode));
case "TRANSACTIONRULE":
TransactionRule rule = obj as TransactionRule;
return(TrueIfExists(className, rule.RuleCode, rule.BankCode));
default:
return(false);
}
}
public static TransactionCategory From(string value)
{
var transactionCategory = new TransactionCategory(value);
if (!SupportedTransactionCategories.Contains(transactionCategory))
{
throw new InvalidValueObjectException(nameof(TransactionCategory), value);
}
return(transactionCategory);
}
public async Task <ActionResult <TransactionCategory> > CreateCategory(TransactionCategory cat)
{
var category = new TransactionCategory {
Title = cat.Title
};
DbContext.Categories.Add(category);
await DbContext.SaveChangesAsync();
return(CreatedAtAction(nameof(RetrieveCategory), new { id = category.Id }, category));
}
public Result SaveTranType(TransactionCategory tranType, string BankCode)
{
Result result = new Result();
result.RequestId = tranType.Id;
string Id = dh.SaveTransactionType(tranType, BankCode);
result.StatusCode = "0";
result.StatusDesc = "SUCCESS";
result.PegPayId = Id;
return(result);
}
public int Add(TransactionCategory entity)
{
int key;
using (var context = new BudgetContext())
{
context.TransactionCategories.Add(entity);
context.SaveChanges();
key = entity.TransactionCategoryId;
}
return(key);
}
public Result SaveTranType(TransactionCategory tranType, string BankCode)
{
Result result = new Result();
result.RequestId = tranType.Id;
LogChangesInAuditLog(tranType, tranType.TranCategoryCode, tranType.BankCode, tranType.ModifiedBy);
string Id = dh.SaveTransactionType(tranType, BankCode);
result.StatusCode = "0";
result.StatusDesc = "SUCCESS";
result.PegPayId = Id;
return(result);
}
protected void btnConfirm_Click(object sender, EventArgs e)
{
try
{
TransactionCategory category = GetTransactionCategory();
Save(category);
}
catch (Exception ex)
{
string msg = "FAILED: " + ex.Message;
bll.ShowMessage(lblmsg, msg, true, Session);
}
}
private void RenderCategory(TransactionCategory category)
{
switch (category)
{
case TransactionCategory.Send:
Source = new BitmapImage(new Uri("../Images/pm - icons - decrease.png", UriKind.Relative));
break;
case TransactionCategory.Receive:
Source = new BitmapImage(new Uri("../Images/pm - icons - increase.png", UriKind.Relative));
break;
default:
Source = null;
break;
}
}
private void SetMembers(TransactionCode code)
{
switch (code)
{
case TransactionCode.COM:
_transactionCode = code;
_transactionCategory = TransactionCategory.PYMT;
_transactionType = TransactionType.P;
break;
default:
break;
}
}
