init

Author: jxxghp

.github/workflows/build-docker.yml

@@ -0,0 +1,47 @@
+name: NASbot Docker
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Build Docker Image
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@master
+
+      -
+        name: Release version
+        id: release_version
+        run: |
+          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
+          echo "app_version=$app_version" >> $GITHUB_ENV
+
+      -
+        name: Set Up QEMU
+        uses: docker/setup-qemu-action@v1
+
+      -
+        name: Set Up Buildx
+        uses: docker/setup-buildx-action@v1
+
+      -
+        name: Login DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      -
+        name: Build Image
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: |
+            linux/amd64
+          push: true
+          tags: |
+            ${{ secrets.DOCKER_USERNAME }}/nasbot:latest
+            ${{ secrets.DOCKER_USERNAME }}/nasbot:${{ env.app_version }}

.gitignore

@@ -0,0 +1,5 @@
+.idea/
+*.c
+build/
+test.py
+app/helper/sites.py

alembic/__pycache__/env.cpython-310.pyc

@@ -0,0 +1,80 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+from app.db.models import Base
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        render_as_batch=True
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

alembic/env.py

@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

alembic/script.py.mako

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+
+from app.api.endpoints import login, users, sites, messages, webhooks, subscribes, media
+
+api_router = APIRouter()
+api_router.include_router(login.router, tags=["login"])
+api_router.include_router(users.router, prefix="/users", tags=["users"])
+api_router.include_router(sites.router, prefix="/sites", tags=["sites"])
+api_router.include_router(messages.router, prefix="/messages", tags=["messages"])
+api_router.include_router(webhooks.router, prefix="/webhooks", tags=["webhooks"])
+api_router.include_router(subscribes.router, prefix="/subscribes", tags=["subscribes"])
+api_router.include_router(media.router, prefix="/media", tags=["media"])

app/__init__.py

@@ -0,0 +1,38 @@
+from datetime import timedelta
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+
+from app import schemas
+from app.core import security, settings
+from app.db import get_db
+from app.db.models.user import User
+
+router = APIRouter()
+
+
+@router.post("/login/access-token", response_model=schemas.Token)
+async def login_access_token(
+        db: Session = Depends(get_db), form_data: OAuth2PasswordRequestForm = Depends()
+) -> Any:
+    """
+    获取认证Token
+    """
+    user = User.authenticate(
+        db=db,
+        email=form_data.username,
+        password=form_data.password
+    )
+    if not user:
+        raise HTTPException(status_code=400, detail="用户名或密码不正确")
+    elif not user.is_active:
+        raise HTTPException(status_code=400, detail="用户未启用")
+    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    return {
+        "access_token": security.create_access_token(
+            user.id, expires_delta=access_token_expires
+        ),
+        "token_type": "bearer",
+    }

app/__pycache__/__init__.cpython-310.pyc

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, HTTPException, Depends
+
+from app import schemas
+from app.chain.identify import IdentifyChain
+from app.db.models.user import User
+from app.db.userauth import get_current_active_user
+
+router = APIRouter()
+
+
+@router.post("/recognize", response_model=schemas.Context)
+async def recognize(title: str,
+                    subtitle: str = None,
+                    current_user: User = Depends(get_current_active_user)):
+    """
+    识别媒体信息
+    """
+    if not current_user:
+        raise HTTPException(
+            status_code=400,
+            detail="需要授权",
+        )
+    # 识别媒体信息
+    context = IdentifyChain().process(title=title, subtitle=subtitle)
+    return context.to_dict()

app/__pycache__/log.cpython-310.pyc

@@ -0,0 +1,51 @@
+from typing import Union
+
+from fastapi import APIRouter, BackgroundTasks
+from fastapi import Request
+
+from app import schemas
+from app.chain.user_message import UserMessageChain
+from app.core import settings
+from app.log import logger
+from app.modules.wechat.WXBizMsgCrypt3 import WXBizMsgCrypt
+
+router = APIRouter()
+
+
+def start_message_chain(request: Request):
+    """
+    启动链式任务
+    """
+    UserMessageChain().process(request)
+
+
+@router.post("/", response_model=schemas.Response)
+async def user_message(background_tasks: BackgroundTasks, request: Request):
+    """
+    用户消息响应
+    """
+    background_tasks.add_task(start_message_chain, request)
+    return {"success": True}
+
+
+@router.get("/")
+async def wechat_verify(echostr: str, msg_signature: str, timestamp: Union[str, int], nonce: str):
+    """
+    用户消息响应
+    """
+    logger.info(f"收到微信验证请求: {echostr}")
+    try:
+        wxcpt = WXBizMsgCrypt(sToken=settings.WECHAT_TOKEN,
+                              sEncodingAESKey=settings.WECHAT_ENCODING_AESKEY,
+                              sReceiveId=settings.WECHAT_CORPID)
+    except Exception as err:
+        logger.error(f"微信请求验证失败: {err}")
+        return str(err)
+    ret, sEchoStr = wxcpt.VerifyURL(sMsgSignature=msg_signature,
+                                    sTimeStamp=timestamp,
+                                    sNonce=nonce,
+                                    sEchoStr=echostr)
+    if ret != 0:
+        logger.error("微信请求验证失败 VerifyURL ret: %s" % str(ret))
+    # 验证URL成功，将sEchoStr返回给企业号
+    return sEchoStr

app/__pycache__/main.cpython-310.pyc

@@ -0,0 +1,43 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app import schemas
+from app.chain.cookiecloud import CookieCloudChain
+from app.db import get_db
+from app.db.models.site import Site
+from app.db.models.user import User
+from app.db.userauth import get_current_active_user
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[schemas.Site])
+async def read_sites(db: Session = Depends(get_db),
+                     current_user: User = Depends(get_current_active_user)) -> List[dict]:
+    """
+    获取站点列表
+    """
+    if not current_user:
+        raise HTTPException(
+            status_code=400,
+            detail="需要授权",
+        )
+    return Site.list(db)
+
+
+@router.get("/cookiecloud", response_model=schemas.Response)
+async def cookie_cloud_sync(current_user: User = Depends(get_current_active_user)) -> dict:
+    """
+    运行CookieCloud同步站点信息
+    """
+    if not current_user:
+        raise HTTPException(
+            status_code=400,
+            detail="需要授权",
+        )
+    status, error_msg = CookieCloudChain().process()
+    if not status:
+        return {"success": False, "message": error_msg}
+    return {"success": True, "message": error_msg}