Exemple #1
0
        public Task <UrbanEmbed> WithDefinitionAsync(
            UrbanDefinition definition,
            string query,
            string userPicture,
            int pagesCount,
            int page = 1)
        {
            WithTitle(definition.Word);
            WithUrl(definition.Permalink);
            WithAuthor(new EmbedAuthorBuilder()
            {
                Name    = "Urban Dictionary",
                Url     = "https://www.urbandictionary.com/",
                IconUrl = userPicture
            });

            WithTimestamp(definition.WrittenOn);
            WithColor(new Color(221, 92, 46));
            WithFooter($"{page}/{pagesCount} | {definition.Author}");
            this.WithMetadata(new UrbanEmbedMetadata {
                PageNumber = page, SearchQuery = query
            });

            WithDescription(CreateLinks(definition.Definition));

            AddField("Example", CreateLinks(definition.ExampleUsage));
            AddField("👍", definition.ThumbsUp, inline: true);
            AddField("👎", definition.ThumbsDown, inline: true);

            return(Task.FromResult(this));
        }
Exemple #2
0
        private async Task <string> GetDefinition(string term)
        {
            try
            {
                var uri = new Uri(string.Format(_options.IanUrbanDictionaryEndpoint,
                                                HttpUtility.UrlEncode(term)));
                var response = await _fetchService.GetAsync <UrbanResponse>(uri);

                if (response?.IsSuccessful == true)
                {
                    var definitions = response.Data;

                    if (definitions?.List?.Length > 0)
                    {
                        string[] swaps = null;

                        if (!string.IsNullOrEmpty(_options.IanUrbanDictionarySwap))
                        {
                            if (_options.IanUrbanDictionarySwap.Contains(','))
                            {
                                swaps = _options.IanUrbanDictionarySwap.Split(',');
                            }
                            else
                            {
                                swaps = new string[1] {
                                    _options.IanUrbanDictionarySwap
                                };
                            }
                        }

                        if (definitions.List.Length >= 2 &&
                            swaps?.SingleOrDefault(_ => _ == term.Trim()) != null)
                        {
                            var revised = new UrbanDefinition[definitions.List.Length];
                            Array.Copy(definitions.List, 1, revised, 0, 1);
                            Array.Copy(definitions.List, 0, revised, 1, 1);
                            Array.Copy(definitions.List, 2, revised, 2, definitions.List.Length - 2);
                            definitions.List = revised;
                        }
                        await _cache.RemoveAsync(CacheKey);

                        await _cache.SetStringAsync(CacheKey,
                                                    JsonSerializer.Serialize(new CachedDefinitions
                        {
                            CreatedAt = DateTime.Now,
                            List      = definitions.List
                        }));

                        return(FormatDefinition(definitions.List, 0));
                    }
                    else
                    {
                        return($"You are making stuff up, **{term}** is not a word!");
                    }
                }
                else
                {
                    return($"The Urban Gods are angered by your query: {response?.Message ?? "...and I don't know why."}");
                }
            }
            catch (Exception ex)
            {
                return($"The Urban Gods have rejected your query ({ex.Message}).");
            }
        }