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; } }