public HttpResponseMessage GetNewsArticle(string sessionKey, int id)
        {
            User user = null;

            try
            {
                user = this.usersRepository.GetBySessionKey(sessionKey);
            }
            catch (Exception)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid user!"));
            }

            NewsArticle newsArticle = this.newsArticlesRepository.Get(id);

            if (newsArticle == null)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "News article not found!"));
            }

            NewsArticleModel newsArticleModel = null;

            try
            {
                newsArticleModel = NewsArticlesMapper.ToNewsArticleModel(newsArticle);
            }
            catch (Exception)
            {
                return(Request.CreateResponse(HttpStatusCode.InternalServerError));
            }

            HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, newsArticleModel);

            return(response);
        }
        public HttpResponseMessage PostNewsArticle(string sessionKey, [FromBody] NewsArticleModel newsArticle)
        {
            User user = null;

            try
            {
                user = this.usersRepository.GetBySessionKey(sessionKey);
            }
            catch (Exception)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid user!"));
            }

            newsArticle.Author = user.Nickname;

            NewsArticle newsArticleEntity = null;

            try
            {
                newsArticleEntity = NewsArticlesMapper
                                    .ToNewsArticleEntity(newsArticle, usersRepository, commentsRepository);
            }
            catch (Exception)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid news article model provided!"));
            }

            newsArticle.ID = newsArticleEntity.ID;

            AddImages(newsArticle, newsArticleEntity);

            this.newsArticlesRepository.Add(newsArticleEntity);

            return(Request.CreateResponse(HttpStatusCode.Created, newsArticle));
        }
        public HttpResponseMessage GetAll(string sessionKey)
        {
            User user = null;

            try
            {
                user = this.usersRepository.GetBySessionKey(sessionKey);
            }
            catch (Exception)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid user!"));
            }

            ICollection <NewsArticleDetails> newsArticles         = new List <NewsArticleDetails>();
            IQueryable <NewsArticle>         newsArticlesEntities = this.newsArticlesRepository.GetAll();

            foreach (var newsArticle in newsArticlesEntities)
            {
                newsArticles.Add(NewsArticlesMapper.ToNewsArticleDetails(newsArticle));
            }

            HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, newsArticles);

            return(response);
        }
        public HttpResponseMessage EditNewsArticle(string sessionKey, int id, NewsArticleModel newsArticle)
        {
            User user = null;

            try
            {
                user = this.usersRepository.GetBySessionKey(sessionKey);
            }
            catch (Exception)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid user!"));
            }

            if (id != newsArticle.ID)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            NewsArticle updatedNewsArticle = null;

            try
            {
                updatedNewsArticle =
                    NewsArticlesMapper.ToNewsArticleEntity(newsArticle, usersRepository, commentsRepository);
            }
            catch (Exception)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid news article model provided!"));
            }

            this.newsArticlesRepository.Update(id, updatedNewsArticle);

            return(Request.CreateResponse(HttpStatusCode.OK));
        }
        public HttpResponseMessage GetNewsArticles(string sessionKey)
        {
            User user = null;

            try
            {
                user = this.usersRepository.GetBySessionKey(sessionKey);
            }
            catch (Exception)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid session key provided!"));
            }

            ICollection <NewsArticleModel> newsArticlesModels = new List <NewsArticleModel>();

            IQueryable <NewsArticle> newsArticles = this.newsArticlesRepository
                                                    .GetAll().Where(n => n.AuthorID == user.ID);

            foreach (NewsArticle newsArticle in newsArticles)
            {
                newsArticlesModels.Add(NewsArticlesMapper.ToNewsArticleModel(newsArticle));
            }

            return(Request.CreateResponse(HttpStatusCode.OK, newsArticlesModels));
        }