public async Task <IActionResult> PutTheater(int id, Theater theater)
{
if (id != theater.TheaterId)
{
return(BadRequest());
}
_context.Entry(theater).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TheaterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult> PostBlog([FromBody] BlogPosts blog)
{
this.DB.Blogs.Add(blog);
await DB.SaveChangesAsync();
return(CreatedAtAction("getBlogs", new { id = blog.Id }, blog));
}
public async Task <T> AddAsync(T entity)
{
await DbContext.Set <T>().AddAsync(entity);
await DbContext.SaveChangesAsync();
return(entity);
}
public async Task <int> Create(TEntity entity)
{
await dbContext.Set <TEntity>().AddAsync(entity);
await dbContext.SaveChangesAsync();
return(entity.Id);
}
public async Task <int> AddPost(Post post)
{
await _context.Post.AddAsync(post);
await _context.SaveChangesAsync();
return(post.PostId);
}
/// <summary>
/// 创建资源
/// </summary>
/// <param name="model">实体</param>
/// <param name="saved">是否保存</param>
/// <returns></returns>
public async Task CreateAsync(T model, bool saved = true)
{
_dbContext.Set <T>().Add(model);
if (saved)
{
await _dbContext.SaveChangesAsync();
}
}
private async Task <UserLoginDto> DoLogin(UserLoginDto userDto, User user)
{
userDto.UserId = user.UserId;
userDto.LoginDto.Token = LoginService.GetToken(user.UserName);
user.Token = userDto.LoginDto.Token;
await _ctx.SaveChangesAsync();
return(userDto);
}
public async Task AddPostAsync(User user, Blog blog, Post post)
{
await dbContext.Entry(blog).Collection(b => b.Posts).LoadAsync();
blog.Posts.Add(post);
await dbContext.SaveChangesAsync();
await MakePostReaded(user, post);
}
public async Task <IActionResult> Post([FromBody] CreatePostDto value)
{
//проверка прав юзера
var user = await _ctx.Users.FirstOrDefaultAsync(u => u.UserId == value.UserId);
if (user == null || user.Privs < (int)UserPermission.AddPost)
{
return(BadRequest("Недостаточно прав для добавления поста"));
}
var author = await _ctx.Authors
.FirstOrDefaultAsync(x => x.AuthorId == value.AuthorId);
if (author == null)
{
return(BadRequest("Ошибка: автор не зарегистрирован"));
}
var allContentsGiven = value.Contents.Any(x => x.Color == 0) &&
value.Contents.Any(x => x.Color == 1);
if (!allContentsGiven)
{
return(BadRequest("Нельзя создать пост с контентом одной стороны"));
}
//создание поста
var post = new Post()
{
Author = author,
PostDate = DateTime.UtcNow
};
//создание контентов к нему
var postContents = value.Contents.Select(content => new PostContent()
{
Title = content.Title,
ImageLink = content.PicLink,
Content = content.HtmlContent,
PostColor = content.Color,
Post = post
})
.ToList();
//соединяем пост с контентами
post.PostContents = postContents;
//добавляем созданный пост
await _ctx.AddAsync(post);
//сохраняем изменения
var result = await _ctx.SaveChangesAsync();
if (result > 0)
{
return(Ok(post.PostId));
}
return(BadRequest("Не удалось создать пост"));
}
public async Task <IFormResult <Post> > CreateItem(Post item)
{
var user = await _userManager.GetUserAsync(_httpContextAccessor.HttpContext.User);
item.Id = Guid.NewGuid();
item.BlogId = item.Blog.Id;
item.Blog = null;
item.CategoryId = item.Category.Id;
item.Category = null;
item.CreatedBy = user.Id;
item.CreatedOn = DateTime.Now;
item.Status = PostStatus.Draft.ToString();
//var dbTags = await _dbContext.Tags.ToDictionaryAsync(t => t.Id, t => t);
//var tags = item.Tags as List<Tag>;
//for (int i = 0; i < tags.Count; i++)
//{
// tags[i] = _blogMapper.Map<Tag>(dbTags[tags[i].Id]);
//}
var entity = _blogMapper.Map <Models.Post>(item);
var dbTags = await _dbContext.Tags.ToDictionaryAsync(t => t.Id, t => t);
var tags = entity.Tags as List <Models.Tag>;
for (int i = 0; i < tags.Count; i++)
{
tags[i] = dbTags[tags[i].Id];
}
var queryableData = await _dbContext.Posts.AddAsync(entity);
await _dbContext.SaveChangesAsync();
if (queryableData.Entity == null)
{
return new FormResult <Post>()
{
IsSucceeded = false,
ErrorMessage = $"Unable to create the Post"
}
}
;
var newPost = await GetItem(item.Id.ToString());
var result = new FormResult <Post>(newPost)
{
IsSucceeded = true,
SuccessMessage = $"Post has been created"
};
return(await Task.FromResult(result));
}
public async Task <Guid> AddAsync(T entity)
{
ArgumentGuard.NotNull(entity, nameof(entity));
await _blogDbContext.Set <T>().AddAsync(entity);
await _blogDbContext.SaveChangesAsync();
return(entity.Id);
}
public async Task <IActionResult> Create([FromBody] CreateBlogRequest createRequest, CancellationToken cancellationToken)
{
var blog = new Blog(Guid.NewGuid(), createRequest.Url);
_dbContext.Add(blog);
await _dbContext.SaveChangesAsync(cancellationToken);
return(CreatedAtRoute(nameof(GetById), new { id = blog.Id }, blog));
}
public async Task <IActionResult> Create([Bind("ID,Name,Content,AuthorEmail")] BgModel bgModel)
{
if (ModelState.IsValid)
{
_context.Add(bgModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(bgModel));
}
public async Task <IActionResult> Create([Bind("Id,Name,Description")] Category category)
{
if (ModelState.IsValid)
{
_context.Add(category);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(category));
}
public async Task <IActionResult> Create([Bind("Id,Title,Content,CreatedAt,CreatedBy")] Blog blog)
{
if (ModelState.IsValid)
{
_context.Add(blog);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(blog));
}
public async Task <ActionResult <Post> > Post(Post post)
{
if (post == null)
{
return(BadRequest());
}
db.Posts.Add(post);
await db.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> Create([Bind("ID,BlogId,Title,Content,Date")] Post post)
{
if (ModelState.IsValid)
{
_context.Add(post);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["BlogId"] = new SelectList(_context.Set <Blog>(), "ID", "ID", post.BlogId);
return(View(post));
}
public async Task <ActionResult <User> > Post(User user)
{
if (user == null)
{
return(BadRequest());
}
db.Users.Add(user);
await db.SaveChangesAsync();
return(Ok(user));
}
public async Task <bool> Add(Category category)
{
if (!await CheckDuplicate(category.CategoryName))
{
await dbContext.Categories.AddAsync(category);
await dbContext.SaveChangesAsync();
return(true);
}
return(false);
}
public async Task <IHttpActionResult> Post(BlogTag m)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
m.CreateTime = System.DateTimeOffset.Now;
m = db.BlogTag.Add(m);
await db.SaveChangesAsync();
return(Created <BlogTag>(m));
}
public async Task <IActionResult> Create([Bind("Id,Nickname,Description,PostedOn,PostId")] Comment comment)
{
if (ModelState.IsValid)
{
_context.Add(comment);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["PostId"] = new SelectList(_context.Posts, "Id", "AppUserId", comment.PostId);
return(View(comment));
}
public async Task <IActionResult> Create([Bind("Id,Title,Description,Published,Modified,AppUserId,CommentId")] Post post)
{
if (ModelState.IsValid)
{
_context.Add(post);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["AppUserId"] = new SelectList(_context.AppUsers, "Id", "Id", post.AppUserId);
return(View(post));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name")] Category category)
{
if (ModelState.IsValid)
{
db.Categories.Add(category);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(category));
}
public async Task <IActionResult> Create([Bind("Id,Title,Content")] Publication publication)
{
if (ModelState.IsValid)
{
publication.UserId = User.Identity.Name;
publication.DateTime = DateTime.Now;
_context.Add(publication);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(publication));
}
public async Task <IActionResult> Create(Blog blog, IFormFile picture)
{
blog.PostedOn = DateTime.Now;
if (ModelState.IsValid)
{
_context.Add(blog);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(blog));
}
public async Task <IHttpActionResult> Post(SubjectCategory m)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
m.CreateTime = System.DateTimeOffset.Now;
//添加专题
m = db.SubjectCategory.Add(m);
await db.SaveChangesAsync();
return(Created <SubjectCategory>(m));
}
public async Task <IActionResult> CreatePost([FromBody] PostResource post)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var mapPost = _iMapper.Map <PostResource, Post>(post);
_context.Posts.Add(mapPost);
await _context.SaveChangesAsync();
return(Ok(mapPost));
}
public async Task <ActionResult> Create([Bind(Include = "ID,Name,Description,Post,Img1,Img2,Img3,Tags,Author,Date")] BlogPost blogpost)
{
if (ModelState.IsValid)
{
blogpost.Author = User.Identity.Name;
blogpost.Date = DateTime.Now;
db.BlogPosts.Add(blogpost);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(blogpost));
}
public async Task <bool> CreatePostAsync(CreatePostViewModel newPost, IdentityUser user)
{
var post = new Post()
{
Title = newPost.Title,
BodyText = newPost.BodyText,
UserId = user.Id
};
_blogDbContext.Posts.Add(post);
var saveResult = await _blogDbContext.SaveChangesAsync();
return(saveResult == 1);
}
public async Task <Response> CreateAsync(CreatePostRequest request)
{
var slug = SlugHelper.GenerateSlug(request.BlogPost.Title);
var post = await _context.Posts.SingleOrDefaultAsync(i => i.Slug == slug);
if (post != null)
{
var error = new ErrorModel
{
Message = $"The blog post {request.BlogPost.Title} already exists"
};
return(new ErrorResponse(error));
}
post = _mapper.Map <Post>(request.BlogPost);
await _context.AddAsync(post);
await _context.SaveChangesAsync();
foreach (var item in request.BlogPost.TagList)
{
var tag = await _context.Tags.SingleOrDefaultAsync(i => i.Name == item);
if (tag == null)
{
tag = new Tag
{
Name = item
};
}
post.PostTags.Add(new PostTag
{
Post = post,
Tag = tag
});
}
await _context.SaveChangesAsync();
var response = _mapper.Map <PostModel>(post);
return(new PostResponse
{
BlogPost = response
});
}
