protected async Task <IEnumerable <AutoCompleteResponse> > FindCompletionsAsync(string filename, string source, bool wantSnippet = false)
{
var testFile = new TestFile(filename, source);
using (var host = CreateOmniSharpHost(testFile))
{
var point = testFile.Content.GetPointFromPosition();
var request = new AutoCompleteRequest
{
Line = point.Line,
Column = point.Offset,
FileName = testFile.FileName,
Buffer = testFile.Content.Code,
WordToComplete = GetPartialWord(testFile.Content),
WantMethodHeader = true,
WantSnippet = wantSnippet,
WantReturnType = true
};
var requestHandler = GetRequestHandler(host);
return(await requestHandler.Handle(request));
}
}
private IEnumerable <AutoCompleteResponse> MakeSnippetedResponses(AutoCompleteRequest request, ISymbol symbol)
{
var completions = new List <AutoCompleteResponse>();
var methodSymbol = symbol as IMethodSymbol;
if (methodSymbol != null)
{
if (methodSymbol.Parameters.Any(p => p.IsOptional))
{
completions.Add(MakeAutoCompleteResponse(request, symbol, false));
}
completions.Add(MakeAutoCompleteResponse(request, symbol));
return(completions);
}
var typeSymbol = symbol as INamedTypeSymbol;
if (typeSymbol != null)
{
completions.Add(MakeAutoCompleteResponse(request, symbol));
foreach (var ctor in typeSymbol.InstanceConstructors)
{
completions.Add(MakeAutoCompleteResponse(request, ctor));
}
return(completions);
}
return(new[] { MakeAutoCompleteResponse(request, symbol) });
}
public IEnumerable <CompletionData> GetCompletions(string editorText, bool includeImportableTypes)
{
int cursorOffset = editorText.IndexOf("$", StringComparison.Ordinal);
if (cursorOffset == -1)
{
throw new ArgumentException("Editor text should contain a $");
}
TextLocation cursorPosition = TestHelpers.GetLineAndColumnFromIndex(editorText, cursorOffset);
string partialWord = GetPartialWord(editorText);
editorText = editorText.Replace("$", "");
var project = new FakeProject();
project.AddFile(editorText);
_solution.Projects.Add(project);
var provider = new AutoCompleteHandler(_solution, new BufferParser(_solution), new Logger(Verbosity.Quiet), new OmniSharpConfiguration());
var request = new AutoCompleteRequest
{
FileName = "myfile",
WordToComplete = partialWord,
Buffer = editorText,
Line = cursorPosition.Line,
Column = cursorPosition.Column,
WantDocumentationForEveryCompletionResult = false,
WantImportableTypes = includeImportableTypes,
WantMethodHeader = true,
WantReturnType = true,
WantSnippet = true
};
return(provider.CreateProvider(request));
}
public IEnumerable <ICompletionData> GetCompletions(string editorText)
{
int cursorOffset = editorText.IndexOf("$", StringComparison.Ordinal);
if (cursorOffset == -1)
{
throw new ArgumentException("Editor text should contain a $");
}
TextLocation cursorPosition = TestHelpers.GetLineAndColumnFromIndex(editorText, cursorOffset);
string partialWord = GetPartialWord(editorText);
editorText = editorText.Replace("$", "");
var project = new FakeProject();
project.AddFile(editorText);
_solution.Projects.Add(project);
var provider = new AutoCompleteHandler(new BufferParser(_solution), new Logger());
var request = new AutoCompleteRequest
{
FileName = "myfile",
WordToComplete = partialWord,
Buffer = editorText,
Line = cursorPosition.Line,
Column = cursorPosition.Column,
};
return(provider.CreateProvider(request));
}
public async override Task <CompletionList> Handle(CompletionParams request, CancellationToken token)
{
var omnisharpRequest = new AutoCompleteRequest()
{
FileName = Helpers.FromUri(request.TextDocument.Uri),
Column = Convert.ToInt32(request.Position.Character),
Line = Convert.ToInt32(request.Position.Line),
WantKind = true,
WantDocumentationForEveryCompletionResult = true,
WantReturnType = true,
WantSnippet = Capability.CompletionItem?.SnippetSupport ?? false
};
var omnisharpResponse = await _autoCompleteHandler.Handle(omnisharpRequest);
var completions = new Dictionary <string, List <CompletionItem> >();
foreach (var response in omnisharpResponse)
{
var isSnippet = !string.IsNullOrEmpty(response.Snippet);
var text = isSnippet ? response.Snippet : response.CompletionText;
var textFormat = isSnippet ? InsertTextFormat.Snippet : InsertTextFormat.PlainText;
var completionItem = new CompletionItem
{
Label = response.CompletionText,
Detail = !string.IsNullOrEmpty(response.ReturnType) ?
response.DisplayText :
$"{response.ReturnType} {response.DisplayText}",
Documentation = response.Description,
Kind = GetCompletionItemKind(response.Kind),
InsertText = text,
InsertTextFormat = textFormat,
};
if (!completions.ContainsKey(completionItem.Label))
{
completions[completionItem.Label] = new List <CompletionItem>();
}
completions[completionItem.Label].Add(completionItem);
}
var result = new List <CompletionItem>();
foreach (var key in completions.Keys)
{
var suggestion = completions[key][0];
var overloadCount = completions[key].Count - 1;
if (overloadCount > 0)
{
// indicate that there is more
suggestion.Detail = $"{suggestion.Detail} (+ {overloadCount} overload(s))";
}
result.Add(suggestion);
}
return(new CompletionList(result));
}
public static IEnumerable <string> GetSelectedIds(this AutoCompleteRequest request)
{
if (request.HasSelectedIds())
{
return(request.SelectedIds);
}
return(new List <string>());
}
private IEnumerable <AutoCompleteResponse> MakeSnippetedResponses(AutoCompleteRequest request, IMethodSymbol methodSymbol, string completionText, bool preselect, bool isSuggestionMode)
{
var completions = new List <AutoCompleteResponse>();
if (methodSymbol.Parameters.Any(p => p.IsOptional))
{
completions.Add(MakeAutoCompleteResponse(request, methodSymbol, completionText, preselect, isSuggestionMode, includeOptionalParams: false));
}
completions.Add(MakeAutoCompleteResponse(request, methodSymbol, completionText, preselect, isSuggestionMode));
return(completions);
}
private IEnumerable <AutoCompleteResponse> MakeSnippetedResponses(AutoCompleteRequest request, ISymbol symbol, string completionText, bool preselect, bool isSuggestionMode)
{
switch (symbol)
{
case IMethodSymbol methodSymbol:
return(MakeSnippetedResponses(request, methodSymbol, completionText, preselect, isSuggestionMode));
case INamedTypeSymbol typeSymbol:
return(MakeSnippetedResponses(request, typeSymbol, completionText, preselect, isSuggestionMode));
default:
return(new[] { MakeAutoCompleteResponse(request, symbol, completionText, preselect, isSuggestionMode) });
}
}
private AutoCompleteResponse MakeAutoCompleteResponse(AutoCompleteRequest request, ISymbol symbol, string completionText, bool preselect, bool isSuggestionMode, bool includeOptionalParams = true)
{
var displayNameGenerator = new SnippetGenerator();
displayNameGenerator.IncludeMarkers = false;
displayNameGenerator.IncludeOptionalParameters = includeOptionalParams;
var response = new AutoCompleteResponse();
response.CompletionText = completionText;
// TODO: Do something more intelligent here
response.DisplayText = displayNameGenerator.Generate(symbol);
response.IsSuggestionMode = isSuggestionMode;
if (request.WantDocumentationForEveryCompletionResult)
{
response.Description = DocumentationConverter.ConvertDocumentation(symbol.GetDocumentationCommentXml(), _formattingOptions.NewLine);
}
if (request.WantReturnType)
{
response.ReturnType = ReturnTypeFormatter.GetReturnType(symbol);
}
if (request.WantKind)
{
response.Kind = symbol.GetKind();
}
if (request.WantSnippet)
{
var snippetGenerator = new SnippetGenerator();
snippetGenerator.IncludeMarkers = true;
snippetGenerator.IncludeOptionalParameters = includeOptionalParams;
response.Snippet = snippetGenerator.Generate(symbol);
}
if (request.WantMethodHeader)
{
response.MethodHeader = displayNameGenerator.Generate(symbol);
}
response.Preselect = preselect;
return(response);
}
public async Task <IEnumerable <AutoCompleteResponse> > Handle(AutoCompleteRequest request)
{
var documents = _workspace.GetDocuments(request.FileName);
var wordToComplete = request.WordToComplete;
var completions = new HashSet <AutoCompleteResponse>();
foreach (var document in documents)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.GetTextPosition(request);
var service = CompletionService.GetService(document);
var options = new OmniSharpCompletionOptions(
ShowItemsFromUnimportedNamespaces: _omniSharpOptions.RoslynExtensionsOptions.EnableImportCompletion,
ForceExpandedCompletionIndexCreation: false);
var completionList = await OmniSharpCompletionService.GetCompletionsAsync(service, document, position, trigger : default, roles : null, options, CancellationToken.None);
public override Task <AutoCompleteReply> AutoComplete(AutoCompleteRequest request, ServerCallContext context)
{
var reply = new AutoCompleteReply();
if (!string.IsNullOrEmpty(request.SearchQuery))
{
var productMatches = _products
.Where(p => p.Name.StartsWith(request.SearchQuery, StringComparison.CurrentCultureIgnoreCase))
.Select(p => new AutoCompleteItem {
EAN = p.EAN, Name = p.Name
})
.Take(10);
reply.Items.AddRange(productMatches);
}
return(Task.FromResult(reply));
}
public object Any(AutoCompleteRequest request)
{
var multiResult = Client().MultiSearch(ms => ms
.Search<AutoComplete>("Artist",
i =>
i.Index("autocomplete")
.Type("autocomplete")
.Skip((request.Offset) * request.Limit)
.Take(request.Limit)
.Query(
q =>
q.Filtered(
x => x.Query(f => f.Match(m => m.OnField(a => a.ObjectType).Query("Artist"))
&&
f.Match(m1 => m1.OnField(m2 => m2.Name).Query(request.Query))))))
.Search<AutoComplete>("Song",
i =>
i.Index("autocomplete")
.Type("autocomplete")
.Skip((request.Offset) * request.Limit)
.Take(request.Limit)
.Query(
q =>
q.Filtered(
x => x.Query(f => f.Match(m => m.OnField(a => a.ObjectType).Query("Song"))
&&
f.Match(m1 => m1.OnField(m2 => m2.Name).Query(request.Query))))))
.Search<AutoComplete>("Album",
i =>
i.Index("autocomplete")
.Type("autocomplete")
.Skip((request.Offset) * request.Limit)
.Take(request.Limit)
.Query(
q =>
q.Filtered(
x => x.Query(f => f.Match(m => m.OnField(a => a.ObjectType).Query("Album"))
&&
f.Match(m1 => m1.OnField(m2 => m2.Name).Query(request.Query)))))));
return new
{
artists = multiResult.GetResponse<AutoComplete>("Artist").Documents.Distinct(),
songs = multiResult.GetResponse<AutoComplete>("Song").Documents.Distinct(),
albums = multiResult.GetResponse<AutoComplete>("Album").Documents.Distinct()
};
}
private IEnumerable <AutoCompleteResponse> MakeSnippetedResponses(AutoCompleteRequest request, INamedTypeSymbol typeSymbol, string completionText, bool preselect, bool isSuggestionMode)
{
var completions = new List <AutoCompleteResponse>
{
MakeAutoCompleteResponse(request, typeSymbol, completionText, preselect, isSuggestionMode)
};
if (typeSymbol.TypeKind != TypeKind.Enum)
{
foreach (var ctor in typeSymbol.InstanceConstructors)
{
completions.Add(MakeAutoCompleteResponse(request, ctor, completionText, preselect, isSuggestionMode));
}
}
return(completions);
}
public async Task <IActionResult> AutoComplete([FromBody] AutoCompleteRequest request)
{
_workspace.EnsureBufferUpdated(request);
var completions = new List <AutoCompleteResponse>();
var documents = _workspace.GetDocuments(request.FileName);
foreach (var document in documents)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(request.Line - 1, request.Column - 1));
var model = await document.GetSemanticModelAsync();
var symbols = Recommender.GetRecommendedSymbolsAtPosition(model, position, _workspace);
var context = CSharpSyntaxContext.CreateContext(_workspace, model, position);
var keywordHandler = new KeywordContextHandler();
var keywords = keywordHandler.Get(context, model, position);
foreach (var keyword in keywords)
{
completions.Add(new AutoCompleteResponse
{
CompletionText = keyword,
DisplayText = keyword,
Snippet = keyword
});
}
foreach (var symbol in symbols.Where(s => s.Name.StartsWith(request.WordToComplete, StringComparison.OrdinalIgnoreCase)))
{
if (request.WantSnippet)
{
completions.AddRange(MakeSnippetedResponses(request, symbol));
}
else
{
completions.Add(MakeAutoCompleteResponse(request, symbol));
}
}
}
return(new ObjectResult(completions));
}
public async Task <CollectionResult <IdTextPair> > GetArtistListAsync([FromQuery] AutoCompleteRequest request)
{
await Task.CompletedTask;
var query = _unitOfWork.Repository <ArtistBson>()
.Select(x => new IdTextPair
{
Id = x.Id.ToString(),
Text = x.Name
});
if (request?.SelectedIds != null && request.SelectedIds.Any())
{
return(query.Where(x => request.SelectedIds.Contains(x.Id)).ToCollectionResult());
}
return(query.ToCollectionResult(request));
}
public object Any(AutoCompleteRequest request)
{
try
{
var sb = new StringBuilder("autocomplete args: ");
sb.AppendFormat(" [UserId:{0}]", request.UserId);
sb.AppendFormat(" [ProjectId:{0}]", request.ProjectId);
sb.AppendFormat(" [FileId:{0}]", request.FileId);
sb.AppendFormat(" [Line:{0}]", request.Line);
sb.AppendFormat(" [Column:{0}]", request.Column);
log.Info(sb.ToString());
var fileRequest = new FileOperationRequest()
{
UserId = request.UserId,
ProjectId = request.ProjectId,
FileId = request.FileId,
CompleteCode = new FileCodeCompletionRequest()
{
AutoComplete = true,
LineNumber = request.Line,
ColumnNumber = request.Column,
CtrlSpace = true // always true for now
},
Parse = new FileParseRequest()
};
FileOperationResponse response = AutocompleteServiceUtil.DoAutoComplete(fileRequest);
return response;
}
catch (Exception ex)
{
log.Error(ex.ToString(), ex);
return new ApiError()
{
FullName = ex.GetType().FullName,
Message = ex.Message,
StackTrace = ex.StackTrace
};
}
}
public object Any(AutoCompleteRequest request)
{
try
{
var sb = new StringBuilder("autocomplete args: ");
sb.AppendFormat(" [UserId:{0}]", request.UserId);
sb.AppendFormat(" [ProjectId:{0}]", request.ProjectId);
sb.AppendFormat(" [FileId:{0}]", request.FileId);
sb.AppendFormat(" [Line:{0}]", request.Line);
sb.AppendFormat(" [Column:{0}]", request.Column);
log.Info(sb.ToString());
var fileRequest = new FileOperationRequest()
{
UserId = request.UserId,
ProjectId = request.ProjectId,
FileId = request.FileId,
CompleteCode = new FileCodeCompletionRequest()
{
AutoComplete = true,
LineNumber = request.Line,
ColumnNumber = request.Column,
CtrlSpace = true // always true for now
},
Parse = new FileParseRequest()
};
FileOperationResponse response = AutocompleteServiceUtil.DoAutoComplete(fileRequest);
return(response);
}
catch (Exception ex)
{
log.Error(ex.ToString(), ex);
return(new ApiError()
{
FullName = ex.GetType().FullName,
Message = ex.Message,
StackTrace = ex.StackTrace
});
}
}
public static bool HasSelectedIds(this AutoCompleteRequest request)
{
if (request == null)
{
return(false);
}
if (request.SelectedIds == null)
{
return(false);
}
if (request.SelectedIds.Any())
{
return(true);
}
return(false);
}
public IActionResult Tags(AutoCompleteRequest request)
{
var items = new List <IdTextPair>
{
new IdTextPair
{
Id = "1",
Text = "Brand New"
},
new IdTextPair
{
Id = "2",
Text = "Millennium"
},
};
return(Json(items.ToCollectionResult(request)));
}
protected async Task UpdateAutoComplete(ChangeEventArgs eventArgs)
{
searchText = (string)eventArgs.Value;
var matchingItem = autoCompleteItems.FirstOrDefault(p => p.Name == searchText);
if (matchingItem != null)
{
searchText = matchingItem.EAN;
await AddItem();
}
else
{
var request = new AutoCompleteRequest {
SearchQuery = searchText
};
var reply = await InventoryClient.AutoCompleteAsync(request);
autoCompleteItems = reply.Items.ToList();
}
}
public async Task <IEnumerable <AutoCompleteResponse> > Handle(AutoCompleteRequest request)
{
var documents = _workspace.GetDocuments(request.FileName);
var wordToComplete = request.WordToComplete;
var completions = new HashSet <AutoCompleteResponse>();
foreach (var document in documents)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(request.Line - 1, request.Column - 1));
var model = await document.GetSemanticModelAsync();
AddKeywords(completions, model, position, request.WantKind, wordToComplete);
var symbols = Recommender.GetRecommendedSymbolsAtPosition(model, position, _workspace);
foreach (var symbol in symbols.Where(s => s.Name.IsValidCompletionFor(wordToComplete)))
{
if (request.WantSnippet)
{
foreach (var completion in MakeSnippetedResponses(request, symbol))
{
completions.Add(completion);
}
}
else
{
completions.Add(MakeAutoCompleteResponse(request, symbol));
}
}
}
return(completions
.OrderByDescending(c => c.CompletionText.IsValidCompletionStartsWithExactCase(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsValidCompletionStartsWithIgnoreCase(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsCamelCaseMatch(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsSubsequenceMatch(wordToComplete))
.ThenBy(c => c.CompletionText));
}
private AutoCompleteResponse MakeAutoCompleteResponse(AutoCompleteRequest request, ISymbol symbol, bool includeOptionalParams = true)
{
var response = new AutoCompleteResponse();
response.CompletionText = symbol.Name;
// TODO: Do something more intelligent here
response.DisplayText = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
if (request.WantDocumentationForEveryCompletionResult)
{
response.Description = symbol.GetDocumentationCommentXml();
}
if (request.WantReturnType)
{
response.ReturnType = ReturnTypeFormatter.GetReturnType(symbol);
}
if (request.WantSnippet)
{
var snippetGenerator = new SnippetGenerator();
snippetGenerator.IncludeMarkers = true;
snippetGenerator.IncludeOptionalParameters = includeOptionalParams;
response.Snippet = snippetGenerator.GenerateSnippet(symbol);
}
if (request.WantMethodHeader)
{
var snippetGenerator = new SnippetGenerator();
snippetGenerator.IncludeMarkers = false;
snippetGenerator.IncludeOptionalParameters = includeOptionalParams;
response.MethodHeader = snippetGenerator.GenerateSnippet(symbol);
}
return(response);
}
private async Task <IEnumerable <AutoCompleteResponse> > FindCompletionsAsync(string source, bool wantSnippet = false)
{
using (var testProject = await TestAssets.Instance.GetTestProjectAsync("CakeProject", shadowCopy: false))
using (var host = CreateOmniSharpHost(testProject.Directory))
{
var testFile = new TestFile(Path.Combine(testProject.Directory, "build.cake"), source);
var point = testFile.Content.GetPointFromPosition();
var request = new AutoCompleteRequest
{
Line = point.Line,
Column = point.Offset,
FileName = testFile.FileName,
Buffer = testFile.Content.Code,
WordToComplete = GetPartialWord(testFile.Content),
WantMethodHeader = true,
WantSnippet = wantSnippet,
WantReturnType = true
};
var updateBufferRequest = new UpdateBufferRequest
{
Buffer = request.Buffer,
Column = request.Column,
FileName = request.FileName,
Line = request.Line,
FromDisk = false
};
await GetUpdateBufferHandler(host).Handle(updateBufferRequest);
var requestHandler = GetRequestHandler(host);
return(await requestHandler.Handle(request));
}
}
protected async Task <IEnumerable <AutoCompleteResponse> > FindCompletionsAsync(string filename, string source, bool wantSnippet = false, string triggerChar = null)
{
var testFile = new TestFile(filename, source);
SharedOmniSharpTestHost.AddFilesToWorkspace(testFile);
var point = testFile.Content.GetPointFromPosition();
var request = new AutoCompleteRequest
{
Line = point.Line,
Column = point.Offset,
FileName = testFile.FileName,
Buffer = testFile.Content.Code,
WordToComplete = GetPartialWord(testFile.Content),
WantMethodHeader = true,
WantSnippet = wantSnippet,
WantReturnType = true,
TriggerCharacter = triggerChar
};
var requestHandler = GetRequestHandler(SharedOmniSharpTestHost);
return(await requestHandler.Handle(request));
}
public async Task <IEnumerable <AutoCompleteResponse> > Handle(AutoCompleteRequest request)
{
var documents = _workspace.GetDocuments(request.FileName);
var wordToComplete = request.WordToComplete;
var completions = new HashSet <AutoCompleteResponse>();
foreach (var document in documents)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(request.Line, request.Column));
var service = CompletionService.GetService(document);
var completionList = await service.GetCompletionsAsync(document, position);
// Add keywords from the completion list. We'll use the recommender service to get symbols
// to create snippets from.
foreach (var item in completionList.Items)
{
if (item.Tags.Contains(CompletionTags.Keyword))
{
// Note: For keywords, we'll just assume that the completion text is the same
// as the display text.
var keyword = item.DisplayText;
if (keyword.IsValidCompletionFor(wordToComplete))
{
var response = new AutoCompleteResponse()
{
CompletionText = item.DisplayText,
DisplayText = item.DisplayText,
Snippet = item.DisplayText,
Kind = request.WantKind ? "Keyword" : null
};
completions.Add(response);
}
}
}
var model = await document.GetSemanticModelAsync();
var symbols = await Recommender.GetRecommendedSymbolsAtPositionAsync(model, position, _workspace);
foreach (var symbol in symbols.Where(s => s.Name.IsValidCompletionFor(wordToComplete)))
{
if (request.WantSnippet)
{
foreach (var completion in MakeSnippetedResponses(request, symbol))
{
completions.Add(completion);
}
}
else
{
completions.Add(MakeAutoCompleteResponse(request, symbol));
}
}
}
return(completions
.OrderByDescending(c => c.CompletionText.IsValidCompletionStartsWithExactCase(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsValidCompletionStartsWithIgnoreCase(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsCamelCaseMatch(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsSubsequenceMatch(wordToComplete))
.ThenBy(c => c.CompletionText));
}
private async Task <IEnumerable <AutoCompleteResponse> > FindCompletionsAsync(string source, AutoCompleteRequest request = null)
{
var workspace = await TestHelpers.CreateSimpleWorkspace(_plugInHost, source);
var controller = new IntellisenseService(workspace, new FormattingOptions());
if (request == null)
{
request = CreateRequest(source);
}
var response = await controller.Handle(request);
var completions = response as IEnumerable <AutoCompleteResponse>;
return(completions);
}
// Method to call API End Point: Auto Complete https://tenor.com/gifapi#autocomplete
public static IEnumerator AutoComplete(AutoCompleteRequest request, DelegateStringAnswer delegateAutoComplete)
{
return(_apiCallStringCollection(request.getQueryString(key), delegateAutoComplete));
}
public async Task <IEnumerable <AutoCompleteResponse> > Handle(AutoCompleteRequest request)
{
var documents = _workspace.GetDocuments(request.FileName);
var wordToComplete = request.WordToComplete;
var completions = new HashSet <AutoCompleteResponse>();
foreach (var document in documents)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(request.Line, request.Column));
var service = CompletionService.GetService(document);
var completionList = await service.GetCompletionsAsync(document, position);
if (completionList != null)
{
// Only trigger on space if Roslyn has object creation items
if (request.TriggerCharacter == " " && !completionList.Items.Any(i => i.IsObjectCreationCompletionItem()))
{
return(completions);
}
// get recommended symbols to match them up later with SymbolCompletionProvider
var semanticModel = await document.GetSemanticModelAsync();
var recommendedSymbols = (await Recommender.GetRecommendedSymbolsAtPositionAsync(semanticModel, position, _workspace)).ToArray();
var isSuggestionMode = completionList.SuggestionModeItem != null;
foreach (var item in completionList.Items)
{
var completionText = item.DisplayText;
var preselect = item.Rules.MatchPriority == MatchPriority.Preselect;
if (completionText.IsValidCompletionFor(wordToComplete))
{
var symbols = await item.GetCompletionSymbolsAsync(recommendedSymbols, document);
if (symbols.Any())
{
foreach (var symbol in symbols)
{
if (item.UseDisplayTextAsCompletionText())
{
completionText = item.DisplayText;
}
else if (item.TryGetInsertionText(out var insertionText))
{
completionText = insertionText;
}
else
{
completionText = symbol.Name;
}
if (symbol != null)
{
if (request.WantSnippet)
{
foreach (var completion in MakeSnippetedResponses(request, symbol, completionText, preselect, isSuggestionMode))
{
completions.Add(completion);
}
}
else
{
completions.Add(MakeAutoCompleteResponse(request, symbol, completionText, preselect, isSuggestionMode));
}
}
}
// if we had any symbols from the completion, we can continue, otherwise it means
// the completion didn't have an associated symbol so we'll add it manually
continue;
}
// for other completions, i.e. keywords, create a simple AutoCompleteResponse
// we'll just assume that the completion text is the same
// as the display text.
var response = new AutoCompleteResponse()
{
CompletionText = item.DisplayText,
DisplayText = item.DisplayText,
Snippet = item.DisplayText,
Kind = request.WantKind ? item.Tags.First() : null,
IsSuggestionMode = isSuggestionMode,
Preselect = preselect
};
completions.Add(response);
}
}
}
}
return(completions
.OrderByDescending(c => c.CompletionText.IsValidCompletionStartsWithExactCase(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsValidCompletionStartsWithIgnoreCase(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsCamelCaseMatch(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsSubsequenceMatch(wordToComplete))
.ThenBy(c => c.DisplayText, StringComparer.OrdinalIgnoreCase)
.ThenBy(c => c.CompletionText, StringComparer.OrdinalIgnoreCase));
}
public override void Init(System.Html.Element element, Func <object> valueAccessor, Func <System.Collections.Dictionary> allBindingsAccessor, object viewModel, object context)
{
XrmLookupEditorButton footerButton = (XrmLookupEditorButton)allBindingsAccessor()["footerButton"];
bool showFooter = (bool)allBindingsAccessor()["showFooter"];
jQueryObject container = jQuery.FromElement(element);
jQueryObject inputField = container.Find(".sparkle-input-lookup-part");
jQueryObject selectButton = container.Find(".sparkle-input-lookup-button-part");
EntityReference _value = new EntityReference(null, null, null);
AutoCompleteOptions options = new AutoCompleteOptions();
options.MinLength = 100000; // Don't enable type down - use search button (or return)
options.Delay = 0;
options.Position = new Dictionary <string, object>("collision", "fit");
bool justSelected = false;
int totalRecordsReturned = 0;
Action <AutoCompleteItem, bool> setValue = delegate(AutoCompleteItem item, bool setFocus)
{
if (_value == null)
{
_value = new EntityReference(null, null, null);
}
string value = item.Label;
inputField.Value(value);
_value.Id = ((Guid)item.Value);
_value.Name = item.Label;
_value.LogicalName = (string)item.Data;
justSelected = true;
TrySetObservable(valueAccessor, inputField, _value, setFocus);
};
// Set the value when selected
options.Select = delegate(jQueryEvent e, AutoCompleteSelectEvent uiEvent)
{
// Note we assume that the binding has added an array of string items
AutoCompleteItem item = (AutoCompleteItem)uiEvent.Item;
string data = ((string)item.Data);
if (data == "footerlink" || data == null)
{
footerButton.OnClick(item);
e.PreventDefault();
e.StopImmediatePropagation();
Script.Literal("return false;");
}
else
{
setValue(item, true);
Script.Literal("return false;");
}
};
options.Open = delegate(jQueryEvent e, jQueryObject o)
{
if (showFooter && totalRecordsReturned > 0)
{
WidgetObject menu = (WidgetObject)Script.Literal("{0}.autocomplete({1})", inputField, "widget");
XrmLookupEditor.AddFooter(menu, totalRecordsReturned);
}
};
options.Close = delegate(jQueryEvent e, jQueryObject o)
{
WidgetObject menu = (WidgetObject)Script.Literal("{0}.autocomplete({1})", inputField, "widget");
jQueryObject footer = menu.Next();
if (footer.Length > 0 || footer.HasClass("sparkle-menu-footer"))
{
footer.Hide();
}
};
// Get the query command
Action <string, Action <EntityCollection> > queryCommand = (Action <string, Action <EntityCollection> >)((object)allBindingsAccessor()["queryCommand"]);
string nameAttribute = ((string)allBindingsAccessor()["nameAttribute"]);
string idAttribute = ((string)allBindingsAccessor()["idAttribute"]);
string typeCodeAttribute = ((string)allBindingsAccessor()["typeCodeAttribute"]);
string[] columnAttributes = null;
// If there multiple names, add them to the columnAttributes
string[] columns = nameAttribute.Split(",");
if (columns.Length > 1)
{
columnAttributes = columns;
nameAttribute = columnAttributes[0];
}
// wire up source to CRM search
Action <AutoCompleteRequest, Action <AutoCompleteItem[]> > queryDelegate = delegate(AutoCompleteRequest request, Action <AutoCompleteItem[]> response)
{
Action <EntityCollection> queryCallBack = delegate(EntityCollection fetchResult)
{
int recordsFound = fetchResult.Entities.Count;
bool noRecordsFound = recordsFound == 0;
AutoCompleteItem[] results = new AutoCompleteItem[recordsFound + (footerButton != null ? 1 : 0) + (noRecordsFound ? 1 : 0)];
for (int i = 0; i < recordsFound; i++)
{
results[i] = new AutoCompleteItem();
results[i].Label = (string)fetchResult.Entities[i].GetAttributeValue(nameAttribute);
results[i].Value = fetchResult.Entities[i].GetAttributeValue(idAttribute);
results[i].Data = fetchResult.Entities[i].LogicalName;
GetExtraColumns(columnAttributes, fetchResult, results, i);
string typeCodeName = fetchResult.Entities[i].LogicalName;
// Get the type code from the name to find the icon
if (!string.IsNullOrEmpty(typeCodeAttribute))
{
typeCodeName = fetchResult.Entities[i].GetAttributeValue(typeCodeAttribute).ToString();
}
results[i].Image = MetadataCache.GetSmallIconUrl(typeCodeName);
}
if (fetchResult.TotalRecordCount > fetchResult.Entities.Count)
{
totalRecordsReturned = fetchResult.TotalRecordCount;
}
else
{
totalRecordsReturned = fetchResult.Entities.Count;
}
int itemsCount = recordsFound;
if (noRecordsFound)
{
AutoCompleteItem noRecordsItem = new AutoCompleteItem();
noRecordsItem.Label = SparkleResourceStrings.NoRecordsFound;
results[itemsCount] = noRecordsItem;
itemsCount++;
}
if (footerButton != null)
{
// Add the add new
AutoCompleteItem addNewLink = new AutoCompleteItem();
addNewLink.Label = footerButton.Label;
addNewLink.Image = footerButton.Image;
addNewLink.ColumnValues = null;
addNewLink.Data = "footerlink";
results[itemsCount] = addNewLink;
}
response(results);
// Disable it now so typing doesn't trigger a search
AutoCompleteOptions disableOption = new AutoCompleteOptions();
disableOption.MinLength = 100000;
inputField.Plugin <AutoCompleteObject>().AutoComplete(disableOption);
};
// Call the function with the correct 'this' context
Script.Literal("{0}.call({1}.$parent,{2},{3})", queryCommand, context, request.Term, queryCallBack);
};
options.Source = queryDelegate;
options.Focus = delegate(jQueryEvent e, AutoCompleteFocusEvent uiEvent)
{
// Prevent the value being updated in the text box we scroll through the results
Script.Literal("return false;");
};
inputField = inputField.Plugin <AutoCompleteObject>().AutoComplete(options);
// Set render template
((RenderItemDelegate)Script.Literal("{0}.data('ui-autocomplete')", inputField))._renderItem = delegate(object ul, AutoCompleteItem item)
{
if (item.Data == null)
{
return((object)jQuery.Select("<li class='ui-state-disabled'>" + item.Label + "</li>").AppendTo((jQueryObject)ul));
}
string html = "<a class='sparkle-menu-item'><span class='sparkle-menu-item-img'>";
if (item.Image != null)
{
html += @"<img src='" + item.Image + "'/>";
}
html += @"</span><span class='sparkle-menu-item-label'>" + item.Label + "</span><br>";
if (item.ColumnValues != null && item.ColumnValues.Length > 0)
{
foreach (string value in item.ColumnValues)
{
html += "<span class='sparkle-menu-item-moreinfo'>" + value + "</span>";
}
}
html += "</a>";
return((object)jQuery.Select("<li>").Append(html).AppendTo((jQueryObject)ul));
};
// Add the click binding to show the drop down
selectButton.Click(delegate(jQueryEvent e)
{
AutoCompleteOptions enableOption = new AutoCompleteOptions();
enableOption.MinLength = 0;
inputField.Focus();
inputField.Plugin <AutoCompleteObject>().AutoComplete(enableOption);
inputField.Plugin <AutoCompleteObject>().AutoComplete(AutoCompleteMethod.Search);
});
// handle the field changing
inputField.Change(delegate(jQueryEvent e)
{
string inputValue = inputField.GetValue();
if (inputValue != _value.Name)
{
// The name is different from the name of the lookup reference
// search to see if we can auto resolve it
TrySetObservable(valueAccessor, inputField, null, false);
AutoCompleteRequest lookup = new AutoCompleteRequest();
lookup.Term = inputValue;
Action <AutoCompleteItem[]> lookupResults = delegate(AutoCompleteItem[] results)
{
int selectableItems = 0;
// If there is only one, then auto-set
if (results != null)
{
foreach (AutoCompleteItem item in results)
{
if (isItemSelectable(item))
{
selectableItems++;
}
if (selectableItems > 2)
{
break;
}
}
}
if (selectableItems == 1)
{
// There is only a single value so set it now
setValue(results[0], false);
}
else
{
inputField.Value(String.Empty);
}
};
queryDelegate(lookup, lookupResults);
}
});
Action disposeCallBack = delegate()
{
if ((bool)Script.Literal("$({0}).data('ui-autocomplete')!=undefined", inputField))
{
Script.Literal("$({0}).autocomplete(\"destroy\")", inputField);
}
};
//handle disposal (if KO removes by the template binding)
Script.Literal("ko.utils.domNodeDisposal.addDisposeCallback({0}, {1})", element, (object)disposeCallBack);
Knockout.BindingHandlers["validationCore"].Init(element, valueAccessor, allBindingsAccessor, null, null);
// Bind return to searching
inputField.Keydown(delegate(jQueryEvent e)
{
if (e.Which == 13 && !justSelected) // Return pressed - but we want to do a search not move to the next cell
{
selectButton.Click();
}
else if (e.Which == 13)
{
return;
}
switch (e.Which)
{
case 13: // Return
case 38: // Up - don't navigate - but use the dropdown to select search results
case 40: // Down - don't navigate - but use the dropdown to select search results
e.PreventDefault();
e.StopPropagation();
break;
}
justSelected = false;
});
//Script.Literal("return { controlsDescendantBindings: true };");
}
private async Task <IEnumerable <AutoCompleteResponse> > FindCompletionsAsync(string source, AutoCompleteRequest request = null)
{
var workspace = TestHelpers.CreateSimpleWorkspace(source);
var controller = new OmnisharpController(workspace, null);
if (request == null)
{
request = CreateRequest(source);
}
var response = await controller.AutoComplete(request);
var completions = response as IEnumerable <AutoCompleteResponse>;
return(completions);
}
public async Task <IActionResult> GetArtistList(AutoCompleteRequest request)
{
var artistCollection = await _albumApi.GetArtistListAsync(request);
return(Json(artistCollection));
}
