public async override Task <Yngdieng.Frontend.V3.Protos.Word> GetWord(GetWordRequest request,
ServerCallContext context)
{
if (string.IsNullOrEmpty(request.Name))
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "name must not be empty"));
}
var docId = ResourceNames.ToDocId(request.Name);
if (_indexHolder.GetIndex().DocIdRedirections.ContainsKey(docId))
{
var redirectionTarget = _indexHolder.GetIndex().DocIdRedirections[docId];
_logger.LogInformation($"DocId Redirection: {docId} -> {redirectionTarget}");
docId = redirectionTarget;
}
DocRef docRef;
try
{
docRef = DocRefs.Decode(docId);
}
catch (Exception e)
{
throw new RpcException(new Status(StatusCode.InvalidArgument, $"{request.Name} is not a valid name.", e));
}
var userPreference = UserPreferences.FromContext(context);
var zhConverter = new ZhConverter(_openCc, userPreference.ZhConversionPreference);
return(await Words.GetWord(_indexHolder, _dbContext, zhConverter, docRef));
}
public async override Task <ListWordListWordsResponse> ListWordListWords(ListWordListWordsRequest request,
ServerCallContext context)
{
if (string.IsNullOrEmpty(request.Parent))
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "parent must not be empty"));
}
var wordListId = ResourceNames.ToWordListId(request.Parent);
var pageSize = Math.Min(MaxPageSize, request.PageSize > 0 ? request.PageSize : DefaultPageSize);
var offset = ParsePageToken(request.PageToken);
var wordIds = await _dbContext.WordListWords
.Where(w => w.WordListId == wordListId)
.OrderBy(w => w.Ordering)
.Select(w => w.WordId)
.Skip(offset)
.Take(pageSize)
.ToListAsync();
var words = new List <Yngdieng.Frontend.V3.Protos.Word>();
var userPreference = UserPreferences.FromContext(context);
var zhConverter = new ZhConverter(_openCc, userPreference.ZhConversionPreference);
foreach (var wordId in wordIds)
{
words.Add(await Words.GetWord(_indexHolder, _dbContext, zhConverter, ResourceNames.ToDocRef(wordId), Words.Mode.Snippet));
}
return(new ListWordListWordsResponse
{
Words = { words },
NextPageToken = (offset + words.Count).ToString()
});
}
public static async Task <Word> GetWord(
IIndexHolder _indexHolder,
AdminContext _dbContext,
ZhConverter zhConverter,
DocRef docRef,
Mode mode = Mode.Full)
{
var maybeYngdiengDocument = _indexHolder.GetIndex().YngdiengDocuments
.SingleOrDefault(yDoc => yDoc.DocId == DocRefs.Encode(docRef));
var maybeWordId = string.IsNullOrEmpty(docRef.ZingzeuId)
? (int?)null : int.Parse(docRef.ZingzeuId, NumberStyles.HexNumber);
var maybeWord = maybeWordId == null
? null
: await _dbContext.Words
.Where(w => w.WordId == maybeWordId)
.Include(w => w.PreferredSandhiAudio)
.SingleOrDefaultAsync();
if (maybeYngdiengDocument == null && maybeWord == null)
{
throw new RpcException(new Status(StatusCode.NotFound, "Not found."));
}
var extensions = await _dbContext.Extensions.Where(e => e.WordId == maybeWordId).ToListAsync();
var prons = await _dbContext.Prons.Where(p => p.WordId == maybeWordId).ToListAsync();
var hanzi = zhConverter.tH(await GetHanzi(_dbContext, maybeYngdiengDocument, maybeWordId));
var recommendedProns = mode == Mode.Snippet
? PronChooser.GetSnippetPronunciations(maybeYngdiengDocument, prons, maybeWord?.PreferredSandhiAudio)
: PronChooser.GetRecommendedPronunciations(maybeYngdiengDocument, prons, maybeWord?.PreferredSandhiAudio);
var explanations = mode == Mode.Snippet
? Enumerable.Empty <RichTextNode>()
: GetExplanations(zhConverter, hanzi, maybeYngdiengDocument, extensions);
var audioCards = mode == Mode.Snippet ? Enumerable.Empty <Word.Types.AudioCard>()
: await GetAudioCards(_dbContext, recommendedProns, maybeWordId);
var wordLists = mode == Mode.Full && maybeWordId.HasValue
? await Queries.QueryWordListsByWordId(_dbContext, maybeWordId.Value).Select(wl => Renderers.ToWordList(wl)).ToListAsync()
: Enumerable.Empty <WordList>();
return(new Word
{
Name = ResourceNames.ToWordName(docRef),
Hanzi = hanzi,
Pronunciations = { recommendedProns },
Explanation = { explanations },
Snippet = zhConverter.tH(GetSnippet(maybeYngdiengDocument, extensions)),
AudioCards = { audioCards },
WordLists =
{
wordLists
}
});
}
public override Task <SearchV2Response> SearchV2(SearchV2Request request,
ServerCallContext context)
{
var userPreference = UserPreferences.FromContext(context);
var query = GetLuceneQuery(QueryParser.Parse(request.Query));
var desiredPageSize = request.PageSize > 0 ? request.PageSize : DefaultPageSize;
var searcher = this._indexHolder.LuceneIndexSearcher;
var resultCards = new List <SearchV2Response.Types.SearchCard>();
TopDocs results;
if (string.IsNullOrEmpty(request.PageToken))
{
// Is first page
results = searcher.Search(query, userPreference.ShowSourcelessSearchResults ? null : FilterSourcelessDocs, desiredPageSize + 1);
// first page && no results
if (results.ScoreDocs.Length == 0)
{
return(Task.FromResult(new SearchV2Response
{
ResultCards = { NoResultsCard() }
}));
}
}
else
{
var lastPage = PaginationTokens.Parse(request.PageToken);
var lastScoreDoc = new ScoreDoc(lastPage.LastDoc.Doc, lastPage.LastDoc.Score);
results = searcher.SearchAfter(lastScoreDoc, query, userPreference.ShowSourcelessSearchResults ? null : FilterSourcelessDocs, desiredPageSize + 1);
}
var zhConverter = new ZhConverter(_openCc, userPreference.ZhConversionPreference);
var response = new SearchV2Response();
var isEndOfResults = results.ScoreDocs.Length < desiredPageSize + 1;
if (isEndOfResults)
{
resultCards.AddRange(RenderDocs(results.ScoreDocs, zhConverter));
resultCards.Add(EndOfResultsCard());
}
else
{
var visibleRange = results.ScoreDocs.Take(desiredPageSize);
var nextPageToken = PaginationTokens.FromScoreDoc(visibleRange.Last());
response.NextPageToken = nextPageToken;
resultCards.AddRange(RenderDocs(visibleRange, zhConverter));
}
response.ResultCards.AddRange(resultCards);
return(Task.FromResult(response));
}
public override void SetContent(int index, Dictionary <string, object> data)
{
m_poemData = (poemDataGenerate)data["poemData"];
if (LanguageManager.s_currentLanguage == SystemLanguage.ChineseTraditional)
{
SetText("Text_poemName", ZhConverter.Convert(m_poemData.m_poemName, ZhConverter.To.Traditional));
SetText("Text_author", ZhConverter.Convert(m_poemData.m_author, ZhConverter.To.Traditional));
}
else
{
SetText("Text_poemName", m_poemData.m_poemName);
SetText("Text_author", m_poemData.m_author);
}
}
public override void SetContent(int index, Dictionary <string, object> data)
{
string content = (string)data["content"];
if (content.Contains("space"))
{
SetText("Text", "");
}
else
{
if (LanguageManager.s_currentLanguage == SystemLanguage.ChineseTraditional)
{
SetText("Text", ZhConverter.Convert(content, ZhConverter.To.Traditional));
}
else
{
SetText("Text", content);
}
}
}
private static RichTextNode[] GetExplanations(
ZhConverter zhConverter,
string hanzi,
YngdiengDocument?maybeYngdiengDocument,
IEnumerable <Extension> extensions
)
{
var output = new List <RichTextNode>();
var fengDocs = maybeYngdiengDocument?.Sources
.Where(s => s.SourceCase == YngdiengDocument.Types.Source.SourceOneofCase.Feng).Select(s => s.Feng)
?? Enumerable.Empty <FengDocument>();
var fengRenderer = new FengRichTextRenderer(zhConverter);
output.AddRange(fengDocs.Select(f => fengRenderer.ToRichTextNode(f)));
var hDocs = maybeYngdiengDocument?.Sources
.Where(s => s.SourceCase == YngdiengDocument.Types.Source.SourceOneofCase.CiklinDfd)
.Select(s => s.CiklinDfd)
.ToList()
?? new List <HistoricalDocument>();
var histRenderer = new HistoricalRichTextRenderer(zhConverter);
output.AddRange(hDocs.Select(hDoc => histRenderer.ToRichTextNode(hDoc)));
var extRenderer = new ExtensionRichTextRenderer(zhConverter);
output.AddRange(extensions.Select(e => extRenderer.ToRichTextNode(hanzi, e.Explanation, e.Source, e.Contributors)));
if (extensions.Count() == 0)
{
var contribFromIndex = maybeYngdiengDocument?.Sources
.Where(s => s.SourceCase == YngdiengDocument.Types.Source.SourceOneofCase.Contrib)
.Select(s => s.Contrib) ?? Enumerable.Empty <ContribDocument>();
var contribRenderer = new ContribRichTextRenderer(zhConverter);
output.AddRange(contribFromIndex.Select(c => contribRenderer.ToRichTextNode(c)));
}
return(output.ToArray());
}
static void CreateAnswer()
{
PuzzleService.Reset();
//去掉已出的所有句子
for (int i = 0; i <= s_currentLine; i++)
{
PuzzleService.RemoveSentence(currentPoemData.m_content[i]);
}
PuzzleService.RemoveSentence(GetCurrentContent());
s_correctIndex = GetRandomIndex(true);
//正确答案
m_questions[s_correctIndex] = GetCurrentContent();
//错误答案
m_questions[GetRandomIndex(false)] = PuzzleService.GetErrorAnswer(GetCurrentContent());
m_questions[GetRandomIndex(false)] = PuzzleService.GetErrorAnswer(GetCurrentContent());
m_questions[GetRandomIndex(false)] = PuzzleService.GetErrorAnswer(GetCurrentContent());
if (LanguageManager.s_currentLanguage == SystemLanguage.ChineseTraditional)
{
m_questions[0] = ZhConverter.Convert(m_questions[0], ZhConverter.To.Traditional);
m_questions[1] = ZhConverter.Convert(m_questions[1], ZhConverter.To.Traditional);
m_questions[2] = ZhConverter.Convert(m_questions[2], ZhConverter.To.Traditional);
m_questions[3] = ZhConverter.Convert(m_questions[3], ZhConverter.To.Traditional);
}
if (s_GameModel == GameModel.Arcade && HP == 0)
{
return;
}
GlobalEvent.DispatchEvent(GameEventEnum.QuestionChange);
}
private IEnumerable <SearchV2Response.Types.SearchCard> RenderDocs(IEnumerable <ScoreDoc> scoreDocs, ZhConverter zhConverter)
{
var searcher = this._indexHolder.LuceneIndexSearcher;
return(scoreDocs.Select(sd =>
{
var docId = searcher.Doc(sd.Doc).GetField(LuceneUtils.Fields.DocId).GetStringValue();
var ydDoc = _indexHolder.GetIndex().YngdiengDocuments.Single(y => y.DocId == docId);
return new SearchV2Response.Types.SearchCard
{
Word = new SearchV2Response.Types.SearchCard.Types.WordCard
{
Id = docId,
Yngping = RichTextUtil.FromString(ydDoc.YngpingSandhi.OrElse(ydDoc.YngpingUnderlying)),
Hanzi = RichTextUtil.FromString(zhConverter.tH(HanziUtils.HanziToString(ydDoc.HanziCanonical))),
Details = RichTextUtil.FromString(zhConverter.tM(Yngdieng.Backend.Services.Frontend.Words.GetSnippet
(ydDoc, new Extension[] { }))),
Score = sd.Score
}
};
}));
}
public FengRichTextRenderer(ZhConverter zhConverter, StructuredExplanationRenderer explanationRenderer)
{
this.zc = zhConverter;
this.explanationRenderer = explanationRenderer;
}
public ExtensionRichTextRenderer(ZhConverter zhConverter)
{
this.zc = zhConverter;
this.explanationRenderer = new StructuredExplanationRenderer(zhConverter);
}
public HistoricalRichTextRenderer(ZhConverter zhConverter)
{
this.zc = zhConverter;
}
public StructuredExplanationRenderer(ZhConverter zhConverter)
{
this.zc = zhConverter;
}
