281 lignes
8.6 KiB
Go
281 lignes
8.6 KiB
Go
package controllers
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"os"
|
|
|
|
"github.com/NyaaPantsu/nyaa/config"
|
|
"github.com/NyaaPantsu/nyaa/models"
|
|
"github.com/NyaaPantsu/nyaa/models/activities"
|
|
"github.com/NyaaPantsu/nyaa/models/notifications"
|
|
"github.com/NyaaPantsu/nyaa/models/reports"
|
|
"github.com/NyaaPantsu/nyaa/models/torrents"
|
|
"github.com/NyaaPantsu/nyaa/service/api"
|
|
"github.com/NyaaPantsu/nyaa/utils"
|
|
"github.com/NyaaPantsu/nyaa/utils/captcha"
|
|
"github.com/NyaaPantsu/nyaa/utils/cookies"
|
|
"github.com/NyaaPantsu/nyaa/utils/filelist"
|
|
msg "github.com/NyaaPantsu/nyaa/utils/messages"
|
|
"github.com/NyaaPantsu/nyaa/utils/publicSettings"
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
// ViewHandler : Controller for displaying a torrent
|
|
func ViewHandler(c *gin.Context) {
|
|
id := c.Param("id")
|
|
messages := msg.GetMessages(c)
|
|
user := getUser(c)
|
|
|
|
if c.Request.URL.Query()["success"] != nil {
|
|
messages.AddInfo("infos", "Torrent uploaded successfully!")
|
|
}
|
|
|
|
torrent, err := torrentService.GetTorrentByID(id)
|
|
|
|
if c.Request.URL.Query()["notif"] != nil {
|
|
notifierService.ToggleReadNotification(torrent.Identifier(), user.ID)
|
|
}
|
|
|
|
if err != nil {
|
|
NotFoundHandler(c)
|
|
return
|
|
}
|
|
b := torrent.ToJSON()
|
|
folder := filelist.FileListToFolder(torrent.FileList, "root")
|
|
captchaID := ""
|
|
if userPermission.NeedsCaptcha(user) {
|
|
captchaID = captcha.GetID()
|
|
}
|
|
torrentTemplate(c, b, folder, captchaID)
|
|
}
|
|
|
|
// ViewHeadHandler : Controller for checking a torrent
|
|
func ViewHeadHandler(c *gin.Context) {
|
|
id, err := strconv.ParseInt(c.Param("id"), 10, 32)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
_, err = torrentService.GetRawTorrentByID(uint(id))
|
|
|
|
if err != nil {
|
|
NotFoundHandler(c)
|
|
return
|
|
}
|
|
|
|
c.AbortWithStatus(http.StatusOK)
|
|
}
|
|
|
|
// PostCommentHandler : Controller for posting a comment
|
|
func PostCommentHandler(c *gin.Context) {
|
|
id := c.Param("id")
|
|
|
|
torrent, err := torrentService.GetTorrentByID(id)
|
|
if err != nil {
|
|
NotFoundHandler(c)
|
|
return
|
|
}
|
|
|
|
currentUser := getUser(c)
|
|
messages := msg.GetMessages(c)
|
|
|
|
if userPermission.NeedsCaptcha(currentUser) {
|
|
userCaptcha := captcha.Extract(c)
|
|
if !captcha.Authenticate(userCaptcha) {
|
|
messages.AddErrorT("errors", "bad_captcha")
|
|
}
|
|
}
|
|
content := util.Sanitize(c.PostForm("comment"), "comment")
|
|
|
|
if strings.TrimSpace(content) == "" {
|
|
messages.AddErrorT("errors", "comment_empty")
|
|
}
|
|
if len(content) > config.Conf.CommentLength {
|
|
messages.AddErrorT("errors", "comment_toolong")
|
|
}
|
|
if !messages.HasErrors() {
|
|
userID := currentUser.ID
|
|
|
|
comment := models.Comment{TorrentID: torrent.ID, UserID: userID, Content: content, CreatedAt: time.Now()}
|
|
err := db.ORM.Create(&comment).Error
|
|
if err != nil {
|
|
messages.Error(err)
|
|
}
|
|
comment.Torrent = &torrent
|
|
|
|
url := "/view/" + strconv.FormatUint(uint64(torrent.ID), 10)
|
|
torrent.Uploader.ParseSettings()
|
|
if torrent.Uploader.Settings.Get("new_comment") {
|
|
T, _, _ := publicSettings.TfuncAndLanguageWithFallback(torrent.Uploader.Language, torrent.Uploader.Language) // We need to send the notification to every user in their language
|
|
notifierService.NotifyUser(torrent.Uploader, comment.Identifier(), fmt.Sprintf(T("new_comment_on_torrent"), torrent.Name), url, torrent.Uploader.Settings.Get("new_comment_email"))
|
|
}
|
|
|
|
if err != nil {
|
|
messages.Error(err)
|
|
}
|
|
}
|
|
ViewHandler(c)
|
|
}
|
|
|
|
// ReportTorrentHandler : Controller for sending a torrent report
|
|
func ReportTorrentHandler(c *gin.Context) {
|
|
id := c.Param("id")
|
|
messages := msg.GetMessages(c)
|
|
currentUser := getUser(c)
|
|
if userPermission.NeedsCaptcha(currentUser) {
|
|
userCaptcha := captcha.Extract(c)
|
|
if !captcha.Authenticate(userCaptcha) {
|
|
messages.AddErrorT("errors", "bad_captcha")
|
|
}
|
|
}
|
|
if !messages.HasErrors() {
|
|
idNum, _ := strconv.Atoi(id)
|
|
userID := currentUser.ID
|
|
|
|
report := models.TorrentReport{
|
|
Description: c.PostForm("report_type"),
|
|
TorrentID: uint(idNum),
|
|
UserID: userID,
|
|
CreatedAt: time.Now(),
|
|
}
|
|
|
|
err := db.ORM.Create(&report).Error
|
|
messages.AddInfoTf("infos", "report_msg", id)
|
|
if err != nil {
|
|
messages.ImportFromError("errors", err)
|
|
}
|
|
}
|
|
ViewHandler(c)
|
|
}
|
|
|
|
// TorrentEditUserPanel : Controller for editing a user torrent by a user, after GET request
|
|
func TorrentEditUserPanel(c *gin.Context) {
|
|
id := c.Query("id")
|
|
torrent, _ := torrentService.GetTorrentByID(id)
|
|
currentUser := getUser(c)
|
|
if userPermission.CurrentOrAdmin(currentUser, torrent.UploaderID) {
|
|
uploadForm := apiService.NewTorrentRequest()
|
|
uploadForm.Name = torrent.Name
|
|
uploadForm.Category = strconv.Itoa(torrent.Category) + "_" + strconv.Itoa(torrent.SubCategory)
|
|
uploadForm.Remake = torrent.Status == models.TorrentStatusRemake
|
|
uploadForm.WebsiteLink = string(torrent.WebsiteLink)
|
|
uploadForm.Description = string(torrent.Description)
|
|
uploadForm.Hidden = torrent.Hidden
|
|
uploadForm.Language = torrent.Language
|
|
formTemplate(c, "site/torrents/edit.jet.html", uploadForm)
|
|
} else {
|
|
NotFoundHandler(c)
|
|
}
|
|
}
|
|
|
|
// TorrentPostEditUserPanel : Controller for editing a user torrent by a user, after post request
|
|
func TorrentPostEditUserPanel(c *gin.Context) {
|
|
var uploadForm apiService.TorrentRequest
|
|
id := c.Query("id")
|
|
messages := msg.GetMessages(c)
|
|
torrent, _ := torrentService.GetTorrentByID(id)
|
|
currentUser := getUser(c)
|
|
if torrent.ID > 0 && userPermission.CurrentOrAdmin(currentUser, torrent.UploaderID) {
|
|
errUp := uploadForm.ExtractEditInfo(c)
|
|
if errUp != nil {
|
|
messages.AddErrorT("errors", "fail_torrent_update")
|
|
}
|
|
if !messages.HasErrors() {
|
|
status := models.TorrentStatusNormal
|
|
if uploadForm.Remake { // overrides trusted
|
|
status = models.TorrentStatusRemake
|
|
} else if currentUser.IsTrusted() {
|
|
status = models.TorrentStatusTrusted
|
|
}
|
|
// update some (but not all!) values
|
|
torrent.Name = uploadForm.Name
|
|
torrent.Category = uploadForm.CategoryID
|
|
torrent.SubCategory = uploadForm.SubCategoryID
|
|
torrent.Status = status
|
|
torrent.Hidden = uploadForm.Hidden
|
|
torrent.WebsiteLink = uploadForm.WebsiteLink
|
|
torrent.Description = uploadForm.Description
|
|
torrent.Language = uploadForm.Language
|
|
db.ORM.Model(&torrent).UpdateColumn(&torrent)
|
|
messages.AddInfoT("infos", "torrent_updated")
|
|
}
|
|
formTemplate(c, "site/torrents/edit.jet.html", uploadForm)
|
|
} else {
|
|
NotFoundHandler(c)
|
|
}
|
|
}
|
|
|
|
// TorrentDeleteUserPanel : Controller for deleting a user torrent by a user
|
|
func TorrentDeleteUserPanel(c *gin.Context) {
|
|
id := c.Query("id")
|
|
currentUser := getUser(c)
|
|
torrent, _ := torrentService.GetTorrentByID(id)
|
|
if userPermission.CurrentOrAdmin(currentUser, torrent.UploaderID) {
|
|
_, _, err := torrentService.DeleteTorrent(id)
|
|
if err == nil {
|
|
_, username := torrentService.HideTorrentUser(torrent.UploaderID, torrent.Uploader.Username, torrent.Hidden)
|
|
if userPermission.HasAdmin(currentUser) { // We hide username on log activity if user is not admin and torrent is hidden
|
|
activity.Log(&models.User{}, torrent.Identifier(), "delete", "torrent_deleted_by", strconv.Itoa(int(torrent.ID)), username, currentUser.Username)
|
|
} else {
|
|
activity.Log(&models.User{}, torrent.Identifier(), "delete", "torrent_deleted_by", strconv.Itoa(int(torrent.ID)), username, username)
|
|
}
|
|
//delete reports of torrent
|
|
whereParams := serviceBase.CreateWhereParams("torrent_id = ?", id)
|
|
reports, _, _ := reportService.GetTorrentReportsOrderBy(&whereParams, "", 0, 0)
|
|
for _, report := range reports {
|
|
reportService.DeleteTorrentReport(report.ID)
|
|
}
|
|
}
|
|
c.Redirect(http.StatusSeeOther, "/?deleted")
|
|
} else {
|
|
NotFoundHandler(c)
|
|
}
|
|
}
|
|
|
|
// DownloadTorrent : Controller for downloading a torrent
|
|
func DownloadTorrent(c *gin.Context) {
|
|
hash := c.Param("hash")
|
|
|
|
if hash == "" && len(config.Conf.Torrents.FileStorage) == 0 {
|
|
//File not found, send 404
|
|
c.AbortWithError(http.StatusNotFound, errors.New("File not found"))
|
|
return
|
|
}
|
|
|
|
//Check if file exists and open
|
|
Openfile, err := os.Open(fmt.Sprintf("%s%c%s.torrent", config.Conf.Torrents.FileStorage, os.PathSeparator, hash))
|
|
if err != nil {
|
|
//File not found, send 404
|
|
c.AbortWithError(http.StatusNotFound, errors.New("File not found"))
|
|
return
|
|
}
|
|
defer Openfile.Close() //Close after function return
|
|
|
|
//Get the file size
|
|
FileStat, _ := Openfile.Stat() //Get info from file
|
|
FileSize := strconv.FormatInt(FileStat.Size(), 10) //Get file size as a string
|
|
|
|
torrent, err := torrentService.GetRawTorrentByHash(hash)
|
|
|
|
if err != nil {
|
|
//File not found, send 404
|
|
c.AbortWithError(http.StatusNotFound, errors.New("File not found"))
|
|
return
|
|
}
|
|
|
|
c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s.torrent\"", torrent.Name))
|
|
c.Header("Content-Type", "application/x-bittorrent")
|
|
c.Header("Content-Length", FileSize)
|
|
//Send the file
|
|
// We reset the offset to 0
|
|
Openfile.Seek(0, 0)
|
|
io.Copy(c.Writer, Openfile) //'Copy' the file to the client
|
|
}
|