public override sealed async Task <object> EventManyAsync(Query <TModel> query)
{
var appenedQuery = new Query <TModel>(query);
OnQuery(appenedQuery.Graph);
var where = AppendWhereExpression(appenedQuery.Where, appenedQuery.Graph);
appenedQuery.Where = where;
var eventModels = (ICollection <EventModel <TModel> >)(await NextProvider.QueryAsync(appenedQuery));
var models = eventModels.Select(x => x.Model).ToArray();
ICollection <EventModel <TModel> > returnEventModels = null;
if (models.Length > 0)
{
var returnModels = OnGet(models, appenedQuery.Graph);
returnEventModels = returnEventModels.Where(x => returnModels.Contains(x.Model)).ToArray();
}
else
{
returnEventModels = Array.Empty <EventModel <TModel> >();
}
return(returnEventModels);
}
public override sealed object EventMany(Query <TModel> query)
{
var whereCompressed = EncryptWhere(query.Where);
var orderCompressed = EncryptOrder(query.Order);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
appenedQuery.Order = orderCompressed;
var eventModels = (ICollection <EventModel <TModel> >)(NextProvider.Query(appenedQuery));
if (eventModels.Count == 0)
{
return(eventModels);
}
var encryptedModels = eventModels.Select(x => x.Model).ToArray();
var models = DecryptModels(encryptedModels, query.Graph, true);
int i = 0;
foreach (var eventModel in eventModels)
{
eventModel.Model = encryptedModels[i];
i++;
}
return(eventModels);
}
public override sealed async Task <object> EventManyAsync(Query <TModel> query)
{
var whereCompressed = CompressWhere(query.Where);
var orderCompressed = CompressOrder(query.Order);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
appenedQuery.Order = orderCompressed;
var eventModels = (ICollection <EventModel <TModel> >)(await NextProvider.QueryAsync(appenedQuery));
if (eventModels.Count == 0)
{
return(eventModels);
}
var compressedModels = eventModels.Select(x => x.Model).ToArray();
var models = DecompressModels(compressedModels, query.Graph, true);
int i = 0;
foreach (var eventModel in eventModels)
{
eventModel.Model = compressedModels[i];
i++;
}
return(eventModels);
}
public override void DoTask(TasksToDo task)
{
//ActionModel model = new ActionModel();
if (task == TasksToDo.DownloadSingleAction)
{
try
{
actionModel = GetSingleAction(DownloadActionName);
}
catch (Exception)
{
NextProvider.DoTask(task);
}
if (actionModel.Name != null)
{
Console.WriteLine($"Information downloaded from {ProviderName}");
Console.WriteLine($"Action name: {actionModel.Name} Date: {actionModel.Date} Maximum Price: {actionModel.MaximumPrice} Open Price: {actionModel.OpenPrice} Close Price: {actionModel.MinPrice} TKO: {actionModel.Tko} Trading Volume: {actionModel.TradingVolume}");
Logger.Instance.AppendLoggerMessage($"Information downloaded from: {ProviderName} Action Name: {actionModel.Name}");
}
else
{
Console.WriteLine($"ERROR - {ProviderName} - dont have any information about this action or server not response");
Logger.Instance.AppendLoggerMessage($"ERROR - {ProviderName} - dont have any information about this action or server not response");
NextProvider.DoTask(task);
}
}
else if (NextProvider != null)
{
NextProvider.DoTask(task);
}
}
public override sealed async Task UpdateAsync(Persist <TModel> persist)
{
var appenedPersist = new Persist <TModel>(persist);
ICollection <TModel> returnModels = OnUpdate(appenedPersist.Models, appenedPersist.Graph);
await NextProvider.PersistAsync(new Update <TModel>(appenedPersist.Event, returnModels, appenedPersist.Graph));
OnUpdateComplete(returnModels, appenedPersist.Graph);
}
public Task <object> QueryAsync(Query <TModel> query)
{
if (query.IsTemporal)
{
return(ThisProvider.QueryAsync(query));
}
else
{
return(NextProvider.QueryAsync(query));
}
}
public object Query(Query <TModel> query)
{
if (query.IsTemporal)
{
return(ThisProvider.Query(query));
}
else
{
return(NextProvider.Query(query));
}
}
public override sealed void Update(Persist <TModel> persist)
{
if (persist.Models.Length == 0)
{
return;
}
ICollection <TModel> compressedModels = CompressModels(persist.Models, persist.Graph, true);
NextProvider.Persist(new Update <TModel>(persist.Event, compressedModels, persist.Graph));
}
public override sealed Task UpdateAsync(Persist <TModel> persist)
{
if (persist.Models.Length == 0)
{
return(Task.CompletedTask);
}
ICollection <TModel> compressedModels = CompressModels(persist.Models, persist.Graph, true);
return(NextProvider.PersistAsync(new Update <TModel>(persist.Event, compressedModels, persist.Graph)));
}
public override sealed Task <object> AnyAsync(Query <TModel> query)
{
var whereCompressed = CompressWhere(query.Where);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
var any = NextProvider.QueryAsync(appenedQuery);
return(any);
}
public override sealed Task <object> CountAsync(Query <TModel> query)
{
var whereCompressed = EncryptWhere(query.Where);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
var count = NextProvider.QueryAsync(appenedQuery);
return(count);
}
public override sealed object Any(Query <TModel> query)
{
var whereCompressed = EncryptWhere(query.Where);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
var any = NextProvider.Query(appenedQuery);
return(any);
}
public override sealed object Count(Query <TModel> query)
{
var whereCompressed = CompressWhere(query.Where);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
var count = NextProvider.Query(appenedQuery);
return(count);
}
public override sealed Task <object> AnyAsync(Query <TModel> query)
{
var appenedQuery = new Query <TModel>(query);
OnQuery(appenedQuery.Graph);
var where = AppendWhereExpression(appenedQuery.Where, appenedQuery.Graph);
appenedQuery.Where = where;
var any = NextProvider.QueryAsync(appenedQuery);
return(any);
}
public override sealed void Create(Persist <TModel> persist)
{
if (persist.Models.Length == 0)
{
return;
}
TModel[] encryptedModels = EncryptModels(persist.Models, persist.Graph, true);
NextProvider.Persist(new Create <TModel>(encryptedModels, persist.Graph));
for (var i = 0; i < persist.Models.Length; i++)
{
object identity = ModelAnalyzer.GetIdentity(encryptedModels[i]);
ModelAnalyzer.SetIdentity(persist.Models[i], identity);
}
}
public override sealed async Task CreateAsync(Persist <TModel> persist)
{
if (persist.Models.Length == 0)
{
return;
}
TModel[] compressedModels = CompressModels(persist.Models, persist.Graph, true);
await NextProvider.PersistAsync(new Create <TModel>(persist.Event, compressedModels, persist.Graph));
for (var i = 0; i < persist.Models.Length; i++)
{
object identity = ModelAnalyzer.GetIdentity(compressedModels[i]);
ModelAnalyzer.SetIdentity(persist.Models[i], identity);
}
}
public override void DoTask(TasksToDo task)
{
if (task == TasksToDo.DownloadSingleAction)
{
HtmlDocument html = DownloadHtml(url);
var model = GetSingleAction(DownloadActionName, html);
Console.WriteLine($"Information downloaded from {ProviderName}");
Console.WriteLine($"Action name: {model.Name} Date: {model.Date} Maximum Price: {model.MaximumPrice} Open Price: {model.OpenPrice} Close Price: {model.MinPrice} TKO: {model.Tko} Trading Volume: {model.TradingVolume}");
Logger.Instance.AppendLoggerMessage($"Information downloaded from: {ProviderName} Action Name: {model.Name}");
}
else if (NextProvider != null)
{
NextProvider.DoTask(task);
Logger.Instance.AppendLoggerMessage($"ERROR - {ProviderName} - dont have any information about this action or server not response");
}
}
public override sealed async Task <object> SingleAsync(Query <TModel> query)
{
var whereCompressed = EncryptWhere(query.Where);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
var encryptedModels = (TModel)(await NextProvider.QueryAsync(appenedQuery));
if (encryptedModels == null)
{
return(null);
}
var model = DecryptModels(new TModel[] { encryptedModels }, query.Graph, true).FirstOrDefault();
return(model);
}
public override sealed object Single(Query <TModel> query)
{
var whereCompressed = EncryptWhere(query.Where);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
var encryptedModels = (TModel)(NextProvider.Query(appenedQuery));
if (encryptedModels == null)
{
return(null);
}
var model = DecryptModel(encryptedModels, query.Graph, true);
return(model);
}
public override sealed async Task <object> SingleAsync(Query <TModel> query)
{
var whereCompressed = CompressWhere(query.Where);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
var compressedModels = (TModel)(await NextProvider.QueryAsync(appenedQuery));
if (compressedModels == null)
{
return(null);
}
var model = DecompressModel(compressedModels, query.Graph, true);
return(model);
}
public override sealed async Task <object> SingleAsync(Query <TModel> query)
{
var appenedQuery = new Query <TModel>(query);
OnQuery(appenedQuery.Graph);
var where = AppendWhereExpression(appenedQuery.Where, appenedQuery.Graph);
appenedQuery.Where = where;
var model = (TModel)(await NextProvider.QueryAsync(appenedQuery));
TModel returnModel = null;
if (model != null)
{
returnModel = OnGet(new TModel[] { model }, appenedQuery.Graph).SingleOrDefault();
}
return(returnModel);
}
public override sealed object Many(Query <TModel> query)
{
var whereCompressed = EncryptWhere(query.Where);
var orderCompressed = EncryptOrder(query.Order);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
appenedQuery.Order = orderCompressed;
var encryptedModels = (ICollection <TModel>)(NextProvider.Query(appenedQuery));
if (encryptedModels.Count == 0)
{
return(encryptedModels);
}
var models = DecryptModels(encryptedModels, query.Graph, true);
return(models);
}
public override sealed async Task <object> ManyAsync(Query <TModel> query)
{
var whereCompressed = CompressWhere(query.Where);
var orderCompressed = CompressOrder(query.Order);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
appenedQuery.Order = orderCompressed;
var compressedModels = (ICollection <TModel>)(await NextProvider.QueryAsync(appenedQuery));
if (compressedModels.Count == 0)
{
return(compressedModels);
}
var models = DecompressModels(compressedModels, query.Graph, true);
return(models);
}
public override sealed object First(Query <TModel> query)
{
var whereCompressed = CompressWhere(query.Where);
var orderCompressed = CompressOrder(query.Order);
var appenedQuery = new Query <TModel>(query);
appenedQuery.Where = whereCompressed;
appenedQuery.Order = orderCompressed;
var compressedModels = (TModel)(NextProvider.Query(appenedQuery));
if (compressedModels == null)
{
return(null);
}
var model = DecompressModel(compressedModels, query.Graph, true);
return(model);
}
public override sealed async Task DeleteAsync(Persist <TModel> persist)
{
ICollection returnIds;
if (persist.IDs != null)
{
returnIds = OnDelete(persist.IDs);
}
else
{
List <object> ids = new List <object>();
foreach (TModel model in persist.Models)
{
ids.Add(ModelAnalyzer.GetIdentity <TModel>(model));
}
returnIds = OnDelete(ids);
}
await NextProvider.PersistAsync(new DeleteByID <TModel>(persist.Event, returnIds));
OnDeleteComplete(returnIds);
}
public override sealed async Task <object> ManyAsync(Query <TModel> query)
{
var appenedQuery = new Query <TModel>(query);
OnQuery(appenedQuery.Graph);
var where = AppendWhereExpression(appenedQuery.Where, appenedQuery.Graph);
appenedQuery.Where = where;
var models = (ICollection <TModel>)(await NextProvider.QueryAsync(appenedQuery));
ICollection <TModel> returnModels;
if (models.Count > 0)
{
returnModels = OnGet(models, appenedQuery.Graph);
}
else
{
returnModels = Array.Empty <TModel>();
}
return(returnModels);
}
public async Task SaveAsync(string name, Stream stream)
{
var resultStream = await OnSaveAsync(stream);
await NextProvider.SaveAsync(name, resultStream);
}
public async Task <Stream> GetAsync(string name)
{
var stream = await NextProvider.GetAsync(name);
return(await OnGetAsync(stream));
}
public Task <bool> ExistsAsync(string name)
{
return(NextProvider.ExistsAsync(name));
}
public void Save(string name, Stream stream)
{
var resultStream = OnSave(stream);
NextProvider.Save(name, resultStream);
}
