private async Task <TResult> GetSumAsync <TResult>(IQueryable <TResult> newSource)
{
var results = await GetStaticDataAsync <TResult>(x => EntityFrameworkQueryableExtensions.SumAsync((dynamic)x), newSource);
return(Enumerable.Sum((dynamic)results));
}
public Task <Dictionary <TKey, TElement> > ToDictionaryAsync <TSource, TKey, TElement>(
IQueryable <TSource> source,
Func <TSource, TKey> keySelector,
Func <TSource, TElement> elementSelector,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.ToDictionaryAsync(source, keySelector, elementSelector, token);
public Task <TSource> SingleOrDefaultAsync <TSource>(
IQueryable <TSource> source,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, token);
public Task <double?> SumAsync <TSource>(
IQueryable <TSource> source,
Expression <Func <TSource, double?> > selector,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.SumAsync(source, selector, token);
public Task <Dictionary <TKey, TSource> > ToDictionaryAsync <TSource, TKey>(
IQueryable <TSource> source,
Func <TSource, TKey> keySelector,
IEqualityComparer <TKey> comparer,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.ToDictionaryAsync(source, keySelector, comparer, token);
public Task <long> LongCountAsync <TSource>(
IQueryable <TSource> source,
Expression <Func <TSource, bool> > predicate,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.LongCountAsync(source, predicate, token);
public Task <TResult> MaxAsync <TSource, TResult>(
IQueryable <TSource> source,
Expression <Func <TSource, TResult> > selector,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.MaxAsync(source, selector, token);
public Task <T> FirstOrDefaultAsync <T>(IQueryable <T> query, Expression <Func <T, bool> > predicate)
{
return(EntityFrameworkQueryableExtensions.FirstOrDefaultAsync(query, predicate));
}
public Task <long> LongCountAsync <T>(IQueryable <T> query)
{
return(EntityFrameworkQueryableExtensions.LongCountAsync(query));
}
public Task <int> CountAsync <T>(IQueryable <T> query)
{
return(EntityFrameworkQueryableExtensions.CountAsync(query));
}
public Task <T> FirstOrDefaultAsync <T>(IQueryable <T> query)
{
return(EntityFrameworkQueryableExtensions.FirstOrDefaultAsync(query));
}
public IEnumerable <Broker> GetAllWithReferenceData()
{
return(EntityFrameworkQueryableExtensions.Include <Broker, ICollection <Exchange> >(context.Brokers, x => x.Exchanges).ThenInclude(y => y.Currency).ToList());
}
public static IQueryable <TEntity> Include <TEntity>(this IQueryable <TEntity> queryable, string prop) where TEntity : class
{
return(EntityFrameworkQueryableExtensions.Include <TEntity>(queryable, navigationPropertyPath: prop));
}
public static IQueryable <TEntity> Include <TEntity, TProperty>(this IQueryable <TEntity> queryable, Expression <Func <TEntity, TProperty> > predicate)
where TEntity : class
where TProperty : class
{
return(EntityFrameworkQueryableExtensions.Include <TEntity, TProperty>(queryable, predicate));
}
public Task <bool> ContainsAsync <TSource>(
IQueryable <TSource> source,
TSource item,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.ContainsAsync(source, item, token);
public Task <TResult> MinAsync <TSource, TResult>(IQueryable <TSource> source, Expression <Func <TSource, TResult> > selector)
{
return(EntityFrameworkQueryableExtensions.MinAsync(source, selector));
}
public Task <long> LongCountAsync <TSource>(
IQueryable <TSource> source,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.LongCountAsync(source, token);
public Task <T[]> ToArrayAsync <T>(IQueryable <T> query)
{
return(EntityFrameworkQueryableExtensions.ToArrayAsync(query));
}
public Task ForEachAsync <TSource>(
IQueryable <TSource> source,
Action <TSource> action,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.ForEachAsync(source, action, token);
public Task <List <T> > ToListAsync <T>(IQueryable <T> query)
{
return(EntityFrameworkQueryableExtensions.ToListAsync(query));
}
public Task <double?> SumAsync(
IQueryable <double?> source,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.SumAsync(source, token);
public Task <decimal?> AverageAsync <TSource>(IQueryable <TSource> source, Expression <Func <TSource, decimal?> > selector)
{
return(EntityFrameworkQueryableExtensions.AverageAsync(source, selector));
}
public Task <decimal?> AverageAsync(
IQueryable <decimal?> source,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.AverageAsync(source, token);
public Task <double> SumAsync <TSource>(IQueryable <TSource> source, Expression <Func <TSource, double> > selector)
{
return(EntityFrameworkQueryableExtensions.SumAsync(source, selector));
}
public Task <decimal?> AverageAsync <TSource>(
IQueryable <TSource> source,
Expression <Func <TSource, decimal?> > selector,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.AverageAsync(source, selector, token);
protected override async Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context)
{
//Get DbContext from DI container
DbContext db = (DbContext)context.HttpContext.RequestServices.GetService(DbContextType);
if (db == null)
{
throw new Exception("Database not found");
}
//Get DbSet as IQueryable
IQueryable query = (IQueryable)_dbContextSetMethod.MakeGenericMethod(ModelType).Invoke(db, null);
if (!string.IsNullOrEmpty(RawSql))
{
query = (IQueryable)RelationalQueryableExtensions.FromSql((dynamic)query, RawSql, RawSqlParameters);
}
if (!EnableChangeTracking)
{
query = (IQueryable)EntityFrameworkQueryableExtensions.AsNoTracking((dynamic)query);
}
if (context.SelectedOnly)
{
//Select by Id
var whereClause = DbContextHelper.SearchForEntityByValues(ModelType, DataValueField, context.CurrentValues);
query = (IQueryable)_dbContextWhereClauseMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, whereClause });
}
else
{
if (context.ModelExplorer.Metadata is DefaultModelMetadata defaultModelMetadata)
{
//Loop over where clauses
IEnumerable <SelectListDbWhereEqualsAttribute> whereClauseAttributes = null;
if (defaultModelMetadata.MetadataKind == ModelMetadataKind.Property)
{
whereClauseAttributes = defaultModelMetadata.Attributes.PropertyAttributes.OfType <SelectListDbWhereEqualsAttribute>().Where(a => a.SelectListId == this.SelectListId);
}
else if (defaultModelMetadata.MetadataKind == ModelMetadataKind.Type)
{
whereClauseAttributes = defaultModelMetadata.Attributes.TypeAttributes.OfType <SelectListDbWhereEqualsAttribute>().Where(a => a.SelectListId == this.SelectListId);
}
if (whereClauseAttributes != null)
{
foreach (var where in whereClauseAttributes)
{
var whereClause = LamdaHelper.SearchForEntityByProperty(ModelType, where.PropertyName, where.Values);
query = (IQueryable)_dbContextWhereClauseMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, whereClause });
}
}
}
}
//Order By
if (!string.IsNullOrWhiteSpace(OrderByProperty))
{
if (OrderByType == "asc")
{
query = (IQueryable)_dbContextOrderByMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, OrderByProperty, true });
}
else
{
query = (IQueryable)_dbContextOrderByMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, OrderByProperty, false });
}
}
//Skip
query = (IQueryable)Queryable.Skip((dynamic)query, Skip);
//Take
query = (IQueryable)Queryable.Take((dynamic)query, Take);
//Get Results
IEnumerable results = (IEnumerable)(await EntityFrameworkQueryableExtensions.ToListAsync((dynamic)query, CancellationToken.None));
return(new ModelMultiSelectList(context.Html, results, DataValueField, DataTextFieldExpression));
}
public Task <TSource> FirstAsync <TSource>(
IQueryable <TSource> source,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.FirstAsync(source, token);
public async Task UpdateSde(bool tq = false)
{
MarketDB db = tq ? (MarketDB)_tqdb : _cndb;
ESIClient esi = tq ? (ESIClient)_tqesi : _esi;
var oldgroups = await EntityFrameworkQueryableExtensions.ToListAsync(db.marketgroup);
var attr = esi.GetAllAttrs();
var allmarketgroupstask = esi.Get_markets_groupsAsync();
var alltypetask = GetAllTypeAsync(tq);
var newmodels = new ConcurrentBag <EVEMarketSite.Model.marketgroup>();
var oldattr = await EntityFrameworkQueryableExtensions.ToListAsync(db.dogma_attributes);
foreach (var m in await attr)
{
var model = oldattr.FirstOrDefault(p => p.attribute_id == m.Attribute_id);
if (model == null)
{
model = new dogma_attributes();
db.dogma_attributes.Add(model);
}
model.attribute_id = m.Attribute_id;
model.name = m.Name;
model.description = m.Description;
model.default_value = m.Default_value;
model.display_name = m.Display_name;
model.high_is_good = m.High_is_good;
model.icon_id = m.Icon_id;
model.published = m.Published;
model.stackable = m.Stackable;
model.unit_id = m.Unit_id;
}
List <marketgroup> cnMarketgroups = new List <marketgroup>();
List <evetypes> cntypes = new List <evetypes>();
if (tq)
{
cnMarketgroups = await _cndb.marketgroup.ToListAsync();
cntypes = await _cndb.evetypes.ToListAsync();
}
await Dasync.Collections.ParallelForEachExtensions.ParallelForEachAsync((await allmarketgroupstask).Distinct(), async i =>
{
while (true)
{
try
{
var groupinfo_en = esi.Get_markets_groups_market_group_idAsync("en-us", i);
Task <Get_markets_groups_market_group_id_ok> groupinfo_cn;
if (!tq)
{
groupinfo_cn = esi.Get_markets_groups_market_group_idAsync("zh", i);
}
else
{
var tmp = cnMarketgroups.FirstOrDefault(p => p.marketGroupID == i);
if (tmp != null)
{
groupinfo_cn = Task.FromResult(new Get_markets_groups_market_group_id_ok()
{
Name = tmp.marketGroupName,
Description = tmp.description,
});
}
else
{
groupinfo_cn = groupinfo_en;
}
}
await Task.WhenAll(groupinfo_cn, groupinfo_en);
_logger.LogDebug($"GetItemMarketGroupInfoV1Async {i}");
var oldmodel = oldgroups.FirstOrDefault(p => p.marketGroupID == i);
if (oldmodel == null)
{
oldmodel = new marketgroup();
oldmodel.marketGroupID = i;
newmodels.Add(oldmodel);
}
oldmodel.marketGroupName_en = groupinfo_en.Result.Name;
oldmodel.marketGroupName = groupinfo_cn.Result.Name;
oldmodel.description = groupinfo_cn.Result.Description;
oldmodel.description_en = groupinfo_en.Result.Description;
oldmodel.parentGroupID = groupinfo_en.Result.Parent_group_id;
return;
}
catch (Exception e)
{
await Task.Delay(TimeSpan.FromSeconds(1));
_logger.LogWarning(e + "");
}
}
}, MAX_THREAD);
db.marketgroup.AddRange(newmodels);
_logger.LogDebug($"Save GetMarketItemGroupInfo");
await db.SaveChangesAsync();
_logger.LogDebug($"Save GetMarketItemGroupInfo OK");
await db.SaveChangesAsync();
var oldtypes = await EntityFrameworkQueryableExtensions.ToListAsync(db.evetypes);
var oldtypeattr = await EntityFrameworkQueryableExtensions.ToListAsync(db.type_attributes);
var newtypes = new ConcurrentBag <evetypes>();
var newtypeattrs = new ConcurrentBag <type_attributes>();
await Dasync.Collections.ParallelForEachExtensions.ParallelForEachAsync(await alltypetask, async i =>
{
try
{
var groupinfo_en = esi.Get_universe_types_type_idAsync("en-us", i);
Task <Get_universe_types_type_id_ok> groupinfo_cn;
if (!tq)
{
groupinfo_cn = esi.Get_universe_types_type_idAsync("zh", i);
}
else
{
var tmp = cntypes.FirstOrDefault(p => p.typeID == i);
if (tmp != null)
{
groupinfo_cn = Task.FromResult(new Get_universe_types_type_id_ok()
{
Name = tmp.typeName,
Description = tmp.description,
});
}
else
{
groupinfo_cn = groupinfo_en;
}
}
await Task.WhenAll(groupinfo_cn, groupinfo_en);
_logger.LogDebug($"GetTypeInfoV3Async {i}");
var oldmodel = oldtypes.FirstOrDefault(p => p.typeID == i);
if (oldmodel == null)
{
oldmodel = new evetypes();
oldmodel.typeID = i;
newtypes.Add(oldmodel);
}
oldmodel.marketGroupID = groupinfo_en.Result.Market_group_id;
oldmodel.portionSize = groupinfo_en.Result.Portion_size;
oldmodel.published = groupinfo_en.Result.Published;
oldmodel.mass = groupinfo_en.Result.Mass;
oldmodel.capacity = groupinfo_en.Result.Capacity;
oldmodel.iconID = groupinfo_en.Result.Icon_id;
oldmodel.volume = groupinfo_en.Result.Volume;
oldmodel.typeName_en = groupinfo_en.Result.Name;
oldmodel.typeName = groupinfo_cn.Result.Name;
oldmodel.description = groupinfo_cn.Result.Description;
oldmodel.description_en = groupinfo_en.Result.Description;
oldmodel.groupID = groupinfo_en.Result.Group_id;
oldmodel.attributes.Clear();
if (groupinfo_cn.Result.Dogma_attributes?.Count > 0)
{
foreach (var resultDogmaAttribute in groupinfo_cn.Result.Dogma_attributes)
{
newtypeattrs.Add(new type_attributes()
{
attribute_id = resultDogmaAttribute.Attribute_id,
value = resultDogmaAttribute.Value,
type_id = i
});
}
}
}
catch (Exception e)
{
await Task.Delay(TimeSpan.FromSeconds(1));
_logger.LogWarning(e + "");
}
}, MAX_THREAD);
db.evetypes.AddRange(newtypes);
await db.SaveChangesAsync();
db.type_attributes.RemoveRange(db.type_attributes);
db.AddRange(newtypeattrs);
await db.SaveChangesAsync();
var http = _httpClientFactory.CreateClient("CN");
db.InvMetaTypes.RemoveRange(db.InvMetaTypes);
await using var bz2file1 = await http.GetStreamAsync("https://www.fuzzwork.co.uk/dump/latest/invMetaTypes.csv.bz2");
await using var fs = new MemoryStream();
BZip2.Decompress(bz2file1, fs, false);
fs.Seek(0, SeekOrigin.Begin);
using var textreader = new StreamReader(fs);
await textreader.ReadLineAsync(); //ignore 1st
var r = await textreader.ReadLineAsync();
while (r != null)
{
var imp = r.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var newmodel = new invMetaTypes();
newmodel.typeID = int.Parse(imp[0]);
if (imp[1] == "None")
{
newmodel.parentTypeID = null;
}
else
{
newmodel.parentTypeID = int.Parse(imp[1]);
}
if (imp[2] == "None")
{
newmodel.metaGroupID = null;
}
else
{
newmodel.metaGroupID = int.Parse(imp[2]);
}
db.InvMetaTypes.Add(newmodel);
r = await textreader.ReadLineAsync(); //ignore 1st
}
await db.SaveChangesAsync();
_logger.LogInformation("完成!");
}
public Task <TSource> SingleOrDefaultAsync <TSource>(
IQueryable <TSource> source,
Expression <Func <TSource, bool> > predicate,
CancellationToken token)
=> EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, predicate, token);
private async Task <int> GetCountAsync(IQueryable newSource)
{
var results = await GetStaticDataAsync <int>(x => EntityFrameworkQueryableExtensions.CountAsync((dynamic)x), newSource);
return(results.Sum());
}
