No content available.
"
- )
+ text: str = replace_tags_in_text_message(entry) or "No content available.
"
published = ""
if entry.published:
published: str = entry.published.strftime("%Y-%m-%d %H:%M:%S")
blacklisted: str = ""
- if entry_is_blacklisted(entry, reader=reader):
+ if entry_is_blacklisted(entry):
blacklisted = "Blacklisted"
whitelisted: str = ""
- if entry_is_whitelisted(entry, reader=reader):
+ if entry_is_whitelisted(entry):
whitelisted = "Whitelisted"
- source_feed_url: str = getattr(entry, "original_feed_url", None) or entry.feed.url
-
- from_another_feed: str = ""
- if current_feed_url and source_feed_url != current_feed_url:
- from_another_feed = f"From another feed: {source_feed_url}"
-
- # Add feed link when viewing from webhook_entries or aggregated views
- feed_link: str = ""
- if not current_feed_url or source_feed_url != current_feed_url:
- encoded_feed_url: str = urllib.parse.quote(source_feed_url)
- feed_title: str = entry.feed.title if hasattr(entry.feed, "title") and entry.feed.title else source_feed_url
- feed_link = (
- f"{feed_title}" - ) - entry_id: str = urllib.parse.quote(entry.id) - encoded_source_feed_url: str = urllib.parse.quote(source_feed_url) - to_discord_html: str = ( - f"" - "Send to Discord" - ) - - # Check if this is a YouTube feed entry and the entry has a link - is_youtube_feed = "youtube.com/feeds/videos.xml" in entry.feed.url - video_embed_html = "" - - if is_youtube_feed and entry.link: - # Extract the video ID and create an embed if possible - video_id: str | None = extract_youtube_video_id(entry.link) - if video_id: - video_embed_html: str = f""" -
-
-
- """
- # Don't use the first image if we have a video embed
- first_image = ""
-
+ to_discord_html: str = f"Send to Discord"
image_html: str = f"
-{blacklisted}{whitelisted}{from_another_feed}
-""" # noqa: E501
+"""
return html.strip()
@@ -1169,7 +736,6 @@ def get_data_from_hook_url(hook_name: str, hook_url: str) -> WebhookInfo:
hook_name (str): The webhook name.
hook_url (str): The webhook URL.
-
Returns:
WebhookInfo: The webhook username, avatar, guild id, etc.
"""
@@ -1190,64 +756,12 @@ def get_data_from_hook_url(hook_name: str, hook_url: str) -> WebhookInfo:
return our_hook
-@app.get("/settings", response_class=HTMLResponse)
-async def get_settings(
- request: Request,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
-):
- """Settings page.
-
- Args:
- request: The request object.
- reader: The Reader instance.
-
- Returns:
- HTMLResponse: The settings page.
- """
- # Get the global default update interval
- global_interval: int = 60 # Default to 60 minutes if not set
- global_update_config = reader.get_tag((), ".reader.update", None)
- if isinstance(global_update_config, dict) and "interval" in global_update_config:
- interval_value = global_update_config["interval"]
- if isinstance(interval_value, int):
- global_interval = interval_value
-
- # Get all feeds with their intervals
- feeds: Iterable[Feed] = reader.get_feeds()
- feed_intervals = []
- for feed in feeds:
- feed_interval: int | None = None
- feed_update_config = reader.get_tag(feed, ".reader.update", None)
- if isinstance(feed_update_config, dict) and "interval" in feed_update_config:
- interval_value = feed_update_config["interval"]
- if isinstance(interval_value, int):
- feed_interval = interval_value
-
- feed_intervals.append({
- "feed": feed,
- "interval": feed_interval,
- "effective_interval": feed_interval or global_interval,
- "domain": extract_domain(feed.url),
- })
-
- context = {
- "request": request,
- "global_interval": global_interval,
- "feed_intervals": feed_intervals,
- }
- return templates.TemplateResponse(request=request, name="settings.html", context=context)
-
-
@app.get("/webhooks", response_class=HTMLResponse)
-async def get_webhooks(
- request: Request,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
-):
+async def get_webhooks(request: Request):
"""Page for adding a new webhook.
Args:
request: The request object.
- reader: The Reader instance.
Returns:
HTMLResponse: The add webhook page.
@@ -1268,241 +782,136 @@ async def get_webhooks(
@app.get("/", response_class=HTMLResponse)
-def get_index(
- request: Request,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
- message: str = "",
-):
+def get_index(request: Request):
"""This is the root of the website.
Args:
request: The request object.
- message: Optional message to display to the user.
- reader: The Reader instance.
Returns:
HTMLResponse: The index page.
"""
- return templates.TemplateResponse(
- request=request,
- name="index.html",
- context=make_context_index(request, message, reader),
- )
+ return templates.TemplateResponse(request=request, name="index.html", context=make_context_index(request))
-def make_context_index(request: Request, message: str = "", reader: Reader | None = None):
+def make_context_index(request: Request):
"""Create the needed context for the index page.
Args:
request: The request object.
- message: Optional message to display to the user.
- reader: The Reader instance.
Returns:
dict: The context for the index page.
"""
- effective_reader: Reader = reader or get_reader_dependency()
- hooks: list[dict[str, str]] = cast("list[dict[str, str]]", list(effective_reader.get_tag((), "webhooks", [])))
+ hooks: list[dict[str, str]] = cast("list[dict[str, str]]", list(reader.get_tag((), "webhooks", [])))
- feed_list: list[dict[str, JSONType | Feed | str]] = []
- broken_feeds: list[Feed] = []
- feeds_without_attached_webhook: list[Feed] = []
+ feed_list = []
+ broken_feeds = []
+ feeds_without_attached_webhook = []
- # Get all feeds and organize them
- feeds: Iterable[Feed] = effective_reader.get_feeds()
+ feeds: Iterable[Feed] = reader.get_feeds()
for feed in feeds:
- webhook: str = str(effective_reader.get_tag(feed.url, "webhook", ""))
- if not webhook:
+ try:
+ webhook = reader.get_tag(feed.url, "webhook")
+ feed_list.append({"feed": feed, "webhook": webhook})
+ except TagNotFoundError:
broken_feeds.append(feed)
continue
- feed_list.append({"feed": feed, "webhook": webhook, "domain": extract_domain(feed.url)})
-
- webhook_list: list[str] = [hook["url"] for hook in hooks]
+ webhook_list = [hook["url"] for hook in hooks]
if webhook not in webhook_list:
feeds_without_attached_webhook.append(feed)
return {
"request": request,
"feeds": feed_list,
- "feed_count": effective_reader.get_feed_counts(),
- "entry_count": effective_reader.get_entry_counts(),
+ "feed_count": reader.get_feed_counts(),
+ "entry_count": reader.get_entry_counts(),
"webhooks": hooks,
"broken_feeds": broken_feeds,
"feeds_without_attached_webhook": feeds_without_attached_webhook,
- "messages": message or None,
}
@app.post("/remove", response_class=HTMLResponse)
-async def remove_feed(
- feed_url: Annotated[str, Form()],
- reader: Annotated[Reader, Depends(get_reader_dependency)],
-):
+async def remove_feed(feed_url: Annotated[str, Form()]):
"""Get a feed by URL.
Args:
feed_url: The feed to add.
- reader: The Reader instance.
-
- Returns:
- RedirectResponse: Redirect to the index page.
Raises:
HTTPException: Feed not found
+
+ Returns:
+ RedirectResponse: Redirect to the index page.
"""
try:
reader.delete_feed(urllib.parse.unquote(feed_url))
except FeedNotFoundError as e:
raise HTTPException(status_code=404, detail="Feed not found") from e
- commit_state_change(reader, f"Remove feed {urllib.parse.unquote(feed_url)}")
-
return RedirectResponse(url="/", status_code=303)
-@app.get("/update", response_class=HTMLResponse)
-async def update_feed(
- request: Request,
- feed_url: str,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
-):
- """Update a feed.
-
- Args:
- request: The request object.
- feed_url: The feed URL to update.
- reader: The Reader instance.
-
- Returns:
- RedirectResponse: Redirect to the feed page.
-
- Raises:
- HTTPException: If the feed is not found.
- """
- try:
- reader.update_feed(urllib.parse.unquote(feed_url))
- except FeedNotFoundError as e:
- raise HTTPException(status_code=404, detail="Feed not found") from e
-
- logger.info("Manually updated feed: %s", feed_url)
- return RedirectResponse(url="/feed?feed_url=" + urllib.parse.quote(feed_url), status_code=303)
-
-
-@app.post("/backup")
-async def manual_backup(
- request: Request,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
-) -> RedirectResponse:
- """Manually trigger a git backup of the current state.
-
- Args:
- request: The request object.
- reader: The Reader instance.
-
- Returns:
- RedirectResponse: Redirect to the index page with a success or error message.
- """
- backup_path = get_backup_path()
- if backup_path is None:
- message = "Git backup is not configured. Set GIT_BACKUP_PATH environment variable to enable backups."
- logger.warning("Manual git backup attempted but GIT_BACKUP_PATH is not configured")
- return RedirectResponse(url=f"/?message={urllib.parse.quote(message)}", status_code=303)
-
- try:
- commit_state_change(reader, "Manual backup triggered from web UI")
- message = "Successfully created git backup!"
- logger.info("Manual git backup completed successfully")
- except Exception as e:
- message = f"Failed to create git backup: {e}"
- logger.exception("Manual git backup failed")
-
- return RedirectResponse(url=f"/?message={urllib.parse.quote(message)}", status_code=303)
-
-
@app.get("/search", response_class=HTMLResponse)
-async def search(
- request: Request,
- query: str,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
-):
+async def search(request: Request, query: str):
"""Get entries matching a full-text search query.
Args:
query: The query to search for.
request: The request object.
- reader: The Reader instance.
Returns:
HTMLResponse: The search page.
"""
reader.update_search()
- context = create_search_context(query, reader=reader)
- return templates.TemplateResponse(request=request, name="search.html", context={"request": request, **context})
+
+ context = {
+ "request": request,
+ "search_html": create_html_for_search_results(query),
+ "query": query,
+ "search_amount": reader.search_entry_counts(query),
+ }
+ return templates.TemplateResponse(request=request, name="search.html", context=context)
@app.get("/post_entry", response_class=HTMLResponse)
-async def post_entry(
- entry_id: str,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
- feed_url: str = "",
-):
+async def post_entry(entry_id: str):
"""Send single entry to Discord.
Args:
entry_id: The entry to send.
- feed_url: Optional feed URL used to disambiguate entries with identical IDs.
- reader: The Reader instance.
Returns:
RedirectResponse: Redirect to the feed page.
"""
unquoted_entry_id: str = urllib.parse.unquote(entry_id)
- clean_feed_url: str = urllib.parse.unquote(feed_url.strip()) if feed_url else ""
-
- # Prefer feed-scoped lookup when feed_url is provided. This avoids ambiguity when
- # multiple feeds contain entries with the same ID.
- entry: Entry | None = None
- if clean_feed_url:
- entry = next(
- (entry for entry in reader.get_entries(feed=clean_feed_url) if entry.id == unquoted_entry_id),
- None,
- )
- else:
- entry = next((entry for entry in reader.get_entries() if entry.id == unquoted_entry_id), None)
-
+ entry: Entry | None = next((entry for entry in reader.get_entries() if entry.id == unquoted_entry_id), None)
if entry is None:
return HTMLResponse(status_code=404, content=f"Entry '{entry_id}' not found.")
- if result := send_entry_to_discord(entry=entry, reader=reader):
+ if result := send_entry_to_discord(entry=entry):
return result
# Redirect to the feed page.
- redirect_feed_url: str = entry.feed.url.strip()
- return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(redirect_feed_url)}", status_code=303)
+ clean_feed_url: str = entry.feed.url.strip()
+ return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(clean_feed_url)}", status_code=303)
@app.post("/modify_webhook", response_class=HTMLResponse)
-def modify_webhook(
- old_hook: Annotated[str, Form()],
- new_hook: Annotated[str, Form()],
- reader: Annotated[Reader, Depends(get_reader_dependency)],
- redirect_to: Annotated[str, Form()] = "",
-):
+def modify_webhook(old_hook: Annotated[str, Form()], new_hook: Annotated[str, Form()]):
"""Modify a webhook.
Args:
old_hook: The webhook to modify.
new_hook: The new webhook.
- redirect_to: Optional redirect URL after the update.
- reader: The Reader instance.
-
- Returns:
- RedirectResponse: Redirect to the webhook page.
Raises:
HTTPException: Webhook could not be modified.
+ Returns:
+ RedirectResponse: Redirect to the webhook page.
"""
# Get current webhooks from the database if they exist otherwise use an empty list.
webhooks = list(reader.get_tag((), "webhooks", []))
@@ -1510,20 +919,15 @@ def modify_webhook(
# Webhooks are stored as a list of dictionaries.
# Example: [{"name": "webhook_name", "url": "webhook_url"}]
webhooks = cast("list[dict[str, str]]", webhooks)
- old_hook_clean: str = old_hook.strip()
- new_hook_clean: str = new_hook.strip()
- webhook_modified: bool = False
for hook in webhooks:
- if hook["url"] in old_hook_clean:
- hook["url"] = new_hook_clean
+ if hook["url"] in old_hook.strip():
+ hook["url"] = new_hook.strip()
# Check if it has been modified.
- if hook["url"] != new_hook_clean:
+ if hook["url"] != new_hook.strip():
raise HTTPException(status_code=500, detail="Webhook could not be modified")
- webhook_modified = True
-
# Add our new list of webhooks to the database.
reader.set_tag((), "webhooks", webhooks) # pyright: ignore[reportArgumentType]
@@ -1531,506 +935,16 @@ def modify_webhook(
# matches the old one.
feeds: Iterable[Feed] = reader.get_feeds()
for feed in feeds:
- webhook: str = str(reader.get_tag(feed, "webhook", ""))
+ try:
+ webhook = reader.get_tag(feed, "webhook")
+ except TagNotFoundError:
+ continue
- if webhook == old_hook_clean:
- reader.set_tag(feed.url, "webhook", new_hook_clean) # pyright: ignore[reportArgumentType]
+ if webhook == old_hook.strip():
+ reader.set_tag(feed.url, "webhook", new_hook.strip()) # pyright: ignore[reportArgumentType]
- if webhook_modified and old_hook_clean != new_hook_clean:
- commit_state_change(reader, f"Modify webhook URL from {old_hook_clean} to {new_hook_clean}")
-
- redirect_url: str = redirect_to.strip() or "/webhooks"
- if redirect_to:
- redirect_url = redirect_url.replace(urllib.parse.quote(old_hook_clean), urllib.parse.quote(new_hook_clean))
- redirect_url = redirect_url.replace(old_hook_clean, new_hook_clean)
-
- # Redirect to the requested page.
- return RedirectResponse(url=redirect_url, status_code=303)
-
-
-def extract_youtube_video_id(url: str) -> str | None:
- """Extract YouTube video ID from a YouTube video URL.
-
- Args:
- url: The YouTube video URL.
-
- Returns:
- The video ID if found, None otherwise.
- """
- if not url:
- return None
-
- # Handle standard YouTube URLs (youtube.com/watch?v=VIDEO_ID)
- if "youtube.com/watch" in url and "v=" in url:
- return url.split("v=")[1].split("&", maxsplit=1)[0]
-
- # Handle shortened YouTube URLs (youtu.be/VIDEO_ID)
- if "youtu.be/" in url:
- return url.split("youtu.be/")[1].split("?", maxsplit=1)[0]
-
- return None
-
-
-def resolve_final_feed_url(url: str) -> tuple[str, str | None]:
- """Resolve a feed URL by following redirects.
-
- Args:
- url: The feed URL to resolve.
-
- Returns:
- tuple[str, str | None]: A tuple with (resolved_url, error_message).
- error_message is None when resolution succeeded.
- """
- clean_url: str = url.strip()
- if not clean_url:
- return "", "URL is empty"
-
- if not is_url_valid(clean_url):
- return clean_url, "URL is invalid"
-
- try:
- response: Response = httpx.get(clean_url, follow_redirects=True, timeout=10.0)
- except httpx.HTTPError as e:
- return clean_url, str(e)
-
- if not response.is_success:
- return clean_url, f"HTTP {response.status_code}"
-
- return str(response.url), None
-
-
-def create_webhook_feed_url_preview(
- webhook_feeds: list[Feed],
- replace_from: str,
- replace_to: str,
- resolve_urls: bool, # noqa: FBT001
- force_update: bool = False, # noqa: FBT001, FBT002
- existing_feed_urls: set[str] | None = None,
-) -> list[dict[str, str | bool | None]]:
- """Create preview rows for bulk feed URL replacement.
-
- Args:
- webhook_feeds: Feeds attached to a webhook.
- replace_from: Text to replace in each URL.
- replace_to: Replacement text.
- resolve_urls: Whether to resolve resulting URLs via HTTP redirects.
- force_update: Whether conflicts should be marked as force-overwritable.
- existing_feed_urls: Optional set of all tracked feed URLs used for conflict detection.
-
- Returns:
- list[dict[str, str | bool | None]]: Rows used in the preview table.
- """
- known_feed_urls: set[str] = existing_feed_urls or {feed.url for feed in webhook_feeds}
- preview_rows: list[dict[str, str | bool | None]] = []
- for feed in webhook_feeds:
- old_url: str = feed.url
- has_match: bool = bool(replace_from and replace_from in old_url)
-
- candidate_url: str = old_url
- if has_match:
- candidate_url = old_url.replace(replace_from, replace_to)
-
- resolved_url: str = candidate_url
- resolution_error: str | None = None
- if has_match and candidate_url != old_url and resolve_urls:
- resolved_url, resolution_error = resolve_final_feed_url(candidate_url)
-
- will_force_ignore_errors: bool = bool(
- force_update and bool(resolution_error) and has_match and old_url != candidate_url,
- )
-
- target_exists: bool = bool(
- has_match and not resolution_error and resolved_url != old_url and resolved_url in known_feed_urls,
- )
- will_force_overwrite: bool = bool(target_exists and force_update)
- will_change: bool = bool(
- has_match
- and old_url != (candidate_url if will_force_ignore_errors else resolved_url)
- and (not target_exists or will_force_overwrite)
- and (not resolution_error or will_force_ignore_errors),
- )
-
- preview_rows.append({
- "old_url": old_url,
- "candidate_url": candidate_url,
- "resolved_url": resolved_url,
- "has_match": has_match,
- "will_change": will_change,
- "target_exists": target_exists,
- "will_force_overwrite": will_force_overwrite,
- "will_force_ignore_errors": will_force_ignore_errors,
- "resolution_error": resolution_error,
- })
-
- return preview_rows
-
-
-def build_webhook_mass_update_context(
- webhook_feeds: list[Feed],
- all_feeds: list[Feed],
- replace_from: str,
- replace_to: str,
- resolve_urls: bool, # noqa: FBT001
- force_update: bool = False, # noqa: FBT001, FBT002
-) -> dict[str, str | bool | int | list[dict[str, str | bool | None]] | dict[str, int]]:
- """Build context data used by the webhook mass URL update preview UI.
-
- Args:
- webhook_feeds: Feeds attached to the selected webhook.
- all_feeds: All tracked feeds.
- replace_from: Text to replace in URLs.
- replace_to: Replacement text.
- resolve_urls: Whether to resolve resulting URLs.
- force_update: Whether to allow overwriting existing target URLs.
-
- Returns:
- dict[str, ...]: Context values for rendering preview controls and table.
- """
- clean_replace_from: str = replace_from.strip()
- clean_replace_to: str = replace_to.strip()
-
- preview_rows: list[dict[str, str | bool | None]] = []
- if clean_replace_from:
- preview_rows = create_webhook_feed_url_preview(
- webhook_feeds=webhook_feeds,
- replace_from=clean_replace_from,
- replace_to=clean_replace_to,
- resolve_urls=resolve_urls,
- force_update=force_update,
- existing_feed_urls={feed.url for feed in all_feeds},
- )
-
- preview_summary: dict[str, int] = {
- "total": len(preview_rows),
- "matched": sum(1 for row in preview_rows if row["has_match"]),
- "will_update": sum(1 for row in preview_rows if row["will_change"]),
- "conflicts": sum(1 for row in preview_rows if row["target_exists"] and not row["will_force_overwrite"]),
- "force_overwrite": sum(1 for row in preview_rows if row["will_force_overwrite"]),
- "force_ignore_errors": sum(1 for row in preview_rows if row["will_force_ignore_errors"]),
- "resolve_errors": sum(1 for row in preview_rows if row["resolution_error"]),
- }
- preview_summary["no_match"] = preview_summary["total"] - preview_summary["matched"]
- preview_summary["no_change"] = sum(
- 1 for row in preview_rows if row["has_match"] and not row["resolution_error"] and not row["will_change"]
- )
-
- return {
- "replace_from": clean_replace_from,
- "replace_to": clean_replace_to,
- "resolve_urls": resolve_urls,
- "force_update": force_update,
- "preview_rows": preview_rows,
- "preview_summary": preview_summary,
- "preview_change_count": preview_summary["will_update"],
- }
-
-
-@app.get("/webhook_entries_mass_update_preview", response_class=HTMLResponse)
-async def get_webhook_entries_mass_update_preview(
- webhook_url: str,
- request: Request,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
- replace_from: str = "",
- replace_to: str = "",
- resolve_urls: bool = True, # noqa: FBT001, FBT002
- force_update: bool = False, # noqa: FBT001, FBT002
-) -> HTMLResponse:
- """Render the mass-update preview fragment for a webhook using HTMX.
-
- Args:
- webhook_url: Webhook URL whose feeds are being updated.
- request: The request object.
- reader: The Reader instance.
- replace_from: Text to find in URLs.
- replace_to: Replacement text.
- resolve_urls: Whether to resolve resulting URLs.
- force_update: Whether to allow overwriting existing target URLs.
-
- Returns:
- HTMLResponse: Rendered partial template containing summary + preview table.
- """
- clean_webhook_url: str = urllib.parse.unquote(webhook_url.strip())
- all_feeds: list[Feed] = list(reader.get_feeds())
- webhook_feeds: list[Feed] = [
- feed for feed in all_feeds if str(reader.get_tag(feed.url, "webhook", "")) == clean_webhook_url
- ]
-
- context = {
- "request": request,
- "webhook_url": clean_webhook_url,
- **build_webhook_mass_update_context(
- webhook_feeds=webhook_feeds,
- all_feeds=all_feeds,
- replace_from=replace_from,
- replace_to=replace_to,
- resolve_urls=resolve_urls,
- force_update=force_update,
- ),
- }
- return templates.TemplateResponse(request=request, name="_webhook_mass_update_preview.html", context=context)
-
-
-@app.get("/webhook_entries", response_class=HTMLResponse)
-async def get_webhook_entries( # noqa: C901, PLR0914
- webhook_url: str,
- request: Request,
- reader: Annotated[Reader, Depends(get_reader_dependency)],
- starting_after: str = "",
- replace_from: str = "",
- replace_to: str = "",
- resolve_urls: bool = True, # noqa: FBT001, FBT002
- force_update: bool = False, # noqa: FBT001, FBT002
- message: str = "",
-) -> HTMLResponse:
- """Get all latest entries from all feeds for a specific webhook.
-
- Args:
- webhook_url: The webhook URL to get entries for.
- request: The request object.
- starting_after: The entry to start after. Used for pagination.
- replace_from: Optional URL substring to find for bulk URL replacement preview.
- replace_to: Optional replacement substring used in bulk URL replacement preview.
- resolve_urls: Whether to resolve replaced URLs by following redirects.
- force_update: Whether to allow overwriting existing target URLs during apply.
- message: Optional status message shown in the UI.
- reader: The Reader instance.
-
- Returns:
- HTMLResponse: The webhook entries page.
-
- Raises:
- HTTPException: If no feeds are found for this webhook or webhook doesn't exist.
- """
- entries_per_page: int = 20
- clean_webhook_url: str = urllib.parse.unquote(webhook_url.strip())
-
- # Get the webhook name from the webhooks list
- webhooks: list[dict[str, str]] = cast("list[dict[str, str]]", list(reader.get_tag((), "webhooks", [])))
- webhook_name: str = ""
- for hook in webhooks:
- if hook["url"] == clean_webhook_url:
- webhook_name = hook["name"]
- break
-
- if not webhook_name:
- raise HTTPException(status_code=404, detail=f"Webhook not found: {clean_webhook_url}")
-
- hook_info: WebhookInfo = get_data_from_hook_url(hook_name=webhook_name, hook_url=clean_webhook_url)
-
- # Get all feeds associated with this webhook
- all_feeds: list[Feed] = list(reader.get_feeds())
- webhook_feeds: list[Feed] = []
-
- for feed in all_feeds:
- feed_webhook: str = str(reader.get_tag(feed.url, "webhook", ""))
- if feed_webhook == clean_webhook_url:
- webhook_feeds.append(feed)
-
- # Get all entries from all feeds for this webhook, sorted by published date
- all_entries: list[Entry] = [entry for feed in webhook_feeds for entry in reader.get_entries(feed=feed)]
-
- # Sort entries by published date (newest first), with undated entries last.
- all_entries.sort(
- key=lambda e: (
- e.published is not None,
- e.published or datetime.min.replace(tzinfo=UTC),
- ),
- reverse=True,
- )
-
- # Handle pagination
- if starting_after:
- try:
- start_after_entry: Entry | None = reader.get_entry((
- starting_after.split("|", maxsplit=1)[0],
- starting_after.split("|")[1],
- ))
- except (FeedNotFoundError, EntryNotFoundError):
- start_after_entry = None
- else:
- start_after_entry = None
-
- # Find the index of the starting entry
- start_index: int = 0
- if start_after_entry:
- for idx, entry in enumerate(all_entries):
- if entry.id == start_after_entry.id and entry.feed.url == start_after_entry.feed.url:
- start_index = idx + 1
- break
-
- # Get the page of entries
- paginated_entries: list[Entry] = all_entries[start_index : start_index + entries_per_page]
-
- # Get the last entry for pagination
- last_entry: Entry | None = None
- if paginated_entries:
- last_entry = paginated_entries[-1]
-
- # Create the html for the entries
- html: str = create_html_for_feed(reader=reader, entries=paginated_entries)
-
- mass_update_context = build_webhook_mass_update_context(
- webhook_feeds=webhook_feeds,
- all_feeds=all_feeds,
- replace_from=replace_from,
- replace_to=replace_to,
- resolve_urls=resolve_urls,
- force_update=force_update,
- )
-
- # Check if there are more entries available
- total_entries: int = len(all_entries)
- is_show_more_entries_button_visible: bool = (start_index + entries_per_page) < total_entries
-
- context = {
- "request": request,
- "hook_info": hook_info,
- "webhook_name": webhook_name,
- "webhook_url": clean_webhook_url,
- "webhook_feeds": webhook_feeds,
- "entries": paginated_entries,
- "html": html,
- "last_entry": last_entry,
- "is_show_more_entries_button_visible": is_show_more_entries_button_visible,
- "total_entries": total_entries,
- "feeds_count": len(webhook_feeds),
- "message": urllib.parse.unquote(message) if message else "",
- **mass_update_context,
- }
- return templates.TemplateResponse(request=request, name="webhook_entries.html", context=context)
-
-
-@app.post("/bulk_change_feed_urls", response_class=HTMLResponse)
-async def post_bulk_change_feed_urls( # noqa: C901, PLR0914, PLR0912, PLR0915
- webhook_url: Annotated[str, Form()],
- replace_from: Annotated[str, Form()],
- reader: Annotated[Reader, Depends(get_reader_dependency)],
- replace_to: Annotated[str, Form()] = "",
- resolve_urls: Annotated[bool, Form()] = True, # noqa: FBT002
- force_update: Annotated[bool, Form()] = False, # noqa: FBT002
-) -> RedirectResponse:
- """Bulk-change feed URLs attached to a webhook.
-
- Args:
- webhook_url: The webhook URL whose feeds should be updated.
- replace_from: Text to find in each URL.
- replace_to: Text to replace with.
- resolve_urls: Whether to resolve resulting URLs via redirects.
- force_update: Whether existing target feed URLs should be overwritten.
- reader: The Reader instance.
-
- Returns:
- RedirectResponse: Redirect to webhook detail with status message.
-
- Raises:
- HTTPException: If webhook is missing or replace_from is empty.
- """
- clean_webhook_url: str = urllib.parse.unquote(webhook_url.strip())
- clean_replace_from: str = replace_from.strip()
- clean_replace_to: str = replace_to.strip()
-
- if not clean_replace_from:
- raise HTTPException(status_code=400, detail="replace_from cannot be empty")
-
- webhooks: list[dict[str, str]] = cast("list[dict[str, str]]", list(reader.get_tag((), "webhooks", [])))
- if not any(hook["url"] == clean_webhook_url for hook in webhooks):
- raise HTTPException(status_code=404, detail=f"Webhook not found: {clean_webhook_url}")
-
- all_feeds: list[Feed] = list(reader.get_feeds())
- webhook_feeds: list[Feed] = []
- for feed in all_feeds:
- feed_webhook: str = str(reader.get_tag(feed.url, "webhook", ""))
- if feed_webhook == clean_webhook_url:
- webhook_feeds.append(feed)
-
- preview_rows: list[dict[str, str | bool | None]] = create_webhook_feed_url_preview(
- webhook_feeds=webhook_feeds,
- replace_from=clean_replace_from,
- replace_to=clean_replace_to,
- resolve_urls=resolve_urls,
- force_update=force_update,
- existing_feed_urls={feed.url for feed in all_feeds},
- )
-
- changed_count: int = 0
- skipped_count: int = 0
- failed_count: int = 0
- conflict_count: int = 0
- force_overwrite_count: int = 0
-
- for row in preview_rows:
- if not row["has_match"]:
- continue
-
- if row["resolution_error"] and not force_update:
- skipped_count += 1
- continue
-
- if row["target_exists"] and not force_update:
- conflict_count += 1
- skipped_count += 1
- continue
-
- old_url: str = str(row["old_url"])
- new_url: str = str(row["candidate_url"] if row["will_force_ignore_errors"] else row["resolved_url"])
-
- if old_url == new_url:
- skipped_count += 1
- continue
-
- if row["target_exists"] and force_update:
- try:
- reader.delete_feed(new_url)
- force_overwrite_count += 1
- except FeedNotFoundError:
- pass
- except ReaderError:
- failed_count += 1
- continue
-
- try:
- reader.change_feed_url(old_url, new_url)
- except FeedExistsError:
- skipped_count += 1
- continue
- except FeedNotFoundError:
- skipped_count += 1
- continue
- except ReaderError:
- failed_count += 1
- continue
-
- try:
- reader.update_feed(new_url)
- except Exception:
- logger.exception("Failed to update feed after URL change: %s", new_url)
-
- for entry in reader.get_entries(feed=new_url, read=False):
- try:
- reader.set_entry_read(entry, True)
- except Exception:
- logger.exception("Failed to mark entry as read after URL change: %s", entry.id)
-
- changed_count += 1
-
- if changed_count > 0:
- commit_state_change(
- reader,
- f"Bulk change {changed_count} feed URL(s) for webhook {clean_webhook_url}",
- )
-
- status_message: str = (
- f"Updated {changed_count} feed URL(s). "
- f"Force overwrote {force_overwrite_count}. "
- f"Conflicts {conflict_count}. "
- f"Skipped {skipped_count}. "
- f"Failed {failed_count}."
- )
- redirect_url: str = (
- f"/webhook_entries?webhook_url={urllib.parse.quote(clean_webhook_url)}"
- f"&message={urllib.parse.quote(status_message)}"
- )
- return RedirectResponse(url=redirect_url, status_code=303)
+ # Redirect to the webhook page.
+ return RedirectResponse(url="/webhooks", status_code=303)
if __name__ == "__main__":
@@ -2043,9 +957,9 @@ if __name__ == "__main__":
uvicorn.run(
"main:app",
- log_level="debug",
+ log_level="info",
host="0.0.0.0", # noqa: S104
- port=3000,
+ port=5000,
proxy_headers=True,
forwarded_allow_ips="*",
)
diff --git a/discord_rss_bot/missing_tags.py b/discord_rss_bot/missing_tags.py
new file mode 100644
index 0000000..84f375e
--- /dev/null
+++ b/discord_rss_bot/missing_tags.py
@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from reader import Feed, Reader, TagNotFoundError
+
+from discord_rss_bot.settings import default_custom_embed, default_custom_message
+
+
+def add_custom_message(reader: Reader, feed: Feed) -> None:
+ """Add the custom message tag to the feed if it doesn't exist.
+
+ Args:
+ reader: What Reader to use.
+ feed: The feed to add the tag to.
+ """
+ try:
+ reader.get_tag(feed, "custom_message")
+ except TagNotFoundError:
+ reader.set_tag(feed.url, "custom_message", default_custom_message) # pyright: ignore[reportArgumentType]
+ reader.set_tag(feed.url, "has_custom_message", True) # pyright: ignore[reportArgumentType]
+
+
+def add_has_custom_message(reader: Reader, feed: Feed) -> None:
+ """Add the has_custom_message tag to the feed if it doesn't exist.
+
+ Args:
+ reader: What Reader to use.
+ feed: The feed to add the tag to.
+ """
+ try:
+ reader.get_tag(feed, "has_custom_message")
+ except TagNotFoundError:
+ if reader.get_tag(feed, "custom_message") == default_custom_message:
+ reader.set_tag(feed.url, "has_custom_message", False) # pyright: ignore[reportArgumentType]
+ else:
+ reader.set_tag(feed.url, "has_custom_message", True) # pyright: ignore[reportArgumentType]
+
+
+def add_if_embed(reader: Reader, feed: Feed) -> None:
+ """Add the if_embed tag to the feed if it doesn't exist.
+
+ Args:
+ reader: What Reader to use.
+ feed: The feed to add the tag to.
+ """
+ try:
+ reader.get_tag(feed, "if_embed")
+ except TagNotFoundError:
+ reader.set_tag(feed.url, "if_embed", True) # pyright: ignore[reportArgumentType]
+
+
+def add_custom_embed(reader: Reader, feed: Feed) -> None:
+ """Add the custom embed tag to the feed if it doesn't exist.
+
+ Args:
+ reader: What Reader to use.
+ feed: The feed to add the tag to.
+ """
+ try:
+ reader.get_tag(feed, "embed")
+ except TagNotFoundError:
+ reader.set_tag(feed.url, "embed", default_custom_embed) # pyright: ignore[reportArgumentType]
+ reader.set_tag(feed.url, "has_custom_embed", True) # pyright: ignore[reportArgumentType]
+
+
+def add_has_custom_embed(reader: Reader, feed: Feed) -> None:
+ """Add the has_custom_embed tag to the feed if it doesn't exist.
+
+ Args:
+ reader: What Reader to use.
+ feed: The feed to add the tag to.
+ """
+ try:
+ reader.get_tag(feed, "has_custom_embed")
+ except TagNotFoundError:
+ if reader.get_tag(feed, "embed") == default_custom_embed:
+ reader.set_tag(feed.url, "has_custom_embed", False) # pyright: ignore[reportArgumentType]
+ else:
+ reader.set_tag(feed.url, "has_custom_embed", True) # pyright: ignore[reportArgumentType]
+
+
+def add_should_send_embed(reader: Reader, feed: Feed) -> None:
+ """Add the should_send_embed tag to the feed if it doesn't exist.
+
+ Args:
+ reader: What Reader to use.
+ feed: The feed to add the tag to.
+ """
+ try:
+ reader.get_tag(feed, "should_send_embed")
+ except TagNotFoundError:
+ reader.set_tag(feed.url, "should_send_embed", True) # pyright: ignore[reportArgumentType]
+
+
+def add_missing_tags(reader: Reader) -> None:
+ """Add missing tags to feeds.
+
+ Args:
+ reader: What Reader to use.
+ """
+ for feed in reader.get_feeds():
+ add_custom_message(reader, feed)
+ add_has_custom_message(reader, feed)
+ add_if_embed(reader, feed)
+ add_custom_embed(reader, feed)
+ add_has_custom_embed(reader, feed)
+ add_should_send_embed(reader, feed)
diff --git a/discord_rss_bot/search.py b/discord_rss_bot/search.py
index 85129ac..c81b398 100644
--- a/discord_rss_bot/search.py
+++ b/discord_rss_bot/search.py
@@ -3,78 +3,66 @@ from __future__ import annotations
import urllib.parse
from typing import TYPE_CHECKING
+from discord_rss_bot.settings import get_reader
+
if TYPE_CHECKING:
from collections.abc import Iterable
- from reader import EntrySearchResult
- from reader import Feed
- from reader import HighlightedString
- from reader import Reader
+ from reader import EntrySearchResult, Feed, HighlightedString, Reader
-def create_search_context(query: str, reader: Reader) -> dict:
- """Build context for search.html template.
+def create_html_for_search_results(query: str, custom_reader: Reader | None = None) -> str:
+ """Create HTML for the search results.
Args:
- query (str): The search query.
- reader (Reader): Custom Reader instance.
+ query: Our search query
+ custom_reader: The reader. If None, we will get the reader from the settings.
Returns:
- dict: Context dictionary for rendering the search results.
+ str: The HTML.
"""
+ # TODO(TheLovinator): There is a .content that also contains text, we should use that if .summary is not available.
+ # TODO(TheLovinator): We should also add tags to the title.
+
+ # Get the default reader if we didn't get a custom one.
+ reader: Reader = get_reader() if custom_reader is None else custom_reader
+
search_results: Iterable[EntrySearchResult] = reader.search_entries(query)
- results: list[dict] = []
+ html: str = ""
for result in search_results:
- feed: Feed = reader.get_feed(result.feed_url)
- feed_url: str = urllib.parse.quote(feed.url)
-
- # Prefer summary, fall back to content
if ".summary" in result.content:
- highlighted = result.content[".summary"]
- else:
- content_keys = [k for k in result.content if k.startswith(".content")]
- highlighted = result.content[content_keys[0]] if content_keys else None
+ result_summary: str = add_span_with_slice(result.content[".summary"])
+ feed: Feed = reader.get_feed(result.feed_url)
+ feed_url: str = urllib.parse.quote(feed.url)
- summary: str = add_spans(highlighted) if highlighted else "(no preview available)"
+ html += f"""
+ {entry.title}
-{feed_link}{f"By {entry.author} @" if entry.author else ""}{published} - {to_discord_html} +{blacklisted}{whitelisted}{entry.title}
+{f"By {entry.author} @" if entry.author else ""}{published} - {to_discord_html} {text} -{video_embed_html} {image_html}
+
+
+ """
- results.append({
- "title": add_spans(result.metadata.get(".title")),
- "summary": summary,
- "feed_url": feed_url,
- })
-
- return {
- "query": query,
- "search_amount": {"total": len(results)},
- "results": results,
- }
+ return html
-def add_spans(highlighted_string: HighlightedString | None) -> str:
- """Wrap all highlighted parts with tags.
+def add_span_with_slice(highlighted_string: HighlightedString) -> str:
+ """Add span tags to the string to highlight the search results.
Args:
- highlighted_string (HighlightedString | None): The highlighted string to process.
+ highlighted_string: The highlighted string.
Returns:
- str: The processed string with tags around highlighted parts.
+ str: The string with added tags.
"""
- if highlighted_string is None:
- return ""
-
- value: str = highlighted_string.value
- parts: list[str] = []
- last_index = 0
+ # TODO(TheLovinator): We are looping through the highlights and only using the last one. We should use all of them.
+ before_span, span_part, after_span = "", "", ""
for txt_slice in highlighted_string.highlights:
- parts.extend((
- value[last_index : txt_slice.start],
- f"{value[txt_slice.start : txt_slice.stop]}",
- ))
- last_index = txt_slice.stop
+ before_span: str = f"{highlighted_string.value[: txt_slice.start]}"
+ span_part: str = f"{highlighted_string.value[txt_slice.start : txt_slice.stop]}"
+ after_span: str = f"{highlighted_string.value[txt_slice.stop :]}"
- # add any trailing text
- parts.append(value[last_index:])
-
- return "".join(parts)
+ return f"{before_span}{span_part}{after_span}"
diff --git a/discord_rss_bot/settings.py b/discord_rss_bot/settings.py
index 194bf08..a99733e 100644
--- a/discord_rss_bot/settings.py
+++ b/discord_rss_bot/settings.py
@@ -1,23 +1,16 @@
from __future__ import annotations
-import os
import typing
from functools import lru_cache
from pathlib import Path
from platformdirs import user_data_dir
-from reader import Reader
-from reader import make_reader
+from reader import Reader, make_reader
if typing.TYPE_CHECKING:
from reader.types import JSONType
-data_dir: str = os.getenv("DISCORD_RSS_BOT_DATA_DIR", "").strip() or user_data_dir(
- appname="discord_rss_bot",
- appauthor="TheLovinator",
- roaming=True,
- ensure_exists=True,
-)
+data_dir: str = user_data_dir(appname="discord_rss_bot", appauthor="TheLovinator", roaming=True, ensure_exists=True)
# TODO(TheLovinator): Add default things to the database and make the edible.
@@ -31,7 +24,7 @@ default_custom_embed: dict[str, str] = {
}
-@lru_cache(maxsize=1)
+@lru_cache
def get_reader(custom_location: Path | None = None) -> Reader:
"""Get the reader.
@@ -42,13 +35,5 @@ def get_reader(custom_location: Path | None = None) -> Reader:
The reader.
"""
db_location: Path = custom_location or Path(data_dir) / "db.sqlite"
- reader: Reader = make_reader(url=str(db_location))
- # https://reader.readthedocs.io/en/latest/api.html#reader.types.UpdateConfig
- # Set the default update interval to 15 minutes if not already configured
- # Users can change this via the Settings page or per-feed in the feed page
- if reader.get_tag((), ".reader.update", None) is None:
- # Set default
- reader.set_tag((), ".reader.update", {"interval": 15})
-
- return reader
+ return make_reader(url=str(db_location))
diff --git a/discord_rss_bot/static/styles.css b/discord_rss_bot/static/styles.css
index 266f951..db0cfba 100644
--- a/discord_rss_bot/static/styles.css
+++ b/discord_rss_bot/static/styles.css
@@ -13,7 +13,3 @@ body {
.form-text {
color: #acabab;
}
-
-.interval-input {
- max-width: 120px;
-}
diff --git a/discord_rss_bot/templates/_webhook_mass_update_preview.html b/discord_rss_bot/templates/_webhook_mass_update_preview.html
deleted file mode 100644
index a59e97b..0000000
--- a/discord_rss_bot/templates/_webhook_mass_update_preview.html
+++ /dev/null
@@ -1,73 +0,0 @@
-{% if preview_rows %}
- {result.metadata[".title"]}
+ + {result_summary} +- {{ preview_change_count }} feed URL{{ 's' if preview_change_count != 1 else '' }} ready to update. -
-
- Total: {{ preview_summary.total }}
- Matched: {{ preview_summary.matched }}
- Will update: {{ preview_summary.will_update }}
- Conflicts: {{ preview_summary.conflicts }}
- Force overwrite: {{ preview_summary.force_overwrite }}
- Force ignore errors: {{ preview_summary.force_ignore_errors }}
- Resolve errors: {{ preview_summary.resolve_errors }}
- No change: {{ preview_summary.no_change }}
- No match: {{ preview_summary.no_match }}
-
-
-
-
-
-
-
-{% elif replace_from %}
- | Old URL | -New URL | -Status | -
|---|---|---|
- {{ row.old_url }}
- |
-
- {{ row.resolved_url if resolve_urls else row.candidate_url }}
- |
- - {% if not row.has_match %} - No match - {% elif row.will_force_ignore_errors %} - Will force update (ignore resolve error) - {% elif row.resolution_error %} - {{ row.resolution_error }} - {% elif row.will_force_overwrite %} - Will force overwrite - {% elif row.target_exists %} - Conflict: target URL exists - {% elif row.will_change %} - Will update - {% else %} - No change - {% endif %} - | -
No preview rows found for that replacement pattern.
-{% endif %} diff --git a/discord_rss_bot/templates/base.html b/discord_rss_bot/templates/base.html index 9146b35..a8640dd 100644 --- a/discord_rss_bot/templates/base.html +++ b/discord_rss_bot/templates/base.html @@ -1,12 +1,13 @@ + + content="Stay updated with the latest news and events with our easy-to-use RSS bot. Never miss a message or announcement again with real-time notifications directly to your Discord server." /> + content="discord, rss, bot, notifications, announcements, updates, real-time, server, messages, news, events, feed." /> @@ -17,20 +18,19 @@ {% block head %} {% endblock head %} + {% include "nav.html" %}
{% if messages %}
-
-
+ {{ messages }}
-
-
+
{% endif %}
+
{% block content %}
{% endblock content %}
{{ messages }}
+
+
-
diff --git a/discord_rss_bot/templates/custom.html b/discord_rss_bot/templates/custom.html
index 48cb3bc..f018d3a 100644
--- a/discord_rss_bot/templates/custom.html
+++ b/discord_rss_bot/templates/custom.html
@@ -14,90 +14,90 @@
-
-
-
-
-
-
-
-
-
-
-
-
- -
-
- - Regular expression patterns for advanced filtering. Each pattern should be on a new - line. - -
- Patterns are case-insensitive. -
-
- Examples:
-
---^New Release:.* -\b(update|version|patch)\s+\d+\.\d+ -.*\[(important|notice)\].* -
-
-
{% raw %}
- {{feed_author}}
+ {{ feed_author }}
{% endraw %}
{{ feed.author }}
{% raw %}
- {{feed_added}}
+ {{ feed_added }}
{% endraw %}
{{ feed.added }}
{% raw %}
- {{feed_last_exception}}
+ {{ feed_last_exception }}
{% endraw %}
{{ feed.last_exception }}
{% raw %}
- {{feed_last_updated}}
+ {{ feed_last_updated }}
{% endraw %}
{{ feed.last_updated }}
{% raw %}
- {{feed_link}}
+ {{ feed_link }}
{% endraw %}
{{ feed.link }}
{% raw %}
- {{feed_subtitle}}
+ {{ feed_subtitle }}
{% endraw %}
{{ feed.subtitle }}
{% raw %}
- {{feed_title}}
+ {{ feed_title }}
{% endraw %}
{{ feed.title }}
{% raw %}
- {{feed_updated}}
+ {{ feed_updated }}
{% endraw %}
{{ feed.updated }}
{% raw %}
- {{feed_updates_enabled}}
+ {{ feed_updates_enabled }}
{% endraw %}
{{ feed.updates_enabled }}
{% raw %}
- {{feed_url}}
+ {{ feed_url }}
{% endraw %}
{{ feed.url }}
{% raw %}
- {{feed_user_title}}
+ {{ feed_user_title }}
{% endraw %}
{{ feed.user_title }}
{% raw %}
- {{feed_version}}
+ {{ feed_version }}
{% endraw %}
{{ feed.version }}
{% raw %}
- {{entry_added}}
+ {{ entry_added }}
{% endraw %}
{{ entry.added }}
{% raw %}
- {{entry_author}}
+ {{ entry_author }}
{% endraw %}
{{ entry.author }}
{% raw %}
- {{entry_content}}
+ {{ entry_content }}
{% endraw %}
{{ entry.content[0].value|discord_markdown }}
{% raw %}
- {{entry_content_raw}}
+ {{ entry_content_raw }}
{% endraw %}
{{ entry.content[0].value }}
{% raw %}
- {{entry_id}}
+ {{ entry_id }}
{% endraw %}
{{ entry.id }}
{% raw %}
- {{entry_important}}
+ {{ entry_important }}
{% endraw %}
{{ entry.important }}
{% raw %}
- {{entry_link}}
+ {{ entry_link }}
{% endraw %}
{{ entry.link }}
{% raw %}
- {{entry_published}}
+ {{ entry_published }}
{% endraw %}
{{ entry.published }}
{% raw %}
- {{entry_read}}
+ {{ entry_read }}
{% endraw %}
{{ entry.read }}
{% raw %}
- {{entry_read_modified}}
+ {{ entry_read_modified }}
{% endraw %}
{{ entry.read_modified }}
{% raw %}
- {{entry_summary}}
+ {{ entry_summary }}
{% endraw %}
{{ entry.summary|discord_markdown }}
{% raw %}
- {{entry_summary_raw}}
+ {{ entry_summary_raw }}
{% endraw %}
{{ entry.summary }}
{% raw %}
- {{entry_title}}
+ {{ entry_title }}
{% endraw %}
{{ entry.title }}
{% raw %}
- {{entry_text}}
+ {{ entry_text }}
{% endraw %}
Same as entry_content if it exists, otherwise entry_summary
{% raw %}
- {{entry_updated}}
+ {{ entry_updated }}
{% endraw %}
{{ entry.updated }}
{% raw %}
- {{image_1}}
+ {{ image_1 }}
{% endraw %}
First image in the entry if it exists
{% raw %}
- {{feed_title}}\n{{entry_content}}
+ {{ feed_title }}\n{{ entry_content }}
{% endraw %}
-
-
- {{ feed.title }} ({{ total_entries }} entries) -
- {% if not feed.updates_enabled %}Disabled{% endif %} - {% if feed.last_exception %} -
-
- {% endif %}
-
- {{ feed.last_exception.type_name }}:
-{{ feed.last_exception.value_str }}
-
-
-
- {{ feed.last_exception.traceback_str }}
- Update
-
- {% if not feed.updates_enabled %}
-
- {% else %}
-
- {% endif %}
- {% if not "youtube.com/feeds/videos.xml" in feed.url %}
- {% if should_send_embed %}
-
- {% else %}
-
- {% endif %}
- {% endif %}
-
-
-
- Whitelist
- Blacklist
-
- Customize message
- {% if not should_send_embed %}(Currently active){% endif %}
-
- {% if not "youtube.com/feeds/videos.xml" in feed.url %}
-
- Customize embed
- {% if should_send_embed %}(Currently active){% endif %}
-
- {% endif %}
-
-
-
-
-
- Feed URL
- -
-
-
- Feed Information
-
-
-
- Added: {{ feed.added | relative_time }}
-
-
- Last Updated: {{ feed.last_updated | relative_time }}
-
-
- Last Retrieved: {{ feed.last_retrieved | relative_time }}
-
-
- Next Update: {{ feed.update_after | relative_time }}
-
-
- Updates: {{ 'Enabled' if feed.updates_enabled else 'Disabled' }}
-
-
-
- Update Interval - {% if feed_interval %} - Custom - {% else %} - Using global default - {% endif %} - -
-
- Current:
- {% if feed_interval %}
- {{ feed_interval }}
- {% if feed_interval >= 60 %}({{ (feed_interval / 60) | round(1) }} hours){% endif %}
- {% else %}
- {{ global_interval }}
- {% if global_interval >= 60 %}({{ (global_interval / 60) | round(1) }} hours){% endif %}
- {% endif %}
- minutes
-
- {% if feed_interval %}
-
- {% endif %}
+
+
+
+
{# Rendered HTML content #}
+ {{ feed.title }} ({{ total_entries }} entries) +
+ {% if not feed.updates_enabled %} + Disabled + {% endif %} + + {% if feed.last_exception %} +
+
+ {% endif %}
+
+
+ {{ feed.last_exception.type_name }}:
+{{ feed.last_exception.value_str }}
+
+
+
{{ feed.last_exception.traceback_str }}
+
+
+ {% if not feed.updates_enabled %}
+
+ {% else %}
+
+ {% endif %}
+
+ {% if should_send_embed %}
+
+ {% else %}
+
+ {% endif %}
+
+
+
+
{{ html|safe }}
-{% if is_show_more_entries_button_visible %}
-
- Show more entries
-
+
+{% if show_more_entires_button %}
+
+ Show more entries
+
{% endif %}
+
{% endblock content %}
diff --git a/discord_rss_bot/templates/index.html b/discord_rss_bot/templates/index.html
index 341ec38..78f0729 100644
--- a/discord_rss_bot/templates/index.html
+++ b/discord_rss_bot/templates/index.html
@@ -1,155 +1,92 @@
{% extends "base.html" %}
{% block content %}
-
- -
-
- {% if feeds %}
-
- - - {% if feed.title %} - {{ feed.title }} - {% else %} - {{ feed.url }} - {% endif %} - - {% if not feed.updates_enabled %}Disabled{% endif %} - {% if feed.last_exception %}({{ feed.last_exception.value_str }}){% endif %} - - {% endfor %} -
- {{ feed_count.total }} feed{{'s' if feed_count.total > 1 else "" }} - - - {% if feed_count.broken %} - - {{ feed_count.broken }} broken - {% else %} - - {{ feed_count.broken }} broken - {% endif %} - - - {% if feed_count.total != feed_count.updates_enabled %} - - {{ feed_count.updates_enabled }} enabled - {% else %} - - {{ feed_count.updates_enabled }} enabled - {% endif %} - - - {{ entry_count.total }} entries - - ({{ entry_count.averages[0]|round(1) }}, - {{ entry_count.averages[1]|round(1) }}, - {{ entry_count.averages[2]|round(1) }}) - -
- - {% for hook_from_context in webhooks %} -
-
-
- {% set feeds_for_hook = [] %}
- {% for feed_webhook in feeds %}
- {% if hook_from_context.url == feed_webhook.webhook %}
- {% set _ = feeds_for_hook.append(feed_webhook) %}
- {% endif %}
- {% endfor %}
- {% if feeds_for_hook %}
-
- {% set domains = {} %}
- {% for feed_item in feeds_for_hook %}
- {% set feed = feed_item.feed %}
- {% set domain = feed_item.domain %}
- {% if domain not in domains %}
- {% set _ = domains.update({domain: []}) %}
- {% endif %}
- {% set _ = domains[domain].append(feed) %}
- {% endfor %}
-
- {% for domain, domain_feeds in domains.items() %}
-
- {% endfor %}
+
+
-
- {% endfor %}
- {% else %}
-
-
- {{ domain }} ({{ domain_feeds|length }})
-
-
- -
- {% for feed in domain_feeds %}
-
No feeds associated with this webhook.
- {% endif %} --
+
+ {% if feeds %}
+
+ {{ feed_count.total }} feed{{'s' if feed_count.total > 1 else "" }} + + + {% if feed_count.broken %} + - {{ feed_count.broken }} broken {% else %} -
- Hello there!
-
-
- You need to add a webhook here to get started. After that, you can
- add feeds here. You can find both of these links in the navigation bar
- above.
-
-
- If you have any questions or suggestions, feel free to contact me on tlovinator@gmail.com or TheLovinator#9276 on Discord.
-
-
- Thanks!
-
-
-
- Feeds without webhook:
- {% for broken_feed in broken_feeds %}
-
- {# Display username@youtube for YouTube feeds #}
- {% if "youtube.com/feeds/videos.xml" in broken_feed.url %}
- {% if "user=" in broken_feed.url %}
- {{ broken_feed.url.split("user=")[1] }}@youtube
- {% elif "channel_id=" in broken_feed.url %}
- {{ broken_feed.title if broken_feed.title else broken_feed.url.split("channel_id=")[1] }}@youtube
- {% else %}
- {{ broken_feed.url }}
- {% endif %}
- {% else %}
- {{ broken_feed.url }}
- {% endif %}
-
- {% endfor %}
-
+
+ {% endfor %}
+ {% else %}
+ + {{ hook_from_context.name }} +
+-
+ {% for feed_webhook in feeds %}
+ {% set feed = feed_webhook["feed"] %}
+ {% set hook_from_feed = feed_webhook["webhook"] %}
+ {% if hook_from_context.url == hook_from_feed %}
+
+ {{ feed.url }}
+ {% if not feed.updates_enabled %}Disabled{% endif %}
+ {% if feed.last_exception %}({{ feed.last_exception.value_str }}){% endif %}
- {% endif %}
-
- {% if feeds_without_attached_webhook %}
-
-
- {% endif %}
- -
- Feeds without attached webhook:
- {% for feed in feeds_without_attached_webhook %}
-
- {# Display username@youtube for YouTube feeds #}
- {% if "youtube.com/feeds/videos.xml" in feed.url %}
- {% if "user=" in feed.url %}
- {{ feed.url.split("user=")[1] }}@youtube
- {% elif "channel_id=" in feed.url %}
- {{ feed.title if feed.title else feed.url.split("channel_id=")[1] }}@youtube
- {% else %}
- {{ feed.url }}
- {% endif %}
- {% else %}
- {{ feed.url }}
- {% endif %}
-
- {% endfor %}
-
+ Hello there!
+
+ You need to add a webhook here to get started. After that, you can
+ add feeds here. You can find both of these links in the navigation bar
+ above.
+
+
+ If you have any questions or suggestions, feel free to contact me on tlovinator@gmail.com or TheLovinator#9276 on Discord.
+
+
+ Thanks!
+
+
+ {% endif %}
+
+ {% if feeds_without_attached_webhook %}
+ -
+ Feeds without webhook:
+ {% for broken_feed in broken_feeds %}
+ {{ broken_feed.url }}
+ {% endfor %}
+
+
+ {% endif %}
+
{% endblock content %}
diff --git a/discord_rss_bot/templates/nav.html b/discord_rss_bot/templates/nav.html
index 7442554..8b9ee37 100644
--- a/discord_rss_bot/templates/nav.html
+++ b/discord_rss_bot/templates/nav.html
@@ -1,9 +1,6 @@
-
+ Feeds without attached webhook:
+ {% for feed in feeds_without_attached_webhook %}
+ {{ feed.url }}
+ {% endfor %}
+