public async Task <ActionResult> Create(string currency, string returnUrl)
{
var user = await UserManager.FindValidByIdAsync(User.Identity.GetUserId());
var currencyData = await CurrencyReader.GetCurrency(currency);
if (currencyData == null || user == null)
{
ViewBag.Message = $"Currency {currency} not found.";
return(View("Error"));
}
if (currencyData.Status == CurrencyStatus.Maintenance || currencyData.Status == CurrencyStatus.Offline)
{
ViewBag.HideSupportLink = true;
ViewBag.SubTitle = $"Status: {currencyData.Status}";
ViewBag.Message = $"Unfortunately we are unable to process your withdrawal at this time.<br /><br />Status: {currencyData.Status}<br />Reason: {(string.IsNullOrEmpty(currencyData.StatusMessage) ? "Unknown" : currencyData.StatusMessage)}";
return(View("Error"));
}
if (currencyData.CurrencyId == Constant.NZDT_ID && !UserVerificationReader.IsVerified(user.VerificationLevel))
{
return(View("NotVerified"));
}
return(View(await CreateWithdrawModel(user, new WithdrawCurrencyModel
{
Name = currencyData.Name,
Symbol = currencyData.Symbol,
ReturnUrl = GetLocalReturnUrl(returnUrl)
})));
}
public async Task <ApiUserDepositAddressResponse> GetUserDepositAddress(ApiUserDepositAddressRequest request)
{
var currency = request.CurrencyId.HasValue
? await CurrencyReader.GetCurrency(request.CurrencyId.Value).ConfigureAwait(false)
: await CurrencyReader.GetCurrency(request.Currency).ConfigureAwait(false);
if (currency == null)
{
return new ApiUserDepositAddressResponse {
Success = false, Error = "Currency not found."
}
}
;
var addressResponse = await AddressReader.GetAddress(request.UserId.ToString(), currency.CurrencyId).ConfigureAwait(false);
if (addressResponse == null || !string.IsNullOrEmpty(addressResponse.ErrorMessage))
{
return new ApiUserDepositAddressResponse {
Success = false, Error = addressResponse.ErrorMessage ?? "Currency not found."
}
}
;
return(new ApiUserDepositAddressResponse
{
Success = true,
Data = new ApiDepositAddressData
{
Currency = currency.Symbol,
Address = addressResponse.AddressData,
BaseAddress = currency.BaseAddress
}
});
}
private async Task <WithdrawCurrencyModel> CreateWithdrawModel(Cryptopia.Entity.ApplicationUser user, WithdrawCurrencyModel model)
{
var currencyData = await CurrencyReader.GetCurrency(model.Symbol);
var balanceData = await BalanceReader.GetCurrencyBalance(User.Identity.GetUserId(), currencyData.CurrencyId);
var addressBook = await AddressBookReader.GetAddressBook(User.Identity.GetUserId(), currencyData.CurrencyId);
var verificationData = await UserVerificationReader.GetVerificationStatus(User.Identity.GetUserId());
var estimatedCoinNzd = await BalanceEstimationService.GetNZDPerCoin(currencyData.CurrencyId);
model = user.GetTwoFactorModel(TwoFactorComponent.Withdraw, model);
model.Name = currencyData.Name;
model.CurrencyId = currencyData.CurrencyId;
model.CurrencyType = currencyData.Type;
model.Symbol = balanceData.Symbol;
model.Balance = balanceData.Available;
model.Fee = currencyData.WithdrawFee;
model.WithdrawFeeType = currencyData.WithdrawFeeType;
model.MinWithdraw = currencyData.WithdrawMin;
model.MaxWithdraw = currencyData.WithdrawMax;
model.AddressBookOnly = !user.IsUnsafeWithdrawEnabled;
model.AddressBook = addressBook;
model.AddressType = currencyData.AddressType;
model.HasWithdrawLimit = verificationData.Limit > 0;
model.WithdrawLimit = verificationData.Limit;
model.WithdrawTotal = verificationData.Current;
model.EstimatedCoinNZD = estimatedCoinNzd;
model.Instructions = currencyData.WithdrawInstructions;
model.Message = currencyData.WithdrawMessage;
model.MessageType = currencyData.WithdrawMessageType.ToString().ToLower();
model.Decimals = currencyData.CurrencyDecimals;
return(model);
}
public async Task <ActionResult> CreateTradePair()
{
return(View("CreateTradePairModal", new CreateTradePairModel
{
Currencies = await CurrencyReader.GetCurrencies()
}));
}
public async Task <PaytopiaPaymentModel> AdminGetPayment(int id)
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var item = await context.PaytopiaPayments
.AsNoTracking()
.Where(x => x.Id == id)
.Select(payment => new PaytopiaPaymentModel
{
Id = payment.Id,
Type = payment.PaytopiaItem.Type,
CurrencyId = payment.PaytopiaItem.CurrencyId,
Amount = payment.Amount,
Status = payment.Status,
UserName = payment.User.UserName,
IsAnonymous = payment.IsAnonymous,
Begins = payment.Begins,
Ends = payment.Ends,
Timestamp = payment.Timestamp,
TransferId = payment.TransferId,
RefundId = payment.RefundId,
ReferenceCode = payment.ReferenceCode,
ReferenceId = payment.ReferenceId,
RefundReason = payment.RefundReason,
RequestData = payment.RequestData,
}).FirstOrDefaultNoLockAsync().ConfigureAwait(false);
var currency = await CurrencyReader.GetCurrency(item.CurrencyId).ConfigureAwait(false);
item.Symbol = currency.Symbol;
if (item.ReferenceId > 0)
{
if (item.Type == PaytopiaItemType.FeaturedCurrency || item.Type == PaytopiaItemType.LottoSlot || item.Type == PaytopiaItemType.RewardSlot || item.Type == PaytopiaItemType.TipSlot)
{
var refCurrency = await CurrencyReader.GetCurrency(item.ReferenceId).ConfigureAwait(false);
if (refCurrency != null)
{
item.ReferenceName = refCurrency.Name;
item.ReferenceAlgo = refCurrency.AlgoType;
item.ReferenceSymbol = refCurrency.Symbol;
}
}
else if (item.Type == PaytopiaItemType.FeaturedPool || item.Type == PaytopiaItemType.PoolListing)
{
var refPool = await PoolReader.GetPool(item.ReferenceId).ConfigureAwait(false);
if (refPool != null)
{
item.ReferenceName = refPool.Name;
item.ReferenceAlgo = refPool.AlgoType;
item.ReferenceSymbol = refPool.Symbol;
}
}
}
return(item);
}
}
public async Task <DisplayAddressModel> GetDisplayAddress(string userId, string symbol)
{
var currentUser = new Guid(userId);
var currency = await CurrencyReader.GetCurrency(symbol).ConfigureAwait(false);
if (currency == null)
{
return(null);
}
using (var context = ExchangeDataContextFactory.CreateContext())
{
var address = await context.Address
.Where(x => x.CurrencyId == currency.CurrencyId && x.UserId == currentUser)
.FirstOrDefaultNoLockAsync().ConfigureAwait(false);
return(new DisplayAddressModel
{
AddressData = address?.AddressHash,
AddressData2 = currency.BaseAddress,
CurrencyId = currency.CurrencyId,
CurrencyType = currency.Type,
Name = currency.Name,
Symbol = currency.Symbol,
Instructions = currency.DepositInstructions,
Message = currency.DepositMessage,
MessageType = currency.DepositMessageType.ToString().ToLower(),
QrFormat = currency.QrFormat,
AddressType = currency.AddressType
});
}
}
public async Task <ActionResult> Create(string currency, string userName, string returnUrl)
{
var user = await UserManager.FindValidByIdAsync(User.Identity.GetUserId());
var currencyData = await CurrencyReader.GetCurrency(currency);
if (currencyData == null || user == null)
{
ViewBag.Message = String.Format(Resources.UserWallet.transferCurrencyNotFoundError, currency);
return(View("Error"));
}
if (currencyData.Status == CurrencyStatus.Maintenance || currencyData.Status == CurrencyStatus.Offline)
{
ViewBag.HideSupportLink = true;
ViewBag.SubTitle = String.Format("{0}: {1}", Resources.UserWallet.transferCreateStatusLabel, currencyData.Status);
ViewBag.Message = $"{Resources.UserWallet.transferCreateErrorMessage} <br /><br /> {Resources.UserWallet.transferCreateStatusLabel}: {currencyData.Status}<br />{Resources.UserWallet.transferCreateReasonLabel}: {(string.IsNullOrEmpty(currencyData.StatusMessage) ? Resources.UserWallet.transferCreateUnknownError : currencyData.StatusMessage)}";
return(View("Error"));
}
var checkUser = await UserReader.GetUserByName(userName);
return(View(await CreateTransferModel(user, new TransferCurrencyModel
{
Name = currencyData.Name,
Symbol = currencyData.Symbol,
ReturnUrl = GetLocalReturnUrl(returnUrl),
UserName = checkUser?.UserName
})));
}
public async Task <CreateTransferResponseModel> SubmitUserTransfer(ApiSubmitUserTransferRequest request)
{
var currency = request.CurrencyId.HasValue
? await CurrencyReader.GetCurrency(request.CurrencyId.Value).ConfigureAwait(false)
: await CurrencyReader.GetCurrency(request.Currency).ConfigureAwait(false);
if (currency == null)
{
return new CreateTransferResponseModel {
Error = "Currency not found."
}
}
;
var receiver = await UserReader.GetUserByName(request.UserName).ConfigureAwait(false);
if (receiver == null)
{
return new CreateTransferResponseModel {
Error = "Receiver not found."
}
}
;
var response = await TradeService.CreateTransfer(request.UserId.ToString(), new CreateTransferModel
{
CurrencyId = currency.CurrencyId,
Amount = request.Amount,
TransferType = TransferType.User,
Receiver = receiver.UserId
}, true).ConfigureAwait(false);
return(response);
}
public async Task <DataTablesResponse> GetPayments(string userId, DataTablesModel model)
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var query = context.PaytopiaPayments
.AsNoTracking()
.Where(x => x.UserId == userId)
.Select(payment => new PaymentDatatableModel
{
Id = payment.Id,
Type = payment.PaytopiaItem.Type,
CurrencyId = payment.PaytopiaItem.CurrencyId,
Amount = payment.Amount,
Status = payment.Status,
UserName = payment.User.UserName,
IsAnonymous = payment.IsAnonymous,
Begins = payment.Begins,
Ends = payment.Ends,
Timestamp = payment.Timestamp,
TransferId = payment.TransferId,
RefundId = payment.RefundId,
});
var currencies = await CurrencyReader.GetCurrencies().ConfigureAwait(false);
var symbolMap = currencies.ToDictionary(k => k.CurrencyId, v => v.Symbol);
return(await query.GetDataTableResultNoLockAsync(model, (item) =>
{
item.Symbol = symbolMap[item.CurrencyId];
}).ConfigureAwait(false));
}
}
public async Task <List <PaytopiaItemModel> > GetItems()
{
var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.PaytopiaItems(), TimeSpan.FromMinutes(10), async() =>
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var items = await context.PaytopiaItems
.AsNoTracking()
.Where(x => x.IsEnabled)
.Select(x => new PaytopiaItemModel
{
Id = x.Id,
Name = x.Name,
Description = x.Description,
Price = x.Price,
Type = x.Type,
Category = x.Category,
CurrencyId = x.CurrencyId
}).ToListNoLockAsync().ConfigureAwait(false);
foreach (var item in items)
{
var currency = await CurrencyReader.GetCurrency(item.CurrencyId).ConfigureAwait(false);
if (currency != null)
{
item.Symbol = currency.Symbol;
}
}
return(items);
}
}).ConfigureAwait(false);
return(cacheResult);
}
public static void Run([TimerTrigger("0 0 22 * * *", RunOnStartup = false)] TimerInfo myTimer, TraceWriter log)
{
try
{
Logger = new Logger(log);
Logger.Write("Starting new process");
StockReader stockReader = new StockReader();
List <Stock> stocks = stockReader.ReadShares();
CurrencyReader currencyReader = new CurrencyReader();
List <Currency> currencies = currencyReader.ReadCurrencies();
CurrencyConverter currencyConverter = new CurrencyConverter(currencies);
PriceReader priceReader = new PriceReader(currencyConverter);
stocks = priceReader.ReadValueOfStocks(stocks);
DynamoWriter stockWriter = new DynamoWriter();
stockWriter.WriteStockValues(stocks);
stockWriter.WriteDailyTotal(stocks.Sum(x => x.TotalValue));
Logger.Write("Process complete");
}
catch (Exception e)
{
log.Info(String.Format("Exception thrown: {0} - {1}", e.Message, e.StackTrace));
}
}
public async Task <DataTablesResponse> GetPaytopiaHistory(DataTablesModel model)
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var query = context.PaytopiaPayments
.AsNoTracking()
.Where(x => x.Status == PaytopiaPaymentStatus.Complete && x.PaytopiaItem.Type != PaytopiaItemType.Shares)
.Select(payment => new PaytopiaDatatableModel
{
Id = payment.Id,
CurrencyId = payment.PaytopiaItem.CurrencyId,
Type = payment.PaytopiaItem.Type,
Amount = payment.Amount,
Timestamp = payment.Timestamp
});
var currencies = await CurrencyReader.GetCurrencies().ConfigureAwait(false);
var nameMap = currencies.ToDictionary(k => k.CurrencyId, v => v.Name);
var symbolMap = currencies.ToDictionary(k => k.CurrencyId, v => v.Symbol);
return(await query.GetDataTableResultNoLockAsync(model, (item) =>
{
item.Name = nameMap[item.CurrencyId];
item.Symbol = symbolMap[item.CurrencyId];
}).ConfigureAwait(false));
}
}
public async Task <ActionResult> CreateMarketItem()
{
return(View(new CreateMarketItemModel
{
Currencies = await CurrencyReader.GetCurrencies(),
Categories = await MarketplaceReader.GetMarketCategories()
}));
}
public async Task <ActionResult> SubmitMarketItem(CreateMarketItemModel model)
{
if (!ModelState.IsValid)
{
model.Currencies = await CurrencyReader.GetCurrencies();
model.Categories = await MarketplaceReader.GetMarketCategories();
return(View("CreateMarketItem", model));
}
var mainImage = await model.MainImage.SaveMarketItemImageToDiskAsync(true);
var altimage1 = await model.AltImage1.SaveMarketItemImageToDiskAsync(false);
var altimage2 = await model.AltImage2.SaveMarketItemImageToDiskAsync(false);
var altimage3 = await model.AltImage3.SaveMarketItemImageToDiskAsync(false);
var altimage4 = await model.AltImage4.SaveMarketItemImageToDiskAsync(false);
var marketItem = new CreateMarketModel
{
Type = model.Type,
CategoryId = model.GetCategoryId(),
Title = model.Title,
CurrencyId = model.CurrencyId,
MainImage = mainImage,
AlternateImages = new List <string> {
altimage1, altimage2, altimage3, altimage4
},
AskingPrice = model.Price,
ReservePrice = model.ReservePrice,
Description = model.Description,
LocationRegion = model.LocationRegion,
AllowPickup = model.AllowPickup,
PickupOnly = model.PickupOnly,
LocationId = model.GetLocationId(),
ShippingBuyerArrange = model.ShippingBuyerArrange,
ShippingNational = model.ShippingNational,
ShippingInternational = model.ShippingInternational,
ShippingNationalPrice = model.ShippingNationalPrice,
ShippingNationalDetails = model.ShippingNationalDetails,
ShippingInternationalPrice = model.ShippingInternationalPrice,
ShippingInternationalDetails = model.ShippingInternationalDetails,
CloseDate = DateTime.UtcNow.AddDays(model.Type == MarketItemType.Auction ? Math.Max(3, model.AuctionDuration) : 14)
};
var result = await MarketplaceWriter.CreateMarketItem(User.Identity.GetUserId(), marketItem);
if (!result.Success)
{
return(ViewMessage(new ViewMessageModel(ViewMessageType.Danger, Resources.Market.itemActionErrorMessageTitle, Resources.Market.createItemErrorMessage)));
}
return(RedirectToAction("MarketItem", new { marketItemId = result.Result }));
}
public async Task <ActionResult> Create(TransferCurrencyModel model)
{
var currencyData = await CurrencyReader.GetCurrency(model.Symbol);
var user = await UserManager.FindValidByIdAsync(User.Identity.GetUserId());
if (currencyData == null || user == null)
{
ViewBag.Message = String.Format(Resources.UserWallet.transferCurrencyNotFoundError, model.Symbol);
return(View("Error"));
}
// Verify User
var receivingUser = await UserReader.GetUserByName(model.UserName);
if (receivingUser == null)
{
ModelState.AddModelError("UserName", String.Format(Resources.UserWallet.transferUserNotFoundError, model.UserName));
return(View(await CreateTransferModel(user, model)));
}
if (receivingUser.UserId.Equals(User.Identity.GetUserId(), StringComparison.OrdinalIgnoreCase))
{
ModelState.AddModelError("UserName", Resources.UserWallet.transferUserIgnoredError);
return(View(await CreateTransferModel(user, model)));
}
// Verify Amount
if (model.Amount < 0.00000001m)
{
ModelState.AddModelError("Amount", String.Format(Resources.UserWallet.transferMinAmountError, "0.00000001", currencyData.Symbol));
return(View(await CreateTransferModel(user, model)));
}
// Verify Two Factor
if (!await UserManager.VerifyUserTwoFactorCodeAsync(TwoFactorComponent.Transfer, user.Id, model.Code1, model.Code2))
{
ModelState.AddModelError("TwoFactorError", Resources.UserWallet.transferTwoFactorFailedError);
return(View(await CreateTransferModel(user, model)));
}
// Create transfer
var result = await TradeService.CreateTransfer(User.Identity.GetUserId(), new CreateTransferModel
{
Receiver = receivingUser.UserId,
Amount = model.Amount,
CurrencyId = model.CurrencyId,
TransferType = TransferType.User
});
if (result.IsError)
{
ModelState.AddModelError("Error", result.Error);
return(View(await CreateTransferModel(user, model)));
}
return(RedirectToAction("Summary", new { transferId = result.TransferId, returnUrl = GetLocalReturnUrl(model.ReturnUrl) }));
}
public async Task <ActionResult> Index(string returnUrl)
{
var currencyData = await CurrencyReader.GetCurrencies();
return(View(new TransferViewModel
{
Currencies = currencyData,
ReturnUrl = GetLocalReturnUrl(returnUrl)
}));
}
/// <summary>
/// App entry point.
/// </summary>
static void Main(string[] args)
{
CurrencyReader reader = new CurrencyReader();
CacheCurrencyReader cacheReader = new CacheCurrencyReader(reader);
CultureInfo culture = new CultureInfo("en-US");
Console.WriteLine("Enter date or dates (with comma) in ISO format (yyyy-MM-dd). " +
"\nFor example: \"2018-01-01\" or \"2018-01-01,2018-02-02\":" +
"Enter a blank line to exit.\n");
// User input.
string input;
// Input dates.
string[] dates;
// Currency name.
string currencyName = System.Threading.Thread.CurrentThread.CurrentCulture == CultureInfo.GetCultureInfo("ru-RU")
? "RUB"
: "EUR";
while (true)
{
input = Console.ReadLine().Trim();
if (string.IsNullOrEmpty(input))
{
break;
}
else
{
dates = input.Split(',');
}
foreach (var date in dates)
{
try
{
DateFormatChecker.Check(date);
Console.WriteLine($"{date}: {cacheReader.GetCurrencyByDate(DateTime.Parse(date)).ToString(culture)} {currencyName}");
}
catch (DateFormatException ex)
{
Console.WriteLine(ex.Message);
}
catch (CurrencyNotFoundException ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
public async Task <ActionResult> UpdateCurrency(int id)
{
var model = await CurrencyReader.GetUpdateCurrency(id);
if (model == null)
{
return(ViewMessageModal(new ViewMessageModel(ViewMessageType.Danger, "Error", $"Currency '{id}' not found")));
}
return(View("UpdateCurrencyModal", model));
}
public async Task <ActionResult> GetCurrencies()
{
var currencies = await CurrencyReader.GetCurrencies();
var model = new AdminCurrencyModel
{
Currencies = currencies.Select(x => x.Symbol).OrderBy(x => x).ToList()
};
return(PartialView("_Currencies", model));
}
public async Task <ActionResult> EditMarketItem(int marketItemId, bool isRelisting = false)
{
var response = await MarketplaceReader.GetMarketItem(marketItemId);
if (response == null)
{
return(RedirectToAction("Index"));
}
var currentUser = new Guid(User.Identity.GetUserId());
if (response.UserId != currentUser)
{
return(RedirectToAction("MarketItem", new { marketItemId = marketItemId }));
}
var marketItem = new EditMarketItemModel
{
Title = response.Title,
Id = response.Id,
Type = response.Type,
CategoryId = response.CategoryId,
Price = response.AskingPrice,
Description = response.Description,
CurrentMainImage = response.MainImage,
CurrentAltImage1 = response.AlternateImages.Take(1).FirstOrDefault(),
CurrentAltImage2 = response.AlternateImages.Skip(1).Take(1).FirstOrDefault(),
CurrentAltImage3 = response.AlternateImages.Skip(2).Take(1).FirstOrDefault(),
CurrentAltImage4 = response.AlternateImages.Skip(3).Take(1).FirstOrDefault(),
CurrencyId = response.CurrencyId,
// Feature = response.MarketItem.Feature,
CityId = response.GetCityId(),
CountryId = response.GetCountryId(),
ReservePrice = response.ReservePrice,
LocationRegion = response.LocationRegion,
AllowPickup = response.AllowPickup,
PickupOnly = response.PickupOnly,
ShippingBuyerArrange = response.ShippingBuyerArrange,
ShippingNational = response.ShippingNational,
ShippingInternational = response.ShippingInternational,
ShippingNationalPrice = response.ShippingNationalPrice,
ShippingNationalDetails = response.ShippingNationalDetails,
ShippingInternationalPrice = response.ShippingInternationalPrice,
ShippingInternationalDetails = response.ShippingInternationalDetails,
IsRelisting = isRelisting,
HasBids = response.Bids != null && response.Bids.Any(),
Currencies = await CurrencyReader.GetCurrencies(),
Categories = await MarketplaceReader.GetMarketCategories()
};
marketItem.SetCategories(response);
return(View(marketItem));
}
async Task <List <Balance> > GetBalancesAsync(string accountNumber, AccessToken accessToken)
{
var balances = new List <Balance>();
foreach (var b in (await BalanceApi.FindBalancesAsync(accountNumber, accessToken)).PerCurrencyBalances)
{
balances.Add(new Balance(Balance.Cash, b.Cash, await CurrencyReader.ReadByCodeAsync(b.Currency.ToString())));
}
return(balances);
}
public async Task <ActionResult> PeerInfo(int id)
{
var model = await CurrencyReader.GetPeerInfo(id);
if (model == null)
{
return(ViewMessageModal(new ViewMessageModel(ViewMessageType.Danger, Resources.CoinInfo.infoCurrencyNotFoundMessageTitle,
String.Format(Resources.CoinInfo.infoCurrencyNotFoundMessage, id))));
}
return(View("PeerInfoModal", model));
}
public async Task <List <LottoSlotItemModel> > GetLottoSlotItems()
{
var currencies = await CurrencyReader.GetCurrencies().ConfigureAwait(false);
return(currencies.Select(x => new LottoSlotItemModel
{
Id = x.CurrencyId,
Name = x.Symbol
})
.OrderBy(x => x.Name)
.ToList());
}
public async Task <ActionResult> TipCurrency()
{
var user = await UserManager.FindValidByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return(View("~/Views/Modal/Invalid.cshtml"));
}
var model = user.GetTwoFactorModel <TipbotModel>(TwoFactorComponent.Tip);
model.Currencies = await CurrencyReader.GetCurrencies();
return(View(model));
}
public async Task <ActionResult> Index(string returnUrl)
{
var currencyData = await CurrencyReader.GetCurrencies();
if (currencyData == null)
{
ViewBag.Message = "An unknown error occurred, if problems persit please contact Cryptopia support.";
return(View("Error"));
}
return(View(new WithdrawViewModel
{
Currencies = currencyData,
ReturnUrl = GetLocalReturnUrl(returnUrl)
}));
}
public async Task <ActionResult> AdminUpdateVoteSettings()
{
var model = await VoteReader.GetVoteSettings();
if (model == null)
{
return(ViewMessageModal(ViewMessageModel.Error("Not Found", "Vote settings not found.")));
}
return(View("AdminUpdateVoteSettingsModal", new UpdateVoteSettingsModel
{
Next = model.NextVote,
Price = model.Price,
IsFreeEnabled = model.IsFreeEnabled,
IsPaidEnabled = model.IsPaidEnabled,
CurrencyId = model.CurrencyId,
Currencies = await CurrencyReader.GetCurrencies()
}));
}
public async Task <List <TipSlotItemModel> > GetTipSlotItems()
{
var currencies = await CurrencyReader.GetCurrencies().ConfigureAwait(false);
return(currencies.Select(x => new TipSlotItemModel
{
Id = x.CurrencyId,
Name = x.Symbol,
IsExpired = DateTime.UtcNow > x.TippingExpires,
Expires = x.TippingExpires > DateTime.UtcNow
? x.TippingExpires
: DateTime.UtcNow,
NewExpiry = x.TippingExpires > DateTime.UtcNow
? x.TippingExpires.AddDays(30)
: DateTime.UtcNow.AddDays(30)
})
.OrderBy(x => x.Name)
.ToList());
}
private async Task <List <ShareholderFeeInfo> > GetTradeFeeInfo(DateTime lastPayout, DateTime nextPayout, decimal totalBTCExpense)
{
var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.ShareholderTradeFeeInfo(), TimeSpan.FromHours(1), async() =>
{
var baseCurrencies = await CurrencyReader.GetBaseCurrencies().ConfigureAwait(false);
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var feeData = await context.TradeHistory
.AsNoTracking()
.Where(x => x.Timestamp > lastPayout && x.Timestamp <= nextPayout)
.Select(x => new
{
BaseCurrency = x.TradePair.Currency2.Symbol,
Fee = x.Fee
})
.GroupBy(x => x.BaseCurrency)
.Select(x => new
{
Symbol = x.Key,
Total = x.Sum(k => k.Fee)
}).ToListNoLockAsync().ConfigureAwait(false);
var results = new List <ShareholderFeeInfo>();
foreach (var baseCurrency in baseCurrencies.OrderBy(x => x.CurrencyId))
{
var fees = feeData.FirstOrDefault(x => x.Symbol == baseCurrency.Symbol);
var info = new ShareholderFeeInfo
{
Name = baseCurrency.Name,
Symbol = baseCurrency.Symbol,
TotalFees = (fees?.Total ?? 0) * 2,
Expenses = baseCurrency.CurrencyId == 1 ? totalBTCExpense : 0
};
info.SharePrice = Math.Max(info.TotalFees - info.Expenses, 0) / 20000.0m;
results.Add(info);
}
return(results);
}
}).ConfigureAwait(false);
return(cacheResult);
}
public async Task <ActionResult> AdminUpdateVoteSettings(UpdateVoteSettingsModel model)
{
if (!ModelState.IsValid)
{
model.Currencies = await CurrencyReader.GetCurrencies();
return(View("AdminUpdateVoteSettingsModal", model));
}
var result = await VoteWriter.AdminUpdateVoteSettings(User.Id(), model);
if (!ModelState.IsWriterResultValid(result))
{
model.Currencies = await CurrencyReader.GetCurrencies();
return(View("AdminUpdateVoteSettingsModal", model));
}
return(CloseModal());
}
public async Task <ActionResult> CreateTradePair(CreateTradePairModel model)
{
if (!ModelState.IsValid)
{
model.Currencies = await CurrencyReader.GetCurrencies();
return(View("CreateTradePairModal", model));
}
var result = await TradePairWriter.AdminCreateTradePair(model);
if (!ModelState.IsWriterResultValid(result))
{
model.Currencies = await CurrencyReader.GetCurrencies();
return(View("CreateTradePairModal", model));
}
return(CloseModal(result));
}
