536 lines
22 KiB
Python
536 lines
22 KiB
Python
"""
|
|
Sidebar — server list with groups, search, add/edit/delete buttons, context menu.
|
|
"""
|
|
|
|
import tkinter as tk
|
|
from tkinter import messagebox
|
|
import customtkinter as ctk
|
|
from core.i18n import t
|
|
from core.icons import (
|
|
icon_text, TYPE_COLORS, TYPE_LABELS, CTX_ICONS, icon,
|
|
make_icon_button, reconfigure_icon_button,
|
|
)
|
|
from gui.widgets.status_badge import StatusBadge
|
|
|
|
GROUP_COLORS = [
|
|
"#ef4444", "#f97316", "#f59e0b", "#22c55e",
|
|
"#3b82f6", "#6366f1", "#a855f7", "#ec4899",
|
|
]
|
|
|
|
# Context menu: type → list of (i18n_key, tab_key_or_None)
|
|
_CONTEXT_ACTIONS = {
|
|
"ssh": [("ctx_open_terminal", "terminal"), ("ctx_browse_files", "files"), ("ctx_install_key", "keys")],
|
|
"telnet": [("ctx_open_terminal", "terminal")],
|
|
"winrm": [("ctx_open_powershell", "powershell")],
|
|
"mariadb": [("ctx_open_query", "query")],
|
|
"mssql": [("ctx_open_query", "query")],
|
|
"postgresql": [("ctx_open_query", "query")],
|
|
"redis": [("ctx_open_console", "console")],
|
|
"grafana": [("ctx_open_browser", None)],
|
|
"prometheus": [("ctx_open_browser", None)],
|
|
"rdp": [("ctx_connect", "launch")],
|
|
"vnc": [("ctx_connect", "launch")],
|
|
}
|
|
|
|
|
|
class Sidebar(ctk.CTkFrame):
|
|
def __init__(self, master, store, on_select=None, on_double_click=None, session_pool=None):
|
|
super().__init__(master, width=250, corner_radius=0)
|
|
self.store = store
|
|
self.on_select = on_select
|
|
self.on_double_click = on_double_click
|
|
self.session_pool = session_pool
|
|
self._selected_alias: str | None = None
|
|
self._server_frames: dict[str, ctk.CTkFrame] = {}
|
|
self._badges: dict[str, StatusBadge] = {}
|
|
self._session_indicators: dict[str, ctk.CTkLabel] = {}
|
|
self._group_headers: dict[str, ctk.CTkFrame] = {}
|
|
|
|
self.pack_propagate(False)
|
|
|
|
# Title
|
|
self.title_label = ctk.CTkLabel(self, text=t("servers"), font=ctk.CTkFont(size=18, weight="bold"))
|
|
self.title_label.pack(padx=15, pady=(15, 5))
|
|
|
|
# Search + Add Group button
|
|
search_frame = ctk.CTkFrame(self, fg_color="transparent")
|
|
search_frame.pack(fill="x", padx=10, pady=(5, 10))
|
|
|
|
self.search_var = ctk.StringVar()
|
|
self.search_var.trace_add("write", lambda *_: self._refresh_list())
|
|
self.search_entry = ctk.CTkEntry(search_frame, placeholder_text=t("search"), textvariable=self.search_var)
|
|
self.search_entry.pack(side="left", fill="x", expand=True)
|
|
|
|
self._add_group_btn = ctk.CTkButton(
|
|
search_frame, text="+", width=30, height=30,
|
|
font=ctk.CTkFont(size=14, weight="bold"),
|
|
command=self._on_add_group,
|
|
)
|
|
self._add_group_btn.pack(side="right", padx=(5, 0))
|
|
|
|
# Server list
|
|
self.list_frame = ctk.CTkScrollableFrame(self, fg_color="transparent")
|
|
self.list_frame.pack(fill="both", expand=True, padx=5, pady=0)
|
|
|
|
# Active sessions label
|
|
self._sessions_label = ctk.CTkLabel(
|
|
self, text="", font=ctk.CTkFont(size=10),
|
|
text_color="#6b7280", anchor="w"
|
|
)
|
|
self._sessions_label.pack(fill="x", padx=15, pady=(0, 2))
|
|
|
|
# Buttons
|
|
btn_frame = ctk.CTkFrame(self, fg_color="transparent")
|
|
btn_frame.pack(fill="x", padx=10, pady=10)
|
|
self.add_btn = make_icon_button(btn_frame, "add", t("add"), width=70, height=30, command=self._on_add)
|
|
self.add_btn.pack(side="left", padx=(0, 3))
|
|
self.edit_btn = make_icon_button(btn_frame, "edit", t("edit"), width=70, height=30, fg_color="#6b7280", command=self._on_edit)
|
|
self.edit_btn.pack(side="left", padx=3)
|
|
self.del_btn = make_icon_button(btn_frame, "delete", t("delete"), width=70, height=30, fg_color="#ef4444", hover_color="#dc2626", command=self._on_delete)
|
|
self.del_btn.pack(side="right", padx=(3, 0))
|
|
|
|
# Callbacks — set by app.py
|
|
self.add_callback = None
|
|
self.edit_callback = None
|
|
self.delete_callback = None
|
|
self.add_group_callback = None
|
|
self.open_tab_callback = None # (alias, tab_key) → select server + switch tab
|
|
self.check_status_callback = None # (alias) → check single server
|
|
self.open_browser_callback = None # (alias) → open server URL in browser
|
|
self.disconnect_callback = None # (alias) → disconnect all sessions
|
|
|
|
# Subscribe to store changes
|
|
self.store.subscribe(self._refresh_list)
|
|
self._refresh_list()
|
|
|
|
def update_language(self):
|
|
self.title_label.configure(text=t("servers"))
|
|
self.search_entry.configure(placeholder_text=t("search"))
|
|
reconfigure_icon_button(self.add_btn, "add", t("add"))
|
|
reconfigure_icon_button(self.edit_btn, "edit", t("edit"))
|
|
reconfigure_icon_button(self.del_btn, "delete", t("delete"))
|
|
self._update_sessions_label()
|
|
|
|
# ── Refresh / Render ──────────────────────────────
|
|
|
|
def _refresh_list(self):
|
|
# Clear
|
|
for widget in self.list_frame.winfo_children():
|
|
widget.destroy()
|
|
self._server_frames.clear()
|
|
self._badges.clear()
|
|
self._session_indicators.clear()
|
|
self._group_headers.clear()
|
|
|
|
active_aliases = self._get_active_aliases()
|
|
search = self.search_var.get().lower()
|
|
groups = self.store.get_groups()
|
|
|
|
if not groups:
|
|
# No groups — flat list (backward compatible)
|
|
self._render_server_list(self.store.get_all(), search, active_aliases)
|
|
else:
|
|
# Grouped layout
|
|
for group in groups:
|
|
group_servers = self.store.get_servers_in_group(group["id"])
|
|
filtered = self._filter_servers(group_servers, search)
|
|
|
|
# Skip empty groups when searching
|
|
if search and not filtered:
|
|
continue
|
|
|
|
self._render_group_header(group, len(group_servers))
|
|
|
|
# Show servers if not collapsed (or always when searching)
|
|
if not group.get("collapsed") or search:
|
|
self._render_server_list(filtered, search, active_aliases, indent=True)
|
|
|
|
# Ungrouped servers
|
|
ungrouped = self.store.get_servers_in_group(None)
|
|
filtered_ungrouped = self._filter_servers(ungrouped, search)
|
|
if filtered_ungrouped:
|
|
self._render_ungrouped_header(len(ungrouped))
|
|
self._render_server_list(filtered_ungrouped, search, active_aliases, indent=True)
|
|
|
|
self._highlight_selected()
|
|
self._update_sessions_label()
|
|
|
|
def _get_active_aliases(self) -> set:
|
|
if self.session_pool:
|
|
return set(self.session_pool.get_active_sessions())
|
|
return set()
|
|
|
|
def _filter_servers(self, servers: list[dict], search: str) -> list[dict]:
|
|
if not search:
|
|
return servers
|
|
return [s for s in servers
|
|
if search in s["alias"].lower() or search in s.get("ip", "").lower()]
|
|
|
|
def _render_group_header(self, group: dict, total_count: int):
|
|
"""Render a collapsible group header."""
|
|
frame = ctk.CTkFrame(self.list_frame, height=32,
|
|
fg_color=("gray90", "gray17"), cursor="hand2")
|
|
frame.pack(fill="x", padx=2, pady=(6, 1))
|
|
frame.pack_propagate(False)
|
|
|
|
# Collapse arrow
|
|
arrow_text = "\u25bc" if not group.get("collapsed") else "\u25b6"
|
|
arrow = ctk.CTkLabel(frame, text=arrow_text, width=16,
|
|
font=ctk.CTkFont(size=10), text_color="#9ca3af")
|
|
arrow.pack(side="left", padx=(8, 2))
|
|
|
|
# Color dot
|
|
color_dot = ctk.CTkLabel(frame, text="\u25cf", width=14,
|
|
font=ctk.CTkFont(size=12),
|
|
text_color=group.get("color", "#6b7280"))
|
|
color_dot.pack(side="left", padx=(0, 4))
|
|
|
|
# Group name
|
|
name_label = ctk.CTkLabel(frame, text=group["name"],
|
|
font=ctk.CTkFont(size=12, weight="bold"),
|
|
anchor="w")
|
|
name_label.pack(side="left", fill="x", expand=True)
|
|
|
|
# Count badge
|
|
count_label = ctk.CTkLabel(frame, text=f"({total_count})",
|
|
font=ctk.CTkFont(size=10),
|
|
text_color="#6b7280", width=30)
|
|
count_label.pack(side="right", padx=(0, 8))
|
|
|
|
# Click handlers
|
|
gid = group["id"]
|
|
for widget in [frame, arrow, color_dot, name_label, count_label]:
|
|
widget.bind("<Button-1>", lambda e, g=gid: self._toggle_group(g))
|
|
widget.bind("<Button-3>", lambda e, g=gid: self._show_group_context_menu(e, g))
|
|
|
|
self._group_headers[gid] = frame
|
|
|
|
def _render_ungrouped_header(self, total_count: int):
|
|
"""Render a non-collapsible 'Ungrouped' header."""
|
|
frame = ctk.CTkFrame(self.list_frame, height=28,
|
|
fg_color="transparent")
|
|
frame.pack(fill="x", padx=2, pady=(6, 1))
|
|
frame.pack_propagate(False)
|
|
|
|
ctk.CTkLabel(frame, text=t("ungrouped"),
|
|
font=ctk.CTkFont(size=11), text_color="#6b7280",
|
|
anchor="w").pack(side="left", padx=(10, 0))
|
|
ctk.CTkLabel(frame, text=f"({total_count})",
|
|
font=ctk.CTkFont(size=10), text_color="#6b7280",
|
|
width=30).pack(side="right", padx=(0, 8))
|
|
|
|
def _render_server_list(self, servers: list[dict], search: str,
|
|
active_aliases: set, indent: bool = False):
|
|
"""Render server items. If indent=True, add left padding for group nesting."""
|
|
pad_left = 12 if indent else 2
|
|
|
|
for server in servers:
|
|
alias = server["alias"]
|
|
ip = server.get("ip", "")
|
|
stype = server.get("type", "ssh")
|
|
|
|
frame = ctk.CTkFrame(self.list_frame, cursor="hand2", height=45)
|
|
frame.pack(fill="x", padx=(pad_left, 2), pady=2)
|
|
frame.pack_propagate(False)
|
|
|
|
# Status badge
|
|
badge = StatusBadge(frame, status=self.store.get_status(alias))
|
|
badge.pack(side="left", padx=(10, 5), pady=10)
|
|
self._badges[alias] = badge
|
|
|
|
# Type badge (colored short label)
|
|
type_color = TYPE_COLORS.get(stype, "#6b7280")
|
|
type_label_text = TYPE_LABELS.get(stype, stype.upper()[:3])
|
|
type_badge = ctk.CTkLabel(
|
|
frame, text=type_label_text,
|
|
font=ctk.CTkFont(size=9, weight="bold"),
|
|
text_color=type_color, width=30
|
|
)
|
|
type_badge.pack(side="left", padx=(0, 2), pady=10)
|
|
|
|
# Active session indicator (right side)
|
|
session_ind = ctk.CTkLabel(
|
|
frame, text="", width=12, height=12,
|
|
font=ctk.CTkFont(size=8)
|
|
)
|
|
session_ind.pack(side="right", padx=(0, 8), pady=10)
|
|
if alias in active_aliases:
|
|
session_ind.configure(text="\u25cf", text_color="#22c55e")
|
|
self._session_indicators[alias] = session_ind
|
|
|
|
# Info
|
|
info = ctk.CTkFrame(frame, fg_color="transparent")
|
|
info.pack(side="left", fill="both", expand=True, padx=5)
|
|
|
|
name_label = ctk.CTkLabel(info, text=alias,
|
|
font=ctk.CTkFont(size=13, weight="bold"),
|
|
anchor="w")
|
|
name_label.pack(fill="x")
|
|
detail_label = ctk.CTkLabel(info, text=ip,
|
|
font=ctk.CTkFont(size=10),
|
|
text_color="#9ca3af", anchor="w")
|
|
detail_label.pack(fill="x")
|
|
|
|
# Click handlers
|
|
for widget in [frame, info, name_label, detail_label, badge, type_badge, session_ind]:
|
|
widget.bind("<Button-1>", lambda e, a=alias: self._select(a))
|
|
widget.bind("<Double-Button-1>", lambda e, a=alias: self._on_double_click(a))
|
|
widget.bind("<Button-3>", lambda e, a=alias: self._show_context_menu(e, a))
|
|
|
|
self._server_frames[alias] = frame
|
|
|
|
# ── Group operations ──────────────────────────────
|
|
|
|
def _toggle_group(self, group_id: str):
|
|
"""Toggle collapse/expand for a group."""
|
|
group = self.store.get_group(group_id)
|
|
if group:
|
|
self.store.update_group(group_id, collapsed=not group.get("collapsed", False))
|
|
|
|
def _on_add_group(self):
|
|
"""Open GroupDialog to create a new group."""
|
|
if self.add_group_callback:
|
|
self.add_group_callback()
|
|
|
|
def _show_group_context_menu(self, event, group_id: str):
|
|
"""Right-click context menu for a group header."""
|
|
group = self.store.get_group(group_id)
|
|
if not group:
|
|
return
|
|
|
|
menu = tk.Menu(self, tearoff=0, bg="#2d2d44", fg="#d3d7cf",
|
|
activebackground="#44447a", activeforeground="#ffffff",
|
|
font=("Segoe UI", 10))
|
|
|
|
menu.add_command(label=t("rename_group"),
|
|
command=lambda: self._rename_group(group_id))
|
|
|
|
# Color submenu
|
|
color_menu = tk.Menu(menu, tearoff=0, bg="#2d2d44", fg="#d3d7cf",
|
|
activebackground="#44447a", activeforeground="#ffffff",
|
|
font=("Segoe UI", 10))
|
|
for color in GROUP_COLORS:
|
|
# Show colored dot + hex
|
|
color_menu.add_command(
|
|
label=f"\u25cf {color}",
|
|
command=lambda c=color: self.store.update_group(group_id, color=c),
|
|
)
|
|
menu.add_cascade(label=t("change_color"), menu=color_menu)
|
|
|
|
menu.add_separator()
|
|
|
|
groups = self.store.get_groups()
|
|
idx = next((i for i, g in enumerate(groups) if g["id"] == group_id), -1)
|
|
if idx > 0:
|
|
menu.add_command(label=t("move_up"),
|
|
command=lambda: self._move_group(group_id, -1))
|
|
if idx < len(groups) - 1:
|
|
menu.add_command(label=t("move_down"),
|
|
command=lambda: self._move_group(group_id, 1))
|
|
|
|
menu.add_separator()
|
|
|
|
menu.add_command(label=t("delete_group"),
|
|
command=lambda: self._delete_group(group_id),
|
|
foreground="#ef4444")
|
|
|
|
try:
|
|
menu.tk_popup(event.x_root, event.y_root)
|
|
finally:
|
|
menu.grab_release()
|
|
|
|
def _rename_group(self, group_id: str):
|
|
"""Open GroupDialog in edit mode."""
|
|
from gui.group_dialog import GroupDialog
|
|
group = self.store.get_group(group_id)
|
|
if group:
|
|
dialog = GroupDialog(self.winfo_toplevel(), self.store, group=group)
|
|
self.winfo_toplevel().wait_window(dialog)
|
|
|
|
def _delete_group(self, group_id: str):
|
|
"""Delete group after confirmation."""
|
|
group = self.store.get_group(group_id)
|
|
if not group:
|
|
return
|
|
msg = t("delete_group_confirm").format(name=group["name"])
|
|
if messagebox.askyesno(t("delete_group"), msg):
|
|
self.store.remove_group(group_id)
|
|
|
|
def _move_group(self, group_id: str, direction: int):
|
|
"""Move group up (-1) or down (+1)."""
|
|
groups = self.store.get_groups()
|
|
ids = [g["id"] for g in groups]
|
|
idx = ids.index(group_id)
|
|
new_idx = idx + direction
|
|
if 0 <= new_idx < len(ids):
|
|
ids[idx], ids[new_idx] = ids[new_idx], ids[idx]
|
|
self.store.reorder_groups(ids)
|
|
|
|
# ── Server selection ──────────────────────────────
|
|
|
|
def _select(self, alias: str):
|
|
self._selected_alias = alias
|
|
self._highlight_selected()
|
|
if self.on_select:
|
|
self.on_select(alias)
|
|
|
|
def _on_double_click(self, alias: str):
|
|
self._select(alias)
|
|
if self.on_double_click:
|
|
self.on_double_click(alias)
|
|
|
|
def _highlight_selected(self):
|
|
for alias, frame in self._server_frames.items():
|
|
if alias == self._selected_alias:
|
|
frame.configure(fg_color=("#3b82f6", "#1d4ed8"))
|
|
else:
|
|
frame.configure(fg_color=("gray85", "gray20"))
|
|
|
|
def get_selected(self) -> str | None:
|
|
return self._selected_alias
|
|
|
|
# ── Status / sessions ─────────────────────────────
|
|
|
|
def update_statuses(self):
|
|
for alias, badge in self._badges.items():
|
|
badge.set_status(self.store.get_status(alias))
|
|
|
|
def update_session_indicators(self):
|
|
if not self.session_pool:
|
|
return
|
|
active_aliases = set(self.session_pool.get_active_sessions())
|
|
for alias, ind in self._session_indicators.items():
|
|
if alias in active_aliases:
|
|
ind.configure(text="\u25cf", text_color="#22c55e")
|
|
else:
|
|
ind.configure(text="")
|
|
self._update_sessions_label()
|
|
|
|
def _update_sessions_label(self):
|
|
if self.session_pool:
|
|
count = len(self.session_pool.get_active_sessions())
|
|
if count > 0:
|
|
self._sessions_label.configure(text=t("active_sessions").format(count=count))
|
|
else:
|
|
self._sessions_label.configure(text="")
|
|
else:
|
|
self._sessions_label.configure(text="")
|
|
|
|
# ── Buttons ───────────────────────────────────────
|
|
|
|
def _on_add(self):
|
|
if self.add_callback:
|
|
self.add_callback()
|
|
|
|
def _on_edit(self):
|
|
if self.edit_callback and self._selected_alias:
|
|
self.edit_callback(self._selected_alias)
|
|
|
|
def _on_delete(self):
|
|
if self.delete_callback and self._selected_alias:
|
|
self.delete_callback(self._selected_alias)
|
|
|
|
# ── Context menu (server) ─────────────────────────
|
|
|
|
def _show_context_menu(self, event, alias: str):
|
|
"""Show right-click context menu for a server item."""
|
|
self._select(alias)
|
|
|
|
server = self.store.get_server(alias)
|
|
if not server:
|
|
return
|
|
stype = server.get("type", "ssh")
|
|
|
|
menu = tk.Menu(self, tearoff=0, bg="#2d2d44", fg="#d3d7cf",
|
|
activebackground="#44447a", activeforeground="#ffffff",
|
|
font=("Segoe UI", 10))
|
|
|
|
# Type-specific actions
|
|
actions = _CONTEXT_ACTIONS.get(stype, [])
|
|
for label_key, tab_key in actions:
|
|
ctx_icon = icon(CTX_ICONS.get(label_key, ""))
|
|
label_text = f"{ctx_icon} {t(label_key)}" if ctx_icon else t(label_key)
|
|
if tab_key:
|
|
menu.add_command(
|
|
label=label_text,
|
|
command=lambda a=alias, tk=tab_key: (
|
|
self.open_tab_callback(a, tk) if self.open_tab_callback else None
|
|
),
|
|
)
|
|
else:
|
|
menu.add_command(
|
|
label=label_text,
|
|
command=lambda a=alias: (
|
|
self.open_browser_callback(a) if self.open_browser_callback else None
|
|
),
|
|
)
|
|
|
|
if actions:
|
|
menu.add_separator()
|
|
|
|
# Dynamic disconnect if session is active
|
|
if self.session_pool and self.session_pool.has_active_session(alias):
|
|
dc_icon = icon(CTX_ICONS.get("ctx_disconnect", ""))
|
|
dc_label = f"{dc_icon} {t('ctx_disconnect')}" if dc_icon else t("ctx_disconnect")
|
|
menu.add_command(
|
|
label=dc_label,
|
|
command=lambda a=alias: (
|
|
self.disconnect_callback(a) if self.disconnect_callback else None
|
|
),
|
|
)
|
|
menu.add_separator()
|
|
|
|
# "Move to Group" submenu
|
|
groups = self.store.get_groups()
|
|
if groups:
|
|
move_menu = tk.Menu(menu, tearoff=0, bg="#2d2d44", fg="#d3d7cf",
|
|
activebackground="#44447a", activeforeground="#ffffff",
|
|
font=("Segoe UI", 10))
|
|
for g in groups:
|
|
move_menu.add_command(
|
|
label=f"\u25cf {g['name']}",
|
|
command=lambda a=alias, gid=g["id"]: self.store.set_server_group(a, gid),
|
|
)
|
|
move_menu.add_separator()
|
|
move_menu.add_command(
|
|
label=t("no_group"),
|
|
command=lambda a=alias: self.store.set_server_group(a, None),
|
|
)
|
|
menu.add_cascade(label=t("move_to_group"), menu=move_menu)
|
|
menu.add_separator()
|
|
|
|
# Universal actions
|
|
menu.add_command(
|
|
label=icon_text("status_check", t("ctx_check_status")),
|
|
command=lambda: (
|
|
self.check_status_callback(alias) if self.check_status_callback else None
|
|
),
|
|
)
|
|
menu.add_command(
|
|
label=icon_text("copy", t("ctx_copy_alias")),
|
|
command=lambda: self._copy_alias(alias),
|
|
)
|
|
|
|
menu.add_separator()
|
|
|
|
# Management
|
|
menu.add_command(
|
|
label=icon_text("edit", t("edit")),
|
|
command=lambda: self.edit_callback(alias) if self.edit_callback else None,
|
|
)
|
|
menu.add_command(
|
|
label=icon_text("delete", t("delete")),
|
|
command=lambda: self.delete_callback(alias) if self.delete_callback else None,
|
|
foreground="#ef4444",
|
|
)
|
|
|
|
try:
|
|
menu.tk_popup(event.x_root, event.y_root)
|
|
finally:
|
|
menu.grab_release()
|
|
|
|
def _copy_alias(self, alias: str):
|
|
"""Copy server alias to clipboard."""
|
|
self.clipboard_clear()
|
|
self.clipboard_append(alias)
|