No content available.
"
+ text: str = replace_tags_in_text_message(entry, reader=reader) 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):
+ if entry_is_blacklisted(entry, reader=reader):
blacklisted = "Blacklisted"
whitelisted: str = ""
- if entry_is_whitelisted(entry):
+ if entry_is_whitelisted(entry, reader=reader):
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) - to_discord_html: str = f"Send to Discord" + 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 = ""
+
image_html: str = f"
-{blacklisted}{whitelisted}
-"""
+""" # noqa: E501
return html.strip()
@@ -736,6 +1169,7 @@ 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.
"""
@@ -756,12 +1190,64 @@ 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):
+async def get_webhooks(
+ request: Request,
+ reader: Annotated[Reader, Depends(get_reader_dependency)],
+):
"""Page for adding a new webhook.
Args:
request: The request object.
+ reader: The Reader instance.
Returns:
HTMLResponse: The add webhook page.
@@ -782,136 +1268,241 @@ async def get_webhooks(request: Request):
@app.get("/", response_class=HTMLResponse)
-def get_index(request: Request):
+def get_index(
+ request: Request,
+ reader: Annotated[Reader, Depends(get_reader_dependency)],
+ message: str = "",
+):
"""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))
+ return templates.TemplateResponse(
+ request=request,
+ name="index.html",
+ context=make_context_index(request, message, reader),
+ )
-def make_context_index(request: Request):
+def make_context_index(request: Request, message: str = "", reader: Reader | None = None):
"""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.
"""
- hooks: list[dict[str, str]] = cast("list[dict[str, str]]", list(reader.get_tag((), "webhooks", [])))
+ effective_reader: Reader = reader or get_reader_dependency()
+ hooks: list[dict[str, str]] = cast("list[dict[str, str]]", list(effective_reader.get_tag((), "webhooks", [])))
- feed_list = []
- broken_feeds = []
- feeds_without_attached_webhook = []
+ feed_list: list[dict[str, JSONType | Feed | str]] = []
+ broken_feeds: list[Feed] = []
+ feeds_without_attached_webhook: list[Feed] = []
- feeds: Iterable[Feed] = reader.get_feeds()
+ # Get all feeds and organize them
+ feeds: Iterable[Feed] = effective_reader.get_feeds()
for feed in feeds:
- try:
- webhook = reader.get_tag(feed.url, "webhook")
- feed_list.append({"feed": feed, "webhook": webhook})
- except TagNotFoundError:
+ webhook: str = str(effective_reader.get_tag(feed.url, "webhook", ""))
+ if not webhook:
broken_feeds.append(feed)
continue
- webhook_list = [hook["url"] for hook in hooks]
+ feed_list.append({"feed": feed, "webhook": webhook, "domain": extract_domain(feed.url)})
+
+ webhook_list: list[str] = [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": reader.get_feed_counts(),
- "entry_count": reader.get_entry_counts(),
+ "feed_count": effective_reader.get_feed_counts(),
+ "entry_count": effective_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()]):
+async def remove_feed(
+ feed_url: Annotated[str, Form()],
+ reader: Annotated[Reader, Depends(get_reader_dependency)],
+):
"""Get a feed by URL.
Args:
feed_url: The feed to add.
-
- Raises:
- HTTPException: Feed not found
+ reader: The Reader instance.
Returns:
RedirectResponse: Redirect to the index page.
+
+ Raises:
+ HTTPException: Feed not found
"""
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):
+async def search(
+ request: Request,
+ query: str,
+ reader: Annotated[Reader, Depends(get_reader_dependency)],
+):
"""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 = {
- "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)
+ context = create_search_context(query, reader=reader)
+ return templates.TemplateResponse(request=request, name="search.html", context={"request": request, **context})
@app.get("/post_entry", response_class=HTMLResponse)
-async def post_entry(entry_id: str):
+async def post_entry(
+ entry_id: str,
+ reader: Annotated[Reader, Depends(get_reader_dependency)],
+ feed_url: 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)
- entry: Entry | None = next((entry for entry in reader.get_entries() if entry.id == unquoted_entry_id), None)
+ 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)
+
if entry is None:
return HTMLResponse(status_code=404, content=f"Entry '{entry_id}' not found.")
- if result := send_entry_to_discord(entry=entry):
+ if result := send_entry_to_discord(entry=entry, reader=reader):
return result
# Redirect to the feed page.
- clean_feed_url: str = entry.feed.url.strip()
- return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(clean_feed_url)}", status_code=303)
+ redirect_feed_url: str = entry.feed.url.strip()
+ return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(redirect_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()]):
+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()] = "",
+):
"""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", []))
@@ -919,15 +1510,20 @@ def modify_webhook(old_hook: Annotated[str, Form()], new_hook: Annotated[str, Fo
# 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.strip():
- hook["url"] = new_hook.strip()
+ if hook["url"] in old_hook_clean:
+ hook["url"] = new_hook_clean
# Check if it has been modified.
- if hook["url"] != new_hook.strip():
+ if hook["url"] != new_hook_clean:
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]
@@ -935,16 +1531,506 @@ def modify_webhook(old_hook: Annotated[str, Form()], new_hook: Annotated[str, Fo
# matches the old one.
feeds: Iterable[Feed] = reader.get_feeds()
for feed in feeds:
- try:
- webhook = reader.get_tag(feed, "webhook")
- except TagNotFoundError:
- continue
+ webhook: str = str(reader.get_tag(feed, "webhook", ""))
- if webhook == old_hook.strip():
- reader.set_tag(feed.url, "webhook", new_hook.strip()) # pyright: ignore[reportArgumentType]
+ if webhook == old_hook_clean:
+ reader.set_tag(feed.url, "webhook", new_hook_clean) # pyright: ignore[reportArgumentType]
- # Redirect to the webhook page.
- return RedirectResponse(url="/webhooks", status_code=303)
+ 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)
if __name__ == "__main__":
@@ -957,9 +2043,9 @@ if __name__ == "__main__":
uvicorn.run(
"main:app",
- log_level="info",
+ log_level="debug",
host="0.0.0.0", # noqa: S104
- port=5000,
+ port=3000,
proxy_headers=True,
forwarded_allow_ips="*",
)
diff --git a/discord_rss_bot/missing_tags.py b/discord_rss_bot/missing_tags.py
deleted file mode 100644
index 84f375e..0000000
--- a/discord_rss_bot/missing_tags.py
+++ /dev/null
@@ -1,106 +0,0 @@
-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 c81b398..85129ac 100644
--- a/discord_rss_bot/search.py
+++ b/discord_rss_bot/search.py
@@ -3,66 +3,78 @@ 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, Feed, HighlightedString, Reader
+ from reader import EntrySearchResult
+ from reader import Feed
+ from reader import HighlightedString
+ from reader import Reader
-def create_html_for_search_results(query: str, custom_reader: Reader | None = None) -> str:
- """Create HTML for the search results.
+def create_search_context(query: str, reader: Reader) -> dict:
+ """Build context for search.html template.
Args:
- query: Our search query
- custom_reader: The reader. If None, we will get the reader from the settings.
+ query (str): The search query.
+ reader (Reader): Custom Reader instance.
Returns:
- str: The HTML.
+ dict: Context dictionary for rendering the search results.
"""
- # 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)
- html: str = ""
+ results: list[dict] = []
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:
- 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)
+ 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
- html += f"""
- {entry.title}
-{f"By {entry.author} @" if entry.author else ""}{published} - {to_discord_html} +{blacklisted}{whitelisted}{from_another_feed}{entry.title}
+{feed_link}{f"By {entry.author} @" if entry.author else ""}{published} - {to_discord_html} {text} +{video_embed_html} {image_html}
-
-
- """
+ summary: str = add_spans(highlighted) if highlighted else "(no preview available)"
- return 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,
+ }
-def add_span_with_slice(highlighted_string: HighlightedString) -> str:
- """Add span tags to the string to highlight the search results.
+def add_spans(highlighted_string: HighlightedString | None) -> str:
+ """Wrap all highlighted parts with tags.
Args:
- highlighted_string: The highlighted string.
+ highlighted_string (HighlightedString | None): The highlighted string to process.
Returns:
- str: The string with added tags.
+ str: The processed string with tags around highlighted parts.
"""
- # 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 = "", "", ""
+ if highlighted_string is None:
+ return ""
+
+ value: str = highlighted_string.value
+ parts: list[str] = []
+ last_index = 0
for txt_slice in highlighted_string.highlights:
- 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 :]}"
+ parts.extend((
+ value[last_index : txt_slice.start],
+ f"{value[txt_slice.start : txt_slice.stop]}",
+ ))
+ last_index = txt_slice.stop
- return f"{before_span}{span_part}{after_span}"
+ # add any trailing text
+ parts.append(value[last_index:])
+
+ return "".join(parts)
diff --git a/discord_rss_bot/settings.py b/discord_rss_bot/settings.py
index a99733e..194bf08 100644
--- a/discord_rss_bot/settings.py
+++ b/discord_rss_bot/settings.py
@@ -1,16 +1,23 @@
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, make_reader
+from reader import Reader
+from reader import make_reader
if typing.TYPE_CHECKING:
from reader.types import JSONType
-data_dir: str = user_data_dir(appname="discord_rss_bot", appauthor="TheLovinator", roaming=True, ensure_exists=True)
+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,
+)
# TODO(TheLovinator): Add default things to the database and make the edible.
@@ -24,7 +31,7 @@ default_custom_embed: dict[str, str] = {
}
-@lru_cache
+@lru_cache(maxsize=1)
def get_reader(custom_location: Path | None = None) -> Reader:
"""Get the reader.
@@ -35,5 +42,13 @@ 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))
- return 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
diff --git a/discord_rss_bot/static/styles.css b/discord_rss_bot/static/styles.css
index db0cfba..266f951 100644
--- a/discord_rss_bot/static/styles.css
+++ b/discord_rss_bot/static/styles.css
@@ -13,3 +13,7 @@ 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
new file mode 100644
index 0000000..a59e97b
--- /dev/null
+++ b/discord_rss_bot/templates/_webhook_mass_update_preview.html
@@ -0,0 +1,73 @@
+{% 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 a8640dd..9146b35 100644 --- a/discord_rss_bot/templates/base.html +++ b/discord_rss_bot/templates/base.html @@ -1,13 +1,12 @@ - + 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." /> @@ -18,19 +17,20 @@ {% 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 f018d3a..48cb3bc 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 %} -
-
{{ feed.last_exception.type_name }}:
-{{ feed.last_exception.value_str }}
-
-
-
{{ feed.last_exception.traceback_str }}
+
+
-
{# 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 }}
+ 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' }}
+
+
+
- {% endif %}
-
-
- + 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 %}
-
-
- {% if not feed.updates_enabled %}
-
- {% else %}
-
- {% endif %}
-
- {% if should_send_embed %}
-
- {% else %}
-
- {% endif %}
-
-
-
-
{{ html|safe }}
-
-{% if show_more_entires_button %}
-
- Show more entries
-
+{% if is_show_more_entries_button_visible %}
+
+ Show more entries
+
{% endif %}
-
{% endblock content %}
diff --git a/discord_rss_bot/templates/index.html b/discord_rss_bot/templates/index.html
index 78f0729..341ec38 100644
--- a/discord_rss_bot/templates/index.html
+++ b/discord_rss_bot/templates/index.html
@@ -1,92 +1,155 @@
{% 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 + +
-
+
+ {% if feeds %}
+
+ {{ 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 %}
{% else %}
- - {{ feed_count.broken }} broken
+
+
+ {% endfor %}
+ {% else %}
+
+
+ {{ domain }} ({{ domain_feeds|length }})
+
+
+ -
+ {% for feed in domain_feeds %}
+
No feeds associated with this webhook.
+ {% endif %} +
+ 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!
+
-
- {{ 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 %}
+
+ {% if broken_feeds %}
+
- {% endfor %}
- {% else %}
-
+
- {% endif %}
- {% endfor %}
-
- -
+ 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 %}
+
- 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 %}
--
- Feeds without attached webhook:
- {% for feed in feeds_without_attached_webhook %}
- {{ feed.url }}
- {% endfor %}
-
+
+ {% endif %}
+
{% endblock content %}
diff --git a/discord_rss_bot/templates/nav.html b/discord_rss_bot/templates/nav.html
index 8b9ee37..7442554 100644
--- a/discord_rss_bot/templates/nav.html
+++ b/discord_rss_bot/templates/nav.html
@@ -1,6 +1,9 @@
-
+ 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 %}
+