Beispiel #1
0
        public AnswerStatus CreateBlog(BlogDto blogDTO)
        {
            try
            {
                using (var uow = _unitOfWorkFactory.Create())
                {
                    var blogRepository = _repositoryFactory.CreateBlogRepository(uow);

                    var result = CreateBlog(blogDTO, blogRepository);

                    if (result == AnswerStatus.Failed)
                    {
                        return(result);
                    }

                    uow.SaveChanges();
                    return(result);
                }
            }
            catch (Exception exc)
            {
                _logger.Log(exc.ToString());

                return(AnswerStatus.Failed);
            }
        }
Beispiel #2
0
        public AnswerStatus CreateBlog(BlogDto blogDTO, IBlogRepository blogRepository)
        {
            try
            {
                var newBlog        = _blogBuilder.CreateBlog(blogDTO.BlogTitle, DateTime.Now);
                var userRepository = _repositoryFactory.CreateUserRepository(blogRepository.UnitOfWork);
                var userCreatedBy  = userRepository.GetEntityById(blogDTO.CreatedBy.Id);
                _userBuilder.SetBlogUserId(userCreatedBy, blogDTO.CreatedBy.Id);
                _blogBuilder.SetBlogUser(newBlog, userCreatedBy);

                blogRepository.CreateEntity(newBlog);
                blogDTO.Id           = newBlog.Id;
                blogDTO.CreationDate = newBlog.CreationDate;

                if (blogDTO.BlogCategories != null)
                {
                    var result = CreateCategories(blogDTO, blogRepository.UnitOfWork);
                    if (result == AnswerStatus.Failed)
                    {
                        return(result);
                    }
                }

                return(AnswerStatus.Successfull);
            }
            catch (Exception exc)
            {
                _logger.Log(exc.ToString());

                return(AnswerStatus.Failed);
            }
        }
Beispiel #3
0
        public AnswerStatus DeleteBlog(BlogDto blogDTO, IBlogRepository blogRepository)
        {
            try
            {
                if (blogDTO.Id <= 0)
                {
                    throw new ArgumentException("id can't be less or equal to 0");
                }

                var blogToDelete = blogRepository.GetEntityById(blogDTO.Id);

                var deletePostsResult = DeletePosts(blogDTO.Id, blogRepository.UnitOfWork);
                if (deletePostsResult == AnswerStatus.Failed)
                {
                    return(deletePostsResult);
                }

                var deleteCategoriesResult = DeleteCategories(blogDTO.Id, blogRepository.UnitOfWork);
                if (deleteCategoriesResult == AnswerStatus.Failed)
                {
                    return(deleteCategoriesResult);
                }


                blogRepository.DeleteEntity(blogToDelete);

                return(AnswerStatus.Successfull);
            }
            catch (Exception exc)
            {
                _logger.Log(exc.ToString());

                return(AnswerStatus.Failed);
            }
        }
Beispiel #4
0
        public ServiceAnswer <BlogDto> GetBlogByUserId(int userId)
        {
            try
            {
                using (var uow = _unitOfWorkFactory.Create())
                {
                    var blogRepository = _repositoryFactory.CreateBlogRepository(uow);

                    var receivedBlog = blogRepository.GetBlogByUserId(userId);

                    var blogDTO = new BlogDto();

                    if (receivedBlog != null)
                    {
                        blogDTO = MapReceivedBlog(receivedBlog);
                    }

                    return(new ServiceAnswer <BlogDto>(blogDTO, AnswerStatus.Successfull));
                }
            }
            catch (Exception exc)
            {
                _logger.Log(exc.ToString());

                return(new ServiceAnswer <BlogDto>(null, AnswerStatus.Failed));
            }
        }
Beispiel #5
0
 public IActionResult CreateBlog(BlogCommand blog)
 {
     try
     {
         if (blog != null)
         {
             BlogDto data     = _mapper.Map <BlogDto>(blog);
             var     iSuccess = _blogService.AddBlog(data);
             if (iSuccess)
             {
                 SuccessModel.SuccessMessage = "Success";
                 SuccessModel.SuccessCode    = "200";
                 return(Ok(SuccessModel));
             }
             else
             {
                 ErrorModel.ErrorMessage = "Update fail";
                 ErrorModel.ErrorCode    = "400";
                 return(StatusCode(400, ErrorModel));
             }
         }
         else
         {
             ErrorModel.ErrorMessage = "Data fail";
             ErrorModel.ErrorCode    = "400";
             return(StatusCode(400, ErrorModel));
         }
     }
     catch (Exception ex)
     {
         ErrorModel.ErrorMessage = ex.Message;
         ErrorModel.ErrorCode    = "500";
         return(StatusCode(500, ErrorModel));
     }
 }
Beispiel #6
0
        private async void OnInitDbClick(object sender, RoutedEventArgs e)
        {
            CountLabel.Text = "";

            TimeLabel.Text = "";

            List.ItemsSource = null;

            await Task.Delay(TimeSpan.FromMilliseconds(20));

            _dataAdapter.Remove();

            for (int i = 0; i < 100000; i++)
            {
                var blog = new BlogDto()
                {
                    BlogId = i + 1,
                    Url    = "https://docs.microsoft.com/en-us/ef/core/get-started/uwp/getting-started"
                };

                _dataAdapter.InsertBlogs(blog);
            }

            //Load data after initialize
            LoadData();
        }
        async public Task AddBlogAsync(BlogDto blog)
        {
            Blog blogEntity = blog.Adapt <Blog>();

            blogEntity.GUID = Guid.NewGuid();

            var b = Context.Blog.Add(blogEntity);

            Dictionary <string, Tag> existingTags = Context.Tag.Where(i =>
                                                                      blog.Tags.Contains(i.Name)).ToDictionary(i => i.Name.ToLower());

            foreach (string tag in blog.Tags)
            {
                Tag t = existingTags.ContainsKey(tag.ToLower()) ? existingTags[tag.ToLower()] : null;
                if (t == null)
                {
                    t = new Tag()
                    {
                        Name = tag, Active = true, CreatedAt = DateTime.UtcNow
                    };
                }
                Context.BlogTag.Add(new BlogTag()
                {
                    Blog = b.Entity, Tag = t, CreatedAt = DateTime.UtcNow
                });
            }

            await Context.SaveChangesAsync();

            blog.Id = b.Entity.Id;
        }
Beispiel #8
0
        public async Task <IActionResult> CreateBlog([FromBody] BlogDto blog)
        {
            try
            {
                var result = await _blogService.CreateBlog(blog, AuthInfo());

                if (result != null)
                {
                    _logger.LogInformation("User successfully created a blog");
                    return(CreatedAtAction(nameof(GetBlogById), new { id = result.Id }, result));
                }
                else
                {
                    throw new ArgumentNullException();
                }
            }
            catch (ArgumentNullException ex)
            {
                _logger.LogError(ex, ex.Message);
                return(BadRequest());
            }
            catch (NameIsAlreadyTakenException ex)
            {
                _logger.LogError(ex, "User tried to create blog with name that was already taken");
                return(BadRequest(ex));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while user tried to create blog");
                throw;
            }
        }
Beispiel #9
0
      public ActionResult Create(BlogViewModel vm)
      {
          if (ModelState.IsValid)
          {
              //Smestanje slike na drajv
              string fileName = Guid.NewGuid().ToString() + "_" + vm.Picture.FileName;
              string putanja  = Path.Combine(Server.MapPath("~/Content/images"), fileName);

              vm.Picture.SaveAs(putanja);

              BlogDto dto = new BlogDto
              {
                  Name         = vm.Name,
                  Date_created = DateTime.Now,
                  Text         = vm.Text,
                  User_id      = User.Identity.GetUserId(),
                  Picture      = new PictureDto
                  {
                      Alt = "blogslika",
                      Src = "Content/Images/" + fileName
                  }
              };

              OpBlogInsert op = new OpBlogInsert();
              op.BlogDto = dto;
              var result = _manager.executeOperation(op);
              return(RedirectToAction("Index"));
          }

          else
          {
              return(View());
          }
      }
Beispiel #10
0
        public OperationResult Update(BlogDto dto)
        {
            try
            {
                var validate = Validate(dto);
                if (validate != null)
                {
                    return(validate);
                }


                Blog blog = BlogRepository.GetById(dto.id);
                if (blog == null)
                {
                    return(new OperationResult(OperationResultType.QueryNull));
                }
                blog = dto.MapTo(blog);
                BlogRepository.Update(blog);
                return(new OperationResult(OperationResultType.Success, "更新博客成功!"));
            }
            catch (Exception ex)
            {
                var msg = ex.Message;
                //log 记录异常信息
                //返回用户友好的提示
                return(new OperationResult(OperationResultType.Error, "更新博客失败!"));
            }
        }
Beispiel #11
0
        public Post CreatePostWithBlog(PostWithBlog postWithBlog)
        {
            PostDto post = null;

            _appContext.StartSession();
            try
            {
                var blog = new BlogDto()
                {
                    Url = postWithBlog.BlogUrl
                };
                _blogRepository.Create(blog);

                post = new PostDto()
                {
                    BlogId  = blog.Id,
                    Title   = postWithBlog.Title,
                    Content = postWithBlog.Content
                };
                _postRepository.Create(post);

                _appContext.CompleteSession();
            }
            catch
            {
                _appContext.RollbackSession();
                throw;
            }

            return(_mapper.Map <Post>(post));
        }
        public void Execute(BlogDto request, int id)
        {
            var blog = _context.Blogs.Find(id);

            if (blog == null)
            {
                throw new EntityNotFoundException(id, typeof(Blog));
            }

            _context.Database.ExecuteSqlRaw($"Delete from BlogCategory where BlogId = {id}");

            _validator.ValidateAndThrow(request);

            blog.Name        = request.Name;
            blog.Description = request.Description;
            blog.ModifiedAt  = DateTime.Now;
            var categoryIds = request.CategoryIds;

            ICollection <BlogCategory> blogCategories = new List <BlogCategory>();

            foreach (var categoryId in categoryIds)
            {
                var blogCategory = new BlogCategory
                {
                    BlogId     = id,
                    CategoryId = categoryId
                };
                blogCategories.Add(blogCategory);
            }
            blog.BlogCategories = blogCategories;
            _context.SaveChanges();
        }
        public List <BlogDto> GetAllBlogs()
        {
            BlogManager blogManager = new BlogManager(this._unitOfWork);

            List <BlogDto> blogDtolsit = new List <BlogDto>();
            var            bloglist    = blogManager.GetBlogAll();

            foreach (BlogDtoDll blog in bloglist)
            {
                BlogDto blogDto = new BlogDto
                {
                    BlogId = blog.BlogId,
                    Url    = blog.Url
                };

                List <PostDto> postDtolist = new List <PostDto>();

                foreach (var post in blog.PostDtoDll)
                {
                    PostDto postDto = new PostDto
                    {
                        BlogId  = post.BlogId,
                        Content = post.Content,
                        Title   = post.Title,
                        PostId  = post.PostId
                    };
                    postDtolist.Add(postDto);
                }
                blogDto.PostDto = postDtolist;
                blogDtolsit.Add(blogDto);
            }

            return(blogDtolsit);
        }
Beispiel #14
0
        public void UpdateBlogName(int id, BlogDto blog, string token)
        {
            if (token == null)
            {
                throw new ArgumentNullException(nameof(token));
            }
            if (blog == null)
            {
                throw new ArgumentNullException(nameof(blog));
            }
            var entity = _unitOfWork.BlogRepository.GetById(id);

            if (entity == null)
            {
                throw new ArgumentNullException(nameof(entity), "This blog doesn't exist");
            }
            if (!ConfigureRights(token, entity.OwnerId))
            {
                throw new NotEnoughtRightsException();
            }
            if (_unitOfWork.BlogRepository.Get(b => b.Name == blog.Name).FirstOrDefault() != null)
            {
                throw new NameIsAlreadyTakenException();
            }
            entity.Name = blog.Name;
            _unitOfWork.BlogRepository.Update(entity);
            _unitOfWork.Save();
        }
Beispiel #15
0
        public BlogDto GetById(int id)
        {
            BlogDto blog = null;

            using (var command = _blogAppContext.CreateCommand())
            {
                command.CommandText = @"SELECT BlogId, Url 
										FROM Blogs 
										WHERE BlogId = @BlogId"                                        ;

                var param = command.CreateParameter();
                param.ParameterName = "BlogId";
                param.Value         = id;
                command.Parameters.Add(param);

                using (var reader = command.ExecuteReader())
                {
                    if (reader.Read())
                    {
                        blog = _mapper.Map <IDataReader, BlogDto>(reader);
                        //blog = CreateBlogFromReader(reader);
                    }
                }
            }

            return(blog);
        }
        /// <summary>
        /// 更新 Blog
        /// </summary>
        /// <param name="blogDto">Blog Dto</param>
        /// <returns></returns>
        public async Task <bool> UpdateAsync(BlogDto blogDto)
        {
            // Convert BlogDto to Blog
            var blog = this._mapper.Map <Blog>(blogDto);

            return(await this._blogRepository.UpdateAsync(blog));
        }
Beispiel #17
0
        /// <summary>
        /// 获取一条博客
        /// </summary>
        /// <param name="blogId"></param>
        /// <returns></returns>
        public async Task <BlogDto> GetOneBlogByBlogIdAsync(long blogId)
        {
            string where = "where blog.IsDelete=0 and blog.BlogId=@BlogId";
            string sql = string.Format("select blog.BlogId,blog.CategoryID,blog.Title,blog.Body,blog.Remark,blog.KeyWord,blog.Description,blog.CreateDate,blog.UpdateDate,blog.Sort,blog.UserId,blog.VisitCount,blog.CommentCount,blog.IsEssence,blog.IsHomePage,blog.IsDelete,category.CategoryID,category.CategoryName,category.CreateDate,user.UserId,user.LoginName,user.UserName,user.UserHeadImaUrl from `blog`  " +
                                       " left join `category`  on blog.CategoryID=category.CategoryID left join `user` on user.UserId=blog.UserId {0}  ", where);
            List <Blog> blist = null;

            using (var connection = CreateConnection())
            {
                blist = (List <Blog>) await connection.QueryAsync <Blog, Category, User, Blog>(sql, (qblog, qcategory, quser) =>
                {
                    qblog.Category = qcategory;
                    qblog.User     = quser;
                    return(qblog);
                }, new { BlogId = blogId },
                                                                                               splitOn : "BlogId,CategoryId,UserId");
            }
            BlogDto blogDto = new BlogDto();

            if (blist.Count() > 0)
            {
                blogDto             = Mapper.Map <Blog, BlogDto>(blist[0]);
                blogDto.CategoryDto = Mapper.Map <Category, CategoryDto>(blist[0].Category);
                blogDto.User        = Mapper.Map <User, UserDto>(blist[0].User);
            }
            return(blogDto);
        }
 public bool CreateBlog(JObject blogDto)
 {
     try
     {
         var blog = new BlogDto
         {
             BlogTitle    = blogDto["BlogTitle"].ToString(),
             CreatedBy    = blogDto["CreatedBy"].ToObject <BlogUserDto>(),
             CreationDate = DateTime.Now
         };
         var result = BlogService.CreateBlog(blog);
         if (result == AnswerStatus.Successfull)
         {
             return(true);
         }
         else
         {
             return(false);
         }
     }
     catch
     {
         return(false);
     }
 }
Beispiel #19
0
        public void Execute(BlogDto request)
        {
            _validator.ValidateAndThrow(request);

            ICollection <BlogCategory> categoryBlogs = new List <BlogCategory>();

            foreach (var catId in request.CategoryIds)
            {
                var blogCategory = new BlogCategory
                {
                    CategoryId = catId
                };
                categoryBlogs.Add(blogCategory);
            }

            var blog = new Blog
            {
                Name           = request.Name,
                Description    = request.Description,
                BlogCategories = categoryBlogs,
                UserId         = actor.Id
            };

            _context.Blogs.Add(blog);
            _context.SaveChanges();
        }
Beispiel #20
0
        public ActionResult Update(int id, BlogDto Blog)
        {
            BlogModel BlogInfo = new BlogModel
            {
                blog_id = Blog.blog_id,
                date = Blog.date,
                photo_path = Blog.photo_path,
                title = Blog.title,
                text = Blog.text,
                email = Blog.email,
                ApplicationUserId = User.Identity.GetUserId()
            };

            string url = "blogapi/updateblog/" + id;
            HttpContent content = new StringContent(jss.Serialize(BlogInfo));
            content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            HttpResponseMessage response = client.PostAsync(url, content).Result;

            if (response.IsSuccessStatusCode)
            {
                return RedirectToAction("AdminShow", new { id });
            }
            else
            {
                return RedirectToAction("Error");
            }
        }
Beispiel #21
0
        public async Task <ActionResult> Create(CreateBlogModel model)
        {
            if (ModelState.IsValid)
            {
                string currentUserId = HttpContext.User.Identity.GetUserId();

                BlogDto blogDto = new BlogDto
                {
                    Title         = model.Title,
                    Text          = model.Text,
                    CreateAt      = DateTime.Now,
                    UserProfileId = currentUserId,
                    IsDeleted     = false
                };

                OperationDetails operationDetails = BlogService.Create(blogDto);

                if (operationDetails.Succedeed)
                {
                    return(RedirectToAction("Index", "Blog"));
                }
                else
                {
                    ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
                }
            }

            return(View());
        }
Beispiel #22
0
        public async Task <IActionResult> Add(int?id)
        {
            var claim = GetClaim(HttpContext.User.Claims, ClaimTypes.Sid);

            if (claim == null)
            {
                return(NotFound());
            }
            int userID = int.Parse(claim.Value);

            ViewBag.CyList = await this._categoryService.GetAllCategoryByUserId(userID);

            ViewBag.NavTitle = "添加博客";
            ViewBag.Btn      = "添加";
            BlogDto blogDto = null;

            if (id != null)
            {
                blogDto = await this._blogService.GetOneBlogByBlogIdAsync((int)id);

                ViewBag.NavTitle = "编辑博客";
                ViewBag.Btn      = "编辑";
            }
            else
            {
                blogDto = new BlogDto();
            }
            ViewBag.Blog = blogDto;
            return(View());
        }
 public async Task <IActionResult> AddBlog([FromBody] BlogDto blog)
 {
     //int n = 4;
     //if (n == 14)
     //{
     //    throw new Exception("Test exception", new Exception("Inner exception for testing"));
     //}
     if (blog == null)
     {
         return(BadRequest("Blog object is null."));
     }
     if (blog.Id != 0)
     {
         return(BadRequest("Blog Id is not zero."));
     }
     if (!ModelState.IsValid)
     {
         return(BadRequest(ModelState));
     }
     else
     {
         await _blogCommands.AddBlogAsync(blog);
     }
     return(CreatedAtAction(nameof(AddBlog), blog));
 }
Beispiel #24
0
        public async Task CreateBlog(BlogDto blog)
        {
            var json = JsonConvert.SerializeObject(blog);
            var resp = await _httpClient.PostAsync($"/api/blogs", new StringContent(json, Encoding.UTF8, "application/json"));

            resp.EnsureSuccessStatusCode();
        }
Beispiel #25
0
        public ActionResult Create([Bind(Include = "Title,Body")] BlogDto blog)
        {
            if (ModelState.IsValid)
            {
                var entity = _mapper.Map <Blog>(blog);
                entity.UserId           = (HttpContext.User.Identity as ClaimsIdentity).FindFirstValue("id");
                entity.LastEditDateTime = DateTime.UtcNow;

                _dbContext.BLogs.Add(entity);

                try
                {
                    _dbContext.SaveChanges();
                }
                catch (DbUpdateException e)
                {
                    Console.WriteLine(e);
                }

                return(RedirectToAction("Index"));
            }


            return(View());
        }
Beispiel #26
0
 public IActionResult Create(BlogDto blogDto)
 {
     try
     {
         if (_blogService.Insert(blogDto))
         {
             var response = new DataResponeCommon()
             {
                 Statu = StatuCodeEnum.OK, Message = "Thêm thành công"
             };
             return(Json(response));
         }
         else
         {
             var response = new DataResponeCommon()
             {
                 Statu = StatuCodeEnum.InternalServerError, Message = "Thêm thất bại"
             };
             return(Json(response));
         }
     }
     catch (Exception e)
     {
         _logger.LogError(e.Message);
         throw;
     }
 }
        public void update(BlogDto blog_dto)
        {
            try
            {
                using (TransactionScope tx = new TransactionScope(TransactionScopeOption.Required))
                {
                    Blog blogs = _blogRepository.getById(blog_dto.blog_id);

                    if (blogs == null)
                    {
                        throw new ItemNotFoundException($"Blog with ID {blog_dto.blog_id} doesnot Exit.");
                    }

                    if (blog_dto.image_name == null)
                    {
                        blog_dto.image_name = blogs.image_name;
                    }

                    _blogMaker.copy(ref blogs, blog_dto);
                    _blogRepository.update(blogs);
                    tx.Complete();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
Beispiel #28
0
        public BlogDto GetBlogArticle(int?categoryId = null)
        {
            var blogDto = new BlogDto();
            var repos   = new ArticlesRepository(_context, new LogsRepository(_context));
            var blogs   = new List <BlogViewModel>();

            if (categoryId == null)
            {
                blogs = repos.GetArticles().Select(s => new BlogViewModel(s, _currentLang)).ToList();
            }
            else
            {
                var category = repos.GetCategory(categoryId.Value);
                if (category != null)
                {
                    //ViewBag.BreadCrumb = category.Title;
                    blogs = repos.GetArticlesByCategory(categoryId.Value).Select(s => new BlogViewModel(s, _currentLang)).ToList();
                }
            }

            var categories = _context.ArticleCategories.Where(w => !w.IsDeleted)
                             .Select(s => new BlogCategoryModel
            {
                Id    = s.Id,
                Title = _currentLang == (int)Language.Farsi ? s.Title : s.EnglishTitle
            }).ToList();

            blogDto.Blogs.AddRange(blogs);
            blogDto.Categories.AddRange(categories);
            blogDto.RecentBlogs = repos.GetArticles().Select(s => new BlogViewModel(s, _currentLang)).ToList();

            return(blogDto);
        }
Beispiel #29
0
        /// <summary>
        /// 新增 Blog
        /// </summary>
        /// <param name="blogDto">Blog Dto</param>
        /// <returns></returns>
        public async Task <int> AddAsync(BlogDto blogDto)
        {
            // Convert BlogDto to Blog
            var blog = this._mapper.Map <Blog>(blogDto);

            return(await this._blogRepository.AddAsync(blog));;
        }
        public void BlogCRUD()
        {
            Task.Run(async() =>
            {
                //await _blogMng.DeleteBlogAsync(2010);

                string blogName01   = "testBlog01";
                int primaryAuthorId = 1;
                List <string> tags  = new List <string>()
                {
                    "Programming", "Art"
                };
                BlogDto blogDto = new BlogDto()
                {
                    Name            = "myTestBlog",
                    DisplayName     = "My Test Blog",
                    Description     = "My test blog description",
                    DisplayOrder    = 1,
                    BlogStatusId    = (int)BlogStatuses.Draft,
                    PrimaryAuthorId = primaryAuthorId
                };
                blogDto.Tags.AddRange(tags);

                await _blogCmds.AddBlogAsync(blogDto);

                BlogDto blogToUpdate = _blogRqs.GetBlog(blogDto.Id);
                blogToUpdate.Name    = blogName01;

                blogDto.Name = blogName01;
                await _blogCmds.UpdateBlogAsync(blogDto);

                blogToUpdate = _blogRqs.GetBlog(blogToUpdate.Id);
                Assert.AreEqual(blogToUpdate.Name, blogName01);
                blogToUpdate = _blogRqs.GetBlog(blogName01);
                Assert.AreEqual(blogToUpdate.Name, blogName01);

                var blogs = await _blogRqs.GetBlogs(tags, BlogStatuses.Draft);
                Assert.IsTrue(blogs.Count() > 0);

                blogs = await _blogRqs.GetBlogsByAuthor(primaryAuthorId, BlogStatuses.Draft);
                Assert.IsTrue(blogs.Count() > 0);

                await _blogCmds.UpdateBlogStatusAsync(blogToUpdate.Id, BlogStatuses.Published);
                blogs = await _blogRqs.GetBlogsByAuthor(primaryAuthorId, BlogStatuses.Published);
                Assert.IsTrue(blogs.Count() > 0);

                blogs = await _blogRqs.GetBlogsByAuthor(primaryAuthorId);
                Assert.IsTrue(blogs.Count() > 0);

                blogs = await _blogRqs.FindBlogs("TestBlog");
                Assert.IsTrue(blogs.Count() > 0);
                blogs = await _blogRqs.FindBlogs("TestBlog", BlogStatuses.Published);
                Assert.IsTrue(blogs.Count() > 0);

                await _blogCmds.DeleteBlogAsync(blogToUpdate.Id);
                blogToUpdate = _blogRqs.GetBlog(blogToUpdate.Id);
                Assert.IsNull(blogToUpdate);
            }).GetAwaiter().GetResult();
        }
 public HttpResponseMessage Put(BlogDto blog)
 {
     var validationService = new BlogValidation();
     var results = validationService.Validate(blog);
     if (!results.IsValid)
     {
         return ValidationHelper.FailedValidationMessage(results);
     }
     _blogService.Create(blog);
     return new HttpResponseMessage(HttpStatusCode.OK);
 }
        public void Blog_Must_Validate_And_Return_Message()
        {
            // Arrange
            var controller = new BlogController();
            var blog = new BlogDto();

            // Act
            var result = controller.Put(blog);

            // Assert
            Assert.AreEqual(result.StatusCode, HttpStatusCode.BadRequest);
        }
        public void Put_Valid_Blog_Test()
        {
            // Arrange
            var controller = new BlogController();
            var blog = new BlogDto();
            blog.AuthorName = "somename";
            blog.Title = "SomeTitle";

            // Act
            var result = controller.Put(blog);

            // Assert
            Assert.AreEqual(result.StatusCode, HttpStatusCode.OK);
        }
Beispiel #34
0
        public OperationResult Add(BlogDto dto)
        {
            try
            {
                var validate = Validate(dto);
                if (validate != null)
                    return validate;

                Blog blog = dto.MapTo<Blog>();
                blog.createTime = DateTime.Now;
                BlogRepository.Insert(blog);
                return new OperationResult(OperationResultType.Success, "添加博客成功!");
            }
            catch (Exception ex)
            {
                var msg = ex.Message;
                //log 记录异常信息
                //返回用户友好的提示
                return new OperationResult(OperationResultType.Error, "添加博客失败!");

            }
        }
Beispiel #35
0
 public HttpResponseMessage PostBlog(BlogDto blog)
 {
     return Request.CreateResponse(HttpStatusCode.Created);
 }
Beispiel #36
0
 private OperationResult Validate(BlogDto dto)
 {
     if (dto.title.IsNullOrEmpty() || dto.title.Trim().IsNullOrEmpty())
     {
         return new OperationResult(OperationResultType.ValidError, "博客标题不能为空!");
     }
     return null;
 }
Beispiel #37
0
 public BlogDto GetByKey(int id)
 {
     var blog = this.Entities.FirstOrDefault(w => w.Id == id);
     if (blog != null)
     {
         var dto = new BlogDto()
         {
             id = blog.Id,
             title = blog.title
         };
         return dto;
     }
     return null;
 }