public DepositDTO CreateDeposit(DepositDTO deposit)
{
deposit.Id = _mpDonationRepository.CreateDeposit(deposit.DepositName, deposit.DepositTotalAmount, deposit.DepositAmount, deposit.ProcessorFeeTotal, deposit.DepositDateTime,
deposit.AccountNumber, deposit.BatchCount, deposit.Exported, deposit.Notes, deposit.ProcessorTransferId);
return(deposit);
}
public static Deposit CastToDAL(DepositDTO deposit)
{
return(new Deposit()
{
depositId = deposit.depositId, userId = deposit.userId, depositDate = deposit.depositDate, depositAmount = deposit.depositAmount
});
}
public async Task <decimal> DepositPocketAsync(DepositDTO request)
{
decimal result;
try
{
var currencyAccount = DbContext.Holders.Include(nameof(PocketHolder.Accounts))
.SingleOrDefault(CheckHolder(request))
.Accounts
.Find(acc => acc.Currency == request.Currency);
if (currencyAccount == null)
{
throw new AccountNotFoundException();
}
currencyAccount.Debit += request.Sum;
DbContext.Update(currencyAccount);
await DbContext.SaveChangesAsync();
result = currencyAccount.Debit;
}
catch (DbUpdateConcurrencyException ex)
{
throw new ConcurrencyException();
}
return(result);
}
public DepositDTO TransferFromAccount(string username, string cardName, DepositDTO dto)
{
var account = accountService.GetAccountForUser(username);
if (account == null)
{
return(null);
}
var vc = virtualCardRepository.GetByAccountIdAndName(account.Id, cardName);
account.Balance = account.Balance - dto.Deposit;
if (account.Balance < 0.00)
{
var thFailed = convertToTH(dto.Deposit, "deposit", "failed", account.Currency, vc.CardNumber);
account.Transactions.Add(TransactionHistoryConverter.ToEntity(thFailed));
accountService.Save(account);
throw new Exception("You don't have that much money into your account!!!");
}
vc.Balance = vc.Balance + dto.Deposit;
accountService.Save(account);
virtualCardRepository.Save(vc);
var th = convertToTH(dto.Deposit, "deposit", "success", account.Currency, vc.CardNumber);
th.AccountId = account.Id;
transactionHistoryService.Save(th);
return(dto);
}
/// <summary>
/// Updates Read views
/// </summary>
/// <param name="notification"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task Handle(DepositChangedEvent notification, CancellationToken cancellationToken)
{
var depo = new DepositDTO {
TotalAmount = notification.TotalAmount
};
await _redisCacheClient.Db1.ReplaceAsync <DepositDTO>(ReadViewNames.Deposit, depo);
}
public async Task <IActionResult> Deposit(DepositType type, [FromBody] DepositDTO model)
{
if (type == DepositType.Cash)
{
try
{
await _accountApplicationService.DepositCashAsync(AccountId.With(model.AccountId), model.Amount);
}
catch (Exception e)
{
return(BadRequest(new { Error = e.Message }));
}
return(Ok(new { isSuccess = true }));
}
if (type == DepositType.Check)
{
try
{
await _accountApplicationService.DepositCheckAsync(AccountId.With(model.AccountId), model.Amount);
}
catch (Exception e)
{
return(BadRequest(new { Error = e.Message }));
}
return(Ok(new { isSuccess = true }));
}
return(BadRequest());
}
public string GPExportFileName(DepositDTO deposit)
{
var date = DateTime.Today.ToString("yyMMdd");
var depositName = deposit.DepositName.Replace(" ", "_");
return(string.Format("XRDReceivables-{0}_{1}.txt", depositName, date));
}
public ActionResult AddDeposit([FromBody] DepositDTO deposit)
{
try
{
DepositBL.AddDeposit(deposit);
}
catch (Exception e)
{
return(BadRequest(e.ToString()));
}
return(Ok());
}
public static double?NewDeposit(DepositDTO depositDTO)
{
db.Deposits.Add(DepositCast.CastToDAL(depositDTO));
try
{
db.SaveChanges();
return(depositDTO.depositAmount);
}
catch
{
return(0);
}
}
public static DepositDTO DALtoDTO(Deposit deposit)
{
try
{
DepositDTO deposit_dto = new DepositDTO()
{
Amount = deposit.Amount,
Date = deposit.Date,
FundId = deposit.FundId,
DepositId = deposit.DepositId,
// status_id = deposit.status,
Type = deposit.Type,
UserId = deposit.UserId
};
return(deposit_dto);
}
catch (Exception)
{
throw;
}
}
public static Deposit DTOtoDAL(DepositDTO deposit)
{
try
{
Deposit DAL_Deposit = new Deposit()
{
Amount = deposit.Amount,
Date = deposit.Date,
FundId = deposit.FundId.ToString(),
// st = deposit.status,
Type = deposit.Type,
UserId = deposit.UserId,
Payment_method = deposit.Payment_method
};
return(DAL_Deposit);
}
catch (Exception e)
{
throw e;
}
}
public DepositDTO DepositToVirtualCard(string username, string cardName, DepositDTO depositDTO)
{
var account = accountService.GetAccountForUser(username);
if (account == null)
{
return(null);
}
var vc = virtualCardRepository.GetByAccountIdAndName(account.Id, cardName);
vc.Balance = vc.Balance + depositDTO.Deposit;
virtualCardRepository.Save(vc);
var th = convertToTH(depositDTO.Deposit, "deposit", "success", account.Currency, vc.CardNumber);
th.AccountId = account.Id;
transactionHistoryService.Save(th);
return(depositDTO);
}
public static void AddDeposit(DepositDTO deposit)
{
DB db = new SuperGmachEntities();
try
{
Deposit deposit_DAL = new Deposit();
deposit_DAL = DepositConvert.DTOtoDAL(deposit);
// System.Console.WriteLine(deposit+" DAL/n "+deposit_DAL);
db.Deposits.Add(deposit_DAL);
User user = db.Users.FirstOrDefault();
db.SaveChanges();
user.Scoring = (int)((int)user.Scoring + deposit.Amount * 0.5);
User_in_fund user_In_Fund = db.UserInFunds.FirstOrDefault(u => u.UserId == deposit.UserId && u.FundId == deposit.FundId);
user_In_Fund.balance += deposit.Amount;
FundBL.AddBalance((int)deposit.Amount, deposit.FundId);
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public static DepositDTO ToDto(this Deposit deposit)
{
if (deposit == null)
{
return(null);
}
var depositDTO = new DepositDTO
{
Id = deposit.Id,
PaymentStatusID = deposit.PaymentStatusID,
PaymentAmount = deposit.PaymentAmount,
ExchangeRate = deposit.ExchangeRate,
FundingTypeID = deposit.FundingTypeID,
CurrencyID = deposit.CurrencyID,
TimeStamp = deposit.TimeStamp,
Currency = deposit.Currency.ToDto(),
FundingType = deposit.FundingType.ToDto(),
PaymentStatus = deposit.PaymentStatus.ToDto(),
};
return(depositDTO);
}
public static Deposit ToEntity(this DepositDTO depositDTO)
{
if (depositDTO == null)
{
return(null);
}
var deposit = new Deposit
{
Id = depositDTO.Id,
PaymentStatusID = depositDTO.PaymentStatusID,
PaymentAmount = depositDTO.PaymentAmount,
ExchangeRate = depositDTO.ExchangeRate,
FundingTypeID = depositDTO.FundingTypeID,
CurrencyID = depositDTO.CurrencyID,
TimeStamp = depositDTO.TimeStamp,
Currency = depositDTO.Currency.ToEntity(),
FundingType = depositDTO.FundingType.ToEntity(),
PaymentStatus = depositDTO.PaymentStatus.ToEntity(),
};
return(deposit);
}
public async Task <IActionResult> DepositAccount(string accountNumber, [FromBody] DepositDTO request)
{
if (string.IsNullOrEmpty(accountNumber) ||
accountNumber != request.MasterAccount)
{
ModelState.AddModelError("", AccountNotFoundException.DefaultErrorMessage);
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await PocketService.DepositPocketAsync(request);
return(new JsonResult(result));
}
catch (Exception ex)
{
return(HandleException(ex));
}
}
public TransferPaidResponseDTO TransferPaid(DateTime?eventTimestamp, StripeTransfer transfer)
{
_logger.Debug("Processing transfer.paid event for transfer id " + transfer.Id);
var response = new TransferPaidResponseDTO();
// Don't process this transfer if we already have a deposit for the same transfer id
var existingDeposit = _donationService.GetDepositByProcessorTransferId(transfer.Id);
if (existingDeposit != null)
{
var msg = $"Deposit {existingDeposit.Id} already created for transfer {existingDeposit.ProcessorTransferId}";
_logger.Debug(msg);
response.TotalTransactionCount = 0;
response.Message = msg;
response.Exception = new ApplicationException(msg);
return(response);
}
// Don't process this transfer if we can't find any charges for the transfer
var charges = _paymentProcessorService.GetChargesForTransfer(transfer.Id);
if (charges == null || charges.Count <= 0)
{
var msg = "No charges found for transfer: " + transfer.Id;
_logger.Debug(msg);
response.TotalTransactionCount = 0;
response.Message = msg;
response.Exception = new ApplicationException(msg);
return(response);
}
var depositName = DateTime.Now.ToString(BatchNameDateFormat);
var paymentcharges = charges.Where(m => m.Metadata != null && m.Metadata.ContainsKey("crossroads_transaction_type") && m.Metadata["crossroads_transaction_type"].ToString() == "payment").ToList();
var donationcharges = charges.Except(paymentcharges).ToList();
if (paymentcharges.Count + donationcharges.Count != charges.Count)
{
var msg = "Donation and Payment charges count error for transfer: " + transfer.Id;
_logger.Debug(msg);
response.TotalTransactionCount = 0;
response.Message = msg;
response.Exception = new ApplicationException(msg);
return(response);
}
var paymentBatch = CreateBatchDTOFromCharges(paymentcharges, depositName + "P", eventTimestamp, transfer, ref response);
var donationBatch = CreateBatchDTOFromCharges(donationcharges, depositName + "D", eventTimestamp, transfer, ref response);
var stripeTotalFees = paymentBatch.BatchFeeTotal + donationBatch.BatchFeeTotal;
// Create the deposit
var deposit = new DepositDTO
{
// Account number must be non-null, and non-empty; using a single space to fulfill this requirement
AccountNumber = " ",
BatchCount = paymentBatch.ItemCount > 0 && donationBatch.ItemCount > 0 ? 2 : 1,
DepositDateTime = DateTime.Now,
DepositName = depositName,
// This is the amount from Stripe - will show out of balance if does not match batch total above
DepositTotalAmount = ((transfer.Amount / Constants.StripeDecimalConversionValue) + (stripeTotalFees / Constants.StripeDecimalConversionValue)),
ProcessorFeeTotal = stripeTotalFees / Constants.StripeDecimalConversionValue,
DepositAmount = transfer.Amount / Constants.StripeDecimalConversionValue,
Exported = false,
Notes = null,
ProcessorTransferId = transfer.Id
};
try
{
response.Deposit = _donationService.CreateDeposit(deposit);
}
catch (Exception e)
{
_logger.Error("Failed to create batch deposit", e);
throw;
}
// Create the batch, with the above deposit id
paymentBatch.DepositId = response.Deposit.Id;
donationBatch.DepositId = response.Deposit.Id;
//donation Batch
try
{
if (donationBatch.ItemCount > 0)
{
response.Batch.Add(_donationService.CreateDonationBatch(donationBatch));
}
}
catch (Exception e)
{
_logger.Error("Failed to create donation batch", e);
throw;
}
// payment Batch
try
{
if (paymentBatch.ItemCount > 0)
{
response.Batch.Add(_paymentService.CreatePaymentBatch(paymentBatch));
}
}
catch (Exception e)
{
_logger.Error("Failed to create payment batch", e);
throw;
}
return(response);
}
public static void deleteDeposit(DepositDTO depositDTO)
{
db.Deposits.Remove(db.Deposits.First(d => d.depositId == depositDTO.depositId));
db.SaveChanges();
}
public IHttpActionResult AddDepositToVitualCard(string username, string cardname, DepositDTO dto)
{
return(Json(_service.DepositToVirtualCard(username, cardname, dto)));
}
public HttpResponseMessage NewDeposit(DepositDTO deposit)
{
return(Request.CreateResponse(HttpStatusCode.OK, DepositLogic.NewDeposit(deposit)));
}
public IHttpActionResult TransferFromAccount(string username, string cardname, DepositDTO dto)
{
return(Json(_service.TransferFromAccount(username, cardname, dto)));
}
public DepositDTO Post([FromBody] DepositDTO Deposit)
{
return(DepositService.PrePostDTO(ModelState, currentClient, Deposit));
}
public HttpResponseMessage DeleteDeposit(DepositDTO depositDTO)
{
DepositLogic.deleteDeposit(depositDTO);
return(Request.CreateResponse(HttpStatusCode.OK));
}
public IHttpActionResult Put([FromUri] int id, [FromBody] DepositDTO Deposit)
{
DepositService.PrePutDTO(ModelState, currentClient, id, Deposit);
return(Ok());
}
