private void BuildRequestUri(Core.Types.NoteType noteType)
{
var queryParameter = new QueryParameter()
{
ModelType = ModelType.Note
};
switch (noteType)
{
case Core.Types.NoteType.Company:
queryParameter.Type = ModelType.Company;
break;
case Core.Types.NoteType.Contact:
queryParameter.Type = ModelType.Contact;
break;
case Core.Types.NoteType.Lead:
queryParameter.Type = ModelType.Lead;
break;
case Core.Types.NoteType.Task:
queryParameter.Type = ModelType.Task;
break;
default:
queryParameter.Type = ModelType.Unknown;
break;
}
RequestUri += ApiQuery.Get(queryParameter);
}
/// <summary>
/// Query about all active Swedish stations
/// </summary>
/// <returns>An Api query</returns>
public static ApiQuery AllActiveSwedenStations()
{
ApiQuery All = AllActiveStations();
All.Filters.Add(new EqualsCondition("CountryCode", "SE"));
return(All);
}
//Hit the Lott Api
public async Task <T> GetApiResultsAsync <T>(string path, string productId) where T : class, ILottery
{
var apiQuery = new ApiQuery
{
CompanyId = _companyId,
MaxDrawCountPerProduct = "3",
OptionalProductFilter = _defaultProducts
};
if (!string.IsNullOrEmpty(productId))
{
apiQuery.OptionalProductFilter = new string[] { productId };
}
var jsonString = JsonConvert.SerializeObject(apiQuery);
T results = null;
var content = new StringContent(jsonString, Encoding.UTF8, "application/json");
var client = new HttpClient();
var response = await client.PostAsync(path, content);
if (response.IsSuccessStatusCode)
{
results = await response.Content.ReadAsAsync <T>();
}
return(results);
}
private ITrainRoute GetTrainRoute(IFavouriteRoute favouriteRoute)
{
var routeRepository = new RouteStopRepository();
var cachedTrainRoute = routeRepository.Find(favouriteRoute.FromId, favouriteRoute.ToId);
if (cachedTrainRoute != null)
{
return(cachedTrainRoute);
}
var stationRoutesQuery = new ApiQuery <Route>(_settingsProvider);
var routes = stationRoutesQuery.Query(string.Format("/query/station/{0}", favouriteRoute.FromId));
foreach (var route in routes)
{
var routeQuery = new ApiQuery <TrainRoute>(_settingsProvider);
var queryUri = string.Format("/query/date/{0}/route/{1}/from/{2}/to/{3}", route.Date, int.Parse(route.RouteNo),
favouriteRoute.FromId, favouriteRoute.ToId);
var trainRoutes = routeQuery.Query(queryUri);
if (trainRoutes.Any())
{
var trainRoute = trainRoutes.First();
if (!string.IsNullOrWhiteSpace(trainRoute.FromStation.StationName) &&
!string.IsNullOrWhiteSpace(trainRoute.ToStation.StationName))
{
routeRepository.Add(trainRoute);
}
return(trainRoute);
}
}
return(null);
}
protected IQueryable <T> ApplyFilters(IQueryable <T> query, ApiQuery queryOptions)
{
query = data.OrderBy(e => e.Id);
if (queryOptions.Offset.HasValue)
{
query = query.Skip(queryOptions.Offset.Value);
}
if (queryOptions.Limit.HasValue)
{
query = query.Take(queryOptions.Limit.Value);
}
if (queryOptions.Include.HasValue && queryOptions.Include.Value)
{
var entityType = dataContext.Model.FindEntityType(typeof(T));
foreach (var navigation in entityType.GetNavigations())
{
query = query.Include(navigation.Name);
}
}
return(query);
}
public async Task <IReadOnlyList <Game> > FetchTopRatedGames(string?mapName = null, FafMod?mod = null)
{
var query = new ApiQuery <Game>()
.Where("validity", "VALID")
.Where("replayAvailable", "true")
.Sort("-startTime")
.Limit(200);
if (mapName == null)
{
if (mod == FafMod.Faf)
{
query.Where("playerStats.player.globalRating.rating", WhereOp.GreaterThan, "2000");
}
query.Where("startTime", WhereOp.GreaterThan, DateTime.Now.AddDays(-7));
}
else
{
query.Where("mapVersion.map.displayName", $"*{mapName}*");
query.Where("startTime", WhereOp.GreaterThan, DateTime.Now.AddDays(-30));
}
if (mod != null)
{
query.Where("featuredMod.id", (int)mod);
}
var games = await _api.GetAsync(query);
return(games.Where(g => g.PlayerStats.Count > 1).OrderByDescending(g => g.AverageRating()).Take(3).ToList());
}
/// <summary>
/// Queries all accounts.
/// </summary>
/// <param name="query">The queryRequest settings.</param>
/// <returns>An enumerable which contains all accounts.</returns>
public IEnumerable <Account> QueryAccounts(ApiQuery query)
{
var response = ApiHandler.CallAction <DefaultResponse <IEnumerable <Account> > >(Device, "/accounts/queryAccounts",
null,
JDownloaderHandler.LoginObject, true);
return(response?.Data);
}
public async Task <ApiResult> Handle(ApiQuery request, CancellationToken cancellationToken)
{
var result = await Handle((QueryBase)request, cancellationToken);
var apiResult = new ApiResult(result.FilteredNumbersCount, request.Offset, request.Limit, result.FilteredNumbers);
return(apiResult);
}
public MiningDashboardPanel()
{
InitializeComponent();
var data = ApiQuery.GetBlocksHistory();
SetBlocksData(data);
}
public async Task <Player?> FetchPlayer(string username)
{
var query = new ApiQuery <Player>()
.Where("login", username)
.Limit(1);
var players = await _api.GetAsync(query);
return(players.FirstOrDefault());
}
/// <summary>
/// Queries all accounts.
/// </summary>
/// <param name="query">The query settings.</param>
/// <returns>An enumerable which contains all accounts.</returns>
public IEnumerable <Account> QueryAccounts(ApiQuery query)
{
var response = ApiHandler.CallAction <DefaultReturnObject>(Device, "/accounts/queryAccounts",
null,
JDownloaderHandler.LoginObject, true);
JArray tmp = (JArray)response.Data;
return(tmp.ToObject <IEnumerable <Account> >());
}
public async Task <Game?> FetchGame(long gameId)
{
var query = new ApiQuery <Game>()
.Where("id", gameId)
.Limit(1);
var games = await _api.GetAsync(query);
return(games.FirstOrDefault());
}
public void GetGameEnginesWildCard()
{
IgdbClient client = new IgdbClient(ApiKey);
ApiQuery query = ApiQuery.WildCard;
var engines = client.GetGameEngines(query);
Assert.IsNotNull(engines);
}
public async Task <Game?> FetchLastGame(string username)
{
var query = new ApiQuery <Game>()
.Where("playerStats.player.login", username)
.Sort("-startTime")
.Limit(1);
var games = await _api.GetAsync(query);
return(games.FirstOrDefault());
}
public override async Task <JsonResult> GetAll([FromQuery] ApiQuery queryOptions)
{
var query = ApplyFilters(data, queryOptions);
if (queryOptions.Include.HasValue && queryOptions.Include.Value)
{
query = query.Include(c => c.CharacterPassiveSkills)
.ThenInclude(c => c.PassiveSkill);
}
return(Json(await query.ToListAsync()));
}
public void GetGameEnginesOnlyNames()
{
IgdbClient client = new IgdbClient(ApiKey);
ApiQuery query = new ApiQuery();
query.Fields.Add("name");
var engines = client.GetGameEngines(query);
Assert.IsNotNull(engines);
}
private void barButtonItem1_ItemClick(object sender, ItemClickEventArgs e)
{
this.AddControlToMainPanel(this.reportControl);
this.reportControl.CreateReport(@"Credit", ApiQuery.GetCredits());
this.reportControl.CreateReport(@"Blocks History", ApiQuery.GetBlocksHistory());
this.reportControl.CreateReport($@"Network Stats", ApiQuery.GetNetworkStats());
this.reportControl.CreateReport($@"Server HashRate Stats", ApiQuery.GetServerHashRateStats());
//this.cmdControl.ExecuteAsync(@"X:\Development Projects\CozmicMinner\CozmicMinner\BatchFiles\Test.bat");
//this.cmdControl.ExecuteAsync(@"dir");
}
public async Task <ApiResult <IEnumerable <NoteFile> > > UploadFiles([FromServices] IRepository <NoteFile> repository,
Guid id, List <IFormFile> files)
{
List <Guid> uploadedFiles = new List <Guid>(files.Count);
foreach (IFormFile formFile in files)
{
uploadedFiles.Add((await _noteFileService.UploadFileAsync(id, formFile)).Id);
}
return(ApiResult.SuccessResult(await ApiQuery.GetItemsFromQueryAsync(
repository.Entities.Where(file => uploadedFiles.Contains(file.Id)), Guid.Empty, null)));
}
public void GetGameEnginesWhereIdIn()
{
const int someId = 583;
const int ueId = 203;
IgdbClient client = new IgdbClient(ApiKey);
ApiQuery query = ApiQuery.WildCard;
query.Predicate = $"id = ({someId},{ueId})";
var engines = client.GetGameEngines(query);
Assert.IsTrue(engines != null && engines.Count() == 2 && engines.Any(e => e.Id == someId || e.Id == ueId));
}
public async Task <IEnumerable <GameEngineLogo> > GetGameEngineLogosAsync(Action <ApiQueryBuilder> queryFactory)
{
if (queryFactory == null)
{
return(await GetGameEngineLogosAsync());
}
ApiQueryBuilder builder = new ApiQueryBuilder();
queryFactory.Invoke(builder);
ApiQuery query = builder.Build();
return(await GetGameEngineLogosAsync(query));
}
public IEnumerable <GameEngineLogo> GetGameEngineLogos(Action <ApiQueryBuilder> queryFactory)
{
if (queryFactory == null)
{
return(GetGameEngineLogos());
}
ApiQueryBuilder builder = new ApiQueryBuilder();
queryFactory.Invoke(builder);
ApiQuery query = builder.Build();
return(GetGameEngineLogos(query));
}
public async Task BadQueryTest()
{
var apiQuerier = new ApiQuerier(ApiKey);
var symbol = "bad_symbol";
var interval = "15min";
var query = new ApiQuery <object>(ApiFunction.TIME_SERIES_INTRADAY, new Dictionary <string, string>()
{
{ nameof(symbol), symbol },
{ nameof(interval), interval }
});
await Assert.ThrowsAsync <ApiQueryErrorException>(async() =>
{
var result = await apiQuerier.Query(query);
});
}
public async Task <TextSummary> ProcessText([FromBody] ApiQuery content)
// public async Task<Object> ProcessText([FromBody] Object content)
{
// Console.WriteLine($"Received Query: {content}");
// Console.WriteLine($"Received Query: {content.text}");
// Console.WriteLine($"Received Query: {content.queries}");
DBTextSummary text = null;
text = CorpusInventoryModel.GetTextWithID(content.text);
if (text == null)
{
text = await CorpusInventoryModel.ProcessNewText(content.text);
}
List <IQueryResult> results = CorpusInventoryModel.Query(content.queries, text.frequencyStructure, text.lengthsStructure);
return(new TextSummary(text.id, text.meta, text.wordsCount, text.uniqueWordsCount, text.mostFrequentWord, text.longestWord, text.leastFrequentWord, text.shortestWord, text.summaryDurationSec, results));
// return content;
}
public BaseModel <T> Post <T> (string url, ApiQuery data, bool ignoreHttpErrorrCode = false)
{
BaseModel <T> result = new BaseModel <T> ();
try {
var reqJson = data.ToJosnString();
var response = Post <T> (url, reqJson, "application/json", true);
if (response == null)
{
result.Failed("Server response null!");
}
else
{
result.Success("ok", response);
}
} catch (Exception ex) {
result.Failed(ex);
}
return(result);
}
private void ReloadResults()
{
if (_grid.Rows.Count > _grid.FixedRows)
{
_grid.Rows.RemoveRange(_grid.FixedRows, _grid.Rows.Count - _grid.FixedRows);
}
_resultSets.Clear();
LoadingForm.Show(this, async p =>
{
p.LoadingText = $"Loading {Constants.PageSize} results...";
_query = _api.CreateQuery(_entity);
_query.Filters.AddRange(_filters);
_query.Count = Constants.PageSize;
LoadResultSet(await _query.ExecuteReaderAsync());
});
}
public ApiResult InitClient(Key bitcoinPrivateKey)
{
if (TryInitTimestamp())
{
var modelIn = new ApiQuery();
modelIn.AddSignature(_timestamp, bitcoinPrivateKey);
var request = new RestRequest("me/InitClient", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddBody(modelIn);
var responseInit = _restClient.Execute <ApiResult>(request);
ApiResult result = responseInit.Data;
if (result != null && result.Status != null && result.Status.ResultCode == 0)
{
_timestamp = result.Status.Timestamp;
return(result);
}
}
return(null);
}
public void GetGameEnginesInvalidField()
{
IgdbClient client = new IgdbClient(ApiKey);
ApiQuery query = new ApiQuery();
query.Fields.Add("something");
string errorTitle = string.Empty;
try
{
var engines = client.GetGameEngines(query);
}
catch (IgdbClientBadStatusException ex)
{
errorTitle = ex?.ErrorInformation?.Title;
}
Assert.AreEqual("Invalid Field", errorTitle);
}
private ITrainRoute GetTrainRoute(IFavouriteRoute favouriteRoute)
{
var routeRepository = new RouteStopRepository();
var cachedTrainRoute = routeRepository.Find(favouriteRoute.FromId, favouriteRoute.ToId);
if (cachedTrainRoute != null) return cachedTrainRoute;
var stationRoutesQuery = new ApiQuery<Route>(_settingsProvider);
var routes = stationRoutesQuery.Query(string.Format("/query/station/{0}", favouriteRoute.FromId));
foreach (var route in routes)
{
var routeQuery = new ApiQuery<TrainRoute>(_settingsProvider);
var queryUri = string.Format("/query/date/{0}/route/{1}/from/{2}/to/{3}", route.Date, int.Parse(route.RouteNo),
favouriteRoute.FromId, favouriteRoute.ToId);
var trainRoutes = routeQuery.Query(queryUri);
if (trainRoutes.Any())
{
var trainRoute = trainRoutes.First();
if (!string.IsNullOrWhiteSpace(trainRoute.FromStation.StationName) &&
!string.IsNullOrWhiteSpace(trainRoute.ToStation.StationName))
routeRepository.Add(trainRoute);
return trainRoute;
}
}
return null;
}
public async Task <ActionResult <ResponseMessage <IEnumerable <HistorySaleView> > > > GetHistorySale([FromQuery] ApiQuery query)
{
if (query == null)
{
return(BadRequest());
}
var result = _context.HistorySaleView.OrderByDescending(x => x.RegDt).AsQueryable();
if (!string.IsNullOrEmpty(query.Filter))
{
result = result.Where(query.Filter);
}
if (!string.IsNullOrEmpty(query.OrderBy))
{
result = result.OrderBy(query.OrderBy);
}
if (query.Skip.HasValue)
{
result = result.Skip(query.Skip.Value);
}
if (query.Top.HasValue)
{
result = result.Take(query.Top.Value);
}
return(new ResponseMessage <IEnumerable <HistorySaleView> >()
{
entity = await result.ToListAsync(), TCount = _context.HistorySaleView.Count()
});
}
public T PostJson <T> (string url, ApiQuery data, bool ignoreHttpErrorrCode = false)
{
return(Post <T> (url, data.ToString(), "application/json", ignoreHttpErrorrCode));
}
private List<Station> GetRoutes()
{
var apiQuery = new ApiQuery<Station>(_settingsProvider);
return apiQuery.Query("/query/stations").ToList();
}
public async Task <ActionResult <ResponseMessage <IEnumerable <ProductIncoms> > > > GetProductIncoms([FromQuery] ApiQuery query)
{
if (query == null)
{
return(BadRequest());
}
var result = _context.ProductIncoms.OrderByDescending(x => x.RegDt).AsQueryable();
if (!string.IsNullOrEmpty(query.Filter))
{
result = result.Where(query.Filter);
}
if (!string.IsNullOrEmpty(query.OrderBy))
{
result = result.OrderBy(query.OrderBy);
}
if (query.Skip.HasValue)
{
result = result.Skip(query.Skip.Value);
}
if (query.Top.HasValue)
{
result = result.Take(query.Top.Value);
}
result = result.Select(x => new ProductIncoms
{
Id = x.Id,
Amount = x.Amount,
RegDt = x.RegDt,
SaleCost = x.SaleCost,
UserId = x.UserId,
SupplierId = x.SupplierId,
Kurs = x.Kurs,
ProductionDt = x.ProductionDt,
Comments = x.Comments,
OptCost = x.OptCost,
IncomeCost = x.IncomeCost,
ProductId = x.ProductId,
Product = new Products {
Id = x.Id, Name = x.Product.Name
},
IncomeNumber = x.IncomeNumber
});
return(new ResponseMessage <IEnumerable <ProductIncoms> >()
{
entity = await result.ToListAsync(), TCount = _context.ProductIncoms.Count()
});
}
