protected async override void DoWork()
{
var usdCurrency = await _currenciesRepository.FirstOrDefaultAsync(c => c.Code.Equals("USD"));
if (usdCurrency == null)
{
_currenciesRepository.Insert(new Currency
{
CreationTime = DateTime.Now.ToUniversalTime(),
Name = "United States Dollar",
Code = "USD",
ImageUrl = "/assets/purchase-tokens/usd-icon.svg"
});
}
var dcntCurrency = await _currenciesRepository.FirstOrDefaultAsync(c => c.Code.Equals("DCNT"));
if (dcntCurrency == null)
{
_currenciesRepository.Insert(new Currency
{
CreationTime = DateTime.Now.ToUniversalTime(),
Name = "DCNT",
Code = "DCNT",
ImageUrl = "/assets/purchase-tokens/dc-icon.svg"
});
}
Stop();
}
public async Task <PaymentResponceDto> SubmitPaymentAsync(CreditPayment body)
{
try
{
var currency = await _currenciesRepository.FirstOrDefaultAsync(body.UserData.UserPaymentData.CurrencyId);
if (currency == null)
{
throw new UserFriendlyException(L("CurrencyNotFound"));
}
StripeConfiguration.SetApiKey(StripeApiKey);
var chargeOptions = new StripeChargeCreateOptions()
{
Amount = Convert.ToInt32(body.UserData.UserPaymentData.Amount) * 100,
//TODO old Currency = body.UserData.UserPaymentData.CurrentType,
Currency = currency.Code,
Description = "Charge for " + body.UserData.FirstName + " " + body.UserData.LastName,
SourceTokenOrExistingSourceId = body.PaymentData.Id
};
var transaction = _transactionRepository.GetAll().LastOrDefault(tran => tran.AmountDue == body.UserData.UserPaymentData.Amount &&
tran.TransactionStatus == TransactionStatusEnum.Commited &&
tran.UserId == body.UserData.UserPaymentData.UserId);
var chargeService = new StripeChargeService();
StripeCharge charge = chargeService.Create(chargeOptions);
if (charge.Status.Equals("succeeded"))
{
if (transaction != null)
{
transaction.TransactionStatus = TransactionStatusEnum.Paid;
await _transactionRepository.UpdateAsync(transaction);
}
await SavePaymentDataAsync(charge, body.UserData.UserPaymentData.UserId);
}
return(new PaymentResponceDto
{
Status = charge.Status
});
}
catch (StripeException ex)
{
throw new UserFriendlyException(ex.Message);
}
catch (Exception ex)
{
throw new UserFriendlyException(ex.Message);
}
}
public async Task UpdateExchangeRatesAsync(Dictionary <string, ExchangeValue> exchangeRates)
{
using (CurrentUnitOfWork.DisableFilter(AbpDataFilters.MayHaveTenant))
{
try
{
foreach (var item in exchangeRates)
{
if (item.Value == null)
{
continue;
}
//TODO need refactoring
var currency = await _currenciesRepository.FirstOrDefaultAsync(c => c.Code.Equals(item.Key));
if (currency == null)
{
continue;
}
ExchangeRate exchangeRate = null;
exchangeRate = _exchangeRepository.FirstOrDefault(c => c.CurrencyId == currency.Id);
if (exchangeRate == null)
{
exchangeRate = new ExchangeRate {
CurrencyId = currency.Id
};
}
exchangeRate.CreationTime = DateTime.Now.ToUniversalTime();
exchangeRate.Price = item.Value.USD;
exchangeRate.IsAutomaticUpdate = true;
exchangeRate.UpdatedBy = null;
await _exchangeRepository.InsertOrUpdateAsync(exchangeRate);
}
}
catch (Exception ex)
{
Logger.Error(String.Empty, ex);
}
}
}
//ToDo: AddPermission
//[AbpAuthorize(AppPermissions.Pages_Administration_Users_Create)]
public async Task CreatePaymentManually(PaymentInput input)
{
try
{
long?transactionId = null;
//get latestUnpaidTransaction
if (input.TransactionId != null)
{
//Demo step
transactionId = (long)input.TransactionId;
}
else
{
//maybe also partially paid
var transactionByWaletId = await _transactionRepository.FirstOrDefaultAsync(x => x.WalletId == input.WalletId && x.TransactionStatus == TransactionStatusEnum.Commited);
if (transactionByWaletId != null)
{
transactionId = transactionByWaletId.Id;
}
}
if (transactionId == null)
{
throw new UserFriendlyException("We are working on that feature");
// todo in case you have a user
//transactionId = _transactionRepository.InsertAndGetIdAsync(new Transaction() { })
}
var transaction = await _transactionRepository.GetAsync((long)transactionId);
//create payment
var payment = new Payments.Payment()
{
AmountOfFunds = input.AmountOfFunds,
CreationTime = DateTime.UtcNow,
//TODO: old CurrencyType = (CurrentTypeEnum)(Enum.Parse(typeof(CurrentTypeEnum), input.CurrencyType)),
CurrencyId = input.CurrencyId,
PaymentReceivedTime = input.PaymentReceivedTime,
WalletId = transaction.WalletId,
TrackingNumber = input.TrackingNumber,
TenantId = AbpSession.TenantId
};
payment.PaymentTransaction.Add(new PaymentTransaction.PaymentTransaction()
{
PaymentId = payment.Id, TransactionId = transaction.Id
});
await _paymentRepository.InsertAsync(payment);
//Convert currency and calculate Tokens Amount
if (transaction.UserId == null)
{
throw new UserFriendlyException("There is no user in found transaction!");
}
var currencies = await _walletAppService.GetBtcEthValue();
var currentCurency = new Wallet.Dto.ExchageRateDto();
var currency = await _currenciesRepository.FirstOrDefaultAsync(input.CurrencyId);
if (currency == null)
{
throw new UserFriendlyException(L("CurrencyNotFound"));
}
if (!currency.IsCrypto)
{
currentCurency.Price = 1;
}
else
{
currentCurency = currencies.Find(x => x.Currency.Id == input.CurrencyId);
}
decimal amountTokens = (decimal)(((decimal)currentCurency.Price * input.AmountOfFunds) / 0.25M);
var user = await _userRepository.GetAsync((long)transaction.UserId);
user.AmountTokens += amountTokens;
user.DcntTokensBalance += amountTokens;
await _userRepository.UpdateAsync(user);
if (amountTokens > transaction.TokensIssued)
{
//pay for current transaction
transaction.TransactionStatus = TransactionStatusEnum.Paid;
transaction.TokensIssued = (long)amountTokens;
//search new unpaid transaction or create one
}
else if (amountTokens == transaction.TokensIssued)
{
//Demo step
transaction.TransactionStatus = TransactionStatusEnum.Paid;
transaction.TokensIssued = (long)amountTokens;
}
else if (amountTokens < transaction.TokensIssued)
{
transaction.TransactionStatus = TransactionStatusEnum.PartiallyPaid;
}
}catch (Exception ex)
{
throw new UserFriendlyException(ex.Message);
}
}
public async Task <PaymentOutput> PurchaseTokens(WalletLogsDto input)
{
try
{
if (input != null)
{
var user = _userRepository.Get(input.UserId);
var dcnt = input.Amount;
var dollar = dcnt * _dcntInUsd;
var dcntInBtcOrEthOrUsd = dollar;
var currency = await _currenciesRepository.FirstOrDefaultAsync(input.CurrencyId);
if (!currency.IsCrypto)
{
var users = await UserManager.GetUsersInRoleAsync("Admin");
var instruction = users.FirstOrDefault(item => item.WiredInstruction != null).WiredInstruction;
return(new PaymentOutput()
{
Instruction = instruction
});
}
if (currency == null)
{
throw new UserFriendlyException(L("CurrencyNotFound"));
}
var exchangeRate = await _exchangeRateRepository.FirstOrDefaultAsync(e => e.CurrencyId.Equals(currency.Id));
if (exchangeRate == null)
{
throw new UserFriendlyException(L("CurrencyNotFound"));
}
if (currency.IsCrypto)
{
if (Convert.ToDouble(input.Amount) != 0.0)
{
dcntInBtcOrEthOrUsd = (_dcntInUsd * input.Amount) / exchangeRate.Price;
}
}
var transaction = new Transaction()
{
UserId = input.UserId,
AmountDue = dcntInBtcOrEthOrUsd,
//TODO: old CurrencyType = (int)Enum.Parse(typeof(CurrentTypeEnum), input.CurrentType),
WalletId = input.WalletId,
CurrencyId = currency.Id,
TransactionStatus = TransactionStatusEnum.Commited,
IsDeleted = false,
FirstName = user.Name,
LastName = user.Surname,
TokensIssued = (long)input.Amount,
EmailAddress = user.EmailAddress,
TransactionDate = DateTime.Now,
TenantId = AbpSession.TenantId
};
await _walletLogsRepository.InsertAsync(transaction);
QRCodeGenerator qrGenerator = new QRCodeGenerator();
var walletId = (await _supportedCurrencyRepository.FirstOrDefaultAsync(x => x.CurrencyId == currency.Id)).WalletId;
QRCodeData qrCodeData = qrGenerator.CreateQrCode(walletId, QRCodeGenerator.ECCLevel.Q);
QRCode qrCode = new QRCode(qrCodeData);
Bitmap qrCodeImage = qrCode.GetGraphic(4);
System.IO.MemoryStream ms = new System.IO.MemoryStream();
qrCodeImage.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);
byte[] byteImage = ms.ToArray();
var qrCodeBase64 = Convert.ToBase64String(byteImage);
var qrcodeDto = new PaymentOutput()
{
QrCode = qrCodeBase64,
Address = walletId
};
var tenant = await _tenantRepository.FirstOrDefaultAsync(item => item.Id == AbpSession.TenantId);
var currencyImage = StoreClientAgreement(ms, currency.Name);
//TODO email
//Uri uri = new Uri(tenant.LogoUrl);
var emailData = new DcntEmailTemplateInput()
{
UserName = user.Name,
WalletId = walletId,
Amount = input.Amount,
CurrentType = currency.Name,
Dcnt = dcnt,
Dollar = dollar,
Uri = tenant.LogoUrl,
DcntInBtcOrEthOrUsd = dcntInBtcOrEthOrUsd,
QrCode = currencyImage
};
var receiver = new MailAddress(user.EmailAddress, user.FullName);
var body = _userEmailer.GetDCEmailTemplate(emailData);
await _userEmailer.SendEmailWithSendGrid(receiver, body);
return(qrcodeDto);
}
}
catch (Exception ex)
{
}
return(new PaymentOutput());
}
