Example #1
0
        public async Task <BlogPostDto> Handle(GetBlogPostQuery query)
        {
            var postId = query.Id;

            var blogPost = await _blogRepository.GetBlogPostWithNoImages(postId);

            var postAsHtml = await _markdownService.ConvertToHtml(blogPost.Content);

            for (var i = 0; i < 20; i++)
            {
                var number = $"{i:00}";
                var src    = $"{number}.png";
                var dest   = $"/api/blog/{postId}/{number}";

                postAsHtml = postAsHtml.Replace(src, dest);
            }

            return(new BlogPostDto
            {
                Id = postId,
                Date = DateTime.Now,
                Title = "Test title",
                Content = postAsHtml,
                Tags = _tagMapper.Map(blogPost.Tags).ToList()
            });
        }
Example #2
0
        public async Task <List <TagModel> > GetTopBySearchTagAsync(string searchTag, int count)
        {
            List <TagModel> tagModels;

            using (var uow = _unitOfWorkFactory.GetUnitOfWork())
            {
                var tags = await uow.TagRepository.GetAll()
                           .Where(t => t.Name.Contains(searchTag))
                           .OrderBy(t => t.Name.IndexOf(searchTag))
                           .ThenBy(t => t.Name)
                           .Take(count)
                           .ToListAsync();

                tagModels = tags.Select(t => tagMapper.Map(t)).ToList();
            }
            return(tagModels);
        }
 public BlogPostHeaderDto Map(BlogPostHeader p)
 {
     return(new BlogPostHeaderDto
     {
         Id = p.Id,
         Title = p.Title,
         Text = p.Header,
         Published = p.PublishingDate,
         Tags = _tagMapper.Map(p.Tags).ToList()
     });
 }
        public List <WordTranslationModel> Post(List <WordTranslationImportModel> wordTranslations)
        {
            List <WordTranslationModel> wordTranslationsToReturn = new List <WordTranslationModel>();

            foreach (WordTranslationImportModel wordTranslation in wordTranslations)
            {
                wordTranslation.OriginalWordId = wordService.Exists(wordTranslation.OriginalWord, wordTranslation.LanguageId);

                if (wordTranslation.OriginalWordId == 0)
                {
                    wordTranslation.OriginalWordId = wordService.Add(wordMapper.ToDomainModel(new WordModel()
                    {
                        Value         = wordTranslation.OriginalWord,
                        LanguageId    = wordTranslation.LanguageId,
                        Transcription = wordTranslation.Transcription,
                        Description   = wordTranslation.Description
                    }));
                }

                wordTranslation.TranslationWordId = wordService.Exists(wordTranslation.TranslationWord, TranslationLanguageId);

                if (wordTranslation.TranslationWordId == 0)
                {
                    wordTranslation.TranslationWordId = wordService.Add(wordMapper.ToDomainModel(new WordModel()
                    {
                        Value      = wordTranslation.TranslationWord,
                        LanguageId = TranslationLanguageId
                    }));
                }


                foreach (TagModel tag in wordTranslation.Tags)
                {
                    tag.Id = tagService.Exists(tag.Name);

                    if (tag.Id == 0)
                    {
                        tag.Id = tagService.Add(tagMapper.Map(tag));
                    }
                }

                wordTranslation.OwnerId = UserId;
                int wordTranslationId = wordTranslationService.Add(wordTranslationMapper.Map(wordTranslation, tagMapper.MapRange(wordTranslation.Tags)));

                wordTranslationsToReturn.Add(new WordTranslationModel()
                {
                    Id              = wordTranslationId,
                    OriginalWord    = wordTranslation.OriginalWord,
                    TranslationWord = wordTranslation.TranslationWord
                });
            }

            return(wordTranslationsToReturn);
        }
        public async Task Execute(UploadBlogPostCommand command)
        {
            var postFile   = command.Files.FirstOrDefault(f => f.FileName.EndsWith(".md"));
            var imageFiles = command.Files.Where(f => !f.FileName.EndsWith(".md"));

            var postFileContent          = Encoding.UTF8.GetString(postFile.Data, 0, postFile.Data.Length);
            var processingMetadataResult = _postMetadataResolver.Resolve(postFileContent);
            var metadata = processingMetadataResult.Result;

            var date   = metadata.PublishedDate ?? DateTime.Now;
            var postId = metadata.Id;
            var tags   = _tagMapper.Map(metadata.Categories?.ToArray());

            var blogPost = new BlogPost
            {
                Id             = postId,
                Title          = metadata.Title,
                Content        = postFileContent,
                Header         = metadata.Header,
                PublishingDate = date,
                Status         = (metadata.PostType == BlogPostMetadata.PostTypeEnum.Article) ?
                                 BlogStatusTypeEnum.Active :
                                 BlogStatusTypeEnum.Page,
                Images = new List <BlogPostImage>(),
                Tags   = tags
            };

            foreach (var imageFile in imageFiles)
            {
                var fileName      = Path.GetFileNameWithoutExtension(imageFile.FileName);
                var blogPostImage = new BlogPostImage
                {
                    Id   = fileName,
                    Data = imageFile.Data
                };

                blogPost.Images.Add(blogPostImage);
            }

            var existingPost = await _blogRepository.GetBlogPostWithNoImages(postId);

            var isPostExists = existingPost != null;

            if (isPostExists)
            {
                await _blogRepository.DeleteBlogPost(postId);
            }

            await _blogRepository.Add(blogPost);
        }
        public async Task <WordTranslationFullModel> GetWordFullInformationAsync(string word, int originalLangId, int translationLangId)
        {
            WordTranslationFullModel infoWord = new WordTranslationFullModel
            {
                OriginalWord = word
            };

            using (var uow = unitOfWorkFactory.GetUnitOfWork())
            {
                Word origWord = await uow.WordRepository.GetAll()
                                .Where(w => w.Value == word && w.LanguageId == originalLangId)
                                .FirstOrDefaultAsync();

                infoWord.Id             = origWord.Id;
                infoWord.Description    = origWord.Description;
                infoWord.Transcription  = origWord.Transcription;
                infoWord.PartOfSpeechId = origWord.PartOfSpeechId;
                infoWord.Comment        = origWord.Comment;

                if (await GetAmountOfTranslations(origWord.Id, translationLangId) > 0)
                {
                    List <Word> translations = await uow.WordTranslationRepository.GetAll()
                                               .Where(x => x.OriginalWord.Value == word && x.OriginalWord.LanguageId == originalLangId &&
                                                      x.TranslationWord.LanguageId == translationLangId)
                                               .Select(x => x.TranslationWord)
                                               .ToListAsync();

                    infoWord.Translations = translations.Select(x => wordMapper.ToValueModel(x)).ToList();
                }
                if (await GetAmountOfTranslations(origWord.Id, originalLangId) > 0)
                {
                    List <Word> synonims = await uow.WordTranslationRepository.GetAll()
                                           .Where(x => x.OriginalWord.Value == word && x.OriginalWord.LanguageId == originalLangId &&
                                                  x.TranslationWord.LanguageId == originalLangId)
                                           .Select(x => x.TranslationWord)
                                           .ToListAsync();

                    infoWord.Synonims = synonims.Select(x => wordMapper.ToValueModel(x)).ToList();
                }
                if (origWord.Tags.Count > 0)
                {
                    List <Tag> tags = origWord.Tags.ToList();
                    infoWord.Tags = tags.Select(x => tagMapper.Map(x)).ToList();
                }
            }
            return(infoWord);
        }