From 08ba99552007e5f8e21a1f1813fbd8a220d6a0d9 Mon Sep 17 00:00:00 2001
From: corbz <corbz.jones@gmail.com>
Date: Sun, 11 Feb 2024 23:52:32 +0000
Subject: [PATCH] Working on new db model integration

---
 src/api.py            |  288 ++++++++--
 src/extensions/rss.py | 1205 ++++++++++++++++++++++++-----------------
 src/feed.py           |   72 +++
 3 files changed, 1025 insertions(+), 540 deletions(-)

diff --git a/src/api.py b/src/api.py
index b7996a2..5ced5ea 100644
--- a/src/api.py
+++ b/src/api.py
@@ -39,6 +39,10 @@ class API:
     RSS_FEED_ENDPOINT = API_ENDPOINT + "rssfeed/"
     FEED_CHANNEL_ENDPOINT = API_ENDPOINT + "feedchannel/"
 
+    SUBSCRIPTION_ENDPOINT = API_ENDPOINT + "subscription/"
+    CHANNEL_ENDPOINT = SUBSCRIPTION_ENDPOINT + "channel/"
+    TRACKED_ENDPOINT = API_ENDPOINT + "tracked/"
+
     def __init__(self, api_token: str, session: aiohttp.ClientSession):
         log.debug("API session initialised")
         self.session = session
@@ -69,72 +73,262 @@ class API:
 
         return {"json": json, "text": text, "status": status}
 
-    async def create_new_rssfeed(self, name: str, url: str, image_url: str, discord_server_id: int) -> dict:
-        """Create a new RSS Feed.
+    async def _post_data(self, url: str, data: dict | aiohttp.FormData) -> dict:
+        return await self.make_request(
+            method="POST",
+            url=url,
+            data=data
+        )
 
-        Args:
-            name (str): Name of the RSS Feed.
-            url (str): URL for the RSS Feed.
-            image_url (str): URL of the image representation of the RSS Feed.
-            discord_server_id (int): ID of the discord server behind this item.
+    async def _put_data(self, url: str, data: dict | aiohttp.FormData) -> dict:
+        return await self.make_request(
+            method="PUT",
+            url=url,
+            data=data
+        )
 
-        Returns:
-            dict: JSON representation of the newly created RSS Feed.
+    async def _get_one(self, url: str) -> dict:
+        return await self.make_request(
+            method="GET",
+            url=url
+        )
+
+    async def _get_many(self, url: str, filters: dict) -> tuple[list[dict], int]:
+        data = await self.make_request(
+            method="GET",
+            url=url,
+            params=filters
+        )
+        content = data["json"]
+        return content["results"], content["count"]
+
+    async def _delete(self, url: str) -> None:
+        await self.make_request(
+            method="DELETE",
+            url=url
+        )
+
+    async def create_subscription(self, name: str, rss_url: str, image_url: str, server_id: str) -> dict:
+        """
+        Create a new Subscription.
         """
 
-        log.debug("creating rssfeed: %s %s %s %s", name, url, image_url, discord_server_id)
+        log.debug("subscribing '%s' to '%s'", server_id, rss_url)
 
         async with self.session.get(image_url) as response:
             image_data = await response.read()
 
-        # Using formdata to make the image transfer easier.
-        form = aiohttp.FormData({
-            "name": name,
-            "url": url,
-            "discord_server_id": str(discord_server_id)
-        })
+        form = aiohttp.FormData()
+        form.add_field("name", name)
+        form.add_field("rss_url", rss_url)
+        form.add_field("server", server_id)
         form.add_field("image", image_data, filename="file.jpg")
 
-        data = (await self.make_request("POST", self.RSS_FEED_ENDPOINT, data=form))["json"]
-        return data
+        data = await self._post_data(self.SUBSCRIPTION_ENDPOINT, form)
 
-    async def get_rssfeed(self, uuid: str) -> dict:
-        """Get a particular RSS Feed given it's UUID.
+        return data["json"]
 
-        Args:
-            uuid (str): Identifier of the desired RSS Feed.
-
-        Returns:
-            dict: A JSON representation of the RSS Feed.
+    async def get_subscription(self, uuid: str) -> dict:
+        """
+        Retreive a Subscription.
         """
 
-        log.debug("getting rssfeed: %s", uuid)
-        endpoint = f"{self.RSS_FEED_ENDPOINT}/{uuid}/"
-        data = (await self.make_request("GET", endpoint))["json"]
-        return data
+        log.debug("retreiving subscription '%s'", uuid)
 
-    async def get_rssfeed_list(self, **filters) -> tuple[list[dict], int]:
-        """Get all RSS Feeds with the associated filters.
+        url=f"{self.SUBSCRIPTION_ENDPOINT}{uuid}/"
+        data = await self._get_one(url)
 
-        Returns:
-            tuple[list[dict], int] list contains dictionaries of each item, int is total items.
+        return data["json"]
+
+    async def get_subscriptions(self, **filters) -> tuple[list[dict], int]:
+        """
+        Retreive multiple Subscriptions.
         """
 
-        log.debug("getting list of rss feeds with filters: %s", filters)
-        data = (await self.make_request("GET", self.RSS_FEED_ENDPOINT, params=filters))["json"]
-        return data["results"], data["count"]
+        log.debug("retreiving multiple subscriptions")
 
-    async def delete_rssfeed(self, uuid: str) -> int:
-        """Delete a specified RSS Feed.
+        return await self._get_many(self.SUBSCRIPTION_ENDPOINT, filters)
 
-        Args:
-            uuid (str): Identifier of the RSS Feed to delete.
-
-        Returns:
-            int: Status code of the response.
+    async def delete_subscription(self, uuid: str) -> None:
+        """
+        Delete an existing Subscription.
         """
 
-        log.debug("deleting rssfeed: %s", uuid)
-        endpoint = f"{self.RSS_FEED_ENDPOINT}/{uuid}/"
-        status = (await self.make_request("DELETE", endpoint))["status"]
-        return status
+        log.debug("deleting subscription '%s'", uuid)
+
+        url=f"{self.SUBSCRIPTION_ENDPOINT}{uuid}/"
+        await self._delete(url)
+
+    async def create_subscription_channel(self, channel_id: int | str, sub_uuid: str) -> dict:
+        """
+        Create a new Channel.
+        """
+
+        log.debug("creating new subscription channel '%s', '%s'", channel_id, sub_uuid)
+
+        form = aiohttp.FormData()
+        form.add_field("id", str(channel_id))
+        form.add_field("subscription", sub_uuid)
+
+        data = await self._post_data(self.CHANNEL_ENDPOINT, form)
+
+        return data["json"]
+
+    async def get_subscription_channel(self, uuid: str) -> dict:
+        """
+        Retreive a Channel.
+        """
+
+        log.debug("retreiving a subscription channel '%s'", uuid)
+
+        url = f"{self.CHANNEL_ENDPOINT}{uuid}/"
+        data = await self._get_one(url)
+
+        return data["json"]
+
+    async def get_subscription_channels(self, **filters) -> tuple[list[dict], int]:
+        """
+        Retreive multiple Channels.
+        """
+
+        log.debug("retreiving multiple channels")
+
+        return await self._get_many(self.CHANNEL_ENDPOINT, filters)
+
+    async def delete_subscription_channel(self, uuid: str) -> None:
+        """
+        Delete an existing Channel.
+        """
+
+        log.debug("deleting channel '%s'", uuid)
+
+        url=f"{self.CHANNEL_ENDPOINT}{uuid}/"
+        await self._delete(url)
+
+    async def create_tracked_content(self, sub_uuid: str, content_url: str) -> dict:
+        """
+        Create a Tracked Content.
+        """
+
+        log.debug("creating tracked content '%s', '%s'", sub_uuid, content_url)
+
+        form = aiohttp.FormData()
+        form.add_field("subscription", sub_uuid)
+        form.add_field("content_url", content_url)
+
+        data = await self._post_data(self.TRACKED_ENDPOINT, form)
+
+        return data["json"]
+
+    async def get_tracked_content(self, uuid: str = None, content_url: str = None) -> dict:
+        """
+        Retreive a Tracked Content.
+        """
+
+        log.debug("retreiving tracked content '%s', '%s'", uuid, content_url)
+
+        if not (uuid or content_url) or (uuid and content_url):
+            raise ValueError(
+                "Must use only 'uuid' or 'content_url' arguments, cannot use "
+                "both arguments or none."
+            )
+
+        url = f"{self.TRACKED_ENDPOINT}{uuid or content_url}/"
+        data = await self._get_one(url)
+
+        return data["json"]
+
+    async def get_tracked_contents(self, **filters) -> tuple[list[dict], int]:
+        """
+        Retreive multiple Tracked Content.
+        """
+
+        log.debug("retreiving multiple tracked content")
+
+        return await self._get_many(self.TRACKED_ENDPOINT, filters)
+
+    async def delete_tracked_content(self, uuid: str) -> None:
+        """
+        Delete a Tracked Content.
+        """
+
+        log.debug("deleting tracked content '%s'", uuid)
+
+        url = f"{self.TRACKED_ENDPOINT}{uuid}/"
+        await self._delete(url)
+
+    async def is_tracked(self, content_url: str) -> bool:
+        """
+        Returns boolean if an item with the given url exists.
+        """
+        raise NotImplementedError
+
+    # async def create_new_rssfeed(self, name: str, url: str, image_url: str, discord_server_id: int) -> dict:
+    #     """Create a new RSS Feed.
+
+    #     Args:
+    #         name (str): Name of the RSS Feed.
+    #         url (str): URL for the RSS Feed.
+    #         image_url (str): URL of the image representation of the RSS Feed.
+    #         discord_server_id (int): ID of the discord server behind this item.
+
+    #     Returns:
+    #         dict: JSON representation of the newly created RSS Feed.
+    #     """
+
+    #     log.debug("creating rssfeed: %s %s %s %s", name, url, image_url, discord_server_id)
+
+    #     async with self.session.get(image_url) as response:
+    #         image_data = await response.read()
+
+    #     # Using formdata to make the image transfer easier.
+    #     form = aiohttp.FormData({
+    #         "name": name,
+    #         "url": url,
+    #         "discord_server_id": str(discord_server_id)
+    #     })
+    #     form.add_field("image", image_data, filename="file.jpg")
+
+    #     data = (await self.make_request("POST", self.RSS_FEED_ENDPOINT, data=form))["json"]
+    #     return data
+
+    # async def get_rssfeed(self, uuid: str) -> dict:
+    #     """Get a particular RSS Feed given it's UUID.
+
+    #     Args:
+    #         uuid (str): Identifier of the desired RSS Feed.
+
+    #     Returns:
+    #         dict: A JSON representation of the RSS Feed.
+    #     """
+
+    #     log.debug("getting rssfeed: %s", uuid)
+    #     endpoint = f"{self.RSS_FEED_ENDPOINT}/{uuid}/"
+    #     data = (await self.make_request("GET", endpoint))["json"]
+    #     return data
+
+    # async def get_rssfeed_list(self, **filters) -> tuple[list[dict], int]:
+    #     """Get all RSS Feeds with the associated filters.
+
+    #     Returns:
+    #         tuple[list[dict], int] list contains dictionaries of each item, int is total items.
+    #     """
+
+    #     log.debug("getting list of rss feeds with filters: %s", filters)
+    #     data = (await self.make_request("GET", self.RSS_FEED_ENDPOINT, params=filters))["json"]
+    #     return data["results"], data["count"]
+
+    # async def delete_rssfeed(self, uuid: str) -> int:
+    #     """Delete a specified RSS Feed.
+
+    #     Args:
+    #         uuid (str): Identifier of the RSS Feed to delete.
+
+    #     Returns:
+    #         int: Status code of the response.
+    #     """
+
+    #     log.debug("deleting rssfeed: %s", uuid)
+    #     endpoint = f"{self.RSS_FEED_ENDPOINT}/{uuid}/"
+    #     status = (await self.make_request("DELETE", endpoint))["status"]
+    #     return status
diff --git a/src/extensions/rss.py b/src/extensions/rss.py
index cbd0b68..7bec1ed 100644
--- a/src/extensions/rss.py
+++ b/src/extensions/rss.py
@@ -5,18 +5,19 @@ Loading this file via `commands.Bot.load_extension` will add `FeedCog` to the bo
 
 import logging
 from typing import Tuple
+from dataclasses import asdict
 
 import aiohttp
 import validators
 from feedparser import FeedParserDict, parse
 from discord.ext import commands
 from discord import Interaction, Embed, Colour, TextChannel, Permissions
-from discord.app_commands import Choice, Group, autocomplete, choices, rename
+from discord.app_commands import Choice, Group, autocomplete, choices, rename, command
 from sqlalchemy import insert, select, and_, delete
 from sqlalchemy.exc import NoResultFound, IntegrityError
 
 from api import API
-from feed import  Source, RSSFeed
+from feed import  Source, RSSFeed, Subscription, SubscriptionChannel, TrackedContent
 from errors import IllegalFeed
 from db import (
     DatabaseManager,
@@ -124,580 +125,798 @@ class FeedCog(commands.Cog):
 
         log.info("%s cog is ready", self.__class__.__name__)
 
-    async def autocomplete_rssfeed(self, inter: Interaction, name: str) -> list[Choice]:
+    # async def autocomplete_channels(self, inter: Interaction, name: str) -> list[Choice]:
+    #     """"""
 
-        async with aiohttp.ClientSession() as session:
-            data, _ = await API(self.bot.api_token, session).get_rssfeed_list(
-                discord_server_id=inter.guild_id
-            )
-            rssfeeds = RSSFeed.from_list(data)
+    #     log.debug("autocompleting channels '%s'", name)
 
-        choices = [
-            Choice(name=item.name, value=item.uuid)
-            for item in rssfeeds
+    #     try:
+    #         async with aiohttp.ClientSession() as session:
+    #             api = API(self.bot.api_token, session)
+    #             results, _ = await api.get_channel(server=inter.guild_id)
+
+    #     except Exception as exc:
+    #         log.error(exc)
+    #         return []
+
+    #     channels = Channel.from_list(results)
+
+    #     return [
+    #         Choice(name=channel.get_textchannel(self.bot).name, value=channel.id)
+    #         for channel in channels
+    #     ]
+
+    async def autocomplete_subscriptions(self, inter: Interaction, name: str) -> list[Choice]:
+        """"""
+
+        log.debug("autocompleting subscriptions '%s'", name)
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                api = API(self.bot.api_token, session)
+                results, _ = await api.get_subscriptions(server=inter.guild_id, search=name)
+
+        except Exception as exc:
+            log.error(exc)
+            return []
+
+        subscriptions = Subscription.from_list(results)
+
+        return [
+            Choice(name=sub.name, value=sub.uuid)
+            for sub in subscriptions
         ]
 
-        return choices
+    # channel_group = Group(
+    #     name="channels",
+    #     description="channel commands",
+    #     guild_only=True
+    # )
 
-    async def source_autocomplete(self, inter: Interaction, nickname: str):
-        """Provides RSS source autocomplete functionality for commands.
+    # @channel_group.command(name="add")
+    # @autocomplete(sub_uuid=autocomplete_subscriptions)
+    # @rename(sub_uuid="subscription", textchannel="channel")
+    # async def new_channel(self, inter: Interaction, sub_uuid: str, textchannel: TextChannel):
+    #     """Create a new channel."""
 
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        nickname : str
-            _description_
+    #     await inter.response.defer()
 
-        Returns
-        -------
-        list of app_commands.Choice
-            _description_
-        """
+    #     try:
+    #         async with aiohttp.ClientSession() as session:
+    #             api = API(self.bot.api_token, session)
+    #             await api.create_channel(textchannel.id)
+    #             # sub = await api.get_subscription(sub_uuid)
+    #             # sub["channels"].append(textchannel.id)
+    #             # await api.put_subscription(sub_uuid, sub)
 
-        async with DatabaseManager() as database:
-            whereclause = and_(
-                RssSourceModel.discord_server_id == inter.guild_id,
-                RssSourceModel.nick.ilike(f"%{nickname}%")
-            )
-            query = select(RssSourceModel).where(whereclause).order_by(RssSourceModel.nick)
-            result = await database.session.execute(query)
-            sources = [
-                Choice(name=rss.nick, value=rss.rss_url)
-                for rss in result.scalars().all()
-            ]
+    #     except Exception as exc:
+    #         return await (
+    #             Followup(exc.__class__.__name__, str(exc))
+    #             .error()
+    #             .send(inter)
+    #         )
 
-        return sources
+    #     await (
+    #         Followup("Channel Assigned!")
+    #         .fields(
+    #             subscription=sub_uuid,
+    #             channel=textchannel.mention
+    #         )
+    #         .added()
+    #         .send(inter)
+    #     )
 
-    # All RSS commands belong to this group.
-    feed_group = Group(
-        name="feed",
-        description="Commands for RSS sources.",
-        default_permissions=Permissions.elevated(),
-        guild_only=True  # We store guild IDs in the database, so guild only = True
+    # @channel_group.command(name="remove")
+    # @autocomplete(id=autocomplete_channels)
+    # @rename(id="choice")
+    # async def remove_channel(self, inter: Interaction, id: int):
+    #     """Remove a channel."""
+
+    #     await inter.response.defer()
+
+    #     try:
+    #         async with aiohttp.ClientSession() as session:
+    #             api = API(self.bot.api_token, session)
+    #             await api.delete_channel(id)
+
+    #     except Exception as exc:
+    #         return await (
+    #             Followup(exc.__class__.__name__, str(exc))
+    #             .error()
+    #             .send(inter)
+    #         )
+
+    #     await (
+    #         Followup("Channel Removed!", str(id))
+    #         .trash()
+    #         .send(inter)
+    #     )
+
+    # @channel_group.command(name="list")
+    # async def list_channels(self, inter: Interaction):
+
+    #     log.debug("Listing all subscription channels with this server.")
+
+    #     await inter.response.defer()
+
+    #     page = 1
+    #     pagesize = 10
+
+    #     def formatdata(index, item):
+    #         item = Channel.from_dict(item)
+    #         text_channel = item.get_textchannel(self.bot)
+
+    #         key = f"{index}. {text_channel.mention}"
+    #         value = f"[RSS]({item.rss_url}) · [API]({API.CHANNEL_ENDPOINT}{item.uuid}/)"
+    #         return key, value
+
+    #     async def getdata(page):
+    #         async with aiohttp.ClientSession() as session:
+    #             api = API(self.bot.api_token, session)
+    #             return await api.get_subscriptions(
+    #                 server=inter.guild.id, page=page, page_size=pagesize
+    #             )
+
+    #     embed = Followup(f"Subscriptions in {inter.guild.name}").info()._embed
+    #     pagination = PaginationView(self.bot, inter, embed, getdata, formatdata, pagesize, page)
+    #     await pagination.send()
+
+    subscription_group = Group(
+        name="subscriptions",
+        description="subscription commands",
+        guild_only=True
     )
 
-    @feed_group.command(name="new")
-    async def add_rssfeed(self, inter: Interaction, name: str, url: str):
-        """Add a new RSS Feed for this server.
-
-        Args:
-            inter (Interaction): Represents the discord command interaction.
-            name (str): A nickname used to refer to this RSS Feed.
-            url (str): The URL of the RSS Feed.
+    @subscription_group.command(name="link")
+    @autocomplete(sub_uuid=autocomplete_subscriptions)
+    @rename(sub_uuid="subscription")
+    async def link_subscription_to_channel(self, inter: Interaction, sub_uuid: str, channel: TextChannel):
+        """
+        Link Subscription to discord.TextChannel.
         """
 
         await inter.response.defer()
 
         try:
-            rssfeed = await self.bot.functions.create_new_rssfeed(name, url, inter.guild_id)
+            async with aiohttp.ClientSession() as session:
+                api = API(self.bot.api_token, session)
+                data = await api.create_subscription_channel(str(channel.id), sub_uuid)
+
         except Exception as exc:
-            await (
+            return await (
                 Followup(exc.__class__.__name__, str(exc))
                 .error()
                 .send(inter)
             )
-        else:
-            await (
-                Followup("New RSS Feed")
-                .image(rssfeed.image)
-                .fields(uuid=rssfeed.uuid, name=name, url=url)
-                .added()
-                .send(inter)
-            )
 
-    @feed_group.command(name="delete")
-    @autocomplete(uuid=autocomplete_rssfeed)
-    @rename(uuid="rssfeed")
-    async def delete_rssfeed(self, inter: Interaction, uuid: str):
-        """Delete an existing RSS Feed for this server.
+        await (
+            Followup("Linked!")
+            .fields(**data)
+            .added()
+            .send(inter)
+        )
 
-        Args:
-            inter (Interaction): Represents the discord command interaction.
-            uuid (str): The UUID of the 
-        """
+
+    @subscription_group.command(name="add")
+    async def new_subscription(self, inter: Interaction, name: str, rss_url: str):
+        """Subscribe this server to a new RSS Feed."""
 
         await inter.response.defer()
 
         try:
-            rssfeed = await self.bot.functions.delete_rssfeed(uuid)
-        except NoResultFound: 
-            await (
-                Followup(
-                    "Feed Not Found Error",
-                    "A Feed with these parameters could not be found."
-                )
+            parsed_rssfeed = await self.bot.functions.validate_feed(name, rss_url)
+            image_url = parsed_rssfeed.get("feed", {}).get("image", {}).get("href")
+
+            async with aiohttp.ClientSession() as session:
+                api = API(self.bot.api_token, session)
+                data = await api.create_subscription(name, rss_url, image_url, str(inter.guild_id))
+
+        except Exception as exc:
+            return await (
+                Followup(exc.__class__.__name__, str(exc))
                 .error()
                 .send(inter)
             )
-        else:
-            await (
-                Followup("Feed Deleted")
-                .image(rssfeed.image)
-                .fields(uuid=rssfeed.uuid, name=rssfeed.name, url=rssfeed.url)
-                .trash()
+
+        # Omit data we dont want the user to see
+        data.pop("image")
+        data.pop("server")
+        data.pop("creation_datetime")
+
+        # Update keys to be more human readable
+        data["UUID"] = data.pop("uuid")
+        data["url"] = data.pop("rss_url")
+
+        await (
+            Followup("Subscription Added!")
+            .fields(**data)
+            .image(image_url)
+            .added()
+            .send(inter)
+        )
+
+    @subscription_group.command(name="remove")
+    @autocomplete(uuid=autocomplete_subscriptions)
+    @rename(uuid="choice")
+    async def remove_subscriptions(self, inter: Interaction, uuid: str):
+        """Unsubscribe this server from an existing RSS Feed."""
+
+        await inter.response.defer()
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                api = API(self.bot.api_token, session)
+                await api.delete_subscription(uuid)
+
+        except Exception as exc:
+            return await (
+                Followup(exc.__class__.__name__, str(exc))
+                .error()
                 .send(inter)
             )
 
-    @feed_group.command(name="list")
-    async def list_rssfeeds(self, inter: Interaction):
-        """Provides a list of all RSS Feeds
+        await (
+            Followup("Subscription Removed!", uuid)
+            .trash()
+            .send(inter)
+        )
 
-        Args:
-            inter (Interaction): Represents the discord command interaction.
-        """
+    @subscription_group.command(name="list")
+    async def list_subscription(self, inter: Interaction):
+        """List Subscriptions from this server."""
 
         await inter.response.defer()
 
         page = 1
         pagesize = 10
 
-        try:
-            def formatdata(index, item):
-                key = f"{index}. {item.name}"
-                value = f"[RSS]({item.url}) · [API]({API.RSS_FEED_ENDPOINT}{item.uuid}/)"
-                return key, value
+        def formatdata(index, item):
+            item = Subscription.from_dict(item)
+            key = f"{index}. {item.name}"
+            value = f"[RSS]({item.rss_url}) · [API]({API.SUBSCRIPTION_ENDPOINT}{item.uuid}/)"
+            return key, value
 
-            async def getdata(page):
-                data, count =  await self.bot.functions.get_rssfeeds(inter.guild_id, page, pagesize)
-                return data, count
+        async def getdata(page):
+            async with aiohttp.ClientSession() as session:
+                api = API(self.bot.api_token, session)
+                return await api.get_subscriptions(
+                    server=inter.guild.id, page=page, page_size=pagesize
+                )
 
-            embed = Followup(f"Available RSS Feeds in {inter.guild.name}").info()._embed
-            pagination = PaginationView(self.bot, inter, embed, getdata, formatdata, pagesize, 1)
-            await pagination.send()
+        embed = Followup(f"Subscriptions in {inter.guild.name}").info()._embed
+        pagination = PaginationView(self.bot, inter, embed, getdata, formatdata, pagesize, page)
+        await pagination.send()
 
-        except Exception as exc:
-            await (
-                Followup(exc.__class__.__name__, str(exc))
-                .error()
-                .send(inter)
-            )
-
-    # @feed_group.command(name="fetch")
-    # @rename(max_="max")
-    # @autocomplete(rss=source_autocomplete)
-    async def fetch_rss(self, inter: Interaction, rss: str, max_: int=1):
-        """Fetch an item from the specified RSS feed.
-
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        rss : str
-            The RSS feed to fetch from.
-        max_ : int, optional
-            Maximum number of items to fetch, by default 1, limits at 5.
-        """
-
-        await inter.response.defer()
-
-        if max_ > 5:
-            followup(inter, "It looks like you have requested too many articles.\nThe limit is 5")
-            return
-
-        invalid_message, feed = await validate_rss_source("", rss)
-        if invalid_message:
-            await followup(inter, invalid_message)
-            return
-
-        source = Source.from_parsed(feed)
-        articles = source.get_latest_articles(max_)
-
-        if not articles:
-            await followup(inter, "Sorry, I couldn't find any articles from this feed.")
-            return
-
-        async with aiohttp.ClientSession() as session:
-            embeds = [await article.to_embed(session) for article in articles]
-
-        async with DatabaseManager() as database:
-            query = insert(SentArticleModel).values([
-                {
-                    "discord_server_id": inter.guild_id,
-                    "discord_channel_id": inter.channel_id,
-                    "discord_message_id": inter.id,
-                    "article_url": article.url,
-                }
-                for article in articles
-            ])
-            await database.session.execute(query)
-            await audit(self,
-                f"User is requesting {max_} articles from {source.name}",
-                inter.user.id, database=database
-            )
-
-        await followup(inter, embeds=embeds)
-
-    # Help     ---- ---- ----
-
-    @feed_group.command(name="help")
-    async def get_help(self, inter: Interaction):
-        """Get help on how to use my commands.
-
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        """
-
-        await inter.response.defer()
-
-        description = (
-            "`/feed add <nickname> <url>` \n\n"
-            "Save a new RSS feed to the bot. This can be referred to later, when assigning "
-            "channels to receive content from these RSS feeds."
-
-            "\n\n\n`/feed remove <option>` \n\n"
-            "Remove a previously saved RSS feed. Select the nickname from the shown options "
-            "if any. You can re-add the RSS feed to the bot using the `/feeds add` command."
-
-            "\n\n\n`/feed list <sort> <sort_reverse>` \n\n"
-            "List all saved RSS feeds numerically. Use the `<sort>` option to order "
-            "the results by either nickname or date & time added. Use the `<sort_reverse>` "
-            "option to order by ascending or descending in conjunction with the `<sort>` option."
-
-            "\n\n\n`/feed assign <rss> <textchannel>` \n\n"
-            "Assign a channel to an RSS feed. Previously saved RSS feeds will be selectable "
-            "under the `<rss>` option. The channel will be assumed as the current channel, "
-            "unless specified otherwise using the `<textchannel` option."
-
-            "\n\n\n`/feed unassign <option>` \n\n"
-            "Unassigned channel from an RSS feed. Previously assigned channels will be shown "
-            "as an `<option>`, select one to remove it."
-
-            "\n\n\n`/feed channels` \n\n"
-            "List all channels assigned to an RSS feed numerically."
-        )
-
-        embed = Embed(
-            title="Help",
-            description=description,
-            colour=Colour.blue(),
-        )
-
-        await followup(inter, embed=embed)
-
-    # Channels ---- ---- ----
-
-    async def autocomplete_rss_sources(self, inter: Interaction, nickname: str):
-        """_summary_
-
-        Parameters
-        ----------
-        inter : Interaction
-            _description_
-        nickname : str
-            _description_
-
-        Returns
-        -------
-        _type_
-            _description_
-        """
-
-        async with DatabaseManager() as database:
-            whereclause = and_(
-                RssSourceModel.discord_server_id == inter.guild_id,
-                RssSourceModel.nick.ilike(f"%{nickname}%")
-            )
-            query = select(RssSourceModel).where(whereclause)
-            result = await database.session.execute(query)
-            sources = [
-                Choice(name=rss.nick, value=rss.rss_url)
-                for rss in result.scalars().all()
-            ]
-
-        log.debug("Autocomplete rss_sources returned %s results", len(sources))
-
-        return sources
-
-    async def autocomplete_existing_feeds(self, inter: Interaction, current: str):
-        """Returns a list of existing RSS + Channel feeds.
-
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        current : str
-            The current text entered for the autocomplete.
-        """
-
-        async with DatabaseManager() as database:
-            whereclause = and_(
-                FeedChannelModel.discord_server_id == inter.guild_id,
-                FeedChannelModel.search_name.ilike(f"%{current}%"),
-                RssSourceModel.id == FeedChannelModel.rss_source_id
-            )
-            query = (
-                select(FeedChannelModel, RssSourceModel)
-                .where(whereclause)
-                .join(RssSourceModel)
-                .order_by(FeedChannelModel.discord_channel_id)
-            )
-            result = await database.session.execute(query)
-            feeds = []
-            for feed in result.scalars().all():
-                channel = inter.guild.get_channel(feed.discord_channel_id)
-                feeds.append(Choice(
-                    name=f"# {channel.name}  |  {feed.rss_source.nick}",
-                    value=feed.id
-                ))
-
-        log.debug("Autocomplete existing_feeds returned %s results", len(feeds))
-
-        return feeds
 
     # # All RSS commands belong to this group.
-    # channel_group = Group(
-    #     name="channels",
-    #     description="Commands for channel assignment.",
-    #     guild_only=True  # These commands belong to channels of
+    # feed_group = Group(
+    #     name="feed",
+    #     description="Commands for RSS sources.",
+    #     default_permissions=Permissions.elevated(),
+    #     guild_only=True  # We store guild IDs in the database, so guild only = True
     # )
 
-    @feed_group.command(name="assign")
-    @rename(url="feed")
-    @autocomplete(url=autocomplete_rss_sources)
-    async def include_feed(
-        self, inter: Interaction, url: str, channel: TextChannel = None, prevent_spam: bool = True
-    ):
-        """Include a feed within the specified channel.
+    # @feed_group.command(name="new")
+    # async def add_rssfeed(self, inter: Interaction, name: str, url: str):
+    #     """Add a new RSS Feed for this server.
 
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        url : int
-            The RSS feed to include.
-        channel : TextChannel
-            The channel to include the feed in.
-        """
+    #     Args:
+    #         inter (Interaction): Represents the discord command interaction.
+    #         name (str): A nickname used to refer to this RSS Feed.
+    #         url (str): The URL of the RSS Feed.
+    #     """
 
-        await inter.response.defer()
+    #     await inter.response.defer()
 
-        channel = channel or inter.channel
+    #     try:
+    #         rssfeed = await self.bot.functions.create_new_rssfeed(name, url, inter.guild_id)
+    #     except Exception as exc:
+    #         await (
+    #             Followup(exc.__class__.__name__, str(exc))
+    #             .error()
+    #             .send(inter)
+    #         )
+    #     else:
+    #         await (
+    #             Followup("New RSS Feed")
+    #             .image(rssfeed.image)
+    #             .fields(uuid=rssfeed.uuid, name=name, url=url)
+    #             .added()
+    #             .send(inter)
+    #         )
 
-        try:
-            feed_id, source = await self.bot.functions.assign_feed(
-                url, channel.name, channel.id, inter.guild_id
-            )
-        except IntegrityError:
-            await (
-                Followup(
-                    "Duplicate Assigned Feed Error",
-                    f"This Feed has already been assigned to {channel.mention}"
-                )
-                .error()
-                .send(inter)
-            )
-        except NoResultFound:
-            await (
-                Followup(
-                    "Feed Not Found Error",
-                    "A Feed with these parameters could not be found."
-                )
-                .error()
-                .send(inter)
-            )
-        else:
-            await (
-                Followup(
-                    "Feed Assigned",
-                    f"I've assigned {channel.mention} to receive content from "
-                    f"[{source.name}]({source.url})."
-                )
-                .assign()
-                .send(inter)
-            )
+    # @feed_group.command(name="delete")
+    # @autocomplete(uuid=autocomplete_rssfeed)
+    # @rename(uuid="rssfeed")
+    # async def delete_rssfeed(self, inter: Interaction, uuid: str):
+    #     """Delete an existing RSS Feed for this server.
 
-        if prevent_spam:
-            await set_all_articles_as_sent(inter, channel, feed_id, url)
+    #     Args:
+    #         inter (Interaction): Represents the discord command interaction.
+    #         uuid (str): The UUID of the 
+    #     """
 
-    @feed_group.command(name="unassign")
-    @autocomplete(option=autocomplete_existing_feeds)
-    async def exclude_feed(self, inter: Interaction, option: int):
-        """Undo command for the `/channel include-feed` command.
+    #     await inter.response.defer()
 
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        option : str
-            The RSS feed and channel to exclude.
-        """
+    #     try:
+    #         rssfeed = await self.bot.functions.delete_rssfeed(uuid)
+    #     except NoResultFound: 
+    #         await (
+    #             Followup(
+    #                 "Feed Not Found Error",
+    #                 "A Feed with these parameters could not be found."
+    #             )
+    #             .error()
+    #             .send(inter)
+    #         )
+    #     else:
+    #         await (
+    #             Followup("Feed Deleted")
+    #             .image(rssfeed.image)
+    #             .fields(uuid=rssfeed.uuid, name=rssfeed.name, url=rssfeed.url)
+    #             .trash()
+    #             .send(inter)
+    #         )
 
-        await inter.response.defer()
+    # @feed_group.command(name="list")
+    # async def list_rssfeeds(self, inter: Interaction):
+    #     """Provides a list of all RSS Feeds
 
-        try:
-            await self.bot.functions.unassign_feed(option, inter.guild_id)
-        except NoResultFound:
-            await (
-                Followup(
-                    "Assigned Feed Not Found",
-                    "The assigned Feed doesn't exist."
-                )
-                .error()
-                .send(inter)
-            )
-        else:
-            await (
-                Followup(
-                    "Unassigned Feed",
-                    "Feed has been unassigned."                                                                                                                       
-                )
-                .trash()
-                .send(inter)
-            )
+    #     Args:
+    #         inter (Interaction): Represents the discord command interaction.
+    #     """
 
-        # async with DatabaseManager() as database:
-        #     query = delete(FeedChannelModel).where(and_(
-        #         FeedChannelModel.id == option,
-        #         FeedChannelModel.discord_server_id == inter.guild_id
-        #     ))
+    #     await inter.response.defer()
 
-        #     result = await database.session.execute(query)
+    #     page = 1
+    #     pagesize = 10
 
-        # if not result.rowcount:
-        #     await followup_error(inter,
-        #         title="Assigned Feed Not Found",
-        #         message=f"I couldn't find any assigned feeds for the option: {option}"
-        #     )
-        #     return
+    #     try:
+    #         def formatdata(index, item):
+    #             key = f"{index}. {item.name}"
+    #             value = f"[RSS]({item.url}) · [API]({API.RSS_FEED_ENDPOINT}{item.uuid}/)"
+    #             return key, value
 
-        await followup(inter, "I've removed this item (placeholder response)")
+    #         async def getdata(page):
+    #             data, count =  await self.bot.functions.get_rssfeeds(inter.guild_id, page, pagesize)
+    #             return data, count
 
-    @feed_group.command(name="channels")
-    @choices(sort=channels_list_sort_choices)
-    async def list_feeds(self, inter: Interaction, sort: Choice[int] = 0, sort_reverse: bool = False):
-        """List all of the channels and their respective included feeds.
+    #         embed = Followup(f"Available RSS Feeds in {inter.guild.name}").info()._embed
+    #         pagination = PaginationView(self.bot, inter, embed, getdata, formatdata, pagesize, 1)
+    #         await pagination.send()
 
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        """
+    #     except Exception as exc:
+    #         await (
+    #             Followup(exc.__class__.__name__, str(exc))
+    #             .error()
+    #             .send(inter)
+    #         )
 
-        await inter.response.defer()
+    # # @feed_group.command(name="fetch")
+    # # @rename(max_="max")
+    # # @autocomplete(rss=source_autocomplete)
+    # async def fetch_rss(self, inter: Interaction, rss: str, max_: int=1):
+    #     """Fetch an item from the specified RSS feed.
 
-        description = "Sort By "
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         Represents an app command interaction.
+    #     rss : str
+    #         The RSS feed to fetch from.
+    #     max_ : int, optional
+    #         Maximum number of items to fetch, by default 1, limits at 5.
+    #     """
 
-        if isinstance(sort, Choice):
-            match sort.value, sort_reverse:
-                case 0, False:
-                    order_by = RssSourceModel.nick.asc()
-                    description += "Nickname "
-                case 0, True:
-                    order_by = RssSourceModel.nick.desc()
-                    description += "Nickname "
-                case 1, False:
-                    order_by = FeedChannelModel.discord_channel_id.asc()
-                    description += "Channel ID "
-                case 1, True:
-                    order_by = FeedChannelModel.discord_channel_id.desc()
-                    description += "Channel ID "
-                case 2, False:
-                    order_by = RssSourceModel.created.desc()
-                    description += "Date Added "
-                case 2, True:
-                    order_by = RssSourceModel.created.asc()
-                    description += "Date Added "
-                case _, _:
-                    raise ValueError(f"Unknown sort: {sort}")
-        else:
-            order_by = FeedChannelModel.discord_channel_id.asc()
-            description = ""
+    #     await inter.response.defer()
 
-        async with DatabaseManager() as database:
-            whereclause = and_(
-                FeedChannelModel.discord_server_id == inter.guild_id,
-                RssSourceModel.id == FeedChannelModel.rss_source_id
-            )
-            query = (
-                select(FeedChannelModel, RssSourceModel)
-                .where(whereclause)
-                .join(RssSourceModel)
-                .order_by(order_by)
-            )
-            result = await database.session.execute(query)
+    #     if max_ > 5:
+    #         followup(inter, "It looks like you have requested too many articles.\nThe limit is 5")
+    #         return
 
-            feed_channels = result.scalars().all()
-            rowcount = len(feed_channels)
+    #     invalid_message, feed = await validate_rss_source("", rss)
+    #     if invalid_message:
+    #         await followup(inter, invalid_message)
+    #         return
 
-            if not feed_channels:
-                await followup_error(inter,
-                    title="No Assigned Feeds Found",
-                    message="Assign a channel to receive feed content with `/feed assign`."
-                )
-                return
+    #     source = Source.from_parsed(feed)
+    #     articles = source.get_latest_articles(max_)
 
-            output = "\n".join([
-                f"{i}. <#{feed.discord_channel_id}> · "  # TODO: add icon indicating inaccessible channel, if is the case.
-                f"[{feed.rss_source.nick}]({feed.rss_source.rss_url})"
-                for i, feed in enumerate(feed_channels)
-            ])
+    #     if not articles:
+    #         await followup(inter, "Sorry, I couldn't find any articles from this feed.")
+    #         return
 
-        embed = Embed(
-            title="Saved Feed Channels",
-            description=f"{description}\n{output}",
-            colour=Colour.blue()
-        )
-        embed.set_footer(text=f"Showing {rowcount} results")
+    #     async with aiohttp.ClientSession() as session:
+    #         embeds = [await article.to_embed(session) for article in articles]
 
-        await followup(inter, embed=embed)
+    #     async with DatabaseManager() as database:
+    #         query = insert(SentArticleModel).values([
+    #             {
+    #                 "discord_server_id": inter.guild_id,
+    #                 "discord_channel_id": inter.channel_id,
+    #                 "discord_message_id": inter.id,
+    #                 "article_url": article.url,
+    #             }
+    #             for article in articles
+    #         ])
+    #         await database.session.execute(query)
+    #         await audit(self,
+    #             f"User is requesting {max_} articles from {source.name}",
+    #             inter.user.id, database=database
+    #         )
 
-    admin_group = Group(
-        name="admin",
-        description="Administration tasks",
-        guild_only=True,
-        default_permissions=Permissions.elevated()
-    )
+    #     await followup(inter, embeds=embeds)
 
-    @admin_group.command(name="clear-sent-articles")
-    async def clear_sent_articles(self, inter: Interaction):
-        """Clear the database of all sent articles.
+    # # Help     ---- ---- ----
 
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        """
+    # @feed_group.command(name="help")
+    # async def get_help(self, inter: Interaction):
+    #     """Get help on how to use my commands.
 
-        await inter.response.defer()
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         Represents an app command interaction.
+    #     """
 
-        async with DatabaseManager() as database:
-            query = delete(SentArticleModel).where(and_(
-                SentArticleModel.discord_server_id == inter.guild_id
-            ))
-            result = await database.session.execute(query)
+    #     await inter.response.defer()
 
-        await followup(inter,
-            f"{result.rowcount} sent articles have been cleared from the database. "
-            "I will no longer recognise these articles as sent, and will send them "
-            "again if they appear during the next RSS feed scan."
-        )
+    #     description = (
+    #         "`/feed add <nickname> <url>` \n\n"
+    #         "Save a new RSS feed to the bot. This can be referred to later, when assigning "
+    #         "channels to receive content from these RSS feeds."
 
-    audit_group = Group(
-        name="audit",
-        description="Check audited actions.",
-        guild_only=True,
-        default_permissions=Permissions.elevated()
-    )
+    #         "\n\n\n`/feed remove <option>` \n\n"
+    #         "Remove a previously saved RSS feed. Select the nickname from the shown options "
+    #         "if any. You can re-add the RSS feed to the bot using the `/feeds add` command."
 
-    @audit_group.command(name="check")
-    async def check_audit_log(self, inter: Interaction):
-        """Check the audit log.
+    #         "\n\n\n`/feed list <sort> <sort_reverse>` \n\n"
+    #         "List all saved RSS feeds numerically. Use the `<sort>` option to order "
+    #         "the results by either nickname or date & time added. Use the `<sort_reverse>` "
+    #         "option to order by ascending or descending in conjunction with the `<sort>` option."
 
-        Parameters
-        ----------
-        inter : Interaction
-            Represents an app command interaction.
-        """
+    #         "\n\n\n`/feed assign <rss> <textchannel>` \n\n"
+    #         "Assign a channel to an RSS feed. Previously saved RSS feeds will be selectable "
+    #         "under the `<rss>` option. The channel will be assumed as the current channel, "
+    #         "unless specified otherwise using the `<textchannel` option."
 
-        await inter.response.defer()
+    #         "\n\n\n`/feed unassign <option>` \n\n"
+    #         "Unassigned channel from an RSS feed. Previously assigned channels will be shown "
+    #         "as an `<option>`, select one to remove it."
 
-        async with DatabaseManager() as database:
-            query = select(AuditModel).where(and_(
-            ))
-            result = await database.session.execute(query)
+    #         "\n\n\n`/feed channels` \n\n"
+    #         "List all channels assigned to an RSS feed numerically."
+    #     )
+
+    #     embed = Embed(
+    #         title="Help",
+    #         description=description,
+    #         colour=Colour.blue(),
+    #     )
+
+    #     await followup(inter, embed=embed)
+
+    # # Channels ---- ---- ----
+
+    # async def autocomplete_rss_sources(self, inter: Interaction, nickname: str):
+    #     """_summary_
+
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         _description_
+    #     nickname : str
+    #         _description_
+
+    #     Returns
+    #     -------
+    #     _type_
+    #         _description_
+    #     """
+
+    #     async with DatabaseManager() as database:
+    #         whereclause = and_(
+    #             RssSourceModel.discord_server_id == inter.guild_id,
+    #             RssSourceModel.nick.ilike(f"%{nickname}%")
+    #         )
+    #         query = select(RssSourceModel).where(whereclause)
+    #         result = await database.session.execute(query)
+    #         sources = [
+    #             Choice(name=rss.nick, value=rss.rss_url)
+    #             for rss in result.scalars().all()
+    #         ]
+
+    #     log.debug("Autocomplete rss_sources returned %s results", len(sources))
+
+    #     return sources
+
+    # async def autocomplete_existing_feeds(self, inter: Interaction, current: str):
+    #     """Returns a list of existing RSS + Channel feeds.
+
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         Represents an app command interaction.
+    #     current : str
+    #         The current text entered for the autocomplete.
+    #     """
+
+    #     async with DatabaseManager() as database:
+    #         whereclause = and_(
+    #             FeedChannelModel.discord_server_id == inter.guild_id,
+    #             FeedChannelModel.search_name.ilike(f"%{current}%"),
+    #             RssSourceModel.id == FeedChannelModel.rss_source_id
+    #         )
+    #         query = (
+    #             select(FeedChannelModel, RssSourceModel)
+    #             .where(whereclause)
+    #             .join(RssSourceModel)
+    #             .order_by(FeedChannelModel.discord_channel_id)
+    #         )
+    #         result = await database.session.execute(query)
+    #         feeds = []
+    #         for feed in result.scalars().all():
+    #             channel = inter.guild.get_channel(feed.discord_channel_id)
+    #             feeds.append(Choice(
+    #                 name=f"# {channel.name}  |  {feed.rss_source.nick}",
+    #                 value=feed.id
+    #             ))
+
+    #     log.debug("Autocomplete existing_feeds returned %s results", len(feeds))
+
+    #     return feeds
+
+    # # # All RSS commands belong to this group.
+    # # channel_group = Group(
+    # #     name="channels",
+    # #     description="Commands for channel assignment.",
+    # #     guild_only=True  # These commands belong to channels of
+    # # )
+
+    # @feed_group.command(name="assign")
+    # @rename(url="feed")
+    # @autocomplete(url=autocomplete_rss_sources)
+    # async def include_feed(
+    #     self, inter: Interaction, url: str, channel: TextChannel = None, prevent_spam: bool = True
+    # ):
+    #     """Include a feed within the specified channel.
+
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         Represents an app command interaction.
+    #     url : int
+    #         The RSS feed to include.
+    #     channel : TextChannel
+    #         The channel to include the feed in.
+    #     """
+
+    #     await inter.response.defer()
+
+    #     channel = channel or inter.channel
+
+    #     try:
+    #         feed_id, source = await self.bot.functions.assign_feed(
+    #             url, channel.name, channel.id, inter.guild_id
+    #         )
+    #     except IntegrityError:
+    #         await (
+    #             Followup(
+    #                 "Duplicate Assigned Feed Error",
+    #                 f"This Feed has already been assigned to {channel.mention}"
+    #             )
+    #             .error()
+    #             .send(inter)
+    #         )
+    #     except NoResultFound:
+    #         await (
+    #             Followup(
+    #                 "Feed Not Found Error",
+    #                 "A Feed with these parameters could not be found."
+    #             )
+    #             .error()
+    #             .send(inter)
+    #         )
+    #     else:
+    #         await (
+    #             Followup(
+    #                 "Feed Assigned",
+    #                 f"I've assigned {channel.mention} to receive content from "
+    #                 f"[{source.name}]({source.url})."
+    #             )
+    #             .assign()
+    #             .send(inter)
+    #         )
+
+    #     if prevent_spam:
+    #         await set_all_articles_as_sent(inter, channel, feed_id, url)
+
+    # @feed_group.command(name="unassign")
+    # @autocomplete(option=autocomplete_existing_feeds)
+    # async def exclude_feed(self, inter: Interaction, option: int):
+    #     """Undo command for the `/channel include-feed` command.
+
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         Represents an app command interaction.
+    #     option : str
+    #         The RSS feed and channel to exclude.
+    #     """
+
+    #     await inter.response.defer()
+
+    #     try:
+    #         await self.bot.functions.unassign_feed(option, inter.guild_id)
+    #     except NoResultFound:
+    #         await (
+    #             Followup(
+    #                 "Assigned Feed Not Found",
+    #                 "The assigned Feed doesn't exist."
+    #             )
+    #             .error()
+    #             .send(inter)
+    #         )
+    #     else:
+    #         await (
+    #             Followup(
+    #                 "Unassigned Feed",
+    #                 "Feed has been unassigned."                                                                                                                       
+    #             )
+    #             .trash()
+    #             .send(inter)
+    #         )
+
+    #     # async with DatabaseManager() as database:
+    #     #     query = delete(FeedChannelModel).where(and_(
+    #     #         FeedChannelModel.id == option,
+    #     #         FeedChannelModel.discord_server_id == inter.guild_id
+    #     #     ))
+
+    #     #     result = await database.session.execute(query)
+
+    #     # if not result.rowcount:
+    #     #     await followup_error(inter,
+    #     #         title="Assigned Feed Not Found",
+    #     #         message=f"I couldn't find any assigned feeds for the option: {option}"
+    #     #     )
+    #     #     return
+
+    #     await followup(inter, "I've removed this item (placeholder response)")
+
+    # @feed_group.command(name="channels")
+    # @choices(sort=channels_list_sort_choices)
+    # async def list_feeds(self, inter: Interaction, sort: Choice[int] = 0, sort_reverse: bool = False):
+    #     """List all of the channels and their respective included feeds.
+
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         Represents an app command interaction.
+    #     """
+
+    #     await inter.response.defer()
+
+    #     description = "Sort By "
+
+    #     if isinstance(sort, Choice):
+    #         match sort.value, sort_reverse:
+    #             case 0, False:
+    #                 order_by = RssSourceModel.nick.asc()
+    #                 description += "Nickname "
+    #             case 0, True:
+    #                 order_by = RssSourceModel.nick.desc()
+    #                 description += "Nickname "
+    #             case 1, False:
+    #                 order_by = FeedChannelModel.discord_channel_id.asc()
+    #                 description += "Channel ID "
+    #             case 1, True:
+    #                 order_by = FeedChannelModel.discord_channel_id.desc()
+    #                 description += "Channel ID "
+    #             case 2, False:
+    #                 order_by = RssSourceModel.created.desc()
+    #                 description += "Date Added "
+    #             case 2, True:
+    #                 order_by = RssSourceModel.created.asc()
+    #                 description += "Date Added "
+    #             case _, _:
+    #                 raise ValueError(f"Unknown sort: {sort}")
+    #     else:
+    #         order_by = FeedChannelModel.discord_channel_id.asc()
+    #         description = ""
+
+    #     async with DatabaseManager() as database:
+    #         whereclause = and_(
+    #             FeedChannelModel.discord_server_id == inter.guild_id,
+    #             RssSourceModel.id == FeedChannelModel.rss_source_id
+    #         )
+    #         query = (
+    #             select(FeedChannelModel, RssSourceModel)
+    #             .where(whereclause)
+    #             .join(RssSourceModel)
+    #             .order_by(order_by)
+    #         )
+    #         result = await database.session.execute(query)
+
+    #         feed_channels = result.scalars().all()
+    #         rowcount = len(feed_channels)
+
+    #         if not feed_channels:
+    #             await followup_error(inter,
+    #                 title="No Assigned Feeds Found",
+    #                 message="Assign a channel to receive feed content with `/feed assign`."
+    #             )
+    #             return
+
+    #         output = "\n".join([
+    #             f"{i}. <#{feed.discord_channel_id}> · "  # TODO: add icon indicating inaccessible channel, if is the case.
+    #             f"[{feed.rss_source.nick}]({feed.rss_source.rss_url})"
+    #             for i, feed in enumerate(feed_channels)
+    #         ])
+
+    #     embed = Embed(
+    #         title="Saved Feed Channels",
+    #         description=f"{description}\n{output}",
+    #         colour=Colour.blue()
+    #     )
+    #     embed.set_footer(text=f"Showing {rowcount} results")
+
+    #     await followup(inter, embed=embed)
+
+    # admin_group = Group(
+    #     name="admin",
+    #     description="Administration tasks",
+    #     guild_only=True,
+    #     default_permissions=Permissions.elevated()
+    # )
+
+    # @admin_group.command(name="clear-sent-articles")
+    # async def clear_sent_articles(self, inter: Interaction):
+    #     """Clear the database of all sent articles.
+
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         Represents an app command interaction.
+    #     """
+
+    #     await inter.response.defer()
+
+    #     async with DatabaseManager() as database:
+    #         query = delete(SentArticleModel).where(and_(
+    #             SentArticleModel.discord_server_id == inter.guild_id
+    #         ))
+    #         result = await database.session.execute(query)
+
+    #     await followup(inter,
+    #         f"{result.rowcount} sent articles have been cleared from the database. "
+    #         "I will no longer recognise these articles as sent, and will send them "
+    #         "again if they appear during the next RSS feed scan."
+    #     )
+
+    # audit_group = Group(
+    #     name="audit",
+    #     description="Check audited actions.",
+    #     guild_only=True,
+    #     default_permissions=Permissions.elevated()
+    # )
+
+    # @audit_group.command(name="check")
+    # async def check_audit_log(self, inter: Interaction):
+    #     """Check the audit log.
+
+    #     Parameters
+    #     ----------
+    #     inter : Interaction
+    #         Represents an app command interaction.
+    #     """
+
+    #     await inter.response.defer()
+
+    #     async with DatabaseManager() as database:
+    #         query = select(AuditModel).where(and_(
+    #         ))
+    #         result = await database.session.execute(query)
 
 
 async def setup(bot):
diff --git a/src/feed.py b/src/feed.py
index afc1818..a2b3878 100644
--- a/src/feed.py
+++ b/src/feed.py
@@ -4,6 +4,7 @@ import json
 import logging
 from dataclasses import dataclass
 from datetime import datetime
+from abc import ABC, abstractmethod
 
             
 import aiohttp
@@ -228,6 +229,77 @@ class RSSFeed:
         return cls(**data)
 
 
+DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
+
+
+@dataclass
+class DjangoDataModel(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def parser(item: dict) -> dict:
+        """Overwrite this method to parse types, otherwise every attr is of type string."""
+        return item
+
+    @classmethod
+    def from_list(cls, data: list[dict]) -> list:
+        return [cls(**cls.parser(item)) for item in data]
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**cls.parser(data))
+
+
+@dataclass
+class Subscription(DjangoDataModel):
+
+    uuid: str
+    name: str
+    rss_url: str
+    image_url: str
+    creation_datetime: datetime
+    server: int
+
+    @staticmethod
+    def parser(item: dict) -> dict:
+
+        item["image_url"] = item.pop("image")
+        item["creation_datetime"] = datetime.strptime(item["creation_datetime"], DATETIME_FORMAT)
+        item["server"] = int(item["server"])
+        return item
+
+
+@dataclass
+class SubscriptionChannel(DjangoDataModel):
+
+    uuid: str
+    id: int
+    subscription: str
+    creation_datetime: datetime
+
+    @staticmethod
+    def parser(item: dict) -> dict:
+        
+        item["id"] = int(item["id"])
+        item["creation_datetime"] = datetime.strptime(item["creation_datetime"], DATETIME_FORMAT)
+        return item
+
+
+@dataclass
+class TrackedContent(DjangoDataModel):
+
+    uuid: str
+    subscription: str
+    content_url: str
+    creation_datetime: datetime
+
+    @staticmethod
+    def parser(item: dict) -> dict:
+
+        item["creation_datetime"] = datetime.strptime(item["creation_datetime"], DATETIME_FORMAT)
+        return item
+
+
 class Functions:
 
     def __init__(self, bot, api_token: str):