316 lines
13 KiB
TypeScript
316 lines
13 KiB
TypeScript
import { Route, Data } from '@/types';
|
|
import got from '@/utils/got';
|
|
import { config } from '@/config';
|
|
import ConfigNotFoundError from '@/errors/types/config-not-found';
|
|
|
|
export const route: Route = {
|
|
path: '/entry/:feeds/:parameters?',
|
|
description: `
|
|
1. Support to get all content: You can obtain the content of all subscription sources by using keywords such as \`/miniflux/all\` or \`/miniflux/default\`.
|
|
2. Support to get the subscription content of a specific subscription source by its ID. Please obtain the subscription source ID on the page where it is located under \`Sources\` (shortcut keys \`g\` \`f\`). The URL for each category (or subscription source) displays its ID information. There are several format options available:
|
|
1. Support \`/miniflux/feed=[feed_id]\`, please replace \`[feed_id]\` with the actual ID of the subscribed feed (note that it should be just a number without brackets).
|
|
2. Support subscribing to multiple feeds using \`/miniflux/feed=[feed1_id]&feed=[feed2_id]\` or \`/miniflux/feeds=[feed1_id]&[feed2_id]\`.
|
|
3. Additionally, you can use shorthand notation by directly using feed IDs: \`/miniflux/[feed1_id]&[feed2_id]\`.
|
|
3. Further customization options are available based on your needs:
|
|
1. All parameters/options provided by MiniFlux are supported ([link](https://miniflux.app/docs/api.html#endpoint-get-feed-entries)). As noted in their documentation, multiple filtering options should be connected with \`&\`. Except for \`status\`, only the first occurrence of duplicate filter options will be considered.
|
|
2. Specifically, this route defaults to sorting entries from new to old (\`direction=desc\`).
|
|
3. Moreover, this route supports additional options including:
|
|
- Using the \`feed_name\` parameter to control title formatting; setting \`feed_name=1\` will display each title as "Article Title | Feed Name," while default is set at \`0\`, showing only article titles.
|
|
- Utilizing the \`mark\` parameter to specify actions after fetching subscriptions in RSSHub, such as maintaining unchanged state (\`unchanged\`, default), marking as read (\`read\`), removing (\`removed\`) or marking as unread (\`unread\`). Note that marking as read should not simply be understood as a means for implementing synchronization services; rather, it functions more like an aid for MiniFlux's automatic cleaning feature.
|
|
- Future support may include utilizing the \`link\` parameter to control output URLs (this functionality requires corresponding interfaces from MiniFlux). It could involve generating URLs through MiniFlux entity sharing features or original content links.
|
|
- The output content quantity can be controlled via the 'limit' parameter; although all matching contents are typically outputted by default, **it is recommended that users set this parameter**.
|
|
`,
|
|
categories: ['other'],
|
|
example: '/miniflux/feeds=1&2&3/mark=read&limit=7&status=unread',
|
|
parameters: {
|
|
feeds: 'Subscribe source ID or get all.',
|
|
parameters: 'Filter and set parameters, use `&` to connect multiple.',
|
|
},
|
|
features: {
|
|
requireConfig: [
|
|
{
|
|
name: 'MINIFLUX_INSTANCE',
|
|
description: 'The instance used by the user, by default, is the official MiniFlux [paid service address](https://reader.miniflux.app)',
|
|
},
|
|
{
|
|
name: 'MINIFLUX_TOKEN',
|
|
description: "User's API key, please log in to the instance used and go to `Settings` -> `API Key` -> `Create a new API key` to obtain.",
|
|
},
|
|
],
|
|
requirePuppeteer: false,
|
|
antiCrawler: false,
|
|
supportBT: false,
|
|
supportPodcast: false,
|
|
supportScihub: false,
|
|
},
|
|
name: 'Feed entry',
|
|
maintainers: ['emdoe', 'DIYgod'],
|
|
handler,
|
|
};
|
|
|
|
async function handler(ctx) {
|
|
// Unchanged entries status after fetching.
|
|
// mark = unchanged | read | removed | unread
|
|
let mark = 'unchanged';
|
|
// Return shared link as default behavior
|
|
// link = shared | original
|
|
// let link = 'shared';
|
|
// Add feed's name to each article, default is off.
|
|
let addFeedName = 0;
|
|
// Here we use `limit` to temporarily store the limit number.
|
|
let limit = 0;
|
|
|
|
const instance = config.miniflux.instance;
|
|
const token = config.miniflux.token;
|
|
|
|
if (!token) {
|
|
throw new ConfigNotFoundError('This RSS feed is disabled due to its incorrect configuration: the token is missing.');
|
|
}
|
|
|
|
// In this function, var`mark`, `link`, and `limit`, `addFeedName`
|
|
// could be changed.
|
|
function filterHandler(item) {
|
|
if (item.search('=') === -1) {
|
|
return '';
|
|
}
|
|
|
|
const filter = item.substring(0, item.indexOf('='));
|
|
const option = item.substring(item.lastIndexOf('=') + 1);
|
|
|
|
switch (filter) {
|
|
case 'mark':
|
|
if ((option === 'read' || option === 'removed' || option === 'unread') && !setMark.length) {
|
|
mark = option;
|
|
setMark.push(1);
|
|
}
|
|
item = '';
|
|
break;
|
|
// case 'link':
|
|
// (option == 'original') ?
|
|
// link = option :
|
|
// link = 'shared';
|
|
// item = '';
|
|
// break;
|
|
case 'feed_name':
|
|
if (Number.parseInt(option) === 1 && !setFeedName.length) {
|
|
addFeedName = 1;
|
|
setFeedName.push(1);
|
|
}
|
|
item = '';
|
|
break;
|
|
case 'direction':
|
|
if (option !== 'asc') {
|
|
item = 'direction=desc';
|
|
}
|
|
break;
|
|
// If user mistakenly set `category=Int`
|
|
case 'category':
|
|
isNaN(Number.parseInt(option)) ? (item = '') : (item = `category_id=${option}`);
|
|
break;
|
|
case 'order':
|
|
if (option !== 'id' && option !== 'category_title' && option !== 'published_at' && option !== 'status' && option !== 'category_id') {
|
|
item = '';
|
|
}
|
|
break;
|
|
// Program should behave differently for `limit` parameter in
|
|
// each mode. So currently we only save the (last & existed)
|
|
// parameter, since user may mistakenly input this parameter
|
|
// several times.
|
|
case 'limit':
|
|
if (!isNaN(option) && !setLimit.length) {
|
|
limit = option;
|
|
setLimit.push(1);
|
|
}
|
|
item = '';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return item;
|
|
}
|
|
|
|
const entriesID = [];
|
|
const feedsName = [];
|
|
const articles = [];
|
|
|
|
// MiniFlux will only preserve the *first* valid filter option
|
|
// for each parameter, in order to matching the default behavior
|
|
// here we use arrays to track the setting for `limit`,
|
|
// `mark` and `feed_name`.
|
|
const setLimit = [];
|
|
const setMark = [];
|
|
const setFeedName = [];
|
|
|
|
const feeds = ctx.req.param('feeds');
|
|
|
|
let parameters = ctx.req.param('parameters');
|
|
// Set default direction
|
|
if (parameters.search('direction=') === -1) {
|
|
parameters += '&direction=desc';
|
|
}
|
|
|
|
parameters = parameters
|
|
.split('&')
|
|
.map((item) => filterHandler(item))
|
|
.filter(Boolean)
|
|
.join('&');
|
|
|
|
let queryLimit = ctx.req.query('limit');
|
|
let result: Data;
|
|
if (feeds.search(/feeds?=/g) !== -1 || !isNaN(Number.parseInt(feeds.split('&').join('')))) {
|
|
const feedsID = feeds.replaceAll(/feeds?=/g, '');
|
|
const feedsList = [feedsID.split('&')].flat();
|
|
|
|
if (limit && queryLimit) {
|
|
if (limit < queryLimit) {
|
|
queryLimit = limit * feedsList.length;
|
|
} else {
|
|
const eachLimit = Number.parseInt(queryLimit / feedsList.length);
|
|
if (eachLimit) {
|
|
limit = eachLimit;
|
|
} else {
|
|
limit = 1;
|
|
queryLimit = feedsList.length;
|
|
}
|
|
}
|
|
parameters += `&limit=${limit}`;
|
|
} else if (limit) {
|
|
parameters += `&limit=${limit}`;
|
|
} else if (queryLimit) {
|
|
const eachLimit = Number.parseInt(queryLimit / feedsList.length);
|
|
if (eachLimit) {
|
|
limit = eachLimit;
|
|
} else {
|
|
limit = 1;
|
|
queryLimit = feedsList.length;
|
|
}
|
|
parameters += `&limit=${limit}`;
|
|
}
|
|
|
|
await Promise.all(
|
|
feedsList.map(async (feed) => {
|
|
const url = `${instance}/v1/feeds/${feed}/entries?${parameters}`;
|
|
const response = await got({
|
|
method: 'get',
|
|
url,
|
|
headers: {
|
|
'X-Auth-Token': token,
|
|
},
|
|
});
|
|
|
|
const entries = response.data.entries;
|
|
// Whether or not get the title of this feed
|
|
let getFeedTitle = 0;
|
|
// entries.map(item => {
|
|
for (const entry of entries) {
|
|
entriesID.push(entry.id);
|
|
if (!getFeedTitle) {
|
|
feedsName.push(entry.feed.title);
|
|
getFeedTitle = 1;
|
|
}
|
|
// Whether or not user would like to add the feed's name
|
|
// to the title of article.
|
|
let entryTitle = entry.title;
|
|
if (addFeedName) {
|
|
entryTitle += ` | ${entry.feed.title}`;
|
|
}
|
|
// let entryURL = `${instance}/share/${entry.share_code}`;
|
|
// if (link == 'original') {
|
|
// entryURL = entry.url;
|
|
// }
|
|
articles.push({
|
|
title: entryTitle,
|
|
author: entry.author,
|
|
pubDate: entry.published_at,
|
|
description: entry.content,
|
|
link: entry.url,
|
|
});
|
|
}
|
|
})
|
|
);
|
|
|
|
const feedsNumber = feedsName.length;
|
|
let agTitle, agInfo;
|
|
if (feedsNumber > 2) {
|
|
agTitle = `MiniFlux | Aggregator For ${feedsNumber} Feeds`;
|
|
agInfo = 'An aggregator powered by MiniFlux and RSSHub. ' + 'This aggregator truthfully preserves the contents in ' + `${feedsNumber} feeds, including: ` + `<li>${feedsName.join('<li></li>')}</li>`;
|
|
} else if (feedsNumber) {
|
|
agTitle = `MiniFlux | ${feedsName.join(', ')}`;
|
|
agInfo = 'A RSS feed powered by MiniFlux and RSSHub ' + 'effortlessly republishes the contents in ' + `"${feedsName.join('" & "')}".`;
|
|
} else {
|
|
agTitle = `MiniFlux | Feeds Aggregator`;
|
|
agInfo = 'An aggregator powered by MiniFlux and RSSHub ' + 'with empty content. If this is not your intention, ' + `please double-check your setting for parameters.`;
|
|
}
|
|
|
|
result = {
|
|
title: agTitle,
|
|
link: instance,
|
|
description: agInfo,
|
|
item: articles,
|
|
allowEmpty: true,
|
|
};
|
|
} else {
|
|
if (limit && queryLimit) {
|
|
if (limit < queryLimit) {
|
|
queryLimit = limit;
|
|
}
|
|
// Here we could add a '&' since parameter(s) list must not empty.
|
|
parameters += `&limit=${queryLimit}`;
|
|
} else if (queryLimit) {
|
|
parameters += `&limit=${queryLimit}`;
|
|
} else if (limit) {
|
|
parameters += `&limit=${limit}`;
|
|
}
|
|
|
|
const response = await got.get(`${instance}/v1/entries?${parameters}`, {
|
|
headers: { 'X-Auth-Token': token },
|
|
});
|
|
|
|
const entries = response.data.entries;
|
|
const articles = [];
|
|
for (const entry of entries) {
|
|
entriesID.push(entry.id);
|
|
let entryTitle = entry.title;
|
|
if (addFeedName) {
|
|
entryTitle += ` | ${entry.feed.title}`;
|
|
}
|
|
// let entryURL = `${instance}/share/${entry.share_code}`;
|
|
// if (link == 'original') {
|
|
// entryURL = entry.url;
|
|
// }
|
|
articles.push({
|
|
title: entryTitle,
|
|
author: entry.author,
|
|
pubDate: entry.published_at,
|
|
description: entry.content,
|
|
link: entry.url,
|
|
});
|
|
}
|
|
|
|
result = {
|
|
title: `MiniFlux | All`,
|
|
link: instance,
|
|
description: `All feeds on ${instance} powered by MiniFlux`,
|
|
item: articles,
|
|
allowEmpty: true,
|
|
};
|
|
}
|
|
|
|
if (mark !== 'unchanged') {
|
|
got({
|
|
method: 'put',
|
|
url: `${instance}/v1/entries`,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-Auth-Token': token,
|
|
},
|
|
json: {
|
|
entry_ids: entriesID,
|
|
status: mark,
|
|
},
|
|
});
|
|
}
|
|
|
|
return result;
|
|
}
|