v2.3.10b

Author: KanoCifer

backend/.gitignore

@@ -32,3 +32,4 @@ trans.sh
 extract_messages.py
 babel.cfg
 legacy/
+jwt

backend/app/configs/config.py

@@ -38,6 +38,7 @@ class Settings(BaseSettings):
     FEISHU_WEBHOOK_URL: str = ""
     VITE_JS_API_TOKEN: str = ""
     AMAP_SECURITY_CODE: str = ""
+    AMAP_WEB_KEY: str = ""
 
     model_config = SettingsConfigDict(
         env_file=get_env_file_path(),

backend/app/main.py

@@ -60,7 +60,7 @@ async def lifespan(app: FastAPI):
         database=app.state.mongo,
         document_models=[MessageBoard, Post, RssArticle],
     )
-    app.state.redis, app.state.redis2 = await init_redis()
+    app.state.redis, app.state.redis2 = await init_redis()  # type: ignore
 
     logger.debug(f"Settings:{get_settings().model_dump()}")
     logger.info("FastAPI started successfully.")

backend/app/routers/public.py

@@ -12,6 +12,7 @@
 from datetime import UTC, datetime
 from xml.etree.ElementTree import Element, SubElement, tostring
 
+import httpx
 from fastapi import APIRouter, Body, Depends, Request
 from fastapi.responses import JSONResponse, PlainTextResponse
 from redis.asyncio import Redis as AsyncRedis
@@ -316,3 +317,93 @@ async def get_amap_security_key(request: Request) -> JSONResponse:
         data={"securityJsCode": encoded_key},
         message="Amap security key retrieved successfully",
     )
+
+
+@router.post("/weather")
+@limiter.limit("100/hour")
+async def get_weather(
+    request: Request,
+    city: str = Body(..., description="City adcode"),
+    extensions: str = Body("base", description="Weather type: base/all"),
+) -> JSONResponse:
+    """Get weather information from Amap API.
+
+    Args:
+        city: City adcode
+        extensions: Weather type (base for current, all for forecast)
+
+    Returns:
+        JSONResponse: Weather data from Amap API
+    """
+    url = "https://restapi.amap.com/v3/weather/weatherInfo"
+    params = {
+        "key": get_settings().AMAP_WEB_KEY,
+        "city": city,
+        "extensions": extensions,
+    }
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+        data = response.json()
+
+    return APIResponse.ok(
+        data=data,
+        message="Weather information retrieved successfully",
+    )
+
+
+@router.post("/geocode/regeo")
+@limiter.limit("100/hour")
+async def reverse_geocode(
+    request: Request,
+    location: str = Body(..., description="Location coordinates: lng,lat"),
+    extensions: str = Body("base", description="Extensions type"),
+) -> JSONResponse:
+    """Reverse geocode coordinates to address using Amap API.
+
+    Args:
+        location: Location coordinates in format "lng,lat"
+        extensions: Extensions type
+
+    Returns:
+        JSONResponse: Address information including city adcode
+    """
+    url = "https://restapi.amap.com/v3/geocode/regeo"
+    params = {
+        "key": get_settings().AMAP_WEB_KEY,
+        "location": location,
+        "extensions": extensions,
+    }
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+        data = response.json()
+
+    return APIResponse.ok(
+        data=data,
+        message="Reverse geocode completed successfully",
+    )
+
+
+# @router.post("/geocode/regeo")
+# @limiter.limit("100/hour")
+# async def reverse_geocode(
+#     request: Request,
+#     params: dict = Body(..., description="Reverse geocode parameters"),
+# ) -> JSONResponse:
+#     """Reverse geocode coordinates to address using Amap API.
+
+#     Args:
+#         params: Reverse geocode parameters including location coordinates
+
+#     Returns:
+#         JSONResponse: Address information including city adcode
+#     """
+#     url = "https://restapi.amap.com/v3/geocode/regeo"
+#     params["key"] = get_settings().AMAP_WEB_KEY
+#     async with httpx.AsyncClient() as client:
+#         response = await client.get(url, params=params)
+#         data = response.json()
+
+#     return APIResponse.ok(
+#         data=data,
+#         message="Reverse geocode completed successfully",
+#     )

backend/app/routers/todos.py

@@ -5,7 +5,7 @@
 from datetime import datetime, timezone
 
 import orjson
-from fastapi import APIRouter, Depends, status
+from fastapi import APIRouter, Depends, Query, status
 from redis.asyncio import Redis as AsyncRedis
 
 from app.dependencies.auth import manager
@@ -50,11 +50,15 @@ async def _release_lock(redis: AsyncRedis, lock_key: str) -> None:
 
 @router.get("")
 async def get_todos(
-    user: User = Depends(manager), redis: AsyncRedis = Depends(get_async_redis)
+    include_archived: bool = Query(False),
+    user: User = Depends(manager),
+    redis: AsyncRedis = Depends(get_async_redis),
 ):
-    """Get current user's todos."""
+    """Get current user's todos. Excludes archived by default."""
     key = f"todos:{user.id}"
     todos = await _read_todos(redis, key)
+    if not include_archived:
+        todos = [t for t in todos if not t.get("archived")]
     return APIResponse.ok(data={"todos": todos})
 
 
@@ -84,6 +88,8 @@ async def create_todo(
             "dueDate": data.dueDate,
             "priority": data.priority or "medium",
             "category": data.category,
+            "archived": bool(data.archived),
+            "archivedAt": data.archivedAt,
         }
         todos.insert(0, todo)
         await _write_todos(redis, key, todos)
@@ -128,6 +134,10 @@ async def patch_todo(
                     t["category"] = data.category
                 if data.completed is not None:
                     t["completed"] = bool(data.completed)
+                if data.archived is not None:
+                    t["archived"] = bool(data.archived)
+                if data.archivedAt is not None:
+                    t["archivedAt"] = data.archivedAt
                 todos[i] = t
                 updated = t
                 break
@@ -171,6 +181,8 @@ async def replace_todo(
                     "dueDate": data.dueDate,
                     "priority": data.priority or "medium",
                     "category": data.category,
+                    "archived": bool(data.archived),
+                    "archivedAt": data.archivedAt,
                 }
                 todos[i] = updated
                 break
@@ -241,6 +253,8 @@ async def import_todos(
                     "dueDate": item.dueDate,
                     "priority": item.priority or "medium",
                     "category": item.category,
+                    "archived": bool(item.archived),
+                    "archivedAt": item.archivedAt,
                 }
             )
         merged = new_items + existing
@@ -251,6 +265,112 @@ async def import_todos(
     return APIResponse.ok(message="Todos imported")
 
 
+@router.get("/archived")
+async def get_archived_todos(
+    user: User = Depends(manager), redis: AsyncRedis = Depends(get_async_redis)
+):
+    """Get all archived todos for current user."""
+    key = f"todos:{user.id}"
+    todos = await _read_todos(redis, key)
+    archived = [t for t in todos if t.get("archived")]
+    return APIResponse.ok(data={"todos": archived})
+
+
+@router.post("/{todo_id}/archive")
+async def archive_todo(
+    todo_id: str,
+    user: User = Depends(manager),
+    redis: AsyncRedis = Depends(get_async_redis),
+):
+    """Archive a todo."""
+    key = f"todos:{user.id}"
+    lock_key = f"todos:lock:{user.id}"
+    if not await _acquire_lock(redis, lock_key):
+        return APIResponse.error(
+            message="Server busy, please retry.", code=status.HTTP_423_LOCKED
+        )
+    updated = None
+    try:
+        todos = await _read_todos(redis, key)
+        for i, t in enumerate(todos):
+            if t.get("id") == todo_id:
+                t["archived"] = True
+                t["archivedAt"] = datetime.now(timezone.utc).isoformat()  # noqa: UP017
+                todos[i] = t
+                updated = t
+                break
+        if updated is None:
+            return APIResponse.error(
+                message="Todo not found", code=status.HTTP_404_NOT_FOUND
+            )
+        await _write_todos(redis, key, todos)
+    finally:
+        await _release_lock(redis, lock_key)
+
+    return APIResponse.ok(data={"todo": updated}, message="Todo archived")
+
+
+@router.post("/{todo_id}/unarchive")
+async def unarchive_todo(
+    todo_id: str,
+    user: User = Depends(manager),
+    redis: AsyncRedis = Depends(get_async_redis),
+):
+    """Unarchive a todo."""
+    key = f"todos:{user.id}"
+    lock_key = f"todos:lock:{user.id}"
+    if not await _acquire_lock(redis, lock_key):
+        return APIResponse.error(
+            message="Server busy, please retry.", code=status.HTTP_423_LOCKED
+        )
+    updated = None
+    try:
+        todos = await _read_todos(redis, key)
+        for i, t in enumerate(todos):
+            if t.get("id") == todo_id:
+                t["archived"] = False
+                t["archivedAt"] = None
+                todos[i] = t
+                updated = t
+                break
+        if updated is None:
+            return APIResponse.error(
+                message="Todo not found", code=status.HTTP_404_NOT_FOUND
+            )
+        await _write_todos(redis, key, todos)
+    finally:
+        await _release_lock(redis, lock_key)
+
+    return APIResponse.ok(data={"todo": updated}, message="Todo unarchived")
+
+
+@router.post("/archive-completed")
+async def archive_completed(
+    user: User = Depends(manager), redis: AsyncRedis = Depends(get_async_redis)
+):
+    """Archive all completed (non-archived) todos."""
+    key = f"todos:{user.id}"
+    lock_key = f"todos:lock:{user.id}"
+    if not await _acquire_lock(redis, lock_key):
+        return APIResponse.error(
+            message="Server busy, please retry.", code=status.HTTP_423_LOCKED
+        )
+    try:
+        todos = await _read_todos(redis, key)
+        now = datetime.now(timezone.utc).isoformat()  # noqa: UP017
+        count = 0
+        for t in todos:
+            if t.get("completed") and not t.get("archived"):
+                t["archived"] = True
+                t["archivedAt"] = now
+                count += 1
+        await _write_todos(redis, key, todos)
+    finally:
+        await _release_lock(redis, lock_key)
+
+    return APIResponse.ok(message=f"Archived {count} completed todos")
+
+
 @router.post("/clear-completed")
 async def clear_completed(
     user: User = Depends(manager), redis: AsyncRedis = Depends(get_async_redis)

backend/app/schemas/schemas.py

@@ -458,6 +458,8 @@ class TodoIn(BaseModel):
     category: str | None = None
     completed: bool = False
     id: str | None = None  # optional client-supplied id
+    archived: bool = False
+    archivedAt: str | None = None  # noqa: N815
 
 
 class TodoUpdate(BaseModel):
@@ -467,6 +469,8 @@ class TodoUpdate(BaseModel):
     priority: str | None = None
     category: str | None = None
     completed: bool | None = None
+    archived: bool | None = None
+    archivedAt: str | None = None  # noqa: N815
 
 
 class TodoOut(BaseModel):
@@ -478,3 +482,5 @@ class TodoOut(BaseModel):
     dueDate: str | None = None  # noqa: N815
     priority: str = "medium"
     category: str | None = None
+    archived: bool = False
+    archivedAt: str | None = None  # noqa: N815

backend/test_task.py backend/test/test_task.pybackend/test_task.py renamed to backend/test/test_task.py

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "exa": {
+      "baseUrl": "https://mcp.exa.ai/mcp"
+    }
+  },
+  "imports": []
+}