public async Task CreatePost_Post_ModelError()
{
var context = MakeContext();
var controller = new OperatorController(
context.CurrentUserService,
context.BranchesDao,
context.MailDaoMock.Object)
{
ControllerContext = context.ControllerContext,
TempData = context.TempDataDictionary
};
var destinationBranch = context.Branches[0];
var vm = new CreatePostViewModel
{
PersonFrom = "personFrom",
PersonTo = "personTo",
DestinationBranchId = destinationBranch.Id,
AddressTo = "addressTo"
};
controller.ModelState.AddModelError("", "error");
var r = await controller.CreatePost(vm) as ViewResult;
Assert.NotNull(r);
Assert.Null(r.ViewName);
var returnedVm = r.Model as CreatePostViewModel;
Assert.NotNull(returnedVm);
Assert.Equal(context.Branches, returnedVm.AllBranches);
context.MailDaoMock.Verify(
m => m.CreateAsync(It.IsAny <Post>(), It.IsAny <User>()),
Times.Never);
}
public IActionResult Create()
{
var tags = this.tagRepository.GetAll();
var viewModel = new CreatePostViewModel(tags);
return(View(viewModel));
}
// Functions
public static NewsFeedViewModel CreatePost(CreatePostViewModel creatPostViewModel, HttpPostedFileBase postPhoto)
{
using (BewanderContext db = new BewanderContext())
{
// GET: Models needed for CreatePostViewModel
string userID = creatPostViewModel.UserID;
User user = db.Users.Find(userID);
Image profilePicture = Image.GetProfileImages(userID, FileType.ProfilePicture);
Post newPost = new Post {
DatePosted = DateTime.Now, Caption = creatPostViewModel.Caption, UserID = userID
};
Image postedPhoto = new Image();
if (postPhoto != null)
{
Image.SavePhotos(user, postPhoto);
postedPhoto = (Image)db.Users.Find(userID).Files.Last();
newPost.PhotoID = postedPhoto.ID;
}
db.Posts.Add(newPost);
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
NewsFeedViewModel postDisplayViewModel = new NewsFeedViewModel(user, profilePicture, postedPhoto, newPost);
return(postDisplayViewModel);
}
}
public async Task <IActionResult> CreatePost(CreatePostViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user.");
}
await _applicationDbContext.Posts.AddAsync(new Post
{
Id = Guid.NewGuid().ToString(),
Title = model.Title,
TitleUrl = model.TitleUrl,
Description = model.Description,
PostedOn = DateTime.UtcNow,
Author = user.Email
});
await _applicationDbContext.SaveChangesAsync();
return(View());
}
//Creation
public static void CreatePost(CreatePostViewModel newPostInfo)
{
try
{
var location = new GeoLocation();
location.Latitude = 2.43M;
location.Longitude = 3.44M;
var setDateTime = DateTime.Now;
var newPost = new Post();
newPost.User = CurrentUser.Storage().UserDb;
newPost.GeoLocation = location;
newPost.Community = DbManager.GetInstance().Community.Single(c => c.CommunityId == CurrentUser.Storage().UserDb.CommunityId);
newPost.TaskType = DbManager.GetInstance().Task.Single(t => t.TaskTypeId == newPostInfo.TaskTypeId);
newPost.DatePosted = setDateTime;
newPost.DateModified = setDateTime;
newPost.CommentTxt = newPostInfo.UserComment;
newPost.DoneFlag = false;
DbManager.GetInstance().Post.Add(newPost);
DbManager.GetInstance().SaveChanges();
}
catch (System.Exception)
{
throw;
}
}
public async Task <int> CreatePostAsync(CreatePostViewModel post, User creator)
{
var message = new Message
{
Author = creator,
Text = post.Message,
Created = DateTime.Now
};
var discussion = new Discussion
{
Author = creator,
Topic = post.Topic,
Created = DateTime.Now,
Messages = new List <Message>
{
message
}
};
var entry = await _context.Discussions.AddAsync(discussion);
await _context.SaveChangesAsync();
_logger.LogInformation("New discussion was created: {0}", entry);
return(entry.Entity.DiscussionId);
}
//Display Post in the input box for editing
public ActionResult Edit(int?id)
{
if (!id.HasValue)
{
return(RedirectToAction(nameof(HomeController.Index)));
}
var post = DbContext.Posts.FirstOrDefault(
p => p.Id == id);
if (post == null)
{
return(RedirectToAction(nameof(HomeController.Index)));
}
var model = new CreatePostViewModel();
model.Title = post.Title;
model.Body = post.Body;
model.Published = post.Published;
model.MainSlide = post.MainSlide;
model.MediaUrl = post.MediaUrl;
return(View(model));
}
public async Task <IActionResult> Post([FromBody] CreatePostViewModel createPostView)
{
var postDto = _mapper.Map <CreatePostViewModel, PostDto>(createPostView);
await _postService.CreateAsync(postDto);
return(Ok());
}
public async Task <IActionResult> Create(CreatePostViewModel model)
{
if (ModelState.IsValid)
{
User user = await _userManager.FindByNameAsync(User.Identity.Name);
if (user is null)
{
throw new InvalidOperationException("There is no current user.");
}
var post = new Post
{
User = user,
Title = model.Title,
Text = model.Text,
Time = DateTime.Now,
Comments = null
};
if (String.IsNullOrWhiteSpace(model.Title) || String.IsNullOrWhiteSpace(model.Text))
{
ModelState.AddModelError(String.Empty, "Both title and text must be provided.");
}
else
{
await _context.PostModels.AddAsync(post);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public async Task <IActionResult> Add([FromForm] CreatePostDto createPostDto)
{
try
{
string createdFilePath = _fileService.CreateLocalFile(createPostDto.PhotoFile, PostPhotosFolder);
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(BadRequest());
}
createPostDto.AuthorId = user.Id;
CreatePostViewModel createPostViewModel = CustomMapper.GetCreatePostViewModel(createPostDto, createdFilePath);
var result = await _postService.Add(createPostViewModel);
if (result.IsValid)
{
return(Ok());
}
return(BadRequest(result.Errors));
}
catch (IOException) { }
return(BadRequest());
}
public async Task <IActionResult> CreatePost(CreatePostViewModel viewModel)
{
var userId = GetUserIdFromClaims(User);
if (userId == null)
{
return(Unauthorized(new UnauthorizedErrorViewModel()));
}
var post = Mapper.Map <Post>(viewModel);
post.AuthorId = userId.Value;
// Automatically like your own post.
post.Likes = new List <Like>
{
new Like
{
UserId = userId.Value
}
};
post.Posted = DateTime.Now;
_postService.Add(post);
await _context.SaveChangesAsync();
return(CreatedAtRoute(new { id = post.Id }, null));
}
public async Task <IActionResult> Edit(CreatePostViewModel model, int?id)
{
if (model != null && id != null)
{
List <string> _tags = null;
if (model.Tags != null)
{
// Работа с тэгами.
_tags = model.Tags
.ToLower() // В нижний регистр.
.Replace(" ", "") // Удалить все пробелы.
.Split(',') // Сделать массив подстрок.
.ToList(); // В List<string>.
}
else
{
_tags = new List <string>()
{
"default"
};
}
Post post = await db.Posts.FirstOrDefaultAsync(p => p.Id == id);
post.Title = model.Title;
post.Tags = _tags;
post.Topic = model.Topic;
post.Text = model.Text;
await db.SaveChangesAsync();
return(Redirect("~/Post/Question/" + id));
}
return(NotFound());
}
public async Task <IActionResult> Edit(int id)
{
Post post = await db.Posts
.Include(p => p.Sender)
.FirstOrDefaultAsync(p => p.Id == id);
if (post.Sender.Login == User.Identity.Name && post != null)
{
string _tags = "";
foreach (string tag in post.Tags)
{
_tags += tag + ", ";
}
CreatePostViewModel viewModel = new CreatePostViewModel
{
Title = post.Title,
Tags = _tags,
Topic = post.Topic,
Text = post.Text,
Id = id
};
return(View(viewModel));
}
return(NotFound());
}
public async Task <IActionResult> Create(CreatePostViewModel postModel)
{
Post post = new Post
{
Title = postModel.Title
};
foreach (var doc in postModel.Documents)
{
var document = await CreateDocumentAsync(doc).ConfigureAwait(false);
post.PostDocuments.Add(document);
}
var user = await _userManager.FindByIdAsync(postModel.AuthorId);
user.Posts.Add(post);
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
RedirectToAction("Index", "Profile");
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(postModel));
}
public async Task <IActionResult> CreatePost(CreatePostViewModel createPostViewModel)
{
try
{
if (ModelState.IsValid)
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "Images", createPostViewModel.FileUrl.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
await createPostViewModel.FileUrl.CopyToAsync(stream);
}
Post post = new Post()
{
UserId = HttpContext.Session.GetString("UserId"),
FileUrl = "/Images/" + Path.GetFileName(path),
Description = htmlEncoder.Encode(createPostViewModel.Description),
CreationDate = DateTime.Now
};
postService.Create(post);
}
return(RedirectToAction(nameof(Details), new { id = HttpContext.Session.GetString("UserId") }));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(View("Error", new ErrorViewModel()));
}
}
public ActionResult Create([Bind(Include = "Title,Body,AuthorId,Tags")] CreatePostViewModel viewModel)
{
if (ModelState.IsValid)
{
Post post = new Post
{
Author = db.Users.FirstOrDefault(u => u.Id == viewModel.AuthorId),
Title = viewModel.Title,
Body = viewModel.Body,
AuthorId = viewModel.AuthorId,
};
var existingTags = db.Tags.ToList();
var inputTags = viewModel.GetTags();
if (inputTags[0] != string.Empty)
{
post.AddTags(inputTags, existingTags);
}
db.Posts.Add(post);
db.SaveChanges();
this.AddNotification("Post created successfully.", NotificationType.SUCCESS);
return(RedirectToAction("Details", new { id = post.Id }));
}
this.AddNotification("Error while creating the post.", NotificationType.ERROR);
return(View());
}
// GET: Posts/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(RedirectToAction("Error", "Error"));
}
var post = await _context.Post.Include("PostTags.Category").
FirstOrDefaultAsync(p => p.Id == id);
if (post == null)
{
return(RedirectToAction("Error", "Error"));
}
CreatePostViewModel createPostViewModel = new CreatePostViewModel(await _context.Category.ToListAsync());
createPostViewModel.Post = post;
List <int> cat = new List <int>();
foreach (var item in post.Categories)
{
cat.Add(item.Id);
}
createPostViewModel.SelectedCategories = cat;
return(View(createPostViewModel));
}
public ActionResult Create(CreatePostViewModel model)
{
if (!ModelState.IsValid)
{
model.ImageList = _imageService.Get();
model.PostCategoryList = _postCategoryService.Get();
model.UserList = _userService.Get(new List <string>()
{
"Admin", "Editor"
});
model.RoleList = _roleService.Get();
return(View("_Create", model));
}
var postId = _postService.Create(model.PostTitle, model.PostCategoryId, model.PostAuthorUserId, model.PostDescription, model.PostBody);
if (model.PublicationState == PublicationState.Published)
{
_postService.Publish(postId);
}
UpdateBanner(postId, model.BannerImageId);
UpdateGallery(postId, model.GalleryImageList);
_postService.Roles(postId, model.SelectedRoleList);
return(this.Content("Blog"));
}
public IActionResult Create(CreatePostViewModel postViewModel)
{
_uow.BeginTransaction();
try
{
if (!ModelState.IsValid)
{
return(View());
}
var post = _mapper.Map <Post>(postViewModel);
post.UserId = UserId;
if (postViewModel.Photo != null)
{
var path = "/Files" + postViewModel.Photo.FileName;
using var fileStream = new FileStream(_environment.WebRootPath + path, FileMode.Create);
postViewModel.Photo.CopyTo(fileStream);
post.Photo = path;
}
_uow.Posts.Create(post);
_uow.Save();
_uow.Commit();
return(RedirectToAction("Index"));
}
catch
{
_uow.Rollback();
return(View());
}
}
public async Task <IActionResult> Create(CreatePostViewModel newPostViewModel)
{
if (newPostViewModel.post.CategoryId == 0)
{
ModelState.AddModelError("", "Select Category");
}
else
{
long SelectedValue = newPostViewModel.post.CategoryId;
//ViewBag.SelectedValue =category.id;
newPostViewModel.post.Likes = 0;
newPostViewModel.post.Approved = false;
newPostViewModel.post.PostedAt = DateTime.Now;
newPostViewModel.post.Edited = false;
var userName = _userManager.GetUserName(User);
newPostViewModel.post.UserName = userName;
ApplicationUser userId = await _userManager.GetUserAsync(User);
newPostViewModel.post.UserId = userId;
newPostViewModel.post.CategoryId = SelectedValue;
newPostViewModel.post.approvedByUser = null;
newPostViewModel.post.approvedByUserId = null;
}
await _postService.Insert(newPostViewModel.post);
return(RedirectToAction("Index", "Home"));
}
public async void Create_New_Post_Success()
{
IPostService postService = new PostService(_mockPostRepository.Object);
CreatePostViewModel createPostViewModel = new CreatePostViewModel
{
Text = PostText,
Title = PostTitle,
FromId = Guid.NewGuid()
};
Post post = new Post(new Content(createPostViewModel.Text), new Title(createPostViewModel.Title), createPostViewModel.FromId);
_mockPostRepository.Setup(repo => repo.AddAsync(It.Is <Post>(p => p.FromId == post.FromId))).Returns(Task.CompletedTask);
_mockPostRepository.Setup(repo => repo.AddAsync(It.Is <Post>(p => p.FromId != post.FromId)));
_mockPostRepository.Setup(repo => repo.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(post);
var returnedPost = await postService.CreatePostAsync(createPostViewModel);
Assert.NotNull(returnedPost);
Assert.Equal(post.Title.Text, createPostViewModel.Title);
Assert.Equal(post.Content.Text, createPostViewModel.Text);
Assert.Equal(post.FromId, createPostViewModel.FromId);
}
public ActionResult Create(CreatePostViewModel postView)
{
string tags = postView.Tags;
var post = Mapper.Map <CreatePostViewModel, Post>(postView);
post.AuthorId = ((Student)Session["User"]).Id;
db.Posts.Add(post);
post.Created = DateTime.Now;
if (post.Tags == null)
{
post.Tags = new List <Tags>();
}
foreach (var tag in tags.Split(' ').Distinct())
{
var buf = db.Tags.Where(a => a.Name == tag).SingleOrDefault();
if (buf == null)
{
buf = new Tags()
{
Name = tag
};
db.Tags.Add(buf);
}
post.Tags.Add(buf);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult CreatePost(CreatePostViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
else
{
Post newPost = new Post();
newPost.Text = model.Text;
newPost.DiscussionId = model.DiscussionId;
newPost.UserId = User.Identity.GetUserId();
newPost.CreatedDate = DateTime.Now;
context.Posts.Add(newPost);
ApplicationUser user = context.Users.SingleOrDefault(u => u.Id == newPost.UserId);
user.PostsCount = user.PostsCount + 1;
Discussion discussion = context.Discussions.SingleOrDefault(d => d.DiscussionId == newPost.DiscussionId);
discussion.PostCount = discussion.PostCount + 1;
context.SaveChanges();
return(RedirectToAction("Discussion", new { discussionid = newPost.DiscussionId }));
}
}
public async Task <IActionResult> CreateNewPost(CreatePostViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("CreatePost", "Post", new { categoryId = model.Post.CategoryId }));
}
var user = await _userManager.GetUserAsync(User);
if (user is null)
{
return(NotFound());
}
var entry = await _dbContext.Posts.AddAsync(new Post
{
AuthorId = user.Id,
CategoryId = model.Post.CategoryId,
Title = model.Post.Title,
Content = model.Post.Content,
DateCreated = DateTime.Now
});
var ok = await _dbContext.SaveChangesAsync();
if (ok == 0)
{
return(StatusCode(500));
}
return(RedirectToAction("Post", "Post", new { id = entry.Entity.Id }));
}
public async Task <ActionResult> Create()
{
var postCategories = await _postCategoryService.GetAsync();
var imageList = await _imageService.GetAsync();
var model = new CreatePostViewModel
{
PostCategoryId = postCategories.First().PostCategoryId,
PostAuthorUserId = UserHelper.Id,
PostCategoryList = postCategories,
UserList = await _userService.GetByRoleAsync(new List <string> {
nameof(Admin), "Editor"
}),
PublicationState = PublicationState.Published,
BannerImages = new PaginationViewModel
{
ImageList = imageList.Where(x => x.ImageCategory == ImageCategory.General || x.ImageCategory == ImageCategory.Screenshot || x.ImageCategory == ImageCategory.Texture),
TargetInputField = BANNER_IMAGE_ID,
PaginationType = BANNER
},
GalleryImages = new PaginationViewModel
{
ImageList = imageList.Where(x => x.ImageCategory == ImageCategory.General || x.ImageCategory == ImageCategory.Screenshot || x.ImageCategory == ImageCategory.Texture),
TargetInputField = GALLERY_IMAGE_LIST,
PaginationType = GALLERY
},
RoleList = await _roleService.GetAsync()
};
return(View("_Create", model));
}
public IActionResult UpdatePost([FromBody] CreatePostViewModel viewModel)
{
if (ModelState.IsValid)
{
var post = postService.GetPostById(viewModel.Id);
post.Tags.Clear();
var updatedPost = ModelFactory.Create(post, viewModel);
updatedPost.Modified = DateTime.UtcNow;
if (updatedPost.Image.Base64 != null)
{
updatedPost.Image.ToImage();
}
postService.UpdatePost(updatedPost);
if (postService.SaveAll())
{
return(Ok());
}
}
return(BadRequest());
}
public async Task <ActionResult> Create(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AlbumDTO albumDto = await albumService.FindByIdAsync((int)id);
if (albumDto == null)
{
return(HttpNotFound());
}
string userId = albumDto.UserId;
if (userId != User.Identity.GetUserId())
{
return(RedirectToAction("Index", "Home"));
}
CreatePostViewModel postVM = new CreatePostViewModel()
{
AlbumId = albumDto.Id
};
return(View(postVM));
}
public ActionResult Create(CreatePostViewModel model)
{
if (ModelState.IsValid)
{
// save post
var post = new Post
{
Title = model.Title,
Body = model.Body,
Posted = DateTime.Now
};
// save tagPot
var tagPost = new TagPost
{
TagId = model.SelectedTadId,
PostId = post.Id,
Place = model.SelectedPlace
};
post.TagPost.Add(tagPost);
db.Post.Add(post);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
// GET: Post/Edit/5
public ActionResult Edit(string forumName, string tagName, string postTitle)
{
if (postTitle == null)
{
return(PageNotFound());
}
var post = db.Post.First(m => m.Title == postTitle);
if (post == null)
{
return(HttpNotFound());
}
var count = db.Post.Where(o => o.TagPost.Any(b => b.Tag.Name == tagName)).Count();
var model = new CreatePostViewModel
{
Id = post.Id,
Title = post.Title,
Body = post.Body,
Tags = db.Tag.ToList(),
PlacesCount = count + 1
};
ViewBag.forumName = forumName;
ViewBag.tagName = tagName;
ViewBag.postTitle = postTitle;
return(View(model));
}
public IActionResult Create()
{
var forumThreads = this.unitOfWork.ForumThreadRepository.GetAll().ToList();
var model = new CreatePostViewModel(forumThreads);
return(View(model));
}
