[InlineData(0, false)] // BlogID = 1 and Not Allow Edit
public void Get_DetailBlogWithEdit_ReturnDetailBlogAndEditOrNo(int blogID, bool Edit)
{
// Expect
var blog = new BlogDTO
{
BlogID = blogID,
Title = "DaLat",
Sapo = "Dalat",
Content = "Dalat",
Edit = Edit
};
// Arrange
var mockDependency = new Mock <IBlogLogic>();
mockDependency.Setup(x => x.GetDetailBlogWithID(It.IsAny <int>(), It.IsAny <bool>()))
.Returns(blog);
// Actual
var sut = new BlogControllerFake(mockDependency.Object);
var result = sut.GetDetailBlogWithID(It.IsAny <int>(), It.IsAny <bool>());
// Assert
Assert.Equal(blog, result);
}
public Task <Blogs> CreateBlogAsync(BlogDTO newBlog)
{
try
{
Blogs objBlogs = new Blogs();
objBlogs.BlogId = 0;
objBlogs.BlogContent = newBlog.BlogContent;
objBlogs.BlogDate = newBlog.BlogDate;
objBlogs.BlogSummary = newBlog.BlogSummary;
objBlogs.BlogTitle = newBlog.BlogTitle;
objBlogs.BlogUserName = newBlog.BlogUserName;
objBlogs.BlogContent = newBlog.BlogContent;
objBlogs.BlogCategory = null;
_context.Blogs.Add(objBlogs);
_context.SaveChanges();
return(Task.FromResult(objBlogs));
}
catch
{
DetachAllEntities();
throw;
}
}
public List <BlogDTO> ReadAllBlogs()
{
List <BlogDTO> blogList = new List <BlogDTO>();
try
{
if (1 > 0)
{
using (var tmcDBContext = new TMCContext())
{
var blogs = (from blog in tmcDBContext.Blogs
select blog).ToList();
foreach (var blog in blogs)
{
var blogDTO = new BlogDTO();
blogDTO.BlogId = blog.Id;
blogDTO.Description = blog.Description;
blogList.Add(blogDTO);
}
}
}
}
catch (Exception ex)
{
//ExceptionManager.HandleException(ex);
//throw new DACException("Error while fetching the organization locations.", ex);
}
return(blogList);
}
public async Task <BlogDTO> UpdateBlog(int id, BlogDTO blogDto, string token)
{
var blog = await _unitOfWork.BlogRepository.GetByIdAsync(id);
if (blog == null)
{
throw new EntityNotFoundException(nameof(blog), id);
}
if (!CheckRights(token, blog.OwnerId))
{
throw new NotEnoughRightsException();
}
var blogWithSameName = await _unitOfWork.BlogRepository.FirstOrDefaultAsync(b => b.Name == blogDto.Name);
if (blogWithSameName != null && blog.Id != blogWithSameName.Id)
{
throw new NameAlreadyTakenException(blogDto.Name);
}
if (blog.Name != blogDto.Name && blogDto.Name != null)
{
blog.Name = blogDto.Name;
}
if (blog.Description != blogDto.Description && blogDto.Description != null)
{
blog.Description = blogDto.Description;
}
var result = await _unitOfWork.BlogRepository.UpdateAndSaveAsync(blog);
return(_mapper.Map <BlogDTO>(result));
}
/// <summary>
/// Get infor blog with check role was allow edit or nope
/// </summary>
/// <param name="blogID">BlogID</param>
/// <param name="edit">Boolean Edit</param>
/// <returns>Object</returns>
public BlogDTO GetDetailBlogWithID(int blogID, bool edit)
{
Blog BlogMain = _db.Blogs.FindByID(blogID);
var blog = new BlogDTO
{
BlogID = BlogMain.BlogID,
Title = BlogMain.Title,
Sapo = BlogMain.Sapo,
Content = BlogMain.Content,
Picture = BlogMain.Picture,
crDate = BlogMain.crDate,
Edit = edit,
ListComment = BlogMain.Comment.Select(s => new CommentDTO
{
CommentID = s.CommentID,
Content = s.Content,
crDate = s.crDate,
UserID = s.UserID,
AuthorComment = s.User.Fullname
}).OrderByDescending(q => q.crDate).ToList(),
AuthorName = BlogMain.Author.Fullname,
AuthorID = BlogMain.AuthorID
};
return(blog);
}
public int Save(BlogDTO obj)
{
using (UnitOfWork uow = new UnitOfWork())
{
try
{
//kaydederken bazı değerlerin default gelmesini sağlayalım
obj.IsConfirmed = false;
obj.RecordStatusId = Convert.ToByte(Enums.RecordStatus.Aktif);
obj.CreatedDate = DateTime.Now;
var blogDTO = Mapper.Map <BlogDTO, Blog>(obj);
var entity = uow.Blogs.Save(blogDTO);
//Commmit işlemi yapmalıyız...
uow.Commit();
//kaydolan blogıd dönüyor
return(entity.BlogId);
}
catch (Exception ex)
{
//hata varsa değişikleri geri al
uow.RollBack();
return(0);
}
}
}
//id e göre veri getirme
public BlogDTO Get(int id)
{
using (UnitOfWork uow = new UnitOfWork())
{
//sorgu
var result = uow.Blogs.Get(x => x.BlogId == id);
if (result == null)
{
return(null);
}
//entityi DTO çevirme Mapper
//Mapper Classı oluşturmalıyız.
//Map<Source,Target>
BlogDTO blog = Mapper.Map <Blog, BlogDTO> (result);
//bu değerler tabloda(entity de) yok
//DTO da bulunuyor bunlara değerleri atanırken tablo bağlantısı yapılmalı
blog.CategoryName = result.Category.CategoryName;
blog.Author = result.User.FirstName + " " + result.User.LastName;
blog.RecordStatusName = result.RecordStatus.RecordStatusName;
return(blog);
}
}
public async Task <IActionResult> Put(int id, [CustomizeValidator(RuleSet = "BlogAddOrUpdate")] BlogDTO blogDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != blogDTO.Id)
{
return(BadRequest("Parameters mismatch"));
}
try
{
var blog = await blogService.GetAsync(id);
if (blog.OwnerId != LoggedInUserId)
{
return(StatusCode((int)HttpStatusCode.Forbidden, "The user is not the owner of the blog."));
}
mapper.Map <BlogDTO, Blog>(blogDTO, blog);
blog = await blogService.AddOrUpdateAsync(blog);
blogDTO = mapper.Map <BlogDTO>(blog);
}
catch
{
throw new BlogSystemException("There's been an error while trying to add the blog entry");
}
return(Ok(blogDTO));
}
public async Task Create(UserDTO userDTO)
{
ApplicationUser existingUser = await UnitOfWork.AppUserManager.FindByEmailAsync(userDTO.Email);
if (existingUser == null)
{
BlogDTO defaultBlogToCreate = new BlogDTO {
Title = "Create new blog title", Description = "Create new description"
};
BlogService.Create(defaultBlogToCreate);
BlogDTO createdBlog = BlogService.GetAll().Last();
ApplicationUser userToCreate = new ApplicationUser {
Email = userDTO.Email, UserName = userDTO.UserName, BlogRefId = createdBlog.BlogId
};
var resultOfCreation = await UnitOfWork.AppUserManager.CreateAsync(userToCreate, userDTO.Password);
if (resultOfCreation.Errors.Count() > 0)
{
throw new CreatingErrorException(resultOfCreation.Errors.ToString());
}
await UnitOfWork.SaveAsync();
}
}
public BlogVM(BlogDTO row)
{
id = row.id;
Name = row.Name;
Email = row.Email;
Comment = row.Comment;
}
public void Create(BlogDTO entity)
{
var blog = mapper.Map <Blog>(entity);
UnitOfWork.BlogRepository.Create(blog);
UnitOfWork.SaveChanges();
}
public async Task <IActionResult> Post([FromBody] BlogDTO blogDTO)
{
Blog blog = BlogMapper.mapSingleToBlog(blogDTO);
await _blogService.AddAsync(blog);
return(CreatedAtAction(nameof(Get), new { id = blog.Id }, blogDTO));
}
public HttpResponseMessage Put(Guid id, [FromBody] BlogDTO blogDTO)
{
var blog = BlogApplication.Get(id);
if (blog == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound, new Note("Blog não encontrado", Note.NoteType.Error)));
}
var converter = new BlogConverter();
converter.Convert(blogDTO, blog);
try
{
BlogApplication.Save(blog);
return(Request.CreateResponse(HttpStatusCode.OK, new Note("Blog salvo com sucesso", Note.NoteType.Success)));
}
catch (InvalidModelState ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new Note("Não foi possível salvar o blog", ex.Details, Note.NoteType.Warning)));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new Note("Não foi possível salvar o blog", ex.Message, Note.NoteType.Error)));
}
}
public async Task BlogsApi_Post_ReturnBlogDTO()
{
// Arrange
var blogDTO = new BlogDTO()
{
Id = 0, Name = "Test blog", CreationDate = DateTime.MinValue, Entries = new List <BlogEntryDTO>(),
Deleted = false, Owner = new UserDTO()
{
Id = 1, UserName = "******", FullName = "Andres Faya", Token = "", Deleted = false
}
};
string stringData = JsonConvert.SerializeObject(blogDTO);
var contentData = new StringContent(stringData, Encoding.UTF8, "application/json");
//Act
var response = await client.PostAsync("api/blogs/", contentData);
// Assert
response.EnsureSuccessStatusCode();
response.StatusCode.Should().Be(HttpStatusCode.OK);
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var blogs = JsonConvert.DeserializeObject <BlogDTO>(responseContent);
blogs.Should().BeAssignableTo <BlogDTO>();
}
// Utility
#region private List<BlogCategory> GetSelectedBlogCategories(BlogDTO objBlogs, IEnumerable<string> blogCatagories)
private List <BlogCategory> GetSelectedBlogCategories(BlogDTO objBlogs, IEnumerable <string> blogCatagories)
{
List <BlogCategory> colBlogCategory = new List <BlogCategory>();
foreach (var item in blogCatagories)
{
int intBlogCatagoryId = Convert.ToInt32(item);
// Get the Category
var Category = _context.Categorys
.Where(x => x.CategoryId == intBlogCatagoryId)
.AsNoTracking()
.FirstOrDefault();
// Create a new BlogCategory
BlogCategory NewBlogCategory = new BlogCategory();
NewBlogCategory.BlogId = objBlogs.BlogId;
NewBlogCategory.CategoryId = Category.CategoryId;
// Add it to the list
colBlogCategory.Add(NewBlogCategory);
}
return(colBlogCategory);
}
public Task <Blogs> CreateBlogAsync(BlogDTO newBlog, IEnumerable <String> BlogCatagories)
{
try
{
Blogs objBlogs = new Blogs();
objBlogs.BlogId = 0;
objBlogs.BlogContent = newBlog.BlogContent;
objBlogs.BlogDate = newBlog.BlogDate;
objBlogs.BlogSummary = newBlog.BlogSummary;
objBlogs.BlogTitle = newBlog.BlogTitle;
objBlogs.BlogUserName = newBlog.BlogUserName;
objBlogs.BlogContent = newBlog.BlogContent;
if (BlogCatagories == null)
{
objBlogs.BlogCategory = null;
}
else
{
objBlogs.BlogCategory =
GetSelectedBlogCategories(newBlog, BlogCatagories);
}
_context.Blogs.Add(objBlogs);
_context.SaveChanges();
return(Task.FromResult(objBlogs));
}
catch (Exception ex)
{
DetachAllEntities();
throw ex;
}
}
public static BlogDTO ToDTO(this Blog entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var result = new BlogDTO() { ID = entity.ID, CreatedDate = entity.CreatedDate };
result.ContentText = !string.IsNullOrEmpty(entity.Content) ? entity.Content : string.Empty;
result.CommentCount = entity.Comments.Count;
result.RepostCount = entity.BaseBlogXBlogs.Count;
if(entity.Person != null)
{
result.Person = entity.Person.ToDTO();
}
if(entity.BlogXContents != null && entity.BlogXContents.Count > 0)
{
result.Contents = new List<ContentDTO>();
foreach (var bxc in entity.BlogXContents)
{
if(bxc.Content != null)
{
var content = bxc.Content.ToDTO();
result.Contents.Add(content);
}
}
}
return result;
}
public void Create(BlogDTO blogDTO)
{
Blog blog = mapper.Map <Blog>(blogDTO);
uof.Blogs.Create(blog);
uof.Save();
}
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();
}
public async Task <IActionResult> Put(int id, [FromBody] BlogDTO blogDTO)
{
if (id != blogDTO.Id)
{
return(BadRequest());
}
Blog blog = BlogMapper.mapSingleToBlog(blogDTO);
try
{
await _blogService.UpdateAsync(blog);
}
catch (DBConcurrencyException e)
{
if (await _blogService.GetByIdAsync(id) == null)
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public List <BlogDTO> GetBlogsByCategory(int id)
{
using (UnitOfWork uow = new UnitOfWork())
{
try
{
var result = uow.Blogs
.Search(x => x.CategoryId == id)
.OrderByDescending(x => x.CreatedDate)
.ToList();
List <BlogDTO> list = new List <BlogDTO>();
foreach (var item in result)
{
BlogDTO obj = new BlogDTO
{
BlogId = item.BlogId,
Title = item.Title,
CategoryName = item.Category.CategoryName,
BlogContent = item.BlogContent.Substring(0, 250),
CreatedDate = item.CreatedDate
};
list.Add(obj);
}
return(list);
}
catch (Exception ex)
{
return(null);
}
}
}
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;
}
}
public static Blog mapSingleToBlog(BlogDTO blogDTO)
{
return(new Blog()
{
Id = blogDTO.Id,
Name = blogDTO.Name
});
}
public ActionResult DeleteConfirmed(int id)
{
BlogDTO blogDTO = db.Blgdata.Find(id);
db.Blgdata.Remove(blogDTO);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void Update(BlogDTO blog)
{
Mapper.CreateMap <BlogDTO, Blog>();
Blog updateBlog = Mapper.Map <BlogDTO, Blog>(blog);
Database.Blogs.Update(updateBlog);
Database.Save();
}
public JsonResult Edit(BlogDTO obj)
{
using (BlogService service = new BlogService())
{
obj.ImagePath = "";
var result = service.Update(obj);
return(Json(result));
}
}
public BlogDTO GetBlog(int BlogId)
{
BlogDTO objBlog = (from blog in _context.Blogs
.Where(x => x.BlogId == BlogId)
select new BlogDTO
{
BlogId = blog.BlogId,
BlogTitle = blog.BlogTitle,
BlogDate = blog.BlogDate,
BlogUserName = blog.BlogUserName,
BlogSummary = blog.BlogSummary,
BlogContent = blog.BlogContent,
BlogDisplayName = "",
}).AsNoTracking().FirstOrDefault();
// Add Blog Categories
objBlog.BlogCategory = new List <BlogCategory>();
var BlogCategories = _context.BlogCategory
.Where(x => x.BlogId == objBlog.BlogId)
.AsNoTracking().ToList();
foreach (var item in BlogCategories)
{
objBlog.BlogCategory.Add(item);
}
// Try to get name
var objUser = _context.AspNetUsers
.Where(x => x.Email.ToLower() == objBlog.BlogUserName).AsNoTracking()
.FirstOrDefault();
if (objUser != null)
{
if (objUser.DisplayName != null)
{
objBlog.BlogDisplayName = objUser.DisplayName;
}
}
// Get GoogleTrackingID and DisqusEnabled
var Settings = _context.Settings.AsNoTracking().ToList();
objBlog.DisqusEnabled = Convert.ToBoolean(Settings.FirstOrDefault(x => x.SettingName == "DisqusEnabled").SettingValue);
if (Settings.FirstOrDefault(x => x.SettingName == "GoogleTrackingID") != null)
{
objBlog.GoogleTrackingID = Convert.ToString(Settings.FirstOrDefault(x => x.SettingName == "GoogleTrackingID").SettingValue);
}
else
{
objBlog.GoogleTrackingID = "";
}
return(objBlog);
}
public async Task <IHttpActionResult> GetById(int id)
{
BlogDTO Blog = await BlogService.GetAll().Where(x => x.Id == id && !x.Deleted).ProjectTo <BlogDTO>().FirstOrDefaultAsync();
if (Blog == null)
{
return(NotFound());
}
return(Ok(Blog));
}
public static void MapBlogFromBlogDto(ref Blog blog, ref BlogDTO blogDTO)
{
blog.Id = blogDTO.Id;
blog.IsDeleted = blogDTO.IsDeleted;
blog.Name = blogDTO.Name;
blog.UserCreatorId = blogDTO.UserCreatorId;
blog.LastUserModifierId = blogDTO.LastUserModifierId;
blog.DataCreated = blogDTO.DateCreated;
blog.LastDateModified = blogDTO.LastDateModified;
}
public async Task <ActionResult <BlogDTO> > Get(int id)
{
BlogDTO blog = await blogService.GetAsync(id);
if (blog == null)
{
return(NotFound());
}
return(new ObjectResult(blog));
}
public void EditDescription(BlogDTO blog)
{
Blog blog_to_edit = Database.Blogs.GetAll().Where(x => x.BlogId == blog.Id).FirstOrDefault();
blog_to_edit.BlogDescription = blog.blogDescription;
blog_to_edit.BlogName = blog.BlogName;
blog_to_edit.Category = Database.Categories.Get(blog.CategoryId);
Database.Blogs.Update(blog_to_edit);
Database.Save();
}
