src/accounting/locale.py

@@ -39,17 +39,6 @@ def gettext(string, **variables) -> str:
     return domain.gettext(string, **variables)
 
 
-def pgettext(context, string, **variables) -> str:
-    """A replacement of the Babel gettext() function..
-
-    :param context: The context.
-    :param string: The message to translate.
-    :param variables: The variable substitution.
-    :return: The translated message.
-    """
-    return domain.pgettext(context, string, **variables)
-
-
 def lazy_gettext(string, **variables) -> LazyString:
     """A replacement of the Babel lazy_gettext() function..
 

src/accounting/templates/accounting/account/list.html

@@ -21,7 +21,7 @@ First written: 2023/1/30
 #}
 {% extends "accounting/base.html" %}
 
-{% block header %}{% block title %}{% if "q" in request.args %}{{ A_("Search Result for \"%(query)s\"", query=request.args["q"]) }}{% else %}{{ A_("Account Management") }}{% endif %}{% endblock %}{% endblock %}
+{% block header %}{% block title %}{{ A_("Account Management") }}{% endblock %}{% endblock %}
 
 {% block content %}
 

src/accounting/templates/accounting/base-account/list.html

@@ -21,7 +21,7 @@ First written: 2023/1/26
 #}
 {% extends "accounting/base.html" %}
 
-{% block header %}{% block title %}{% if "q" in request.args %}{{ A_("Search Result for \"%(query)s\"", query=request.args["q"]) }}{% else %}{{ A_("Base Account Managements") }}{% endif %}{% endblock %}{% endblock %}
+{% block header %}{% block title %}{{ A_("Base Account Managements") }}{% endblock %}{% endblock %}
 
 {% block content %}
 

src/accounting/templates/accounting/include/pagination.html

@@ -19,10 +19,10 @@ pagination.html: The pagination navigation bar.
 Author: imacat@mail.imacat.idv.tw (imacat)
 First written: 2023/1/26
 #}
-{% if pagination.is_paged %}
+{% if pagination.is_needed %}
   <nav aria-label="Page navigation">
     <ul class="pagination">
-      {% for link in pagination.pages %}
+      {% for link in pagination.page_links %}
         {% if link.uri is none %}
           <li class="page-item disabled {% if not link.is_for_mobile %} d-none d-md-inline {% endif %}">
             <span class="page-link">
@@ -42,7 +42,7 @@ First written: 2023/1/26
           {{ pagination.page_size }}
         </div>
         <ul class="dropdown-menu">
-          {% for link in pagination.page_size_options %}
+          {% for link in pagination.page_sizes %}
             <li>
               <a class="dropdown-item {% if link.is_current %} active {% endif %}" href="{{ link.uri }}">
                 {{ link.text }}

src/accounting/translations/zh_Hant/LC_MESSAGES/accounting.po

@@ -8,8 +8,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Mia! Accounting Flask 0.0.0\n"
 "Report-Msgid-Bugs-To: imacat@mail.imacat.idv.tw\n"
-"POT-Creation-Date: 2023-02-06 09:47+0800\n"
-"PO-Revision-Date: 2023-02-06 09:48+0800\n"
+"POT-Creation-Date: 2023-02-03 10:15+0800\n"
+"PO-Revision-Date: 2023-02-03 10:16+0800\n"
 "Last-Translator: imacat <imacat@mail.imacat.idv.tw>\n"
 "Language: zh_Hant\n"
 "Language-Team: zh_Hant <imacat@mail.imacat.idv.tw>\n"
@@ -33,7 +33,7 @@ msgid "Please fill in the title"
 msgstr "請填上標題。"
 
 #: src/accounting/account/query.py:50
-#: src/accounting/templates/accounting/account/detail.html:90
+#: src/accounting/templates/accounting/account/detail.html:88
 #: src/accounting/templates/accounting/account/list.html:62
 msgid "Offset needed"
 msgstr "逐筆核銷"
@@ -81,36 +81,36 @@ msgstr "回上頁"
 msgid "Settings"
 msgstr "設定"
 
-#: src/accounting/templates/accounting/account/detail.html:41
+#: src/accounting/templates/accounting/account/detail.html:40
 msgid "Order"
 msgstr "次序"
 
-#: src/accounting/templates/accounting/account/detail.html:46
+#: src/accounting/templates/accounting/account/detail.html:44
 msgid "Delete"
 msgstr "刪除"
 
-#: src/accounting/templates/accounting/account/detail.html:69
+#: src/accounting/templates/accounting/account/detail.html:67
 msgid "Delete Account Confirmation"
 msgstr "科目刪除確認"
 
-#: src/accounting/templates/accounting/account/detail.html:73
+#: src/accounting/templates/accounting/account/detail.html:71
 msgid "Do you really want to delete this account?"
 msgstr "你確定要刪掉這個科目嗎？"
 
-#: src/accounting/templates/accounting/account/detail.html:76
+#: src/accounting/templates/accounting/account/detail.html:74
 #: src/accounting/templates/accounting/account/include/form.html:111
 msgid "Cancel"
 msgstr "取消"
 
-#: src/accounting/templates/accounting/account/detail.html:77
+#: src/accounting/templates/accounting/account/detail.html:75
 msgid "Confirm"
 msgstr "確定"
 
-#: src/accounting/templates/accounting/account/detail.html:94
+#: src/accounting/templates/accounting/account/detail.html:92
 msgid "Created"
 msgstr "建檔"
 
-#: src/accounting/templates/accounting/account/detail.html:95
+#: src/accounting/templates/accounting/account/detail.html:93
 msgid "Updated"
 msgstr "更新"
 
@@ -119,12 +119,6 @@ msgstr "更新"
 msgid "%(account)s Settings"
 msgstr "%(account)s設定"
 
-#: src/accounting/templates/accounting/account/list.html:24
-#: src/accounting/templates/accounting/base-account/list.html:24
-#, python-format
-msgid "Search Result for \"%(query)s\""
-msgstr "「%(query)s」搜尋結果"
-
 #: src/accounting/templates/accounting/account/list.html:24
 msgid "Account Management"
 msgstr "科目管理"
@@ -140,7 +134,6 @@ msgid "Search"
 msgstr "搜尋"
 
 #: src/accounting/templates/accounting/account/list.html:68
-#: src/accounting/templates/accounting/account/order.html:81
 #: src/accounting/templates/accounting/base-account/list.html:51
 msgid "There is no data."
 msgstr "沒有資料。"
@@ -151,7 +144,7 @@ msgid "The Accounts of %(base)s"
 msgstr "%(base)s下的科目"
 
 #: src/accounting/templates/accounting/account/include/form.html:75
-#: src/accounting/templates/accounting/account/order.html:62
+#: src/accounting/templates/accounting/account/order.html:61
 msgid "Save"
 msgstr "儲存"
 
@@ -196,13 +189,11 @@ msgstr "科目"
 msgid "Base Accounts"
 msgstr "基本科目"
 
-#: src/accounting/utils/pagination.py:206
-msgctxt "Pagination|"
+#: src/accounting/utils/pagination.py:146
 msgid "Previous"
-msgstr "上一頁"
+msgstr "前一頁"
 
-#: src/accounting/utils/pagination.py:255
-msgctxt "Pagination|"
+#: src/accounting/utils/pagination.py:194
 msgid "Next"
 msgstr "下一頁"
 

src/accounting/utils/pagination.py

@@ -26,11 +26,11 @@ from urllib.parse import urlparse, parse_qsl, urlencode, urlunparse, \
 from flask import request
 from werkzeug.routing import RequestRedirect
 
-from accounting.locale import gettext, pgettext
+from accounting.locale import gettext
 
 
-class Link:
-    """A link."""
+class PageLink:
+    """A link in the pagination."""
 
     def __init__(self, text: str, uri: str | None = None,
                  is_current: bool = False, is_for_mobile: bool = False):
@@ -59,14 +59,15 @@ class Redirection(RequestRedirect):
     """The HTTP code."""
 
 
-DEFAULT_PAGE_SIZE: int = 10
-"""The default page size."""
-
 T = t.TypeVar("T")
 
 
 class Pagination(t.Generic[T]):
-    """The pagination utility."""
+    """The pagination utilities"""
+    AVAILABLE_PAGE_SIZES: list[int] = [10, 100, 200]
+    """The available page sizes."""
+    DEFAULT_PAGE_SIZE: int = 10
+    """The default page size."""
 
     def __init__(self, items: list[T], is_reversed: bool = False):
         """Constructs the pagination.
@@ -74,80 +75,36 @@ class Pagination(t.Generic[T]):
         :param items: The items.
         :param is_reversed: True if the default page is the last page, or False
             otherwise.
-        :raise Redirection: When the pagination parameters are malformed.
         """
-        pagination: AbstractPagination[T] = EmptyPagination[T]() \
-            if len(items) == 0 \
-            else NonEmptyPagination[T](items, is_reversed)
-        self.is_paged: bool = pagination.is_paged
-        """Whether there should be pagination."""
-        self.list: list[T] = pagination.list
-        """The items shown in the list"""
-        self.pages: list[Link] = pagination.pages
-        """The pages."""
-        self.page_size: int = pagination.page_size
-        """The number of items in a page."""
-        self.page_size_options: list[Link] = pagination.page_size_options
-        """The options to the number of items in a page."""
-
-
-class AbstractPagination(t.Generic[T]):
-    """An abstract pagination."""
-
-    def __init__(self):
-        """Constructs an empty pagination."""
-        self.page_size: int = DEFAULT_PAGE_SIZE
-        """The number of items in a page."""
-        self.is_paged: bool = False
-        """Whether there should be pagination."""
-        self.list: list[T] = []
-        """The items shown in the list"""
-        self.pages: list[Link] = []
-        """The pages."""
-        self.page_size_options: list[Link] = []
-        """The options to the number of items in a page."""
-
-
-class EmptyPagination(AbstractPagination[T]):
-    """The pagination from empty data."""
-    pass
-
-
-class NonEmptyPagination(AbstractPagination[T]):
-    """The pagination with real data."""
-    PAGE_SIZE_OPTIONS: list[int] = [10, 100, 200]
-    """The page size options."""
-
-    def __init__(self, items: list[T], is_reversed: bool = False):
-        """Constructs the pagination.
-
-        :param items: The items.
-        :param is_reversed: True if the default page is the last page, or False
-            otherwise.
-        :raise Redirection: When the pagination parameters are malformed.
-        """
-        super().__init__()
         self.__current_uri: str = request.full_path if request.query_string \
             else request.path
         """The current URI."""
+        self.__items: list[T] = items
+        """All the items."""
         self.__is_reversed: bool = is_reversed
         """Whether the default page is the last page."""
-        self.page_size = self.__get_page_size()
-        self.__total_pages: int = int((len(items) - 1) / self.page_size) + 1
+        self.page_size: int = self.__get_page_size()
+        """The number of items in a page."""
+        self.__total_pages: int = 0 if len(items) == 0 \
+            else int((len(items) - 1) / self.page_size) + 1
         """The total number of pages."""
-        self.is_paged = self.__total_pages > 1
-        self.__default_page_no: int = self.__total_pages \
-            if self.__is_reversed else 1
+        self.is_needed: bool = self.__total_pages > 1
+        """Whether there should be pagination."""
+        self.__default_page_no: int = 0
         """The default page number."""
-        self.__page_no: int = self.__get_page_no()
+        self.page_no: int = 0
         """The current page number."""
-        lower_bound: int = (self.__page_no - 1) * self.page_size
-        upper_bound: int = lower_bound + self.page_size
-        if upper_bound > len(items):
-            upper_bound = len(items)
-        self.list = items[lower_bound:upper_bound]
-        self.pages = self.__get_pages()
-        self.page_size_options = self.__get_page_size_options()
+        self.list: list[T] = []
+        """The items shown in the list"""
+        if self.__total_pages > 0:
+            self.__set_list()
+        self.__base_uri_params: tuple[list[str], list[tuple[str, str]]] \
+            = self.__get_base_uri_params()
+        """The base URI parameters."""
+        self.page_links: list[PageLink] = self.__get_page_links()
+        """The pagination links."""
+        self.page_sizes: list[PageLink] = self.__get_page_sizes()
+        """The links to switch the number of items in a page."""
 
     def __get_page_size(self) -> int:
         """Returns the page size.
@@ -156,14 +113,29 @@ class NonEmptyPagination(AbstractPagination[T]):
         :raise Redirection: When the page size is malformed.
         """
         if "page-size" not in request.args:
-            return DEFAULT_PAGE_SIZE
+            return self.DEFAULT_PAGE_SIZE
         try:
-            page_size: int = int(request.args["page-size"])
+            return int(request.args["page-size"])
         except ValueError:
             raise Redirection(self.__uri_set("page-size", None))
-        if page_size == DEFAULT_PAGE_SIZE or page_size < 1:
-            raise Redirection(self.__uri_set("page-size", None))
-        return page_size
+
+    def __set_list(self) -> None:
+        """Sets the items to show in the list.
+
+        :return: None.
+        """
+        self.__default_page_no = self.__total_pages if self.__is_reversed \
+            else 1
+        self.page_no = self.__get_page_no()
+        if self.page_no < 1:
+            self.page_no = 1
+        if self.page_no > self.__total_pages:
+            self.page_no = self.__total_pages
+        lower_bound: int = (self.page_no - 1) * self.page_size
+        upper_bound: int = lower_bound + self.page_size
+        if upper_bound > len(self.__items):
+            upper_bound = len(self.__items)
+        self.list = self.__items[lower_bound:upper_bound]
 
     def __get_page_no(self) -> int:
         """Returns the page number.
@@ -177,8 +149,6 @@ class NonEmptyPagination(AbstractPagination[T]):
             page_no: int = int(request.args["page-no"])
         except ValueError:
             raise Redirection(self.__uri_set("page-no", None))
-        if page_no == self.__default_page_no:
-            raise Redirection(self.__uri_set("page-no", None))
         if page_no < 1:
             if not self.__is_reversed:
                 raise Redirection(self.__uri_set("page-no", None))
@@ -190,108 +160,6 @@ class NonEmptyPagination(AbstractPagination[T]):
                                              str(self.__total_pages)))
         return page_no
 
-    def __get_pages(self) -> list[Link]:
-        """Returns the page links in the pagination navigation.
-
-        :return: The page links in the pagination navigation.
-        """
-        if not self.is_paged:
-            return []
-        uri: str | None
-        links: list[Link] = []
-
-        # The previous page.
-        uri = None if self.__page_no == 1 \
-            else self.__uri_page(self.__page_no - 1)
-        links.append(Link(pgettext("Pagination|", "Previous"), uri,
-                          is_for_mobile=True))
-
-        # The first page.
-        if self.__page_no > 1:
-            links.append(Link("1", self.__uri_page(1)))
-
-        # The eclipse of the previous pages.
-        if self.__page_no - 3 == 2:
-            links.append(Link(str(self.__page_no - 3),
-                              self.__uri_page(self.__page_no - 3)))
-        elif self.__page_no - 3 > 2:
-            links.append(Link("…"))
-
-        # The previous two pages.
-        if self.__page_no - 2 > 1:
-            links.append(Link(str(self.__page_no - 2),
-                              self.__uri_page(self.__page_no - 2)))
-        if self.__page_no - 1 > 1:
-            links.append(Link(str(self.__page_no - 1),
-                              self.__uri_page(self.__page_no - 1)))
-
-        # The current page.
-        links.append(Link(str(self.__page_no), self.__uri_page(self.__page_no),
-                          is_current=True))
-
-        # The next two pages.
-        if self.__page_no + 1 < self.__total_pages:
-            links.append(Link(str(self.__page_no + 1),
-                              self.__uri_page(self.__page_no + 1)))
-        if self.__page_no + 2 < self.__total_pages:
-            links.append(Link(str(self.__page_no + 2),
-                              self.__uri_page(self.__page_no + 2)))
-
-        # The eclipse of the next pages.
-        if self.__page_no + 3 == self.__total_pages - 1:
-            links.append(Link(str(self.__page_no + 3),
-                              self.__uri_page(self.__page_no + 3)))
-        elif self.__page_no + 3 < self.__total_pages - 1:
-            links.append(Link("…"))
-
-        # The last page.
-        if self.__page_no < self.__total_pages:
-            links.append(Link(str(self.__total_pages),
-                              self.__uri_page(self.__total_pages)))
-
-        # The next page.
-        uri = None if self.__page_no == self.__total_pages \
-            else self.__uri_page(self.__page_no + 1)
-        links.append(Link(pgettext("Pagination|", "Next"), uri,
-                          is_for_mobile=True))
-
-        return links
-
-    def __uri_page(self, page_no: int) -> str:
-        """Returns the URI of a page.
-
-        :param page_no: The page number.
-        :return: The URI of the page.
-        """
-        if page_no == self.__page_no:
-            return self.__current_uri
-        if page_no == self.__default_page_no:
-            return self.__uri_set("page-no", None)
-        return self.__uri_set("page-no", str(page_no))
-
-    def __get_page_size_options(self) -> list[Link]:
-        """Returns the page size options.
-
-        :return: The page size options.
-        """
-        if not self.is_paged:
-            return []
-        return [Link(str(x), self.__uri_size(x),
-                     is_current=x == self.page_size)
-                for x in self.PAGE_SIZE_OPTIONS]
-
-    def __uri_size(self, page_size: int) -> str:
-        """Returns the URI of a page size.
-
-        :param page_size: The page size.
-        :return: The URI of the page size.
-        """
-        if page_size == self.page_size:
-            return self.__current_uri
-        if page_size == DEFAULT_PAGE_SIZE:
-            return self.__uri_set("page-size", None)
-        return self.__uri_set("page-size", str(page_size))
-
     def __uri_set(self, name: str, value: str | None) -> str:
         """Raises current URI with a parameter set.
 
@@ -311,11 +179,128 @@ class NonEmptyPagination(AbstractPagination[T]):
                     params = params[:i] + params[i + 1:]
                     continue
                 params[i] = (name, value)
-                is_found = True
             i = i + 1
-        if not is_found and value is not None:
-            params.append((name, value))
 
         parts: list[str] = list(uri_p)
         parts[4] = urlencode(params)
         return urlunparse(parts)
+
+    def __get_base_uri_params(self) -> tuple[list[str], list[tuple[str, str]]]:
+        """Returns the base URI and its parameters, with the "page-no" and
+        "page-size" parameters removed.
+
+        :return: The URI parts and the cleaned-up query parameters.
+        """
+        uri_p: ParseResult = urlparse(self.__current_uri)
+        params: list[tuple[str, str]] = parse_qsl(uri_p.query)
+        params = [x for x in params if x[0] not in ["page-no", "page-size"]]
+        parts: list[str] = list(uri_p)
+        return parts, params
+
+    def __get_page_links(self) -> list[PageLink]:
+        """Returns the page links in the pagination navigation.
+
+        :return: The page links in the pagination navigation.
+        """
+        if self.__total_pages < 2:
+            return []
+        uri: str | None
+        links: list[PageLink] = []
+
+        # The previous page.
+        uri = None if self.page_no == 1 else self.__uri_page(self.page_no - 1)
+        links.append(PageLink(gettext("Previous"), uri, is_for_mobile=True))
+
+        # The first page.
+        if self.page_no > 1:
+            links.append(PageLink("1", self.__uri_page(1)))
+
+        # The eclipse of the previous pages.
+        if self.page_no - 3 == 2:
+            links.append(PageLink(str(self.page_no - 3),
+                                  self.__uri_page(self.page_no - 3)))
+        elif self.page_no - 3 > 2:
+            links.append(PageLink("…"))
+
+        # The previous two pages.
+        if self.page_no - 2 > 1:
+            links.append(PageLink(str(self.page_no - 2),
+                                  self.__uri_page(self.page_no - 2)))
+        if self.page_no - 1 > 1:
+            links.append(PageLink(str(self.page_no - 1),
+                                  self.__uri_page(self.page_no - 1)))
+
+        # The current page.
+        links.append(PageLink(str(self.page_no), self.__uri_page(self.page_no),
+                              is_current=True))
+
+        # The next two pages.
+        if self.page_no + 1 < self.__total_pages:
+            links.append(PageLink(str(self.page_no + 1),
+                                  self.__uri_page(self.page_no + 1)))
+        if self.page_no + 2 < self.__total_pages:
+            links.append(PageLink(str(self.page_no + 2),
+                                  self.__uri_page(self.page_no + 2)))
+
+        # The eclipse of the next pages.
+        if self.page_no + 3 == self.__total_pages - 1:
+            links.append(PageLink(str(self.page_no + 3),
+                                  self.__uri_page(self.page_no + 3)))
+        elif self.page_no + 3 < self.__total_pages - 1:
+            links.append(PageLink("…"))
+
+        # The last page.
+        if self.page_no < self.__total_pages:
+            links.append(PageLink(str(self.__total_pages),
+                                  self.__uri_page(self.__total_pages)))
+
+        # The next page.
+        uri = None if self.page_no == self.__total_pages \
+            else self.__uri_page(self.page_no + 1)
+        links.append(PageLink(gettext("Next"), uri, is_for_mobile=True))
+
+        return links
+
+    def __uri_page(self, page_no: int) -> str:
+        """Returns the URI of a page.
+
+        :param page_no: The page number.
+        :return: The URI of the page.
+        """
+        params: list[tuple[str, str]] = []
+        if page_no != self.__default_page_no:
+            params.append(("page-no", str(page_no)))
+        if self.page_size != self.DEFAULT_PAGE_SIZE:
+            params.append(("page-size", str(self.page_size)))
+        return self.__uri_set_params(params)
+
+    def __get_page_sizes(self) -> list[PageLink]:
+        """Returns the available page sizes.
+
+        :return: The available page sizes.
+        """
+        return [PageLink(str(x), self.__uri_size(x),
+                         is_current=x == self.page_size)
+                for x in self.AVAILABLE_PAGE_SIZES]
+
+    def __uri_size(self, page_size: int) -> str:
+        """Returns the URI of a page size.
+
+        :param page_size: The page size.
+        :return: The URI of the page size.
+        """
+        if page_size == self.page_size:
+            return self.__current_uri
+        return self.__uri_set_params([("page-size", str(page_size))])
+
+    def __uri_set_params(self, params: list[tuple[str, str]]) -> str:
+        """Returns the URI with the query parameters set.
+
+        :param params: The query parameters.
+        :return: The URI with the query parameters set.
+        """
+        cur_params: list[tuple[str, str]] = self.__base_uri_params[1].copy()
+        cur_params.extend(params)
+        parts: list[str] = self.__base_uri_params[0].copy()
+        parts[4] = urlencode(cur_params)
+        return urlunparse(parts)

src/accounting/utils/query.py

@@ -34,22 +34,11 @@ def parse_query_keywords(q: str | None) -> list[str]:
     if q == "":
         return []
     keywords: list[str] = []
-    while True:
-        m: re.Match
-        m = re.match(r"\"([^\"]+)\"\s+(.+)$", q)
-        if m is not None:
+    while q is not None:
+        m: re.Match = re.match(r"(?:\"([^\"]+)\"|(\S+))(?:\s+(.+)|)$", q)
+        if m.group(1) is not None:
             keywords.append(m.group(1))
-            q = m.group(2)
-            continue
-        m = re.match(r"\"([^\"]+)\"?$", q)
-        if m is not None:
-            keywords.append(m.group(1))
-            break
-        m = re.match(r"(\S+)\s+(.+)$", q)
-        if m is not None:
-            keywords.append(m.group(1))
-            q = m.group(2)
-            continue
-        keywords.append(q)
-        break
+        else:
+            keywords.append(m.group(2))
+        q = m.group(3)
     return keywords

tests/test_utils.py

@@ -24,9 +24,10 @@ import httpx
 from flask import Flask, request
 
 from accounting.utils.next_url import append_next, inherit_next, or_next
-from accounting.utils.pagination import Pagination, DEFAULT_PAGE_SIZE
+from accounting.utils.pagination import Pagination
 from accounting.utils.query import parse_query_keywords
-from test_site import create_app, csrf
+from test_site import create_app
+from testlib import get_csrf_token
 
 
 class NextUriTestCase(unittest.TestCase):
@@ -41,7 +42,6 @@ class NextUriTestCase(unittest.TestCase):
         target: str = "/target"
 
         @app.route("/test-next", methods=["GET", "POST"])
-        @csrf.exempt
         def test_next_view() -> str:
             """The test view with the next URI."""
             current_uri: str = request.full_path if request.query_string \
@@ -56,7 +56,6 @@ class NextUriTestCase(unittest.TestCase):
             return ""
 
         @app.route("/test-no-next", methods=["GET", "POST"])
-        @csrf.exempt
         def test_no_next_view() -> str:
             """The test view without the next URI."""
             current_uri: str = request.full_path if request.query_string \
@@ -70,19 +69,22 @@ class NextUriTestCase(unittest.TestCase):
         client: httpx.Client = httpx.Client(app=app,
                                             base_url="https://testserver")
         client.headers["Referer"] = "https://testserver"
+        csrf_token: str = get_csrf_token(self, client, "/login")
         response: httpx.Response
 
         # With the next URI
         response = client.get("/test-next?next=/next&q=abc&page-no=4")
         self.assertEqual(response.status_code, 200)
-        response = client.post("/test-next", data={"next": "/next",
+        response = client.post("/test-next", data={"csrf_token": csrf_token,
+                                                   "next": "/next",
                                                    "name": "viewer"})
         self.assertEqual(response.status_code, 200)
 
         # Without the next URI
         response = client.get("/test-no-next?q=abc&page-no=4")
         self.assertEqual(response.status_code, 200)
-        response = client.post("/test-no-next", data={"name": "viewer"})
+        response = client.post("/test-no-next", data={"csrf_token": csrf_token,
+                                                      "name": "viewer"})
         self.assertEqual(response.status_code, 200)
 
 
@@ -98,21 +100,16 @@ class QueryKeywordParserTestCase(unittest.TestCase):
         self.assertEqual(parse_query_keywords("coffee tea"), ["coffee", "tea"])
         self.assertEqual(parse_query_keywords("\"coffee\" \"tea cake\""),
                          ["coffee", "tea cake"])
-        self.assertEqual(parse_query_keywords("\"coffee tea\" cheese "
-                                              "\"cake candy\" sugar"),
-                         ["coffee tea", "cheese", "cake candy", "sugar"])
 
     def test_malformed(self) -> None:
         """Tests the malformed query.
 
         :return: None.
         """
-        self.assertEqual(parse_query_keywords("coffee \"tea cake"),
-                         ["coffee", "tea cake"])
         self.assertEqual(parse_query_keywords("coffee te\"a ca\"ke"),
                          ["coffee", "te\"a", "ca\"ke"])
-        self.assertEqual(parse_query_keywords("coffee\" tea cake\""),
-                         ["coffee\"", "tea", "cake\""])
+        self.assertEqual(parse_query_keywords("coffee \"tea cake"),
+                         ["coffee", "\"tea", "cake"])
 
     def test_empty(self) -> None:
         """Tests the empty query.
@@ -130,18 +127,18 @@ class PaginationTestCase(unittest.TestCase):
         """The testing parameters."""
 
         def __init__(self, items: list[int], is_reversed: bool | None,
-                     result: list[int], is_paged: bool):
+                     result: list[int], is_needed: bool):
             """Constructs the expected pagination.
 
             :param items: All the items in the list.
             :param is_reversed: Whether the default page is the last page.
             :param result: The expected items on the page.
-            :param is_paged: Whether the pagination is needed.
+            :param is_needed: Whether the pagination is needed.
             """
             self.items: list[int] = items
             self.is_reversed: bool | None = is_reversed
             self.result: list[int] = result
-            self.is_paged: bool = is_paged
+            self.is_needed: bool = is_needed
 
     def setUp(self) -> None:
         """Sets up the test.
@@ -157,11 +154,11 @@ class PaginationTestCase(unittest.TestCase):
             """The test view with the pagination."""
             pagination: Pagination
             if self.params.is_reversed is not None:
-                pagination = Pagination[int](
-                    self.params.items, is_reversed=self.params.is_reversed)
+                pagination = Pagination(self.params.items,
+                                        is_reversed=self.params.is_reversed)
             else:
-                pagination = Pagination[int](self.params.items)
-            self.assertEqual(pagination.is_paged, self.params.is_paged)
+                pagination = Pagination(self.params.items)
+            self.assertEqual(pagination.is_needed, self.params.is_needed)
             self.assertEqual(pagination.list, self.params.result)
             return ""
 
@@ -169,14 +166,14 @@ class PaginationTestCase(unittest.TestCase):
         self.client.headers["Referer"] = "https://testserver"
 
     def __test_success(self, query: str, items: range,
-                       result: range, is_paged: bool = True,
+                       result: range, is_needed: bool = True,
                        is_reversed: bool | None = None) -> None:
         """Tests the pagination.
 
         :param query: The query string.
         :param items: The original items.
         :param result: The expected page content.
-        :param is_paged: Whether the pagination is needed.
+        :param is_needed: Whether the pagination is needed.
         :param is_reversed: Whether the list is reversed.
         :return: None.
         """
@@ -184,7 +181,7 @@ class PaginationTestCase(unittest.TestCase):
         if query != "":
             target = f"{target}?{query}"
         self.params = self.Params(list(items), is_reversed,
-                                  list(result), is_paged)
+                                  list(result), is_needed)
         response: httpx.Response = self.client.get(target)
         self.assertEqual(response.status_code, 200)
 
@@ -237,12 +234,12 @@ class PaginationTestCase(unittest.TestCase):
         :return: None.
         """
         # Empty list
-        self.__test_success("", range(0, 0), range(0, 0), is_paged=False)
+        self.__test_success("", range(0, 0), range(0, 0), is_needed=False)
         # A list that fits in one page
-        self.__test_success("", range(1, 4), range(1, 4), is_paged=False)
+        self.__test_success("", range(1, 4), range(1, 4), is_needed=False)
         # A large page size that fits in everything
         self.__test_success("page-size=1000", range(1, 687), range(1, 687),
-                            is_paged=False)
+                            is_needed=False)
 
     def test_reversed(self) -> None:
         """Tests the default page on a reversed list.
@@ -274,23 +271,9 @@ class PaginationTestCase(unittest.TestCase):
         # A malformed page size
         self.__test_malformed("q=word&page-size=100a&page-no=37&next=%2F",
                               range(1, 691), "q=word&page-no=37&next=%2F")
-        # A default page size
-        self.__test_malformed(f"q=word&page-size={DEFAULT_PAGE_SIZE}"
-                              "&page-no=37&next=%2F",
-                              range(1, 691), "q=word&page-no=37&next=%2F")
-        # An invalid page size
-        self.__test_malformed("q=word&page-size=0&page-no=37&next=%2F",
-                              range(1, 691), "q=word&page-no=37&next=%2F")
         # A malformed page number
         self.__test_malformed("q=word&page-size=15&page-no=37a&next=%2F",
                               range(1, 691), "q=word&page-size=15&next=%2F")
-        # A default page number
-        self.__test_malformed("q=word&page-size=15&page-no=1&next=%2F",
-                              range(1, 691), "q=word&page-size=15&next=%2F")
-        # A default page number, on a reversed list
-        self.__test_malformed("q=word&page-size=15&page-no=46&next=%2F",
-                              range(1, 691), "q=word&page-size=15&next=%2F",
-                              is_reversed=True)
         # A page number beyond the last page
         self.__test_malformed("q=word&page-size=15&page-no=100&next=%2F",
                               range(1, 691),