github.com/predbdotovh/pre-api@v0.0.0-20211230223408-096f265fde6a/handlers.go (about)

     1  package main
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"fmt"
     7  	"log"
     8  	"net/http"
     9  	"net/url"
    10  	"strconv"
    11  	"time"
    12  
    13  	"github.com/gorilla/feeds"
    14  	"github.com/gorilla/mux"
    15  )
    16  
    17  const defaultOffset = 0
    18  const defaultCount = 20
    19  const maxCount = 100
    20  
    21  func pagination(query url.Values) (int, int, error) {
    22  	var err error
    23  	count := defaultCount
    24  	offset := defaultOffset
    25  
    26  	countStr := query.Get("count")
    27  	if countStr != "" {
    28  		count, err = strconv.Atoi(countStr)
    29  		if err != nil {
    30  			return 0, 0, fmt.Errorf("incorrect parameters (count)")
    31  		}
    32  
    33  	}
    34  	if count > maxCount {
    35  		count = maxCount
    36  	}
    37  	if count < 0 {
    38  		count = defaultCount
    39  	}
    40  
    41  	pageStr := query.Get("page")
    42  	if pageStr != "" {
    43  		page, err := strconv.Atoi(pageStr)
    44  		if err != nil {
    45  			return 0, 0, fmt.Errorf("incorrect parameters (page)")
    46  		}
    47  
    48  		offset = (page - 1) * count
    49  	}
    50  
    51  	offsetStr := query.Get("offset")
    52  	if offsetStr != "" {
    53  		offset, err = strconv.Atoi(offsetStr)
    54  		if err != nil {
    55  			return 0, 0, fmt.Errorf("incorrect parameters (offset)")
    56  		}
    57  	}
    58  	if offset < 0 {
    59  		offset = defaultOffset
    60  	}
    61  
    62  	return offset, count, nil
    63  }
    64  
    65  func handleQuery(r *http.Request) (*apiRowData, error) {
    66  	t := time.Now()
    67  
    68  	query := r.URL.Query()
    69  	idStr := query.Get("id")
    70  	q := query.Get("q")
    71  
    72  	offset, count, err := pagination(query)
    73  	if err != nil {
    74  		return nil, err
    75  	}
    76  
    77  	tx, err := sphinx.Begin()
    78  	if err != nil {
    79  		return nil, err
    80  	}
    81  	defer tx.Commit()
    82  
    83  	rows := make([]preRow, 0)
    84  	if idStr != "" {
    85  		id, err := strconv.Atoi(idStr)
    86  		if err != nil {
    87  			return nil, err
    88  		}
    89  		rows, err = getPresById(tx, id, true)
    90  	} else if q == "" {
    91  		rows, err = latestPres(tx, offset, count, true)
    92  	} else {
    93  		rows, err = searchPres(tx, q, offset, count, true)
    94  	}
    95  	if err != nil {
    96  		return nil, err
    97  	}
    98  
    99  	meta, err := sphinxMeta(tx)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  
   104  	total, err := strconv.Atoi(meta["total_found"])
   105  	if err != nil {
   106  		return nil, err
   107  	}
   108  
   109  	data := &apiRowData{
   110  		RowCount: len(rows),
   111  		Rows:     rows,
   112  		Offset:   offset,
   113  		ReqCount: count,
   114  		Total:    total,
   115  		Time:     time.Since(t).Seconds(),
   116  	}
   117  
   118  	return data, nil
   119  }
   120  
   121  func rootHandlerV1(w http.ResponseWriter, r *http.Request) {
   122  	data, err := handleQuery(r)
   123  	if err != nil {
   124  		err = apiErr(w, err)
   125  		if err != nil {
   126  			log.Println(err)
   127  		}
   128  		return
   129  	}
   130  
   131  	w.Header().Set("Cache-Control", "public, max-age=60")
   132  	err = apiSuccess(w, data)
   133  	if err != nil {
   134  		log.Println(err)
   135  	}
   136  }
   137  
   138  func teamsHandlerV1(w http.ResponseWriter, _ *http.Request) {
   139  	t := time.Now()
   140  
   141  	tx, err := sphinx.Begin()
   142  	if err != nil {
   143  		err = apiErr(w, err)
   144  		if err != nil {
   145  			log.Println(err)
   146  		}
   147  		return
   148  	}
   149  	defer tx.Commit()
   150  
   151  	rows, err := listTeams(tx)
   152  	if err != nil {
   153  		err = apiErr(w, err)
   154  		if err != nil {
   155  			log.Println(err)
   156  		}
   157  
   158  		return
   159  	}
   160  
   161  	data := &apiTeamsData{
   162  		RowCount: len(rows),
   163  		Rows:     rows,
   164  		Offset:   0,
   165  		ReqCount: maxListedTeams,
   166  		Total:    len(rows),
   167  		Time:     time.Since(t).Seconds(),
   168  	}
   169  
   170  	w.Header().Set("Cache-Control", "public, max-age=3600")
   171  	err = apiSuccess(w, data)
   172  	if err != nil {
   173  		log.Println(err)
   174  	}
   175  }
   176  
   177  func liveHandlerV1(w http.ResponseWriter, r *http.Request) {
   178  	data, err := handleQuery(r)
   179  	if err != nil {
   180  		err = apiErr(w, err)
   181  		if err != nil {
   182  			log.Println(err)
   183  		}
   184  		return
   185  	}
   186  
   187  	w.Header().Set("Cache-Control", "no-cache")
   188  	err = apiSuccess(w, data)
   189  	if err != nil {
   190  		log.Println(err)
   191  	}
   192  }
   193  
   194  func websocketHandlerV1(w http.ResponseWriter, r *http.Request) {
   195  	websocketUpgrader(w, r)
   196  }
   197  
   198  func preTriggerHandlerV1(w http.ResponseWriter, r *http.Request) {
   199  	if r.Header.Get("x-forwarded-for") != "" {
   200  		err := apiErr(w, errors.New("not authorized"))
   201  		if err != nil {
   202  			log.Println(err)
   203  		}
   204  		return
   205  	}
   206  
   207  	var p preRow
   208  	err := json.NewDecoder(r.Body).Decode(&p)
   209  	if err != nil {
   210  		err = apiFail(w, err)
   211  		if err != nil {
   212  			log.Println(err)
   213  		}
   214  		return
   215  	}
   216  	defer r.Body.Close()
   217  
   218  	p.proc()
   219  
   220  	backendUpdates <- triggerAction{Action: mux.Vars(r)["action"], Row: &p}
   221  	err = apiSuccess(w, nil)
   222  	if err != nil {
   223  		log.Println(err)
   224  	}
   225  }
   226  
   227  func nukeTriggerHandlerV1(w http.ResponseWriter, r *http.Request) {
   228  	if r.Header.Get("x-forwarded-for") != "" {
   229  		err := apiErr(w, errors.New("not authorized"))
   230  		if err != nil {
   231  			log.Println(err)
   232  		}
   233  		return
   234  	}
   235  
   236  	var n nuke
   237  	err := json.NewDecoder(r.Body).Decode(&n)
   238  	if err != nil {
   239  		err = apiFail(w, err)
   240  		if err != nil {
   241  			log.Println(err)
   242  		}
   243  		return
   244  	}
   245  	defer r.Body.Close()
   246  
   247  	p, err := getPre(sphinx, n.PreID, false)
   248  	if err != nil {
   249  		err = apiFail(w, err)
   250  		if err != nil {
   251  			log.Println(err)
   252  		}
   253  		return
   254  	}
   255  
   256  	p.setNuke(&n)
   257  
   258  	backendUpdates <- triggerAction{Action: n.Type, Row: p}
   259  	err = apiSuccess(w, nil)
   260  	if err != nil {
   261  		log.Println(err)
   262  	}
   263  }
   264  
   265  func statsHandlerV1(w http.ResponseWriter, _ *http.Request) {
   266  	t := time.Now()
   267  
   268  	tx, err := sphinx.Begin()
   269  	if err != nil {
   270  		err = apiErr(w, err)
   271  		if err != nil {
   272  			log.Println(err)
   273  		}
   274  		return
   275  	}
   276  	defer tx.Commit()
   277  
   278  	_, err = latestPres(tx, 0, 0, false)
   279  	if err != nil {
   280  		err = apiErr(w, err)
   281  		if err != nil {
   282  			log.Println(err)
   283  		}
   284  		return
   285  	}
   286  
   287  	meta, err := sphinxMeta(tx)
   288  	if err != nil {
   289  		err = apiErr(w, err)
   290  		if err != nil {
   291  			log.Println(err)
   292  		}
   293  		return
   294  	}
   295  
   296  	total, err := strconv.Atoi(meta["total_found"])
   297  	if err != nil {
   298  		log.Println(err)
   299  	}
   300  
   301  	w.Header().Set("Cache-Control", "public, max-age=60")
   302  	data := apiStatsData{
   303  		Total: total,
   304  		Date:  time.Now(),
   305  		Time:  time.Since(t).Seconds(),
   306  	}
   307  	err = apiSuccess(w, data)
   308  	if err != nil {
   309  		log.Println(err)
   310  	}
   311  }
   312  
   313  func rssHandlerV1(w http.ResponseWriter, r *http.Request) {
   314  	data, err := handleQuery(r)
   315  	if err != nil {
   316  		w.WriteHeader(http.StatusInternalServerError)
   317  		return
   318  	}
   319  
   320  	feed := &feeds.Feed{
   321  		Title:   "PreDB",
   322  		Link:    &feeds.Link{Href: fmt.Sprintf("https://%s/", hostname)},
   323  		Created: time.Now(),
   324  	}
   325  
   326  	for _, row := range data.Rows {
   327  		feed.Items = append(feed.Items, &feeds.Item{
   328  			Title:       row.Name,
   329  			Link:        &feeds.Link{Href: fmt.Sprintf("https://%s/?id=%d", hostname, row.ID)},
   330  			Description: fmt.Sprintf("Cat:%s | Genre:%s | Size:%0.fMB | Files:%d | ID:%d", row.Cat, row.Genre, row.Size, row.Files, row.ID),
   331  			Created:     time.Unix(int64(row.PreAt), 0),
   332  		})
   333  	}
   334  
   335  	rss, err := feed.ToRss()
   336  	if err != nil {
   337  		w.WriteHeader(http.StatusInternalServerError)
   338  		return
   339  	}
   340  
   341  	_, err = w.Write([]byte(rss))
   342  	if err != nil {
   343  		log.Println(err)
   344  	}
   345  }