public CurrencyRates GetCurrencyRate()
{
//RefreshRates();
CurrencyRates cr = new CurrencyRates {
rates = new Dictionary <string, double>()
};
using (var httpClient = new HttpClient())
{
try
{
var response = httpClient
//.GetAsync("http://api.exchangeratesapi.io/latest?access_key=1321df5586167c5aef4b48e9a5f48100") MM
.GetAsync("http://api.exchangeratesapi.io/latest?access_key=e679628e9639d0e7a2978ae3c8334092") // ZZ
//.GetAsync("http://api.exchangeratesapi.io/latest?access_key=9af4380e30dc86fcdf244b7ee3b178d9") // Mr
//.GetAsync("http://api.exchangeratesapi.io/latest?access_key=14c3532a0167f03217b77741623e63af") // DJ
.Result;
var a = response.Content.ReadAsStringAsync().Result;
cr = Newtonsoft.Json.JsonConvert.DeserializeObject <CurrencyRates>(a);
cr.date = _dateService.DateTimeToString(DateTime.Today);
}
catch (Exception ex)
{
// logovati sve ovakve stvari
Log.Information(ex, "CATHED ERROR: External service not responding!");
}
}
return(cr);
}
private async void PrepareDataAsync()
{
IsDataLoading = true;
Currency currency = null;
try
{
currency = await _initializationFacade.GetData();
}
catch (Exception ex)
{
PopError(ex.Message);
}
if (currency == null)
{
IsDataLoading = false;
return;
}
foreach (var item in currency.Rates)
{
CurrencyRates.Add(new Rate
{
CurrencyName = item.Key,
CurrencyRate = item.Value
});
}
CentralDate = currency.Date.ToString();
IsDataLoading = false;
}
private void Save()
{
try
{
var currencyRates = new CurrencyRates
{
Rates = CurrencyRates.ToDictionary(x => x.Currency, x => x.Rate)
};
var currencyRatesData = Serialize(currencyRates);
var currencyRatesInfo = new CurrencyRatesInfo
{
Data = currencyRatesData,
Sign = CreateSign(currencyRatesData)
};
var currencyRatesInfoData = Serialize(currencyRatesInfo);
var currencyRatesInfoDataBase64 = Convert.ToBase64String(currencyRatesInfoData);
File.WriteAllText(file, currencyRatesInfoDataBase64);
Clipboard.SetText(currencyRatesInfoDataBase64);
MessageBox.Show($"Data has been saved to {file}", "Done!", MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception e)
{
MessageBox.Show($"Failed to save data to {file}: {e}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public async Task <IActionResult> GetCurrencies([FromBody] CurrencyRatesRequest request, CancellationToken cts)
{
if (request == null)
{
request = new CurrencyRatesRequest("ECB", DateTime.Now);
}
var value = new CurrencyRates();
if (_cache.TryGetValue($"{request.bankCode}_{request.date.ToShortDateString()}", out value))
{
return(Ok(value));
}
var parser = SelectParser(request.bankCode);
var res = await parser.GetCurrencyRatesAsync(request.date, cts);
if (res.IsOk)
{
_cache.Set($"{request.bankCode}_{request.date.ToShortDateString()}",
res.Ok,
new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(2)));
}
return(res.Match <IActionResult>(
currencies => Ok(currencies),
error => BadRequest(error)));
}
public CurrencyRates GetAvarageRates()
{
CurrencyRates output = new CurrencyRates();
foreach (var bank in Banks)
{
CurrencyRates rates = bank.Value.CurrencyRates;
foreach (PropertyInfo property in rates.GetType().GetProperties())
{
if (property.PropertyType.Equals(typeof(Currency)))
{
Currency value = (Currency)property.GetValue(rates);
Currency currentValue = (Currency)property.GetValue(output);
if (currentValue != null)
{
Currency newValue = new Currency();
newValue.Purchase = (currentValue.Purchase + value.Purchase) / 2;
newValue.Sell = (currentValue.Sell + value.Sell) / 2;
property.SetValue(output, newValue);
}
else
{
property.SetValue(output, value);
}
}
}
}
return(output);
}
List <CurrencyRates> getCurrencyDataFromSqlServer()
{
StringBuilder sb = new StringBuilder();
List <CurrencyRates> ratesList = new List <CurrencyRates>();
string connectionString = ConfigurationManager.ConnectionStrings["localDb"].ConnectionString;
using (SqlConnection connection = new SqlConnection(connectionString))
using (SqlCommand cmd = new SqlCommand("SELECT * FROM rates", connection))
{
connection.Open();
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
CurrencyRates rates = new CurrencyRates();
rates.date = DateTime.Parse(reader["date"].ToString());
rates.usd = Decimal.Parse(reader["usd"].ToString());
rates.gbp = Decimal.Parse(reader["gbp"].ToString());
ratesList.Add(rates);
}
}
}
}
return(ratesList);
}
public void ExchangeRateForm_Load(object sender, EventArgs e)
{
try
{
var firstList = new CurrencyRates().GetExchangeRates();
var secondList = new CurrencyRates().GetExchangeRates();
foreach (var item in firstList)
{
textBox1.AppendText(item.GetString() + "\n");
}
firstList.Insert(0, new CurrencyRate()
{
CurrencyName = "гривня",
CurrencyStringCode = "UAH",
ExchangeRate = 100
});
secondList.Insert(0, new CurrencyRate()
{
CurrencyName = "гривня",
CurrencyStringCode = "UAH",
ExchangeRate = 100
});
firstCurrencyBox.DataSource = firstList;
secondCurrencyBox.DataSource = secondList;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public static async void Go(Customer customer)
{
await Bot.SendTextMessageAsync(customer.ChatId, CurrencyRates.ShowCurrencyRates());
LogService.PrintLogText($"{customer.FirstName} {customer.LastName}", "checked currency rates");
ActiveCustomersCollection.Remove(customer.ChatId);
}
public double ConvertXToPLN(double amount, string codeA)
{
RestRequest request = new RestRequest($"exchangerates/rates/a/{codeA}", Method.GET);
CurrencyRates rateA = Client.Execute <CurrencyRates>(request).Data;
double result = amount * rateA.Rates.First().Mid;
return(result);
}
static void Main(string[] args)
{
try {
CurrencyRates rates = getEcbCurrencyData();
writeRatesInDB(rates);
}
catch (Exception ex)
{
writeErrorLog(ex.ToString() + "; in " + ex.StackTrace);
}
}
public async Task <IActionResult> Create([Bind("Id,CurrecyScale,CurrencyRate,DateRate,CurrencyId,BaseCurrencyId")] CurrencyRates currencyRates)
{
if (ModelState.IsValid)
{
await _currencyRatesService.AddAsync(currencyRates);
return(RedirectToAction(nameof(Index)));
}
SetViewData();
return(View(currencyRates));
}
public async Task UpdateBYNVoid()
{
Currency baseCurrency = await _context.Currency.Where(x => x.Code == Constants.BYNCode).SingleOrDefaultAsync();
var currencyList = _context.Currency.Where(x => x.Code != Constants.BYNCode && x.Active);
string jsonCurList = await ServicesCommonFunctions.SendGetRequestAsync(new Uri(Constants.BYN_CURRENCY_LIST_URL));
DataContractJsonSerializer jsonFormatterNBRBCurAr = new DataContractJsonSerializer(typeof(NbrbCur[]));
DataContractJsonSerializer jsonFormatterNBRBRate = new DataContractJsonSerializer(typeof(NbrbRate));
NbrbCur[] curArray = (NbrbCur[])jsonFormatterNBRBCurAr.ReadObject(new MemoryStream(Encoding.UTF8.GetBytes(jsonCurList)));
var addedRates = new List <CurrencyRates>();
foreach (var currency in currencyList)
{
for (var currencyDate = Constants.baseDate; currencyDate <= DateTime.Today; currencyDate = currencyDate.AddDays(1))
{
if (await _context.CurrencyRates.Where(x => x.DateRate == currencyDate && x.Currency.Code == currency.Code).SingleOrDefaultAsync() != null)
{
continue;
}
var curNBRB = curArray.SingleOrDefault(x => x.Cur_Abbreviation == currency.Code &&
DateTime.Parse(x.Cur_DateStart) <= currencyDate &&
DateTime.Parse(x.Cur_DateEnd) >= currencyDate
);
if (curNBRB == null)
{
continue;
}
string urlRate = Constants.BYN_CURRENCY_RATE_URL + curNBRB.Cur_ID + Constants.BYN_ATTR_DATE + currencyDate;
string jsonRate = await ServicesCommonFunctions.SendGetRequestAsync(new Uri(urlRate));
NbrbRate curRate = jsonFormatterNBRBRate.ReadObject(new MemoryStream(Encoding.UTF8.GetBytes(jsonRate))) as NbrbRate;
CurrencyRates currencyRate = new CurrencyRates
{
BaseCurrencyId = baseCurrency.Id,
CurrencyId = currency.Id,
DateRate = currencyDate,
CurrecyScale = curRate.Cur_Scale,
CurrencyRate = (decimal)curRate.Cur_OfficialRate
};
addedRates.Add(currencyRate);
}
}
if (addedRates.Count > 0)
{
await _context.AddRangeAsync(addedRates);
await _context.SaveChangesAsync();
}
}
private void UpdateSummary()
{
var amount = 0m;
if (decimal.TryParse(TbAmount.Text, out var a))
{
amount = a;
}
LblTotalAmount.Text = $"{(string.IsNullOrWhiteSpace(TbAmount.Text) ? "0" : TbAmount.Text)} {_currencyPickerModel.SelectedItem}";
LblAmountNormalized.Text = $" = {amount / CurrencyRates.Convert("USD", _currencyPickerModel.SelectedItem):F2} USD";
LblConversion.Text = $"1 USD = {CurrencyRates.Convert("USD", _currencyPickerModel.SelectedItem)} {_currencyPickerModel.SelectedItem}";
LblDescription.Text = TbDescription.Text;
}
public double Convert(double amount, string codeA, string codeX)
{
//get data
RestRequest request1 = new RestRequest($"exchangerates/rates/a/{codeA}", Method.GET);
CurrencyRates rateA = Client.Execute <CurrencyRates>(request1).Data;
RestRequest request2 = new RestRequest($"exchangerates/rates/a/{codeX}", Method.GET);
CurrencyRates rateX = Client.Execute <CurrencyRates>(request2).Data;
//calc
double rateForCodeAInPLN = rateA.Rates.First().Mid *amount;
double result = rateForCodeAInPLN / rateX.Rates.First().Mid;
return(result);
}
public Double ConvertToUSD(dynamic rateCode, dynamic sourceValue)
{
if (((string)rateCode).ToUpper().Equals("USD"))
{
return(sourceValue);
}
var code = ((string)rateCode).ToUpper();
CurrencyRate rate;
if (!CurrencyRates.TryGetValue(code, out rate))
{
throw new MappingException(String.Format("Currncy code '{0}' could not be found in DB for date {1}.", rateCode, this.Delivery.TimePeriodDefinition.Start.ToDateTime()));
}
return(Convert.ToDouble(rate.RateValue) * Convert.ToDouble(sourceValue));
}
private async void LoadCurrencyRatesAsync()
{
CurrencyRates.Clear();
var newCurrencyRates = await currencyRateRepository.GetCurrencyRates();
if (newCurrencyRates != null)
{
foreach (var code in newCurrencyRates)
{
CurrencyRates.Add(code);
}
SelectedRateFirst = CurrencyRates[0];
SelectedRateSecond = CurrencyRates[1];
}
}
public async Task <IActionResult> Edit(long id, [Bind("Id,CurrecyScale,CurrencyRate,DateRate,CurrencyId,BaseCurrencyId")] CurrencyRates currencyRates)
{
if (id != currencyRates.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
if (!await _currencyRatesService.UpdateAsync(currencyRates))
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
SetViewData();
return(View(currencyRates));
}
private void Window_Loaded_1(object sender, RoutedEventArgs e)
{
//ViewModel2.StartDate = DateTime.Today; //;(DateTime)StartDate.SelectedDate;
//ViewModel2.EndDate = DateTime.Today; // (DateTime)endDate.SelectedDate;
//return;
ViewModel.StartDate = new DateTime(2015, 01, 01);
ViewModel.EndDate = new DateTime(2017, 06, 01);
ViewModel.IsItQuarter = true;
//алешкин код
ViewModel.LiveStreamModel = ProcessesEngine.GetLiveStream(ViewModel.StartDate, ViewModel.EndDate, ViewModel);
ViewModel.InfoModel.CurrencyRateList = CurrencyRates.GetExchangeRates();
ViewModel.InfoModel.StartTimer2();
HeaderControl.DataContext = ViewModel.InfoModel;
LiveStreamControl.DataBind(ViewModel.LiveStreamModel);
}
static void Main(string[] args)
{
string content = string.Empty;
try
{
using (var request = new HttpRequest())
{
request.UserAgent = Http.IEUserAgent();
var urlParams = new RequestParams();
urlParams["date_req"] = DateTime.Now.ToString("dd.MM.yyyy");
content = request.Get("http://www.cbr.ru/currency_base/daily/", urlParams).ToString();
}
if (!string.IsNullOrEmpty(content))
{
var tableHtml = content.ElementById("content").ElementByName("table");
var currencyRatesList = CurrencyRates.HelperByHtmlTabls(tableHtml);
//foreach (var item in currencyRatesList)
// CurrencyRates.AddCource(item);
foreach (var item in currencyRatesList)
{
Console.WriteLine(string.Format("{0,5}|{1,5}|{2,5}|{4,15}|{3,5} {5}",
item.DigitCode, item.LettersCode, item.Units, item.Currency, item.Course, Environment.NewLine));
}
}
else
{
Console.WriteLine("Error in loading website");
}
}
catch (Exception)
{
throw;
}
Console.ReadKey();
}
private async void Update()
{
try
{
UpdateVisibility = Visibility.Visible;
var data = await UpdateRates();
data.Add(new CurrencyRate
{
CurrencyCode = "HUF",
Unit = 1,
ValueInForint = 1
});
CurrencyRates.Clear();
CurrencyRates.AddRange(data.OrderBy(d => d.CurrencyCode));
OnPropertyChanged(() => CurrencyRates);
var types = from rate in CurrencyRates
orderby rate.CurrencyCode ascending
select rate.CurrencyCode;
CurrencyTypes.Clear();
CurrencyTypes.AddRange(types);
OnPropertyChanged(() => CurrencyTypes);
_selectedInputIndex = CurrencyTypes.IndexOf("EUR");
_selectedOutputIndex = CurrencyTypes.IndexOf("HUF");
OnPropertyChanged(() => SelectedInputIndex);
OnPropertyChanged(() => SelectedOutputIndex);
LastUpdate = DateTime.Now;
Input = 1;
UpdateVisibility = Visibility.Collapsed;
}
catch (Exception ex)
{
LastUpdate = DateTime.Now;
CurrencyRates.Clear();
CurrencyTypes.Clear();
_app.Log.Exception(ex);
await _app.ShowMessageBox("Error", "Error calling webservice", DialogButtons.Ok);
UpdateVisibility = Visibility.Collapsed;
}
}
private void SearchRates()
{
if (!String.IsNullOrWhiteSpace(search))
{
var searchResults = CurrencyRates.Where(
r => r.Id == search ||
r.NumCode == search ||
r.CharCode == search ||
r.Name.ToLower()
.Contains(search.ToLower())
);
SearchResults.Clear();
foreach (var item in searchResults)
{
SearchResult result = new SearchResult(item);
var style = NumberStyles.AllowDecimalPoint;
var culture = CultureInfo.CreateSpecificCulture("ru-RU");
if (Decimal.TryParse(result.Value, style,
culture, out decimal resultCurs))
{
var dollar = CurrencyRates.FirstOrDefault(
r => r.Id == "R01235"
);
if (dollar != null && Decimal.TryParse(dollar.Value, style,
culture, out decimal dollarCurs))
{
resultCurs /= result.Nominal;
dollarCurs /= dollar.Nominal;
result.RateToDollar = Math.Round(
(resultCurs / dollarCurs), 4
).ToString();
}
}
SearchResults.Add(result);
}
}
}
private static CurrencyRates getEcbCurrencyData()
{
string ecbUrl = "https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml";
HttpClient client = new HttpClient();
//client.BaseAddress = new Uri(ecbUrl);
HttpResponseMessage response = client.GetAsync(ecbUrl).Result;
if (response.IsSuccessStatusCode)
{
string resultAsString = response.Content.ReadAsStringAsync().Result;
var xml = XDocument.Parse(resultAsString);
XAttribute date = (from elem in xml.Root.Descendants()
where elem.Attribute("time") != null
select elem.Attribute("time")).FirstOrDefault();
XAttribute usd = (from elem in xml.Root.Descendants()
where elem.Attribute("currency") != null && elem.Attribute("currency").Value == "USD"
select elem.Attribute("rate")).FirstOrDefault();
XAttribute GBP = (from elem in xml.Root.Descendants()
where elem.Attribute("currency") != null && elem.Attribute("currency").Value == "GBP"
select elem.Attribute("rate")).FirstOrDefault();
CurrencyRates rates = new CurrencyRates();
rates.date = DateTime.Parse(date.Value);
rates.usd = Decimal.Parse(usd.Value);
rates.gbp = Decimal.Parse(GBP.Value);
return(rates);
}
else
{
throw new Exception("Http client exception. Status code: " + response.StatusCode);
}
}
public double Get([FromQuery] string from, [FromQuery] string to)
{
if (string.IsNullOrEmpty(from) || string.IsNullOrEmpty(to))
{
throw new Exception("From Currency & To Currency are required. E.g. api/ExchangeRates?from=GBP&to=EUR");
}
if (from.ToLower() == to.ToLower())
{
return(1);
}
var currencyRate = new CurrencyRates("USD");
if (currencyRate.Rates.ContainsKey(from) && currencyRate.Rates.ContainsKey(to) &&
currencyRate.Rates[from] != 0)
{
return(Math.Round(currencyRate.Rates[to] / currencyRate.Rates[from], 2));
}
return(0);
}
public List <CurrencyRates> ConvertDBToEntity(DataSet dataEntity)
{
List <CurrencyRates> entities = null;
if (dataEntity != null && dataEntity.Tables.Count > 0)
{
entities = new List <CurrencyRates>();
foreach (DataRow row in dataEntity.Tables[0].Rows)
{
CurrencyRates newRate = new CurrencyRates();
newRate.BaseCurrency = (EnumCurrencyList)Enum.Parse(typeof(EnumCurrencyList), row["BaseCurrency"].ToString());
newRate.TargetCurrency = (EnumCurrencyList)Enum.Parse(typeof(EnumCurrencyList), row["TargetCurrency"].ToString());
newRate.ConversionRate = (double)row["ConversionRate"];
newRate.Timestamp = (DateTime)row["Timestamp"];
entities.Add(newRate);
}
}
return(entities);
}
private static void writeRatesInDB(CurrencyRates rates)
{
string connectionString = ConfigurationManager.ConnectionStrings["localDb"].ConnectionString;
string commandText = "insert into rates(date, usd, gbp) values (@date,@usd,@gbp)";
using (SqlConnection con = new SqlConnection(connectionString))
using (SqlCommand command = new SqlCommand(commandText, con))
{
con.Open();
command.Parameters.Add(new SqlParameter("@date", SqlDbType.Date)
{
Value = rates.date.ToShortDateString()
});
command.Parameters.Add(new SqlParameter("@usd", SqlDbType.Decimal)
{
Value = rates.usd
});
command.Parameters.Add(new SqlParameter("@gbp", SqlDbType.Decimal)
{
Value = rates.gbp
});
command.ExecuteNonQuery();
}
}
public void SaveExpense(string amount, string currency, string category, string description)
{
var valuesArr = new List <string>
{
DateTime.Now.Date.ToString("yyyy-M-dd"),
amount,
currency,
CurrencyRates.Convert("USD", currency).ToString(CultureInfo.InvariantCulture)
};
// TODO: move to constant and then to settings.
var last = _googleSheetsClient.GetFirstEmptyCell("Transactions!B4:B500");
var firstPart = last;
var secondPart = new GSheetRange(last.TableName, "G" + last.RangeStart.YNumber, null);
_googleSheetsClient.WriteRows(firstPart.ToString(), valuesArr);
valuesArr.Clear();
valuesArr.Add(description);
valuesArr.Add(category);
_googleSheetsClient.WriteRows(secondPart.ToString(), valuesArr);
}
public int Save(CurrencyRates Data)
{
TopContractsV01Entities context = new TopContractsV01Entities(Utilities.getTestEnvName());
TopContractsEntities.CurrencyConversionRate efCurrency = null;
foreach (TopContractsDAL10.SystemTables.CurrencyRate Currency in Data.Entries)
{
if (Currency.New)
{
efCurrency = new TopContractsEntities.CurrencyConversionRate();
}
else
{
efCurrency = context.CurrencyConversionRates.Where(c => c.CurrencyConversionRatesID == Currency.ID).SingleOrDefault();
}
if (Currency.Deleted == false)
{
efCurrency.OrganizationIdentifier = this.organizationIdentifier;
efCurrency.CurrencyID = Currency.CurrencyID;
efCurrency.Rate = Currency.Rate;
efCurrency.RateDate = Convert.ToDateTime(Currency.RateDate);
efCurrency.DateCreated = DateTime.Now;
}
if (Currency.New)
{
context.CurrencyConversionRates.Add(efCurrency);
}
else
{
if (Currency.Deleted && efCurrency != null)
{
context.CurrencyConversionRates.Remove(efCurrency);
}
}
}
return context.SaveChanges();
}
public CurrencyRates GetExchangeRates(Currency baseCurrency, Currency rateCurrency, DateTime start, DateTime end)
{
if (!_context.Database.CanConnect())
{
throw new Exception("Can not connect to database");
}
var exchangeRates = new CurrencyRates
{
DataSource = DataSource.Database,
BaseCurrency = baseCurrency.ToString(),
RateCurrency = rateCurrency.ToString()
};
if (baseCurrency == Currency.USD && rateCurrency == Currency.AUD)
{
exchangeRates.Rates = new List <ValueDate>(
_context.USD_AUD.Where(c => c.Date >= start && c.Date <= end));
}
else if (baseCurrency == Currency.AUD && rateCurrency == Currency.USD)
{
var AUD_USD = _context.USD_AUD
.Where(c => c.Date >= start && c.Date <= end)
.ToList();
AUD_USD.ForEach(e => e.Value = 1 / e.Value);
exchangeRates.Rates = new List <ValueDate>(AUD_USD);
}
else if (baseCurrency == Currency.USD && rateCurrency == Currency.EUR)
{
exchangeRates.Rates = new List <ValueDate>(_context.USD_EUR
.Where(c => c.Date >= start && c.Date <= end));
}
else if (baseCurrency == Currency.EUR && rateCurrency == Currency.USD)
{
var EUR_USD = _context.USD_EUR
.Where(c => c.Date >= start && c.Date <= end)
.ToList();
EUR_USD.ForEach(e => e.Value = 1 / e.Value);
exchangeRates.Rates = new List <ValueDate>(EUR_USD);
}
else if (baseCurrency == Currency.EUR && rateCurrency == Currency.AUD)
{
exchangeRates.Rates = new List <ValueDate>(_context.EUR_AUD
.Where(c => c.Date >= start && c.Date <= end));
}
else if (baseCurrency == Currency.AUD && rateCurrency == Currency.EUR)
{
var AUD_EUR = _context.EUR_AUD
.Where(c => c.Date >= start && c.Date <= end)
.ToList();
AUD_EUR.ForEach(e => e.Value = 1 / e.Value);
exchangeRates.Rates = new List <ValueDate>(AUD_EUR);
}
return(exchangeRates);
}
public IActionResult Index()
{
CurrencyRates cr = _currencyRateService.GetCurrencyRate();
return(View(cr));
}
private void SaveCurrencies(object sender, RoutedEventArgs e)
{
CheckBox[] checkBoxArray = { AUD, CAD, CHF, CNY, EUR, GBP, JPY, MXN, NZD, RUB, SEK, USD };
LinkedList <string> selectedCurrencies = new LinkedList <string> {
};
string currency;
Thread newWindowThread = new Thread(new ThreadStart(ThreadStartingPoint));
newWindowThread.SetApartmentState(ApartmentState.STA);
newWindowThread.IsBackground = true;
newWindowThread.Start();
Thread.Sleep(1000);
for (int i = 0; i < checkBoxArray.Length; i++)
{
if (checkBoxArray[i].IsChecked == true)
{
currency = checkBoxArray[i].Content.ToString();
selectedCurrencies.AddLast(currency);
}
}
CurrencyRates currentRates = new CurrencyRates();
float[,] FW_Array = new float[selectedCurrencies.Count(), selectedCurrencies.Count()];
FW_Array = currentRates.GetCurrencyRates(selectedCurrencies); // This array Contains the magic
string test1 = "";
for (int i = 0; i < selectedCurrencies.Count; i++)
{
for (int j = 0; j < selectedCurrencies.Count; j++)
{
test1 += "\t" + FW_Array[i, j].ToString() + "\t";
}
test1 += "\n";
}
TestBox.Text = test1.ToString();
Loading.Visibility = Visibility.Visible;
newWindowThread.Abort();
double[,] Algoarray = new double[selectedCurrencies.Count(), selectedCurrencies.Count()];
for (int i = 0; i < selectedCurrencies.Count; i++)
{
for (int j = 0; j < selectedCurrencies.Count; j++)
{
Algoarray[i, j] = FW_Array[i, j];
}
}
String Result = "";
FW algo = new FW(Algoarray, selectedCurrencies.Count);
Double maxp = 0.01;
int maxt = selectedCurrencies.Count;
if (optionsCheck.IsChecked.HasValue && optionsCheck.IsChecked.Value)
{
Double.TryParse(profitTextbox.Text, out maxp);
int.TryParse(TransTextbox.Text, out maxt);
}
Result += (maxp + " " + maxt + "\n");
//This part is what appends the returned result to the textbox. You can just store Returnproft to a string and pass that string to a new window
String[] checkarray = { "AUD", "CAD", "CHF", "CNY", "EUR", "GBP", "JPY", "MXN", "NZD", "RUB", "SEK", "USD" };
Result += algo.ReturnProft(maxp, maxt, checkarray);
MessageBox.Show(Result); //display current resulting path on screen
}
public void AddCurrencyConversion(Currency fromCountry, double value)
{
CurrencyRates.Add(fromCountry, value);
}
