public void CreateArticle(string username, int blogId, Article article)
        {
            Member    existingMember = _memberDomain.GetMemberByUsername(username);
            BlogSpace exisitingBlog  = _blogDomain.GetBlogById(blogId);

            if (exisitingBlog != null && existingMember != null)
            {
                if (_memberDomain.RelationWithBlogSpace(existingMember.MemberId, exisitingBlog.BlogSpaceId))
                {
                    Article existingArticle = _articleRepository
                                              .GetAllArticles()
                                              .Include(item => item.BlogSpace)
                                              .FirstOrDefault(item => item.ArticleTitle.Trim().ToUpper() == article.ArticleTitle.Trim().ToUpper() &&
                                                              item.BlogSpace.BlogSpaceId == exisitingBlog.BlogSpaceId);
                    if (exisitingBlog == null)
                    {
                        _articleRepository.CreateArticle(new Article()
                        {
                            ArticleCreation         = article.ArticleCreation,
                            ArticleLastModification = article.ArticleLastModification,
                            ArticleTitle            = article.ArticleTitle,
                            BlogSpace = exisitingBlog
                        });
                    }
                }
            }
        }
        public List <Article> GetAllArticles(string username, int blogId)
        {
            Member existingMember = _memberDomain.GetMemberByUsername(username);

            if (existingMember != null)
            {
                if (_memberDomain.RelationWithBlogSpace(existingMember.MemberId, blogId))
                {
                    BlogSpace exisitingBlog = _blogDomain.GetBlogById(blogId);
                    return(exisitingBlog.Articles.ToList());
                }
            }

            return(null);
        }
        public bool UpdateBlog(BlogSpace obj)
        {
            bool status = false;

            using (dbcon = new Context())
            {
                dbcon.BlogSpaces.Add(obj);
                int changes = dbcon.SaveChanges();
                if (changes > 0)
                {
                    status = true;
                }
            }
            return(status);
        }
Beispiel #4
0
        public bool UpdateBlog(BlogSpace obj)
        {
            bool status = false;

            using (dbcon = new TourismWebsiteDBEntities())
            {
                dbcon.BlogSpaces.Add(obj);
                int changes = dbcon.SaveChanges();
                if (changes > 0)
                {
                    status = true;
                }
            }

            return(status);
        }
        public void DelteBlogSpace(string username, int blogId)
        {
            Member exisitingMember = _memberRepository
                                     .GetAllMembers()
                                     .FirstOrDefault(item => item.MemberUserName == username);
            BlogSpace exisitingBlogSpace = _blogRepository
                                           .GetAllBlogSpaces()
                                           .FirstOrDefault(item => item.BlogSpaceId == blogId);

            if (exisitingMember != null && exisitingBlogSpace != null)
            {
                if (_memberDomainService.RelationWithBlogSpace(exisitingMember.MemberId, blogId))
                {
                    _blogRepository.DeleteBlogSpace(exisitingBlogSpace);
                }
            }
        }
        public bool RelationWithBlogSpace(int memberId, int blogId)
        {
            Member existingMember = _memberRepository.GetMemberById(memberId);

            if (existingMember != null)
            {
                BlogSpace existingSpace = _blogSpaceRepository
                                          .GetAllBlogSpaces()
                                          .Include(item => item.Member)
                                          .FirstOrDefault(item => item.Member.MemberId == memberId &&
                                                          item.BlogSpaceId == blogId);
                if (existingSpace != null)
                {
                    return(true);
                }
            }
            return(false);
        }
        public bool RelationWithArticle(int blogId, int articleId)
        {
            BlogSpace existing = _blogRepository.GetBlogSpaceById(blogId);

            if (existing != null)
            {
                Article existingArticle = _articleRepository
                                          .GetAllArticles()
                                          .Include(item => item.BlogSpace)
                                          .FirstOrDefault(item => item.ArticleId == articleId &&
                                                          item.BlogSpace.BlogSpaceId == blogId);
                if (existingArticle != null)
                {
                    return(true);
                }
            }
            return(false);
        }
        public void DeleteArticle(string username, int blogId, int articleId)
        {
            Member    exisitingMember = _memberDomain.GetMemberByUsername(username);
            BlogSpace existingBlog    = _blogDomain.GetBlogById(blogId);

            if (exisitingMember != null && existingBlog != null)
            {
                if (_memberDomain.RelationWithBlogSpace(exisitingMember.MemberId, existingBlog.BlogSpaceId))
                {
                    Article exisitingArticle = _articleRepository
                                               .GetAllArticles()
                                               .Include(item => item.BlogSpace)
                                               .FirstOrDefault(item => item.BlogSpace.BlogSpaceId == blogId &&
                                                               item.ArticleId == articleId);
                    if (exisitingArticle != null)
                    {
                        _articleRepository.DeleteArticle(exisitingArticle);
                    }
                }
            }
        }
        public void ModifyArticle(string username, int blogId, Article article)
        {
            Member    exisitingMember   = _memberDomain.GetMemberByUsername(username);
            BlogSpace existingBlogSpace = _blogDomain.GetBlogById(blogId);

            if (exisitingMember != null && existingBlogSpace != null)
            {
                if (_memberDomain.RelationWithBlogSpace(exisitingMember.MemberId, existingBlogSpace.BlogSpaceId))
                {
                    Article existingArticle = _articleRepository
                                              .GetAllArticles()
                                              .Include(item => item.BlogSpace)
                                              .FirstOrDefault(item => item.BlogSpace.BlogSpaceId == blogId &&
                                                              item.ArticleId == article.ArticleId);
                    if (exisitingMember != null)
                    {
                        existingArticle.ArticleCreation         = article.ArticleCreation;
                        existingArticle.ArticleLastModification = article.ArticleLastModification;
                        existingArticle.ArticleTitle            = article.ArticleTitle;
                        _articleRepository.ModfiyArticle();
                    }
                }
            }
        }
        public void CreateBlogSpace(string username, BlogSpace blogSpace)
        {
            Member existingMember = _memberRepository.GetAllMembers().FirstOrDefault(item => item.MemberUserName == username);

            if (existingMember != null)
            {
                BlogSpace exisitingBlog = _blogRepository
                                          .GetAllBlogSpaces()
                                          .Include(item => item.Member)
                                          .FirstOrDefault(item => item.BlogSpaceTitle.Trim().ToUpper() == blogSpace.BlogSpaceTitle.Trim().ToUpper() &&
                                                          item.Member.MemberUserName == username);
                if (exisitingBlog == null)
                {
                    _blogRepository.ChangeEntityState(existingMember, EntityState.Unchanged);
                    BlogSpace toCreate = new BlogSpace()
                    {
                        BlogSpaceIsPublic = blogSpace.BlogSpaceIsPublic,
                        BlogSpaceTitle    = blogSpace.BlogSpaceTitle,
                        Member            = existingMember
                    };
                    _blogRepository.CreateBlogSpace(toCreate);
                }
            }
        }
        public void ModifyBlogSpace(string username, BlogSpace blogSpace)
        {
            Member exisitingMember = _memberRepository
                                     .GetAllMembers()
                                     .FirstOrDefault(item => item.MemberUserName == username);

            BlogSpace exisitingBlogSpace = _blogRepository
                                           .GetAllBlogSpaces()
                                           .FirstOrDefault(item => item.BlogSpaceId == blogSpace.BlogSpaceId);

            BlogSpace possiblyDuplicate = _blogRepository
                                          .GetAllBlogSpaces()
                                          .FirstOrDefault(item => item.BlogSpaceTitle.Trim().ToUpper() == blogSpace.BlogSpaceTitle.Trim().ToUpper());

            if (exisitingBlogSpace != null && exisitingMember != null && possiblyDuplicate == null)
            {
                if (_memberDomainService.RelationWithBlogSpace(exisitingMember.MemberId, blogSpace.BlogSpaceId))
                {
                    exisitingBlogSpace.BlogSpaceIsPublic = blogSpace.BlogSpaceIsPublic;
                    exisitingBlogSpace.BlogSpaceTitle    = blogSpace.BlogSpaceTitle;
                    _blogRepository.ModifyBlog();
                }
            }
        }
Beispiel #12
0
 public void ModifyBlogSpace(String username, [FromBody] BlogSpace blogSpace)
 {
     _blogApplicationService.ModifyBlogSpace(username, blogSpace);
 }
Beispiel #13
0
 public void CreateBlog(String username, [FromBody] BlogSpace blogSpace)
 {
     _blogApplicationService.CreateBlogSpace(username, blogSpace);
 }
 public void ModifyBlogSpace(string username, BlogSpace blogSpace)
 {
     _blogDomain.ModifyBlogSpace(username, blogSpace);
 }
Beispiel #15
0
 public void CreateBlogSpace(BlogSpace blog)
 {
     _context.BlogSpaces.Add(blog);
     _context.SaveChanges();
 }
Beispiel #16
0
 public void DeleteBlogSpace(BlogSpace blog)
 {
     _context.BlogSpaces.Remove(blog);
     _context.SaveChanges();
 }
 public void CreateBlogSpace(string username, BlogSpace blogSpace)
 {
     _blogDomain.CreateBlogSpace(username, blogSpace);
 }