public ActionResult EditCourse(int?id, double buy, double sell)
{
CurrencyContext context = new CurrencyContext();
Courses course = context.Courses.FirstOrDefault(cor => cor.currency_id == id);
if (course != null)
{
course.buy = buy;
course.sell = sell;
context.SaveChanges();
}
else
{
course = new Courses
{
currency_id = (int)id,
buy = buy,
sell = sell,
};
context.Courses.Add(course);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
public static void RecreateCleanDatabase()
{
using var context = new CurrencyContext(quiet: true);
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
public IEnumerable <RequestHistory> Find(Func <RequestHistory, bool> predicate)
{
using (CurrencyContext context = new CurrencyContext())
{
return(context.RequestHistory.Where(predicate).ToList());
}
}
static void Main(string[] args)
{
Console.WriteLine("Spinning CurrencyDatabaseGenerator");
try
{
var optionsBuilder = new DbContextOptionsBuilder <CurrencyContext>();
//TODO: dev config
optionsBuilder.UseSqlServer("Server=DESKTOP-CNCHB79\\SQLEXPRESS;Database=Currency;Trusted_Connection=True;MultipleActiveResultSets=true");
//TODO: prod config
//options.UseSqlServer("Server=DESKTOP-CNCHB79\\SQLEXPRESS;Database=Currency;Trusted_Connection=True;MultipleActiveResultSets=true");
CurrencyContext context = new CurrencyContext(optionsBuilder.Options);
Initialize(context);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("Generated");
}
private Dictionary <string, decimal> FillRatesRelations()
{
using (CurrencyContext db = new CurrencyContext())
{
//ExchangeRate exchangeRate = new ExchangeRate() { Dollar = 73.71m, Euro = 80.67m, DollarToEuro = 1.06m };
//db.DbExchangeRates.Add(exchangeRate);
//db.SaveChanges();
ExchangeRate exchangeRates = db.DbExchangeRates.FirstOrDefault();
if (exchangeRates != null)
{
var ratesRelations = new Dictionary <string, decimal>
{
[$"{Constants.Rub}:{Constants.Dollar}"] = exchangeRates.Dollar,
[$"{Constants.Dollar}:{Constants.Rub}"] = exchangeRates.Dollar,
[$"{Constants.Rub}:{Constants.Euro}"] = exchangeRates.Euro,
[$"{Constants.Euro}:{Constants.Rub}"] = exchangeRates.Euro,
[$"{Constants.Dollar}:{Constants.Euro}"] = exchangeRates.DollarToEuro,
[$"{Constants.Euro}:{Constants.Dollar}"] = exchangeRates.DollarToEuro
};
return(ratesRelations);
}
}
throw new ArgumentException("Отсутствуют данные в базе данных");
}
public async Task ListMemes()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var memes = db.Memes.AsQueryable().Where(m => m.Owner == Context.Message.Author.Id).ToList();
if (memes.Count <= 0)
{
await ReplyAsync("You dont have any memes yet!");
}
else
{
var memeNames = "";
foreach (Meme meme in memes)
{
memeNames += (memes.First() == meme) ? meme.Id : ", " + meme.Id;
}
await ReplyAsync($"Your memes: {memeNames}");
}
}
}
public ExchangeRateRepository(CurrencyContext dbContext,
IMapper mapper)
{
this.dbContext = dbContext;
this.mapper = mapper;
this.exchangeRatesDbSet = dbContext.Set <Database.Entities.ExchangeRate>();
}
public async Task CreateNewMeme(string name, [Remainder] string content)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var meme = db.Memes.Find(name);
if (meme == null)
{
await db.AddAsync(new Meme
{
Id = name,
Content = content,
Owner = Context.Message.Author.Id
});
await db.SaveChangesAsync();
await ReplyAsync($"Meme {name} created!");
}
else
{
await ReplyAsync($"The name: {name} already exists, pick a different one!");
}
}
}
public async Task CreateAccount()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
await db.UserAccounts.AddAsync(new UserAccount
{
Id = Context.User.Id,
Balance = 1000,
Inventory = new Dictionary <string, int>()
});
await db.Cooldowns.AddAsync(new Cooldowns
{
Id = Context.User.Id,
Collect = new DateTime(),
Work = new DateTime(),
Rob = new DateTime(),
Robbed = new DateTime(),
Roulette = new DateTime(),
Trivia = new DateTime()
});
await db.SaveChangesAsync();
await ReplyAsync("Account created!");
}
}
public async Task ListShop()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var items = db.Items.ToList();
if (items.Count == 0)
{
await ReplyAsync("The shop is empty right now, come back later!");
}
string stock = "";
foreach (Item item in items)
{
stock += "**" + item.Id + ":** " + item.Description + "\n **Price:** " + item.Price + "\n **Max quantity:** " + item.MaxQuantity + "\n \n";
}
var embed = new EmbedBuilder();
embed.WithColor(new Color(0, 255, 0));
embed.WithTitle("Item shop");
embed.WithDescription(stock);
await ReplyAsync("", false, embed.Build());
}
}
public RefreshCurrencyListHandler(ICurrencyApi currencyApi, CurrencyContext db, ILogger <RefreshCurrencyListHandler> logger, IMapper mapper)
{
this.currencyApi = currencyApi;
this.db = db;
this.logger = logger;
this.mapper = mapper;
}
public static void RestToDB(DateTime someDaysAgo)
{
var client = new RestClient(@"http://data.fixer.io/api/");
string key = "96067c8c5fb4cd025c5edec854c44316";
var request = new RestRequest(MakeResponceFixer_io(key, someDaysAgo), Method.GET);
request.OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; };
var queryResult = client.Execute(request);
if (queryResult.StatusCode == HttpStatusCode.OK)
{
string rawResponse = queryResult.Content;
JObject jsonResponce = JObject.Parse(rawResponse);
//using (StreamWriter file = File.CreateText(@"C:\1\currency.json"))
//using (JsonTextWriter writer = new JsonTextWriter(file))
//{
// jsonResponce.WriteTo(writer);
//}
using (CurrencyContext db = new CurrencyContext())
{
Currency currencyRate = JsonConvert.DeserializeObject <Currency>(rawResponse);
var dt = currencyRate.Date;
Console.WriteLine("Add infofmation for date -- " + dt);
db.Currencies.Add(currencyRate);
db.SaveChanges();
}
}
}
public async Task Ranking()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var accounts = db.UserAccounts.AsQueryable().OrderByDescending(a => a.Balance).Take(5).ToList();
var message = "";
var nr = 1;
foreach (UserAccount account in accounts)
{
message += nr + ". <@" + account.Id + ">: " + account.Balance + " Kredits \n";
nr++;
}
var embed = new EmbedBuilder();
embed.WithColor(new Color(0, 0, 255));
embed.WithTitle("Ranking");
embed.WithDescription(message);
await ReplyAsync("", false, embed.Build());
}
}
public ActionResult EditCurrency(int?id, string code, string name, string name_lat, int order_index)
{
CurrencyContext context = new CurrencyContext();
if (id != null && id > 0)
{
Currency currency = context.Currency.Single(cur => cur.id == id);
currency.code = code;
currency.name = name;
currency.name_lat = name_lat;
currency.order_index = order_index;
context.SaveChanges();
}
else
{
Currency currency = new Currency
{
code = code,
name = name,
name_lat = name_lat,
order_index = order_index,
};
context.Currency.Add(currency);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
public static void DBUpdate(DateTime date)
{
CurrencyContext db;
for (int i = 0; i < 10; i++)
{
DateTime someDaysAgo = date.AddDays(-i);
using (CurrencyContext context = new CurrencyContext())
{
db = context;
string dbDateFrmat = someDaysAgo.ToString("yyyy-MM-dd");
var currRes = db.Currencies;
if (currRes.Any(x => x != null))
{
var result = currRes.FirstOrDefault(rec => rec.Date == dbDateFrmat);
if (result != null)
{
continue;
}
}
}
RestToDB(someDaysAgo);
}
}
public CurrencyContext currency()
{
CurrencyContext _localctx = new CurrencyContext(Context, State);
EnterRule(_localctx, 16, RULE_currency);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 65;
_la = TokenStream.LA(1);
if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__4) | (1L << T__5) | (1L << T__6))) != 0)))
{
ErrorHandler.RecoverInline(this);
}
else
{
ErrorHandler.ReportMatch(this);
Consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public async Task Inventory(IUser user)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(a => a.Id == user.Id).FirstOrDefault();
if (account != null)
{
if (account.Inventory != null)
{
var inventory = "";
foreach (KeyValuePair <string, int> item in account.Inventory)
{
inventory += "[" + item.Value + "] " + item.Key + " \n";
}
var embed = new EmbedBuilder();
embed.WithColor(new Color(0, 255, 0));
embed.WithTitle(user.Username + "'s inventory");
embed.WithDescription(inventory);
await ReplyAsync("", false, embed.Build());
}
else
{
await ReplyAsync("Your inventory is empty!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
public void EnsurFiatSeedData(string filePath)
{
CurrencyContext currencyContext = new CurrencyContext();
if (!currencyContext.Fiat.Any())
{
dynamic jsonData = ReadJsonFile(filePath);
if (jsonData != null)
{
foreach (dynamic d in jsonData)
{
currencyContext.Fiat.Add(new FiatEntity()
{
Id = d.Id,
Code = d.Code,
Description = d.Description,
Name = d.Name,
Symbol = d.Symbol,
DisplayName = d.DisplayName,
FlagId = d.FlagId,
ImageId = d.ImageId
});
}
currencyContext.SaveChanges();
}
}
}
public Rate AddRate(Rate rate)
{
using (CurrencyContext dbContext = new CurrencyContext())
{
var dateToUse = GetDate(rate, dbContext);
var currencyToUse = GetCurrency(rate, dbContext);
Rate dbRate = dbContext.Rates.AsEnumerable().FirstOrDefault(r => r.Currency == currencyToUse &&
r.Date == dateToUse);
if (dbRate != null)
{
return(dbRate);
}
var newRate = dbContext.Rates.Add(new Rate
{
Price = rate.Price,
Currency = currencyToUse,
Date = dateToUse,
TableNumber = rate.TableNumber
});
dbContext.SaveChanges();
return(newRate);
}
}
public async Task AddHistory(RequestHistory history)
{
using (CurrencyContext context = new CurrencyContext())
{
context.RequestHistory.Add(history);
await context.SaveChangesAsync();
}
}
public IHttpActionResult GetT()
{
using (CurrencyContext currencyDb = new CurrencyContext())
{
var currencies = currencyDb.Currency.ToList().AsQueryable();
return(Ok(new { data = currencies }));
}
}
public IHttpActionResult GetC(int id)
{
using (CurrencyContext currencyDb = new CurrencyContext())
{
var currency = currencyDb.Currency.FirstOrDefault(cur => cur.currencyId == id);
return(Ok(new { data = currency }));
}
}
public HttpResponseMessage Get()
{
using (CurrencyContext currencyDb = new CurrencyContext())
{
var currencies = currencyDb.Currency.ToList().AsQueryable();
return(Request.CreateResponse(HttpStatusCode.OK, new { data = currencies.AsQueryable() }));
}
}
public ActionResult Index()
{
var model = new ExchangeRateDTO();
using (CurrencyContext context = new CurrencyContext())
{
model.ExchangeRateDataList = context.ExchangeRate.Where(m => m.Id > 0).Include(m => m.Currency).ToList();
}
return(View(model));
}
public async Task Buy(string itemname, int quantity = 1)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var item = db.Items.AsQueryable().Where(i => i.Id.ToLower() == itemname.ToLower()).FirstOrDefault();
if (item != null)
{
if (account.AddToInventory(item, quantity))
{
if (account.SubtractBalance(item.Price * quantity))
{
if (item.Id.ToLower() == "bitcoin_miner")
{
cooldowns.Collect = new DateTime();
db.Update(cooldowns);
}
db.Update(account);
await ReplyAsync("Item purchased!");
}
else
{
account.RemoveFromInventory(item, quantity);
db.Update(account);
await ReplyAsync("You can't afford that item!");
}
await db.SaveChangesAsync();
}
else
{
await ReplyAsync("You have reached the item limit for that item!");
}
}
else
{
await ReplyAsync("Item was not found!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
// GET: Currencies / Index
public ActionResult Index()
{
CurrencyContext context = new CurrencyContext();
var viewModel = new CurrenciesViewModel
{
Currencies = context.Currency.ToList()
};
return(View(viewModel));
}
/// <summary>
/// get currency info a number of days back
/// </summary>
/// <param name="days">number of days to go back</param>
/// <returns>list of currency info in the requested range</returns>
public async Task <List <HistoricalCurrencyEntity> > GetTimeSpanCurrency(int days)
{
await UpdateDataBaseAsync(DateTime.Today.AddDays(-days), DateTime.Today); //make sure db is updated
List <HistoricalCurrencyEntity> ret;
using (var db = new CurrencyContext()) {
ret = (from hentinity in db.HistoricalCurrency
select hentinity).ToList();
}
return(ret.GetRange(ret.Count - days, days));//the last days
}
public SalesOrder Get(int id)
{
var model = _salesorderRepository.GetSalesOrderById(id);
CurrencyContext db = new CurrencyContext();
Currency cu = db.Currencies.Find(model.CurrencyNo);
if (cu != null)
{
model.CurrencyDesc = db.Currencies.Find(model.CurrencyNo).CurrencyDescription;
}
return(model);
}
protected void Application_Start()
{
Database.SetInitializer(new CurrencyDbInitializer());
CurrencyContext context = new CurrencyContext();
context.Database.Initialize(true);
Database.SetInitializer <ApplicationDbContext>(new AppSecurityDbInitializer());
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
public JsonResult GetExchangeRates(string currencyName)
{
using var scope = _scopeFactory.CreateScope();
var dbContext =
new CurrencyContext(scope.ServiceProvider
.GetRequiredService <DbContextOptions <CurrencyContext> >());
var maxDate = dbContext.Currency.Max(c => c.RatesDate.Date);
var model = dbContext.Currency.FirstOrDefault(c => c.CurrencyName == currencyName && c.RatesDate.Date == maxDate);
var jsonData = JsonConvert.SerializeObject(model.Rates);
return(Json(jsonData));
}
