entry_handlers.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633
  1. // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
  2. // SPDX-License-Identifier: Apache-2.0
  3. package api // import "miniflux.app/v2/internal/api"
  4. import (
  5. json_parser "encoding/json"
  6. "errors"
  7. "net/http"
  8. "strconv"
  9. "time"
  10. "miniflux.app/v2/internal/config"
  11. "miniflux.app/v2/internal/crypto"
  12. "miniflux.app/v2/internal/http/request"
  13. "miniflux.app/v2/internal/http/response"
  14. "miniflux.app/v2/internal/integration"
  15. "miniflux.app/v2/internal/mediaproxy"
  16. "miniflux.app/v2/internal/model"
  17. "miniflux.app/v2/internal/reader/processor"
  18. "miniflux.app/v2/internal/reader/readingtime"
  19. "miniflux.app/v2/internal/reader/sanitizer"
  20. "miniflux.app/v2/internal/storage"
  21. "miniflux.app/v2/internal/validator"
  22. )
  23. func (h *handler) getEntryFromBuilder(w http.ResponseWriter, r *http.Request, b *storage.EntryQueryBuilder) {
  24. entry, err := b.GetEntry()
  25. if err != nil {
  26. response.JSONServerError(w, r, err)
  27. return
  28. }
  29. if entry == nil {
  30. response.JSONNotFound(w, r)
  31. return
  32. }
  33. entry.Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(entry.Content)
  34. entry.Enclosures.ProxifyEnclosureURL(config.Opts.MediaProxyMode(), config.Opts.MediaProxyResourceTypes())
  35. response.JSON(w, r, entry)
  36. }
  37. func (h *handler) getFeedEntryHandler(w http.ResponseWriter, r *http.Request) {
  38. feedID := request.RouteInt64Param(r, "feedID")
  39. if feedID == 0 {
  40. response.JSONBadRequest(w, r, errors.New("invalid feed ID"))
  41. return
  42. }
  43. entryID := request.RouteInt64Param(r, "entryID")
  44. if entryID == 0 {
  45. response.JSONBadRequest(w, r, errors.New("invalid entry ID"))
  46. return
  47. }
  48. builder := h.store.NewEntryQueryBuilder(request.UserID(r)).
  49. WithFeedID(feedID).
  50. WithEntryIDs(entryID)
  51. h.getEntryFromBuilder(w, r, builder)
  52. }
  53. func (h *handler) getCategoryEntryHandler(w http.ResponseWriter, r *http.Request) {
  54. categoryID := request.RouteInt64Param(r, "categoryID")
  55. if categoryID == 0 {
  56. response.JSONBadRequest(w, r, errors.New("invalid category ID"))
  57. return
  58. }
  59. entryID := request.RouteInt64Param(r, "entryID")
  60. if entryID == 0 {
  61. response.JSONBadRequest(w, r, errors.New("invalid entry ID"))
  62. return
  63. }
  64. builder := h.store.NewEntryQueryBuilder(request.UserID(r)).
  65. WithCategoryID(categoryID).
  66. WithEntryIDs(entryID)
  67. h.getEntryFromBuilder(w, r, builder)
  68. }
  69. func (h *handler) getEntryHandler(w http.ResponseWriter, r *http.Request) {
  70. entryID := request.RouteInt64Param(r, "entryID")
  71. if entryID == 0 {
  72. response.JSONBadRequest(w, r, errors.New("invalid entry ID"))
  73. return
  74. }
  75. builder := h.store.NewEntryQueryBuilder(request.UserID(r)).
  76. WithEntryIDs(entryID)
  77. h.getEntryFromBuilder(w, r, builder)
  78. }
  79. func (h *handler) getFeedEntriesHandler(w http.ResponseWriter, r *http.Request) {
  80. feedID := request.RouteInt64Param(r, "feedID")
  81. if feedID == 0 {
  82. response.JSONBadRequest(w, r, errors.New("invalid feed ID"))
  83. return
  84. }
  85. h.findEntries(w, r, feedID, 0)
  86. }
  87. func (h *handler) getCategoryEntriesHandler(w http.ResponseWriter, r *http.Request) {
  88. categoryID := request.RouteInt64Param(r, "categoryID")
  89. if categoryID == 0 {
  90. response.JSONBadRequest(w, r, errors.New("invalid category ID"))
  91. return
  92. }
  93. h.findEntries(w, r, 0, categoryID)
  94. }
  95. func (h *handler) getEntriesHandler(w http.ResponseWriter, r *http.Request) {
  96. h.findEntries(w, r, 0, 0)
  97. }
  98. func (h *handler) findEntries(w http.ResponseWriter, r *http.Request, feedID int64, categoryID int64) {
  99. statuses := request.QueryStringParamList(r, "status")
  100. for _, status := range statuses {
  101. if err := validator.ValidateEntryStatus(status); err != nil {
  102. response.JSONBadRequest(w, r, err)
  103. return
  104. }
  105. }
  106. order := request.QueryStringParam(r, "order", model.DefaultSortingOrder)
  107. if err := validator.ValidateEntryOrder(order); err != nil {
  108. response.JSONBadRequest(w, r, err)
  109. return
  110. }
  111. direction := request.QueryStringParam(r, "direction", model.DefaultSortingDirection)
  112. if err := validator.ValidateDirection(direction); err != nil {
  113. response.JSONBadRequest(w, r, err)
  114. return
  115. }
  116. limit := request.QueryIntParam(r, "limit", 100)
  117. offset := request.QueryIntParam(r, "offset", 0)
  118. if err := validator.ValidateRange(offset, limit); err != nil {
  119. response.JSONBadRequest(w, r, err)
  120. return
  121. }
  122. userID := request.UserID(r)
  123. categoryID = request.QueryInt64Param(r, "category_id", categoryID)
  124. if categoryID > 0 {
  125. exists, err := h.store.CategoryIDExists(userID, categoryID)
  126. if err != nil {
  127. response.JSONServerError(w, r, err)
  128. return
  129. }
  130. if !exists {
  131. response.JSONBadRequest(w, r, errors.New("invalid category ID"))
  132. return
  133. }
  134. }
  135. feedID = request.QueryInt64Param(r, "feed_id", feedID)
  136. if feedID > 0 {
  137. exists, err := h.store.FeedExists(userID, feedID)
  138. if err != nil {
  139. response.JSONServerError(w, r, err)
  140. return
  141. }
  142. if !exists {
  143. response.JSONBadRequest(w, r, errors.New("invalid feed ID"))
  144. return
  145. }
  146. }
  147. tags := request.QueryStringParamList(r, "tags")
  148. builder := h.store.NewEntryQueryBuilder(userID).
  149. WithFeedID(feedID).
  150. WithCategoryID(categoryID).
  151. WithStatuses(statuses...).
  152. WithSorting(order, direction).
  153. WithOffset(offset).
  154. WithLimit(limit).
  155. WithTags(tags...).
  156. WithEnclosures()
  157. if request.HasQueryParam(r, "globally_visible") {
  158. globallyVisible := request.QueryBoolParam(r, "globally_visible", true)
  159. if globallyVisible {
  160. builder = builder.WithGloballyVisible()
  161. }
  162. }
  163. builder = configureFilters(builder, r)
  164. entries, count, err := builder.GetEntriesWithCount()
  165. if err != nil {
  166. response.JSONServerError(w, r, err)
  167. return
  168. }
  169. for i := range entries {
  170. entries[i].Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(entries[i].Content)
  171. entries[i].Enclosures.ProxifyEnclosureURL(config.Opts.MediaProxyMode(), config.Opts.MediaProxyResourceTypes())
  172. }
  173. response.JSON(w, r, &entriesResponse{Total: count, Entries: entries})
  174. }
  175. func (h *handler) setEntryStatusAndStarredHandler(w http.ResponseWriter, r *http.Request) {
  176. var entriesStatusUpdateRequest model.EntriesStatusUpdateRequest
  177. if err := json_parser.NewDecoder(r.Body).Decode(&entriesStatusUpdateRequest); err != nil {
  178. response.JSONBadRequest(w, r, err)
  179. return
  180. }
  181. if err := validator.ValidateEntriesStatusAndStarredUpdateRequest(&entriesStatusUpdateRequest); err != nil {
  182. response.JSONBadRequest(w, r, err)
  183. return
  184. }
  185. if entriesStatusUpdateRequest.Status != "" {
  186. if err := h.store.SetEntriesStatus(request.UserID(r), entriesStatusUpdateRequest.EntryIDs, entriesStatusUpdateRequest.Status); err != nil {
  187. response.JSONServerError(w, r, err)
  188. return
  189. }
  190. }
  191. if entriesStatusUpdateRequest.Starred != nil {
  192. if err := h.store.SetEntriesStarredState(request.UserID(r), entriesStatusUpdateRequest.EntryIDs, *entriesStatusUpdateRequest.Starred); err != nil {
  193. response.JSONServerError(w, r, err)
  194. return
  195. }
  196. }
  197. response.NoContent(w, r)
  198. }
  199. func (h *handler) toggleStarredHandler(w http.ResponseWriter, r *http.Request) {
  200. entryID := request.RouteInt64Param(r, "entryID")
  201. if entryID == 0 {
  202. response.JSONBadRequest(w, r, errors.New("invalid entry ID"))
  203. return
  204. }
  205. if err := h.store.ToggleStarred(request.UserID(r), entryID); err != nil {
  206. response.JSONServerError(w, r, err)
  207. return
  208. }
  209. response.NoContent(w, r)
  210. }
  211. func (h *handler) saveEntryHandler(w http.ResponseWriter, r *http.Request) {
  212. entryID := request.RouteInt64Param(r, "entryID")
  213. if entryID == 0 {
  214. response.JSONBadRequest(w, r, errors.New("invalid entry ID"))
  215. return
  216. }
  217. if !h.store.HasSaveEntry(request.UserID(r)) {
  218. response.JSONBadRequest(w, r, errors.New("no third-party integration enabled"))
  219. return
  220. }
  221. entry, err := h.store.NewEntryQueryBuilder(request.UserID(r)).
  222. WithEntryIDs(entryID).
  223. GetEntry()
  224. if err != nil {
  225. response.JSONServerError(w, r, err)
  226. return
  227. }
  228. if entry == nil {
  229. response.JSONNotFound(w, r)
  230. return
  231. }
  232. settings, err := h.store.Integration(request.UserID(r))
  233. if err != nil {
  234. response.JSONServerError(w, r, err)
  235. return
  236. }
  237. go integration.SendEntry(entry, settings)
  238. response.JSONAccepted(w, r)
  239. }
  240. func (h *handler) updateEntryHandler(w http.ResponseWriter, r *http.Request) {
  241. var entryUpdateRequest model.EntryUpdateRequest
  242. if err := json_parser.NewDecoder(r.Body).Decode(&entryUpdateRequest); err != nil {
  243. response.JSONBadRequest(w, r, err)
  244. return
  245. }
  246. if err := validator.ValidateEntryModification(&entryUpdateRequest); err != nil {
  247. response.JSONBadRequest(w, r, err)
  248. return
  249. }
  250. entryID := request.RouteInt64Param(r, "entryID")
  251. if entryID == 0 {
  252. response.JSONBadRequest(w, r, errors.New("invalid entry ID"))
  253. return
  254. }
  255. loggedUserID := request.UserID(r)
  256. entry, err := h.store.NewEntryQueryBuilder(loggedUserID).
  257. WithEntryIDs(entryID).
  258. GetEntry()
  259. if err != nil {
  260. response.JSONServerError(w, r, err)
  261. return
  262. }
  263. if entry == nil {
  264. response.JSONNotFound(w, r)
  265. return
  266. }
  267. user, err := h.store.UserByID(loggedUserID)
  268. if err != nil {
  269. response.JSONServerError(w, r, err)
  270. return
  271. }
  272. if user == nil {
  273. response.JSONNotFound(w, r)
  274. return
  275. }
  276. if entryUpdateRequest.Content != nil {
  277. sanitizedContent := sanitizer.SanitizeHTML(entry.URL, *entryUpdateRequest.Content, &sanitizer.SanitizerOptions{OpenLinksInNewTab: user.OpenExternalLinksInNewTab})
  278. entryUpdateRequest.Content = &sanitizedContent
  279. }
  280. entryUpdateRequest.Patch(entry)
  281. if user.ShowReadingTime {
  282. entry.ReadingTime = readingtime.EstimateReadingTime(entry.Content, user.DefaultReadingSpeed, user.CJKReadingSpeed)
  283. }
  284. if err := h.store.UpdateEntryTitleAndContent(entry); err != nil {
  285. response.JSONServerError(w, r, err)
  286. return
  287. }
  288. response.JSONCreated(w, r, entry)
  289. }
  290. func (h *handler) importFeedEntryHandler(w http.ResponseWriter, r *http.Request) {
  291. userID := request.UserID(r)
  292. feedID := request.RouteInt64Param(r, "feedID")
  293. if feedID <= 0 {
  294. response.JSONBadRequest(w, r, errors.New("invalid feed ID"))
  295. return
  296. }
  297. exists, err := h.store.FeedExists(userID, feedID)
  298. if err != nil {
  299. response.JSONServerError(w, r, err)
  300. return
  301. }
  302. if !exists {
  303. response.JSONBadRequest(w, r, errors.New("feed does not exist"))
  304. return
  305. }
  306. var importRequest entryImportRequest
  307. if err := json_parser.NewDecoder(r.Body).Decode(&importRequest); err != nil {
  308. response.JSONBadRequest(w, r, err)
  309. return
  310. }
  311. if importRequest.URL == "" {
  312. response.JSONBadRequest(w, r, errors.New("url is required"))
  313. return
  314. }
  315. if importRequest.Status == "" {
  316. importRequest.Status = model.EntryStatusRead
  317. }
  318. if err := validator.ValidateEntryStatus(importRequest.Status); err != nil {
  319. response.JSONBadRequest(w, r, err)
  320. return
  321. }
  322. entry := model.NewEntry()
  323. entry.URL = importRequest.URL
  324. entry.CommentsURL = importRequest.CommentsURL
  325. entry.Author = importRequest.Author
  326. entry.Tags = importRequest.Tags
  327. if importRequest.PublishedAt > 0 {
  328. entry.Date = time.Unix(importRequest.PublishedAt, 0).UTC()
  329. } else {
  330. entry.Date = time.Now().UTC()
  331. }
  332. if importRequest.Title == "" {
  333. entry.Title = entry.URL
  334. } else {
  335. entry.Title = importRequest.Title
  336. }
  337. hashInput := importRequest.ExternalID
  338. if hashInput == "" {
  339. hashInput = importRequest.URL
  340. }
  341. entry.Hash = crypto.HashFromBytes([]byte(hashInput))
  342. user, err := h.store.UserByID(userID)
  343. if err != nil {
  344. response.JSONServerError(w, r, err)
  345. return
  346. }
  347. if user == nil {
  348. response.JSONNotFound(w, r)
  349. return
  350. }
  351. if importRequest.Content != "" {
  352. entry.Content = sanitizer.SanitizeHTML(entry.URL, importRequest.Content, &sanitizer.SanitizerOptions{OpenLinksInNewTab: user.OpenExternalLinksInNewTab})
  353. }
  354. if user.ShowReadingTime {
  355. entry.ReadingTime = readingtime.EstimateReadingTime(entry.Content, user.DefaultReadingSpeed, user.CJKReadingSpeed)
  356. }
  357. created, err := h.store.InsertEntryForFeed(userID, feedID, entry)
  358. if errors.Is(err, storage.ErrEntryTombstoned) {
  359. response.JSONBadRequest(w, r, err)
  360. return
  361. }
  362. if err != nil {
  363. response.JSONServerError(w, r, err)
  364. return
  365. }
  366. if err := h.store.SetEntriesStatus(userID, []int64{entry.ID}, importRequest.Status); err != nil {
  367. response.JSONServerError(w, r, err)
  368. return
  369. }
  370. entry.Status = importRequest.Status
  371. if importRequest.Starred {
  372. if err := h.store.SetEntriesStarredState(userID, []int64{entry.ID}, true); err != nil {
  373. response.JSONServerError(w, r, err)
  374. return
  375. }
  376. entry.Starred = true
  377. }
  378. if created {
  379. response.JSONCreated(w, r, entryIDResponse{ID: entry.ID})
  380. } else {
  381. response.JSON(w, r, entryIDResponse{ID: entry.ID})
  382. }
  383. }
  384. func (h *handler) fetchContentHandler(w http.ResponseWriter, r *http.Request) {
  385. loggedUserID := request.UserID(r)
  386. entryID := request.RouteInt64Param(r, "entryID")
  387. if entryID == 0 {
  388. response.JSONBadRequest(w, r, errors.New("invalid entry ID"))
  389. return
  390. }
  391. entry, err := h.store.NewEntryQueryBuilder(loggedUserID).
  392. WithEntryIDs(entryID).
  393. GetEntry()
  394. if err != nil {
  395. response.JSONServerError(w, r, err)
  396. return
  397. }
  398. if entry == nil {
  399. response.JSONNotFound(w, r)
  400. return
  401. }
  402. user, err := h.store.UserByID(loggedUserID)
  403. if err != nil {
  404. response.JSONServerError(w, r, err)
  405. return
  406. }
  407. if user == nil {
  408. response.JSONNotFound(w, r)
  409. return
  410. }
  411. feed, err := h.store.NewFeedQueryBuilder(loggedUserID).
  412. WithFeedID(entry.FeedID).
  413. GetFeed()
  414. if err != nil {
  415. response.JSONServerError(w, r, err)
  416. return
  417. }
  418. if feed == nil {
  419. response.JSONNotFound(w, r)
  420. return
  421. }
  422. if err := processor.ProcessEntryWebPage(feed, entry, user); err != nil {
  423. response.JSONServerError(w, r, err)
  424. return
  425. }
  426. shouldUpdateContent := request.QueryBoolParam(r, "update_content", false)
  427. if shouldUpdateContent {
  428. if err := h.store.UpdateEntryTitleAndContent(entry); err != nil {
  429. response.JSONServerError(w, r, err)
  430. return
  431. }
  432. }
  433. response.JSON(w, r, entryContentResponse{Content: mediaproxy.RewriteDocumentWithAbsoluteProxyURL(entry.Content), ReadingTime: entry.ReadingTime})
  434. }
  435. func (h *handler) getEntryIDsHandler(w http.ResponseWriter, r *http.Request) {
  436. if request.HasQueryParam(r, "starred") {
  437. starredValue := request.QueryStringParam(r, "starred", "")
  438. if starredValue != "true" && starredValue != "false" {
  439. response.JSONBadRequest(w, r, errors.New(`invalid starred parameter, must be "true" or "false"`))
  440. return
  441. }
  442. }
  443. if request.HasQueryParam(r, "status") {
  444. statusValue := request.QueryStringParam(r, "status", "")
  445. if statusValue != model.EntryStatusRead && statusValue != model.EntryStatusUnread {
  446. response.JSONBadRequest(w, r, errors.New(`invalid status parameter, must be "read" or "unread"`))
  447. return
  448. }
  449. }
  450. limit, offset := parseEntryIDsParams(r)
  451. builder := h.store.NewEntryQueryBuilder(request.UserID(r)).
  452. WithSorting("id", "DESC").
  453. WithLimitAndMaximum(limit, model.MaxEntryIDsLimit).
  454. WithOffset(offset)
  455. if request.HasQueryParam(r, "starred") {
  456. builder.WithStarred(request.QueryBoolParam(r, "starred", false))
  457. }
  458. if request.HasQueryParam(r, "status") {
  459. builder.WithStatuses(request.QueryStringParam(r, "status", ""))
  460. }
  461. entryIDs, total, err := builder.GetEntryIDsWithCount()
  462. if err != nil {
  463. response.JSONServerError(w, r, err)
  464. return
  465. }
  466. if entryIDs == nil {
  467. entryIDs = []int64{}
  468. }
  469. response.JSON(w, r, entryIDsResponse{Total: total, EntryIDs: entryIDs})
  470. }
  471. func (h *handler) flushHistoryHandler(w http.ResponseWriter, r *http.Request) {
  472. loggedUserID := request.UserID(r)
  473. go h.store.FlushHistory(loggedUserID)
  474. response.JSONAccepted(w, r)
  475. }
  476. func configureFilters(builder *storage.EntryQueryBuilder, r *http.Request) *storage.EntryQueryBuilder {
  477. if beforeEntryID := request.QueryInt64Param(r, "before_entry_id", 0); beforeEntryID > 0 {
  478. builder = builder.BeforeEntryID(beforeEntryID)
  479. }
  480. if afterEntryID := request.QueryInt64Param(r, "after_entry_id", 0); afterEntryID > 0 {
  481. builder = builder.AfterEntryID(afterEntryID)
  482. }
  483. if beforePublishedTimestamp := request.QueryInt64Param(r, "before", 0); beforePublishedTimestamp > 0 {
  484. builder = builder.BeforePublishedDate(time.Unix(beforePublishedTimestamp, 0))
  485. }
  486. if afterPublishedTimestamp := request.QueryInt64Param(r, "after", 0); afterPublishedTimestamp > 0 {
  487. builder = builder.AfterPublishedDate(time.Unix(afterPublishedTimestamp, 0))
  488. }
  489. if beforePublishedTimestamp := request.QueryInt64Param(r, "published_before", 0); beforePublishedTimestamp > 0 {
  490. builder = builder.BeforePublishedDate(time.Unix(beforePublishedTimestamp, 0))
  491. }
  492. if afterPublishedTimestamp := request.QueryInt64Param(r, "published_after", 0); afterPublishedTimestamp > 0 {
  493. builder = builder.AfterPublishedDate(time.Unix(afterPublishedTimestamp, 0))
  494. }
  495. if beforeChangedTimestamp := request.QueryInt64Param(r, "changed_before", 0); beforeChangedTimestamp > 0 {
  496. builder = builder.BeforeChangedDate(time.Unix(beforeChangedTimestamp, 0))
  497. }
  498. if afterChangedTimestamp := request.QueryInt64Param(r, "changed_after", 0); afterChangedTimestamp > 0 {
  499. builder = builder.AfterChangedDate(time.Unix(afterChangedTimestamp, 0))
  500. }
  501. if request.HasQueryParam(r, "starred") {
  502. starred, err := strconv.ParseBool(r.URL.Query().Get("starred"))
  503. if err == nil {
  504. builder = builder.WithStarred(starred)
  505. }
  506. }
  507. if searchQuery := request.QueryStringParam(r, "search", ""); searchQuery != "" {
  508. builder = builder.WithSearchQuery(searchQuery)
  509. }
  510. return builder
  511. }
  512. func parseEntryIDsParams(r *http.Request) (limit, offset int) {
  513. limit = request.QueryIntParam(r, "limit", model.MaxEntryIDsLimit)
  514. if limit <= 0 || limit > model.MaxEntryIDsLimit {
  515. limit = model.MaxEntryIDsLimit
  516. }
  517. offset = request.QueryIntParam(r, "offset", 0)
  518. return limit, offset
  519. }