/// <summary>
/// Método responsável por realizar uma query (filtro, ordenação e projeção)
/// </summary>
/// <typeparam name="T">entidade</typeparam>
/// <param name="source">fonte de dados</param>
/// <param name="query">parametros para realização da consulta</param>
/// <returns>retorna a query executada</returns>
public static IQueryable ProjectedQuery <T>(this IQueryable <T> source, ResourceQueryFilter query)
where T : class
{
return(source.Filter(query.Filters)
.Sort(query.Sorts)
.Project(query.Fields.ToArray()));
}
public static DynamicSql SqlJoin(
this DynamicSql query, ResourceQueryProjection model,
ResourceQueryFilter filter)
{
query = DynamicSql.DeepClone(query);
var joins = model.GetFieldsArr()
.Where(f => ResourceQueryProjection.Joins.ContainsKey(f))
.Select(f => ResourceQueryProjection.Joins[f]);
if (joins.Any())
{
var joinClause = string.Join('\n', joins);
query.DynamicForm = query.DynamicForm
.Replace(DynamicSql.JOIN, joinClause);
if (filter != null)
{
var contentFilters = new List <string>();
if (filter.lang != null)
{
var paramName = query.AddAutoIncrParam(filter.lang);
var resourceContentLang = $"{nameof(ResourceContent)}.{nameof(ResourceContent.Lang)}";
contentFilters.Add($"{resourceContentLang}=@{paramName}");
}
if (contentFilters.Any())
{
var whereClause = "WHERE " + string.Join(" AND ", contentFilters);
query.DynamicForm = query.DynamicForm
.Replace(ResourceQueryPlaceholder.RES_CONTENT_FILTER, whereClause);
}
}
}
return(query);
}
public async Task <ListResourcesRes> ListResources(ResourceQueryFilter resourceQueryFilter, CancellationToken cancellation = default)
{
var res = await client.Host.AppendPathSegment("api/v2/resources").WithOAuthBearerToken(client.Token).SetQueryParams(
new Dictionary <string, object>
{
{
"namespace",
resourceQueryFilter.NameSpace
},
{
"type",
resourceQueryFilter.Type
},
{
"limit",
resourceQueryFilter.Limit
},
{
"page",
resourceQueryFilter.Page
}
}
).GetJsonAsync <ListResourcesRes>(cancellation);
return(res);
}
public async Task <IActionResult> Get([FromQuery] ResourceQueryFilter filter,
[FromQuery] ResourceQuerySort sort,
[FromQuery] ResourceQueryProjection projection,
[FromQuery] ResourceQueryPaging paging,
[FromQuery] ResourceQueryOptions options)
{
var validationResult = _service.ValidateGetResources(
User, filter, sort, projection, paging, options);
if (!validationResult.Valid)
{
return(BadRequest(validationResult.Result));
}
var result = await _service.QueryResourceDynamic(
projection, options, filter, sort, paging);
if (options.single_only)
{
if (result == null)
{
return(NotFound(new AppResultBuilder().NotFound()));
}
return(Ok(new AppResultBuilder().Success(result.SingleResult)));
}
return(Ok(new AppResultBuilder().Success(result)));
}
public async Task <QueryResult <IDictionary <string, object> > > QueryResourceDynamic(
ResourceQueryProjection projection,
ResourceQueryOptions options,
ResourceQueryFilter filter = null,
ResourceQuerySort sort = null,
ResourceQueryPaging paging = null)
{
var query = Resources;
#region General
if (filter != null)
{
query = query.Filter(filter);
}
query = query.Project(projection);
int?totalCount = null;
if (options.count_total)
{
totalCount = query.Count();
}
#endregion
if (!options.single_only)
{
#region List query
if (sort != null)
{
query = query.Sort(sort);
}
if (paging != null && (!options.load_all || !ResourceQueryOptions.IsLoadAllAllowed))
{
query = query.SelectPage(paging.page, paging.limit);
}
#endregion
}
if (options.single_only)
{
var single = query.SingleOrDefault();
if (single == null)
{
return(null);
}
var singleResult = GetResourceDynamic(single, projection, options);
return(new QueryResult <IDictionary <string, object> >()
{
Single = singleResult
});
}
var entities = query.ToList();
var list = GetResourceDynamic(entities, projection, options);
var result = new QueryResult <IDictionary <string, object> >();
result.List = list;
if (options.count_total)
{
result.Count = totalCount;
}
return(result);
}
/// <inheritdoc />
public ResourceModel[] GetResources(ResourceQuery query)
{
var filter = new ResourceQueryFilter(query, TypeTree);
var resources = Graph.GetResources <Resource>(filter.Match).ToArray();
var converter = new ResourceQueryConverter(TypeTree, Serialization, query);
return(converter.QueryConversion(resources));
}
public ActionResult <ResourceModel[]> GetResources(ResourceQuery query)
{
var filter = new ResourceQueryFilter(query, _resourceTypeTree);
var resourceProxies = _resourceModification.GetAllResources <IResource>(r => filter.Match(r as Resource)).ToArray();
var converter = new ResourceQueryConverter(_resourceTypeTree, _serialization, query);
var values = resourceProxies.Select(p => _resourceModification.Read(p.Id, r => converter.QueryConversion(r))).ToArray();
return(values);
}
public ValidationData ValidateGetResources(
ClaimsPrincipal principal,
ResourceQueryFilter filter,
ResourceQuerySort sort,
ResourceQueryProjection projection,
ResourceQueryPaging paging,
ResourceQueryOptions options)
{
return(new ValidationData());
}
public static IQueryable <Resource> Filter(
this IQueryable <Resource> query, ResourceQueryFilter filter)
{
if (filter.id != null)
{
query = query.Where(o => o.Id == filter.id);
}
if (filter.name_contains != null)
{
query = query.Where(o => o.Name.Contains(filter.name_contains));
}
return(query);
}
public QueryResult QueryResourceList(ResourceQueryFilter request)
{
if (request == null)
{
throw new BizException(ResouceManager.GetMessageString("IM.ProductResource", "ProductGroupSysNoIsNull"));
}
int totalCount;
var dataTable = ObjectFactory <IResourceQueryDA> .Instance.QueryResourceList(request, out totalCount);
return(new QueryResult
{
Data = dataTable,
TotalCount = dataTable != null && dataTable.Rows != null ? dataTable.Rows.Count : 0
});
}
/// <summary>
/// 获取商品资源文件信息
/// </summary>
/// <param name="queryCriteria"></param>
/// <param name="totalCount"></param>
/// <returns></returns>
public DataTable QueryResourceList(ResourceQueryFilter queryCriteria, out int totalCount)
{
totalCount = 0;
if (queryCriteria.CommonSKUNumberList == null || queryCriteria.CommonSKUNumberList.Count == 0)
{
return(null);
}
var commonSKUNumbers = "'" + queryCriteria.CommonSKUNumberList.Join("','") + "'";
CustomDataCommand dataCommand = DataCommandManager.CreateCustomDataCommandFromConfig("QueryResourceList");
dataCommand.SetParameterValue("@CommonSKUNumberList", commonSKUNumbers);
dataCommand.SetParameterValue("@SortField", queryCriteria.PagingInfo.SortBy);
var dt = dataCommand.ExecuteDataTable();
return(dt);
}
/// <summary>
/// Método responsável por realizar o bind dos parametros da querystring para a classe <see cref="QueryFilter" />
/// </summary>
/// <param name="bindingContext">bind contendo os dados da requisição</param>
/// <returns>retorna uma instância de <see cref="QueryFilter" /></returns>
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext.ModelType != typeof(ResourceQueryFilter))
{
throw new ArgumentNullException(nameof(bindingContext));
}
var nameValueCollection = HttpUtility.ParseQueryString(bindingContext.HttpContext.Request.QueryString.Value);
var queryFilter = new ResourceQueryFilter(
GetFilter(nameValueCollection),
nameValueCollection[QueryFilterOptions.OrderByQueryAlias],
nameValueCollection[QueryFilterOptions.SelectFieldsQueryAlias],
GetPaging(nameValueCollection));
bindingContext.Result = ModelBindingResult.Success(queryFilter);
return(Task.CompletedTask);
}
public static DynamicSql SqlFilter(
this DynamicSql query, ResourceQueryFilter filter)
{
query = DynamicSql.DeepClone(query);
var listFilters = new List <string>();
if (filter.id != null)
{
var paramName = query.AddAutoIncrParam(filter.id);
listFilters.Add($"{nameof(Resource)}.{nameof(Resource.Id)}=@{paramName}");
}
if (filter.archived != 2)
{
var paramName = query.AddAutoIncrParam(filter.archived);
listFilters.Add($"{nameof(Resource)}.{nameof(Resource.Archived)}=@{paramName}");
}
if (filter.name_contains != null)
{
var paramName = query.AddAutoIncrParam(filter.name_contains);
listFilters.Add($"CHARINDEX(@{paramName}, {nameof(ResourceContent)}" +
$".{nameof(ResourceContent.Name)}) > 0");
}
if (filter.owner_id != null)
{
var paramName = query.AddAutoIncrParam(filter.owner_id);
listFilters.Add($"{nameof(Resource)}.{nameof(Resource.OwnerId)}=@{paramName}");
}
if (filter.loc_id != null)
{
var paramName = query.AddAutoIncrParam(filter.loc_id);
listFilters.Add($"{nameof(Resource)}.{nameof(Resource.LocationId)}=@{paramName}");
}
if (filter.area_id != null)
{
var paramName = query.AddAutoIncrParam(filter.area_id);
listFilters.Add($"{nameof(Resource)}.{nameof(Resource.AreaId)}=@{paramName}");
}
if (listFilters.Any())
{
var whereClause = "WHERE " + string.Join(" AND ", listFilters);
query.DynamicForm = query.DynamicForm.Replace(DynamicSql.FILTER, whereClause);
}
return(query);
}
public async Task <IActionResult> Get([FromQuery][QueryObject] ResourceQueryFilter filter,
[FromQuery] ResourceQuerySort sort,
[FromQuery] ResourceQueryProjection projection,
[FromQuery] ResourceQueryPaging paging,
[FromQuery] ResourceQueryOptions options)
{
var validationData = _service.ValidateGetResources(
User, filter, sort, projection, paging, options);
if (!validationData.IsValid)
{
return(BadRequest(AppResult.FailValidation(data: validationData)));
}
var result = await _service.QueryResourceDynamic(
projection, options, filter, sort, paging);
if (options.single_only && result == null)
{
return(NotFound(AppResult.NotFound()));
}
return(Ok(AppResult.Success(result)));
}
public static DynamicSql SqlExtras(
this DynamicSql query, ResourceQueryProjection model,
ResourceQueryFilter filter)
{
query = DynamicSql.DeepClone(query);
var extras = model.GetFieldsArr()
.Where(f => ResourceQueryProjection.Extras.ContainsKey(f))
.Select(f => ResourceQueryProjection.Extras[f]);
if (extras.Any())
{
var extraSqls = string.Join(';', extras);
var originalQuery = query.PreparedViewForm;
query.DynamicForm += ";\n" + extraSqls;
query.DynamicForm = query.DynamicForm
.Replace(ResourceQueryPlaceholder.RES_SUB_QUERY, originalQuery);
if (filter != null)
{
if (model.fields.Contains(ResourceQueryProjection.CATEGORIES))
{
var contentFilters = new List <string>();
if (filter.lang != null)
{
var paramName = query.AddAutoIncrParam(filter.lang);
var ecLang = $"{nameof(EntityCategoryContent)}.{nameof(EntityCategoryContent.Lang)}";
contentFilters.Add($"{ecLang}=@{paramName}");
}
if (contentFilters.Any())
{
var whereClause = "WHERE " + string.Join(" AND ", contentFilters);
query.DynamicForm = query.DynamicForm
.Replace(ResourceQueryPlaceholder.CATE_CONTENT_FILTER, whereClause);
}
}
}
}
return(query);
}
/// <summary>
/// 查询商品组信息
/// </summary>
/// <param name="model"></param>
/// <param name="sortField"></param>
/// <param name="callback"></param>
public void QueryResources(ProductResourcesQueryVM model, string sortField, EventHandler <RestClientEventArgs <dynamic> > callback)
{
var filter = new ResourceQueryFilter();
filter.CommonSKUNumberList = model.CommonSKUNumberList;
filter.PagingInfo = new PagingInfo
{
SortBy = sortField
};
_restClient.QueryDynamicData(QueryUrl, filter,
(obj, args) =>
{
if (args.FaultsHandle())
{
return;
}
callback(obj, args);
}
);
}
public async Task <ListResourcesRes> GetResources(ResourceQueryFilter resourceQueryFilter, CancellationToken cancellationToken = default)
{
var res = await ListResources(resourceQueryFilter, cancellationToken);
return(res);
}
public async Task <QueryResult <ResourceQueryRow> > QueryResource(
ResourceQueryFilter filter = null,
ResourceQuerySort sort = null,
ResourceQueryProjection projection = null,
ResourceQueryPaging paging = null,
ResourceQueryOptions options = null)
{
var conn = context.Database.GetDbConnection();
var openConn = conn.OpenAsync();
var query = ResourceQuery.CreateDynamicSql();
#region General
if (filter != null)
{
query = query.SqlFilter(filter);
}
if (projection != null)
{
query = query.SqlJoin(projection, filter);
}
DynamicSql countQuery = null; int?totalCount = null; Task <int> countTask = null;
if (options != null && options.count_total)
{
countQuery = query.SqlCount("*");
}
if (projection != null)
{
query = query.SqlProjectFields(projection);
}
#endregion
await openConn;
if (options != null && !options.single_only)
{
#region List query
if (sort != null)
{
query = query.SqlSort(sort);
}
if (paging != null && (!options.load_all || !ResourceQueryOptions.IsLoadAllAllowed))
{
query = query.SqlSelectPage(paging.page, paging.limit);
}
#endregion
#region Count query
if (options.count_total)
{
countTask = conn.ExecuteScalarAsync <int>(
sql: countQuery.PreparedForm,
param: countQuery.DynamicParameters);
}
#endregion
}
if (projection != null)
{
query = query.SqlExtras(projection, filter);
}
var multipleResult = await conn.QueryMultipleAsync(
sql : query.PreparedForm,
param : query.DynamicParameters);
using (multipleResult)
{
var queryResult = multipleResult.Read(
types: query.GetTypesArr(),
map: (objs) => ProcessMultiResults(query, objs),
splitOn: string.Join(',', query.GetSplitOns()));
if (projection != null)
{
var extraKeys = projection.GetFieldsArr()
.Where(f => ResourceQueryProjection.Extras.ContainsKey(f));
IEnumerable <CateOfResQueryRow> categories = null;
foreach (var key in extraKeys)
{
switch (key)
{
case ResourceQueryProjection.CATEGORIES:
categories = GetCategoriesQueryResult(multipleResult);
break;
}
}
ProcessExtras(queryResult, categories);
}
if (options != null && options.single_only)
{
var single = queryResult.FirstOrDefault();
if (single == null)
{
return(null);
}
return(new QueryResult <ResourceQueryRow>
{
SingleResult = single
});
}
if (options != null && options.count_total)
{
totalCount = await countTask;
}
return(new QueryResult <ResourceQueryRow>
{
Results = queryResult,
TotalCount = totalCount
});
}
}
/// <summary>
/// Método responsável por realizar uma query (filtro e ordenação)
/// </summary>
/// <typeparam name="T">entidade</typeparam>
/// <param name="source">fonte de dados</param>
/// <param name="query">parametros para realização da consulta</param>
/// <returns>retorna a query executada</returns>
public static IQueryable <T> Query <T>(this IQueryable <T> source, ResourceQueryFilter query)
where T : class
{
return(source.Filter(query.Filters)
.Sort(query.Sorts));
}
