public IEnumerable <BillerCryptoItemOM> GetBillerCryptoCurrency(UserAccount user, string fiatCurrency)
{
var dac = new MasterSettingDAC();
var discount = dac.SelectByGroup("BillerMaxAmount").First(item =>
item.Name.Equals("DiscountRate", StringComparison.CurrentCultureIgnoreCase));
var coins = new UserWalletComponent().ListForDepositAndWithdrawal(user, fiatCurrency).List;
var priceInfoDict = new PriceInfoDAC().GetByCurrencyId(new CurrenciesDAC().GetByCode(fiatCurrency).ID).ToDictionary(item => item.CryptoID);
foreach (var item in coins)
{
var model = new BillerCryptoItemOM()
{
Code = item.Code,
Id = item.Id,
Name = item.Name,
CryptoEnable = item.CryptoEnable,
DecimalPlace = item.DecimalPlace,
FiatBalance = item.FiatBalance,
FrozenBalance = item.FrozenBalance,
IconUrl = item.IconUrl,
NewStatus = item.NewStatus,
UseableBalance = item.UseableBalance,
ExchangeRate = priceInfoDict.ContainsKey(item.Id) ? priceInfoDict[item.Id].Price.ToString(4) : 0.ToString()
};
if (item.Code.Equals("fiii", StringComparison.InvariantCultureIgnoreCase))
{
model.Discount = decimal.Parse(discount.Value).ToString();
yield return(model);
}
else
{
model.Discount = "0";
yield return(model);
}
}
}
public BillerPayOM Pay(UserAccount account, BillerPayIM im, ref int errorCode)
{
var coin = new CryptocurrencyDAC().GetById(im.CryptoId);
if (!coin.Status.HasFlag(CryptoStatus.Biller) || coin.Enable == 0)
{
throw new CommonException(ReasonCode.CURRENCY_FORBIDDEN, MessageResources.CurrencyForbidden);
}
var result = PrePay(new BillerPrePayIM()
{
CountryId = im.CountryId, CryptoAmount = im.CryptoAmount, CryptoCode = im.CryptoCode,
CryptoId = im.CryptoId, FiatAmount = im.FiatAmount, FiatCurrency = im.FiatCurrency
}).Status;
if (result != 0)
{
errorCode = 10400 + result;
return(null);
}
new SecurityComponent().VerifyPin(account, im.Pin);
var cryptoCurrency = new CryptocurrencyDAC().GetById(im.CryptoId);
if (cryptoCurrency?.Id == null)
{
throw new CommonException(ReasonCode.CRYPTO_NOT_EXISTS, "Error: Invalid Cryptocurrency");
}
var uwComponent = new UserWalletComponent();
var userWallet = uwComponent.GetUserWallet(account.Id, im.CryptoId);
if (userWallet == null)
{
throw new CommonException(ReasonCode.INSUFFICIENT_BALANCE, MessageResources.InsufficientBalance);
}
if (userWallet.Balance < im.CryptoAmount)
{
throw new CommonException(ReasonCode.INSUFFICIENT_BALANCE, MessageResources.InsufficientBalance);
}
var uwDAC = new UserWalletDAC();
var uwsDAC = new UserWalletStatementDAC();
var boDAC = new BillerOrderDAC();
var billerOrder = new BillerOrder()
{
Id = Guid.NewGuid(),
BillerCode = im.BillerCode,
CryptoAmount = im.CryptoAmount,
CryptoCode = im.CryptoCode,
CryptoId = im.CryptoId,
Discount = im.CryptoCode.Equals("Fiii", StringComparison.InvariantCultureIgnoreCase)
? decimal.Parse(new MasterSettingDAC().SelectByGroup("BillerMaxAmount").First(item =>
item.Name.Equals("DiscountRate", StringComparison.CurrentCultureIgnoreCase)).Value)
: 0,
ExchangeRate = im.ExchangeRate,
FiatAmount = im.FiatAmount,
FiatCurrency = im.FiatCurrency,
ReferenceNumber = im.ReferenceNumber,
Tag = im.Tag,
Status = BillerOrderStatus.Pending,
Timestamp = DateTime.UtcNow,
AccountId = account.Id,
OrderNo = IdentityHelper.OrderNo(),
PayTime = DateTime.UtcNow,
CountryId = im.CountryId
};
var address = new BillerAddressDAC().GetAllAddresses(account.Id).FirstOrDefault(item =>
item.BillerCode == im.BillerCode && im.ReferenceNumber == item.ReferenceNumber);
billerOrder.Tag = address?.Tag;
using (var scope = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required, new TimeSpan(0, 0, 1, 30)))
{
uwDAC.Decrease(userWallet.Id, billerOrder.CryptoAmount);
uwsDAC.Insert(new UserWalletStatement
{
WalletId = userWallet.Id,
Action = UserWalletStatementAction.Consume,
Amount = -billerOrder.CryptoAmount,
Balance = userWallet.Balance - billerOrder.CryptoAmount,
FrozenAmount = 0,
FrozenBalance = userWallet.FrozenBalance,
Timestamp = DateTime.UtcNow
});
boDAC.Insert(billerOrder);
new UserTransactionDAC().Insert(new UserTransaction
{
Id = Guid.NewGuid(),
AccountId = billerOrder.AccountId,
CryptoId = cryptoCurrency.Id,
CryptoCode = cryptoCurrency.Code,
Type = UserTransactionType.BillOrder,
DetailId = billerOrder.Id.ToString(),
Status = (byte)billerOrder.Status,
Timestamp = billerOrder.Timestamp,
Amount = billerOrder.CryptoAmount,
OrderNo = billerOrder.OrderNo
});
scope.Complete();
}
return(new BillerPayOM()
{
CryptoAmount = billerOrder.CryptoAmount.ToString(), OrderNo = billerOrder.OrderNo,
CryptoCode = billerOrder.CryptoCode, OrderId = billerOrder.Id,
Timestamp = billerOrder.PayTime.ToUnixTime().ToString(),
SaveAddress = address != null
});
}
public RedPocketDetailOM Receive(UserAccount userAccount, string passcode, bool isZH = false)
{
if (userAccount == null)
{
throw new SystemErrorException();
}
if (string.IsNullOrWhiteSpace(passcode))
{
throw new CommonException(Argument_Error, MessageResources.InvalidDataFormat);
}
if (userAccount.L1VerifyStatus != Entities.Enums.VerifyStatus.Certified)
{
throw new CommonException(ReasonCode.NOT_VERIFY_LV1, Resources.EMNeedLV1Verfied);
}
var count = RedisHelper.StringGet(LockDbIndex, string.Format(KeyFormat, userAccount.Id));
if (!string.IsNullOrWhiteSpace(count) && int.Parse(count) >= 10)
{
var ttl = RedisHelper.KeyTimeToLive(LockDbIndex, string.Format(KeyFormat, userAccount.Id));
if (ttl != null)
{
var message = "";
var t = "";
try
{
t = TimeConvert(ttl.Value, isZH);
message = string.Format(MessageResources.RedPocket_PassCodeErrorMaxCount, t);
}
catch (Exception exception)
{
_log.Error(exception.Message + " " + MessageResources.RedPocket_PassCodeErrorMaxCount + " " + t);
}
throw new CommonException(MaxError, message);
}
}
var redPocketDAC = new RedPocketDAC();
var redPocket = redPocketDAC.GetByPassCode(passcode);
if (redPocket == null)
{
var errorCount = ErrorCount(userAccount.Id, count, isZH);
throw new CommonException(PassCodeError, string.Format(MessageResources.RedPocket_PassCodeError, errorCount, 10 - errorCount));
}
if (redPocket.ExpirationDate < DateTime.UtcNow)
{
var errorCount = ErrorCount(userAccount.Id, count, isZH);
throw new CommonException(PassCodeExpired, MessageResources.RedPocket_ReceiveExpired + Environment.NewLine + string.Format(MessageResources.RedPocket_PassCodeError, errorCount, 10 - errorCount));
}
var crypto = new CryptocurrencyDAC().GetByCode(redPocket.CryptoCode);
if (!crypto.Status.HasFlag(Foundation.Entities.Enum.CryptoStatus.RedPocket) || crypto.Enable == 0)
{
throw new CommonException(ReasonCode.CURRENCY_FORBIDDEN, MessageResources.CurrencyForbidden);
}
var om = new RedPocketDetailOM();
var redPocketReceiveDAC = new RedPocketReceiverDAC();
var hasReceive = redPocketReceiveDAC.HasReceive(userAccount.Id, redPocket.Id);
if (redPocket.Status == RedPocketStatus.Actived && hasReceive == null)
{
var userWalletDAC = new UserWalletDAC();
var userWalletStatementDAC = new UserWalletStatementDAC();
var uwComponent = new UserWalletComponent();
var userTransactionDAC = new UserTransactionDAC();
var wallet = userWalletDAC.GetByCryptoCode(userAccount.Id, redPocket.CryptoCode);
if (wallet == null)
{
wallet = uwComponent.GenerateWallet(userAccount.Id, redPocket.CryptoCode);
}
var min = crypto.DecimalPlace == 8 ? 0.00000001M : crypto.DecimalPlace == 6 ? 0.000001M : 0.00000001M;
var n = crypto.DecimalPlace == 8 ? 100000000 : crypto.DecimalPlace == 6 ? 1000000 : 100000000;
var amount = GetRandomMoney(redPocket, min, n);
var priceDAC = new PriceInfoDAC();
var price = priceDAC.GetPriceByName("USD", crypto.Code);
var fiatAmount = price * amount;
using (var scope = new TransactionScope())
{
try
{
var redPocketReceiver = new RedPocketReceiver
{
PocketId = redPocket.Id,
AccountId = userAccount.Id,
SendAccountId = redPocket.AccountId,
CryptoCode = redPocket.CryptoCode,
Amount = amount,
Timestamp = DateTime.UtcNow,
IsBestLuck = redPocket.Count == 1,
OrderNo = IdentityHelper.OrderNo(),
FiatAmount = fiatAmount <= 0 ? 0M : Math.Round(fiatAmount, 8)
};
var id = redPocketReceiveDAC.Insert(redPocketReceiver);
userTransactionDAC.Insert(new UserTransaction
{
Id = Guid.NewGuid(),
AccountId = redPocketReceiver.AccountId,
CryptoId = redPocket.CryptoId,
CryptoCode = redPocket.CryptoCode,
Type = UserTransactionType.ReceiveRedPocket,
DetailId = id.ToString(),
Status = (byte)redPocket.Status,
Timestamp = redPocketReceiver.Timestamp,
Amount = redPocketReceiver.Amount,
OrderNo = redPocketReceiver.OrderNo
});
userWalletDAC.Increase(wallet.Id, amount);
userWalletStatementDAC.Insert(new UserWalletStatement
{
WalletId = wallet.Id,
Balance = wallet.Balance + amount,
Amount = amount,
FrozenAmount = 0,
FrozenBalance = wallet.FrozenBalance,
Action = "Receive Red Pocket",
Timestamp = DateTime.UtcNow
});
redPocketDAC.UpdateRemain(redPocket.Id, amount);
if (redPocket.RemainCount == 0)
{
redPocketDAC.UpdateStatus(redPocket.Id, RedPocketStatus.Complate);
userTransactionDAC.UpdateStatus(UserTransactionType.PushRedPocket, redPocket.Id.ToString(), redPocket.AccountId, (byte)RedPocketStatus.Complate);
if (redPocket.Count > 1)
{
redPocketReceiveDAC.UpdateBestLuck(redPocket.Id);
}
}
scope.Complete();
}
catch (Exception ex)
{
_log.Error(ex);
throw new CommonException();
}
}
om.SelfAmount = amount.ToString();
om.ReceiveStatus = ReceiveStatusEnum.Receive;
om.HasExpried = false;
redPocket.Balance -= amount;
}
else
{
if (hasReceive != null)
{
om.ReceiveStatus = ReceiveStatusEnum.HasReceive;
om.SelfAmount = hasReceive.Amount.ToString();
}
else
{
om.ReceiveStatus = ReceiveStatusEnum.None;
om.SelfAmount = string.Empty;
}
}
var account = new UserAccountComponent().GetById(redPocket.AccountId);
om.Message = redPocket.Message;
om.SnederNickname = account.Nickname;
om.TotalAmount = redPocket.Amount.ToString();
om.TotalCount = redPocket.Count;
om.CryptoCode = redPocket.CryptoCode;
om.ReceiveAmount = (redPocket.Amount - redPocket.Balance).ToString();
om.ReceiveCount = redPocket.Count - redPocket.RemainCount;
om.Id = redPocket.Id;
om.HasExpried = redPocket.ExpirationDate < DateTime.UtcNow;
om.HasSelfSned = redPocket.AccountId == userAccount.Id;
return(om);
}
