/// <summary>
/// All
/// </summary>
/// <param name="searchTypeRequest">SearchTypeRequest</param>
/// <returns>SearchTypeRequest</returns>
public static SearchTypeRequest All(this SearchTypeRequest searchTypeRequest)
{
searchTypeRequest.Album = true;
searchTypeRequest.Artist = true;
searchTypeRequest.Episode = true;
searchTypeRequest.Playlist = true;
searchTypeRequest.Show = true;
searchTypeRequest.Track = true;
return(searchTypeRequest);
}
public override IList <IUsing> FindUnusedUsingDeclarations(string fileName, string fileContent, ICompilationUnit cu)
{
IClass @class = cu.Classes.Count == 0 ? null : cu.Classes[0];
Dictionary <PossibleTypeReference, object> references = FindPossibleTypeReferences(fileContent);
if (references == null)
{
return(new IUsing[0]);
}
Dictionary <IUsing, object> dict = new Dictionary <IUsing, object>();
foreach (PossibleTypeReference tr in references.Keys)
{
SearchTypeRequest request = new SearchTypeRequest(tr.Name, tr.TypeParameterCount, @class, cu, 1, 1);
SearchTypeResult response = cu.ProjectContent.SearchType(request);
if (response.UsedUsing != null)
{
dict[response.UsedUsing] = null;
}
}
List <IUsing> list = new List <IUsing>();
foreach (IUsing import in cu.Usings)
{
if (!dict.ContainsKey(import))
{
if (import.HasAliases)
{
foreach (string key in import.Aliases.Keys)
{
if (references.ContainsKey(new PossibleTypeReference(key)))
{
goto checkNextImport;
}
}
}
list.Add(import); // this using is unused
}
checkNextImport :;
}
return(list);
}
public async Task <PagingResponseMessage <CategoryListResponse> > TypeList([FromBody] SearchTypeRequest search)
{
var response = new PagingResponseMessage <CategoryListResponse>()
{
Extension = new List <CategoryListResponse> {
}
};
try
{
response = await _typeManager.TypeListAsync(search, HttpContext.RequestAborted);
}
catch (Exception e)
{
response.Code = ResponseCodeDefines.ServiceError;
response.Message = "商品类型列表查询失败，请重试";
_logger.LogInformation($"商品类型列表查询失败异常:{JsonHelper.ToJson(e)}");
}
return(response);
}
public override IList <IUsing> FindUnusedUsingDeclarations(IDomProgressMonitor progressMonitor, string fileName, string fileContent, ICompilationUnit cu)
{
IClass @class = cu.Classes.Count == 0 ? null : cu.Classes[0];
HashSet <PossibleTypeReference> references = FindPossibleTypeReferences(progressMonitor, fileContent, new ParseInformation(cu));
if (references == null)
{
return(new IUsing[0]);
}
HashSet <IUsing> usedUsings = new HashSet <IUsing>();
foreach (PossibleTypeReference tr in references)
{
if (tr.ExtensionMethod != null)
{
// the invocation of an extension method can implicitly use a using
StringComparer nameComparer = cu.ProjectContent.Language.NameComparer;
// go through all usings in all nested child scopes
foreach (IUsing import in cu.GetAllUsings())
{
foreach (string i in import.Usings)
{
if (nameComparer.Equals(tr.ExtensionMethod.DeclaringType.Namespace, i))
{
usedUsings.Add(import);
}
}
}
}
else
{
// normal possible type reference
SearchTypeRequest request = new SearchTypeRequest(tr.Name, tr.TypeParameterCount, @class, cu, 1, 1);
SearchTypeResult response = cu.ProjectContent.SearchType(request);
if (response.UsedUsing != null)
{
usedUsings.Add(response.UsedUsing);
}
}
}
List <IUsing> unusedUsings = new List <IUsing>();
foreach (IUsing import in cu.GetAllUsings())
{
if (!usedUsings.Contains(import))
{
if (import.HasAliases)
{
foreach (string key in import.Aliases.Keys)
{
if (references.Contains(new PossibleTypeReference(key)))
{
goto checkNextImport;
}
}
}
unusedUsings.Add(import); // this using is unused
}
checkNextImport :;
}
return(unusedUsings);
}
public override IList<IUsing> FindUnusedUsingDeclarations(IDomProgressMonitor progressMonitor, string fileName, string fileContent, ICompilationUnit cu)
{
IClass @class = cu.Classes.Count == 0 ? null : cu.Classes[0];
HashSet<PossibleTypeReference> references = FindPossibleTypeReferences(progressMonitor, fileContent, new ParseInformation(cu));
if (references == null) return new IUsing[0];
HashSet<IUsing> usedUsings = new HashSet<IUsing>();
foreach (PossibleTypeReference tr in references) {
if (tr.ExtensionMethod != null) {
// the invocation of an extension method can implicitly use a using
StringComparer nameComparer = cu.ProjectContent.Language.NameComparer;
// go through all usings in all nested child scopes
foreach (IUsing import in cu.GetAllUsings()) {
foreach (string i in import.Usings) {
if (nameComparer.Equals(tr.ExtensionMethod.DeclaringType.Namespace, i)) {
usedUsings.Add(import);
}
}
}
} else {
// normal possible type reference
SearchTypeRequest request = new SearchTypeRequest(tr.Name, tr.TypeParameterCount, @class, cu, 1, 1);
SearchTypeResult response = cu.ProjectContent.SearchType(request);
if (response.UsedUsing != null) {
usedUsings.Add(response.UsedUsing);
}
}
}
List<IUsing> unusedUsings = new List<IUsing>();
foreach (IUsing import in cu.GetAllUsings()) {
if (!usedUsings.Contains(import)) {
if (import.HasAliases) {
foreach (string key in import.Aliases.Keys) {
if (references.Contains(new PossibleTypeReference(key)))
goto checkNextImport;
}
}
unusedUsings.Add(import); // this using is unused
}
checkNextImport:;
}
return unusedUsings;
}
public SearchTypeResult SearchType(SearchTypeRequest request)
{
searchTypeCalled = true;
searchTypeRequest = request;
return(searchTypeResult);
}
public SearchTypeResult SearchType(SearchTypeRequest request)
{
throw new NotImplementedException();
}
public override IList<IUsing> FindUnusedUsingDeclarations(string fileName, string fileContent, ICompilationUnit cu)
{
IClass @class = cu.Classes.Count == 0 ? null : cu.Classes[0];
Dictionary<PossibleTypeReference, object> references = FindPossibleTypeReferences(fileContent);
if (references == null) return new IUsing[0];
Dictionary<IUsing, object> dict = new Dictionary<IUsing, object>();
foreach (PossibleTypeReference tr in references.Keys) {
SearchTypeRequest request = new SearchTypeRequest(tr.Name, tr.TypeParameterCount, @class, cu, 1, 1);
SearchTypeResult response = cu.ProjectContent.SearchType(request);
if (response.UsedUsing != null) {
dict[response.UsedUsing] = null;
}
}
List<IUsing> list = new List<IUsing>();
foreach (IUsing import in cu.Usings) {
if (!dict.ContainsKey(import)) {
if (import.HasAliases) {
foreach (string key in import.Aliases.Keys) {
if (references.ContainsKey(new PossibleTypeReference(key)))
goto checkNextImport;
}
}
list.Add(import); // this using is unused
}
checkNextImport:;
}
return list;
}
public static SearchType Map(this IMapper mapper, SearchTypeRequest searchTypeRequest) => mapper.Map <SearchType>(searchTypeRequest);
/// <summary>
/// 列表数据
/// </summary>
/// <param name="search"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <PagingResponseMessage <CategoryListResponse> > TypeListAsync(SearchTypeRequest search, CancellationToken cancellationToken)
{
var response = new PagingResponseMessage <CategoryListResponse>()
{
};
var list = await _typeStore.IQueryableListAsync().Where(type => type.ParentId == search.Parentid).Skip(search.PageIndex * search.PageSize).Take(search.PageSize).ToListAsync(cancellationToken);
var data = _mapper.Map <List <CategoryListResponse> >(list);
response.PageIndex = search.PageIndex;
response.PageSize = search.PageSize;
response.Extension = data;
return(response);
}
