Albirew/nyaa-pantsu
Archivé
1
0
Bifurcation 0
Ce dépôt a été archivé le 2022-05-07. Vous pouvez voir ses fichiers ou le cloner, mais pas ouvrir de ticket ou de demandes d'ajout, ni soumettre de changements.
nyaa-pantsu/router/api_handler.go

241 lignes
6 Kio
Go
Brut Vue normale Historique

package router
2017-05-08 11:18:49 +02:00
import (
"encoding/json"
"fmt"
"html"
2017-05-08 11:18:49 +02:00
"net/http"
"strconv"
2017-05-11 05:04:11 +02:00
"strings"
2017-05-08 11:18:49 +02:00
"time"
2017-05-17 07:58:40 +02:00
"github.com/NyaaPantsu/nyaa/config"
"github.com/NyaaPantsu/nyaa/db"
"github.com/NyaaPantsu/nyaa/model"
"github.com/NyaaPantsu/nyaa/service"
"github.com/NyaaPantsu/nyaa/service/api"
"github.com/NyaaPantsu/nyaa/service/upload"
2017-05-17 07:58:40 +02:00
"github.com/NyaaPantsu/nyaa/service/torrent"
"github.com/NyaaPantsu/nyaa/util"
"github.com/NyaaPantsu/nyaa/util/log"
2017-05-08 11:18:49 +02:00
"github.com/gorilla/mux"
)
func ApiHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
page := vars["page"]
2017-05-10 20:42:20 +02:00
whereParams := serviceBase.WhereParams{}
2017-05-09 18:54:12 +02:00
req := apiService.TorrentsRequest{}
2017-05-09 17:09:45 +02:00
contentType := r.Header.Get("Content-Type")
if contentType == "application/json" {
d := json.NewDecoder(r.Body)
2017-05-09 18:37:40 +02:00
if err := d.Decode(&req); err != nil {
2017-05-09 17:09:45 +02:00
util.SendError(w, err, 502)
}
2017-05-09 18:54:12 +02:00
if req.MaxPerPage == 0 {
req.MaxPerPage = config.TorrentsPerPage
2017-05-09 18:54:12 +02:00
}
if req.Page <= 0 {
2017-05-09 18:54:12 +02:00
req.Page = 1
}
2017-05-09 18:37:40 +02:00
whereParams = req.ToParams()
2017-05-09 18:54:12 +02:00
} else {
var err error
maxString := r.URL.Query().Get("max")
if maxString != "" {
req.MaxPerPage, err = strconv.Atoi(maxString)
if !log.CheckError(err) {
req.MaxPerPage = config.TorrentsPerPage
}
} else {
req.MaxPerPage = config.TorrentsPerPage
}
req.Page = 1
if page != "" {
req.Page, err = strconv.Atoi(html.EscapeString(page))
if !log.CheckError(err) {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if req.Page <= 0 {
NotFoundHandler(w, r)
return
}
2017-05-09 18:54:12 +02:00
}
2017-05-09 17:09:45 +02:00
}
2017-05-09 18:54:12 +02:00
torrents, nbTorrents, err := torrentService.GetTorrents(whereParams, req.MaxPerPage, req.MaxPerPage*(req.Page-1))
if err != nil {
util.SendError(w, err, 400)
return
}
2017-05-08 11:18:49 +02:00
b := model.ApiResultJSON{
2017-05-09 01:56:57 +02:00
Torrents: model.TorrentsToJSON(torrents),
}
2017-05-09 18:54:12 +02:00
b.QueryRecordCount = req.MaxPerPage
b.TotalRecordCount = nbTorrents
w.Header().Set("Content-Type", "application/json")
err = json.NewEncoder(w).Encode(b)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func ApiViewHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
id := vars["id"]
torrent, err := torrentService.GetTorrentById(id)
b := torrent.ToJSON()
w.Header().Set("Content-Type", "application/json")
err = json.NewEncoder(w).Encode(b)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
2017-05-08 11:18:49 +02:00
func ApiUploadHandler(w http.ResponseWriter, r *http.Request) {
2017-05-18 15:37:44 +02:00
token := r.Header.Get("Authorization")
2017-05-18 14:27:13 +02:00
user := model.User{}
2017-05-18 15:37:44 +02:00
db.ORM.Where("api_token = ?", token).First(&user) //i don't like this
if !uploadService.IsUploadEnabled(user) {
http.Error(w, "Error uploads are disabled", http.StatusBadRequest)
return
2017-05-08 11:18:49 +02:00
}
2017-05-11 05:04:11 +02:00
if user.ID == 0 {
2017-05-11 06:12:54 +02:00
http.Error(w, apiService.ErrApiKey.Error(), http.StatusUnauthorized)
2017-05-11 05:04:11 +02:00
return
}
upload := apiService.TorrentRequest{}
var filesize int64
2017-05-09 20:54:50 +02:00
contentType := r.Header.Get("Content-Type")
2017-05-09 19:37:39 +02:00
if contentType == "application/json" {
defer r.Body.Close()
2017-05-08 11:18:49 +02:00
2017-05-09 19:37:39 +02:00
d := json.NewDecoder(r.Body)
if err := d.Decode(&upload); err != nil {
decodeError := fmt.Errorf("Unable to decode upload data: %s", err).Error()
http.Error(w, decodeError, http.StatusInternalServerError)
2017-05-09 19:37:39 +02:00
return
}
2017-05-09 20:54:50 +02:00
err, code := upload.ValidateUpload()
2017-05-09 19:37:39 +02:00
if err != nil {
2017-05-09 19:58:35 +02:00
http.Error(w, err.Error(), code)
2017-05-09 19:37:39 +02:00
return
}
2017-05-11 05:04:11 +02:00
} else if strings.HasPrefix(contentType, "multipart/form-data") {
upload.Name = r.FormValue("name")
upload.Category, _ = strconv.Atoi(r.FormValue("category"))
upload.SubCategory, _ = strconv.Atoi(r.FormValue("sub_category"))
upload.Description = r.FormValue("description")
var err error
var code int
2017-05-09 19:37:39 +02:00
2017-05-11 05:04:11 +02:00
filesize, err, code = upload.ValidateMultipartUpload(r)
2017-05-09 23:21:15 +02:00
if err != nil {
2017-05-11 05:04:11 +02:00
http.Error(w, err.Error(), code)
2017-05-09 23:21:15 +02:00
return
}
} else {
// TODO What should we do here ? upload is empty so we shouldn't
// create a torrent from it
err := fmt.Errorf("Please provide either of Content-Type: application/json header or multipart/form-data").Error()
http.Error(w, err, http.StatusInternalServerError)
2017-05-09 19:37:39 +02:00
}
2017-05-11 05:25:41 +02:00
var sameTorrents int
2017-05-11 05:25:41 +02:00
db.ORM.Model(&model.Torrent{}).Where("torrent_hash = ?", upload.Hash).Count(&sameTorrents)
if sameTorrents == 0 {
torrent := model.Torrent{
Name: upload.Name,
Category: upload.Category,
SubCategory: upload.SubCategory,
Status: 1,
Hash: upload.Hash,
Date: time.Now(),
Filesize: filesize,
Description: upload.Description,
UploaderID: user.ID,
Uploader: &user,
}
db.ORM.Create(&torrent)
/*if err != nil {
util.SendError(w, err, 500)
return
}*/
fmt.Printf("%+v\n", torrent)
} else {
http.Error(w, "torrent already exists", http.StatusBadRequest)
2017-05-11 05:04:11 +02:00
return
2017-05-11 05:25:41 +02:00
}
2017-05-08 11:18:49 +02:00
}
2017-05-09 19:37:39 +02:00
// FIXME Impossible to update a torrent uploaded by user 0
2017-05-09 19:58:35 +02:00
func ApiUpdateHandler(w http.ResponseWriter, r *http.Request) {
2017-05-18 15:37:44 +02:00
token := r.Header.Get("Authorization")
2017-05-18 14:27:13 +02:00
user := model.User{}
2017-05-18 15:37:44 +02:00
db.ORM.Where("api_token = ?", token).First(&user) //i don't like this
if !uploadService.IsUploadEnabled(user) {
http.Error(w, "Error uploads are disabled", http.StatusBadRequest)
return
2017-05-09 20:54:50 +02:00
}
contentType := r.Header.Get("Content-Type")
if contentType == "application/json" {
if user.ID == 0 {
2017-05-09 22:24:32 +02:00
http.Error(w, apiService.ErrApiKey.Error(), http.StatusForbidden)
2017-05-09 20:54:50 +02:00
return
}
defer r.Body.Close()
update := apiService.UpdateRequest{}
d := json.NewDecoder(r.Body)
if err := d.Decode(&update); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
id := update.ID
torrent := model.Torrent{}
2017-05-09 20:54:50 +02:00
db.ORM.Where("torrent_id = ?", id).First(&torrent)
if torrent.ID == 0 {
2017-05-09 22:24:32 +02:00
http.Error(w, apiService.ErrTorrentId.Error(), http.StatusBadRequest)
2017-05-09 20:54:50 +02:00
return
}
if torrent.UploaderID != 0 && torrent.UploaderID != user.ID { //&& user.Status != mod
2017-05-09 22:24:32 +02:00
http.Error(w, apiService.ErrRights.Error(), http.StatusForbidden)
2017-05-09 20:54:50 +02:00
return
}
2017-05-09 22:24:32 +02:00
2017-05-09 20:54:50 +02:00
err, code := update.Update.ValidateUpdate()
if err != nil {
http.Error(w, err.Error(), code)
return
}
update.UpdateTorrent(&torrent)
2017-05-09 19:58:35 +02:00
2017-05-09 20:54:50 +02:00
db.ORM.Save(&torrent)
2017-05-09 23:21:15 +02:00
if err != nil {
util.SendError(w, err, 500)
return
}
2017-05-09 20:54:50 +02:00
fmt.Printf("%+v\n", torrent)
}
2017-05-09 19:58:35 +02:00
}