Exemple #1
0
        public void SlugifyTaxonomy_replaces_hashtag_with_letter_s()
        {
            var expected = "cs";
            var actual   = BlogUtil.SlugifyTaxonomy("c#", CategoryService.SLUG_MAXLEN);

            Assert.Equal(expected, actual);
        }
Exemple #2
0
        public void SlugifyTaxonomy_trucates_long_slug_and_keeps_only_24_chars()
        {
            var expected = "this-is-a-really-long-ca";
            var actual   = BlogUtil.SlugifyTaxonomy("this is a really long category title", CategoryService.SLUG_MAXLEN);

            Assert.Equal(expected, actual);
        }
Exemple #3
0
        /// <summary>
        /// Creates a new <see cref="Tag"/>.
        /// </summary>
        /// <param name="tag">The tag with data to be created.</param>
        /// <exception cref="MokException">If tag is empty or title exists already.</exception>
        /// <returns>Created tag.</returns>
        public async Task <Tag> CreateAsync(Tag tag)
        {
            if (tag == null || tag.Title.IsNullOrEmpty())
            {
                throw new MokException($"Invalid tag to create.");
            }

            // prep title
            tag.Title = PrepareTitle(tag.Title);

            // make sure it is unique
            var allTags = await GetAllAsync();

            if (allTags.Any(t => t.Title.Equals(tag.Title, StringComparison.CurrentCultureIgnoreCase)))
            {
                throw new MokException($"'{tag.Title}' already exists.");
            }

            // prep slug, description and count
            tag.Slug        = BlogUtil.SlugifyTaxonomy(tag.Title, SLUG_MAXLEN, allTags.Select(c => c.Slug)); // slug is based on title
            tag.Description = Util.CleanHtml(tag.Description);
            tag.Count       = tag.Count;

            // create
            tag = await tagRepository.CreateAsync(tag);

            // remove cache
            await cache.RemoveAsync(BlogCache.KEY_ALL_TAGS);

            await cache.RemoveAsync(BlogCache.KEY_POSTS_INDEX);

            logger.LogDebug("Created {@Tag}", tag);
            return(tag);
        }
Exemple #4
0
        /// <summary>
        /// Updates an existing <see cref="Category"/>.
        /// </summary>
        /// <param name="category">The category with data to be updated.</param>
        /// <exception cref="MokException">If category is invalid or title exists.</exception>
        /// <returns>Updated category.</returns>
        public async Task <Category> UpdateAsync(Category category)
        {
            if (category == null || category.Id <= 0 || category.Title.IsNullOrEmpty())
            {
                throw new MokException($"Invalid category to update.");
            }

            // prep title
            category.Title = PrepareTitle(category.Title);

            // make sure it is unique
            var allCats = await GetAllAsync();

            allCats.RemoveAll(c => c.Id == category.Id); // remove selft
            if (allCats.Any(c => c.Title.Equals(category.Title, StringComparison.CurrentCultureIgnoreCase)))
            {
                throw new MokException($"'{category.Title}' already exists.");
            }

            // prep slug, description and count
            var entity = await categoryRepository.GetAsync(category.Id);

            entity.Title       = category.Title;                                                                     // assign new title
            entity.Slug        = BlogUtil.SlugifyTaxonomy(category.Title, SLUG_MAXLEN, allCats.Select(c => c.Slug)); // slug is based on title
            entity.Description = Util.CleanHtml(category.Description);
            entity.Count       = category.Count;

            // update
            await categoryRepository.UpdateAsync(category);

            // remove cache
            await cache.RemoveAsync(BlogCache.KEY_ALL_CATS);

            await cache.RemoveAsync(BlogCache.KEY_POSTS_INDEX);

            // raise nav updated event
            await mediator.Publish(new NavUpdated { Id = category.Id, Type = ENavType.BlogCategory });

            // return entity
            logger.LogDebug("Updated {@Category}", entity);
            return(entity);
        }
Exemple #5
0
        /// <summary>
        /// Updates an existing <see cref="Tag"/>.
        /// </summary>
        /// <param name="tag">The tag with data to be updated.</param>
        /// <exception cref="FanException">If tag is invalid or title exists already.</exception>
        /// <returns>Updated tag.</returns>
        public async Task <Tag> UpdateAsync(Tag tag)
        {
            if (tag == null || tag.Id <= 0 || tag.Title.IsNullOrEmpty())
            {
                throw new FanException($"Invalid tag to update.");
            }

            // prep title
            tag.Title = PrepareTitle(tag.Title);

            // make sure it is unique
            var allTags = await GetAllAsync();

            allTags.RemoveAll(t => t.Id == tag.Id); // remove self
            if (allTags.Any(t => t.Title.Equals(tag.Title, StringComparison.CurrentCultureIgnoreCase)))
            {
                throw new FanException($"'{tag.Title}' already exists.");
            }

            // prep slug, description and count
            var entity = await _tagRepo.GetAsync(tag.Id);

            entity.Title       = tag.Title;                                                                     // assign new title
            entity.Slug        = BlogUtil.SlugifyTaxonomy(tag.Title, SLUG_MAXLEN, allTags.Select(c => c.Slug)); // slug is based on title
            entity.Description = Util.CleanHtml(tag.Description);
            entity.Count       = tag.Count;

            // update
            await _tagRepo.UpdateAsync(entity);

            // remove cache
            await _cache.RemoveAsync(BlogCache.KEY_ALL_TAGS);

            await _cache.RemoveAsync(BlogCache.KEY_POSTS_INDEX);

            // return entity
            _logger.LogDebug("Updated {@Tag}", entity);
            return(entity);
        }
Exemple #6
0
        /// <summary>
        /// Creates a new <see cref="Category"/>.
        /// </summary>
        /// <param name="category">The category with data to be created.</param>
        /// <exception cref="MokException">If title is empty or exists already.</exception>
        /// <returns>Created category.</returns>
        public async Task <Category> CreateAsync(string title, string description = null)
        {
            if (title.IsNullOrEmpty())
            {
                throw new MokException($"Category title cannot be empty.");
            }

            // prep title
            title = PrepareTitle(title);

            // make sure unique
            var allCats = await GetAllAsync();

            if (allCats.Any(t => t.Title.Equals(title, StringComparison.CurrentCultureIgnoreCase)))
            {
                throw new MokException($"'{title}' already exists.");
            }

            // prep slug, desc and count
            var category = new Category
            {
                Title       = title,
                Slug        = BlogUtil.SlugifyTaxonomy(title, SLUG_MAXLEN, allCats.Select(c => c.Slug)),
                Description = Util.CleanHtml(description),
                Count       = 0,
            };

            // create
            category = await categoryRepository.CreateAsync(category);

            // remove cache
            await cache.RemoveAsync(BlogCache.KEY_ALL_CATS);

            await cache.RemoveAsync(BlogCache.KEY_POSTS_INDEX);

            logger.LogDebug("Created {@Category}", category);
            return(category);
        }
Exemple #7
0
 public void SlugifyTaxonomy_returns_unique_slug_by_append_counter_to_duplicate(string input, string expected, IEnumerable <string> existing = null)
 {
     Assert.Equal(expected, BlogUtil.SlugifyTaxonomy(input, CategoryService.SLUG_MAXLEN, existing));
 }
Exemple #8
0
        public void SlugifyTaxonomy_produces_8chars_string_when_input_is_non_english()
        {
            var actual = BlogUtil.SlugifyTaxonomy("你好", CategoryService.SLUG_MAXLEN);

            Assert.True(actual.Length == 6);
        }