public ActionResult Create(BlogViewModel model)
{
if (ModelState.IsValid)
{
try
{
model.Id = Guid.NewGuid().ToString();
Blog blog = new Blog();
PropertyCopy.Copy(model, blog);
blogRepository.Add(blog);
blogRepository.Save(requestContext);
return(RedirectToAction("Index"));
}
catch (Exception)
{
return(View());
}
}
return(View());
}
public async Task <ActionResult> Post([FromBody] Blog item)
{
if (!ModelState.IsValid)
{
Context.Response.StatusCode = 400;
return(new ObjectResult("Model is invalid"));
}
if (item.Id > 0)
{
await _db.Update(item);
}
else
{
await _db.Add(item);
Context.Response.StatusCode = 201;
}
return(new ObjectResult(item));
}
public HttpResponseMessage Post([FromBody] BlogItem item)
{
try
{
var result = repository.Add(item);
if (result == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(Request.CreateResponse(HttpStatusCode.Created, result));
}
catch (UnauthorizedAccessException)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, Resources.labels.notAuthorized));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public IActionResult SaveEntity(BlogViewModel productVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
else
{
if (productVm.Id == 0)
{
_blogRepository.Add(productVm);
}
else
{
_blogRepository.Update(productVm);
}
_blogRepository.Save();
return(new OkObjectResult(productVm));
}
}
public ICommandResult Execute(CreateBlogPostCommand command)
{
if (command == null)
{
throw new ArgumentNullException();
}
try
{
var post = new BlogPost();
AddBlogAppurtenance(command, post);
_blogRepository.Add(post);
}
catch (Exception exception)
{
_logger.Error(exception.Message);
return(new FailureResult(BlogPostCommandMessage.BlogPostCreationFaild));
}
return(new SuccessResult(BlogPostCommandMessage.BlogPostCreatedSuccessfully));
}
public async Task CanDoCrudOnBlogs()
{
var allBlogs = await _db.All();
var cnt = allBlogs.Count;
// add
var blog = new Blog {
Title = "blog1", Description = "blog one"
};
await _db.Add(blog);
allBlogs = await _db.All();
Assert.Equal(allBlogs.Count, cnt + 1);
var blogs = await _db.Find(b => b.Title == "blog1");
var added = blogs.FirstOrDefault();
Assert.NotNull(added);
Assert.True(added.Id > 0);
// update
added.Description = "blog one updated";
await _db.Update(added);
blogs = await _db.Find(b => b.Title == "blog1");
added = blogs.FirstOrDefault();
Assert.Equal(added.Description, "blog one updated");
// delete
await _db.Delete(added.Id);
allBlogs = await _db.All();
Assert.Equal(allBlogs.Count, cnt);
}
public async Task <IActionResult> AddBlog(int id, BlogForAddDto blogForAddDto)
{
// if user is not authorized => return 400 NotAuthorized
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var blogToAdd = _mapper.Map <Blog>(blogForAddDto);
blogToAdd.UserId = id;
_repo.Add(blogToAdd);
// if blog adding to db is successfull => return http response status 200 Ok with blog info
if (await _repo.SaveAll())
{
return(Ok(blogToAdd));
}
throw new Exception($"Adding blog failed");
}
public override async Task <BlogDTO> AddAsync(BlogDTO blogDTO)
{
if (blogDTO == null)
{
throw new ArgumentException(_resources.GetStringResource(LocalizationKeys.Application.validation_No_Records_Found_Error));
}
Blog blog = BlogFactory.CreateBlog(blogDTO.Name, blogDTO.Url, blogDTO.Rating);
if (_validator.IsValid <Blog>(blog))
{
_blogRepository.Add(blog);
await _blogRepository.UnitOfWork.CommitAsync();
return(blog.ProjectedAs <BlogDTO>());
}
else
{
throw new ApplicationValidationErrorsException(_validator.GetInvalidMessages <Blog>(blog));
}
}
public ActionResult <BlogCreationViewModel> Post([FromBody] UpdateBlogViewModel model)
{
var creationTime = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds();
var blog = new Model.Blog
{
Title = model.Title,
Content = model.Content,
CreationTime = creationTime,
LastEditTime = creationTime,
OwnerId = NVLInt64(HttpContext.User.Identity.Name, 0),
Draft = true
};
_blogRepository.Add(blog);
_blogRepository.Commit();
return(new BlogCreationViewModel
{
BlogId = blog.Id
});
}
public void Handle(RegisterNewBlogCommand message)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return;
}
Models.Blog blog = new Models.Blog(Guid.NewGuid(), message.Name, message.Title, message.Slug, message.Description, message.CreatedUtc, message.ModifiedUtc, message.PublishedUtc, message.CreatedByUserId, message.CommonStatusId);
if (_blogRepository.GetByName(blog.Name) != null)
{
Bus.RaiseEvent(new DomainNotification(message.MessageType, "The blog name has already been taken."));
return;
}
_blogRepository.Add(blog);
if (Commit())
{
Bus.RaiseEvent(new BlogRegisteredEvent(blog.Id, blog.Name, blog.Title, blog.Slug, blog.Description, blog.CreatedUtc, blog.ModifiedUtc, blog.PublishedUtc, blog.CreatedByUserId, blog.CommonStatusId));
}
}
public async Task <ActionResult <Blog> > Post(Blog model)
{
try
{
var blog = await _blogRepository.IsUnique(model.Name);
if (blog != null)
{
return(BadRequest("Name in Use"));
}
_blogRepository.Add(model);
if (await _blogRepository.SaveChangesAsync())
{
return(Created($"/api/blogs/{model.BlogId}", model));
}
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public async Task <IActionResult> Post([FromBody] BlogModel model)
{
try
{
var blog = new Blog
{
Url = model.Url,
BlogId = model.BlogId
};
_repo.Add(blog);
if (await _repo.SaveAllAsync())
{
return(Ok("OK!"));
}
}
catch (Exception ex)
{
Console.WriteLine($"Exception when trying to post {ex}");
_logger.LogError($"Exception when trying to post {ex}");
return(BadRequest($"Exception when trying to post {ex}"));
}
return(BadRequest("Somthings wrong I can feel it"));
}
public void Add(ModelBL modelBL)
{
var model = Map(modelBL);
_repository.Add(model);
}
public void CreateBlog(Blog blog)
{
blogRepository.Add(blog);
SaveBlog();
}
public void Add(Blog blog)
{
_blogRepository.Add(blog);
}
public Blog Add(Blog blog)
{
return(blogRepository.Add(blog));
}
public void CreateBlog(Blog Blog)
{
BlogsRepository.Add(Blog);
SaveBlog();
}
public void Add(Blog blog)
{
_blogRepository.Add(blog);
_blogRepository.Commit();
}
public async Task <BlogContract> Add(BlogContract contract)
{
return(Mapper.Map <BlogContract>(
_blogRepository.Add(Mapper.Map <Blog>(contract))));
}
public Blog Add(Blog newBlog)
{
return(_blogRepository.Add(newBlog));
}
public ResultMessage <Blog> Add(Blog data)
{
data.isActive = true;
return(_blogRepository.Add(data));
}
public ServiceResult <string> Save(BlogEntryModel entryModel)
{
if (entryModel == null)
{
throw new ArgumentNullException("entryModel");
}
entryModel.RebuildTagsFromString();
BlogEntry entry = null;
if (!Exists(entryModel.Slug))
{
entry = new BlogEntry
{
Slug = entryModel.Title.ToUrlSlug(),
DateCreated = DateTime.Now
};
if (Exists(entry.Slug))
{
return(ServiceResult <string> .Error("Sorry, a post with that slug already exists."));
}
}
else
{
entry = AutoMapper.Mapper.Map <BlogEntryEntity, BlogEntry>(_blogRepository.Single <BlogEntryEntity>(b => b.Slug == entryModel.Slug));
entry.DateCreated = DateTime.ParseExact(entryModel.Date, DateSettings.DateStringFormat(), Thread.CurrentThread.CurrentCulture);
var slugChanged =
!string.Equals(entryModel.Slug, entryModel.NewSlug, StringComparison.InvariantCultureIgnoreCase) &&
!string.IsNullOrWhiteSpace(entryModel.NewSlug);
if (slugChanged)
{
if (Exists(entryModel.NewSlug))
{
return(ServiceResult <string> .Error("Sorry, a post with that slug already exists."));
}
//delete current one as slug is the ID will create / save a new one.
Delete(entryModel.Slug);
entry.Slug = entryModel.NewSlug.ToLowerInvariant();
}
}
if (!IsValidSlug(entry.Slug))
{
return(ServiceResult <string> .Error("That's not a valid slug. Only letters, numbers and hypens are allowed."));
}
entry.Title = entryModel.Title;
entry.Markdown = entryModel.Markdown;
entry.Summary = CreateSummary(entryModel.Markdown);
entry.IsPublished = entryModel.IsPublished;
entry.IsCodePrettified = entryModel.IsCodePrettified;
entry.Author = _blogUserService.FindByName(_currentUserService.GetUserName()).DisplayName;
//update all the tags.
var tags = _blogRepository.All <TagEntity>().ToArray();
var distinctTags = entryModel.Tags.Distinct();
var trimmedTags = distinctTags.Select(t => t.Trim().ToLowerInvariant()).ToArray();
var matchedTags = tags.Where(t => trimmedTags.Contains(t.Name.ToLowerInvariant())).ToArray();
var newTags = trimmedTags.Where(t => tags.All(tag => tag.Name.ToLowerInvariant() != t))
.Select(t => new TagEntity {
Id = 0, Name = t
}).ToArray();
//ensure new tags are added to the list of known tags.
foreach (var newTag in newTags)
{
_blogRepository.Add(newTag);
}
var actualTags = newTags.Union(matchedTags);
var entryEntity = AutoMapper.Mapper.Map <BlogEntry, BlogEntryEntity>(entry);
entryEntity.Tags.Clear();
entryEntity.Tags.AddRange(actualTags);
_blogRepository.Save(entryEntity, b => b.Slug == entry.Slug);
_blogTagService.RemoveUnsedTags();
_blogTagService.UpdateTagCount();
return(ServiceResult <string> .Success(entry.Slug));
}
public void Add(Blog blog)
{
_blogRepository.Add(blog);
_unitOfWork.Commit();
}
public async Task AddBlog(AddBlogRequest request)
{
var blog = new Blog(request.Author, request.Topic, request.Body);
await _repository.Add(blog);
}
public async Task <int> AddPost(AddPostDto postDto)
{
var post = _blogConverter.ConvertToPost(postDto);
return(await _blogRepository.Add(post));
}
public IActionResult BlogAdd(Blog blog)
{
_blogRespository.Add(blog);
_blogRespository.SaveAll();
return(RedirectToAction("Index", "Auth"));
}
public void Init()
{
var serviceLocator = new RepositoryServiceLocator();
_postRepository = serviceLocator.Locate<IPostRepository>();
_userRepository = serviceLocator.Locate<IUserRepository>();
_blogRepository = serviceLocator.Locate<IBlogRepository>();
// add the needed user
_neededUser = new User
{
DisplayName = "Galilyou",
Email = "*****@*****.**",
Url = "http://galilyou.blogspot.com",
SignUpDate = DateTime.Now
};
_userRepository.Add(_neededUser);
// add the needed blog
_neededBlog = new Blog {Name = "Programming for Cowards", Author = _neededUser, CreatedDate = DateTime.Now, LastModifiedDate = DateTime.Now};
_blogRepository.Add(_neededBlog);
}
public void CreateBlog(Blog blog)
{
blogsRepository.Add(blog);
}
public Post Add([FromBody] Post _newPost)
{
_blogRepository.Add(_newPost);
_blogRepository.Save();
return(_newPost);
}
public Blog CreateBlog(Blog blog)
{
_blogRepository.Add(blog);
_unitOfWork.Commit();
return(_blogRepository.Get(a => a.BlogId == blog.BlogId).FirstOrDefault());
}
public IActionResult Create(Blog blog)
{
blog.AccountId = GetCurrentUserId();
blogRepo.Add(blog);
return(View("Post", blog));
}