public double GetConversionRate(string from, string to)
{
double conversion = 0;
var baseAddress = new Uri("https://min-api.cryptocompare.com/data/price?fsym=" + from + "&tsyms=" + to);
using (var wb = new WebClient())
{
var response = wb.DownloadString(baseAddress);
var jsonData = JObject.Parse(response);
foreach (var item in jsonData)
{
if (item.Key != to)
{
continue;
}
foreach (var items in jsonData)
{
var itemValueResult = items.Value.ToString();
ConversionRate conversionRate = new ConversionRate();
conversionRate.ConversionRateValue = Convert.ToDouble(itemValueResult);
conversion = conversionRate.ConversionRateValue;
}
}
return(conversion);
}
}
public async Task <IActionResult> PutConversionRate([FromRoute] int id, [FromBody] ConversionRate conversionRate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != conversionRate.conversionID)
{
return(BadRequest());
}
_context.Entry(conversionRate).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConversionRateExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private static void GetConversion()
{
try
{
RequestMap map = new RequestMap();
map.Set("fxDate", "2019-03-22");
map.Set("transCurr", "USD");
map.Set("crdhldBillCurr", "BRL");
map.Set("bankFee", "0");
map.Set("transAmt", "10");
ConversionRate response = ConversionRate.Query(map);
Out(response, "name"); //-->settlement-conversion-rate
Out(response, "description"); //-->Settlement conversion rate and billing amount
Out(response, "date"); //-->2017-11-03 03:59:50
Out(response, "data.conversionRate"); //-->0.57
Out(response, "data.crdhldBillAmt"); //-->13.11
Out(response, "data.fxDate"); //-->2016-09-30
Out(response, "data.transCurr"); //-->ALL
Out(response, "data.crdhldBillCurr"); //-->DZD
Out(response, "data.transAmt"); //-->23
Out(response, "data.bankFee"); //-->5
Console.ReadKey();
}
catch (ApiException e)
{
Err("HttpStatus: {0}", e.HttpStatus.ToString());
Err("Message: {0}", e.Message);
Err("ReasonCode: {0}", e.ReasonCode);
Err("Source: {0}", e.Source);
Console.ReadKey();
}
}
/// <inheritdoc/>
public override string ModelSummary()
{
using (StringWriter htmlWriter = new StringWriter())
{
htmlWriter.Write("\r\n<div class=\"activityentry\">Process ");
htmlWriter.Write(CLEMModel.DisplaySummaryValueSnippet(ResourceTypeProcessedName, "Resource not set", HTMLSummaryStyle.Resource));
htmlWriter.Write(" into ");
htmlWriter.Write(CLEMModel.DisplaySummaryValueSnippet(ResourceTypeCreatedName, "Resource not set", HTMLSummaryStyle.Resource));
htmlWriter.Write(" at a rate of ");
if (ConversionRate <= 0)
{
htmlWriter.Write("<span class=\"errorlink\">[RATE NOT SET]</span>");
}
else
{
htmlWriter.Write("1:<span class=\"resourcelink\">" + ConversionRate.ToString("0.###") + "</span>");
}
htmlWriter.Write("</div>");
if (Reserve > 0)
{
htmlWriter.Write("\r\n<div class=\"activityentry\">");
htmlWriter.Write("<span class=\"setvalue\">" + Reserve.ToString("0.###") + "</span> will be reserved.");
htmlWriter.Write("</div>");
}
return(htmlWriter.ToString());
}
}
/// <summary>
/// Open driver
/// </summary>
/// <param name="conversionRate">Conversion rate</param>
/// <param name="shutdownMode">Shutdown mode</param>
/// <param name="thermostatMode">Thermostat mode</param>
/// <param name="alertPolarity">Polarity of the alert pin</param>
/// <param name="consecutiveFaults">Consecutive faults before activate alert pin</param>
/// <param name="temperatureHigh">Temperature High for alert</param>
/// <param name="temperatureLow">Temperature Low for alert</param>
/// <param name="alertPin">Alert pin</param>
/// <param name="i2cSelector">I2C selector string</param>
/// <returns>Driver opened</returns>
public async Task<bool> OpenAsync(
ConversionRate conversionRate = ConversionRate._4Hz,
bool shutdownMode = false,
ThermostatMode thermostatMode = ThermostatMode.Comparator,
AlertPolarity alertPolarity = AlertPolarity.ActiveLow,
ConsecutiveFaults consecutiveFaults = ConsecutiveFaults._1,
float temperatureHigh = TEMP_HIGH_DEFAULT,
float temperatureLow = TEMP_LOW_DEFAULT,
int alertPin = 0,
string i2cSelector = PI2_I2C_SELECTOR)
{
try
{
string advancedQuerySyntax = I2cDevice.GetDeviceSelector(i2cSelector);
DeviceInformationCollection device_information_collection = await DeviceInformation.FindAllAsync(advancedQuerySyntax);
string deviceId = device_information_collection[0].Id;
this.i2c = await I2cDevice.FromIdAsync(deviceId, this.i2cConfig);
// load configuration register
this.LoadConfiguration();
// set conversion rate
this.configuration = (ushort)(this.configuration & ~CONV_RATE_MASK);
this.configuration |= (ushort)conversionRate;
// set shutdown mode
this.configuration = (shutdownMode) ? (ushort)(this.configuration | SHUTDOWN_MODE) : (ushort)(this.configuration & ~SHUTDOWN_MODE);
// set thermostat mode
this.configuration = (thermostatMode == ThermostatMode.Interrupt) ? (ushort)(this.configuration | THERMOSTAT_MODE) : (ushort)(this.configuration & ~THERMOSTAT_MODE);
// set alert pin polarity
this.configuration = (alertPolarity == AlertPolarity.ActiveHigh) ? (ushort)(this.configuration | POLARITY) : (ushort)(this.configuration & ~POLARITY);
// set consecutive faults for alert
this.configuration = (ushort)(this.configuration & ~FAULT_QUEUE_MASK);
this.configuration |= (ushort)consecutiveFaults;
// save configuration register
this.ChangeConfiguration();
// set temperature high for alert
this.regAddress[0] = TEMP_HIGH_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureHigh);
this.WriteRegister(this.regAddress, this.regData);
// set temperature low for alert
this.regAddress[0] = TEMP_LOW_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureLow);
this.WriteRegister(this.regAddress, this.regData);
if (alertPin != 0)
{
GpioController gpioController = GpioController.GetDefault();
this.alertPin = gpioController.OpenPin(alertPin);
this.alertPin.ValueChanged += AlertPin_ValueChanged;
}
return true;
}
catch (Exception ex)
{
return false;
}
}
private static void CompleteConversion(ConversionRate conversionRate)
{
Console.WriteLine(conversionRate.InputCurrency + " to " + conversionRate.OutputCurrency + " selected.");
Console.WriteLine("Please enter the amount of " + conversionRate.InputCurrency + " you want to convert.");
string inputString = Console.ReadLine();
decimal input = 0;
if (!decimal.TryParse(inputString, out input))
{
Console.WriteLine("Please enter a valid number.");
CompleteConversion(conversionRate);
}
if (input < 0 || input > 1000000)
{
Console.WriteLine("Please enter a valid number greater than 0 and less than 1,000,000");
CompleteConversion(conversionRate);
}
var output = Math.Round(conversionRate.CompleteConversion(input), 2);
conversions.Add(new Conversion()
{
Time = DateTime.UtcNow, Input = input, Output = output, InputCurrency = conversionRate.InputCurrency, OutputCurrency = conversionRate.OutputCurrency, Rate = conversionRate.Rate
});
Console.WriteLine(inputString + " in " + conversionRate.InputCurrency + " is " + output.ToString() + " in " + conversionRate.OutputCurrency + ".");
SelectConversion();
}
public ActionResult DeleteConfirmed(int id)
{
ConversionRate conversionrate = db.ConversionRates.Find(id);
db.ConversionRates.Remove(conversionrate);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task TradeCurrency(double amount, string cur1, string cur2)
{
if (amount <= 0)
{
await Context.Channel.SendMessageAsync("You can't exchange an invalid amount good try :^)");
return;
}
EntityUser eu = _userRepo.GetByID(Context.User.Id);
if (eu == null)
{
await ErrorUserDoesntExistInSystem();
return;
}
string[] names = Enum.GetNames(typeof(CurrencyEnum));
var curToTrade = names.SingleOrDefault(n => n.ToLower().StartsWith(cur1.ToLower()));
var curConvert = names.SingleOrDefault(n => n.ToLower().StartsWith(cur2.ToLower()));
if (curToTrade == null || curConvert == null)
{
var em = await CurrencyEmbedBuilder.MakeCurrencyError(names, Context);
await Context.Channel.SendMessageAsync(embed : em.Build());
return;
}
CurrencyEnum curr1 = (CurrencyEnum)Enum.Parse(typeof(CurrencyEnum), curToTrade);
if (eu.GetCurrencyAmount(curr1) < amount)
{
await Context.Channel.SendMessageAsync($"You're {amount - Math.Round(eu.GetCurrencyAmount(curr1), 2)}"
+ $" {curr1} short for that exchange.");
return;
}
CurrencyEnum curr2 = (CurrencyEnum)Enum.Parse(typeof(CurrencyEnum), curConvert);
ConversionRate cr1 = (ConversionRate)Enum.Parse(typeof(ConversionRate), $"{curToTrade}To{curConvert}");
ConversionRate cr2 = (ConversionRate)Enum.Parse(typeof(ConversionRate), $"{curConvert}To{curToTrade}");
var rate = (((double)(int)cr2) / ((double)(int)cr1));
var addAmount = rate * amount;
eu.RemoveAmount(curr1, amount);
eu.AddAmount(curr2, addAmount);
_userRepo.SaveChanges();
var embed = await CurrencyEmbedBuilder.MakeTradeEmbed(addAmount, amount, Context, curr2, curr1);
await Context.Channel.SendMessageAsync(embed : embed.Build());
}
//
// GET: /ConversionRate/Details/5
public ActionResult Details(int id = 0)
{
ConversionRate conversionrate = db.ConversionRates.Find(id);
if (conversionrate == null)
{
return(HttpNotFound());
}
return(View(conversionrate));
}
public ActionResult Edit(ConversionRate conversionrate)
{
if (ModelState.IsValid)
{
db.Entry(conversionrate).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CurrencyID = new SelectList(db.Currencies, "ID", "FullDescription", conversionrate.CurrencyID);
return(View(conversionrate));
}
public Task <int> SaveItemAsync(ConversionRate item)
{
if (item.ID != 0)
{
return(Database.UpdateAsync(item));
}
else
{
return(Database.InsertAsync(item));
}
}
//
// GET: /ConversionRate/Edit/5
public ActionResult Edit(int id = 0)
{
ConversionRate conversionrate = db.ConversionRates.Find(id);
if (conversionrate == null)
{
return(HttpNotFound());
}
ViewBag.CurrencyID = new SelectList(db.Currencies, "ID", "FullDescription", conversionrate.CurrencyID);
return(View(conversionrate));
}
public async Task <IActionResult> PostConversionRate([FromBody] ConversionRate conversionRate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.ConversionRate.Add(conversionRate);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetConversionRate", new { id = conversionRate.conversionID }, conversionRate));
}
public ActionResult Create(ConversionRate conversionrate)
{
if (ModelState.IsValid)
{
db.ConversionRates.Add(conversionrate);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CurrencyID = new SelectList(db.Currencies, "ID", "FullDescription", conversionrate.CurrencyID);
return(View(conversionrate));
}
private void CalculateValue(ProductPriceData productPrice, string currency,
List <ConversionRate> conversionRates)
{
Value = Quantity * productPrice.Price;
if (currency == "EUR")
{
ValueInEUR = Quantity * productPrice.Price;
}
else
{
ConversionRate conversionRate =
conversionRates.Single(x => x.SourceCurrency == currency && x.TargetCurrency == "EUR");
ValueInEUR = conversionRate.Convert(Value);
}
}
public ConversionRateTest()
{
var faker = new Faker();
rateDto = new RateDto
{
ValueOrigin = faker.Random.Double(1, 10000),
CurrencyOrigin = "USD",
CurrencyDestination = "BRL",
FormatMsg = faker.Random.Int(0, 1).ToString(),
ApiKey = faker.Random.Hash().ToString()
};
rateServiceMock = new Mock <IRateService>();
conversionRate = new ConversionRate(rateServiceMock.Object);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="a0addrSelect">A0 pin connection for address selection</param>
/// <param name="clockRateKhz">I2C clock rate in KHz</param>
/// <param name="conversionRate">Conversion rate</param>
/// <param name="shutdownMode">Shutdown mode</param>
/// <param name="thermostatMode">Thermostat mode</param>
/// <param name="alertPolarity">Polarity of the alert pin</param>
/// <param name="consecutiveFaults">Consecutive faults before activate alert pin</param>
/// <param name="temperatureHigh">Temperature High for alert</param>
/// <param name="temperatureLow">Temperature Low for alert</param>
public TMP102(A0AddressSelect a0addrSelect = A0AddressSelect.GND,
int clockRateKhz = CLOCK_RATE_KHZ_DEFAULT,
ConversionRate conversionRate = ConversionRate._4Hz,
bool shutdownMode = false,
ThermostatMode thermostatMode = ThermostatMode.Comparator,
AlertPolarity alertPolarity = AlertPolarity.ActiveLow,
ConsecutiveFaults consecutiveFaults = ConsecutiveFaults._1,
float temperatureHigh = TEMP_HIGH_DEFAULT,
float temperatureLow = TEMP_LOW_DEFAULT)
{
// create buffers for one and two bytes for I2C communications
this.regAddress = new byte[REG_ADDRESS_SIZE];
this.regData = new byte[REG_DATA_SIZE];
// configure and create I2C reference device
I2CDevice.Configuration i2cConfig = new I2CDevice.Configuration((ushort)(TMP102_ADDRESS_BASE + a0addrSelect), clockRateKhz);
this.i2c = new I2CDevice(i2cConfig);
// load configuration register
this.LoadConfiguration();
// set conversion rate
this.configuration = (ushort)(this.configuration & ~CONV_RATE_MASK);
this.configuration |= (ushort)conversionRate;
// set shutdown mode
this.configuration = (shutdownMode) ? (ushort)(this.configuration | SHUTDOWN_MODE) : (ushort)(this.configuration & ~SHUTDOWN_MODE);
// set thermostat mode
this.configuration = (thermostatMode == ThermostatMode.Interrupt) ? (ushort)(this.configuration | THERMOSTAT_MODE) : (ushort)(this.configuration & ~THERMOSTAT_MODE);
// set alert pin polarity
this.configuration = (alertPolarity == AlertPolarity.ActiveHigh) ? (ushort)(this.configuration | POLARITY) : (ushort)(this.configuration & ~POLARITY);
// set consecutive faults for alert
this.configuration = (ushort)(this.configuration & ~FAULT_QUEUE_MASK);
this.configuration |= (ushort)consecutiveFaults;
// save configuration register
this.ChangeConfiguration();
// set temperature high for alert
this.regAddress[0] = TEMP_HIGH_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureHigh);
this.WriteRegister(this.regAddress, this.regData);
// set temperature low for alert
this.regAddress[0] = TEMP_LOW_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureLow);
this.WriteRegister(this.regAddress, this.regData);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ConversionRate = await _context.ConversionRate
.Include(c => c.sourceCurrency)
.Include(c => c.targetCurrency).FirstOrDefaultAsync(m => m.conversionID == id);
if (ConversionRate == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ConversionRate = await _context.ConversionRate.FindAsync(id);
if (ConversionRate != null)
{
_context.ConversionRate.Remove(ConversionRate);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public static double caculateCurrentConversion(int currencyID)
{
TCRMDBContext _db = new TCRMDBContext();
List <ConversionRate> conversionRatesList = _db.ConversionRates.Where(c => c.CurrencyID == currencyID).ToList();
//if list is empty , throw an exception
if (conversionRatesList.Count == 0)
{
throw new System.ArgumentException("There are no conversion rates for this currency");
}
//find the right conversion - which is the Max {earlier dates then today}
List <ConversionRate> earlierDatesThenNow = new List <ConversionRate>();
foreach (ConversionRate conversionRate in conversionRatesList)
{
if (conversionRate.Date <= DateTime.Now)
{
earlierDatesThenNow.Add(conversionRate);
}
}
//if conversion list is empty now, throw an exception
if (earlierDatesThenNow.Count == 0)
{
throw new System.ArgumentException("There are no conversion rates earlier or equal to today for this currency");
}
//find the max of the earlier or equal dates of today
DateTime maxDate = new DateTime(1900, 1, 1);
ConversionRate rightConversionRate = new ConversionRate();
foreach (ConversionRate conversionRate in earlierDatesThenNow)
{
if (conversionRate.Date > maxDate)
{
maxDate = conversionRate.Date;
rightConversionRate = conversionRate;
}
}
//if no dates, or date is (1900,1,1) throw exception
if (maxDate == new DateTime(1900, 1, 1))
{
throw new System.ArgumentException("There are no conversion rates earlier or equal to today for this currency");
}
return(rightConversionRate.ConversionValue);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ConversionRate = await _context.ConversionRate
.Include(c => c.sourceCurrency)
.Include(c => c.targetCurrency).FirstOrDefaultAsync(m => m.conversionID == id);
if (ConversionRate == null)
{
return(NotFound());
}
ViewData["sourceCurrencyID"] = new SelectList(_context.Currency, "currencyID", "currencyCode");
ViewData["targetCurrencyID"] = new SelectList(_context.Currency, "currencyID", "currencyCode");
return(Page());
}
public ExchangeRate CalculateFromConversionRate(ConversionRate conversionRate, DateTime timstampUtc, Rounding rounding)
{
Argument.NotNull(conversionRate, "conversionRate");
var baseCurrency = _currencyRepository.Find(conversionRate.Conversion.From);
if (baseCurrency == null)
{
var message = string.Format("Can't find currency [{0}] in the database.", conversionRate.Conversion.From);
throw new InvalidOperationException(message);
}
var foreignCurrency = _currencyRepository.Find(conversionRate.Conversion.To);
if (foreignCurrency == null)
{
var message = string.Format("Can't find currency [{0}] in the database.", conversionRate.Conversion.To);
throw new InvalidOperationException(message);
}
var buyRate = MoneyMath.Round(conversionRate.Rate * (decimal) Randomizer.FromRange(_settings.BuyRateCoefficientRange), rounding);
var sellRate = MoneyMath.Round(conversionRate.Rate * (decimal) Randomizer.FromRange(_settings.SellRateCoefficientRange), rounding);
return ExchangeRate.Create(baseCurrency, foreignCurrency, buyRate, sellRate, timstampUtc);
}
/// <summary>
/// Provides the description of the model settings for summary (GetFullSummary)
/// </summary>
/// <param name="formatForParentControl">Use full verbose description</param>
/// <returns></returns>
public override string ModelSummary(bool formatForParentControl)
{
using (StringWriter htmlWriter = new StringWriter())
{
htmlWriter.Write("\r\n<div class=\"activityentry\">Process ");
if (ResourceTypeProcessedName == null || ResourceTypeProcessedName == "")
{
htmlWriter.Write("<span class=\"errorlink\">[RESOURCE NOT SET]</span>");
}
else
{
htmlWriter.Write("<span class=\"resourcelink\">" + ResourceTypeProcessedName + "</span>");
}
htmlWriter.Write(" into ");
if (ResourceTypeCreatedName == null || ResourceTypeCreatedName == "")
{
htmlWriter.Write("<span class=\"errorlink\">[RESOURCE NOT SET]</span>");
}
else
{
htmlWriter.Write("<span class=\"resourcelink\">" + ResourceTypeCreatedName + "</span>");
}
htmlWriter.Write(" at a rate of ");
if (ConversionRate <= 0)
{
htmlWriter.Write("<span class=\"errorlink\">[RATE NOT SET]</span>");
}
else
{
htmlWriter.Write("1:<span class=\"resourcelink\">" + ConversionRate.ToString("0.###") + "</span>");
}
htmlWriter.Write("</div>");
if (Reserve > 0)
{
htmlWriter.Write("\r\n<div class=\"activityentry\">");
htmlWriter.Write("<span class=\"setvalue\">" + Reserve.ToString("0.###") + "</span> will be reserved.");
htmlWriter.Write("</div>");
}
return(htmlWriter.ToString());
}
}
/// <summary>
/// Provides the description of the model settings for summary (GetFullSummary)
/// </summary>
/// <param name="formatForParentControl">Use full verbose description</param>
/// <returns></returns>
public override string ModelSummary(bool formatForParentControl)
{
string html = "";
html += "\n<div class=\"activityentry\">Process ";
if (ResourceTypeProcessedName == null || ResourceTypeProcessedName == "")
{
html += "<span class=\"errorlink\">[RESOURCE NOT SET]</span>";
}
else
{
html += "<span class=\"resourcelink\">" + ResourceTypeProcessedName + "</span>";
}
html += " into ";
if (ResourceTypeCreatedName == null || ResourceTypeCreatedName == "")
{
html += "<span class=\"errorlink\">[RESOURCE NOT SET]</span>";
}
else
{
html += "<span class=\"resourcelink\">" + ResourceTypeCreatedName + "</span>";
}
html += " at a rate of ";
if (ConversionRate <= 0)
{
html += "<span class=\"errorlink\">[RATE NOT SET]</span>";
}
else
{
html += "1:<span class=\"resourcelink\">" + ConversionRate.ToString("0.###") + "</span>";
}
html += "</div>";
if (Reserve > 0)
{
html += "\n<div class=\"activityentry\">";
html += "<span class=\"setvalue\">" + Reserve.ToString("0.###") + "</span> will be reserved.";
html += "</div>";
}
return(html);
}
public async Task <ActionResult <ConversionRate> > GetConversionRate(string from, string to)
{
List <ConversionRate> conversion = new List <ConversionRate>();
using (var client = new HttpClient())
{
try
{
client.BaseAddress = new Uri("https://min-api.cryptocompare.com/data/price?fsym=" + from + "&tsyms=" + to);
var response = await client.GetAsync(client.BaseAddress);
response.EnsureSuccessStatusCode();
var stringResult = await response.Content.ReadAsStringAsync();
var jsonData = JObject.Parse(stringResult);
foreach (var item in jsonData)
{
if (item.Key != to)
{
continue;
}
foreach (var items in jsonData)
{
var itemValueResult = items.Value.ToString();
ConversionRate conversionRate = new ConversionRate();
conversionRate.ConversionRateValue = Convert.ToDouble(itemValueResult);
conversion.Add(conversionRate);
}
}
return(Ok(_mapper.Map <IEnumerable <ConversionRate> >(conversion)));
}
catch (HttpRequestException httpRequestException)
{
return(BadRequest($"Error getting crypto: {httpRequestException.Message}"));
}
}
}
public void TestInitialize()
{
ConversionRateManager = new ConversionRate();
if (TestContext.TestName == nameof(FileNameDoesExist) ||
TestContext.TestName == nameof(SaveHistoryWhenFileExists))
{
SetGoodFileName();
if (!string.IsNullOrEmpty(_goodFileName))
{
TestContext.WriteLine("Creating the file: " + _goodFileName);
File.AppendAllText(_goodFileName, "Lorem Ipsum Text");
}
}
if (TestContext.TestName == nameof(FileNameDoesNotExist) ||
TestContext.TestName == nameof(SaveHistoryWhenFileNotExists))
{
SetBadFileName();
TestContext.WriteLine("Setting the bad file: " + _badFileName);
}
}
private decimal GetConversionRateValue(IEnumerable <ConversionRate> rates, string from, string to)
{
try
{
if (rates == null || rates.Count() == 0)
{
return(-1);
}
if (from == to)
{
return(1);
}
ConversionRate exactConversion = rates.Where(r => r.From == from && r.To == to).FirstOrDefault();
if (exactConversion != null)
{
return(exactConversion.Rate);
}
IEnumerable <ConversionRate> nextRates = rates.Where(r => r.From == from);
IEnumerable <ConversionRate> filteredRates = rates.Where(r => r.To != from);
foreach (ConversionRate nextRate in nextRates)
{
var value = GetConversionRateValue(filteredRates, nextRate.To, to);
if (value > 0)
{
return(nextRate.Rate * value);
}
}
return(-1);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private ConversionRate[] CreateConversionRates()
{
var tempCurrencies1 = new Dictionary <string, decimal>();
var tempCurrencies2 = new Dictionary <string, decimal>();
var _conversionRate1 = new ConversionRate(new DateTime(2019, 1, 25));
tempCurrencies1.Add("UAH", 27.7830473323m);
tempCurrencies1.Add("RUB", 65.9764487621m);
tempCurrencies1.Add("EUR", 0.8765548195m);
tempCurrencies1.Add("USD", 1.0m);
_conversionRate1.Currencies = tempCurrencies1;
var _conversionRate2 = new ConversionRate(DateTime.Today);
tempCurrencies2.Add("UAH", 24.4715083357m);
tempCurrencies2.Add("RUB", 65.2378996809m);
tempCurrencies2.Add("EUR", 0.9147112977m);
tempCurrencies2.Add("USD", 1.0m);
_conversionRate2.Currencies = tempCurrencies2;
return(new ConversionRate[] { _conversionRate1, _conversionRate2 });
}
public Task <int> DeleteItemAsync(ConversionRate item)
{
return(Database.DeleteAsync(item));
}
public bool Init(
ADD0 addressSelect = ADD0.Gnd,
bool oneShotMode = false,
AlertPolarity alertPolarity = AlertPolarity.activeHigh,
ConversionRate conversionRate = ConversionRate.four_Hz,
ThermostatMode thermostatMode = ThermostatMode.ComparatorMode)
{
return Init(addressSelect, oneShotMode, alertPolarity, conversionRate, thermostatMode, ConsecutiveFaults.one, 0, 0);
}
public ExchangeRate CalculateFromNationalBankRate(string foreignCurrencyISOName, decimal rate, DateTime timestampUtc)
{
Argument.NotEmpty(foreignCurrencyISOName, "foreignCurrencyISOName");
Argument.Satisfies(foreignCurrencyISOName, x => x != _settings.NationalCurrency);
Argument.Satisfies(rate, x => x > 0, "rate");
var conversionRate = new ConversionRate(new CurrencyConversion(_settings.NationalCurrency, foreignCurrencyISOName), rate);
return CalculateFromConversionRate(conversionRate, timestampUtc, _roundingSettings.GetRounding(foreignCurrencyISOName));
}
/// <summary>
/// Configures the device.
/// </summary>
/// <param name="OneShot">If tepmerature conversions are made on request.</param>
/// <param name="FaultQueue">Fault queue.</param>
/// <param name="AlertPolarity">Alert polarity.</param>
/// <param name="ThermostatMode">Thermostat mode.</param>
/// <param name="ShutdownMode">Shutdown mode.</param>
/// <param name="ConversionRate">Conversion rate.</param>
/// <param name="ExtendedMode">Extended mode</param>
public void Configure (bool OneShot, FaultQueue FaultQueue, AlertPolarity AlertPolarity, ThermostatMode ThermostatMode, bool ShutdownMode, ConversionRate ConversionRate, bool ExtendedMode)
{
byte H = (byte)(OneShot ? 1 : 0);
H <<= 2;
H |= 3; // Resolution=11
H <<= 2;
H |= (byte)FaultQueue;
H <<= 1;
H |= (byte)AlertPolarity;
H <<= 1;
H |= (byte)ThermostatMode;
H <<= 1;
H |= (byte)(ShutdownMode ? 1 : 0);
byte L = (byte)ConversionRate;
L <<= 2;
L |= (byte)(ExtendedMode ? 1 : 0);
L <<= 4;
if (!this.i2cBus.Write (this.address, 1, H, L))
throw new System.IO.IOException ("Unable to write register.");
}
// -------------------------------------------------------------------------------------------------------------------------------------
private bool Init(
ADD0 addressSelect,
bool oneShotMode,
AlertPolarity alertPolarity,
ConversionRate conversionRate,
ThermostatMode thermostatMode,
ConsecutiveFaults consecutiveFaults,
ushort limitHigh,
ushort limitLow)
{
// Sleep past first conversion
Thread.Sleep(30);
switch (addressSelect)
{
case ADD0.Gnd: _sensorAddress = 0x90 >> 1; break;
case ADD0.Vcc: _sensorAddress = 0x92 >> 1; break;
case ADD0.SDA: _sensorAddress = 0x94 >> 1; break;
case ADD0.SCL: _sensorAddress = 0x96 >> 1; break;
}
_TMP102 = new I2CDevice(new I2CDevice.Configuration(_sensorAddress, 100));
_alertPolarity = alertPolarity;
_oneShotMode = oneShotMode;
_thermostatMode = thermostatMode;
_consecutiveFaults = consecutiveFaults;
_registerNum[0] = (byte)Registers.Configuration;
int bytesTransfered = ReadRegister();
if (bytesTransfered == 3)
{
if (_oneShotMode)
_registerValue[0] = (byte)(_registerValue[0] | 0x01);
else
_registerValue[0] = (byte)(_registerValue[0] & 0xfe);
if (_thermostatMode == ThermostatMode.InterruptMode)
_registerValue[0] = (byte)(_registerValue[0] | 0x02);
else
_registerValue[0] = (byte)(_registerValue[0] & 0xfd);
if (_alertPolarity == AlertPolarity.activeLow)
_registerValue[0] = (byte)(_registerValue[0] | 0x04);
else
_registerValue[0] = (byte)(_registerValue[0] & ~0x04);
switch (conversionRate)
{
case ConversionRate.quarter_Hz: _registerValue[1] = (byte)((_registerValue[1] & 0x3f) | (0x00 << 6)); break;
case ConversionRate.one_Hz: _registerValue[1] = (byte)((_registerValue[1] & 0x3f) | (0x01 << 6)); break;
case ConversionRate.four_Hz: _registerValue[1] = (byte)((_registerValue[1] & 0x3f) | (0x02 << 6)); break;
case ConversionRate.eight_Hz: _registerValue[1] = (byte)((_registerValue[1] & 0x3f) | (0x03 << 6)); break;
}
bytesTransfered = WriteRegister();
Thread.Sleep(30);
}
return (bytesTransfered == 3);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="a0addrSelect">A0 pin connection for address selection</param>
/// <param name="clockRateKhz">I2C clock rate in KHz</param>
/// <param name="conversionRate">Conversion rate</param>
/// <param name="shutdownMode">Shutdown mode</param>
/// <param name="thermostatMode">Thermostat mode</param>
/// <param name="alertPolarity">Polarity of the alert pin</param>
/// <param name="consecutiveFaults">Consecutive faults before activate alert pin</param>
/// <param name="temperatureHigh">Temperature High for alert</param>
/// <param name="temperatureLow">Temperature Low for alert</param>
public TMP102(A0AddressSelect a0addrSelect = A0AddressSelect.GND,
int clockRateKhz = CLOCK_RATE_KHZ_DEFAULT,
ConversionRate conversionRate = ConversionRate._4Hz,
bool shutdownMode = false,
ThermostatMode thermostatMode = ThermostatMode.Comparator,
AlertPolarity alertPolarity = AlertPolarity.ActiveLow,
ConsecutiveFaults consecutiveFaults = ConsecutiveFaults._1,
float temperatureHigh = TEMP_HIGH_DEFAULT,
float temperatureLow = TEMP_LOW_DEFAULT)
{
// create buffers for one and two bytes for I2C communications
this.regAddress = new byte[REG_ADDRESS_SIZE];
this.regData = new byte[REG_DATA_SIZE];
// configure and create I2C reference device
I2CDevice.Configuration i2cConfig = new I2CDevice.Configuration((ushort)(TMP102_ADDRESS_BASE + a0addrSelect), clockRateKhz);
this.i2c = new I2CDevice(i2cConfig);
// load configuration register
this.LoadConfiguration();
// set conversion rate
this.configuration = (ushort)(this.configuration & ~CONV_RATE_MASK);
this.configuration |= (ushort)conversionRate;
// set shutdown mode
this.configuration = (shutdownMode) ? (ushort)(this.configuration | SHUTDOWN_MODE) : (ushort)(this.configuration & ~SHUTDOWN_MODE);
// set thermostat mode
this.configuration = (thermostatMode == ThermostatMode.Interrupt) ? (ushort)(this.configuration | THERMOSTAT_MODE) : (ushort)(this.configuration & ~THERMOSTAT_MODE);
// set alert pin polarity
this.configuration = (alertPolarity == AlertPolarity.ActiveHigh) ? (ushort)(this.configuration | POLARITY) : (ushort)(this.configuration & ~POLARITY);
// set consecutive faults for alert
this.configuration = (ushort)(this.configuration & ~FAULT_QUEUE_MASK);
this.configuration |= (ushort)consecutiveFaults;
// save configuration register
this.ChangeConfiguration();
// set temperature high for alert
this.regAddress[0] = TEMP_HIGH_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureHigh);
this.WriteRegister(this.regAddress, this.regData);
// set temperature low for alert
this.regAddress[0] = TEMP_LOW_REG_ADDR;
this.regData = this.TemperatureToBytes(temperatureLow);
this.WriteRegister(this.regAddress, this.regData);
}
public override string ToString()
{
return(string.Format("{0}: {1} @ {2} ({3})", Symbol, Quantity, ConversionRate.ToString("C"), ValueInAccountCurrency));
}
/// <summary>
/// Configures the device.
/// </summary>
/// <param name="OneShot">If tepmerature conversions are made on request.</param>
/// <param name="FaultQueue">Fault queue.</param>
/// <param name="AlertPolarity">Alert polarity.</param>
/// <param name="ThermostatMode">Thermostat mode.</param>
/// <param name="ShutdownMode">Shutdown mode.</param>
/// <param name="ConversionRate">Conversion rate.</param>
/// <param name="ExtendedMode">Extended mode</param>
public void Configure(bool OneShot, FaultQueue FaultQueue, AlertPolarity AlertPolarity, ThermostatMode ThermostatMode, bool ShutdownMode, ConversionRate ConversionRate, bool ExtendedMode)
{
byte H = (byte)(OneShot ? 1 : 0);
H <<= 2;
H |= 3; // Resolution=11
H <<= 2;
H |= (byte)FaultQueue;
H <<= 1;
H |= (byte)AlertPolarity;
H <<= 1;
H |= (byte)ThermostatMode;
H <<= 1;
H |= (byte)(ShutdownMode ? 1 : 0);
byte L = (byte)ConversionRate;
L <<= 2;
L |= (byte)(ExtendedMode ? 1 : 0);
L <<= 4;
if (!this.i2cBus.Write(this.address, 1, H, L))
{
throw new System.IO.IOException("Unable to write register.");
}
}
