public async Task <IActionResult> CreateThread([FromForm] CreateThreadViewModel model, [FromForm] string unparsedContent)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
if (string.IsNullOrWhiteSpace(unparsedContent))
{
return(new ContentResult
{
ContentType = "text/html",
StatusCode = (int)HttpStatusCode.BadRequest,
Content = "Content can't be empty"
});
}
var createResult = await _threadsManagementService.CreateThreadAsync(model.Title, model.Content, model.SectionName, User.Identity.Name);
if (!createResult.IsSuccess)
{
var errorMessage = GetErrorMessage(createResult.ErrorType);
return(new ContentResult
{
ContentType = "text/html",
StatusCode = (int)HttpStatusCode.BadRequest,
Content = errorMessage
});
}
return(Ok());
}
public IActionResult CreateThread(int id)
{
CreateThreadViewModel model = new CreateThreadViewModel {
id = id
};
return(View(model));
}
public ViewResult CreateThread(int boardId)
{
CreateThreadViewModel model = new CreateThreadViewModel();
model.BoardTitle = _boardRepository.GetById(boardId).Title;
model.BoardId = boardId;
return(View(model));
}
public CreateThreadPage(CreateThreadViewModel viewModel)
{
BindingContext = viewModel;
InitializeComponent();
MessagingCenter.Subscribe <CreateThreadViewModel, string>(viewModel, "Error", (sender, data) =>
{
DisplayAlert("Error", data, "Ok");
});
}
public ActionResult Create(int forumId)
{
Forum theForum = db.Forums.Single(f => f.ForumId == forumId);
CreateThreadViewModel ctvm = new CreateThreadViewModel
{
TheForum = theForum
};
return(View(ctvm));
}
public ActionResult Delete(int threadId, int forumId)
{
Thread theThread = db.Threads.SingleOrDefault(t => t.ThreadId == threadId);
Forum theForum = db.Forums.SingleOrDefault(f => f.ForumId == forumId);
CreateThreadViewModel viewModel = new CreateThreadViewModel
{
TheThread = theThread,
TheForum = theForum
};
return(View(viewModel));
}
public async Task <ActionResult <int> > PostThreadCreate(CreateThreadViewModel createThreadEntryViewModel)
{
ThreadEntry threadEntry = new ThreadEntry();
if (ModelState.IsValid)
{
string currentUserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
ApplicationUser currentUser = await _context.Users.FirstOrDefaultAsync(x => x.Id == currentUserId).ConfigureAwait(false);
threadEntry.Author = currentUser;
threadEntry.InjectFrom(createThreadEntryViewModel);
threadEntry.CreatedAt = DateTime.Now;
threadEntry.UpdatedAt = DateTime.Now;
threadEntry.Locked = false;
if (createThreadEntryViewModel.ForumId == -1)
{
threadEntry.PostNumber = 1;
}
else
{
threadEntry.Forum = await _context.Fora.FirstOrDefaultAsync(forum => forum.Id == createThreadEntryViewModel.ForumId);
threadEntry.Parent = await _context.ForumThreadEntrys.Include(te => te.Root).Include(te => te.Children).FirstOrDefaultAsync(thread => thread.Id == createThreadEntryViewModel.parentId);
threadEntry.Root = threadEntry.Parent.Root;
}
_context.ForumThreadEntrys.Add(threadEntry);
try
{
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateException exception)
{
Console.WriteLine($"SaveChangesAsync threw an exception Message: {exception.Message}");
}
if (threadEntry.Parent == null && threadEntry.Root != null)
{
threadEntry.UpdatedAt = threadEntry.CreatedAt;
threadEntry.Root.Id = threadEntry.Id;
await _context.SaveChangesAsync().ConfigureAwait(false);
}
}
return(threadEntry.PostNumber);
}
public async Task <ActionResult> Post([FromBody] CreateThreadViewModel threadViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var threadDto = _mapper.Map <CreateThreadViewModel, ThreadDto>(threadViewModel);
await _threadService.CreateAsync(threadDto);
return(Ok());
}
public ActionResult Create(CreateThreadViewModel model)
{
try
{
return(RedirectToAction("Preview", new { id = threadService.Create(model) }));
}
catch (NoCategoryException e)
{
return(View("NoCategory"));
}
catch (CouldntCreateThread e) {
}
return(RedirectToAction("Index", "Home", new { }));
}
public ActionResult Index([Bind(Include = "Title, Content, SectionId")] CreateThreadViewModel threadViewModel)
{
if (ModelState.IsValid)
{
var thread = this.mappingService.Map <Thread>(threadViewModel);
thread.Published = DateTime.Now;
thread.IsVisible = true;
thread.UserId = User.Identity.GetUserId();
this.data.Threads.Add(thread);
this.data.SaveChanges();
return(RedirectToAction(WebConstants.IndexAction, WebConstants.ThreadController, new { id = thread.Id, title = thread.Title }));
}
return(this.View(threadViewModel));
}
public async Task <IActionResult> CreateThread(CreateThreadViewModel model)
{
if (ModelState.IsValid)
{
Thread thread = new Thread();
Match match = db.Match.Find(model.id);
thread.match = match;
thread.name = model.name;
thread.user = await _userManager.GetUserAsync(User);
db.Thread.Add(thread);
await db.SaveChangesAsync();
return(RedirectToAction("Index", "Match", new { id = model.id }));
}
return(View(model));
}
public int Create(CreateThreadViewModel model)
{
using (ApplicationDbContext db = new ApplicationDbContext()) {
Kategoria category = db.Kategorie.Where(w => w.Id == model.CategoryId).FirstOrDefault();
if (category == null)
{
throw new NoCategoryException();
}
Watek newThread = new Watek()
{
Tytul = model.Title,
SlowaKluczowe = model.Keywords,
Aktywny = true,
DataDodania = DateTime.Now,
Grafika = "",
IdKategorii = category.Id,
IdUzytkownika = "123"//HttpContext.Current.User.Identity.Name
};
db.Watki.Add(newThread);
if (db.SaveChanges() > 0)
{
Post newPost = new Post()
{
IdWatku = newThread.Id,
Tresc = model.Content,
DataDodania = DateTime.Now,
IdUzytkownika = HttpContext.Current.User.Identity.Name
};
db.Posty.Add(newPost);
if (db.SaveChanges() > 0)
{
return(newThread.Id);
}
}
throw new CouldntCreateThread();
}
}
public void Forum_CreateController_Index_Post_ShouldCallRedirectToActionWithCorrectRouteParams()
{
//Arrange
var data = new Mock <IUowData>();
var threadRepository = new Mock <IRepository <Thread> >();
var mappingService = new Mock <IMappingService>();
data.Setup(d => d.Threads).Returns(threadRepository.Object);
var claim = new Claim("test", "asd-123");
var identity = new Mock <ClaimsIdentity>();
identity.Setup(i => i.FindFirst(It.IsAny <string>())).Returns(claim);
var principal = new Mock <IPrincipal>();
principal.Setup(p => p.Identity).Returns(identity.Object);
var context = new Mock <ControllerContext>();
context.Setup(c => c.HttpContext.User).Returns(principal.Object);
mappingService.Setup(m => m.Map <Thread>(It.IsAny <CreateThreadViewModel>())).Returns(new Thread()
{
Id = 3
});
CreateController controller = new CreateController(data.Object, mappingService.Object)
{
ControllerContext = context.Object
};
var thread = new CreateThreadViewModel();
//Act
RedirectToRouteResult redirectResult = controller.Index(thread) as RedirectToRouteResult;
//Assert
Assert.AreEqual(3, redirectResult.RouteValues["id"]);
}
public async Task <IActionResult> CreateThread([FromQuery] string sectionName)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
var model = new CreateThreadViewModel
{
SectionName = sectionName
};
var content = await this.RenderViewToStringAsync("/Views/Threads/CreateThread.cshtml", model);
return(new ContentResult
{
ContentType = "text/html",
StatusCode = (int)HttpStatusCode.OK,
Content = content
});
}
public void Forum_CreateController_Index_Post_ShouldAddInstanceOfAThread()
{
//Arrange
var data = new Mock <IUowData>();
var mappingService = new Mock <IMappingService>();
var threadRepository = new Mock <IRepository <Thread> >();
data.Setup(d => d.Threads).Returns(threadRepository.Object);
var claim = new Claim("test", "asd-123");
var identity = new Mock <ClaimsIdentity>();
identity.Setup(i => i.FindFirst(It.IsAny <string>())).Returns(claim);
var principal = new Mock <IPrincipal>();
principal.Setup(p => p.Identity).Returns(identity.Object);
var context = new Mock <ControllerContext>();
context.Setup(c => c.HttpContext.User).Returns(principal.Object);
mappingService.Setup(m => m.Map <Thread>(It.IsAny <CreateThreadViewModel>())).Returns(new Thread());
CreateController controller = new CreateController(data.Object, mappingService.Object)
{
ControllerContext = context.Object
};
var thread = new CreateThreadViewModel();
//Act
var result = controller.Index(thread) as ViewResult;
//Assert
threadRepository.Verify(d => d.Add(It.IsAny <Thread>()));
}
public IActionResult CreateThread(CreateThreadViewModel model)
{
if (ModelState.IsValid)
{
Thread newThread = new Thread
{
Title = model.Title,
BoardId = model.BoardId
};
_threadRepository.Add(newThread);
Post newPost = new Post
{
Content = model.Content,
ThreadId = newThread.Id,
User = User.Identity.Name
};
_postRepository.Add(newPost);
return(RedirectToAction("index", new { boardId = model.BoardId }));
}
return(View(model));
}
// GET: PrivateMessage/Create
public ActionResult CreateThread()
{
CreateThreadViewModel viewModel = new CreateThreadViewModel();
var userId = User.Identity.GetUserId();
viewModel.User = db.Users.ToList().Find(x => x.Id == userId);
viewModel.PostsCount = db.Posts.ToList().FindAll(x => x.UserID == viewModel.User.Id).Count();
viewModel.TopicsCount = db.Topics.ToList().FindAll(x => x.UserID == viewModel.User.Id).Count();
viewModel.Roles = new List <IdentityRole>();
foreach (IdentityUserRole role in viewModel.User.Roles)
{
viewModel.Roles.Add(db.Roles.ToList().Find(x => x.Id == role.RoleId));
}
var lastRole = viewModel.User.Roles.Last();
viewModel.UserRole = db.Roles.Find(lastRole.RoleId).Name;
return(View(viewModel));
}
public ActionResult CreateThread(CreateThreadViewModel request)
{
try
{
var newThread = new PrivateThread();
var userId = User.Identity.GetUserId();
newThread.Recipient = db.Users.ToList().Find(x => x.UserName == request.Recipient);
newThread.SenderID = userId;
newThread.Title = request.Title;
db.PrivateThreads.Add(newThread);
db.SaveChanges();
var newMessage = new PrivateMessage();
newMessage.AuthorID = userId;
newMessage.Content = Html.EditMarkers(request.Content);
newMessage.Date = DateTime.Now;
newMessage.PrivateThread = newThread;
if (Request.Files != null)
{
bool error = false;
if (Request.Files.Count > 3)
{
error = true;
ViewBag.Error = Resources.AttachmentCount;
}
for (int i = 0; i < Request.Files.Count; i++)
{
if (Request.Files[i].ContentLength > 512 * 1024)
{
ViewBag.Error = Resources.AttachmentSize;
error = true;
break;
}
}
if (error)
{
request.User = db.Users.ToList().Find(x => x.Id == userId);
request.PostsCount = db.Posts.ToList().FindAll(x => x.UserID == request.User.Id).Count();
request.TopicsCount = db.Topics.ToList().FindAll(x => x.UserID == request.User.Id).Count();
request.Roles = new List <IdentityRole>();
foreach (IdentityUserRole role in request.User.Roles)
{
request.Roles.Add(db.Roles.ToList().Find(x => x.Id == role.RoleId));
}
return(View(request));
}
db.PrivateMessages.Add(newMessage);
db.SaveChanges();
for (int i = 0; i < Request.Files.Count; i++)
{
HttpPostedFileBase file = Request.Files[i];
if (file == null || file.FileName == "")
{
continue;
}
file.SaveAs(HttpContext.Server.MapPath("~/Content/Attachments/")
+ file.FileName);
MessageFile _messageFile = new MessageFile();
_messageFile.Filename = "~/Content/Attachments/" + file.FileName;
_messageFile.PrivateMessage = newMessage;
db.MessageFiles.Add(_messageFile);
db.SaveChanges();
}
}
else
{
db.PrivateMessages.Add(newMessage);
db.SaveChanges();
}
return(RedirectToAction("ViewThread", new { id = newThread.ID }));
}
catch
{
var userId = User.Identity.GetUserId();
request.User = db.Users.ToList().Find(x => x.Id == userId);
request.PostsCount = db.Posts.ToList().FindAll(x => x.UserID == request.User.Id).Count();
request.TopicsCount = db.Topics.ToList().FindAll(x => x.UserID == request.User.Id).Count();
request.Roles = new List <IdentityRole>();
foreach (IdentityUserRole role in request.User.Roles)
{
request.Roles.Add(db.Roles.ToList().Find(x => x.Id == role.RoleId));
}
return(View(request));
}
}
