func ActionMoveThread(w http.ResponseWriter, r *http.Request) {
current_user := utils.GetCurrentUser(r)
if current_user == nil || !current_user.CanModerate() {
http.NotFound(w, r)
return
}
thread_id_str := r.FormValue("post_id")
thread_id, err := strconv.Atoi(thread_id_str)
board_id_str := r.FormValue("to")
board_id, err := strconv.Atoi(board_id_str)
op, err := models.GetPost(thread_id)
// boards, _ := models.GetBoardsfor(current_user.GroupId)
boards, _ := models.GetBoards()
if op == nil || err != nil {
http.NotFound(w, r)
return
}
if board_id_str != "" {
db := models.GetDbSession()
new_board, _ := models.GetBoard(board_id)
if new_board == nil {
http.NotFound(w, r)
return
}
_, err := db.Exec("UPDATE posts SET board_id=$1 WHERE parent_id=$2", new_board.Id, op.Id)
op.BoardId = new_board.Id
db.Update(op)
if err != nil {
http.NotFound(w, r)
fmt.Printf("Error moving post: %s\n", err.Error())
return
}
http.Redirect(w, r, fmt.Sprintf("/board/%d/%d", op.BoardId, op.Id), http.StatusFound)
}
board, err := models.GetBoard(int(op.BoardId))
utils.RenderTemplate(w, r, "action_move_thread.html", map[string]interface{}{
"board": board,
"thread": op,
"boards": boards,
}, nil)
}
func NewThread(w http.ResponseWriter, r *http.Request) {
db := models.GetDbSession()
board_id_str := mux.Vars(r)["id"]
board_id, _ := strconv.Atoi(board_id_str)
err, board := models.GetBoard(board_id)
if err != nil {
http.NotFound(w, r)
return
}
current_user := utils.GetCurrentUser(r)
if current_user == nil {
http.NotFound(w, r)
return
}
if r.Method == "POST" {
title := r.FormValue("title")
content := r.FormValue("content")
post := models.NewPost(current_user, board, title, content)
post.LatestReply = time.Now()
db.Insert(post)
http.Redirect(w, r, fmt.Sprintf("/board/%d/%d", board.Id, post.Id), http.StatusFound)
return
}
utils.RenderTemplate(w, r, "new_thread.html", map[string]interface{}{
"board": board,
})
}
func Thread(w http.ResponseWriter, r *http.Request) {
page_id_str := r.FormValue("page")
page_id, err := strconv.Atoi(page_id_str)
if err != nil {
page_id = 0
}
board_id_str := mux.Vars(r)["board_id"]
board_id, _ := strconv.Atoi(board_id_str)
err, board := models.GetBoard(board_id)
post_id_str := mux.Vars(r)["post_id"]
post_id, _ := strconv.Atoi(post_id_str)
err, op, posts := models.GetThread(post_id, page_id)
if r.Method == "POST" {
db := models.GetDbSession()
title := r.FormValue("title")
content := r.FormValue("content")
current_user := utils.GetCurrentUser(r)
if current_user == nil {
http.NotFound(w, r)
return
}
post := models.NewPost(current_user, board, title, content)
post.ParentId = sql.NullInt64{int64(post_id), true}
op.LatestReply = time.Now()
db.Insert(post)
db.Update(op)
err, op, posts = models.GetThread(post_id, page_id)
}
if err != nil {
http.NotFound(w, r)
return
}
num_pages := op.GetPagesInThread()
utils.RenderTemplate(w, r, "thread.html", map[string]interface{}{
"board": board,
"op": op,
"posts": posts,
"prev_page": (page_id != 0),
"next_page": (page_id < num_pages),
"page_id": page_id,
})
}
func PostEditor(w http.ResponseWriter, r *http.Request) {
db := models.GetDbSession()
var err error
var board *models.Board
var post *models.Post
// Attempt to get a board
board_id_str := mux.Vars(r)["board_id"]
if board_id_str != "" {
board_id, _ := strconv.Atoi(board_id_str)
board, err = models.GetBoard(board_id)
}
// Otherwise, a post
post_id_str := r.FormValue("post_id")
if post_id_str != "" {
post_id, _ := strconv.Atoi(post_id_str)
post_tmp, _ := db.Get(&models.Post{}, post_id)
post = post_tmp.(*models.Post)
}
if err != nil {
fmt.Println("something went wrong")
http.NotFound(w, r)
return
}
current_user := utils.GetCurrentUser(r)
if current_user == nil {
http.NotFound(w, r)
return
}
if post != nil && (post.AuthorId != current_user.Id && !current_user.CanModerate()) {
http.NotFound(w, r)
return
}
if r.Method == "POST" {
title := r.FormValue("title")
content := r.FormValue("content")
if post == nil {
post = models.NewPost(current_user, board, title, content)
post.LatestReply = time.Now()
err = post.Validate()
if err != nil {
renderPostEditor(w, r, board, post, err)
return
}
err = db.Insert(post)
} else {
post.Title = title
post.Content = content
post.LastEdit = time.Now()
post.LatestReply = time.Now()
err = post.Validate()
if err != nil {
renderPostEditor(w, r, board, post, err)
return
}
_, err = db.Update(post)
}
if err != nil {
fmt.Printf("[error] Could not save post (%s)", err.Error())
return
}
http.Redirect(w, r, post.GetLink(), http.StatusFound)
return
}
renderPostEditor(w, r, board, post, err)
}
func Thread(w http.ResponseWriter, r *http.Request) {
page_id_str := r.FormValue("page")
page_id, err := strconv.Atoi(page_id_str)
if err != nil {
page_id = 0
}
board_id_str := mux.Vars(r)["board_id"]
board_id, _ := strconv.Atoi(board_id_str)
board, err := models.GetBoard(board_id)
post_id_str := mux.Vars(r)["post_id"]
post_id, _ := strconv.Atoi(post_id_str)
err, op, posts := models.GetThread(post_id, page_id)
var posting_error error
current_user := utils.GetCurrentUser(r)
if r.Method == "POST" {
db := models.GetDbSession()
title := r.FormValue("title")
content := r.FormValue("content")
if current_user == nil {
http.NotFound(w, r)
return
}
if op.Locked && !current_user.CanModerate() {
http.NotFound(w, r)
return
}
post := models.NewPost(current_user, board, title, content)
post.ParentId = sql.NullInt64{int64(post_id), true}
op.LatestReply = time.Now()
posting_error = post.Validate()
if posting_error == nil {
db.Insert(post)
db.Update(op)
if page := post.GetPageInThread(); page != page_id {
http.Redirect(w, r, fmt.Sprintf("/board/%d/%d?page=%d#post_%d", post.BoardId, op.Id, page, post.Id), http.StatusFound)
}
err, op, posts = models.GetThread(post_id, page_id)
}
}
if err != nil {
http.NotFound(w, r)
fmt.Printf("[error] Something went wrong in posts (%s)\n", err.Error())
return
}
num_pages := op.GetPagesInThread()
if page_id > num_pages {
http.NotFound(w, r)
return
}
var previous_text string
if posting_error != nil {
previous_text = r.FormValue("content")
}
// Mark the thread as read
if current_user != nil {
models.AddView(current_user, op)
}
utils.RenderTemplate(w, r, "thread.html", map[string]interface{}{
"board": board,
"op": op,
"posts": posts,
"first_page": (page_id > 0),
"prev_page": (page_id > 1),
"next_page": (page_id < num_pages-1),
"last_page": (page_id < num_pages),
"page_id": page_id,
"posting_error": posting_error,
"previous_text": previous_text,
}, map[string]interface{}{
"CurrentUserCanModerateThread": func(thread *models.Post) bool {
current_user := utils.GetCurrentUser(r)
if current_user == nil {
return false
}
return (current_user.CanModerate() && thread.ParentId.Valid == false)
},
"CurrentUserCanDeletePost": func(thread *models.Post) bool {
current_user := utils.GetCurrentUser(r)
if current_user == nil {
return false
}
return (current_user.Id == thread.AuthorId) || current_user.CanModerate()
},
"CurrentUserCanEditPost": func(post *models.Post) bool {
current_user := utils.GetCurrentUser(r)
if current_user == nil {
return false
}
return (current_user.Id == post.AuthorId || current_user.CanModerate())
},
"CurrentUserCanModerate": func() bool {
current_user := utils.GetCurrentUser(r)
if current_user == nil {
return false
}
return current_user.CanModerate()
},
"SignaturesEnabled": func() bool {
enable_signatures, _ := config.Config.GetBool("gobb", "enable_signatures")
return enable_signatures
},
"ShowReplyBox": func(post *models.Post) bool {
current_user := utils.GetCurrentUser(r)
if current_user != nil && (!post.Locked || current_user.CanModerate()) {
return true
}
return false
},
})
}