fix: urldecode of special character

source/controlers/rss.ts

@@ -4,6 +4,7 @@ import twoKeyReply from '../utils/two-key-reply';
 import errors from '../utils/errors';
 import { MContext, Next } from '../types/ctx';
 import { isNone } from '../types/option';
+import { decodeUrl } from '../utils/decodeUrl';
 
 export async function sub(ctx: MContext, next: Next): Promise<void> {
     const { feedUrl, chat, lang } = ctx.state;
@@ -84,7 +85,7 @@ export async function rss(ctx: MContext, next: Next): Promise<void> {
             builder.push(
                 `${feed.feed_title.trim()}: <a href="${encodeURI(
                     feed.url.trim()
-                )}">${decodeURI(feed.url.trim())}</a>`
+                )}">${decodeUrl(feed.url.trim())}</a>`
             );
         });
     } else {
@@ -154,7 +155,7 @@ export async function getUrlById(ctx: MContext, next: Next): Promise<void> {
     const { text } = ctx.message;
     const feed_id = text.match(/^\[(\d+)] (.+)/)[1];
     const feed = await RSS.getFeedById(parseInt(feed_id));
-    ctx.state.feedUrl = decodeURI(feed.url);
+    ctx.state.feedUrl = decodeUrl(feed.url);
     await next();
 }
 

source/middlewares/get-url-by-title.ts

@@ -2,6 +2,7 @@ import { MContext, Next } from '../types/ctx';
 
 import { getFeedsByTitle } from '../proxies/rss-feed';
 import errors from '../utils/errors';
+import { decodeUrl } from '../utils/decodeUrl';
 export default async (ctx: MContext, next: Next): Promise<void> => {
     const me = await ctx.telegram.getMe();
     const myId = me.id;
@@ -14,6 +15,6 @@ export default async (ctx: MContext, next: Next): Promise<void> => {
     if (feeds.length > 1) throw errors.newCtrlErr('SAME_NAME');
     if (feeds.length === 0) throw errors.newCtrlErr('UNSUBTHIS_USAGE');
     ctx.state.feed = feeds[0];
-    ctx.state.feedUrl = decodeURI(feeds[0].url);
+    ctx.state.feedUrl = decodeUrl(feeds[0].url);
     await next();
 };

source/middlewares/get-url.ts

@@ -2,6 +2,7 @@ import errors from '../utils/errors';
 import { getSubscribedFeedsByUserId } from '../proxies/rss-feed';
 import i18n from '../i18n';
 import { MContext, Next } from '../types/ctx';
+import { decodeUrl } from '../utils/decodeUrl';
 
 export default async (ctx: MContext, next: Next): Promise<void> => {
     const { lang } = ctx.state;
@@ -41,6 +42,6 @@ export default async (ctx: MContext, next: Next): Promise<void> => {
     } else if (!url.startsWith('http') && !url.startsWith('https')) {
         throw errors.newCtrlErr('FEED_URL_NOT_PARSE');
     }
-    ctx.state.feedUrl = decodeURI(url);
+    ctx.state.feedUrl = decodeUrl(url);
     await next();
 };

source/middlewares/sub-multi-url.ts

@@ -6,6 +6,7 @@ import { MContext, Next } from '../types/ctx';
 import { isSome } from '../types/option';
 import { Feed } from '../types/feed';
 import { parseString } from '../parser/parse';
+import { decodeUrl } from '../utils/decodeUrl';
 
 export default async (ctx: MContext, next: Next): Promise<void> => {
     const urls = ctx.message.text.match(
@@ -15,7 +16,7 @@ export default async (ctx: MContext, next: Next): Promise<void> => {
     const feedsReady = await Promise.all(
         urls.map(
             async (url): Promise<Partial<Feed>> => {
-                url = decodeURI(url); // idempotent operation just do it first
+                url = decodeUrl(url); // decode first
                 const feed = await getFeedByUrl(url);
                 if (isSome(feed)) {
                     return feed.value;

source/middlewares/test-url.ts

@@ -6,6 +6,7 @@ import { getFeedByUrl } from '../proxies/rss-feed';
 import { MContext, Next } from '../types/ctx';
 import { isNone, isSome } from '../types/option';
 import { parseString } from '../parser/parse';
+import { decodeUrl } from '../utils/decodeUrl';
 
 export default async (ctx: MContext, next: Next): Promise<void> => {
     const url = encodeURI(ctx.state.feedUrl);
@@ -17,12 +18,12 @@ export default async (ctx: MContext, next: Next): Promise<void> => {
     } else {
         try {
             const res = await got(url);
-            ctx.state.feedUrl = decodeURI(res.url); // handle redirect
+            ctx.state.feedUrl = decodeUrl(res.url); // handle redirect
             const feedOption = await isFeedValid(res.body);
             if (isNone(feedOption)) {
                 // feed is NOT valid, try to find feed by link tag with type contain rss/atom
                 ctx.state.feedUrls = await findFeed(res.body, res.url);
-                ctx.state.feedUrls = ctx.state.feedUrls.map(decodeURI);
+                ctx.state.feedUrls = ctx.state.feedUrls.map(decodeUrl);
                 /* eslint no-case-declarations: 0*/
                 switch (ctx.state.feedUrls.length) {
                     case 0:

source/proxies/rss-feed.ts

@@ -3,13 +3,14 @@ import errors from '../utils/errors';
 import { Feed } from '../types/feed';
 import { Subscribe } from '../types/subscribe';
 import { isSome, Option, Optional, Some } from '../types/option';
+import { decodeUrl } from '../utils/decodeUrl';
 
 export async function sub(
     userId: number,
     feedUrl: string,
     feedTitle: string
 ): Promise<string> {
-    feedUrl = decodeURI(feedUrl);
+    feedUrl = decodeUrl(feedUrl);
     const feed = await db<Feed>('rss_feed').where('url', feedUrl).first();
     if (feed) {
         const res = await db<Subscribe>('subscribes')
@@ -211,6 +212,7 @@ export async function handleRedirect(
     realUrl: string
 ): Promise<void> {
     try {
+        realUrl = decodeUrl(realUrl);
         const oldFeed: Option<Feed> = Optional(
             await db<Feed>('rss_feed').where('url', url).first()
         );

source/utils/decodeUrl.ts

@@ -0,0 +1,6 @@
+export function decodeUrl(url) {
+    while (url !== decodeURIComponent(url)) {
+        url = decodeURIComponent(url);
+    }
+    return url;
+}

source/utils/fetch.ts

@@ -60,7 +60,7 @@ async function fetch(feedModal: Feed): Promise<Option<any[]>> {
         logger.debug(`fetching ${feedUrl}`);
         const res = await got.get(encodeURI(feedUrl));
         if (encodeURI(feedUrl) !== res.url && Object.is(res.statusCode, 301)) {
-            await handleRedirect(feedUrl, decodeURI(res.url));
+            await handleRedirect(feedUrl, res.url);
         }
         const feed = await parseString(res.body);