private static void ParseCurrencyValueFromNode(ref CurrencyValue newCurrency, XmlNode childnode)
{
String nodeValue = childnode.InnerText;
Int32.TryParse(nodeValue, out Int32 intValue);
Single.TryParse(nodeValue, out Single floatValue);
switch (childnode.Name)
{
case "NumCode":
newCurrency.CurrencyInfo.NumCode = intValue;
break;
case "CharCode":
newCurrency.CurrencyInfo.CharCode = nodeValue.ToUpper();
newCurrency.CurrencyInfoId = nodeValue.ToUpper();
break;
case "Nominal":
newCurrency.CurrencyInfo.Nominal = intValue;
break;
case "Name":
newCurrency.CurrencyInfo.Name = nodeValue;
break;
case "Value":
newCurrency.Value = floatValue;
break;
}
}
public override async Task <string> IsPaymentMethodAllowedBasedOnInvoiceAmount(StoreBlob storeBlob,
Dictionary <CurrencyPair, Task <RateResult> > rate, Money amount, PaymentMethodId paymentMethodId)
{
Func <Money, Money, bool> compare = null;
CurrencyValue limitValue = null;
string errorMessage = null;
if (storeBlob.LightningMaxValue != null)
{
compare = (value, limit) => value > limit;
limitValue = storeBlob.LightningMaxValue;
errorMessage = "The amount of the invoice is too high to be paid with lightning";
}
if (compare != null)
{
var currentRateToCrypto = await rate[new CurrencyPair(paymentMethodId.CryptoCode, limitValue.Currency)];
if (currentRateToCrypto.BidAsk != null)
{
var limitValueCrypto = Money.Coins(limitValue.Value / currentRateToCrypto.BidAsk.Bid);
if (compare(amount, limitValueCrypto))
{
return(errorMessage);
}
}
}
return(string.Empty);
}
public static void Main()
{
// Display the currency value.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Decimal value = 16039.47m;
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
Console.WriteLine("Currency Value: {0:C2}", value);
// Serialize the currency data.
BinaryFormatter bf = new BinaryFormatter();
FileStream fw = new FileStream("currency.dat", FileMode.Create);
CurrencyValue data = new CurrencyValue(value, CultureInfo.CurrentCulture.Name);
bf.Serialize(fw, data);
fw.Close();
Console.WriteLine();
// Change the current thread culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
// Deserialize the data.
FileStream fr = new FileStream("currency.dat", FileMode.Open);
CurrencyValue restoredData = (CurrencyValue)bf.Deserialize(fr);
fr.Close();
// Display the original value.
CultureInfo culture = CultureInfo.CreateSpecificCulture(restoredData.CultureName);
Console.WriteLine("Currency Value: {0}", restoredData.Amount.ToString("C2", culture));
}
public void Write(CurrencyValue currencyObject)
{
var currencyValuesContext = new CurrencyValuesContext();
currencyValuesContext.CurrencyValues.Add(currencyObject);
currencyValuesContext.SaveChanges();
}
private static void SaveValueDbWork(CurrencyValue value)
{
using (var conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Para"].ConnectionString))
{
using (var cmd = new SqlCommand())
{
cmd.Connection = conn;
cmd.CommandType = CommandType.Text;
cmd.CommandText = @"IF NOT EXISTS (SELECT *
FROM [CurrencyValue]
WHERE [Day] = @day
AND [Source] = @source
AND [Target] = @target
AND [ValueSource] = @valueSource
AND [ValueType] = @valueType
AND [Value] = @value)
BEGIN
INSERT INTO [CurrencyValue] ([Day],[Source],[Target],[ValueSource],[ValueType],[Value])
VALUES (@day,@source,@target,@valueSource,@valueType,@value)
END";
cmd.Parameters.AddWithValue("@day", value.Day);
cmd.Parameters.AddWithValue("@source", value.Source.ToString());
cmd.Parameters.AddWithValue("@target", value.Target.ToString());
cmd.Parameters.AddWithValue("@valueSource", value.ValueSoruce.ToString());
cmd.Parameters.AddWithValue("@valueType", value.ValueType.ToString());
cmd.Parameters.AddWithValue("@value", value.Value);
conn.Open();
cmd.ExecuteNonQuery();
}
}
}
public void Test_TwoEqualValues_DifferentSymbols_AreNotEqual()
{
var value1 = new CurrencyValue("£123.45");
var value2 = new CurrencyValue("$123.45");
Check.That(value1.Equals(value2)).IsFalse();
}
public void Test_TwoEqualValues_AreEqual()
{
var value1 = new CurrencyValue("£123.45");
var value2 = new CurrencyValue("123.45 £");
Check.That(value1.Equals(value2)).IsTrue();
}
private void WriteInternal(CurrencyValue currencyObject)
{
using (StreamWriter outputFile = new StreamWriter(File.Open(Bootstrapper.FilePath + currencyObject.Type.ToString() + ".txt", FileMode.Append)))
{
outputFile.Write($"{currencyObject.Date.ToShortDateString()};{currencyObject.Type.ToString()};{currencyObject.Value};{currencyObject.ReferenceNumber}\r\n");
}
}
public async Task <IActionResult> CheckoutExperience(CheckoutExperienceViewModel model)
{
CurrencyValue lightningMaxValue = null;
if (!string.IsNullOrWhiteSpace(model.LightningMaxValue))
{
if (!CurrencyValue.TryParse(model.LightningMaxValue, out lightningMaxValue))
{
ModelState.AddModelError(nameof(model.LightningMaxValue), "Invalid lightning max value");
}
}
CurrencyValue onchainMinValue = null;
if (!string.IsNullOrWhiteSpace(model.OnChainMinValue))
{
if (!CurrencyValue.TryParse(model.OnChainMinValue, out onchainMinValue))
{
ModelState.AddModelError(nameof(model.OnChainMinValue), "Invalid on chain min value");
}
}
bool needUpdate = false;
var blob = StoreData.GetStoreBlob();
if (StoreData.GetDefaultCrypto() != model.DefaultCryptoCurrency)
{
needUpdate = true;
StoreData.SetDefaultCrypto(model.DefaultCryptoCurrency);
}
model.SetCryptoCurrencies(_ExplorerProvider, model.DefaultCryptoCurrency);
model.SetLanguages(_LangService, model.DefaultLang);
if (!ModelState.IsValid)
{
return(View(model));
}
blob.DefaultLang = model.DefaultLang;
blob.AllowCoinConversion = model.AllowCoinConversion;
blob.RequiresRefundEmail = model.RequiresRefundEmail;
blob.LightningMaxValue = lightningMaxValue;
blob.OnChainMinValue = onchainMinValue;
blob.CustomLogo = string.IsNullOrWhiteSpace(model.CustomLogo) ? null : new Uri(model.CustomLogo, UriKind.Absolute);
blob.CustomCSS = string.IsNullOrWhiteSpace(model.CustomCSS) ? null : new Uri(model.CustomCSS, UriKind.Absolute);
blob.HtmlTitle = string.IsNullOrWhiteSpace(model.HtmlTitle) ? null : model.HtmlTitle;
if (StoreData.SetStoreBlob(blob))
{
needUpdate = true;
}
if (needUpdate)
{
await _Repo.UpdateStore(StoreData);
StatusMessage = "Store successfully updated";
}
return(RedirectToAction(nameof(CheckoutExperience), new
{
storeId = StoreData.Id
}));
}
public static decimal GetOrDefault(this CurrencyValue value)
{
if (!value.IsDefined())
{
return(default(decimal));
}
return(value.Value);
}
/// <summary>
/// Saves <see cref="CurrencyModel"/> into database
/// </summary>
/// <param name="result"><see cref="CurrencyModel"/></param>
/// <returns></returns>
public async Task SaveAsync(CurrencyResultResponse result)
{
using (var transaction = await _dbContext.Database.BeginTransactionAsync())
{
try
{
var currencyValue = await _dbContext.CurrencyValues.Include(c => c.Currency)
.FirstOrDefaultAsync(c =>
c.DailyDataOfCurrency == result.DailyDataOfCurrency &&
c.Currency.CurrencyBeingMeasured == result.CurrencyBeingMeasured &&
c.Currency.CurrencyMatched == result.CurrencyMatched);
if (currencyValue != null)
{
return;
}
var currency = await _dbContext.Currencies.FirstOrDefaultAsync(c =>
c.CurrencyBeingMeasured == result.CurrencyBeingMeasured && c.CurrencyMatched == result.CurrencyMatched);
if (currency == null)
{
currency = new Currency
{
CurrencyBeingMeasured = result.CurrencyBeingMeasured,
CurrencyMatched = result.CurrencyMatched
};
var currencyEntity = await _dbContext.Currencies.AddAsync(currency);
currency = currencyEntity.Entity;
}
currencyValue = new CurrencyValue
{
Value = result.CurrencyValue,
DailyDataOfCurrency = result.DailyDataOfCurrency,
Currency = currency
};
await _dbContext.CurrencyValues.AddAsync(currencyValue);
await _dbContext.SaveChangesAsync();
await transaction.CommitAsync();
}
catch
{
await transaction.RollbackAsync();
throw;
}
}
}
public Revenue(CurrencyValue gross, DateTimeWithTimeZone accepted = null, CurrencyValue notTaxable = null, TaxRateItem lowerTaxRate = null, TaxRateItem reducedTaxRate = null, TaxRateItem standardTaxRate = null, CurrencyValue travelServices = null, CurrencyValue deposit = null, CurrencyValue usedDeposit = null)
{
Accepted = accepted ?? DateTimeProvider.Now;
Gross = gross;
NotTaxable = notTaxable;
LowerTaxRate = lowerTaxRate;
ReducedTaxRate = reducedTaxRate;
StandardTaxRate = standardTaxRate;
TravelServices = travelServices;
Deposit = deposit;
UsedDeposit = usedDeposit;
}
public void ToLists()
{
CurrencyName.Add("polski złoty");
CurrencyValue.Add(1);
CurrencySignature.Add("PLN");
foreach (var value in CurrencyCalculatorApiJsonVariable[0].Rates)
{
CurrencyName.Add(value.Currency);
CurrencyValue.Add(value.Mid);
CurrencySignature.Add(value.Code);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
return(reader.TokenType == JsonToken.Null ? null :
CurrencyValue.TryParse((string)reader.Value, out var result) ? result :
throw new JsonObjectException("Invalid Currency value", reader));
}
catch (InvalidCastException)
{
throw new JsonObjectException("Invalid Currency value", reader);
}
}
/// <summary>
/// Gets current price information for all items.
/// </summary>
/// <param name="value">The type(s) of price values desired to be included in the response.</param>
/// <param name="since">If set, only items with prices newer than this <see cref="DateTimeOffset"/> will be returned.</param>
public async Task <ItemPrices> GetItemPricesAsync(CurrencyValue value = CurrencyValue.None,
DateTimeOffset?since = null)
{
var dto = (since ?? UnixEpoch).ToUniversalTime();
if (dto < UnixEpoch)
{
throw new ArgumentOutOfRangeException(nameof(since),
"The specified value must be greater than the value of the UNIX epoch.");
}
return(await GetAsync <ItemPrices>("IGetPrices/v4",
("raw", (int)value),
("since", (dto - UnixEpoch).TotalSeconds)).ConfigureAwait(false));
}
public async Task <IActionResult> CheckoutExperience(string storeId, CheckoutExperienceViewModel model)
{
CurrencyValue currencyValue = null;
if (!string.IsNullOrWhiteSpace(model.LightningMaxValue))
{
if (!CurrencyValue.TryParse(model.LightningMaxValue, out currencyValue))
{
ModelState.AddModelError(nameof(model.LightningMaxValue), "Invalid currency value");
}
}
var store = await _Repo.FindStore(storeId, GetUserId());
if (store == null)
{
return(NotFound());
}
bool needUpdate = false;
var blob = store.GetStoreBlob();
if (store.GetDefaultCrypto() != model.DefaultCryptoCurrency)
{
needUpdate = true;
store.SetDefaultCrypto(model.DefaultCryptoCurrency);
}
model.SetCryptoCurrencies(_ExplorerProvider, model.DefaultCryptoCurrency);
model.SetLanguages(_LangService, model.DefaultLang);
blob.DefaultLang = model.DefaultLang;
blob.AllowCoinConversion = model.AllowCoinConversion;
blob.LightningMaxValue = currencyValue;
blob.CustomLogo = model.CustomLogo;
blob.CustomCSS = model.CustomCSS;
if (store.SetStoreBlob(blob))
{
needUpdate = true;
}
if (needUpdate)
{
await _Repo.UpdateStore(store);
StatusMessage = "Store successfully updated";
}
return(RedirectToAction(nameof(CheckoutExperience), new
{
storeId = storeId
}));
}
public TaxData(
CurrencyValue standartRate = null,
CurrencyValue reducedRate = null,
CurrencyValue lowerReducedRate = null,
CurrencyValue zeroRate = null,
CurrencyValue specialRate = null
)
{
var fallback = new CurrencyValue(0);
StandardRate = standartRate ?? fallback;
ReducedRate = reducedRate ?? fallback;
LowerReducedRate = lowerReducedRate ?? fallback;
ZeroRate = zeroRate ?? fallback;
SpecialRate = specialRate ?? fallback;
}
private async Task MigratePaymentMethodCriteria()
{
using var ctx = _DBContextFactory.CreateContext();
foreach (var store in await ctx.Stores.AsQueryable().ToArrayAsync())
{
var blob = store.GetStoreBlob();
CurrencyValue onChainMinValue = null;
CurrencyValue lightningMaxValue = null;
if (blob.AdditionalData.TryGetValue("onChainMinValue", out var onChainMinValueJToken))
{
CurrencyValue.TryParse(onChainMinValueJToken.Value <string>(), out onChainMinValue);
blob.AdditionalData.Remove("onChainMinValue");
}
if (blob.AdditionalData.TryGetValue("lightningMaxValue", out var lightningMaxValueJToken))
{
CurrencyValue.TryParse(lightningMaxValueJToken.Value <string>(), out lightningMaxValue);
blob.AdditionalData.Remove("lightningMaxValue");
}
blob.PaymentMethodCriteria = store.GetEnabledPaymentIds(_NetworkProvider).Select(paymentMethodId =>
{
var matchedFromBlob =
blob.PaymentMethodCriteria?.SingleOrDefault(criteria => criteria.PaymentMethod == paymentMethodId && criteria.Value != null);
return(matchedFromBlob switch
{
null when paymentMethodId.PaymentType == LightningPaymentType.Instance &&
lightningMaxValue != null => new PaymentMethodCriteria()
{
Above = false,
PaymentMethod = paymentMethodId,
Value = lightningMaxValue
},
null when paymentMethodId.PaymentType == BitcoinPaymentType.Instance &&
onChainMinValue != null => new PaymentMethodCriteria()
{
Above = true,
PaymentMethod = paymentMethodId,
Value = onChainMinValue
},
_ => new PaymentMethodCriteria()
{
PaymentMethod = paymentMethodId,
Above = matchedFromBlob?.Above ?? true,
Value = matchedFromBlob?.Value
}
});
}).ToList();
private static List <CurrencyValue> GetCurrencyValuesFromXmlRoot(XmlElement root, DateTime forDate)
{
List <CurrencyValue> result = new List <CurrencyValue>();
foreach (XmlNode node in root)
{
CurrencyValue newCurrency = new CurrencyValue()
{
Date = forDate.Date
};
foreach (XmlNode childnode in node.ChildNodes)
{
ParseCurrencyValueFromNode(ref newCurrency, childnode);
}
result.Add(newCurrency);
}
return(result);
}
public override CurrencyValue[] GetCosts(ItemStack itemStack)
{
List <CurrencyValue> validCosts = new List <CurrencyValue>();
if (!m_UseItemValues)
{
foreach (CurrencyValue cost in m_Costs)
{
if (cost.Currency.ConsistencyCheck())
{
validCosts.Add(cost);
}
}
}
else
{
validCosts.Add(itemStack.Item.CurrencyValue);
}
float multiplier = 1.0f;
if (m_ScaleByExplicitCount)
{
multiplier += itemStack.ExplicitMods.Length;
}
if (m_ScaleByImplicitCount)
{
multiplier += itemStack.ImplicitMods.Length;
}
if (m_ScaleByPowerLevel)
{
multiplier += itemStack.PowerLevel;
}
multiplier *= m_Multiplier;
for (int i = 0; i < validCosts.Count; i++)
{
CurrencyValue cv = validCosts[i];
cv.Value = (long)(cv.Value * multiplier);
validCosts[i] = cv;
}
return(validCosts.ToArray());
}
public override bool OnBeforeSerialize()
{
if (!m_WalletIdentifier.ConsistencyCheck())
{
return(false);
}
var currencyList = m_WalletIdentifier.Object.CurrencyList;
m_Currencies = new CurrencyValue[currencyList.Count];
int i = 0;
foreach (var currency in currencyList)
{
m_Currencies[i] = new CurrencyValue();
m_Currencies[i].Currency.Identifier = currency.Key;
m_Currencies[i].Value = currency.Value;
i++;
}
return(true);
}
public JsonResult SaveCurrencyValue(CurrencyValue ObjToSave)
{
MsgUnit Msg = new MsgUnit();
try
{
var userId = User.Identity.GetUserId();
var UserInfo = _unitOfWork.User.GetMyInfo(userId);
ObjToSave.InsDateTime = DateTime.Now;
ObjToSave.InsUserID = userId;
ObjToSave.CompanyID = UserInfo.fCompanyId;
if (!ModelState.IsValid)
{
string Err = " ";
var errors = ModelState.Values.SelectMany(v => v.Errors);
foreach (ModelError error in errors)
{
Err = Err + error.ErrorMessage + " * ";
}
Msg.Msg = Resources.Resource.SomthingWentWrong + " : " + Err;
Msg.Code = 0;
return(Json(Msg, JsonRequestBehavior.AllowGet));
}
_unitOfWork.CurrencyValue.Add(ObjToSave);
_unitOfWork.Complete();
Msg.Code = 1;
Msg.Msg = Resources.Resource.AddedSuccessfully;
return(Json(Msg, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
Msg.Msg = Resources.Resource.SomthingWentWrong + " : " + ex.Message.ToString();
Msg.Code = 0;
return(Json(Msg, JsonRequestBehavior.AllowGet));
}
}
private static Dictionary <string, CurrencyValue> PrepareCrossRate(List <CurrencyValue> values)
{
var crossRate = new Dictionary <string, CurrencyValue>();
foreach (var currencyValue in values)
{
foreach (var value in values.Where(value => currencyValue.ValueType == value.ValueType))
{
var key = string.Format("{0}-{1}-{2}", currencyValue.Source, value.Source, value.ValueType);
crossRate[key] = new CurrencyValue
{
Day = value.Day,
Source = currencyValue.Source,
Target = value.Source,
ValueSoruce = value.ValueSoruce,
ValueType = value.ValueType,
Value = Convert.ToDecimal((currencyValue.Value / value.Value).ToString("##.####"))
};
}
}
return(crossRate);
}
public GameCurrencySystem(UserInterfaceSystem ui)
{
map = new Dictionary <GameCurrency, CurrencyValue>();
buffers = new Dictionary <GameCurrency, CurrencyValue>();
var currencies = (GameCurrency[])System.Enum.GetValues(typeof(GameCurrency));
System.Action <GameCurrency, int> onSetMainCurrencyValueCallback = null;
onSetMainCurrencyValueCallback += (currency, value) => PersistentData.SetIntEncoded(GetType(), (int)currency, value);
onSetMainCurrencyValueCallback += ui.DisplayCurrency;
System.Action <GameCurrency, int> onSetBufferCurrencyValueCallback = ui.DisplayBufferCurrency;
foreach (var currency in currencies)
{
var persistentCurrencyValue = new CurrencyValue(true, currency, onSetMainCurrencyValueCallback);
persistentCurrencyValue.Value = PersistentData.GetIntDecoded(GetType(), (int)currency);
map.Add(currency, persistentCurrencyValue);
var bufferCurrencyValue = new CurrencyValue(true, currency, onSetBufferCurrencyValueCallback);
buffers.Add(currency, bufferCurrencyValue);
}
}
public override async Task <string> IsPaymentMethodAllowedBasedOnInvoiceAmount(StoreBlob storeBlob,
Dictionary <CurrencyPair, Task <RateResult> > rate, Money amount, PaymentMethodId paymentMethodId)
{
Func <Money, Money, bool> compare = null;
CurrencyValue limitValue = null;
string errorMessage = null;
if (paymentMethodId.PaymentType == PaymentTypes.LightningLike &&
storeBlob.LightningMaxValue != null)
{
compare = (a, b) => a > b;
limitValue = storeBlob.LightningMaxValue;
errorMessage = "The amount of the invoice is too high to be paid with lightning";
}
else if (paymentMethodId.PaymentType == PaymentTypes.BTCLike &&
storeBlob.OnChainMinValue != null)
{
compare = (a, b) => a < b;
limitValue = storeBlob.OnChainMinValue;
errorMessage = "The amount of the invoice is too low to be paid on chain";
}
if (compare != null)
{
var limitValueRate = await rate[new CurrencyPair(paymentMethodId.CryptoCode, storeBlob.OnChainMinValue.Currency)];
if (limitValueRate.BidAsk != null)
{
var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate.BidAsk.Bid);
if (compare(amount, limitValueCrypto))
{
return(errorMessage);
}
}
}
return(string.Empty);
}
public async Task <IActionResult> CheckoutExperience(CheckoutExperienceViewModel model)
{
bool needUpdate = false;
var blob = CurrentStore.GetStoreBlob();
var defaultPaymentMethodId = model.DefaultPaymentMethod == null ? null : PaymentMethodId.Parse(model.DefaultPaymentMethod);
if (CurrentStore.GetDefaultPaymentId(_NetworkProvider) != defaultPaymentMethodId)
{
needUpdate = true;
CurrentStore.SetDefaultPaymentId(defaultPaymentMethodId);
}
SetCryptoCurrencies(model, CurrentStore);
model.SetLanguages(_LangService, model.DefaultLang);
model.PaymentMethodCriteria ??= new List <PaymentMethodCriteriaViewModel>();
for (var index = 0; index < model.PaymentMethodCriteria.Count; index++)
{
var methodCriterion = model.PaymentMethodCriteria[index];
if (!string.IsNullOrWhiteSpace(methodCriterion.Value))
{
if (!CurrencyValue.TryParse(methodCriterion.Value, out var value))
{
model.AddModelError(viewModel => viewModel.PaymentMethodCriteria[index].Value,
$"{methodCriterion.PaymentMethod}: invalid format (1.0 USD)", this);
}
}
}
if (!ModelState.IsValid)
{
return(View(model));
}
blob.PaymentMethodCriteria = model.PaymentMethodCriteria
.Where(viewModel => !string.IsNullOrEmpty(viewModel.Value)).Select(viewModel =>
{
CurrencyValue.TryParse(viewModel.Value, out var cv);
return(new PaymentMethodCriteria()
{
Above = viewModel.Type == PaymentMethodCriteriaViewModel.CriteriaType.GreaterThan, Value = cv, PaymentMethod = PaymentMethodId.Parse(viewModel.PaymentMethod)
});
}).ToList();
blob.RequiresRefundEmail = model.RequiresRefundEmail;
blob.LazyPaymentMethods = model.LazyPaymentMethods;
blob.LightningAmountInSatoshi = model.LightningAmountInSatoshi;
blob.LightningPrivateRouteHints = model.LightningPrivateRouteHints;
blob.OnChainWithLnInvoiceFallback = model.OnChainWithLnInvoiceFallback;
blob.RedirectAutomatically = model.RedirectAutomatically;
blob.ShowRecommendedFee = model.ShowRecommendedFee;
blob.RecommendedFeeBlockTarget = model.RecommendedFeeBlockTarget;
blob.CustomLogo = model.CustomLogo;
blob.CustomCSS = model.CustomCSS;
blob.HtmlTitle = string.IsNullOrWhiteSpace(model.HtmlTitle) ? null : model.HtmlTitle;
blob.DefaultLang = model.DefaultLang;
if (CurrentStore.SetStoreBlob(blob))
{
needUpdate = true;
}
if (needUpdate)
{
await _Repo.UpdateStore(CurrentStore);
TempData[WellKnownTempData.SuccessMessage] = "Store successfully updated";
}
return(RedirectToAction(nameof(CheckoutExperience), new
{
storeId = CurrentStore.Id
}));
}
private async Task <PaymentMethod> CreatePaymentMethodAsync(Dictionary <CurrencyPair, Task <RateResult> > fetchingByCurrencyPair, IPaymentMethodHandler handler, ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network, InvoiceEntity entity, StoreData store, InvoiceLogs logs)
{
try
{
var logPrefix = $"{handler.ToPrettyString(supportedPaymentMethod.PaymentId)}:";
var storeBlob = store.GetStoreBlob();
var preparePayment = handler.PreparePayment(supportedPaymentMethod, store, network);
var rate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, entity.ProductInformation.Currency)];
if (rate.BidAsk == null)
{
return(null);
}
PaymentMethod paymentMethod = new PaymentMethod();
paymentMethod.ParentEntity = entity;
paymentMethod.Network = network;
paymentMethod.SetId(supportedPaymentMethod.PaymentId);
paymentMethod.Rate = rate.BidAsk.Bid;
paymentMethod.PreferOnion = this.Request.IsOnion();
using (logs.Measure($"{logPrefix} Payment method details creation"))
{
var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, store, network, preparePayment);
paymentMethod.SetPaymentMethodDetails(paymentDetails);
}
Func <Money, Money, bool> compare = null;
CurrencyValue limitValue = null;
string errorMessage = null;
if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.LightningLike &&
storeBlob.LightningMaxValue != null)
{
compare = (a, b) => a > b;
limitValue = storeBlob.LightningMaxValue;
errorMessage = "The amount of the invoice is too high to be paid with lightning";
}
else if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.BTCLike &&
storeBlob.OnChainMinValue != null)
{
compare = (a, b) => a < b;
limitValue = storeBlob.OnChainMinValue;
errorMessage = "The amount of the invoice is too low to be paid on chain";
}
if (compare != null)
{
var limitValueRate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, limitValue.Currency)];
if (limitValueRate.BidAsk != null)
{
var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate.BidAsk.Bid);
if (compare(paymentMethod.Calculate().Due, limitValueCrypto))
{
logs.Write($"{logPrefix} {errorMessage}");
return(null);
}
}
}
///////////////
#pragma warning disable CS0618
if (paymentMethod.GetId().IsBTCOnChain)
{
entity.TxFee = paymentMethod.NextNetworkFee;
entity.Rate = paymentMethod.Rate;
entity.DepositAddress = paymentMethod.DepositAddress;
}
#pragma warning restore CS0618
return(paymentMethod);
}
catch (PaymentMethodUnavailableException ex)
{
logs.Write($"{supportedPaymentMethod.PaymentId.CryptoCode}: Payment method unavailable ({ex.Message})");
}
catch (Exception ex)
{
logs.Write($"{supportedPaymentMethod.PaymentId.CryptoCode}: Unexpected exception ({ex.ToString()})");
}
return(null);
}
public async Task <IActionResult> CheckoutExperience(CheckoutExperienceViewModel model)
{
CurrencyValue lightningMaxValue = null;
if (!string.IsNullOrWhiteSpace(model.LightningMaxValue))
{
if (!CurrencyValue.TryParse(model.LightningMaxValue, out lightningMaxValue))
{
ModelState.AddModelError(nameof(model.LightningMaxValue), "Invalid lightning max value");
}
}
CurrencyValue onchainMinValue = null;
if (!string.IsNullOrWhiteSpace(model.OnChainMinValue))
{
if (!CurrencyValue.TryParse(model.OnChainMinValue, out onchainMinValue))
{
ModelState.AddModelError(nameof(model.OnChainMinValue), "Invalid on chain min value");
}
}
bool needUpdate = false;
var blob = CurrentStore.GetStoreBlob();
var defaultPaymentMethodId = model.DefaultPaymentMethod == null ? null : PaymentMethodId.Parse(model.DefaultPaymentMethod);
if (CurrentStore.GetDefaultPaymentId(_NetworkProvider) != defaultPaymentMethodId)
{
needUpdate = true;
CurrentStore.SetDefaultPaymentId(defaultPaymentMethodId);
}
SetCryptoCurrencies(model, CurrentStore);
model.SetLanguages(_LangService, model.DefaultLang);
if (!ModelState.IsValid)
{
return(View(model));
}
blob.CustomLogo = model.CustomLogo;
blob.CustomCSS = model.CustomCSS;
blob.HtmlTitle = string.IsNullOrWhiteSpace(model.HtmlTitle) ? null : model.HtmlTitle;
blob.DefaultLang = model.DefaultLang;
blob.RequiresRefundEmail = model.RequiresRefundEmail;
blob.ShowRecommendedFee = model.ShowRecommendedFee;
blob.RecommendedFeeBlockTarget = model.RecommendedFeeBlockTarget;
blob.OnChainMinValue = onchainMinValue;
blob.LightningMaxValue = lightningMaxValue;
blob.LightningAmountInSatoshi = model.LightningAmountInSatoshi;
blob.RedirectAutomatically = model.RedirectAutomatically;
if (CurrentStore.SetStoreBlob(blob))
{
needUpdate = true;
}
if (needUpdate)
{
await _Repo.UpdateStore(CurrentStore);
TempData[WellKnownTempData.SuccessMessage] = "Store successfully updated";
}
return(RedirectToAction(nameof(CheckoutExperience), new
{
storeId = CurrentStore.Id
}));
}
public CurrencyValue Convert(CurrencyValue from, CurrencySymbol to) =>
new CurrencyValue
{
Symbol = to,
Amount = from.Amount * _conversionTable[(int)from.Symbol, (int)to]
};
public async Task <IActionResult> CheckoutAppearance(CheckoutAppearanceViewModel model)
{
bool needUpdate = false;
var blob = CurrentStore.GetStoreBlob();
var defaultPaymentMethodId = model.DefaultPaymentMethod == null ? null : PaymentMethodId.Parse(model.DefaultPaymentMethod);
if (CurrentStore.GetDefaultPaymentId() != defaultPaymentMethodId)
{
needUpdate = true;
CurrentStore.SetDefaultPaymentId(defaultPaymentMethodId);
}
SetCryptoCurrencies(model, CurrentStore);
model.SetLanguages(_LangService, model.DefaultLang);
model.PaymentMethodCriteria ??= new List <PaymentMethodCriteriaViewModel>();
for (var index = 0; index < model.PaymentMethodCriteria.Count; index++)
{
var methodCriterion = model.PaymentMethodCriteria[index];
if (!string.IsNullOrWhiteSpace(methodCriterion.Value))
{
if (!CurrencyValue.TryParse(methodCriterion.Value, out var value))
{
model.AddModelError(viewModel => viewModel.PaymentMethodCriteria[index].Value,
$"{methodCriterion.PaymentMethod}: Invalid format. Make sure to enter a valid amount and currency code. Examples: '5 USD', '0.001 BTC'", this);
}
}
}
if (!ModelState.IsValid)
{
return(View(model));
}
// Payment criteria for Off-Chain should also affect LNUrl
foreach (var newCriteria in model.PaymentMethodCriteria.ToList())
{
var paymentMethodId = PaymentMethodId.Parse(newCriteria.PaymentMethod);
if (paymentMethodId.PaymentType == PaymentTypes.LightningLike)
{
model.PaymentMethodCriteria.Add(new PaymentMethodCriteriaViewModel()
{
PaymentMethod = new PaymentMethodId(paymentMethodId.CryptoCode, PaymentTypes.LNURLPay).ToString(),
Type = newCriteria.Type,
Value = newCriteria.Value
});
}
// Should not be able to set LNUrlPay criteria directly in UI
if (paymentMethodId.PaymentType == PaymentTypes.LNURLPay)
{
model.PaymentMethodCriteria.Remove(newCriteria);
}
}
blob.PaymentMethodCriteria ??= new List <PaymentMethodCriteria>();
foreach (var newCriteria in model.PaymentMethodCriteria)
{
var paymentMethodId = PaymentMethodId.Parse(newCriteria.PaymentMethod);
var existingCriteria = blob.PaymentMethodCriteria.FirstOrDefault(c => c.PaymentMethod == paymentMethodId);
if (existingCriteria != null)
{
blob.PaymentMethodCriteria.Remove(existingCriteria);
}
CurrencyValue.TryParse(newCriteria.Value, out var cv);
blob.PaymentMethodCriteria.Add(new PaymentMethodCriteria()
{
Above = newCriteria.Type == PaymentMethodCriteriaViewModel.CriteriaType.GreaterThan,
Value = cv,
PaymentMethod = paymentMethodId
});
}
blob.RequiresRefundEmail = model.RequiresRefundEmail;
blob.LazyPaymentMethods = model.LazyPaymentMethods;
blob.RedirectAutomatically = model.RedirectAutomatically;
blob.CustomLogo = model.CustomLogo;
blob.CustomCSS = model.CustomCSS;
blob.HtmlTitle = string.IsNullOrWhiteSpace(model.HtmlTitle) ? null : model.HtmlTitle;
blob.AutoDetectLanguage = model.AutoDetectLanguage;
blob.DefaultLang = model.DefaultLang;
if (CurrentStore.SetStoreBlob(blob))
{
needUpdate = true;
}
if (needUpdate)
{
await _Repo.UpdateStore(CurrentStore);
TempData[WellKnownTempData.SuccessMessage] = "Store successfully updated";
}
return(RedirectToAction(nameof(CheckoutAppearance), new
{
storeId = CurrentStore.Id
}));
}