コード例 #1
0
        public async Task <ClientResponseWithObject <IEnumerable <PrcKeywordsResult> > > KeywordsAsync(string serviceId, PrcKeywordsRequest prcKeywordsRequest, bool isStrict = false)
        {
            var queryParameters = new Dictionary <string, string>
            {
                ["isStrict"] = isStrict.ToString(),
            };

            return(await _client.SendAsync <IEnumerable <PrcKeywordsResult> >(HttpMethod.Post, prcKeywordsRequest, $"{serviceId}/{KeywordsEndpointSuffix}", queryParameters, null));
        }
コード例 #2
0
        public IActionResult Keywords(string id, [FromBody] PrcKeywordsRequest request, [FromQuery] bool isStrict = false)
        {
            // If Id is Alias, translate to Id
            if (GlobalStore.ServiceAliases.IsExist(id))
            {
                id = GlobalStore.ServiceAliases.Get(id);
            }

            if (!GlobalStore.ActivatedPrcs.IsExist(id))
            {
                return(new HttpStatusCodeWithErrorResult(StatusCodes.Status400BadRequest, string.Format(ServiceResources.ServiceNotExistsOrNotActivated, ServiceTypeEnum.Prc)));
            }
            if (!string.IsNullOrEmpty(request.TagId) && !GlobalStore.ActivatedPrcs.Get(id).PrcsSettings.Tags.Any(t => t.Id == request.TagId))
            {
                return(new HttpStatusCodeWithErrorResult(StatusCodes.Status400BadRequest, ServiceResources.TheGivenTagIsMissingFromThePRCService));
            }

            var dataSet      = GlobalStore.DataSets.Get(GlobalStore.ActivatedPrcs.Get(id).PrcsSettings.DataSetName).DataSet;
            var analyzeQuery = queryFactory.GetAnalyzeQuery(dataSet.Name);

            var tokens = analyzeQuery.Analyze(request.Text, 1).ToList();
            var text   = string.Join(" ", tokens);

            var tagId = string.Empty;

            if (!string.IsNullOrEmpty(request.TagId))
            {
                tagId = request.TagId;
            }
            else
            {
                //ha nincs megadva tagId akkor kiszámoljuk a prc scorer-ekkel
                var allResults = new List <KeyValuePair <string, double> >();
                foreach (var scorerKvp in GlobalStore.ActivatedPrcs.Get(id).PrcScorers)
                {
                    var score = scorerKvp.Value.GetScore(text, 1.7, true);
                    allResults.Add(new KeyValuePair <string, double>(scorerKvp.Key, score));
                }
                var resultsList = allResults.Where(r => r.Value > 0).OrderByDescending(r => r.Value).ToList();
                if (resultsList.Count == 0)
                {
                    return(new OkObjectResult(new List <PrcRecommendationResult>()));
                }
                tagId = resultsList.First().Key;
            }

            var globalSubset = GlobalStore.ActivatedPrcs.Get(id).PrcSubsets[tagId];

            if (globalSubset.WordsWithOccurences == null)
            {
                return(new HttpStatusCodeWithErrorResult(StatusCodes.Status406NotAcceptable, ServiceResources.TheGivenTagHasNoWordsInDictionary));
            }
            var wordsInDic = globalSubset.WordsWithOccurences.Keys.Intersect(tokens).ToList();

            var baseSubset = new Cerebellum.Subset
            {
                AllWordsOccurencesSumInCorpus = globalSubset.AllWordsOccurencesSumInCorpus,
                AllWordsOccurencesSumInTag    = globalSubset.AllWordsOccurencesSumInTag,
                WordsWithOccurences           = wordsInDic.ToDictionary(w => w, w => globalSubset.WordsWithOccurences[w])
            };
            var baseDic = new Cerebellum.Dictionary.TwisterAlgorithm(baseSubset, true, false).GetDictionary().OrderByDescending(d => d.Value).ToList();

            if (isStrict)
            {
                var avg = baseDic.Sum(d => d.Value) / baseDic.Count;
                baseDic.RemoveAll(d => d.Value < avg);
            }
            return(new OkObjectResult(baseDic.Select(d => new PrcKeywordsResult {
                Word = d.Key, Score = d.Value
            })));
        }