e3cli 0.3.1__py3-none-any.whl

e3cli/commands/schedule.py

@@ -0,0 +1,42 @@
+"""e3cli schedule"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from e3cli.config import load_config
+from e3cli.i18n import t
+from e3cli.scheduler import cron
+
+console = Console()
+app = typer.Typer()
+
+
+@app.command()
+def enable(
+    interval: int = typer.Option(None, "--interval", "-i", help=t("sched.opt_interval")),
+):
+    """Enable automatic sync (install cron job)."""
+    cfg = load_config()
+    minutes = interval or cfg.schedule.interval_minutes
+    cron.install(minutes)
+    console.print(f"[green]{t('sched.enabled', m=minutes)}[/green]")
+
+
+@app.command()
+def disable():
+    """Disable automatic sync (remove cron job)."""
+    cron.uninstall()
+    console.print(f"[green]{t('sched.disabled')}[/green]")
+
+
+@app.command()
+def status():
+    """Show current schedule status."""
+    if cron.is_installed():
+        line = cron.get_schedule_line()
+        console.print(f"[green]{t('sched.status_on')}[/green]")
+        console.print(f"  [dim]{line}[/dim]")
+    else:
+        console.print(f"[yellow]{t('sched.status_off')}[/yellow]")

e3cli/commands/setup.py

@@ -0,0 +1,142 @@
+"""e3cli setup — interactive setup wizard."""
+
+from __future__ import annotations
+
+import getpass
+import os
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from e3cli import __version__
+from e3cli.auth import AuthError, get_token
+from e3cli.config import CONFIG_FILE, ensure_dirs, save_token
+from e3cli.credential import save_credentials
+from e3cli.i18n import set_lang, t
+
+console = Console()
+app = typer.Typer()
+
+BANNER = r"""
+    _____ ____   _____ _      _____
+   / ____|___ \ / ____| |    |_   _|
+  | |__    __) | |    | |      | |
+  |  __|  |__ <| |    | |      | |
+  | |____ ___) | |____| |____ _| |_
+  |______|____/ \_____|______|_____|
+"""
+
+
+def is_first_run() -> bool:
+    return not CONFIG_FILE.exists()
+
+
+def _choose_language() -> str:
+    """讓使用者選擇語言 / Let user choose language."""
+    console.print("[bold cyan]Language / 語言[/bold cyan]")
+    console.print("  [cyan]1[/cyan] 繁體中文")
+    console.print("  [cyan]2[/cyan] English")
+    choice = typer.prompt("Choose / 請選擇", default="1", show_default=True)
+    if choice.strip() in ("2", "en", "EN", "english", "English"):
+        return "en"
+    return "zh"
+
+
+def run_setup_wizard() -> None:
+    console.print()
+    console.print(Panel(
+        Text(BANNER, style="cyan", justify="center"),
+        title=f"[bold]Welcome to e3cli v{__version__}[/bold]",
+        subtitle="NYCU E3 Moodle automation tool",
+        border_style="cyan",
+    ))
+    console.print()
+
+    # Step 0: Language
+    lang = _choose_language()
+    set_lang(lang)
+    console.print()
+
+    console.print(f"[bold]{t('setup.welcome')}[/bold]")
+    console.print()
+
+    # Step 1: Moodle URL
+    console.print(f"[bold cyan]Step 1/4[/bold cyan] — {t('setup.step_url')}")
+    console.print(f"[dim]{t('setup.step_url_hint')}[/dim]")
+    url = typer.prompt(
+        "Moodle URL",
+        default="https://e3p.nycu.edu.tw",
+        show_default=True,
+    ).rstrip("/")
+    console.print()
+
+    # Step 2: Download directory
+    console.print(f"[bold cyan]Step 2/4[/bold cyan] — {t('setup.step_dir')}")
+    console.print(f"[dim]{t('setup.step_dir_hint')}[/dim]")
+    default_dir = os.path.expanduser("~/e3-downloads")
+    download_dir = typer.prompt(
+        t("setup.step_dir"),
+        default=default_dir,
+        show_default=True,
+    )
+    console.print()
+
+    # Step 3: Save config (including language preference)
+    console.print(f"[bold cyan]Step 3/4[/bold cyan] — {t('setup.step_save')}")
+    ensure_dirs()
+    config_content = f"""[moodle]
+url = "{url}"
+service = "moodle_mobile_app"
+
+[storage]
+download_dir = "{download_dir}"
+
+[schedule]
+interval_minutes = 60
+notify = true
+
+[general]
+lang = "{lang}"
+"""
+    CONFIG_FILE.write_text(config_content)
+    console.print(f"[green]  {t('setup.config_saved', path=CONFIG_FILE)}[/green]")
+    console.print()
+
+    # Step 4: Login
+    console.print(f"[bold cyan]Step 4/4[/bold cyan] — {t('setup.step_login')}")
+    want_login = typer.confirm(t("setup.want_login"), default=True)
+
+    if want_login:
+        username = typer.prompt(f"  {t('setup.prompt_id')}")
+        password = getpass.getpass(f"  {t('login.prompt_pass')}")
+
+        console.print(f"[dim]  {t('login.connecting', url=url)}[/dim]")
+        try:
+            token = get_token(url, username, password)
+            save_token(token)
+
+            save_creds = typer.confirm(f"  {t('setup.want_save_creds')}", default=True)
+            if save_creds:
+                save_credentials(username, password)
+                console.print(f"[green]  {t('login.success_saved')}[/green]")
+            else:
+                console.print(f"[green]  {t('login.success')}[/green]")
+        except AuthError as e:
+            console.print(f"[red]  ✗ {e}[/red]")
+            console.print(f"[dim]  {t('setup.login_fail_hint')}[/dim]")
+    console.print()
+
+    # Done
+    console.print(Panel(
+        f"[bold green]{t('setup.done_title')}[/bold green]\n\n{t('setup.done_body')}",
+        title="[bold]Ready![/bold]",
+        border_style="green",
+    ))
+
+
+@app.callback(invoke_without_command=True)
+def setup():
+    """Re-run interactive setup wizard."""
+    run_setup_wizard()

e3cli/commands/submit.py

@@ -0,0 +1,77 @@
+"""e3cli submit"""
+
+from __future__ import annotations
+
+import time
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from e3cli.api.assignments import get_submission_status, save_submission
+from e3cli.commands._common import get_client, get_db
+from e3cli.i18n import t
+
+console = Console()
+app = typer.Typer()
+
+
+@app.callback(invoke_without_command=True)
+def submit(
+    assignment_id: int = typer.Argument(..., help="Assignment ID"),
+    files: list[Path] = typer.Argument(..., help="File(s) to submit"),
+    text: str = typer.Option("", "--text", "-t", help=t("submit.opt_text")),
+    force: bool = typer.Option(False, "--force", "-f", help=t("submit.opt_force")),
+):
+    """Upload and submit an assignment."""
+    for f in files:
+        if not f.exists():
+            console.print(f"[red]✗ {t('submit.not_found', f=f)}[/red]")
+            raise typer.Exit(1)
+
+    client = get_client()
+    db = get_db()
+
+    console.print(f"[dim]{t('submit.checking', id=assignment_id)}[/dim]")
+    try:
+        status = get_submission_status(client, assignment_id)
+    except Exception as e:
+        console.print(f"[red]{t('submit.check_fail', e=e)}[/red]")
+        raise typer.Exit(1)
+
+    assign_info = status.get("lastattempt", {}).get("assign", {})
+    duedate = assign_info.get("duedate", 0)
+    if duedate and duedate < int(time.time()) and not force:
+        dt = datetime.fromtimestamp(duedate).strftime("%Y-%m-%d %H:%M")
+        console.print(f"[red]✗ {t('submit.past_due', dt=dt)}[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]{t('submit.uploading', n=len(files))}[/dim]")
+    itemid = 0
+    for f in files:
+        result = client.upload_file(f, itemid=itemid)
+        if result and isinstance(result, list):
+            itemid = result[0].get("itemid", itemid)
+        console.print(f"  ✓ {f.name}")
+
+    console.print(f"[dim]{t('submit.submitting')}[/dim]")
+    save_submission(client, assignment_id, itemid, text)
+
+    verify = get_submission_status(client, assignment_id)
+    sub_status = (
+        verify.get("lastattempt", {})
+        .get("submission", {})
+        .get("status", "unknown")
+    )
+
+    if sub_status == "submitted":
+        console.print(f"[green]{t('submit.ok')}[/green]")
+        db.update_assignment_status(assignment_id, "submitted")
+    elif sub_status == "draft":
+        console.print(f"[yellow]{t('submit.draft')}[/yellow]")
+        db.update_assignment_status(assignment_id, "draft")
+    else:
+        console.print(f"[yellow]⚠ Status: {sub_status}[/yellow]")
+
+    db.close()

e3cli/commands/sync.py

@@ -0,0 +1,115 @@
+"""e3cli sync"""
+
+from __future__ import annotations
+
+import re
+import time
+
+import typer
+from rich.console import Console
+
+from e3cli.api.assignments import get_assignments
+from e3cli.api.courses import get_course_contents, get_enrolled_courses
+from e3cli.api.files import download_file
+from e3cli.api.site import get_site_info
+from e3cli.commands._common import get_client, get_db
+from e3cli.config import load_config
+from e3cli.i18n import t
+
+console = Console()
+app = typer.Typer()
+
+
+def _sanitize(name: str) -> str:
+    return re.sub(r'[<>:"/\\|?*]', "_", name).strip().rstrip(".")
+
+
+@app.callback(invoke_without_command=True)
+def sync(
+    quiet: bool = typer.Option(False, "--quiet", "-q", help=t("sync.opt_quiet")),
+):
+    """Sync all course materials and assignment status."""
+    client = get_client()
+    db = get_db()
+    cfg = load_config()
+    download_dir = cfg.storage.download_dir
+    now = int(time.time())
+
+    info = get_site_info(client)
+    userid = info["userid"]
+    if not quiet:
+        console.print(f"[bold]{t('sync.syncing', name=info['fullname'])}[/bold]\n")
+
+    course_list = get_enrolled_courses(client, userid)
+    courseids = []
+    course_names = {}
+
+    for c in course_list:
+        cid = c["id"]
+        courseids.append(cid)
+        course_names[cid] = c.get("shortname", "")
+        db.upsert_course(cid, c.get("shortname", ""), c.get("fullname", ""))
+
+    new_files = 0
+    for c in course_list:
+        cid = c["id"]
+        cname = _sanitize(c.get("shortname", str(cid)))
+
+        try:
+            contents = get_course_contents(client, cid)
+        except Exception:
+            continue
+
+        for section in contents:
+            section_name = _sanitize(section.get("name", "unnamed"))
+            for module in section.get("modules", []):
+                mid = module.get("id", 0)
+                for file_info in module.get("contents", []):
+                    fname = file_info.get("filename", "")
+                    furl = file_info.get("fileurl", "")
+                    fsize = file_info.get("filesize", 0)
+                    ftime = file_info.get("timemodified", 0)
+
+                    if not fname or not furl:
+                        continue
+                    if db.is_downloaded(cid, mid, fname, ftime):
+                        continue
+
+                    dest = download_dir / cname / section_name / fname
+                    try:
+                        download_file(client, furl, dest)
+                        db.record_download(cid, mid, fname, furl, fsize, ftime, str(dest), now)
+                        new_files += 1
+                        if not quiet:
+                            console.print(f"  [green]↓[/green] {cname}/{section_name}/{fname}")
+                    except Exception as e:
+                        if not quiet:
+                            console.print(f"  [red]✗[/red] {fname}: {e}")
+
+        time.sleep(0.3)
+
+    new_assignments = 0
+    if courseids:
+        try:
+            data = get_assignments(client, courseids)
+            for course in data.get("courses", []):
+                cid = course["id"]
+                cname = course_names.get(cid, "")
+                for a in course.get("assignments", []):
+                    is_new = db.upsert_assignment(
+                        a["id"], cid, cname, a["name"], a.get("duedate", 0), now,
+                    )
+                    if is_new:
+                        new_assignments += 1
+                        if not quiet:
+                            console.print(
+                                f"  [yellow]{t('sync.new_assign', course=cname, name=a['name'])}[/yellow]"
+                            )
+        except Exception as e:
+            if not quiet:
+                console.print(f"[red]{t('sync.assign_fail', e=e)}[/red]")
+
+    if not quiet:
+        console.print(f"\n[green]{t('sync.done', files=new_files, assigns=new_assignments)}[/green]")
+
+    db.close()

e3cli/config.py

@@ -0,0 +1,98 @@
+"""設定管理 — 讀取/寫入 ~/.e3cli/config.toml"""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".e3cli"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+TOKEN_FILE = CONFIG_DIR / "token"
+DB_PATH = CONFIG_DIR / "data" / "e3cli.db"
+DEFAULT_DOWNLOAD_DIR = Path.home() / "e3-downloads"
+
+
+@dataclass
+class MoodleConfig:
+    url: str = "https://e3p.nycu.edu.tw"
+    service: str = "moodle_mobile_app"
+
+
+@dataclass
+class StorageConfig:
+    download_dir: Path = field(default_factory=lambda: DEFAULT_DOWNLOAD_DIR)
+    db_path: Path = field(default_factory=lambda: DB_PATH)
+
+
+@dataclass
+class ScheduleConfig:
+    interval_minutes: int = 60
+    notify: bool = True
+
+
+@dataclass
+class GeneralConfig:
+    lang: str = ""  # "" = auto-detect, "zh", "en"
+
+
+@dataclass
+class Config:
+    moodle: MoodleConfig = field(default_factory=MoodleConfig)
+    storage: StorageConfig = field(default_factory=StorageConfig)
+    schedule: ScheduleConfig = field(default_factory=ScheduleConfig)
+    general: GeneralConfig = field(default_factory=GeneralConfig)
+
+
+def ensure_dirs() -> None:
+    """建立必要的目錄。"""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    (CONFIG_DIR / "data").mkdir(exist_ok=True)
+
+
+def load_config() -> Config:
+    """從 ~/.e3cli/config.toml 載入設定，不存在則使用預設值。"""
+    ensure_dirs()
+    cfg = Config()
+
+    if CONFIG_FILE.exists():
+        with open(CONFIG_FILE, "rb") as f:
+            data = tomllib.load(f)
+
+        if "moodle" in data:
+            m = data["moodle"]
+            cfg.moodle.url = m.get("url", cfg.moodle.url)
+            cfg.moodle.service = m.get("service", cfg.moodle.service)
+
+        if "storage" in data:
+            s = data["storage"]
+            if "download_dir" in s:
+                cfg.storage.download_dir = Path(os.path.expanduser(s["download_dir"]))
+            if "db_path" in s:
+                cfg.storage.db_path = Path(os.path.expanduser(s["db_path"]))
+
+        if "schedule" in data:
+            sc = data["schedule"]
+            cfg.schedule.interval_minutes = sc.get("interval_minutes", cfg.schedule.interval_minutes)
+            cfg.schedule.notify = sc.get("notify", cfg.schedule.notify)
+
+        if "general" in data:
+            g = data["general"]
+            cfg.general.lang = g.get("lang", cfg.general.lang)
+
+    return cfg
+
+
+def save_token(token: str) -> None:
+    """儲存 token 到 ~/.e3cli/token (chmod 600)。"""
+    ensure_dirs()
+    TOKEN_FILE.write_text(token)
+    TOKEN_FILE.chmod(0o600)
+
+
+def load_token() -> str | None:
+    """讀取已儲存的 token，不存在則回傳 None。"""
+    if TOKEN_FILE.exists():
+        return TOKEN_FILE.read_text().strip()
+    return None

e3cli/credential.py

@@ -0,0 +1,116 @@
+"""
+安全帳密儲存 — 純 Python stdlib 實作 (無需 cryptography/Rust)。
+
+加密流程：
+1. 首次使用時產生 32 bytes 隨機 key，存入 ~/.e3cli/key (chmod 600)
+2. 帳密 JSON → PBKDF2 派生加密金鑰 → AES-like XOR stream cipher → base64 編碼
+3. 加上 HMAC-SHA256 驗證完整性，防止竄改
+
+安全模型：
+- key 檔案權限 0600，僅擁有者可讀
+- key 與 credentials 分離
+- HMAC 驗證確保資料完整性
+- 密碼從不以明文寫入磁碟
+- logout 時覆寫後再刪除
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+
+from e3cli.config import CONFIG_DIR, ensure_dirs
+
+KEY_FILE = CONFIG_DIR / "key"
+CRED_FILE = CONFIG_DIR / "credentials.enc"
+
+
+def _get_or_create_key() -> bytes:
+    """取得加密金鑰，不存在則產生新的。"""
+    ensure_dirs()
+    if KEY_FILE.exists():
+        return KEY_FILE.read_bytes()
+    key = os.urandom(32)
+    KEY_FILE.write_bytes(key)
+    KEY_FILE.chmod(0o600)
+    return key
+
+
+def _derive_key(master_key: bytes, salt: bytes) -> bytes:
+    """用 PBKDF2-HMAC-SHA256 派生加密金鑰。"""
+    return hashlib.pbkdf2_hmac("sha256", master_key, salt, iterations=100_000)
+
+
+def _xor_bytes(data: bytes, key_stream: bytes) -> bytes:
+    """XOR data with repeating key stream."""
+    return bytes(d ^ key_stream[i % len(key_stream)] for i, d in enumerate(data))
+
+
+def _encrypt(plaintext: bytes, master_key: bytes) -> bytes:
+    """加密：salt + HMAC + ciphertext，base64 編碼輸出。"""
+    salt = os.urandom(16)
+    derived = _derive_key(master_key, salt)
+    ciphertext = _xor_bytes(plaintext, derived)
+    mac = hmac.new(derived, ciphertext, hashlib.sha256).digest()
+    # Format: salt (16) + mac (32) + ciphertext (variable)
+    return base64.b64encode(salt + mac + ciphertext)
+
+
+def _decrypt(encoded: bytes, master_key: bytes) -> bytes | None:
+    """解密，驗證 HMAC 後回傳明文，失敗回傳 None。"""
+    try:
+        raw = base64.b64decode(encoded)
+        if len(raw) < 48:  # salt(16) + mac(32) minimum
+            return None
+        salt = raw[:16]
+        stored_mac = raw[16:48]
+        ciphertext = raw[48:]
+        derived = _derive_key(master_key, salt)
+        # 驗證 HMAC
+        expected_mac = hmac.new(derived, ciphertext, hashlib.sha256).digest()
+        if not hmac.compare_digest(stored_mac, expected_mac):
+            return None
+        return _xor_bytes(ciphertext, derived)
+    except Exception:
+        return None
+
+
+def save_credentials(username: str, password: str) -> None:
+    """加密儲存帳號密碼。"""
+    ensure_dirs()
+    key = _get_or_create_key()
+    data = json.dumps({"username": username, "password": password}).encode()
+    encrypted = _encrypt(data, key)
+    CRED_FILE.write_bytes(encrypted)
+    CRED_FILE.chmod(0o600)
+
+
+def load_credentials() -> tuple[str, str] | None:
+    """讀取已儲存的帳密，回傳 (username, password) 或 None。"""
+    if not CRED_FILE.exists() or not KEY_FILE.exists():
+        return None
+    try:
+        key = _get_or_create_key()
+        decrypted = _decrypt(CRED_FILE.read_bytes(), key)
+        if decrypted is None:
+            return None
+        data = json.loads(decrypted)
+        return data["username"], data["password"]
+    except (KeyError, json.JSONDecodeError):
+        return None
+
+
+def clear_credentials() -> None:
+    """安全清除所有認證資料（帳密 + token + key）。"""
+    for path in [CRED_FILE, KEY_FILE, CONFIG_DIR / "token"]:
+        if path.exists():
+            path.write_bytes(b"\x00" * max(path.stat().st_size, 1))
+            path.unlink()
+
+
+def has_credentials() -> bool:
+    """是否已儲存帳密。"""
+    return CRED_FILE.exists() and KEY_FILE.exists()