oss/miniflux-v2
oss/miniflux-v2
1
0
Fork 0
mirror of https://github.com/miniflux/v2.git synced 2025-06-27 16:36:00 +00:00
Code Wiki Activity

Move API middleware and routes to api package

Browse source
This commit is contained in:
Frédéric Guillot 2018-11-11 10:22:47 -08:00
parent a9f98adb07
commit 0925899cee
12 changed files with 132 additions and 139 deletions
Download patch file Download diff file Expand all files Collapse all files

47
api/api.go Normal file
View file

@ -0,0 +1,47 @@
// Copyright 2018 Frédéric Guillot. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package api // import "miniflux.app/api"
import (
"miniflux.app/reader/feed"
"miniflux.app/storage"
"github.com/gorilla/mux"
)
// Serve declares API routes for the application.
func Serve(router *mux.Router, store *storage.Storage, feedHandler *feed.Handler) {
handler := &handler{store, feedHandler}
sr := router.PathPrefix("/v1").Subrouter()
sr.Use(newMiddleware(store).serve)
sr.HandleFunc("/users", handler.createUser).Methods("POST")
sr.HandleFunc("/users", handler.users).Methods("GET")
sr.HandleFunc("/users/{userID:[0-9]+}", handler.userByID).Methods("GET")
sr.HandleFunc("/users/{userID:[0-9]+}", handler.updateUser).Methods("PUT")
sr.HandleFunc("/users/{userID:[0-9]+}", handler.removeUser).Methods("DELETE")
sr.HandleFunc("/users/{username}", handler.userByUsername).Methods("GET")
sr.HandleFunc("/me", handler.currentUser).Methods("GET")
sr.HandleFunc("/categories", handler.createCategory).Methods("POST")
sr.HandleFunc("/categories", handler.getCategories).Methods("GET")
sr.HandleFunc("/categories/{categoryID}", handler.updateCategory).Methods("PUT")
sr.HandleFunc("/categories/{categoryID}", handler.removeCategory).Methods("DELETE")
sr.HandleFunc("/discover", handler.getSubscriptions).Methods("POST")
sr.HandleFunc("/feeds", handler.createFeed).Methods("POST")
sr.HandleFunc("/feeds", handler.getFeeds).Methods("GET")
sr.HandleFunc("/feeds/{feedID}/refresh", handler.refreshFeed).Methods("PUT")
sr.HandleFunc("/feeds/{feedID}", handler.getFeed).Methods("GET")
sr.HandleFunc("/feeds/{feedID}", handler.updateFeed).Methods("PUT")
sr.HandleFunc("/feeds/{feedID}", handler.removeFeed).Methods("DELETE")
sr.HandleFunc("/feeds/{feedID}/icon", handler.feedIcon).Methods("GET")
sr.HandleFunc("/export", handler.exportFeeds).Methods("GET")
sr.HandleFunc("/import", handler.importFeeds).Methods("POST")
sr.HandleFunc("/feeds/{feedID}/entries", handler.getFeedEntries).Methods("GET")
sr.HandleFunc("/feeds/{feedID}/entries/{entryID}", handler.getFeedEntry).Methods("GET")
sr.HandleFunc("/entries", handler.getEntries).Methods("GET")
sr.HandleFunc("/entries", handler.setEntryStatus).Methods("PUT")
sr.HandleFunc("/entries/{entryID}", handler.getEntry).Methods("GET")
sr.HandleFunc("/entries/{entryID}/bookmark", handler.toggleBookmark).Methods("PUT")
}

24
api/category.go
View file

@ -12,8 +12,7 @@ import (
"miniflux.app/http/response/json" "miniflux.app/http/response/json"
) )
// CreateCategory is the API handler to create a new category. func (h *handler) createCategory(w http.ResponseWriter, r *http.Request) {
func (c *Controller) CreateCategory(w http.ResponseWriter, r *http.Request) {
category, err := decodeCategoryPayload(r.Body) category, err := decodeCategoryPayload(r.Body)
if err != nil { if err != nil {
json.BadRequest(w, r, err) json.BadRequest(w, r, err)
@ -27,12 +26,12 @@ func (c *Controller) CreateCategory(w http.ResponseWriter, r *http.Request) {
return return
} }
if c, err := c.store.CategoryByTitle(userID, category.Title); err != nil || c != nil { if c, err := h.store.CategoryByTitle(userID, category.Title); err != nil || c != nil {
json.BadRequest(w, r, errors.New("This category already exists")) json.BadRequest(w, r, errors.New("This category already exists"))
return return
} }
if err := c.store.CreateCategory(category); err != nil { if err := h.store.CreateCategory(category); err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
} }
@ -40,8 +39,7 @@ func (c *Controller) CreateCategory(w http.ResponseWriter, r *http.Request) {
json.Created(w, r, category) json.Created(w, r, category)
} }
// UpdateCategory is the API handler to update a category. func (h *handler) updateCategory(w http.ResponseWriter, r *http.Request) {
func (c *Controller) UpdateCategory(w http.ResponseWriter, r *http.Request) {
categoryID := request.RouteInt64Param(r, "categoryID") categoryID := request.RouteInt64Param(r, "categoryID")
category, err := decodeCategoryPayload(r.Body) category, err := decodeCategoryPayload(r.Body)
@ -57,7 +55,7 @@ func (c *Controller) UpdateCategory(w http.ResponseWriter, r *http.Request) {
return return
} }
err = c.store.UpdateCategory(category) err = h.store.UpdateCategory(category)
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -66,9 +64,8 @@ func (c *Controller) UpdateCategory(w http.ResponseWriter, r *http.Request) {
json.Created(w, r, category) json.Created(w, r, category)
} }
// GetCategories is the API handler to get a list of categories for a given user. func (h *handler) getCategories(w http.ResponseWriter, r *http.Request) {
func (c *Controller) GetCategories(w http.ResponseWriter, r *http.Request) { categories, err := h.store.Categories(request.UserID(r))
categories, err := c.store.Categories(request.UserID(r))
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -77,17 +74,16 @@ func (c *Controller) GetCategories(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, categories) json.OK(w, r, categories)
} }
// RemoveCategory is the API handler to remove a category. func (h *handler) removeCategory(w http.ResponseWriter, r *http.Request) {
func (c *Controller) RemoveCategory(w http.ResponseWriter, r *http.Request) {
userID := request.UserID(r) userID := request.UserID(r)
categoryID := request.RouteInt64Param(r, "categoryID") categoryID := request.RouteInt64Param(r, "categoryID")
if !c.store.CategoryExists(userID, categoryID) { if !h.store.CategoryExists(userID, categoryID) {
json.NotFound(w, r) json.NotFound(w, r)
return return
} }
if err := c.store.RemoveCategory(userID, categoryID); err != nil { if err := h.store.RemoveCategory(userID, categoryID); err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
} }

2
api/doc.go
View file

@ -4,7 +4,7 @@
/* /*
Package api implements API endpoints for Miniflux application. Package api implements API endpoints for the application.
*/ */
package api // import "miniflux.app/api" package api // import "miniflux.app/api"

30
api/entry.go
View file

@ -15,12 +15,11 @@ import (
"miniflux.app/storage" "miniflux.app/storage"
) )
// GetFeedEntry is the API handler to get a single feed entry. func (h *handler) getFeedEntry(w http.ResponseWriter, r *http.Request) {
func (c *Controller) GetFeedEntry(w http.ResponseWriter, r *http.Request) {
feedID := request.RouteInt64Param(r, "feedID") feedID := request.RouteInt64Param(r, "feedID")
entryID := request.RouteInt64Param(r, "entryID") entryID := request.RouteInt64Param(r, "entryID")
builder := c.store.NewEntryQueryBuilder(request.UserID(r)) builder := h.store.NewEntryQueryBuilder(request.UserID(r))
builder.WithFeedID(feedID) builder.WithFeedID(feedID)
builder.WithEntryID(entryID) builder.WithEntryID(entryID)
@ -38,10 +37,9 @@ func (c *Controller) GetFeedEntry(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, entry) json.OK(w, r, entry)
} }
// GetEntry is the API handler to get a single entry. func (h *handler) getEntry(w http.ResponseWriter, r *http.Request) {
func (c *Controller) GetEntry(w http.ResponseWriter, r *http.Request) {
entryID := request.RouteInt64Param(r, "entryID") entryID := request.RouteInt64Param(r, "entryID")
builder := c.store.NewEntryQueryBuilder(request.UserID(r)) builder := h.store.NewEntryQueryBuilder(request.UserID(r))
builder.WithEntryID(entryID) builder.WithEntryID(entryID)
entry, err := builder.GetEntry() entry, err := builder.GetEntry()
@ -58,8 +56,7 @@ func (c *Controller) GetEntry(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, entry) json.OK(w, r, entry)
} }
// GetFeedEntries is the API handler to get all feed entries. func (h *handler) getFeedEntries(w http.ResponseWriter, r *http.Request) {
func (c *Controller) GetFeedEntries(w http.ResponseWriter, r *http.Request) {
feedID := request.RouteInt64Param(r, "feedID") feedID := request.RouteInt64Param(r, "feedID")
status := request.QueryStringParam(r, "status", "") status := request.QueryStringParam(r, "status", "")
@ -89,7 +86,7 @@ func (c *Controller) GetFeedEntries(w http.ResponseWriter, r *http.Request) {
return return
} }
builder := c.store.NewEntryQueryBuilder(request.UserID(r)) builder := h.store.NewEntryQueryBuilder(request.UserID(r))
builder.WithFeedID(feedID) builder.WithFeedID(feedID)
builder.WithStatus(status) builder.WithStatus(status)
builder.WithOrder(order) builder.WithOrder(order)
@ -113,8 +110,7 @@ func (c *Controller) GetFeedEntries(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, &entriesResponse{Total: count, Entries: entries}) json.OK(w, r, &entriesResponse{Total: count, Entries: entries})
} }
// GetEntries is the API handler to fetch entries. func (h *handler) getEntries(w http.ResponseWriter, r *http.Request) {
func (c *Controller) GetEntries(w http.ResponseWriter, r *http.Request) {
status := request.QueryStringParam(r, "status", "") status := request.QueryStringParam(r, "status", "")
if status != "" { if status != "" {
if err := model.ValidateEntryStatus(status); err != nil { if err := model.ValidateEntryStatus(status); err != nil {
@ -142,7 +138,7 @@ func (c *Controller) GetEntries(w http.ResponseWriter, r *http.Request) {
return return
} }
builder := c.store.NewEntryQueryBuilder(request.UserID(r)) builder := h.store.NewEntryQueryBuilder(request.UserID(r))
builder.WithStatus(status) builder.WithStatus(status)
builder.WithOrder(order) builder.WithOrder(order)
builder.WithDirection(direction) builder.WithDirection(direction)
@ -165,8 +161,7 @@ func (c *Controller) GetEntries(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, &entriesResponse{Total: count, Entries: entries}) json.OK(w, r, &entriesResponse{Total: count, Entries: entries})
} }
// SetEntryStatus is the API handler to change the status of entries. func (h *handler) setEntryStatus(w http.ResponseWriter, r *http.Request) {
func (c *Controller) SetEntryStatus(w http.ResponseWriter, r *http.Request) {
entryIDs, status, err := decodeEntryStatusPayload(r.Body) entryIDs, status, err := decodeEntryStatusPayload(r.Body)
if err != nil { if err != nil {
json.BadRequest(w , r, errors.New("Invalid JSON payload")) json.BadRequest(w , r, errors.New("Invalid JSON payload"))
@ -178,7 +173,7 @@ func (c *Controller) SetEntryStatus(w http.ResponseWriter, r *http.Request) {
return return
} }
if err := c.store.SetEntriesStatus(request.UserID(r), entryIDs, status); err != nil { if err := h.store.SetEntriesStatus(request.UserID(r), entryIDs, status); err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
} }
@ -186,10 +181,9 @@ func (c *Controller) SetEntryStatus(w http.ResponseWriter, r *http.Request) {
json.NoContent(w, r) json.NoContent(w, r)
} }
// ToggleBookmark is the API handler to toggle bookmark status. func (h *handler) toggleBookmark(w http.ResponseWriter, r *http.Request) {
func (c *Controller) ToggleBookmark(w http.ResponseWriter, r *http.Request) {
entryID := request.RouteInt64Param(r, "entryID") entryID := request.RouteInt64Param(r, "entryID")
if err := c.store.ToggleBookmark(request.UserID(r), entryID); err != nil { if err := h.store.ToggleBookmark(request.UserID(r), entryID); err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
} }

44
api/feed.go
View file

@ -12,8 +12,7 @@ import (
"miniflux.app/http/response/json" "miniflux.app/http/response/json"
) )
// CreateFeed is the API handler to create a new feed. func (h *handler) createFeed(w http.ResponseWriter, r *http.Request) {
func (c *Controller) CreateFeed(w http.ResponseWriter, r *http.Request) {
feedInfo, err := decodeFeedCreationPayload(r.Body) feedInfo, err := decodeFeedCreationPayload(r.Body)
if err != nil { if err != nil {
json.BadRequest(w, r, err) json.BadRequest(w, r, err)
@ -32,17 +31,17 @@ func (c *Controller) CreateFeed(w http.ResponseWriter, r *http.Request) {
userID := request.UserID(r) userID := request.UserID(r)
if c.store.FeedURLExists(userID, feedInfo.FeedURL) { if h.store.FeedURLExists(userID, feedInfo.FeedURL) {
json.BadRequest(w, r, errors.New("This feed_url already exists")) json.BadRequest(w, r, errors.New("This feed_url already exists"))
return return
} }
if !c.store.CategoryExists(userID, feedInfo.CategoryID) { if !h.store.CategoryExists(userID, feedInfo.CategoryID) {
json.BadRequest(w, r, errors.New("This category_id doesn't exists or doesn't belongs to this user")) json.BadRequest(w, r, errors.New("This category_id doesn't exists or doesn't belongs to this user"))
return return
} }
feed, err := c.feedHandler.CreateFeed( feed, err := h.feedHandler.CreateFeed(
userID, userID,
feedInfo.CategoryID, feedInfo.CategoryID,
feedInfo.FeedURL, feedInfo.FeedURL,
@ -63,17 +62,16 @@ func (c *Controller) CreateFeed(w http.ResponseWriter, r *http.Request) {
json.Created(w, r, &result{FeedID: feed.ID}) json.Created(w, r, &result{FeedID: feed.ID})
} }
// RefreshFeed is the API handler to refresh a feed. func (h *handler) refreshFeed(w http.ResponseWriter, r *http.Request) {
func (c *Controller) RefreshFeed(w http.ResponseWriter, r *http.Request) {
feedID := request.RouteInt64Param(r, "feedID") feedID := request.RouteInt64Param(r, "feedID")
userID := request.UserID(r) userID := request.UserID(r)
if !c.store.FeedExists(userID, feedID) { if !h.store.FeedExists(userID, feedID) {
json.NotFound(w, r) json.NotFound(w, r)
return return
} }
err := c.feedHandler.RefreshFeed(userID, feedID) err := h.feedHandler.RefreshFeed(userID, feedID)
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -82,8 +80,7 @@ func (c *Controller) RefreshFeed(w http.ResponseWriter, r *http.Request) {
json.NoContent(w, r) json.NoContent(w, r)
} }
// UpdateFeed is the API handler that is used to update a feed. func (h *handler) updateFeed(w http.ResponseWriter, r *http.Request) {
func (c *Controller) UpdateFeed(w http.ResponseWriter, r *http.Request) {
feedID := request.RouteInt64Param(r, "feedID") feedID := request.RouteInt64Param(r, "feedID")
feedChanges, err := decodeFeedModificationPayload(r.Body) feedChanges, err := decodeFeedModificationPayload(r.Body)
if err != nil { if err != nil {
@ -93,7 +90,7 @@ func (c *Controller) UpdateFeed(w http.ResponseWriter, r *http.Request) {
userID := request.UserID(r) userID := request.UserID(r)
originalFeed, err := c.store.FeedByID(userID, feedID) originalFeed, err := h.store.FeedByID(userID, feedID)
if err != nil { if err != nil {
json.NotFound(w, r) json.NotFound(w, r)
return return
@ -106,17 +103,17 @@ func (c *Controller) UpdateFeed(w http.ResponseWriter, r *http.Request) {
feedChanges.Update(originalFeed) feedChanges.Update(originalFeed)
if !c.store.CategoryExists(userID, originalFeed.Category.ID) { if !h.store.CategoryExists(userID, originalFeed.Category.ID) {
json.BadRequest(w, r, errors.New("This category_id doesn't exists or doesn't belongs to this user")) json.BadRequest(w, r, errors.New("This category_id doesn't exists or doesn't belongs to this user"))
return return
} }
if err := c.store.UpdateFeed(originalFeed); err != nil { if err := h.store.UpdateFeed(originalFeed); err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
} }
originalFeed, err = c.store.FeedByID(userID, feedID) originalFeed, err = h.store.FeedByID(userID, feedID)
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -125,9 +122,8 @@ func (c *Controller) UpdateFeed(w http.ResponseWriter, r *http.Request) {
json.Created(w, r, originalFeed) json.Created(w, r, originalFeed)
} }
// GetFeeds is the API handler that get all feeds that belongs to the given user. func (h *handler) getFeeds(w http.ResponseWriter, r *http.Request) {
func (c *Controller) GetFeeds(w http.ResponseWriter, r *http.Request) { feeds, err := h.store.Feeds(request.UserID(r))
feeds, err := c.store.Feeds(request.UserID(r))
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -136,10 +132,9 @@ func (c *Controller) GetFeeds(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, feeds) json.OK(w, r, feeds)
} }
// GetFeed is the API handler to get a feed. func (h *handler) getFeed(w http.ResponseWriter, r *http.Request) {
func (c *Controller) GetFeed(w http.ResponseWriter, r *http.Request) {
feedID := request.RouteInt64Param(r, "feedID") feedID := request.RouteInt64Param(r, "feedID")
feed, err := c.store.FeedByID(request.UserID(r), feedID) feed, err := h.store.FeedByID(request.UserID(r), feedID)
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -153,17 +148,16 @@ func (c *Controller) GetFeed(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, feed) json.OK(w, r, feed)
} }
// RemoveFeed is the API handler to remove a feed. func (h *handler) removeFeed(w http.ResponseWriter, r *http.Request) {
func (c *Controller) RemoveFeed(w http.ResponseWriter, r *http.Request) {
feedID := request.RouteInt64Param(r, "feedID") feedID := request.RouteInt64Param(r, "feedID")
userID := request.UserID(r) userID := request.UserID(r)
if !c.store.FeedExists(userID, feedID) { if !h.store.FeedExists(userID, feedID) {
json.NotFound(w, r) json.NotFound(w, r)
return return
} }
if err := c.store.RemoveFeed(userID, feedID); err != nil { if err := h.store.RemoveFeed(userID, feedID); err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
} }

8
api/controller.go → api/handler.go
View file

@ -9,13 +9,7 @@ import (
"miniflux.app/storage" "miniflux.app/storage"
) )
// Controller holds all handlers for the API. type handler struct {
type Controller struct {
store *storage.Storage store *storage.Storage
feedHandler *feed.Handler feedHandler *feed.Handler
} }
// NewController creates a new controller.
func NewController(store *storage.Storage, feedHandler *feed.Handler) *Controller {
return &Controller{store: store, feedHandler: feedHandler}
}

7
api/icon.go
View file

@ -11,16 +11,15 @@ import (
"miniflux.app/http/response/json" "miniflux.app/http/response/json"
) )
// FeedIcon returns a feed icon. func (h *handler) feedIcon(w http.ResponseWriter, r *http.Request) {
func (c *Controller) FeedIcon(w http.ResponseWriter, r *http.Request) {
feedID := request.RouteInt64Param(r, "feedID") feedID := request.RouteInt64Param(r, "feedID")
if !c.store.HasIcon(feedID) { if !h.store.HasIcon(feedID) {
json.NotFound(w, r) json.NotFound(w, r)
return return
} }
icon, err := c.store.IconByFeedID(request.UserID(r), feedID) icon, err := h.store.IconByFeedID(request.UserID(r), feedID)
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return

23
middleware/basic_auth.go → api/middleware.go
View file

@ -2,7 +2,7 @@
// Use of this source code is governed by the Apache 2.0 // Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
package middleware // import "miniflux.app/middleware" package api // import "miniflux.app/api"
import ( import (
"context" "context"
@ -11,41 +11,50 @@ import (
"miniflux.app/http/request" "miniflux.app/http/request"
"miniflux.app/http/response/json" "miniflux.app/http/response/json"
"miniflux.app/logger" "miniflux.app/logger"
"miniflux.app/storage"
) )
type middleware struct {
store *storage.Storage
}
func newMiddleware(s *storage.Storage) *middleware {
return &middleware{s}
}
// BasicAuth handles HTTP basic authentication. // BasicAuth handles HTTP basic authentication.
func (m *Middleware) BasicAuth(next http.Handler) http.Handler { func (m *middleware) serve(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`) w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
clientIP := request.ClientIP(r) clientIP := request.ClientIP(r)
username, password, authOK := r.BasicAuth() username, password, authOK := r.BasicAuth()
if !authOK { if !authOK {
logger.Debug("[Middleware:BasicAuth] No authentication headers sent") logger.Debug("[API] No authentication headers sent")
json.Unauthorized(w, r) json.Unauthorized(w, r)
return return
} }
if err := m.store.CheckPassword(username, password); err != nil { if err := m.store.CheckPassword(username, password); err != nil {
logger.Error("[Middleware:BasicAuth] [ClientIP=%s] Invalid username or password: %s", clientIP, username) logger.Error("[API] [ClientIP=%s] Invalid username or password: %s", clientIP, username)
json.Unauthorized(w, r) json.Unauthorized(w, r)
return return
} }
user, err := m.store.UserByUsername(username) user, err := m.store.UserByUsername(username)
if err != nil { if err != nil {
logger.Error("[Middleware:BasicAuth] %v", err) logger.Error("[API] %v", err)
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
} }
if user == nil { if user == nil {
logger.Error("[Middleware:BasicAuth] [ClientIP=%s] User not found: %s", clientIP, username) logger.Error("[API] [ClientIP=%s] User not found: %s", clientIP, username)
json.Unauthorized(w, r) json.Unauthorized(w, r)
return return
} }
logger.Info("[Middleware:BasicAuth] User authenticated: %s", username) logger.Info("[API] User authenticated: %s", username)
m.store.SetLastLogin(user.ID) m.store.SetLastLogin(user.ID)
ctx := r.Context() ctx := r.Context()

10
api/opml.go
View file

@ -13,9 +13,8 @@ import (
"miniflux.app/reader/opml" "miniflux.app/reader/opml"
) )
// Export is the API handler that export feeds to OPML. func (h *handler) exportFeeds(w http.ResponseWriter, r *http.Request) {
func (c *Controller) Export(w http.ResponseWriter, r *http.Request) { opmlHandler := opml.NewHandler(h.store)
opmlHandler := opml.NewHandler(c.store)
opml, err := opmlHandler.Export(request.UserID(r)) opml, err := opmlHandler.Export(request.UserID(r))
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
@ -25,9 +24,8 @@ func (c *Controller) Export(w http.ResponseWriter, r *http.Request) {
xml.OK(w, r, opml) xml.OK(w, r, opml)
} }
// Import is the API handler that import an OPML file. func (h *handler) importFeeds(w http.ResponseWriter, r *http.Request) {
func (c *Controller) Import(w http.ResponseWriter, r *http.Request) { opmlHandler := opml.NewHandler(h.store)
opmlHandler := opml.NewHandler(c.store)
err := opmlHandler.Import(request.UserID(r), r.Body) err := opmlHandler.Import(request.UserID(r), r.Body)
defer r.Body.Close() defer r.Body.Close()
if err != nil { if err != nil {

3
api/subscription.go
View file

@ -11,8 +11,7 @@ import (
"miniflux.app/reader/subscription" "miniflux.app/reader/subscription"
) )
// GetSubscriptions is the API handler to find subscriptions. func (h *handler) getSubscriptions(w http.ResponseWriter, r *http.Request) {
func (c *Controller) GetSubscriptions(w http.ResponseWriter, r *http.Request) {
subscriptionInfo, bodyErr := decodeURLPayload(r.Body) subscriptionInfo, bodyErr := decodeURLPayload(r.Body)
if bodyErr != nil { if bodyErr != nil {
json.BadRequest(w, r, bodyErr) json.BadRequest(w, r, bodyErr)

41
api/user.go
View file

@ -12,9 +12,8 @@ import (
"miniflux.app/http/response/json" "miniflux.app/http/response/json"
) )
// CurrentUser is the API handler to retrieve the authenticated user. func (h *handler) currentUser(w http.ResponseWriter, r *http.Request) {
func (c *Controller) CurrentUser(w http.ResponseWriter, r *http.Request) { user, err := h.store.UserByID(request.UserID(r))
user, err := c.store.UserByID(request.UserID(r))
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -23,8 +22,7 @@ func (c *Controller) CurrentUser(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, user) json.OK(w, r, user)
} }
// CreateUser is the API handler to create a new user. func (h *handler) createUser(w http.ResponseWriter, r *http.Request) {
func (c *Controller) CreateUser(w http.ResponseWriter, r *http.Request) {
if !request.IsAdminUser(r) { if !request.IsAdminUser(r) {
json.Forbidden(w, r) json.Forbidden(w, r)
return return
@ -41,12 +39,12 @@ func (c *Controller) CreateUser(w http.ResponseWriter, r *http.Request) {
return return
} }
if c.store.UserExists(user.Username) { if h.store.UserExists(user.Username) {
json.BadRequest(w, r, errors.New("This user already exists")) json.BadRequest(w, r, errors.New("This user already exists"))
return return
} }
err = c.store.CreateUser(user) err = h.store.CreateUser(user)
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -56,8 +54,7 @@ func (c *Controller) CreateUser(w http.ResponseWriter, r *http.Request) {
json.Created(w, r, user) json.Created(w, r, user)
} }
// UpdateUser is the API handler to update the given user. func (h *handler) updateUser(w http.ResponseWriter, r *http.Request) {
func (c *Controller) UpdateUser(w http.ResponseWriter, r *http.Request) {
if !request.IsAdminUser(r) { if !request.IsAdminUser(r) {
json.Forbidden(w, r) json.Forbidden(w, r)
return return
@ -70,7 +67,7 @@ func (c *Controller) UpdateUser(w http.ResponseWriter, r *http.Request) {
return return
} }
originalUser, err := c.store.UserByID(userID) originalUser, err := h.store.UserByID(userID)
if err != nil { if err != nil {
json.BadRequest(w, r, errors.New("Unable to fetch this user from the database")) json.BadRequest(w, r, errors.New("Unable to fetch this user from the database"))
return return
@ -87,7 +84,7 @@ func (c *Controller) UpdateUser(w http.ResponseWriter, r *http.Request) {
return return
} }
if err = c.store.UpdateUser(originalUser); err != nil { if err = h.store.UpdateUser(originalUser); err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
} }
@ -95,14 +92,13 @@ func (c *Controller) UpdateUser(w http.ResponseWriter, r *http.Request) {
json.Created(w, r, originalUser) json.Created(w, r, originalUser)
} }
// Users is the API handler to get the list of users. func (h *handler) users(w http.ResponseWriter, r *http.Request) {
func (c *Controller) Users(w http.ResponseWriter, r *http.Request) {
if !request.IsAdminUser(r) { if !request.IsAdminUser(r) {
json.Forbidden(w, r) json.Forbidden(w, r)
return return
} }
users, err := c.store.Users() users, err := h.store.Users()
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -112,15 +108,14 @@ func (c *Controller) Users(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, users) json.OK(w, r, users)
} }
// UserByID is the API handler to fetch the given user by the ID. func (h *handler) userByID(w http.ResponseWriter, r *http.Request) {
func (c *Controller) UserByID(w http.ResponseWriter, r *http.Request) {
if !request.IsAdminUser(r) { if !request.IsAdminUser(r) {
json.Forbidden(w, r) json.Forbidden(w, r)
return return
} }
userID := request.RouteInt64Param(r, "userID") userID := request.RouteInt64Param(r, "userID")
user, err := c.store.UserByID(userID) user, err := h.store.UserByID(userID)
if err != nil { if err != nil {
json.BadRequest(w, r, errors.New("Unable to fetch this user from the database")) json.BadRequest(w, r, errors.New("Unable to fetch this user from the database"))
return return
@ -135,15 +130,14 @@ func (c *Controller) UserByID(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, user) json.OK(w, r, user)
} }
// UserByUsername is the API handler to fetch the given user by the username. func (h *handler) userByUsername(w http.ResponseWriter, r *http.Request) {
func (c *Controller) UserByUsername(w http.ResponseWriter, r *http.Request) {
if !request.IsAdminUser(r) { if !request.IsAdminUser(r) {
json.Forbidden(w, r) json.Forbidden(w, r)
return return
} }
username := request.RouteStringParam(r, "username") username := request.RouteStringParam(r, "username")
user, err := c.store.UserByUsername(username) user, err := h.store.UserByUsername(username)
if err != nil { if err != nil {
json.BadRequest(w, r, errors.New("Unable to fetch this user from the database")) json.BadRequest(w, r, errors.New("Unable to fetch this user from the database"))
return return
@ -157,15 +151,14 @@ func (c *Controller) UserByUsername(w http.ResponseWriter, r *http.Request) {
json.OK(w, r, user) json.OK(w, r, user)
} }
// RemoveUser is the API handler to remove an existing user. func (h *handler) removeUser(w http.ResponseWriter, r *http.Request) {
func (c *Controller) RemoveUser(w http.ResponseWriter, r *http.Request) {
if !request.IsAdminUser(r) { if !request.IsAdminUser(r) {
json.Forbidden(w, r) json.Forbidden(w, r)
return return
} }
userID := request.RouteInt64Param(r, "userID") userID := request.RouteInt64Param(r, "userID")
user, err := c.store.UserByID(userID) user, err := h.store.UserByID(userID)
if err != nil { if err != nil {
json.ServerError(w, r, err) json.ServerError(w, r, err)
return return
@ -176,7 +169,7 @@ func (c *Controller) RemoveUser(w http.ResponseWriter, r *http.Request) {
return return
} }
if err := c.store.RemoveUser(user.ID); err != nil { if err := h.store.RemoveUser(user.ID); err != nil {
json.BadRequest(w, r, errors.New("Unable to remove this user from the database")) json.BadRequest(w, r, errors.New("Unable to remove this user from the database"))
return return
} }

32
daemon/routes.go
View file

@ -23,7 +23,6 @@ import (
func routes(cfg *config.Config, store *storage.Storage, feedHandler *feed.Handler, pool *scheduler.WorkerPool) *mux.Router { func routes(cfg *config.Config, store *storage.Storage, feedHandler *feed.Handler, pool *scheduler.WorkerPool) *mux.Router {
router := mux.NewRouter() router := mux.NewRouter()
templateEngine := template.NewEngine(cfg, router) templateEngine := template.NewEngine(cfg, router)
apiController := api.NewController(store, feedHandler)
uiController := ui.NewController(cfg, store, pool, feedHandler, templateEngine, router) uiController := ui.NewController(cfg, store, pool, feedHandler, templateEngine, router)
middleware := middleware.New(cfg, store, router) middleware := middleware.New(cfg, store, router)
@ -45,36 +44,7 @@ func routes(cfg *config.Config, store *storage.Storage, feedHandler *feed.Handle
}) })
fever.Serve(router, cfg, store) fever.Serve(router, cfg, store)
api.Serve(router, store, feedHandler)
apiRouter := router.PathPrefix("/v1").Subrouter()
apiRouter.Use(middleware.BasicAuth)
apiRouter.HandleFunc("/users", apiController.CreateUser).Methods("POST")
apiRouter.HandleFunc("/users", apiController.Users).Methods("GET")
apiRouter.HandleFunc("/users/{userID:[0-9]+}", apiController.UserByID).Methods("GET")
apiRouter.HandleFunc("/users/{userID:[0-9]+}", apiController.UpdateUser).Methods("PUT")
apiRouter.HandleFunc("/users/{userID:[0-9]+}", apiController.RemoveUser).Methods("DELETE")
apiRouter.HandleFunc("/users/{username}", apiController.UserByUsername).Methods("GET")
apiRouter.HandleFunc("/me", apiController.CurrentUser).Methods("GET")
apiRouter.HandleFunc("/categories", apiController.CreateCategory).Methods("POST")
apiRouter.HandleFunc("/categories", apiController.GetCategories).Methods("GET")
apiRouter.HandleFunc("/categories/{categoryID}", apiController.UpdateCategory).Methods("PUT")
apiRouter.HandleFunc("/categories/{categoryID}", apiController.RemoveCategory).Methods("DELETE")
apiRouter.HandleFunc("/discover", apiController.GetSubscriptions).Methods("POST")
apiRouter.HandleFunc("/feeds", apiController.CreateFeed).Methods("POST")
apiRouter.HandleFunc("/feeds", apiController.GetFeeds).Methods("GET")
apiRouter.HandleFunc("/feeds/{feedID}/refresh", apiController.RefreshFeed).Methods("PUT")
apiRouter.HandleFunc("/feeds/{feedID}", apiController.GetFeed).Methods("GET")
apiRouter.HandleFunc("/feeds/{feedID}", apiController.UpdateFeed).Methods("PUT")
apiRouter.HandleFunc("/feeds/{feedID}", apiController.RemoveFeed).Methods("DELETE")
apiRouter.HandleFunc("/feeds/{feedID}/icon", apiController.FeedIcon).Methods("GET")
apiRouter.HandleFunc("/export", apiController.Export).Methods("GET")
apiRouter.HandleFunc("/import", apiController.Import).Methods("POST")
apiRouter.HandleFunc("/feeds/{feedID}/entries", apiController.GetFeedEntries).Methods("GET")
apiRouter.HandleFunc("/feeds/{feedID}/entries/{entryID}", apiController.GetFeedEntry).Methods("GET")
apiRouter.HandleFunc("/entries", apiController.GetEntries).Methods("GET")
apiRouter.HandleFunc("/entries", apiController.SetEntryStatus).Methods("PUT")
apiRouter.HandleFunc("/entries/{entryID}", apiController.GetEntry).Methods("GET")
apiRouter.HandleFunc("/entries/{entryID}/bookmark", apiController.ToggleBookmark).Methods("PUT")
uiRouter := router.NewRoute().Subrouter() uiRouter := router.NewRoute().Subrouter()
uiRouter.Use(middleware.AppSession) uiRouter.Use(middleware.AppSession)