public async Task <IActionResult> Create([FromBody] CurrencyEntry pModel)
{
// Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (Validate(pModel, false) == false)
{
return(BadRequest(ModelState));
}
else
{
// Execution of concrete process
SQLResult result = new SQLResult();
result = await _repo.Create(pModel);
if (result.ErrorNo > 0)
{
return(BadRequest(result));
}
else
{
return(Ok(result));
}
}
}
public ActionResult Create([Bind(Include = "id,FromCurrency,ToCurrency,Rate")] CurrencyEntry currencyEntry)
{
if (ModelState.IsValid)
{
CurrencyEntry deleted = db.CurrencyEntries.Where(e => e.FromCurrency == currencyEntry.FromCurrency &&
e.ToCurrency == currencyEntry.ToCurrency).FirstOrDefault();
if (deleted != null) // Do an update if old entry with same currencies was "deleted"
{
deleted.Enabled = true;
deleted.DateUpdated = DateTime.Now;
deleted.Rate = currencyEntry.Rate;
}
else
{
currencyEntry.Enabled = true;
currencyEntry.DateCreated = DateTime.Now;
currencyEntry.DateUpdated = DateTime.Now;
db.CurrencyEntries.Add(currencyEntry);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(currencyEntry));
}
internal FinancialCalculator CreateCalculator()
{
var result = new FinancialCalculator();
//{
// MarginMode = this.MarginMode
//};
foreach (var element in this.Prices)
{
result.Prices.Update(element.Symbol, element.Bid, element.Ask);
}
foreach (var element in this.Symbols)
{
var entry = element.CreateEntry(result);
result.Symbols.Add(entry);
}
foreach (var element in this.Accounts)
{
var entry = element.CreateEntry(result);
result.Accounts.Add(entry);
}
foreach (var element in this.Currencies)
{
var entry = new CurrencyEntry(result, element, 2, 0);
result.Currencies.Add(entry);
}
return(result);
}
private bool Validate(CurrencyEntry pModel, bool isUpdateValidation)
{
if (isUpdateValidation == true)
{
if (pModel.CurrencyId <= 0)
{
ModelState.AddModelError("", Messages.Blank("Currency entry"));
return(false);
}
}
if (pModel.CurrencyCode.Trim().Length == 0)
{
ModelState.AddModelError("", Messages.Blank("Code"));
return(false);
}
if (pModel.Currency.Trim().Length == 0)
{
ModelState.AddModelError("", Messages.Blank("Currency"));
return(false);
}
if (pModel.Description.Trim().Length == 0)
{
ModelState.AddModelError("", Messages.Blank("Description"));
return(false);
}
if (pModel.CurrencySymbol.Trim().Length == 0)
{
ModelState.AddModelError("", Messages.Blank("Symbol"));
return(false);
}
return(true);
}
public ActionResult DeleteConfirmed(int id)
{
CurrencyEntry currencyEntry = db.CurrencyEntries.Find(id);
currencyEntry.Enabled = false;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static CurrencyInfo ToCurrencyInfo(CurrencyEntry currency, int priority)
{
return(new CurrencyInfo
{
Name = currency.Name,
Precision = currency.Precision,
SortOrder = currency.SortOrder,
Id = (short)currency.GetHashCode()
});
}
public async Task <SQLResult> Edit(CurrencyEntry pModel)
{
SQLResult result = new SQLResult();
_Context.Database.BeginTransaction();
try
{
string csql = @" EXEC spmCurrencyUpdate
@pi_mCurrencyId
, @pi_CurrencyCode
, @pi_Currency
, @pi_Description
, @pi_CurrencySymbol
, @pi_Active
, @pi_UserId
, @pi_HostName
, @pi_IPAddress
, @pi_DeviceType
, @pi_MACAddress";
List <SqlParameter> sqlparam = new List <SqlParameter>()
{
new SqlParameter("@pi_mCurrencyId", pModel.CurrencyId),
new SqlParameter("@pi_CurrencyCode", pModel.CurrencyCode),
new SqlParameter("@pi_Currency", pModel.Currency),
new SqlParameter("@pi_Description", pModel.Description),
new SqlParameter("@pi_CurrencySymbol", pModel.CurrencySymbol),
new SqlParameter("@pi_Active", pModel.Active),
new SqlParameter("@pi_UserId", pModel.AuditColumns.UserId),
new SqlParameter("@pi_HostName", pModel.AuditColumns.HostName),
new SqlParameter("@pi_IPAddress", pModel.AuditColumns.IPAddress),
new SqlParameter("@pi_DeviceType", pModel.AuditColumns.DeviceType),
new SqlParameter("@pi_MACAddress", pModel.AuditColumns.MACAddress),
};
result = await _Context.DBResult.FromSql(csql, sqlparam.ToArray()).SingleOrDefaultAsync();
if (result.ErrorNo != 0)
{
_Context.Database.RollbackTransaction();
}
else
{
_Context.Database.CommitTransaction();
}
}
catch (Exception ex)
{
_Context.Database.RollbackTransaction();
result.ErrorNo = 9999999999;
result.ErrorMessage = ex.Message.ToString();
result.SQLErrorNumber = ex.HResult;
result.SQLErrorMessage = ex.Source.ToString();
}
return(result);
}
internal CurrencyData(CurrencyEntry entry)
{
if (entry == null)
{
throw new ArgumentNullException(nameof(entry));
}
this.Name = entry.Name;
this.Precision = entry.Precision;
this.SortOrder = entry.SortOrder;
}
public async Task <CurrencyEntry> GetEntry(Int64 id)
{
try
{
CurrencyEntry result = await _Context.CurrencyEntry.FromSql("Exec spmCurrencyEntry @pi_mCurrencyId", new SqlParameter("@pi_mCurrencyId", id)).SingleOrDefaultAsync();
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Edit([Bind(Include = "id,FromCurrency,ToCurrency,Rate,DateCreated,DateUpdated")] CurrencyEntry currencyEntry)
{
if (ModelState.IsValid)
{
currencyEntry.Enabled = true;
currencyEntry.DateUpdated = DateTime.Now;
db.Entry(currencyEntry).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(currencyEntry));
}
// GET: CurrencyEntries/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CurrencyEntry currencyEntry = db.CurrencyEntries.Find(id);
if (currencyEntry == null)
{
return(HttpNotFound());
}
return(View(currencyEntry));
}
public CurrencyEntryEditor(CurrencyEntry entry)
{
InitializeComponent();
DataContext = this;
this.Entry = entry;
var cmenu = new ContextMenu();
cmenu.Items.Add(ContextHelper.CreateSelectItemButton((asset) =>
{
GUID = asset.guid.ToString("N");
guidBox.Text = asset.guid.ToString("N");
}));
guidBox.ContextMenu = cmenu;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(""));
}
private async Task retrieveCurrencyPrice(CurrencyEntry currency)
{
await Task.Run(async() =>
{
if (currency.Name != Constants.BTC_CURRENCY_HEADER && !this.getCurrencyStatus(currency.Name))
{
RestRequest getMarketSummaryRequest = new RestRequest(string.Format(Constants.BITTREX_GET_MARKET_SUMMARY, currency.Name), Method.GET);
IRestResponse <BittrexResponse> response = await this.bittrexClient.ExecuteGetTaskAsync <BittrexResponse>(getMarketSummaryRequest);
if (response.Data.Success)
{
currency.LastEstimate = (double)((Dictionary <string, object>)response.Data.Result[0])["Last"];
this.updateCurrencyStatus(currency.Name, true);
}
else
{
currency.LastEstimate = -1;
this.updateCurrencyStatus(currency.Name, false);
}
}
});
}
protected override void readAsset(IFileReader reader)
{
base.readAsset(reader);
valueFormat = reader.readValue("ValueFormat");
name = valueFormat;
int num = reader.readArrayLength("Entries");
entries = new CurrencyEntry[num];
for (int i = 0; i < num; i++)
{
IFileReader formattedFileReader = reader.readObject(i);
CurrencyEntry entry = new CurrencyEntry();
entry.ItemGUID = formattedFileReader.readValue <GameAssetReference <GameItemAsset> >("Item").GUID.ToString("N");
entry.Value = formattedFileReader.readValue <uint>("Value");
entries[i] = entry;
}
Array.Sort(entries, new Comparison <CurrencyEntry>((x, y) =>
{
return(x.Value.CompareTo(y.Value));
}));
}
public CurrencyEntryControl(CurrencyEntry entry)
{
InitializeComponent();
this.Entry = entry;
}
public async Task <IActionResult> Get(Int64 id)
{
CurrencyEntry result = await _repo.GetEntry(id);
return(Ok(result));
}
internal CurrencyEntry CreateEntry(FinancialCalculator owner)
{
var result = new CurrencyEntry(owner, this.Name, this.Precision, this.SortOrder);
return(result);
}
