fix(webclient): port

---

Closes: #141

.gitattributes

@@ -1 +1,2 @@
-resources/web/**/* linguist-vendored
+resources/web/**/* linguist-vendored
+resources/web2/**/* linguist-vendored

.github/workflows/build.yml

@@ -55,6 +55,13 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/checkout@v4
+        with:
+          repository: lejianwen/rustdesk-api-web
+          path: rustdesk-api-web
+          ref: master
 
       - name: Set up Go environment
         uses: actions/setup-go@v4
@@ -66,19 +73,26 @@ jobs:
         with:
           node-version: '20'
 
-
       - name: build rustdesk-api-web
+        working-directory: rustdesk-api-web
         run: |
-          git clone ${{ env.WEBCLIENT_SOURCE_LOCATION }}
-          cd rustdesk-api-web
           npm install
           npm run build
-          mkdir ../resources/admin/ -p
+          mkdir -p ../resources/admin/
           cp -ar dist/* ../resources/admin/
 
       - name: tidy
         run: go mod tidy
 
+      - name: Get tag version
+        run: |
+          TAG_VERSION="${GITHUB_REF##*/}"
+          VERSION="${TAG_VERSION#v}" 
+          echo "VERSION=$VERSION" >> $GITHUB_ENV
+
+      - name: Write version to resources/version
+        run:  echo $VERSION > resources/version
+
       - name: swag
         run: |
           go install github.com/swaggo/swag/cmd/swag@latest
@@ -96,6 +110,8 @@ jobs:
           if [ "${{ matrix.job.goos }}" = "windows" ]; then
             sudo apt-get install gcc-mingw-w64-x86-64 zip -y
             GOOS=${{ matrix.job.goos }} GOARCH=${{ matrix.job.platform }} CC=x86_64-w64-mingw32-gcc CGO_LDFLAGS="-static" CGO_ENABLED=1 go build -ldflags "-s -w" -o ./release/apimain.exe ./cmd/apimain.go
+            echo @echo off > release/start.bat
+            echo cmd /c \"%~dp0apimain.exe\" >> release/start.bat
             zip -r ${{ matrix.job.goos}}-${{ matrix.job.platform }}.${{matrix.job.file_ext}} ./release
           else
             if [ "${{ matrix.job.platform }}" = "arm64" ]; then
@@ -121,15 +137,93 @@ jobs:
           name: rustdesk-api-${{ matrix.job.goos }}-${{ matrix.job.platform }}
           path: |
             ${{ matrix.job.goos}}-${{ matrix.job.platform }}.${{matrix.job.file_ext}}
+
       - name: Upload to GitHub Release
         uses: softprops/action-gh-release@v2
         with:
           files: |
             ${{ matrix.job.goos}}-${{ matrix.job.platform }}.${{matrix.job.file_ext}}
-        #          tag_name: ${{ env.LATEST_TAG }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Generate Changelog
+        run: npx changelogithub # or changelogithub@0.12 if ensure the stable result
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+
+  deb-package:
+    name: debian package - ${{ matrix.job.platform }}
+    needs: build
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { platform: "amd64", goos: "linux", debian_platform: "amd64", crossbuild_package: ""}
+          - { platform: "arm64", goos: "linux", debian_platform: "arm64", crossbuild_package: "crossbuild-essential-arm64" }
+          - { platform: "armv7l", goos: "linux", debian_platform: "armhf", crossbuild_package: "crossbuild-essential-armhf" }
+    steps:
+
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Create packaging env
+        run: |
+          sudo apt update
+          DEBIAN_FRONTEND=noninteractive sudo apt install -y devscripts build-essential debhelper pkg-config ${{ matrix.job.crossbuild_package }}
+          mkdir -p debian-build/${{ matrix.job.platform }}/bin
+
+      - name: Get tag version
+        id: get_tag
+        run: |
+          TAG_VERSION="${GITHUB_REF##*/}"
+          VERSION="${TAG_VERSION#v}" 
+          echo "TAG_VERSION=$TAG_VERSION" >> $GITHUB_ENV
+          echo "VERSION=$VERSION" >> $GITHUB_ENV
+
+      - name: Update changelog
+        run: |
+          DATE=$(date -R)
+          sed -i "1i rustdesk-api-server (${VERSION}) stable; urgency=medium\n\n  * Automatically generated release for version ${VERSION}.\n\n -- GitHub Actions <actions@github.com>  ${DATE}\n" debian/changelog
+
+      - name: Download binaries
+        uses: actions/download-artifact@v4
+        with:
+          name: rustdesk-api-${{ matrix.job.goos }}-${{ matrix.job.platform }}
+          path: .
+
+      - name: Unzip binaries
+        run: |
+          mkdir -p ${{ matrix.job.platform }}
+          tar -xzf ${{ matrix.job.goos }}-${{ matrix.job.platform }}.tar.gz -C ${{ matrix.job.platform }}
+
+      - name: Build package for ${{ matrix.job.platform }} arch
+        run: |
+          mv ${{ matrix.job.platform }}/release/apimain debian-build/${{ matrix.job.platform }}/bin/rustdesk-api 
+          mv ${{ matrix.job.platform }}/release/resources/admin resources
+          chmod -v a+x debian-build/${{ matrix.job.platform }}/bin/*
+          mkdir -p data
+          cp -vr debian systemd conf data resources runtime debian-build/${{ matrix.job.platform }}/
+          cat debian/control.tpl | sed 's/{{ ARCH }}/${{ matrix.job.debian_platform }}/' > debian-build/${{ matrix.job.platform }}/debian/control
+          cd debian-build/${{ matrix.job.platform }}/
+          debuild -i -us -uc -b -a${{ matrix.job.debian_platform}}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: rustdesk-api-${{ matrix.job.debian_platform }}
+          path: |
+            debian-build/*.deb
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            debian-build/rustdesk-api-server_*_${{ matrix.job.debian_platform }}.deb
+
   docker:
     name: Push Docker Image
     needs: build
@@ -191,7 +285,6 @@ jobs:
         run: |
           mkdir -p ${{ matrix.job.platform }}
           tar -xzf ${{ matrix.job.goos }}-${{ matrix.job.platform }}.tar.gz -C ${{ matrix.job.platform }}
-          file ${{ matrix.job.platform }}/apimain
 
       - name: Build and push Docker image to Docker Hub ${{ matrix.job.platform }}
         if: ${{ env.SKIP_DOCKER_HUB == 'false' }}  # Only run this step if SKIP_DOCKER_HUB is false
@@ -209,6 +302,21 @@ jobs:
             ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-${{ matrix.job.platform }}
           labels: ${{ steps.meta.outputs.labels }}
 
+      - name: Build and push Docker Full S6 image to Docker Hub ${{ matrix.job.platform }}
+        if: ${{ env.SKIP_DOCKER_HUB == 'false' }}  # Only run this step if SKIP_DOCKER_HUB is false
+        uses: docker/build-push-action@v5
+        with:
+          context: "."
+          file: ./Dockerfile_full_s6
+          platforms: ${{ matrix.job.docker_platform }}
+          push: true
+          provenance: false
+          build-args: |
+            BUILDARCH=${{ matrix.job.platform }}
+          tags: |
+            ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:full-s6-${{ matrix.job.platform }}
+          labels: ${{ steps.meta.outputs.labels }}
+
       - name: Build and push Docker image to GHCR ${{ matrix.job.platform }}
         if: ${{ env.SKIP_GHCR == 'false' }}  # Only run this step if SKIP_GHCR is false
         uses: docker/build-push-action@v5
@@ -225,6 +333,21 @@ jobs:
             ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-${{ matrix.job.platform }}
           labels: ${{ steps.meta.outputs.labels }}
 
+      - name: Build and push Docker Full S6 image to GHCR ${{ matrix.job.platform }}
+        if: ${{ env.SKIP_GHCR == 'false' }}  # Only run this step if SKIP_GHCR is false
+        uses: docker/build-push-action@v5
+        with:
+          context: "."
+          file: ./Dockerfile
+          platforms: ${{ matrix.job.docker_platform }}
+          push: true
+          provenance: false
+          build-args: |
+            BUILDARCH=${{ matrix.job.platform }}
+          tags: |
+            ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:full-s6-${{ matrix.job.platform }}
+          labels: ${{ steps.meta.outputs.labels }}
+
   #
   docker-manifest:
     name: Push Docker Manifest
@@ -295,4 +418,26 @@ jobs:
             ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:latest-armv7l,
             ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:latest-arm64
           push: true
+          amend: true
+
+      - name: Create and push Full S6 manifest Docker Hub (:version)
+        if: ${{ env.SKIP_DOCKER_HUB == 'false' }}
+        uses: Noelware/docker-manifest-action@master
+        with:
+          base-image: ${{ env.BASE_IMAGE_NAMESPACE }}/rustdesk-api:full-s6
+          extra-images: ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:full-s6-amd64,
+            ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:full-s6-armv7l,
+            ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:full-s6-arm64
+          push: true
+          amend: true
+
+      - name: Create and push Full S6 manifest GHCR (:latest)
+        if: ${{ env.SKIP_GHCR == 'false' }}
+        uses: Noelware/docker-manifest-action@master
+        with:
+          base-image: ghcr.io/${{ env.BASE_IMAGE_NAMESPACE }}/rustdesk-api:full-s6
+          extra-images: ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:full-s6-amd64,
+            ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:full-s6-armv7l,
+            ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:full-s6-arm64
+          push: true
           amend: true

.github/workflows/build_test.yml

@@ -0,0 +1,337 @@
+name: Build Test
+
+on:
+  workflow_dispatch:
+    inputs:
+      BASE_IMAGE_NAMESPACE:
+        description: 'Base image namespace (Default: Your Github username)'
+        required: false
+        default: ''
+      DOCKERHUB_IMAGE_NAMESPACE:
+        description: 'Docker Hub image namespace (Default: Your Github username)'
+        required: false
+        default: ''
+      GHCR_IMAGE_NAMESPACE:
+        description: 'GitHub Container Registry image namespace (Default: Your Github username)'
+        required: false
+        default: ''
+      SKIP_DOCKER_HUB:
+        description: 'Set to true to skip pushing to Docker Hub (default: false)'
+        required: false
+        default: 'false'
+      SKIP_GHCR:
+        description: 'Set to true to skip pushing to GHCR (default: false)'
+        required: false
+        default: 'false'
+      WEBCLIENT_SOURCE_LOCATION:
+        description: 'Web Client API Repository'
+        required: true
+        default: 'https://github.com/lejianwen/rustdesk-api-web'
+
+env:
+  LATEST_TAG: latest
+  WEBCLIENT_SOURCE_LOCATION: ${{ github.event.inputs.WEBCLIENT_SOURCE_LOCATION || 'https://github.com/lejianwen/rustdesk-api-web' }}
+  BASE_IMAGE_NAMESPACE: ${{ github.event.inputs.BASE_IMAGE_NAMESPACE || github.actor }}
+  DOCKERHUB_IMAGE_NAMESPACE: ${{ github.event.inputs.DOCKERHUB_IMAGE_NAMESPACE || github.actor }}
+  GHCR_IMAGE_NAMESPACE: ${{ github.event.inputs.GHCR_IMAGE_NAMESPACE || github.actor }}
+  SKIP_DOCKER_HUB: ${{ github.event.inputs.SKIP_DOCKER_HUB || 'false' }}
+  SKIP_GHCR: ${{ github.event.inputs.SKIP_GHCR || 'false' }}
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { platform: "amd64", goos: "linux", file_ext: "tar.gz" }
+          - { platform: "arm64", goos: "linux", file_ext: "tar.gz" }
+          - { platform: "armv7l", goos: "linux", file_ext: "tar.gz" }
+          - { platform: "amd64", goos: "windows", file_ext: "zip" }
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - uses: actions/checkout@v4
+        with:
+          repository: lejianwen/rustdesk-api-web
+          path: rustdesk-api-web
+          ref: master
+
+      - name: Set up Go environment
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.22'  # 选择 Go 版本
+
+      - name: Set up npm
+        uses: actions/setup-node@v2
+        with:
+          node-version: '20'
+
+      - name: build rustdesk-api-web
+        working-directory: rustdesk-api-web
+        run: |
+          npm install
+          npm run build
+          mkdir -p ../resources/admin/
+          cp -ar dist/* ../resources/admin/
+
+      - name: tidy
+        run: go mod tidy
+
+      - name: swag
+        run: |
+          go install github.com/swaggo/swag/cmd/swag@latest
+          swag init -g cmd/apimain.go --output docs/api --instanceName api --exclude http/controller/admin
+          swag init -g cmd/apimain.go --output docs/admin --instanceName admin --exclude http/controller/api
+
+      - name: Build for ${{ matrix.job.goos }}-${{ matrix.job.platform }}
+        run: |
+          mkdir release -p
+          cp -ar resources release/
+          cp -ar docs release/
+          cp -ar conf release/
+          mkdir -p release/data
+          mkdir -p release/runtime
+          if [ "${{ matrix.job.goos }}" = "windows" ]; then
+            sudo apt-get install gcc-mingw-w64-x86-64 zip -y
+            GOOS=${{ matrix.job.goos }} GOARCH=${{ matrix.job.platform }} CC=x86_64-w64-mingw32-gcc CGO_LDFLAGS="-static" CGO_ENABLED=1 go build -ldflags "-s -w" -o ./release/apimain.exe ./cmd/apimain.go
+            echo @echo off > release/start.bat
+            echo cmd /c \"%~dp0apimain.exe\" >> release/start.bat
+            zip -r ${{ matrix.job.goos}}-${{ matrix.job.platform }}.${{matrix.job.file_ext}} ./release
+          else
+            if [ "${{ matrix.job.platform }}" = "arm64" ]; then
+                wget https://musl.cc/aarch64-linux-musl-cross.tgz
+                tar -xf aarch64-linux-musl-cross.tgz
+                export PATH=$PATH:$PWD/aarch64-linux-musl-cross/bin
+                GOOS=${{ matrix.job.goos }} GOARCH=${{ matrix.job.platform }} CC=aarch64-linux-musl-gcc CGO_LDFLAGS="-static" CGO_ENABLED=1 go build -ldflags "-s -w" -o ./release/apimain ./cmd/apimain.go
+            elif [ "${{ matrix.job.platform }}" = "armv7l" ]; then
+                wget https://musl.cc/armv7l-linux-musleabihf-cross.tgz
+                tar -xf armv7l-linux-musleabihf-cross.tgz
+                export PATH=$PATH:$PWD/armv7l-linux-musleabihf-cross/bin
+                GOOS=${{ matrix.job.goos }} GOARCH=arm GOARM=7 CC=armv7l-linux-musleabihf-gcc CGO_LDFLAGS="-static" CGO_ENABLED=1 go build -ldflags "-s -w" -o ./release/apimain ./cmd/apimain.go
+            else
+              sudo apt-get install musl musl-dev musl-tools -y
+              GOOS=${{ matrix.job.goos }} GOARCH=${{ matrix.job.platform }} CC=musl-gcc CGO_LDFLAGS="-static" CGO_ENABLED=1 go build -ldflags "-s -w" -o ./release/apimain ./cmd/apimain.go
+            fi
+            tar -czf ${{ matrix.job.goos}}-${{ matrix.job.platform }}.${{matrix.job.file_ext}} ./release
+          fi
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: rustdesk-api-${{ matrix.job.goos }}-${{ matrix.job.platform }}
+          path: |
+            ${{ matrix.job.goos}}-${{ matrix.job.platform }}.${{matrix.job.file_ext}}
+
+      - name: Upload to GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            ${{ matrix.job.goos}}-${{ matrix.job.platform }}.${{matrix.job.file_ext}}
+          tag_name: test
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  deb-package:
+    name: debian package - ${{ matrix.job.platform }}
+    needs: build
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { platform: "amd64", goos: "linux", debian_platform: "amd64", crossbuild_package: ""}
+          - { platform: "arm64", goos: "linux", debian_platform: "arm64", crossbuild_package: "crossbuild-essential-arm64" }
+          - { platform: "armv7l", goos: "linux", debian_platform: "armhf", crossbuild_package: "crossbuild-essential-armhf" }
+    steps:
+
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Create packaging env
+        run: |
+          sudo apt update
+          DEBIAN_FRONTEND=noninteractive sudo apt install -y devscripts build-essential debhelper pkg-config ${{ matrix.job.crossbuild_package }}
+          mkdir -p debian-build/${{ matrix.job.platform }}/bin
+
+      - name: Download binaries
+        uses: actions/download-artifact@v4
+        with:
+          name: rustdesk-api-${{ matrix.job.goos }}-${{ matrix.job.platform }}
+          path: .
+
+      - name: Unzip binaries
+        run: |
+          mkdir -p ${{ matrix.job.platform }}
+          tar -xzf ${{ matrix.job.goos }}-${{ matrix.job.platform }}.tar.gz -C ${{ matrix.job.platform }}
+
+      - name: Build package for ${{ matrix.job.platform }} arch
+        run: |
+          mv ${{ matrix.job.platform }}/release/apimain debian-build/${{ matrix.job.platform }}/bin/rustdesk-api 
+          chmod -v a+x debian-build/${{ matrix.job.platform }}/bin/*
+          mkdir -p data
+          cp -vr debian systemd conf data resources runtime debian-build/${{ matrix.job.platform }}/
+          cat debian/control.tpl | sed 's/{{ ARCH }}/${{ matrix.job.debian_platform }}/' > debian-build/${{ matrix.job.platform }}/debian/control
+          cd debian-build/${{ matrix.job.platform }}/
+          debuild -i -us -uc -b -a${{ matrix.job.debian_platform}}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: rustdesk-api-${{ matrix.job.debian_platform }}
+          path: |
+            debian-build/*.deb
+
+      - name: Upload to GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: test
+          files: |
+            debian-build/rustdesk-api-server_*_${{ matrix.job.debian_platform }}.deb
+
+  docker:
+    name: Push Docker Image
+    needs: build
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { platform: "amd64", goos: "linux",  docker_platform: "linux/amd64" }
+          - { platform: "arm64", goos: "linux",  docker_platform: "linux/arm64" }
+          - { platform: "armv7l", goos: "linux",  docker_platform: "linux/arm/v7" }
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Log in to Docker Hub
+        if: ${{ env.SKIP_DOCKER_HUB == 'false' }}  # Only log in if SKIP_DOCKER_HUB is false
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
+
+      - name: Log in to GitHub Container Registry
+        if: ${{ env.SKIP_GHCR == 'false' }}  # Only log in if GHCR push is enabled
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract version from tag
+        id: vars
+        run: |
+          if [[ "${GITHUB_REF}" == refs/tags/* ]]; then
+            echo "TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+          else
+            echo "TAG=test" >> $GITHUB_ENV  # Default to 'test' if not a tag
+          fi
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: ${{ env.BASE_IMAGE_NAMESPACE }}/rustdesk-api
+
+      - name: Download binaries
+        uses: actions/download-artifact@v4
+        with:
+          name: rustdesk-api-${{ matrix.job.goos }}-${{ matrix.job.platform }}
+          path: ./
+
+      - name: Unzip binaries
+        run: |
+          mkdir -p ${{ matrix.job.platform }}
+          tar -xzf ${{ matrix.job.goos }}-${{ matrix.job.platform }}.tar.gz -C ${{ matrix.job.platform }}
+
+      - name: Build and push Docker image to Docker Hub ${{ matrix.job.platform }}
+        if: ${{ env.SKIP_DOCKER_HUB == 'false' }}  # Only run this step if SKIP_DOCKER_HUB is false
+        uses: docker/build-push-action@v5
+        with:
+          context: "."
+          file: ./Dockerfile
+          platforms: ${{ matrix.job.docker_platform }}
+          push: true
+          provenance: false
+          build-args: |
+            BUILDARCH=${{ matrix.job.platform }}
+          tags: |
+            ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-${{ matrix.job.platform }}
+          labels: ${{ steps.meta.outputs.labels }}
+
+      - name: Build and push Docker image to GHCR ${{ matrix.job.platform }}
+        if: ${{ env.SKIP_GHCR == 'false' }}  # Only run this step if SKIP_GHCR is false
+        uses: docker/build-push-action@v5
+        with:
+          context: "."
+          file: ./Dockerfile
+          platforms: ${{ matrix.job.docker_platform }}
+          push: true
+          provenance: false
+          build-args: |
+            BUILDARCH=${{ matrix.job.platform }}
+          tags: |
+            ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-${{ matrix.job.platform }}
+          labels: ${{ steps.meta.outputs.labels }}
+
+  #
+  docker-manifest:
+    name: Push Docker Manifest
+    needs: docker
+    runs-on: ubuntu-latest
+    steps:
+      - name: Extract version from tag
+        id: vars
+        run: |
+          if [[ "${GITHUB_REF}" == refs/tags/* ]]; then
+            echo "TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+          else
+            echo "TAG=test" >> $GITHUB_ENV  # Default to 'test' if not a tag
+          fi
+
+      - name: Log in to Docker Hub
+        if: ${{ env.SKIP_DOCKER_HUB == 'false' }}  # Only log in if Docker Hub push is enabled
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
+
+      - name: Log in to GitHub Container Registry
+        if: ${{ env.SKIP_GHCR == 'false' }}  # Only log in if GHCR push is enabled
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create and push manifest Docker Hub (:version)
+        if: ${{ env.SKIP_DOCKER_HUB == 'false' }}
+        uses: Noelware/docker-manifest-action@master
+        with:
+          base-image: ${{ env.BASE_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}
+          extra-images: ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-amd64,
+            ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-armv7l,
+            ${{ env.DOCKERHUB_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-arm64
+          push: true
+
+      - name: Create and push manifest GHCR (:version)
+        if: ${{ env.SKIP_GHCR == 'false' }}
+        uses: Noelware/docker-manifest-action@master
+        with:
+          base-image: ghcr.io/${{ env.BASE_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}
+          extra-images: ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-amd64,
+            ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-armv7l,
+            ghcr.io/${{ env.GHCR_IMAGE_NAMESPACE }}/rustdesk-api:${{ env.TAG }}-arm64
+          push: true
+          amend: true

.github/workflows/release.yml

@@ -1,95 +0,0 @@
-name: Build and Release
-
-on:
-  workflow_dispatch:
-#    tags:
-#      - 'v*.*.*'  # 当推送带有版本号的 tag（例如 v1.0.0）时触发工作流
-#on:
-#  push:
-#    branches: [ "master" ]
-#  pull_request:
-#    branches: [ "master" ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        goos: [ linux, windows ] # 指定要构建的操作系统
-        goarch: [ amd64 ]         # 指定架构
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Set up Go environment
-        uses: actions/setup-go@v4
-        with:
-          go-version: '1.22'  # 选择 Go 版本
-
-      - name: Set up npm
-        uses: actions/setup-node@v2
-        with:
-          node-version: '20'
-
-      - name: install gcc zip musl
-        run: |
-          if [ "${{ matrix.goos }}" = "windows" ]; then
-            sudo apt-get install gcc-mingw-w64-x86-64 zip -y
-          else
-            sudo apt-get install musl musl-dev musl-tools -y
-          fi
-
-
-      - name: build rustdesk-api-web
-        run: |
-          git clone https://github.com/lejianwen/rustdesk-api-web
-          cd rustdesk-api-web
-          npm install
-          npm run build
-          mkdir ../resources/admin/ -p
-          cp -ar dist/* ../resources/admin/
-
-      - name: tidy
-        run: go mod tidy
-
-
-      - name: swag
-        run: |
-          go install github.com/swaggo/swag/cmd/swag@latest
-          swag init -g cmd/apimain.go --output docs/api --instanceName api --exclude http/controller/admin
-          swag init -g cmd/apimain.go --output docs/admin --instanceName admin --exclude http/controller/api
-
-      - name: Build for ${{ matrix.goos }}-${{ matrix.goarch }}
-        run: |
-          mkdir release -p
-          cp -ar resources release/
-          cp -ar docs release/
-          cp -ar conf release/
-          mkdir -p release/data
-          mkdir -p release/runtime
-          if [ "${{ matrix.goos }}" = "windows" ]; then
-            GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} CC=x86_64-w64-mingw32-gcc CGO_LDFLAGS="-static" CGO_ENABLED=1 go build -ldflags "-s -w" -o ./release/apimain.exe ./cmd/apimain.go
-            zip -r ${{ matrix.goos}}-${{ matrix.goarch }}.zip ./release
-          else
-            GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} CC=musl-gcc CGO_LDFLAGS="-static" CGO_ENABLED=1 go build -ldflags "-s -w" -o ./release/apimain ./cmd/apimain.go
-            tar -czf ${{ matrix.goos}}-${{ matrix.goarch }}.tar.gz ./release 
-          fi
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: myapp-${{ matrix.goos }}-${{ matrix.goarch }}
-          path: |
-            ${{ matrix.goos}}-${{ matrix.goarch }}.tar.gz
-            ${{ matrix.goos}}-${{ matrix.goarch }}.zip
-
-      - name: Upload to GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          files: |
-            ${{ matrix.goos}}-${{ matrix.goarch }}.tar.gz
-            ${{ matrix.goos}}-${{ matrix.goarch }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,10 +1,8 @@
 .idea
 runtime/*
-!runtime/cache/.gitignore
+!runtime
+!runtime/cache/.gitkeep
 go.sum
-resources/*
-!resources/public/upload/.gitignore
-!resources/web
-!resources/i18n
+resources/admin
 release
 data

Dockerfile

@@ -2,9 +2,8 @@ FROM alpine
 
 ARG BUILDARCH
 WORKDIR /app
-RUN apk add --no-cache tzdata file
+RUN apk add --no-cache tzdata
 COPY ./${BUILDARCH}/release /app/
-RUN file /app/apimain
 VOLUME /app/data
 
 EXPOSE 21114

Dockerfile_full_s6

@@ -0,0 +1,38 @@
+FROM rustdesk/rustdesk-server-s6:latest AS server
+
+FROM alpine
+
+ARG BUILDARCH
+WORKDIR /app
+RUN apk add --no-cache tzdata
+COPY ./${BUILDARCH}/release /app/
+
+COPY --from=server /init /init
+COPY --from=server /etc/s6-overlay /etc/s6-overlay
+COPY --from=server /package /package
+COPY --from=server /usr/bin/healthcheck.sh /usr/bin/healthcheck.sh
+COPY --from=server /usr/bin/hbbr /usr/bin/hbbr
+COPY --from=server /usr/bin/hbbs /usr/bin/hbbs
+COPY --from=server /usr/bin/rustdesk-utils /usr/bin/rustdesk-utils
+COPY --from=server /command /command
+
+RUN \
+  mkdir -p /etc/s6-overlay/s6-rc.d/api && \
+  echo -e "key-secret\nhbbs" > /etc/s6-overlay/s6-rc.d/api/dependencies && \
+  echo "longrun" > /etc/s6-overlay/s6-rc.d/api/type && \
+  echo "#!/command/with-contenv sh" > /etc/s6-overlay/s6-rc.d/api/run && \
+  echo "cd /app" >> /etc/s6-overlay/s6-rc.d/api/run && \
+  echo "./apimain" >> /etc/s6-overlay/s6-rc.d/api/run && \
+  touch /etc/s6-overlay/s6-rc.d/user/contents.d/api && \
+  echo "/package/admin/s6/command/s6-svstat /run/s6-rc/servicedirs/api || exit 1" >> /usr/bin/healthcheck.sh && \
+  ln -s /run /var/run
+
+ENV RELAY=relay.example.com
+ENV ENCRYPTED_ONLY=0
+
+VOLUME /data
+VOLUME /app/data
+
+EXPOSE 21114 21115 21116 21116/udp 21117 21118 21119
+
+ENTRYPOINT ["/init"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Lejianwen and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -9,6 +9,7 @@
 <img src="https://img.shields.io/badge/gin-v1.9.0-lightBlue"/>
 <img src="https://img.shields.io/badge/gorm-v1.25.7-green"/>
 <img src="https://img.shields.io/badge/swag-v1.16.3-yellow"/>
+<img src="https://img.shields.io/badge/i18n-7-green"/>
 <img src="https://github.com/lejianwen/rustdesk-api/actions/workflows/build.yml/badge.svg"/>
 </div>
 
@@ -19,7 +20,10 @@
     - 登录
     - 地址簿
     - 群组
-    - 授权登录，支持`github`, `google` 和 `OIDC` 登录，支持`web后台`授权登录
+    - 授权登录
+      - 支持`github`, `google` 和 `OIDC` 登录，
+      - 支持`web后台`授权登录
+      - 支持`LDAP`(AD和OpenLDAP已测试), 如果API Server配置了LDAP
     - i18n
 - Web Admin
     - 用户管理
@@ -28,118 +32,97 @@
     - 标签管理
     - 群组管理
     - Oauth 管理
+    - 配置LDAP, 配置文件或者环境变量
     - 登录日志
     - 链接日志
     - 文件传输日志
     - 快速使用web client
     - i18n
     - 通过 web client 分享给游客
+    - server控制(一些官方的简单的指令 [WIKI](https://github.com/lejianwen/rustdesk-api/wiki/Rustdesk-Command))
 - Web Client
     - 自动获取API server
     - 自动获取ID服务器和KEY
     - 自动获取地址簿
     - 游客通过临时分享链接直接远程到设备
-
-## 使用前准备
-
-### [Rustdesk](https://github.com/rustdesk/rustdesk)
-
-#### PC客户端使用的是 ***1.3.0***，经测试 ***1.2.6+*** 都可以
-
-#### 关于PC端链接超时或者链接不上的问题以及解决方案
-##### 链接不上或者超时
-因为server端相对于客户端落后版本，server不会响应客户端的`secure_tcp`请求，所以客户端超时。
-相关代码代码位置在`https://github.com/rustdesk/rustdesk/blob/master/src/client.rs#L322`
-  ```rust
-    if !key.is_empty() && !token.is_empty() {
-    // mainly for the security of token
-    allow_err!(secure_tcp(&mut socket, key).await);
-    }
-  ```
-  可看到当`key`和`token`都不为空时，会调用`secure_tcp`，但是server端不会响应，所以客户端超时
-  `secure_tcp` 代码位置在 `https://github.com/rustdesk/rustdesk/blob/master/src/common.rs#L1203`
-  
-##### 4种解决方案
-1. server端指定key。
-    - 优点：简单
-    - 缺点：链接不是加密的
-       ```bash
-       hbbs -r <relay-server-ip[:port]> -k <key>
-       hbbr -k <key>
-       ```
-       比如
-       ```bash
-         hbbs -r <relay-server-ip[:port]> -k abc1234567
-         hbbr -k abc1234567
-       ```
-2. server端使用系统生成的key，或者自定义的密钥对，但如果client已登录，链接时容易超时或者链接不上，可以退出登录后再链接就可以了，webclient可以不用退出登录
-    - 优点：链接加密
-    - 缺点：操作麻烦
-3. server端使用系统生成的key，或者自定义的密钥对，fork官方客户端的代码将`secure_tcp`修改成直接返回，然后通过`Github Actions`编译，下载编译后的客户端。
-参考[官方文档](https://rustdesk.com/docs/en/dev/build/all/)
-    - 优点：链接加密，可以自定义客户端一些功能，编译后直接可用
-    - 缺点：需要自己fork代码，编译，有点难度
-4. 使用[我fork的代码](https://github.com/lejianwen/rustdesk)，已经修改了`secure_tcp`，可以直接下载使用，[下载地址](https://github.com/lejianwen/rustdesk/releases)
-    - 优点：代码改动可查看，`Github Actions`编译，链接加密，直接下载使用
-    - 缺点：可能跟不上官方版本更新
-     
-***对链接加密要求不高的可以使用`1`，对链接加密要求高的可以使用`3`或`4`***
+    - v2 Preview
+- CLI
+    - 重置管理员密码
 
 ## 功能
 
+
 ### API 服务 
 基本实现了PC端基础的接口。支持Personal版本接口，可以通过配置文件`rustdesk.personal`或环境变量`RUSTDESK_API_RUSTDESK_PERSONAL`来控制是否启用
 
-#### 登录
-
-- 添加了`github`, `google` 以及`OIDC`授权登录，需要在后台配置好就可以用了，具体可看后台OAuth配置
-- 添加了web后台授权登录,点击后直接登录后台就自动登录客户端了
-
-![pc_login](docs/pc_login.png)
-
-#### 地址簿
-
-![pc_ab](docs/pc_ab.png)
-
-#### 群组
-群组分为`共享组`和`普通组`，共享组中所有人都能看到小组成员的设备，普通组只有管理员能看到所有小组成员的设备
-
-![pc_gr](docs/pc_gr.png)
+<table>
+    <tr>
+      <td width="50%" align="center" colspan="2"><b>登录</b></td>
+    </tr>
+    <tr>
+        <td width="50%" align="center" colspan="2"><img src="docs/pc_login.png"></td>
+    </tr>
+     <tr>
+      <td width="50%" align="center"><b>地址簿</b></td>
+      <td width="50%" align="center"><b>群组</b></td>
+    </tr>
+    <tr>
+        <td width="50%" align="center"><img src="docs/pc_ab.png"></td>
+        <td width="50%" align="center"><img src="docs/pc_gr.png"></td>
+    </tr>
+</table>
 
 ### Web Admin:
 
 * 使用前后端分离，提供用户友好的管理界面，主要用来管理和展示。前端代码在[rustdesk-api-web](https://github.com/lejianwen/rustdesk-api-web)
 
-* 后台访问地址是`http://<your server>[:port]/_admin/`初次安装管理员为用户名密码为`admin` `admin`，请即时更改密码
+* 后台访问地址是`http://<your server>[:port]/_admin/`
+* 初次安装管理员为用户名为`admin`，密码将在控制台打印，可以通过[命令行](#CLI)更改密码
+
+  ![img.png](./docs/init_admin_pwd.png)
 
 1. 管理员界面
    ![web_admin](docs/web_admin.png)
 2. 普通用户界面
    ![web_user](docs/web_admin_user.png)
-   右上角可以更改密码,可以切换语言，可以切换`白天/黑夜`模式
-   ![web_resetpwd](docs/web_resetpwd.png)
 
-3. 分组可以自定义，方便管理，暂时支持两种类型: `共享组` 和 `普通组`
-   ![web_admin_gr](docs/web_admin_gr.png)
-4. 可以直接打开webclient，方便使用；也可以分享给游客，游客可以直接通过webclient远程到设备
-
-   ![web_webclient](docs/admin_webclient.png)
-5. Oauth,支持了`Github`, `Google` 以及 `OIDC`, 需要创建一个`OAuth App`，然后配置到后台
-   ![web_admin_oauth](docs/web_admin_oauth.png)
+3. 每个用户可以多个地址簿，也可以将地址簿共享给其他用户
+4. 分组可以自定义，方便管理，暂时支持两种类型: `共享组` 和 `普通组`
+5. 可以直接打开webclient，方便使用；也可以分享给游客，游客可以直接通过webclient远程到设备
+6. Oauth,支持了`Github`, `Google` 以及 `OIDC`, 需要创建一个`OAuth App`，然后配置到后台
     - 对于`Google` 和 `Github`, `Issuer` 和 `Scopes`不需要填写.
     - 对于`OIDC`, `Issuer`是必须的。`Scopes`是可选的，默认为 `openid,profile,email`. 确保可以获取 `sub`,`email` 和`preferred_username`
     - `github oauth app`在`Settings`->`Developer settings`->`OAuth Apps`->`New OAuth App`
       中创建,地址 [https://github.com/settings/developers](https://github.com/settings/developers)
     - `Authorization callback URL`填写`http://<your server[:port]>/api/oauth/callback`
       ，比如`http://127.0.0.1:21114/api/oauth/callback`
+7. 登录日志
+8. 链接日志
+9. 文件传输日志
+10. server控制
+
+  - `简易模式`,已经界面化了一些简单的指令，可以直接在后台执行
+    ![rustdesk_command_simple](./docs/rustdesk_command_simple.png)
+
+  - `高级模式`,直接在后台执行指令
+      * 可以官方指令
+      * 可以添加自定义指令
+      * 可以执行自定义指令
+    
+    ![rustdesk_command_advance](./docs/rustdesk_command_advance.png)
+ 
+11. **LDAP 支持**, 当在API Server上设置了LDAP(已测试AD和LDAP),可以通过LDAP中的用户信息进行登录 https://github.com/lejianwen/rustdesk-api/issues/114 ,如果LDAP验证失败，返回本地用户
 
 ### Web Client:
 
 1. 如果已经登录了后台，web client将自动直接登录
 2. 如果没登录后台，点击右上角登录即可，api server已经自动配置好了
-   ![webclient_conf](docs/webclient_conf.png)
 3. 登录后，会自动同步ID服务器和KEY
 4. 登录后，会将地址簿自动保存到web client中，方便使用
+5. 现已支持`v2 Preview`，访问路径是`/webclient2`
+   ![webclientv2](./docs/webclientv2.png)
+6. `v2 preview` 部署，参考[WIKI](https://github.com/lejianwen/rustdesk-api/wiki)
+
 
 ### 自动化文档: 使用 Swag 生成 API 文档，方便开发者理解和使用 API。
 
@@ -147,6 +130,18 @@
 2. PC端文档 `<youer server[:port]>/swagger/index.html`
    ![api_swag](docs/api_swag.png)
 
+### CLI
+
+```bash
+# 查看帮助
+./apimain -h
+```
+
+#### 重置管理员密码
+```bash
+./apimain reset-admin-pwd <pwd>
+```
+
 ## 安装与运行
 
 ### 相关配置
@@ -160,6 +155,7 @@ lang: "en"
 app:
   web-client: 1  # 1:启用 0:禁用
   register: false #是否开启注册
+  show-swagger: 0 #是否显示swagger文档
 gin:
   api-addr: "0.0.0.0:21114"
   mode: "release"
@@ -187,37 +183,73 @@ logger:
 proxy:
   enable: false
   host: ""
+jwt:
+  key: ""
+  expire-duration: 360000
+ldap:
+  enable: false
+  url: "ldap://ldap.example.com:389"
+  tls: false
+  tls-verify: false
+  base-dn: "dc=example,dc=com"
+  bind-dn: "cn=admin,dc=example,dc=com"
+  bind-password: "password"
+
+  user:
+    base-dn: "ou=users,dc=example,dc=com"
+    enable-attr: ""       #The attribute name of the user for enabling, in AD it is "userAccountControl", empty means no enable attribute, all users are enabled
+    enable-attr-value: "" # The value of the enable attribute when the user is enabled. If you are using AD, just set random value, it will be ignored.
+    filter: "(cn=*)"
+    username: "uid"       # The attribute name of the user for usernamem if you are using AD, it should be "sAMAccountName"
+    email: "mail"
+    first-name: "givenName"
+    last-name: "sn"
+    sync: false         # If true, the user will be synchronized to the database when the user logs in. If false, the user will be synchronized to the database when the user be created.
+    admin-group: "cn=admin,dc=example,dc=com" # The group name of the admin group, if the user is in this group, the user will be an admin.
+
 ```
 
 ### 环境变量
-变量名前缀是`RUSTDESK_API`，环境变量如果存在将覆盖配置文件中的配置
+环境变量和配置文件`conf/config.yaml`中的配置一一对应，变量名前缀是`RUSTDESK_API`
+下面表格并未全部列出，可以参考`conf/config.yaml`中的配置。
 
-| 变量名                                | 说明                                   | 示例                          |
-|------------------------------------|--------------------------------------|-----------------------------|
-| TZ                                 | 时区                                   | Asia/Shanghai               |
-| RUSTDESK_API_LANG                  | 语言                                   | `en`,`zh-CN`                |
-| RUSTDESK_API_APP_WEB_CLIENT        | 是否启用web-client; 1:启用,0:不启用; 默认启用     | 1                           |
-| RUSTDESK_API_APP_REGISTER          | 是否开启注册; `true`, `false`  默认`false`   | `false`                     |
-| -----GIN配置-----                    | ----------                           | ----------                  |
-| RUSTDESK_API_GIN_TRUST_PROXY       | 信任的代理IP列表，以`,`分割，默认信任所有              | 192.168.1.2,192.168.1.3     |
-| -----------GORM配置----------------  | ------------------------------------ | --------------------------- |
-| RUSTDESK_API_GORM_TYPE             | 数据库类型sqlite或者mysql，默认sqlite          | sqlite                      |
-| RUSTDESK_API_GORM_MAX_IDLE_CONNS   | 数据库最大空闲连接数                           | 10                          |
-| RUSTDESK_API_GORM_MAX_OPEN_CONNS   | 数据库最大打开连接数                           | 100                         |
-| RUSTDESK_API_RUSTDESK_PERSONAL     | 是否启用个人版API， 1:启用,0:不启用； 默认启用         | 1                           |
-| -----MYSQL配置-----                  | ----------                           | ----------                  |
-| RUSTDESK_API_MYSQL_USERNAME        | mysql用户名                             | root                        |
-| RUSTDESK_API_MYSQL_PASSWORD        | mysql密码                              | 111111                      |
-| RUSTDESK_API_MYSQL_ADDR            | mysql地址                              | 192.168.1.66:3306           |
-| RUSTDESK_API_MYSQL_DBNAME          | mysql数据库名                            | rustdesk                    |
-| -----RUSTDESK配置-----               | ---------------                      | ----------                  |
-| RUSTDESK_API_RUSTDESK_ID_SERVER    | Rustdesk的id服务器地址                     | 192.168.1.66:21116          |
-| RUSTDESK_API_RUSTDESK_RELAY_SERVER | Rustdesk的relay服务器地址                  | 192.168.1.66:21117          |
-| RUSTDESK_API_RUSTDESK_API_SERVER   | Rustdesk的api服务器地址                    | http://192.168.1.66:21114   |
-| RUSTDESK_API_RUSTDESK_KEY          | Rustdesk的key                         | 123456789                   |
-| ----PROXY配置-----                   | ---------------                      | ----------                  |
-| RUSTDESK_API_PROXY_ENABLE          | 是否启用代理:`false`, `true`               | `false`                     |
-| RUSTDESK_API_PROXY_HOST            | 代理地址                                 | `http://127.0.0.1:1080`     |
+| 变量名                                                    | 说明                                                                             | 示例                           |
+|--------------------------------------------------------|--------------------------------------------------------------------------------|------------------------------|
+| TZ                                                     | 时区                                                                             | Asia/Shanghai                |
+| RUSTDESK_API_LANG                                      | 语言                                                                             | `en`,`zh-CN`                 |
+| RUSTDESK_API_APP_WEB_CLIENT                            | 是否启用web-client; 1:启用,0:不启用; 默认启用                                               | 1                            |
+| RUSTDESK_API_APP_REGISTER                              | 是否开启注册; `true`, `false`  默认`false`                                             | `false`                      |
+| RUSTDESK_API_APP_SHOW_SWAGGER                          | 是否可见swagger文档;`1`显示，`0`不显示，默认`0`不显示                                            | `1`                          |
+| RUSTDESK_API_APP_TOKEN_EXPIRE                          | token有效时长（秒）                                                                   | `3600`                       |
+| -----ADMIN配置-----                                      | ----------                                                                     | ----------                   |
+| RUSTDESK_API_ADMIN_TITLE                               | 后台标题                                                                           | `RustDesk Api Admin`         |
+| RUSTDESK_API_ADMIN_HELLO                               | 后台欢迎语，可以使用`html`                                                               |                              |
+| RUSTDESK_API_ADMIN_HELLO_FILE                          | 后台欢迎语文件，如果内容多，使用文件更方便。<br>会覆盖`RUSTDESK_API_ADMIN_HELLO`                        | `./conf/admin/hello.html`    |
+| -----GIN配置-----                                        | ----------                                                                     | ----------                   |
+| RUSTDESK_API_GIN_TRUST_PROXY                           | 信任的代理IP列表，以`,`分割，默认信任所有                                                        | 192.168.1.2,192.168.1.3      |
+| -----GORM配置-----                                       | ----------                                                                     | ---------------------------  |
+| RUSTDESK_API_GORM_TYPE                                 | 数据库类型sqlite或者mysql，默认sqlite                                                    | sqlite                       |
+| RUSTDESK_API_GORM_MAX_IDLE_CONNS                       | 数据库最大空闲连接数                                                                     | 10                           |
+| RUSTDESK_API_GORM_MAX_OPEN_CONNS                       | 数据库最大打开连接数                                                                     | 100                          |
+| RUSTDESK_API_RUSTDESK_PERSONAL                         | 是否启用个人版API， 1:启用,0:不启用； 默认启用                                                   | 1                            |
+| -----MYSQL配置-----                                      | ----------                                                                     | ----------                   |
+| RUSTDESK_API_MYSQL_USERNAME                            | mysql用户名                                                                       | root                         |
+| RUSTDESK_API_MYSQL_PASSWORD                            | mysql密码                                                                        | 111111                       |
+| RUSTDESK_API_MYSQL_ADDR                                | mysql地址                                                                        | 192.168.1.66:3306            |
+| RUSTDESK_API_MYSQL_DBNAME                              | mysql数据库名                                                                      | rustdesk                     |
+| -----RUSTDESK配置-----                                   | ----------                                                                     | ----------                   |
+| RUSTDESK_API_RUSTDESK_ID_SERVER                        | Rustdesk的id服务器地址                                                               | 192.168.1.66:21116           |
+| RUSTDESK_API_RUSTDESK_RELAY_SERVER                     | Rustdesk的relay服务器地址                                                            | 192.168.1.66:21117           |
+| RUSTDESK_API_RUSTDESK_API_SERVER                       | Rustdesk的api服务器地址                                                              | http://192.168.1.66:21114    |
+| RUSTDESK_API_RUSTDESK_KEY                              | Rustdesk的key                                                                   | 123456789                    |
+| RUSTDESK_API_RUSTDESK_KEY_FILE                         | Rustdesk存放key的文件                                                               | `./conf/data/id_ed25519.pub` |
+| RUSTDESK_API_RUSTDESK_WEBCLIENT<br/>_MAGIC_QUERYONLINE | Web client v2 中是否启用新的在线状态查询方法; `1`:启用,`0`:不启用,默认不启用                            | `0`                          |
+| ----PROXY配置-----                                       | ----------                                                                     | ----------                   |
+| RUSTDESK_API_PROXY_ENABLE                              | 是否启用代理:`false`, `true`                                                         | `false`                      |
+| RUSTDESK_API_PROXY_HOST                                | 代理地址                                                                           | `http://127.0.0.1:1080`      |
+| ----JWT配置----                                          | --------                                                                       | --------                     |
+| RUSTDESK_API_JWT_KEY                                   | 自定义JWT KEY,为空则不启用JWT<br/>如果没使用`lejianwen/rustdesk-server`中的`MUST_LOGIN`，建议设置为空 |                              |
+| RUSTDESK_API_JWT_EXPIRE_DURATION                       | JWT有效时间                                                                        | 360000                       |
 
 
 ### 运行
@@ -238,189 +270,8 @@ proxy:
     lejianwen/rustdesk-api
     ```
 
-2. 使用`docker compose`
-   - 简单示例
-   ```yaml
-   services:
-      rustdesk-api:
-       container_name: rustdesk-api
-       environment:
-         - TZ=Asia/Shanghai
-         - RUSTDESK_API_RUSTDESK_ID_SERVER=192.168.1.66:21116
-         - RUSTDESK_API_RUSTDESK_RELAY_SERVER=192.168.1.66:21117
-         - RUSTDESK_API_RUSTDESK_API_SERVER=http://192.168.1.66:21114
-         - RUSTDESK_API_RUSTDESK_KEY=<key>
-       ports:
-         - 21114:21114
-       image: lejianwen/rustdesk-api
-       volumes:
-         - /data/rustdesk/api:/app/data #将数据库挂载出来方便备份
-       networks:
-         - rustdesk-net
-       restart: unless-stopped
-   ```
+2. 使用`docker compose`，参考[WIKI](https://github.com/lejianwen/rustdesk-api/wiki)
 
-   - 根据rustdesk官方提供的示例，加上自己的rustdesk-api
-     - 如果是使用的系统生成的KEY，去掉`-k <key>`参数，在启动后运行`docker-compose logs hbbs`或者`cat ./data/id_ed25519.pub`查看KEY，然后再修改`RUSTDESK_API_RUSTDESK_KEY=<key>`再执行`docker-compose up -d`
-      ```yaml
-      networks:
-        rustdesk-net:
-          external: false
-      services:
-        hbbs:
-          container_name: hbbs
-          ports:
-            - 21115:21115
-            - 21116:21116 # 自定义 hbbs 映射端口
-            - 21116:21116/udp # 自定义 hbbs 映射端口
-            - 21118:21118 # web client
-          image: rustdesk/rustdesk-server
-          command: hbbs -r <relay-server-ip[:port]> -k <key> # 填入个人域名或 IP + hbbr 暴露端口
-          volumes:
-            - ./data:/root # 自定义挂载目录
-          networks:
-            - rustdesk-net
-          depends_on:
-            - hbbr
-          restart: unless-stopped
-          deploy:
-            resources:
-              limits:
-                memory: 64M
-        hbbr:
-          container_name: hbbr
-          ports:
-            - 21117:21117 # 自定义 hbbr 映射端口
-            - 21119:21119 # web client
-          image: rustdesk/rustdesk-server
-          command: hbbr -k <key>
-          volumes:
-            - ./data:/root
-          networks:
-            - rustdesk-net
-          restart: unless-stopped
-          deploy:
-            resources:
-              limits:
-                memory: 64M
-        rustdesk-api:
-          container_name: rustdesk-api
-          environment:
-            - TZ=Asia/Shanghai
-            - RUSTDESK_API_RUSTDESK_ID_SERVER=192.168.1.66:21116
-            - RUSTDESK_API_RUSTDESK_RELAY_SERVER=192.168.1.66:21117
-            - RUSTDESK_API_RUSTDESK_API_SERVER=http://192.168.1.66:21114
-            - RUSTDESK_API_RUSTDESK_KEY=<key>
-          ports:
-            - 21114:21114
-          image: lejianwen/rustdesk-api
-          volumes:
-            - /data/rustdesk/api:/app/data #将数据库挂载出来方便备份
-          networks:
-            - rustdesk-net
-          restart: unless-stopped
-      ```
-     
-   - S6的镜像
-     - 如果使用***自定义KEY***，会需要修改启动脚本，覆盖镜像中的`/etc/s6-overlay/s6-rc.d/hbbr/run`和`/etc/s6-overlay/s6-rc.d/hbbr/run`
-         1. 创建`hbbr/run`，自定义KEY才需要
-            ```bash
-            #!/command/with-contenv sh
-            cd /data
-            PARAMS=
-            [ "${ENCRYPTED_ONLY}" = "1" ] && PARAMS="-k ${KEY}"
-            /usr/bin/hbbr $PARAMS
-            ```
-         2. 创建`hbbs/run`，自定义KEY才需要
-             ```bash
-             #!/command/with-contenv sh
-             sleep 2
-             cd /data
-             PARAMS=
-             [ "${ENCRYPTED_ONLY}" = "1" ] && PARAMS="-k ${KEY}"
-             /usr/bin/hbbs -r $RELAY $PARAMS
-             ```
-         3. 修改`docker-compose.yml`中的`s6`部分
-         ```yaml
-         networks:
-           rustdesk-net:
-             external: false
-         services:
-           rustdesk-server:
-             container_name: rustdesk-server
-             ports:
-               - 21115:21115
-               - 21116:21116
-               - 21116:21116/udp
-               - 21117:21117
-               - 21118:21118
-               - 21119:21119
-             image: rustdesk/rustdesk-server-s6:latest
-             environment:
-               - RELAY=192.168.1.66:21117
-               - ENCRYPTED_ONLY=1
-               - KEY=<key>  #自定义KEY
-             volumes:
-               - ./data:/data
-               - ./hbbr/run:/etc/s6-overlay/s6-rc.d/hbbr/run 
-               - ./hbbs/run:/etc/s6-overlay/s6-rc.d/hbbs/run 
-             restart: unless-stopped
-           rustdesk-api:
-             container_name: rustdesk-api
-             ports:
-               - 21114:21114
-             image: lejianwen/rustdesk-api
-             environment:
-               - TZ=Asia/Shanghai
-               - RUSTDESK_API_RUSTDESK_ID_SERVER=192.168.1.66:21116
-               - RUSTDESK_API_RUSTDESK_RELAY_SERVER=192.168.1.66:21117
-               - RUSTDESK_API_RUSTDESK_API_SERVER=http://192.168.1.66:21114
-               - RUSTDESK_API_RUSTDESK_KEY=<key>
-             volumes:
-               - /data/rustdesk/api:/app/data #将数据库挂载
-             networks:
-               - rustdesk-net
-             restart: unless-stopped
-         ```
-   - 如果使用***系统生成的KEY***或者***自定义KEY_PUB,KEY_PRIV***，不需要修改启动脚本，但要在生成KEY后获取到KEY再`docker-compose up -d`
-       ```yaml
-       networks:
-         rustdesk-net:
-           external: false
-       services:
-         rustdesk-server:
-           container_name: rustdesk-server
-           ports:
-             - 21115:21115
-             - 21116:21116
-             - 21116:21116/udp
-             - 21117:21117
-             - 21118:21118
-             - 21119:21119
-           image: rustdesk/rustdesk-server-s6:latest
-           environment:
-             - RELAY=192.168.1.66:21117
-             - ENCRYPTED_ONLY=1
-           volumes:
-             - ./data:/data
-           restart: unless-stopped
-         rustdesk-api:
-           container_name: rustdesk-api
-           ports:
-             - 21114:21114
-           image: lejianwen/rustdesk-api
-           environment:
-             - TZ=Asia/Shanghai
-             - RUSTDESK_API_RUSTDESK_ID_SERVER=192.168.1.66:21116
-             - RUSTDESK_API_RUSTDESK_RELAY_SERVER=192.168.1.66:21117
-             - RUSTDESK_API_RUSTDESK_API_SERVER=http://192.168.1.66:21114
-             - RUSTDESK_API_RUSTDESK_KEY=<key> #系统生成的KEY
-           volumes:
-             - /data/rustdesk/api:/app/data #将数据库挂载
-           networks:
-             - rustdesk-net
-           restart: unless-stopped
-       ```
 #### 下载release直接运行
 
 [下载地址](https://github.com/lejianwen/rustdesk-api/releases)
@@ -463,22 +314,62 @@ proxy:
 
 6. 打开浏览器访问`http://<your server[:port]>/_admin/`，默认用户名密码为`admin`，请及时更改密码。
 
-#### nginx反代
-在`nginx`中配置反代
-```
-server {
-    listen <your port>;
-    server_name <your server>;
-    location / {
-        proxy_pass http://<api-server[:port]>;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-}
+
+#### 使用`lejianwen/server-s6`镜像运行
+
+- 已解决链接超时问题
+- 可以强制登录后才能发起链接
+- github https://github.com/lejianwen/rustdesk-server
+
+```yaml
+ networks:
+   rustdesk-net:
+     external: false
+ services:
+   rustdesk:
+     ports:
+       - 21114:21114
+       - 21115:21115
+       - 21116:21116
+       - 21116:21116/udp
+       - 21117:21117
+       - 21118:21118
+       - 21119:21119
+     image: lejianwen/rustdesk-server-s6:latest
+     environment:
+       - RELAY=<relay_server[:port]>
+       - ENCRYPTED_ONLY=1
+       - MUST_LOGIN=N
+       - TZ=Asia/Shanghai
+       - RUSTDESK_API_RUSTDESK_ID_SERVER=<id_server[:21116]>
+       - RUSTDESK_API_RUSTDESK_RELAY_SERVER=<relay_server[:21117]>
+       - RUSTDESK_API_RUSTDESK_API_SERVER=http://<api_server[:21114]>
+       - RUSTDESK_API_KEY_FILE=/data/id_ed25519.pub
+       - RUSTDESK_API_JWT_KEY=xxxxxx # jwt key
+     volumes:
+       - /data/rustdesk/server:/data
+       - /data/rustdesk/api:/app/data #将数据库挂载
+     networks:
+       - rustdesk-net
+     restart: unless-stopped
+       
 ```
+
+
 ## 其他
 
+- [WIKI](https://github.com/lejianwen/rustdesk-api/wiki)
+- [链接超时问题](https://github.com/lejianwen/rustdesk-api/issues/92)
 - [修改客户端ID](https://github.com/abdullah-erturk/RustDesk-ID-Changer)
-- [webclient来源](https://hub.docker.com/r/keyurbhole/flutter_web_desk)
+- [webclient来源](https://hub.docker.com/r/keyurbhole/flutter_web_desk)
+
+
+## 鸣谢
+
+感谢所有做过贡献的人!
+
+<a href="https://github.com/lejianwen/rustdesk-api/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=lejianwen/rustdesk-api" />
+</a>
+
+## 感谢你的支持！如果这个项目对你有帮助，请点个⭐️鼓励一下，谢谢！

README_EN.md

@@ -8,6 +8,7 @@ desktop software that provides self-hosted solutions.
 <img src="https://img.shields.io/badge/gin-v1.9.0-lightBlue"/>
 <img src="https://img.shields.io/badge/gorm-v1.25.7-green"/>
 <img src="https://img.shields.io/badge/swag-v1.16.3-yellow"/>
+<img src="https://img.shields.io/badge/i18n-7-green"/>
 <img src="https://github.com/lejianwen/rustdesk-api/actions/workflows/build.yml/badge.svg"/>
 </div>
 
@@ -18,7 +19,10 @@ desktop software that provides self-hosted solutions.
     - Login
     - Address Book
     - Groups
-    - Authorized login, supports `GitHub`, `Google` and `OIDC` login, supports `web admin` authorized login
+    - Authorized login, 
+      - supports `GitHub`, `Google` and `OIDC` login, 
+      - supports `web admin` authorized login, 
+      - supports LDAP(test AD and openladp) if API Server config
     - i18n
 - Web Admin
     - User Management
@@ -27,125 +31,98 @@ desktop software that provides self-hosted solutions.
     - Tag Management
     - Group Management
     - OAuth Management
+    - LDAP Config by config file or ENV
     - Login Logs
     - Connection Logs
     - File Transfer Logs
     - Quick access to web client
     - i18n
     - Share to guest by web client
+    - Server control (some simple official commands [WIKI](https://github.com/lejianwen/rustdesk-api/wiki/Rustdesk-Command))
 - Web Client
     - Automatically obtain API server
     - Automatically obtain ID server and KEY
     - Automatically obtain address book
     - Visitors are remotely to the device via a temporary sharing link
-
-## Prerequisites
-
-### [Rustdesk](https://github.com/rustdesk/rustdesk)
-
-
-#### The PC client uses version ***1.3.0***, and versions ***1.2.6+*** have been tested to work.
-
-#### Solutions for PC client connection timeout or connection issues
-##### Connection issues or timeouts
-Because the server version lags behind the client version, the server does not respond to the client's `secure_tcp` request, causing the client to timeout.
-  Relevant code can be found at `https://github.com/rustdesk/rustdesk/blob/master/src/client.rs#L322`
-  ```rust
-    if !key.is_empty() && !token.is_empty() {
-    // mainly for the security of token
-    allow_err!(secure_tcp(&mut socket, key).await);
-    }
-  ```
-  
-As seen, when both `key` and `token` are not empty, `secure_tcp` is called, but the server does not respond, causing the client to timeout.
-The `secure_tcp` code is located at `https://github.com/rustdesk/rustdesk/blob/master/src/common.rs#L1203`
-
-##### Four Solutions
-1. Specify the key on the server.
-    - Advantage: Simple
-    - Disadvantage: The connection is not encrypted
-       ```bash
-       hbbs -r <relay-server-ip[:port]> -k <key>
-       hbbr -k <key>
-       ```
-      For example
-       ```bash
-         hbbs -r <relay-server-ip[:port]> -k abc1234567
-         hbbr -k abc1234567
-       ```
-2. Use a system-generated key or a custom key pair on the server. If the client is already logged in, it may timeout or fail to connect. Logging out and reconnecting usually resolves the issue, and the web client does not need to log out.
-    - Advantage: Encrypted connection
-    - Disadvantage: Complicated operation
-3. Use a system-generated key or a custom key pair on the server, fork the official client code to modify `secure_tcp` to return directly, then compile using `Github Actions` and download the compiled client.
-   Refer to [official documentation](https://rustdesk.com/docs/en/dev/build/all/)
-    - Advantage: Encrypted connection, customizable client features, ready to use after compilation
-    - Disadvantage: Requires forking code and compiling, which can be challenging
-4. Use [my forked code](https://github.com/lejianwen/rustdesk), which has already modified `secure_tcp`. You can download and use it directly from [here](https://github.com/lejianwen/rustdesk/releases)
-    - Advantage: Code changes are viewable, compiled with `Github Actions`, encrypted connection, ready to use
-    - Disadvantage: May not keep up with official version updates
-   
-***If encryption is not a high priority, use `1`. If encryption is important, use `3` or `4`.***
+- CLI
+    - Reset admin password
 
 ## Overview
 
 ### API Service
 Basic implementation of the PC client's primary interfaces.Supports the Personal version api, which can be enabled by configuring the `rustdesk.personal` file or the `RUSTDESK_API_RUSTDESK_PERSONAL` environment variable.
 
-#### Login
-
-- Added `GitHub`, `Google` and `OIDC` login, which can be used after configuration in the admin panel. See the OAuth
-  configuration section for details.
-- Added authorization login for the web admin panel.
-
-![pc_login](docs/en_img/pc_login.png)
-
-#### Address Book
-
-![pc_ab](docs/en_img/pc_ab.png)
-
-#### Groups
-Groups are divided into `shared groups` and `regular groups`. In shared groups, everyone can see the peers of all group members, while in regular groups, only administrators can see all members' peers.
-
-![pc_gr](docs/en_img/pc_gr.png)
+<table>
+    <tr>
+      <td width="50%" align="center" colspan="2"><b>Login</b></td>
+    </tr>
+    <tr>
+        <td width="50%" align="center" colspan="2"><img src="docs/en_img/pc_login.png"></td>
+    </tr>
+     <tr>
+      <td width="50%" align="center"><b>Address Book</b></td>
+      <td width="50%" align="center"><b>Groups</b></td>
+    </tr>
+    <tr>
+        <td width="50%" align="center"><img src="docs/en_img/pc_ab.png"></td>
+        <td width="50%" align="center"><img src="docs/en_img/pc_gr.png"></td>
+    </tr>
+</table>
 
 ### Web Admin
 
 * The frontend and backend are separated to provide a user-friendly management interface, primarily for managing and
 displaying data.Frontend code is available at [rustdesk-api-web](https://github.com/lejianwen/rustdesk-api-web)
 
-* Admin panel URL: `http://<your server[:port]>/_admin/`. The default username and password for the initial
-installation are `admin` `admin`, please change the password immediately.
+* Admin panel URL: `http://<your server[:port]>/_admin/`
+* For the initial installation, the admin username is `admin`, and the password will be printed in the console. You can change the password via the [command line](#CLI).
+
+  ![img.png](./docs/init_admin_pwd.png)
+
 
 1. Admin interface:
    ![web_admin](docs/en_img/web_admin.png)
 2. Regular user interface:
    ![web_user](docs/en_img/web_admin_user.png)
-   In the top right corner, you can change the password, switch languages, and toggle between `day/night` mode.
 
-   ![web_resetpwd](docs/en_img/web_resetpwd.png)
-3. Groups can be customized for easy management. Currently, two types are supported: `shared group` and `regular group`.
-   ![web_admin_gr](docs/en_img/web_admin_gr.png)
-4. You can directly launch the client or open the web client for convenience; you can also share it with guests, who can remotely access the device via the web client.
-
-   ![web_webclient](docs/en_img/admin_webclient.png)
-5. OAuth support: Currently, `GitHub`, `Google` and `OIDC`  are supported. You need to create an `OAuth App` and configure it in
+3. Each user can have multiple address books, which can also be shared with other users.
+4. Groups can be customized for easy management. Currently, two types are supported: `shared group` and `regular group`.
+5. You can directly launch the client or open the web client for convenience; you can also share it with guests, who can remotely access the device via the web client.
+6. OAuth support: Currently, `GitHub`, `Google` and `OIDC`  are supported. You need to create an `OAuth App` and configure it in
    the admin panel.
-   ![web_admin_oauth](docs/en_img/web_admin_oauth.png)
     - For `Google` and `Github`, you don't need to fill the `Issuer` and `Scpoes`
     - For `OIDC`, you must set the `Issuer`. And `Scopes` is optional which default is `openid,email,profile`, please make sure this `Oauth App` can access `sub`, `email` and `preferred_username`
     - Create a `GitHub OAuth App`
       at `Settings` -> `Developer settings` -> `OAuth Apps` -> `New OAuth App` [here](https://github.com/settings/developers).
     - Set the `Authorization callback URL` to `http://<your server[:port]>/api/oauth/callback`,
       e.g., `http://127.0.0.1:21114/api/oauth/callback`.
+   
+7. Login logs
+8. Connection logs
+9. File transfer logs
+10. Server control
+  - `Simple mode`, some simple commands have been GUI-ized and can be executed directly in the backend
+    ![rustdesk_command_simple](./docs/en_img/rustdesk_command_simple.png)
 
+  - `Advanced mode`, commands can be executed directly in the backend
+    * Official commands can be used
+    * Custom commands can be added
+    * Custom commands can be executed
+
+    ![rustdesk_command_advance](./docs/en_img/rustdesk_command_advance.png)
+
+11. **LDAP Support**, When you setup the LDAP(test for OpenLDAP and AD), you can login with the LDAP's user. https://github.com/lejianwen/rustdesk-api/issues/114 , if LDAP fail fallback local user
+  
 ### Web Client:
 
 1. If you're already logged into the admin panel, the web client will log in automatically.
 2. If you're not logged in, simply click the login button in the top right corner, and the API server will be
    pre-configured.
-   ![webclient_conf](docs/webclient_conf.png)
 3. After logging in, the ID server and key will be automatically synced.
 4. The address book will also be automatically saved to the web client for convenient use.
+5. Now supports `v2 Preview`, accessible at `/webclient2`
+   ![webclientv2](./docs/webclientv2.png)
+6. `v2 preview` deployment, [WIKI](https://github.com/lejianwen/rustdesk-api/wiki)
 
 ### Automated Documentation : API documentation is generated using Swag, making it easier for developers to understand and use the API.
 
@@ -153,6 +130,17 @@ installation are `admin` `admin`, please change the password immediately.
 2. PC client docs: `<your server[:port]>/swagger/index.html`
    ![api_swag](docs/api_swag.png)
 
+### CLI
+```bash
+# help
+./apimain -h
+```
+
+#### Reset admin password
+```bash
+./apimain reset-admin-pwd <pwd>
+```
+
 ## Installation and Setup
 
 ### Configuration
@@ -166,6 +154,7 @@ lang: "en"
 app:
   web-client: 1  # web client route 1:open 0:close  
   register: false #register enable
+  show-swagger: 0 #show swagger 1:open 0:close
 gin:
   api-addr: "0.0.0.0:21114"
   mode: "release"
@@ -193,37 +182,73 @@ logger:
 proxy:
   enable: false
   host: ""
+jwt:
+  key: ""
+  expire-duration: 360000
+ldap:
+  enable: false
+  url: "ldap://ldap.example.com:389"
+  tls: false
+  tls-verify: false
+  base-dn: "dc=example,dc=com"
+  bind-dn: "cn=admin,dc=example,dc=com"
+  bind-password: "password"
+
+  user:
+    base-dn: "ou=users,dc=example,dc=com"
+    enable-attr: ""       #The attribute name of the user for enabling, in AD it is "userAccountControl", empty means no enable attribute, all users are enabled
+    enable-attr-value: "" # The value of the enable attribute when the user is enabled. If you are using AD, just set random value, it will be ignored.
+    filter: "(cn=*)"
+    username: "uid"       # The attribute name of the user for usernamem if you are using AD, it should be "sAMAccountName"
+    email: "mail"
+    first-name: "givenName"
+    last-name: "sn"
+    sync: false         # If true, the user will be synchronized to the database when the user logs in. If false, the user will be synchronized to the database when the user be created.
+    admin-group: "cn=admin,dc=example,dc=com" # The group name of the admin group, if the user is in this group, the user will be an admin.
+
 ```
 
 ### Environment Variables
-The prefix for variable names is `RUSTDESK_API`. If environment variables exist, they will override the configurations in the configuration file.
+The environment variables correspond one-to-one with the configurations in the `conf/config.yaml` file. The prefix for variable names is `RUSTDESK_API`.
+The table below does not list all configurations. Please refer to the configurations in `conf/config.yaml`.
 
-| Variable Name                      | Description                                               | Example                       |
-|------------------------------------|-----------------------------------------------------------|-------------------------------|
-| TZ                                 | timezone                                                  | Asia/Shanghai                 |
-| RUSTDESK_API_LANG                  | Language                                                  | `en`,`zh-CN`                  |
-| RUSTDESK_API_APP_WEB_CLIENT        | web client on/off; 1: on, 0 off, deault 1                 | 1                             |
-| RUSTDESK_API_APP_REGISTER          | register enable; `true`, `false`; default:`false`         | `false`                       |
-| ----- GIN Configuration -----      | ---------------------------------------                   | ----------------------------- |
-| RUSTDESK_API_GIN_TRUST_PROXY       | Trusted proxy IPs, separated by commas.                   | 192.168.1.2,192.168.1.3       |
-| ----- GORM Configuration -----     | ---------------------------------------                   | ----------------------------- |
-| RUSTDESK_API_GORM_TYPE             | Database type (`sqlite` or `mysql`). Default is `sqlite`. | sqlite                        |
-| RUSTDESK_API_GORM_MAX_IDLE_CONNS   | Maximum idle connections                                  | 10                            |
-| RUSTDESK_API_GORM_MAX_OPEN_CONNS   | Maximum open connections                                  | 100                           |
-| RUSTDESK_API_RUSTDESK_PERSONAL     | Open Personal Api 1:Enable,0:Disable                      | 1                             |
-| ----- MYSQL Configuration -----    | ---------------------------------------                   | ----------------------------- |
-| RUSTDESK_API_MYSQL_USERNAME        | MySQL username                                            | root                          |
-| RUSTDESK_API_MYSQL_PASSWORD        | MySQL password                                            | 111111                        |
-| RUSTDESK_API_MYSQL_ADDR            | MySQL address                                             | 192.168.1.66:3306             |
-| RUSTDESK_API_MYSQL_DBNAME          | MySQL database name                                       | rustdesk                      |
-| ----- RUSTDESK Configuration ----- | ---------------------------------------                   | ----------------------------- |
-| RUSTDESK_API_RUSTDESK_ID_SERVER    | Rustdesk ID server address                                | 192.168.1.66:21116            |
-| RUSTDESK_API_RUSTDESK_RELAY_SERVER | Rustdesk relay server address                             | 192.168.1.66:21117            |
-| RUSTDESK_API_RUSTDESK_API_SERVER   | Rustdesk API server address                               | http://192.168.1.66:21114     |
-| RUSTDESK_API_RUSTDESK_KEY          | Rustdesk key                                              | 123456789                     |
-| ---- PROXY -----                   | ---------------                                           | ----------                    |
-| RUSTDESK_API_PROXY_ENABLE          | proxy_enable :`false`, `true`                             | `false`                       |
-| RUSTDESK_API_PROXY_HOST            | proxy_host                                                | `http://127.0.0.1:1080`       |
+| Variable Name                                     | Description                                                                                                                                          | Example                       |
+|---------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------|
+| TZ                                                | timezone                                                                                                                                             | Asia/Shanghai                 |
+| RUSTDESK_API_LANG                                 | Language                                                                                                                                             | `en`,`zh-CN`                  |
+| RUSTDESK_API_APP_WEB_CLIENT                       | web client on/off; 1: on, 0 off, default: 1                                                                                                          | 1                             |
+| RUSTDESK_API_APP_REGISTER                         | register enable; `true`, `false`; default:`false`                                                                                                    | `false`                       |
+| RUSTDESK_API_APP_SHOW_SWAGGER                     | swagger visible; 1: yes, 0: no; default: 0                                                                                                           | `0`                           |
+| RUSTDESK_API_APP_TOKEN_EXPIRE                     | token expire duration(second)                                                                                                                        | `3600`                        |
+| ----- ADMIN Configuration-----                    | ----------                                                                                                                                           | ----------                    |
+| RUSTDESK_API_ADMIN_TITLE                          | Admin Title                                                                                                                                          | `RustDesk Api Admin`          |
+| RUSTDESK_API_ADMIN_HELLO                          | Admin welcome message, you can use `html`                                                                                                            |                               |
+| RUSTDESK_API_ADMIN_HELLO_FILE                     | Admin welcome message file,<br>will override `RUSTDESK_API_ADMIN_HELLO`                                                                              | `./conf/admin/hello.html`     |
+| ----- GIN Configuration -----                     | ---------------------------------------                                                                                                              | ----------------------------- |
+| RUSTDESK_API_GIN_TRUST_PROXY                      | Trusted proxy IPs, separated by commas.                                                                                                              | 192.168.1.2,192.168.1.3       |
+| ----- GORM Configuration -----                    | ---------------------------------------                                                                                                              | ----------------------------- |
+| RUSTDESK_API_GORM_TYPE                            | Database type (`sqlite` or `mysql`). Default is `sqlite`.                                                                                            | sqlite                        |
+| RUSTDESK_API_GORM_MAX_IDLE_CONNS                  | Maximum idle connections                                                                                                                             | 10                            |
+| RUSTDESK_API_GORM_MAX_OPEN_CONNS                  | Maximum open connections                                                                                                                             | 100                           |
+| RUSTDESK_API_RUSTDESK_PERSONAL                    | Open Personal Api 1:Enable,0:Disable                                                                                                                 | 1                             |
+| ----- MYSQL Configuration -----                   | ---------------------------------------                                                                                                              | ----------------------------- |
+| RUSTDESK_API_MYSQL_USERNAME                       | MySQL username                                                                                                                                       | root                          |
+| RUSTDESK_API_MYSQL_PASSWORD                       | MySQL password                                                                                                                                       | 111111                        |
+| RUSTDESK_API_MYSQL_ADDR                           | MySQL address                                                                                                                                        | 192.168.1.66:3306             |
+| RUSTDESK_API_MYSQL_DBNAME                         | MySQL database name                                                                                                                                  | rustdesk                      |
+| ----- RUSTDESK Configuration -----                | ---------------------------------------                                                                                                              | ----------------------------- |
+| RUSTDESK_API_RUSTDESK_ID_SERVER                   | Rustdesk ID server address                                                                                                                           | 192.168.1.66:21116            |
+| RUSTDESK_API_RUSTDESK_RELAY_SERVER                | Rustdesk relay server address                                                                                                                        | 192.168.1.66:21117            |
+| RUSTDESK_API_RUSTDESK_API_SERVER                  | Rustdesk API server address                                                                                                                          | http://192.168.1.66:21114     |
+| RUSTDESK_API_RUSTDESK_KEY                         | Rustdesk key                                                                                                                                         | 123456789                     |
+| RUSTDESK_API_RUSTDESK_KEY_FILE                    | Rustdesk key file                                                                                                                                    | `./conf/data/id_ed25519.pub`  |
+| RUSTDESK_API_RUSTDESK<br/>_WEBCLIENT_MAGIC_QUERYONLINE | New online query method is enabled in the web client v2; '1': Enabled, '0': Disabled, not enabled by default                                         | `0`                           |
+| ---- PROXY -----                                  | ---------------                                                                                                                                      | ----------                    |
+| RUSTDESK_API_PROXY_ENABLE                         | proxy_enable :`false`, `true`                                                                                                                        | `false`                       |
+| RUSTDESK_API_PROXY_HOST                           | proxy_host                                                                                                                                           | `http://127.0.0.1:1080`       |
+| ----JWT----                                       | --------                                                                                                                                             | --------                      |
+| RUSTDESK_API_JWT_KEY                              | Custom JWT KEY, if empty JWT is not enabled.<br/>If `MUST_LOGIN` from `lejianwen/rustdesk-server` is not used, it is recommended to leave it empty.  |                               |
+| RUSTDESK_API_JWT_EXPIRE_DURATION                  | JWT expire duration                                                                                                                                  | 360000                        |
 
 ### Installation Steps
 
@@ -243,189 +268,7 @@ The prefix for variable names is `RUSTDESK_API`. If environment variables exist,
     lejianwen/rustdesk-api
     ```
 
-2. Using `docker-compose`
-    - Simple example:
-       ```yaml
-       services:
-          rustdesk-api:
-           container_name: rustdesk-api
-           environment:
-             - RUSTDESK_API_LANG=en
-             - RUSTDESK_API_RUSTDESK_ID_SERVER=192.168.1.66:21116
-             - RUSTDESK_API_RUSTDESK_RELAY_SERVER=192.168.1.66:21117
-             - RUSTDESK_API_RUSTDESK_API_SERVER=http://192.168.1.66:21114
-             - RUSTDESK_API_RUSTDESK_KEY=<key>
-           ports:
-             - 21114:21114
-           image: lejianwen/rustdesk-api
-           volumes:
-             - /data/rustdesk/api:/app/data # Mount the database for easy backup
-           networks:
-             - rustdesk-net
-           restart: unless-stopped
-       ```
-
-    - Example with RustDesk's official Docker Compose file, adding your `rustdesk-api` service:
-     - If you are using a system-generated KEY, remove the `-k <key>` parameter. However, after the first startup, run `docker-compose logs hbbs` or `cat ./data/id_ed25519.pub` to view the KEY, then modify `RUSTDESK_API_RUSTDESK_KEY=<key>` and execute `docker-compose up -d` again.
-       ```yaml
-          networks:
-            rustdesk-net:
-              external: false
-          services:
-            hbbs:
-              container_name: hbbs
-              ports:
-                - 21115:21115
-                - 21116:21116 # 自定义 hbbs 映射端口
-                - 21116:21116/udp # 自定义 hbbs 映射端口
-                - 21118:21118 # web client
-              image: rustdesk/rustdesk-server
-              command: hbbs -r <relay-server-ip[:port]> -k <key> # 填入个人域名或 IP + hbbr 暴露端口
-              volumes:
-                - ./data:/root # 自定义挂载目录
-              networks:
-                - rustdesk-net
-              depends_on:
-                - hbbr
-              restart: unless-stopped
-              deploy:
-                resources:
-                  limits:
-                    memory: 64M
-            hbbr:
-              container_name: hbbr
-              ports:
-                - 21117:21117 # 自定义 hbbr 映射端口
-                - 21119:21119 # web client
-              image: rustdesk/rustdesk-server
-              command: hbbr -k <key>
-              volumes:
-                - ./data:/root
-              networks:
-                - rustdesk-net
-              restart: unless-stopped
-              deploy:
-                resources:
-                  limits:
-                    memory: 64M
-            rustdesk-api:
-              container_name: rustdesk-api
-              environment:
-                - TZ=Asia/Shanghai
-                - RUSTDESK_API_RUSTDESK_ID_SERVER=192.168.1.66:21116
-                - RUSTDESK_API_RUSTDESK_RELAY_SERVER=192.168.1.66:21117
-                - RUSTDESK_API_RUSTDESK_API_SERVER=http://192.168.1.66:21114
-                - RUSTDESK_API_RUSTDESK_KEY=<key>
-              ports:
-                - 21114:21114
-              image: lejianwen/rustdesk-api
-              volumes:
-                - /data/rustdesk/api:/app/data #将数据库挂载出来方便备份
-              networks:
-                - rustdesk-net
-              restart: unless-stopped
-          ```
-
-   - S6 image
-       - - If using ***custom KEY***, you will need to modify the startup script to override the `/etc/s6-overlay/s6-rc.d/hbbr/run` and `/etc/s6-overlay/s6-rc.d/hbbr/run` in the image.
-           1. Create `hbbr/run`, only needed for custom KEY
-              ```bash
-              #!/command/with-contenv sh
-              cd /data
-              PARAMS=
-              [ "${ENCRYPTED_ONLY}" = "1" ] && PARAMS="-k ${KEY}"
-              /usr/bin/hbbr $PARAMS
-              ```
-           2. Create `hbbs/run`, only needed for custom KEY
-               ```bash
-               #!/command/with-contenv sh
-               sleep 2
-               cd /data
-               PARAMS=
-               [ "${ENCRYPTED_ONLY}" = "1" ] && PARAMS="-k ${KEY}"
-               /usr/bin/hbbs -r $RELAY $PARAMS
-               ```
-           3. Modify the `s6` section in `docker-compose.yml`
-           ```yaml
-           networks:
-             rustdesk-net:
-               external: false
-           services:
-             rustdesk-server:
-               container_name: rustdesk-server
-               ports:
-                 - 21115:21115
-                 - 21116:21116
-                 - 21116:21116/udp
-                 - 21117:21117
-                 - 21118:21118
-                 - 21119:21119
-               image: rustdesk/rustdesk-server-s6:latest
-               environment:
-                 - RELAY=192.168.1.66:21117
-                 - ENCRYPTED_ONLY=1
-                 - KEY=<key>  #KEY
-               volumes:
-                 - ./data:/data
-                 - ./hbbr/run:/etc/s6-overlay/s6-rc.d/hbbr/run 
-                 - ./hbbs/run:/etc/s6-overlay/s6-rc.d/hbbs/run 
-               restart: unless-stopped
-             rustdesk-api:
-               container_name: rustdesk-api
-               ports:
-                 - 21114:21114
-               image: lejianwen/rustdesk-api
-               environment:
-                 - TZ=Asia/Shanghai
-                 - RUSTDESK_API_RUSTDESK_ID_SERVER=192.168.1.66:21116
-                 - RUSTDESK_API_RUSTDESK_RELAY_SERVER=192.168.1.66:21117
-                 - RUSTDESK_API_RUSTDESK_API_SERVER=http://192.168.1.66:21114
-                 - RUSTDESK_API_RUSTDESK_KEY=<key>
-               volumes:
-                 - /data/rustdesk/api:/app/data 
-               networks:
-                 - rustdesk-net
-               restart: unless-stopped
-           ```
-   - If using ***system-generated KEY*** or ***custom KEY_PUB, KEY_PRIV***, you do not need to modify the startup script, but you need to obtain the KEY after it is generated and then run `docker-compose up -d`
-       ```yaml
-       networks:
-         rustdesk-net:
-           external: false
-       services:
-         rustdesk-server:
-           container_name: rustdesk-server
-           ports:
-             - 21115:21115
-             - 21116:21116
-             - 21116:21116/udp
-             - 21117:21117
-             - 21118:21118
-             - 21119:21119
-           image: rustdesk/rustdesk-server-s6:latest
-           environment:
-             - RELAY=192.168.1.66:21117
-             - ENCRYPTED_ONLY=1
-           volumes:
-             - ./data:/data
-           restart: unless-stopped
-         rustdesk-api:
-           container_name: rustdesk-api
-           ports:
-             - 21114:21114
-           image: lejianwen/rustdesk-api
-           environment:
-             - TZ=Asia/Shanghai
-             - RUSTDESK_API_RUSTDESK_ID_SERVER=192.168.1.66:21116
-             - RUSTDESK_API_RUSTDESK_RELAY_SERVER=192.168.1.66:21117
-             - RUSTDESK_API_RUSTDESK_API_SERVER=http://192.168.1.66:21114
-             - RUSTDESK_API_RUSTDESK_KEY=<key>
-           volumes:
-             - /data/rustdesk/api:/app/data 
-           networks:
-             - rustdesk-net
-           restart: unless-stopped
-       ```
+2. Using `docker-compose`,look [WIKI](https://github.com/lejianwen/rustdesk-api/wiki)
 
 #### Running from Release
 
@@ -474,22 +317,58 @@ Download the release from [release](https://github.com/lejianwen/rustdesk-api/re
 6. Open your browser and visit `http://<your server[:port]>/_admin/`, with default credentials `admin admin`. Please
    change the password promptly.
 
-#### nginx reverse proxy
-Configure reverse proxy in `nginx`
-```
-server {
-    listen <your port>;
-    server_name <your server>;
-    location / {
-        proxy_pass http://<api-server[:port]>;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-}
+#### Running with my forked server-s6 image
+
+- Connection timeout issue resolved
+- Can enforce login before initiating a connection
+- github https://github.com/lejianwen/rustdesk-server
+
+```yaml
+ networks:
+   rustdesk-net:
+     external: false
+ services:
+   rustdesk:
+     ports:
+       - 21114:21114
+       - 21115:21115
+       - 21116:21116
+       - 21116:21116/udp
+       - 21117:21117
+       - 21118:21118
+       - 21119:21119
+     image: lejianwen/rustdesk-server-s6:latest
+     environment:
+       - RELAY=<relay_server[:port]>
+       - ENCRYPTED_ONLY=1
+       - MUST_LOGIN=N
+       - TZ=Asia/Shanghai
+       - RUSTDESK_API_RUSTDESK_ID_SERVER=<id_server[:21116]>
+       - RUSTDESK_API_RUSTDESK_RELAY_SERVER=<relay_server[:21117]>
+       - RUSTDESK_API_RUSTDESK_API_SERVER=http://<api_server[:21114]>
+       - RUSTDESK_API_KEY_FILE=/data/id_ed25519.pub
+       - RUSTDESK_API_JWT_KEY=xxxxxx # jwt key
+     volumes:
+       - /data/rustdesk/server:/data
+       - /data/rustdesk/api:/app/data #将数据库挂载
+     networks:
+       - rustdesk-net
+     restart: unless-stopped
+       
 ```
 ## Others
 
+- [WIKI](https://github.com/lejianwen/rustdesk-api/wiki)
+- [Connection Timeout](https://github.com/lejianwen/rustdesk-api/issues/92)
 - [Change client ID](https://github.com/abdullah-erturk/RustDesk-ID-Changer)
-- [Web client source](https://hub.docker.com/r/keyurbhole/flutter_web_desk)
+- [Web client source](https://hub.docker.com/r/keyurbhole/flutter_web_desk)
+
+## Acknowledgements
+
+Thanks to everyone who contributed!
+
+<a href="https://github.com/lejianwen/rustdesk-api/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=lejianwen/rustdesk-api" />
+</a>
+
+## Thanks for your support! If you find this project useful, please give it a ⭐️. Thank you!

cmd/apimain.go

@@ -1,19 +1,24 @@
 package main
 
 import (
-	"Gwen/config"
-	"Gwen/global"
-	"Gwen/http"
-	"Gwen/lib/cache"
-	"Gwen/lib/lock"
-	"Gwen/lib/logger"
-	"Gwen/lib/orm"
-	"Gwen/lib/upload"
-	"Gwen/model"
-	"Gwen/service"
-	"fmt"
 	"github.com/go-redis/redis/v8"
+	"github.com/lejianwen/rustdesk-api/v2/config"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http"
+	"github.com/lejianwen/rustdesk-api/v2/lib/cache"
+	"github.com/lejianwen/rustdesk-api/v2/lib/jwt"
+	"github.com/lejianwen/rustdesk-api/v2/lib/lock"
+	"github.com/lejianwen/rustdesk-api/v2/lib/logger"
+	"github.com/lejianwen/rustdesk-api/v2/lib/orm"
+	"github.com/lejianwen/rustdesk-api/v2/lib/upload"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"github.com/lejianwen/rustdesk-api/v2/utils"
 	"github.com/nicksnyder/go-i18n/v2/i18n"
+	"github.com/spf13/cobra"
+	"os"
+	"strconv"
+	"time"
 )
 
 // @title 管理系统API
@@ -26,9 +31,76 @@ import (
 // @securitydefinitions.apikey BearerAuth
 // @in header
 // @name Authorization
+
+var rootCmd = &cobra.Command{
+	Use:   "apimain",
+	Short: "RUSTDESK API SERVER",
+	PersistentPreRun: func(cmd *cobra.Command, args []string) {
+		InitGlobal()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		global.Logger.Info("API SERVER START")
+		http.ApiInit()
+	},
+}
+
+var resetPwdCmd = &cobra.Command{
+	Use:     "reset-admin-pwd [pwd]",
+	Example: "reset-admin-pwd 123456",
+	Short:   "Reset Admin Password",
+	Args:    cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		pwd := args[0]
+		admin := service.AllService.UserService.InfoById(1)
+		err := service.AllService.UserService.UpdatePassword(admin, pwd)
+		if err != nil {
+			global.Logger.Error("reset password fail! ", err)
+			return
+		}
+		global.Logger.Info("reset password success! ")
+	},
+}
+var resetUserPwdCmd = &cobra.Command{
+	Use:     "reset-pwd [userId] [pwd]",
+	Example: "reset-pwd 2 123456",
+	Short:   "Reset User Password",
+	Args:    cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		userId := args[0]
+		pwd := args[1]
+		uid, err := strconv.Atoi(userId)
+		if err != nil {
+			global.Logger.Warn("userId must be int!")
+			return
+		}
+		if uid <= 0 {
+			global.Logger.Warn("userId must be greater than 0! ")
+			return
+		}
+		u := service.AllService.UserService.InfoById(uint(uid))
+		err = service.AllService.UserService.UpdatePassword(u, pwd)
+		if err != nil {
+			global.Logger.Warn("reset password fail! ", err)
+			return
+		}
+		global.Logger.Info("reset password success!")
+	},
+}
+
+func init() {
+	rootCmd.PersistentFlags().StringVarP(&global.ConfigPath, "config", "c", "./conf/config.yaml", "choose config file")
+	rootCmd.AddCommand(resetPwdCmd, resetUserPwdCmd)
+}
 func main() {
+	if err := rootCmd.Execute(); err != nil {
+		global.Logger.Error(err)
+		os.Exit(1)
+	}
+}
+
+func InitGlobal() {
 	//配置解析
-	global.Viper = config.Init(&global.Config)
+	global.Viper = config.Init(&global.Config, global.ConfigPath)
 
 	//日志
 	global.Logger = logger.New(&logger.Config{
@@ -90,25 +162,19 @@ func main() {
 
 	//jwt
 	//fmt.Println(global.Config.Jwt.PrivateKey)
-	//global.Jwt = jwt.NewJwt(global.Config.Jwt.PrivateKey, global.Config.Jwt.ExpireDuration*time.Second)
+	global.Jwt = jwt.NewJwt(global.Config.Jwt.Key, global.Config.Jwt.ExpireDuration*time.Second)
 
 	//locker
 	global.Lock = lock.NewLocal()
-
-	//gin
-	http.ApiInit()
-
 }
-
 func DatabaseAutoUpdate() {
-	version := 245
+	version := 260
 
 	db := global.DB
 
 	if global.Config.Gorm.Type == config.TypeMysql {
 		//检查存不存在数据库，不存在则创建
 		dbName := db.Migrator().CurrentDatabase()
-		fmt.Println("dbName", dbName)
 		if dbName == "" {
 			dbName = global.Config.Mysql.Dbname
 			// 移除 DSN 中的数据库名称，以便初始连接时不指定数据库
@@ -120,18 +186,18 @@ func DatabaseAutoUpdate() {
 			// 获取底层的 *sql.DB 对象，并确保在程序退出时关闭连接
 			sqlDBWithoutDB, err := dbWithoutDB.DB()
 			if err != nil {
-				fmt.Printf("获取底层 *sql.DB 对象失败: %v\n", err)
+				global.Logger.Errorf("获取底层 *sql.DB 对象失败: %v", err)
 				return
 			}
 			defer func() {
 				if err := sqlDBWithoutDB.Close(); err != nil {
-					fmt.Printf("关闭连接失败: %v\n", err)
+					global.Logger.Errorf("关闭连接失败: %v", err)
 				}
 			}()
 
 			err = dbWithoutDB.Exec("CREATE DATABASE IF NOT EXISTS " + dbName + " DEFAULT CHARSET utf8mb4").Error
 			if err != nil {
-				fmt.Println(err)
+				global.Logger.Error(err)
 				return
 			}
 		}
@@ -150,7 +216,7 @@ func DatabaseAutoUpdate() {
 		if v.Version < 245 {
 			//oauths 表的 oauth_type 字段设置为 op同样的值
 			db.Exec("update oauths set oauth_type = op")
-			db.Exec("update oauths set issuer = 'https://accounts.google.com' where op = 'google' and issuer = ''")
+			db.Exec("update oauths set issuer = 'https://accounts.google.com' where op = 'google'")
 			db.Exec("update user_thirds set oauth_type = third_type, op = third_type")
 			//通过email迁移旧的google授权
 			uts := make([]model.UserThird, 0)
@@ -161,11 +227,14 @@ func DatabaseAutoUpdate() {
 				}
 			}
 		}
+		if v.Version < 246 {
+			db.Exec("update oauths set issuer = 'https://accounts.google.com' where op = 'google' and issuer is null")
+		}
 	}
 
 }
 func Migrate(version uint) {
-	fmt.Println("migrating....", version)
+	global.Logger.Info("migrating....", version)
 	err := global.DB.AutoMigrate(
 		&model.Version{},
 		&model.User{},
@@ -182,9 +251,10 @@ func Migrate(version uint) {
 		&model.AuditFile{},
 		&model.AddressBookCollection{},
 		&model.AddressBookCollectionRule{},
+		&model.ServerCmd{},
 	)
 	if err != nil {
-		fmt.Println("migrate err :=>", err)
+		global.Logger.Error("migrate err :=>", err)
 	}
 	global.DB.Create(&model.Version{Version: version})
 	//如果是初次则创建一个默认用户
@@ -218,7 +288,11 @@ func Migrate(version uint) {
 			IsAdmin:  &is_admin,
 			GroupId:  1,
 		}
-		admin.Password = service.AllService.UserService.EncryptPassword("admin")
+
+		// 生成随机密码
+		pwd := utils.RandomString(8)
+		global.Logger.Info("Admin Password Is: ", pwd)
+		admin.Password = service.AllService.UserService.EncryptPassword(pwd)
 		global.DB.Create(admin)
 	}
 

conf/admin/hello.html

@@ -0,0 +1 @@
+### 👏👏👏 你好 ***{{username}}***， 欢迎使用 [RustDesk API](https://github.com/lejianwen/rustdesk-api)

conf/config.yaml

@@ -2,6 +2,14 @@ lang: "zh-CN"
 app:
   web-client: 1  # 1:启用 0:禁用
   register: false #是否开启注册
+  show-swagger: 0 # 1:启用 0:禁用
+  token-expire: 360000
+  web-sso: true #web auth sso
+  disable-pwd-login: false #禁用密码登录
+admin:
+  title: "RustDesk Api Admin"
+  hello-file: "./conf/admin/hello.html"  #优先使用file
+  hello: ""
 gin:
   api-addr: "0.0.0.0:21114"
   mode: "release" #release,debug,test
@@ -21,15 +29,40 @@ rustdesk:
   relay-server: "192.168.1.66:21117"
   api-server: "http://127.0.0.1:21114"
   key: ""
-  key-file: "./conf/data/id_ed25519.pub"
+  key-file: "/data/id_ed25519.pub"
   personal: 1
+  webclient-magic-queryonline: 0
 logger:
   path: "./runtime/log.txt"
-  level: "warn" #trace,debug,info,warn,error,fatal
+  level: "info" #trace,debug,info,warn,error,fatal
   report-caller: true
 proxy:
   enable: false
   host: "http://127.0.0.1:1080"
+jwt:
+  key: ""
+  expire-duration: 360000
+ldap:
+  enable: false
+  url: "ldap://ldap.example.com:389"
+  tls: false
+  tls-verify: false
+  base-dn: "dc=example,dc=com"
+  bind-dn: "cn=admin,dc=example,dc=com"
+  bind-password: "password"
+
+  user:
+    base-dn: "ou=users,dc=example,dc=com"
+    enable-attr: ""       #The attribute name of the user for enabling, in AD it is "userAccountControl", empty means no enable attribute, all users are enabled
+    enable-attr-value: "" # The value of the enable attribute when the user is enabled. If you are using AD, just set random value, it will be ignored.
+    filter: "(cn=*)"
+    username: "uid"       # The attribute name of the user for usernamem if you are using AD, it should be "sAMAccountName"
+    email: "mail"
+    first-name: "givenName"
+    last-name: "sn"
+    sync: false         # If true, the user will be synchronized to the database when the user logs in. If false, the user will be synchronized to the database when the user be created.
+    admin-group: "cn=admin,dc=example,dc=com" # The group name of the admin group, if the user is in this group, the user will be an admin.
+
 redis:
   addr: "127.0.0.1:6379"
   password: ""
@@ -47,6 +80,4 @@ oss:
   callback-url: ""
   expire-time: 30
   max-byte: 10240
-jwt:
-  private-key: "./conf/jwt_pri.pem"
-  expire-duration: 360000
+

config/config.go

@@ -1,9 +1,7 @@
 package config
 
 import (
-	"flag"
 	"fmt"
-	"github.com/fsnotify/fsnotify"
 	"github.com/spf13/viper"
 	"strings"
 )
@@ -15,13 +13,22 @@ const (
 )
 
 type App struct {
-	WebClient int  `mapstructure:"web-client"`
-	Register  bool `mapstructure:"register"`
+	WebClient       int  `mapstructure:"web-client"`
+	Register        bool `mapstructure:"register"`
+	ShowSwagger     int  `mapstructure:"show-swagger"`
+	TokenExpire     int  `mapstructure:"token-expire"`
+	WebSso          bool `mapstructure:"web-sso"`
+	DisablePwdLogin bool `mapstructure:"disable-pwd-login"`
+}
+type Admin struct {
+	Title     string `mapstructure:"title"`
+	Hello     string `mapstructure:"hello"`
+	HelloFile string `mapstructure:"hello-file"`
 }
-
 type Config struct {
 	Lang     string `mapstructure:"lang"`
 	App      App
+	Admin    Admin
 	Gorm     Gorm
 	Mysql    Mysql
 	Gin      Gin
@@ -32,38 +39,44 @@ type Config struct {
 	Jwt      Jwt
 	Rustdesk Rustdesk
 	Proxy    Proxy
+	Ldap     Ldap
 }
 
 // Init 初始化配置
-func Init(rowVal interface{}) *viper.Viper {
-	var config string
-	flag.StringVar(&config, "c", "", "choose config file.")
-	flag.Parse()
-	if config == "" { // 优先级: 命令行 > 默认值
-		config = DefaultConfig
+func Init(rowVal *Config, path string) *viper.Viper {
+	if path == "" {
+		path = DefaultConfig
 	}
-	v := viper.New()
+	v := viper.GetViper()
 	v.AutomaticEnv()
 	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_", "-", "_"))
 	v.SetEnvPrefix("RUSTDESK_API")
-	v.SetConfigFile(config)
+	v.SetConfigFile(path)
 	v.SetConfigType("yaml")
 	err := v.ReadInConfig()
 	if err != nil {
 		panic(fmt.Errorf("Fatal error config file: %s \n", err))
 	}
-	v.WatchConfig()
-	v.OnConfigChange(func(e fsnotify.Event) {
-		//配置文件修改监听
-		fmt.Println("config file changed:", e.Name)
-		if err2 := v.Unmarshal(rowVal); err2 != nil {
-			fmt.Println(err2)
-		}
-	})
+	/*
+		v.WatchConfig()
+
+
+			//监听配置修改没什么必要
+			v.OnConfigChange(func(e fsnotify.Event) {
+				//配置文件修改监听
+				fmt.Println("config file changed:", e.Name)
+				if err2 := v.Unmarshal(rowVal); err2 != nil {
+					fmt.Println(err2)
+				}
+				rowVal.Rustdesk.LoadKeyFile()
+				rowVal.Rustdesk.ParsePort()
+			})
+	*/
 	if err := v.Unmarshal(rowVal); err != nil {
 		fmt.Println(err)
 	}
-	LoadKeyFile(&rowVal.(*Config).Rustdesk)
+	rowVal.Rustdesk.LoadKeyFile()
+	rowVal.Rustdesk.ParsePort()
 	return v
 }
 

config/jwt.go

@@ -3,6 +3,6 @@ package config
 import "time"
 
 type Jwt struct {
-	PrivateKey     string        `mapstructure:"private-key"`
+	Key            string        `mapstructure:"key"`
 	ExpireDuration time.Duration `mapstructure:"expire-duration"`
 }

config/ldap.go

@@ -0,0 +1,36 @@
+package config
+
+type LdapUser struct {
+	BaseDn          string `mapstructure:"base-dn"`           // The base DN of the user for searching
+	EnableAttr      string `mapstructure:"enable-attr"`       // The attribute name of the user for enabling, in AD it is "userAccountControl", empty means no enable attribute, all users are enabled
+	EnableAttrValue string `mapstructure:"enable-attr-value"` // The value of the enable attribute when the user is enabled. If you are using AD, just leave it random str, it will be ignored.
+	Filter          string `mapstructure:"filter"`
+	Username        string `mapstructure:"username"`
+	Email           string `mapstructure:"email"`
+	FirstName       string `mapstructure:"first-name"`
+	LastName        string `mapstructure:"last-name"`
+	Sync            bool   `mapstructure:"sync"`        // Will sync the user's information to the internal database
+	AdminGroup      string `mapstructure:"admin-group"` // Which group is the admin group
+}
+
+// type LdapGroup struct {
+// 	BaseDn 		string            `mapstructure:"base-dn"` // The base DN of the group for searching
+// 	Name        string            `mapstructure:"name"`    // The attribute name of the group
+// 	Filter      string            `mapstructure:"filter"`
+// 	Admin       string            `mapstructure:"admin"`   // Which group is the admin group
+// 	Member      string            `mapstructure:"member"`  // How to get the member of the group: member, uniqueMember, or memberOf (default: member)
+// 	Mode        string            `mapstructure:"mode"`
+// 	Map         map[string]string `mapstructure:"map"`     // If mode is "map", map the LDAP group to the internal group
+// }
+
+type Ldap struct {
+	Enable       bool     `mapstructure:"enable"`
+	Url          string   `mapstructure:"url"`
+	TLS          bool     `mapstructure:"tls"`
+	TlsVerify    bool     `mapstructure:"tls-verify"`
+	BaseDn       string   `mapstructure:"base-dn"`
+	BindDn       string   `mapstructure:"bind-dn"`
+	BindPassword string   `mapstructure:"bind-password"`
+	User         LdapUser `mapstructure:"user"`
+	// Group        LdapGroup `mapstructure:"group"`
+}

config/oauth.go

@@ -17,4 +17,4 @@ type OidcOauth struct {
 	ClientId     string `mapstructure:"client-id"`
 	ClientSecret string `mapstructure:"client-secret"`
 	RedirectUrl  string `mapstructure:"redirect-url"`
-}
+}

config/rustdesk.go

@@ -2,29 +2,56 @@ package config
 
 import (
 	"os"
+	"strconv"
+	"strings"
+)
+
+const (
+	DefaultIdServerPort    = 21116
+	DefaultRelayServerPort = 21117
 )
 
 type Rustdesk struct {
-	IdServer    string `mapstructure:"id-server"`
-	RelayServer string `mapstructure:"relay-server"`
-	ApiServer   string `mapstructure:"api-server"`
-	Key         string `mapstructure:"key"`
-	KeyFile     string `mapstructure:"key-file"`
-	Personal    int    `mapstructure:"personal"`
+	IdServer        string `mapstructure:"id-server"`
+	IdServerPort    int    `mapstructure:"-"`
+	RelayServer     string `mapstructure:"relay-server"`
+	RelayServerPort int    `mapstructure:"-"`
+	ApiServer       string `mapstructure:"api-server"`
+	Key             string `mapstructure:"key"`
+	KeyFile         string `mapstructure:"key-file"`
+	Personal        int    `mapstructure:"personal"`
+	//webclient-magic-queryonline
+	WebclientMagicQueryonline int `mapstructure:"webclient-magic-queryonline"`
 }
 
-func LoadKeyFile(rustdesk *Rustdesk) {
+func (rd *Rustdesk) LoadKeyFile() {
 	// Load key file
-	if rustdesk.Key != "" {
+	if rd.Key != "" {
 		return
 	}
-	if rustdesk.KeyFile != "" {
+	if rd.KeyFile != "" {
 		// Load key from file
-		b, err := os.ReadFile(rustdesk.KeyFile)
+		b, err := os.ReadFile(rd.KeyFile)
 		if err != nil {
 			return
 		}
-		rustdesk.Key = string(b)
+		rd.Key = string(b)
 		return
 	}
 }
+func (rd *Rustdesk) ParsePort() {
+	// Parse port
+	idres := strings.Split(rd.IdServer, ":")
+	if len(idres) == 1 {
+		rd.IdServerPort = DefaultIdServerPort
+	} else if len(idres) == 2 {
+		rd.IdServerPort, _ = strconv.Atoi(idres[1])
+	}
+
+	relayres := strings.Split(rd.RelayServer, ":")
+	if len(relayres) == 1 {
+		rd.RelayServerPort = DefaultRelayServerPort
+	} else if len(relayres) == 2 {
+		rd.RelayServerPort, _ = strconv.Atoi(relayres[1])
+	}
+}

debian/changelog

@@ -0,0 +1,5 @@
+rustdesk-api-server (1.3.6) UNRELEASED; urgency=medium
+ 
+  * Update the version to 1.3.6 to match the client.
+ 
+ -- rustdesk-api <ymwlpoolc@qq.com>  Tue, 24 Dec 2024 13:48:34 +0800

debian/compat

@@ -0,0 +1 @@
+10

debian/control.tpl

@@ -0,0 +1,13 @@
+Source: rustdesk-api-server
+Section: net
+Priority: optional
+Maintainer: ymwl <ymwlpoolc@qq.com>
+Build-Depends: debhelper (>= 10), pkg-config
+Standards-Version: 4.5.0
+Homepage: https://github.com/lejianwen/rustdesk-api/
+
+Package: rustdesk-api-server
+Architecture: {{ ARCH }}
+Depends: systemd ${misc:Depends}
+Description: RustDesk api server
+ RustDesk api server, it is free and open source.

debian/copyright

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Lejianwen and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

debian/rules

@@ -0,0 +1,6 @@
+#!/usr/bin/make -f
+%:
+	dh $@
+
+override_dh_builddeb:
+	dh_builddeb -- -Zgzip

debian/rustdesk-api-server.install

@@ -0,0 +1,6 @@
+bin/rustdesk-api usr/bin
+systemd/rustdesk-api.service lib/systemd/system
+conf var/lib/rustdesk-api
+data var/lib/rustdesk-api
+resources var/lib/rustdesk-api
+runtime var/lib/rustdesk-api

debian/rustdesk-api-server.postinst

@@ -0,0 +1,28 @@
+#!/bin/sh
+set -e
+
+SERVICE=rustdesk-api.service
+
+if [ "$1" = "configure" ]; then
+    mkdir -p /var/log/rustdesk-api
+fi
+
+case "$1" in
+    configure|abort-upgrade|abort-deconfigure|abort-remove)
+      mkdir -p /var/lib/rustdesk-api/
+	  deb-systemd-helper unmask "${SERVICE}" >/dev/null || true
+	  if deb-systemd-helper --quiet was-enabled "${SERVICE}"; then
+		deb-systemd-invoke enable "${SERVICE}" >/dev/null || true
+	  else
+		deb-systemd-invoke update-state "${SERVICE}" >/dev/null || true
+	  fi
+	  systemctl --system daemon-reload >/dev/null || true
+	  if [ -n "$2" ]; then
+		deb-systemd-invoke restart "${SERVICE}" >/dev/null || true
+	  else
+		deb-systemd-invoke start "${SERVICE}" >/dev/null || true
+	  fi
+    ;;
+esac
+
+exit 0

debian/rustdesk-api-server.postrm

@@ -0,0 +1,18 @@
+#!/bin/sh
+set -e
+
+SERVICE=rustdesk-api.service
+
+systemctl --system daemon-reload >/dev/null || true
+
+if [ "$1" = "purge" ]; then
+	rm -rf /var/log/rustdesk-api/rustdesk-api.*
+	deb-systemd-helper purge "${SERVICE}" >/dev/null || true
+	deb-systemd-helper unmask "${SERVICE}" >/dev/null || true
+fi
+
+if [ "$1" = "remove" ]; then
+	deb-systemd-helper mask "${SERVICE}" >/dev/null || true
+fi
+
+exit 0

debian/rustdesk-api-server.prerm

@@ -0,0 +1,13 @@
+#!/bin/sh
+set -e
+
+SERVICE=rustdesk-api.service
+
+case "$1" in
+    remove|deconfigure)
+	  deb-systemd-invoke stop "${SERVICE}" >/dev/null || true
+	  deb-systemd-invoke disable "${SERVICE}" >/dev/null || true
+	;;
+esac
+
+exit 0

debian/source/format

@@ -0,0 +1 @@
+3.0 (native)

docs/api/api_docs.go

@@ -653,40 +653,6 @@ const docTemplateapi = `{
                 }
             }
         },
-        "/api": {
-            "get": {
-                "security": [
-                    {
-                        "token": []
-                    }
-                ],
-                "description": "用户信息",
-                "consumes": [
-                    "application/json"
-                ],
-                "produces": [
-                    "application/json"
-                ],
-                "tags": [
-                    "用户"
-                ],
-                "summary": "用户信息",
-                "responses": {
-                    "200": {
-                        "description": "OK",
-                        "schema": {
-                            "$ref": "#/definitions/api.UserPayload"
-                        }
-                    },
-                    "500": {
-                        "description": "Internal Server Error",
-                        "schema": {
-                            "$ref": "#/definitions/response.Response"
-                        }
-                    }
-                }
-            }
-        },
         "/audit/conn": {
             "post": {
                 "description": "审计连接",
@@ -767,6 +733,40 @@ const docTemplateapi = `{
                 }
             }
         },
+        "/currentUser": {
+            "get": {
+                "security": [
+                    {
+                        "token": []
+                    }
+                ],
+                "description": "用户信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "用户"
+                ],
+                "summary": "用户信息",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/api.UserPayload"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    }
+                }
+            }
+        },
         "/heartbeat": {
             "post": {
                 "description": "心跳",
@@ -1075,6 +1075,40 @@ const docTemplateapi = `{
                 }
             }
         },
+        "/server-config-v2": {
+            "get": {
+                "security": [
+                    {
+                        "token": []
+                    }
+                ],
+                "description": "服务配置,给webclient提供api-server",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "WEBCLIENT_V2"
+                ],
+                "summary": "服务配置",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    }
+                }
+            }
+        },
         "/shared-peer": {
             "post": {
                 "description": "分享的peer",
@@ -1144,43 +1178,6 @@ const docTemplateapi = `{
                 }
             }
         },
-        "/tags": {
-            "post": {
-                "security": [
-                    {
-                        "BearerAuth": []
-                    }
-                ],
-                "description": "标签",
-                "consumes": [
-                    "application/json"
-                ],
-                "produces": [
-                    "application/json"
-                ],
-                "tags": [
-                    "地址"
-                ],
-                "summary": "标签",
-                "responses": {
-                    "200": {
-                        "description": "OK",
-                        "schema": {
-                            "type": "array",
-                            "items": {
-                                "$ref": "#/definitions/model.Tag"
-                            }
-                        }
-                    },
-                    "500": {
-                        "description": "Internal Server Error",
-                        "schema": {
-                            "$ref": "#/definitions/response.ErrorResponse"
-                        }
-                    }
-                }
-            }
-        },
         "/users": {
             "get": {
                 "security": [
@@ -1255,6 +1252,35 @@ const docTemplateapi = `{
                     }
                 }
             }
+        },
+        "/version": {
+            "get": {
+                "description": "版本",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页"
+                ],
+                "summary": "版本",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    }
+                }
+            }
         }
     },
     "definitions": {
@@ -1356,7 +1382,7 @@ const docTemplateapi = `{
                 },
                 "password": {
                     "type": "string",
-                    "maxLength": 20,
+                    "maxLength": 32,
                     "minLength": 4
                 },
                 "type": {
@@ -1364,8 +1390,8 @@ const docTemplateapi = `{
                 },
                 "username": {
                     "type": "string",
-                    "maxLength": 10,
-                    "minLength": 4
+                    "maxLength": 32,
+                    "minLength": 2
                 },
                 "uuid": {
                     "type": "string"

docs/api/api_swagger.json

@@ -646,40 +646,6 @@
                 }
             }
         },
-        "/api": {
-            "get": {
-                "security": [
-                    {
-                        "token": []
-                    }
-                ],
-                "description": "用户信息",
-                "consumes": [
-                    "application/json"
-                ],
-                "produces": [
-                    "application/json"
-                ],
-                "tags": [
-                    "用户"
-                ],
-                "summary": "用户信息",
-                "responses": {
-                    "200": {
-                        "description": "OK",
-                        "schema": {
-                            "$ref": "#/definitions/api.UserPayload"
-                        }
-                    },
-                    "500": {
-                        "description": "Internal Server Error",
-                        "schema": {
-                            "$ref": "#/definitions/response.Response"
-                        }
-                    }
-                }
-            }
-        },
         "/audit/conn": {
             "post": {
                 "description": "审计连接",
@@ -760,6 +726,40 @@
                 }
             }
         },
+        "/currentUser": {
+            "get": {
+                "security": [
+                    {
+                        "token": []
+                    }
+                ],
+                "description": "用户信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "用户"
+                ],
+                "summary": "用户信息",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/api.UserPayload"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    }
+                }
+            }
+        },
         "/heartbeat": {
             "post": {
                 "description": "心跳",
@@ -1068,6 +1068,40 @@
                 }
             }
         },
+        "/server-config-v2": {
+            "get": {
+                "security": [
+                    {
+                        "token": []
+                    }
+                ],
+                "description": "服务配置,给webclient提供api-server",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "WEBCLIENT_V2"
+                ],
+                "summary": "服务配置",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    }
+                }
+            }
+        },
         "/shared-peer": {
             "post": {
                 "description": "分享的peer",
@@ -1137,43 +1171,6 @@
                 }
             }
         },
-        "/tags": {
-            "post": {
-                "security": [
-                    {
-                        "BearerAuth": []
-                    }
-                ],
-                "description": "标签",
-                "consumes": [
-                    "application/json"
-                ],
-                "produces": [
-                    "application/json"
-                ],
-                "tags": [
-                    "地址"
-                ],
-                "summary": "标签",
-                "responses": {
-                    "200": {
-                        "description": "OK",
-                        "schema": {
-                            "type": "array",
-                            "items": {
-                                "$ref": "#/definitions/model.Tag"
-                            }
-                        }
-                    },
-                    "500": {
-                        "description": "Internal Server Error",
-                        "schema": {
-                            "$ref": "#/definitions/response.ErrorResponse"
-                        }
-                    }
-                }
-            }
-        },
         "/users": {
             "get": {
                 "security": [
@@ -1248,6 +1245,35 @@
                     }
                 }
             }
+        },
+        "/version": {
+            "get": {
+                "description": "版本",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页"
+                ],
+                "summary": "版本",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    }
+                }
+            }
         }
     },
     "definitions": {
@@ -1349,7 +1375,7 @@
                 },
                 "password": {
                     "type": "string",
-                    "maxLength": 20,
+                    "maxLength": 32,
                     "minLength": 4
                 },
                 "type": {
@@ -1357,8 +1383,8 @@
                 },
                 "username": {
                     "type": "string",
-                    "maxLength": 10,
-                    "minLength": 4
+                    "maxLength": 32,
+                    "minLength": 2
                 },
                 "uuid": {
                     "type": "string"

docs/api/api_swagger.yaml

@@ -62,14 +62,14 @@ definitions:
       id:
         type: string
       password:
-        maxLength: 20
+        maxLength: 32
         minLength: 4
         type: string
       type:
         type: string
       username:
-        maxLength: 10
-        minLength: 4
+        maxLength: 32
+        minLength: 2
         type: string
       uuid:
         type: string
@@ -598,27 +598,6 @@ paths:
       summary: 标签
       tags:
       - 地址[Personal]
-  /api:
-    get:
-      consumes:
-      - application/json
-      description: 用户信息
-      produces:
-      - application/json
-      responses:
-        "200":
-          description: OK
-          schema:
-            $ref: '#/definitions/api.UserPayload'
-        "500":
-          description: Internal Server Error
-          schema:
-            $ref: '#/definitions/response.Response'
-      security:
-      - token: []
-      summary: 用户信息
-      tags:
-      - 用户
   /audit/conn:
     post:
       consumes:
@@ -671,6 +650,27 @@ paths:
       summary: 审计文件
       tags:
       - 审计
+  /currentUser:
+    get:
+      consumes:
+      - application/json
+      description: 用户信息
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/api.UserPayload'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.Response'
+      security:
+      - token: []
+      summary: 用户信息
+      tags:
+      - 用户
   /heartbeat:
     post:
       consumes:
@@ -870,6 +870,27 @@ paths:
       summary: 服务配置
       tags:
       - WEBCLIENT
+  /server-config-v2:
+    get:
+      consumes:
+      - application/json
+      description: 服务配置,给webclient提供api-server
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.Response'
+      security:
+      - token: []
+      summary: 服务配置
+      tags:
+      - WEBCLIENT_V2
   /shared-peer:
     post:
       consumes:
@@ -915,29 +936,6 @@ paths:
       summary: 提交系统信息
       tags:
       - 地址
-  /tags:
-    post:
-      consumes:
-      - application/json
-      description: 标签
-      produces:
-      - application/json
-      responses:
-        "200":
-          description: OK
-          schema:
-            items:
-              $ref: '#/definitions/model.Tag'
-            type: array
-        "500":
-          description: Internal Server Error
-          schema:
-            $ref: '#/definitions/response.ErrorResponse'
-      security:
-      - BearerAuth: []
-      summary: 标签
-      tags:
-      - 地址
   /users:
     get:
       consumes:
@@ -983,6 +981,25 @@ paths:
       summary: 用户列表
       tags:
       - 群组
+  /version:
+    get:
+      consumes:
+      - application/json
+      description: 版本
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.Response'
+      summary: 版本
+      tags:
+      - 首页
 securityDefinitions:
   BearerAuth:
     in: header

generate_api.go

@@ -1,4 +1,4 @@
-package Gwen
+package main
 
 //go:generate swag init -g cmd/apimain.go --output docs/api --instanceName api --exclude http/controller/admin
 //go:generate swag init -g cmd/apimain.go --output docs/admin --instanceName admin --exclude http/controller/api

generate_run.go

@@ -1,3 +1,3 @@
-package Gwen
+package main
 
 //go:generate go run cmd/apimain.go

global/apiValidator.go

@@ -3,15 +3,20 @@ package global
 import (
 	"github.com/gin-gonic/gin"
 	"github.com/go-playground/locales/en"
+	"github.com/go-playground/locales/es"
+	"github.com/go-playground/locales/fr"
 	"github.com/go-playground/locales/ko"
 	"github.com/go-playground/locales/ru"
 	"github.com/go-playground/locales/zh_Hans_CN"
-
+	"github.com/go-playground/locales/zh_Hant"
 	ut "github.com/go-playground/universal-translator"
 	"github.com/go-playground/validator/v10"
 	en_translations "github.com/go-playground/validator/v10/translations/en"
+	es_translations "github.com/go-playground/validator/v10/translations/es"
+	fr_translations "github.com/go-playground/validator/v10/translations/fr"
 	ru_translations "github.com/go-playground/validator/v10/translations/ru"
 	zh_translations "github.com/go-playground/validator/v10/translations/zh"
+	zh_tw_translations "github.com/go-playground/validator/v10/translations/zh_tw"
 	"reflect"
 )
 
@@ -23,13 +28,19 @@ func ApiInitValidator() {
 	cn := zh_Hans_CN.New()
 	koT := ko.New()
 	ruT := ru.New()
+	esT := es.New()
+	frT := fr.New()
+	zhTwT := zh_Hant.New()
 
-	uni := ut.New(enT, cn, koT, ruT)
+	uni := ut.New(enT, cn, koT, ruT, esT, frT, zhTwT)
 
 	enTrans, _ := uni.GetTranslator("en")
 	zhTrans, _ := uni.GetTranslator("zh_Hans_CN")
 	koTrans, _ := uni.GetTranslator("ko")
 	ruTrans, _ := uni.GetTranslator("ru")
+	esTrans, _ := uni.GetTranslator("es")
+	frTrans, _ := uni.GetTranslator("fr")
+	zhTwTrans, _ := uni.GetTranslator("zh_Hant")
 
 	err := zh_translations.RegisterDefaultTranslations(validate, zhTrans)
 	if err != nil {
@@ -49,6 +60,18 @@ func ApiInitValidator() {
 	if err != nil {
 		panic(err)
 	}
+	err = es_translations.RegisterDefaultTranslations(validate, esTrans)
+	if err != nil {
+		panic(err)
+	}
+	err = fr_translations.RegisterDefaultTranslations(validate, frTrans)
+	if err != nil {
+		panic(err)
+	}
+	err = zh_tw_translations.RegisterDefaultTranslations(validate, zhTwTrans)
+	if err != nil {
+		panic(err)
+	}
 
 	validate.RegisterTagNameFunc(func(field reflect.StructField) string {
 		label := field.Tag.Get("label")
@@ -109,12 +132,25 @@ func getTranslatorForLang(lang string) ut.Translator {
 	case "zh":
 		trans, _ := Validator.UT.GetTranslator("zh_Hans_CN")
 		return trans
+	case "zh_TW":
+		fallthrough
+	case "zh-TW":
+		fallthrough
+	case "zh-tw":
+		trans, _ := Validator.UT.GetTranslator("zh_Hant")
+		return trans
 	case "ko":
 		trans, _ := Validator.UT.GetTranslator("ko")
 		return trans
 	case "ru":
 		trans, _ := Validator.UT.GetTranslator("ru")
 		return trans
+	case "es":
+		trans, _ := Validator.UT.GetTranslator("es")
+		return trans
+	case "fr":
+		trans, _ := Validator.UT.GetTranslator("fr")
+		return trans
 	case "en":
 		fallthrough
 	default:

global/global.go

@@ -1,15 +1,15 @@
 package global
 
 import (
-	"Gwen/config"
-	"Gwen/lib/cache"
-	"Gwen/lib/jwt"
-	"Gwen/lib/lock"
-	"Gwen/lib/upload"
 	"github.com/gin-gonic/gin"
 	ut "github.com/go-playground/universal-translator"
 	"github.com/go-playground/validator/v10"
 	"github.com/go-redis/redis/v8"
+	"github.com/lejianwen/rustdesk-api/v2/config"
+	"github.com/lejianwen/rustdesk-api/v2/lib/cache"
+	"github.com/lejianwen/rustdesk-api/v2/lib/jwt"
+	"github.com/lejianwen/rustdesk-api/v2/lib/lock"
+	"github.com/lejianwen/rustdesk-api/v2/lib/upload"
 	"github.com/nicksnyder/go-i18n/v2/i18n"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/viper"
@@ -17,13 +17,14 @@ import (
 )
 
 var (
-	DB        *gorm.DB
-	Logger    *logrus.Logger
-	Config    config.Config
-	Viper     *viper.Viper
-	Redis     *redis.Client
-	Cache     cache.Handler
-	Validator struct {
+	DB         *gorm.DB
+	Logger     *logrus.Logger
+	ConfigPath string = ""
+	Config     config.Config
+	Viper      *viper.Viper
+	Redis      *redis.Client
+	Cache      cache.Handler
+	Validator  struct {
 		Validate    *validator.Validate
 		UT          *ut.UniversalTranslator
 		VTrans      ut.Translator

global/i18n.go

@@ -15,7 +15,6 @@ func InitI18n() {
 	fileInfos, err := os.ReadDir(dir)
 	if err != nil {
 		panic(err)
-		return
 	}
 	for _, fileInfo := range fileInfos {
 		//如果文件名不是.toml结尾

go.mod

@@ -1,4 +1,4 @@
-module Gwen
+module github.com/lejianwen/rustdesk-api/v2
 
 go 1.22
 
@@ -13,22 +13,23 @@ require (
 	github.com/go-playground/validator/v10 v10.11.2
 	github.com/go-redis/redis/v8 v8.11.4
 	github.com/golang-jwt/jwt/v5 v5.2.1
-	github.com/google/uuid v1.1.2
+	github.com/google/uuid v1.6.0
 	github.com/nicksnyder/go-i18n/v2 v2.4.0
 	github.com/sirupsen/logrus v1.8.1
+	github.com/spf13/cobra v1.8.1
 	github.com/spf13/viper v1.9.0
 	github.com/swaggo/files v1.0.1
 	github.com/swaggo/gin-swagger v1.6.0
 	github.com/swaggo/swag v1.16.3
 	golang.org/x/oauth2 v0.23.0
-	golang.org/x/text v0.18.0
+	golang.org/x/text v0.21.0
 	gorm.io/driver/mysql v1.5.7
 	gorm.io/driver/sqlite v1.5.6
 	gorm.io/gorm v1.25.7
 )
 
 require (
-	cloud.google.com/go/compute/metadata v0.5.1 // indirect
+	github.com/Azure/go-ntlmssp v0.0.0-20221128193559-754e69321358 // indirect
 	github.com/KyleBanks/depth v1.2.1 // indirect
 	github.com/PuerkitoBio/purell v1.1.1 // indirect
 	github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
@@ -37,13 +38,17 @@ require (
 	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-asn1-ber/asn1-ber v1.5.7 // indirect
+	github.com/go-ldap/ldap/v3 v3.4.10 // indirect
 	github.com/go-openapi/jsonpointer v0.19.5 // indirect
 	github.com/go-openapi/jsonreference v0.19.6 // indirect
 	github.com/go-openapi/spec v0.20.4 // indirect
 	github.com/go-openapi/swag v0.19.15 // indirect
 	github.com/go-sql-driver/mysql v1.7.0 // indirect
 	github.com/goccy/go-json v0.10.0 // indirect
+	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
@@ -57,6 +62,7 @@ require (
 	github.com/mitchellh/mapstructure v1.4.2 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/mojocn/base64Captcha v1.3.6 // indirect
 	github.com/pelletier/go-toml v1.9.4 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.6 // indirect
 	github.com/spf13/afero v1.6.0 // indirect
@@ -67,9 +73,10 @@ require (
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.9 // indirect
 	golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect
-	golang.org/x/crypto v0.23.0 // indirect
-	golang.org/x/net v0.25.0 // indirect
-	golang.org/x/sys v0.25.0 // indirect
+	golang.org/x/crypto v0.31.0 // indirect
+	golang.org/x/image v0.13.0 // indirect
+	golang.org/x/net v0.33.0 // indirect
+	golang.org/x/sys v0.28.0 // indirect
 	golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect
 	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/ini.v1 v1.63.2 // indirect

http/controller/admin/addressBook.go

@@ -1,13 +1,13 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/model"
-	"Gwen/service"
+	"encoding/json"
 	_ "encoding/json"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 	"strconv"
 )
@@ -30,11 +30,6 @@ func (ct *AddressBook) Detail(c *gin.Context) {
 	id := c.Param("id")
 	iid, _ := strconv.Atoi(id)
 	t := service.AllService.AddressBookService.InfoByRowId(uint(iid))
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
-		return
-	}
 	if t.RowId > 0 {
 		response.Success(c, t)
 		return
@@ -66,9 +61,9 @@ func (ct *AddressBook) Create(c *gin.Context) {
 		return
 	}
 	t := f.ToAddressBook()
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) || t.UserId == 0 {
-		t.UserId = u.Id
+	if t.UserId == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
 	}
 	if t.CollectionId > 0 && !service.AllService.AddressBookService.CheckCollectionOwner(t.UserId, t.CollectionId) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
@@ -98,7 +93,7 @@ func (ct *AddressBook) Create(c *gin.Context) {
 // @Param body body admin.AddressBookForm true "地址簿信息"
 // @Success 200 {object} response.Response{data=model.AddressBook}
 // @Failure 500 {object} response.Response
-// @Router /admin/address_book/create [post]
+// @Router /admin/address_book/batchCreate [post]
 // @Security token
 func (ct *AddressBook) BatchCreate(c *gin.Context) {
 	f := &admin.AddressBookForm{}
@@ -111,9 +106,21 @@ func (ct *AddressBook) BatchCreate(c *gin.Context) {
 		response.Fail(c, 101, errList[0])
 		return
 	}
+	ul := len(f.UserIds)
+
+	if ul == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	if ul > 1 {
+		//多用户置空标签
+		f.Tags = []string{}
+		//多用户只能创建到默认地址簿
+		f.CollectionId = 0
+	}
 
 	//创建标签
-	for _, fu := range f.UserIds {
+	/*for _, fu := range f.UserIds {
 		if fu == 0 {
 			continue
 		}
@@ -126,13 +133,13 @@ func (ct *AddressBook) BatchCreate(c *gin.Context) {
 				})
 			}
 		}
-	}
+	}*/
 	ts := f.ToAddressBooks()
 	for _, t := range ts {
 		if t.UserId == 0 {
 			continue
 		}
-		ex := service.AllService.AddressBookService.InfoByUserIdAndId(t.UserId, t.Id)
+		ex := service.AllService.AddressBookService.InfoByUserIdAndIdAndCid(t.UserId, t.Id, t.CollectionId)
 		if ex.RowId == 0 {
 			service.AllService.AddressBookService.Create(t)
 		}
@@ -161,10 +168,6 @@ func (ct *AddressBook) List(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
 		return
 	}
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) || query.IsMy == 1 {
-		query.UserId = int(u.Id)
-	}
 	res := service.AllService.AddressBookService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
 		tx.Preload("Collection", func(txc *gorm.DB) *gorm.DB {
 			return txc.Select("id,name")
@@ -190,11 +193,6 @@ func (ct *AddressBook) List(c *gin.Context) {
 	for _, ab := range res.AddressBooks {
 		abCIds = append(abCIds, ab.CollectionId)
 	}
-	//获取地址簿名称
-	//cRes := service.AllService.AddressBookService.ListCollection(1, 999, func(tx *gorm.DB) {
-	//		tx.Where("id in ?", abCIds)
-	//})
-	//
 	response.Success(c, res)
 }
 
@@ -221,15 +219,15 @@ func (ct *AddressBook) Update(c *gin.Context) {
 		return
 	}
 	if f.RowId == 0 {
-		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	ex := service.AllService.AddressBookService.InfoByRowId(f.RowId)
+	if ex.RowId == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 		return
 	}
 	t := f.ToAddressBook()
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
-		return
-	}
 	if t.CollectionId > 0 && !service.AllService.AddressBookService.CheckCollectionOwner(t.UserId, t.CollectionId) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
 		return
@@ -270,21 +268,12 @@ func (ct *AddressBook) Delete(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 		return
 	}
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+	err := service.AllService.AddressBookService.Delete(t)
+	if err == nil {
+		response.Success(c, nil)
 		return
 	}
-	if u.Id > 0 {
-		err := service.AllService.AddressBookService.Delete(t)
-		if err == nil {
-			response.Success(c, nil)
-			return
-		}
-		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
-		return
-	}
-	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+	response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
 }
 
 // ShareByWebClient
@@ -327,3 +316,47 @@ func (ct *AddressBook) ShareByWebClient(c *gin.Context) {
 		"share_token": m.ShareToken,
 	})
 }
+
+func (ct *AddressBook) BatchCreateFromPeers(c *gin.Context) {
+	f := &admin.BatchCreateFromPeersForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+
+	if f.UserId == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+
+	if f.CollectionId != 0 {
+		collection := service.AllService.AddressBookService.CollectionInfoById(f.CollectionId)
+		if collection.Id == 0 {
+			response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+			return
+		}
+	}
+
+	pl := int64(len(f.PeerIds))
+	peers := service.AllService.PeerService.List(1, uint(pl), func(tx *gorm.DB) {
+		tx.Where("row_id in ?", f.PeerIds)
+	})
+	if peers.Total == 0 || pl != peers.Total {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+
+	tags, _ := json.Marshal(f.Tags)
+	for _, peer := range peers.Peers {
+		ab := service.AllService.AddressBookService.FromPeer(peer)
+		ab.Tags = tags
+		ab.CollectionId = f.CollectionId
+		ab.UserId = f.UserId
+		ex := service.AllService.AddressBookService.InfoByUserIdAndIdAndCid(f.UserId, ab.Id, ab.CollectionId)
+		if ex.RowId != 0 {
+			continue
+		}
+		service.AllService.AddressBookService.Create(ab)
+	}
+	response.Success(c, nil)
+}

http/controller/admin/addressBookCollection.go

@@ -1,12 +1,12 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 	"strconv"
 )
@@ -29,11 +29,6 @@ func (abc *AddressBookCollection) Detail(c *gin.Context) {
 	id := c.Param("id")
 	iid, _ := strconv.Atoi(id)
 	t := service.AllService.AddressBookService.CollectionInfoById(uint(iid))
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
-		return
-	}
 	if t.Id > 0 {
 		response.Success(c, t)
 		return
@@ -64,12 +59,11 @@ func (abc *AddressBookCollection) Create(c *gin.Context) {
 		response.Fail(c, 101, errList[0])
 		return
 	}
-	//t := f.ToAddressBookCollection()
-	t := f
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) || t.UserId == 0 {
-		t.UserId = u.Id
+	if f.UserId == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
 	}
+	t := f
 	err := service.AllService.AddressBookService.CreateCollection(t)
 	if err != nil {
 		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
@@ -98,10 +92,6 @@ func (abc *AddressBookCollection) List(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
 		return
 	}
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) || query.IsMy == 1 {
-		query.UserId = int(u.Id)
-	}
 	res := service.AllService.AddressBookService.ListCollection(query.Page, query.PageSize, func(tx *gorm.DB) {
 		if query.UserId > 0 {
 			tx.Where("user_id = ?", query.UserId)
@@ -137,11 +127,6 @@ func (abc *AddressBookCollection) Update(c *gin.Context) {
 		return
 	}
 	t := f //f.ToAddressBookCollection()
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
-		return
-	}
 	err := service.AllService.AddressBookService.UpdateCollection(t)
 	if err != nil {
 		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
@@ -173,20 +158,15 @@ func (abc *AddressBookCollection) Delete(c *gin.Context) {
 		response.Fail(c, 101, errList[0])
 		return
 	}
-	t := service.AllService.AddressBookService.CollectionInfoById(f.Id)
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+	ex := service.AllService.AddressBookService.CollectionInfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 		return
 	}
-	if u.Id > 0 {
-		err := service.AllService.AddressBookService.DeleteCollection(t)
-		if err == nil {
-			response.Success(c, nil)
-			return
-		}
-		response.Fail(c, 101, err.Error())
+	err := service.AllService.AddressBookService.DeleteCollection(ex)
+	if err == nil {
+		response.Success(c, nil)
 		return
 	}
-	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+	response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
 }

http/controller/admin/addressBookCollectionRule.go

@@ -1,12 +1,12 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 	"strconv"
 )
@@ -35,10 +35,6 @@ func (abcr *AddressBookCollectionRule) List(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
 		return
 	}
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) || query.IsMy == 1 {
-		query.UserId = int(u.Id)
-	}
 
 	res := service.AllService.AddressBookService.ListRules(query.Page, query.PageSize, func(tx *gorm.DB) {
 		if query.UserId > 0 {
@@ -66,17 +62,11 @@ func (abcr *AddressBookCollectionRule) Detail(c *gin.Context) {
 	id := c.Param("id")
 	iid, _ := strconv.Atoi(id)
 	t := service.AllService.AddressBookService.RuleInfoById(uint(iid))
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
-		return
-	}
 	if t.Id > 0 {
 		response.Success(c, t)
 		return
 	}
 	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
-	return
 }
 
 // Create 创建地址簿规则
@@ -105,13 +95,8 @@ func (abcr *AddressBookCollectionRule) Create(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
 		return
 	}
-	//t := f.ToAddressBookCollection()
 	t := f
-	u := service.AllService.UserService.CurUser(c)
-	if t.UserId == 0 {
-		t.UserId = u.Id
-	}
-	msg, res := abcr.CheckForm(u, t)
+	msg, res := abcr.CheckForm(t)
 	if !res {
 		response.Fail(c, 101, response.TranslateMsg(c, msg))
 		return
@@ -124,9 +109,9 @@ func (abcr *AddressBookCollectionRule) Create(c *gin.Context) {
 	response.Success(c, nil)
 }
 
-func (abcr *AddressBookCollectionRule) CheckForm(u *model.User, t *model.AddressBookCollectionRule) (string, bool) {
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		return "NoAccess", false
+func (abcr *AddressBookCollectionRule) CheckForm(t *model.AddressBookCollectionRule) (string, bool) {
+	if t.UserId == 0 {
+		return "ParamsError", false
 	}
 	if t.CollectionId > 0 && !service.AllService.AddressBookService.CheckCollectionOwner(t.UserId, t.CollectionId) {
 		return "ParamsError", false
@@ -141,15 +126,7 @@ func (abcr *AddressBookCollectionRule) CheckForm(u *model.User, t *model.Address
 		if tou.Id == 0 {
 			return "ItemNotFound", false
 		}
-		//非管理员不能分享给非本组织用户
-		if tou.GroupId != u.GroupId && !service.AllService.UserService.IsAdmin(u) {
-			return "NoAccess", false
-		}
 	} else if t.Type == model.ShareAddressBookRuleTypeGroup {
-		if t.ToId != u.GroupId && !service.AllService.UserService.IsAdmin(u) {
-			return "NoAccess", false
-		}
-
 		tog := service.AllService.GroupService.InfoById(t.ToId)
 		if tog.Id == 0 {
 			return "ItemNotFound", false
@@ -194,9 +171,8 @@ func (abcr *AddressBookCollectionRule) Update(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
 		return
 	}
-	t := f //f.ToAddressBookCollection()
-	u := service.AllService.UserService.CurUser(c)
-	msg, res := abcr.CheckForm(u, t)
+	t := f
+	msg, res := abcr.CheckForm(t)
 	if !res {
 		response.Fail(c, 101, response.TranslateMsg(c, msg))
 		return
@@ -232,20 +208,15 @@ func (abcr *AddressBookCollectionRule) Delete(c *gin.Context) {
 		response.Fail(c, 101, errList[0])
 		return
 	}
-	t := service.AllService.AddressBookService.RuleInfoById(f.Id)
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+	ex := service.AllService.AddressBookService.RuleInfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 		return
 	}
-	if t.Id > 0 {
-		err := service.AllService.AddressBookService.DeleteRule(t)
-		if err == nil {
-			response.Success(c, nil)
-			return
-		}
-		response.Fail(c, 101, err.Error())
+	err := service.AllService.AddressBookService.DeleteRule(ex)
+	if err == nil {
+		response.Success(c, nil)
 		return
 	}
-	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+	response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
 }

http/controller/admin/audit.go

@@ -1,12 +1,12 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 )
 
@@ -81,6 +81,37 @@ func (a *Audit) ConnDelete(c *gin.Context) {
 	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 }
 
+// BatchConnDelete 删除
+// @Tags 链接日志
+// @Summary 链接日志批量删除
+// @Description 链接日志批量删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.AuditConnLogIds true "链接日志"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/audit_conn/batchDelete [post]
+// @Security token
+func (a *Audit) BatchConnDelete(c *gin.Context) {
+	f := &admin.AuditConnLogIds{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	if len(f.Ids) == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+
+	err := service.AllService.AuditService.BatchDeleteAuditConn(f.Ids)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, err.Error())
+	return
+}
+
 // FileList 列表
 // @Tags 文件日志
 // @Summary 文件日志列表
@@ -93,7 +124,7 @@ func (a *Audit) ConnDelete(c *gin.Context) {
 // @Param from_peer query int false "来源设备"
 // @Success 200 {object} response.Response{data=model.AuditFileList}
 // @Failure 500 {object} response.Response
-// @Router /admin/audit_conn/list [get]
+// @Router /admin/audit_file/list [get]
 // @Security token
 func (a *Audit) FileList(c *gin.Context) {
 	query := &admin.AuditQuery{}
@@ -122,7 +153,7 @@ func (a *Audit) FileList(c *gin.Context) {
 // @Param body body model.AuditFile true "文件日志信息"
 // @Success 200 {object} response.Response
 // @Failure 500 {object} response.Response
-// @Router /admin/audit_conn/delete [post]
+// @Router /admin/audit_file/delete [post]
 // @Security token
 func (a *Audit) FileDelete(c *gin.Context) {
 	f := &model.AuditFile{}
@@ -148,3 +179,34 @@ func (a *Audit) FileDelete(c *gin.Context) {
 	}
 	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 }
+
+// BatchFileDelete 删除
+// @Tags 文件日志
+// @Summary 文件日志批量删除
+// @Description 文件日志批量删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.AuditFileLogIds true "文件日志"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/audit_file/batchDelete [post]
+// @Security token
+func (a *Audit) BatchFileDelete(c *gin.Context) {
+	f := &admin.AuditFileLogIds{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	if len(f.Ids) == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+
+	err := service.AllService.AuditService.BatchDeleteAuditFile(f.Ids)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, err.Error())
+	return
+}

http/controller/admin/config.go

@@ -0,0 +1,85 @@
+package admin
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"os"
+	"strings"
+)
+
+type Config struct {
+}
+
+// ServerConfig RUSTDESK服务配置
+// @Tags ADMIN
+// @Summary RUSTDESK服务配置
+// @Description 服务配置,给webclient提供api-server
+// @Accept  json
+// @Produce  json
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/config/server [get]
+// @Security token
+func (co *Config) ServerConfig(c *gin.Context) {
+	cf := &response.ServerConfigResponse{
+		IdServer:    global.Config.Rustdesk.IdServer,
+		Key:         global.Config.Rustdesk.Key,
+		RelayServer: global.Config.Rustdesk.RelayServer,
+		ApiServer:   global.Config.Rustdesk.ApiServer,
+	}
+	response.Success(c, cf)
+}
+
+// AppConfig APP服务配置
+// @Tags ADMIN
+// @Summary APP服务配置
+// @Description APP服务配置
+// @Accept  json
+// @Produce  json
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/config/app [get]
+// @Security token
+func (co *Config) AppConfig(c *gin.Context) {
+	response.Success(c, &gin.H{
+		"web_client": global.Config.App.WebClient,
+	})
+}
+
+// AdminConfig ADMIN服务配置
+// @Tags ADMIN
+// @Summary ADMIN服务配置
+// @Description ADMIN服务配置
+// @Accept  json
+// @Produce  json
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/config/admin [get]
+// @Security token
+func (co *Config) AdminConfig(c *gin.Context) {
+
+	u := service.AllService.UserService.CurUser(c)
+	if u == nil || u.Id == 0 {
+		response.Success(c, &gin.H{
+			"title": global.Config.Admin.Title,
+		})
+		return
+	}
+	hello := global.Config.Admin.Hello
+	helloFile := global.Config.Admin.HelloFile
+	if helloFile != "" {
+		b, err := os.ReadFile(helloFile)
+		if err == nil && len(b) > 0 {
+			hello = string(b)
+		}
+	}
+
+	//replace {{username}} to username
+	hello = strings.Replace(hello, "{{username}}", u.Username, -1)
+	response.Success(c, &gin.H{
+		"title": global.Config.Admin.Title,
+		"hello": hello,
+	})
+}

http/controller/admin/file.go

@@ -1,11 +1,11 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/response"
-	"Gwen/lib/upload"
 	"fmt"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/lib/upload"
 	"os"
 	"time"
 )

http/controller/admin/group.go

@@ -1,11 +1,11 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"strconv"
 )
 

http/controller/admin/login.go

@@ -1,21 +1,145 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/controller/api"
-	"Gwen/http/request/admin"
-	apiReq "Gwen/http/request/api"
-	"Gwen/http/response"
-	adResp "Gwen/http/response/admin"
-	"Gwen/model"
-	"Gwen/service"
 	"fmt"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/controller/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	apiReq "github.com/lejianwen/rustdesk-api/v2/http/request/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	adResp "github.com/lejianwen/rustdesk-api/v2/http/response/admin"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"github.com/mojocn/base64Captcha"
+	"sync"
+	"time"
 )
 
 type Login struct {
 }
 
+// Captcha 验证码结构
+type Captcha struct {
+	Id        string    `json:"id"`  // 验证码 ID
+	B64       string    `json:"b64"` // base64 验证码
+	Code      string    `json:"-"`   // 验证码内容
+	ExpiresAt time.Time `json:"-"`   // 过期时间
+}
+type LoginLimiter struct {
+	mu        sync.RWMutex
+	failCount map[string]int       // 记录每个 IP 的失败次数
+	timestamp map[string]time.Time // 记录每个 IP 的最后失败时间
+	captchas  map[string]Captcha   // 每个 IP 的验证码
+	threshold int                  // 失败阈值
+	expiry    time.Duration        // 失败记录过期时间
+}
+
+func NewLoginLimiter(threshold int, expiry time.Duration) *LoginLimiter {
+	return &LoginLimiter{
+		failCount: make(map[string]int),
+		timestamp: make(map[string]time.Time),
+		captchas:  make(map[string]Captcha),
+		threshold: threshold,
+		expiry:    expiry,
+	}
+}
+
+// RecordFailure 记录登录失败
+func (l *LoginLimiter) RecordFailure(ip string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	// 如果该 IP 的记录已经过期，重置计数
+	if lastTime, exists := l.timestamp[ip]; exists && time.Since(lastTime) > l.expiry {
+		l.failCount[ip] = 0
+	}
+
+	// 更新失败次数和时间戳
+	l.failCount[ip]++
+	l.timestamp[ip] = time.Now()
+}
+
+// NeedsCaptcha 检查是否需要验证码
+func (l *LoginLimiter) NeedsCaptcha(ip string) bool {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	// 检查记录是否存在且未过期
+	if lastTime, exists := l.timestamp[ip]; exists && time.Since(lastTime) <= l.expiry {
+		return l.failCount[ip] >= l.threshold
+	}
+	return false
+}
+
+// GenerateCaptcha 为指定 IP 生成验证码
+func (l *LoginLimiter) GenerateCaptcha(ip string) Captcha {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	capd := base64Captcha.NewDriverString(50, 150, 5, 10, 4, "1234567890abcdefghijklmnopqrstuvwxyz", nil, nil, nil)
+	b64cap := base64Captcha.NewCaptcha(capd, base64Captcha.DefaultMemStore)
+	id, b64s, answer, err := b64cap.Generate()
+	if err != nil {
+		global.Logger.Error("Generate captcha failed: " + err.Error())
+		return Captcha{}
+	}
+	// 保存验证码到对应 IP
+	l.captchas[ip] = Captcha{
+		Id:        id,
+		B64:       b64s,
+		Code:      answer,
+		ExpiresAt: time.Now().Add(5 * time.Minute),
+	}
+	return l.captchas[ip]
+}
+
+// VerifyCaptcha 验证指定 IP 的验证码
+func (l *LoginLimiter) VerifyCaptcha(ip, code string) bool {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	// 检查验证码是否存在且未过期
+	if captcha, exists := l.captchas[ip]; exists && time.Now().Before(captcha.ExpiresAt) {
+		return captcha.Code == code
+	}
+	return false
+}
+
+// RemoveCaptcha 移除指定 IP 的验证码
+func (l *LoginLimiter) RemoveCaptcha(ip string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	delete(l.captchas, ip)
+}
+
+// CleanupExpired 清理过期的记录
+func (l *LoginLimiter) CleanupExpired() {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	now := time.Now()
+	for ip, lastTime := range l.timestamp {
+		if now.Sub(lastTime) > l.expiry {
+			delete(l.failCount, ip)
+			delete(l.timestamp, ip)
+			delete(l.captchas, ip)
+		}
+	}
+}
+
+func (l *LoginLimiter) RemoveRecord(ip string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	delete(l.failCount, ip)
+	delete(l.timestamp, ip)
+	delete(l.captchas, ip)
+}
+
+var loginLimiter = NewLoginLimiter(3, 5*time.Minute)
+
 // Login 登录
 // @Tags 登录
 // @Summary 登录
@@ -28,39 +152,82 @@ type Login struct {
 // @Router /admin/login [post]
 // @Security token
 func (ct *Login) Login(c *gin.Context) {
+	if global.Config.App.DisablePwdLogin {
+		response.Fail(c, 101, response.TranslateMsg(c, "PwdLoginDisabled"))
+		return
+	}
 	f := &admin.Login{}
 	err := c.ShouldBindJSON(f)
+	clientIp := c.ClientIP()
 	if err != nil {
-		global.Logger.Warn(fmt.Sprintf("Login Fail: %s %s %s", "ParamsError", c.RemoteIP(), c.ClientIP()))
+		global.Logger.Warn(fmt.Sprintf("Login Fail: %s %s %s", "ParamsError", c.RemoteIP(), clientIp))
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
 		return
 	}
 
 	errList := global.Validator.ValidStruct(c, f)
 	if len(errList) > 0 {
-		global.Logger.Warn(fmt.Sprintf("Login Fail: %s %s %s", "ParamsError", c.RemoteIP(), c.ClientIP()))
+		global.Logger.Warn(fmt.Sprintf("Login Fail: %s %s %s", "ParamsError", c.RemoteIP(), clientIp))
 		response.Fail(c, 101, errList[0])
 		return
 	}
+
+	// 检查是否需要验证码
+	if loginLimiter.NeedsCaptcha(clientIp) {
+		if f.Captcha == "" || !loginLimiter.VerifyCaptcha(clientIp, f.Captcha) {
+			response.Fail(c, 101, response.TranslateMsg(c, "CaptchaError"))
+			return
+		}
+	}
+
 	u := service.AllService.UserService.InfoByUsernamePassword(f.Username, f.Password)
 
 	if u.Id == 0 {
-		global.Logger.Warn(fmt.Sprintf("Login Fail: %s %s %s", "UsernameOrPasswordError", c.RemoteIP(), c.ClientIP()))
+		global.Logger.Warn(fmt.Sprintf("Login Fail: %s %s %s", "UsernameOrPasswordError", c.RemoteIP(), clientIp))
+		loginLimiter.RecordFailure(clientIp)
+		if loginLimiter.NeedsCaptcha(clientIp) {
+			loginLimiter.RemoveCaptcha(clientIp)
+		}
 		response.Fail(c, 101, response.TranslateMsg(c, "UsernameOrPasswordError"))
 		return
 	}
 
+	if !service.AllService.UserService.CheckUserEnable(u) {
+		if loginLimiter.NeedsCaptcha(clientIp) {
+			loginLimiter.RemoveCaptcha(clientIp)
+		}
+		response.Fail(c, 101, response.TranslateMsg(c, "UserDisabled"))
+		return
+	}
+
 	ut := service.AllService.UserService.Login(u, &model.LoginLog{
 		UserId:   u.Id,
 		Client:   model.LoginLogClientWebAdmin,
 		Uuid:     "", //must be empty
-		Ip:       c.ClientIP(),
+		Ip:       clientIp,
 		Type:     model.LoginLogTypeAccount,
 		Platform: f.Platform,
 	})
 
+	// 成功后清除记录
+	loginLimiter.RemoveRecord(clientIp)
+
+	// 清理过期记录
+	go loginLimiter.CleanupExpired()
+
 	responseLoginSuccess(c, u, ut.Token)
 }
+func (ct *Login) Captcha(c *gin.Context) {
+	clientIp := c.ClientIP()
+	if !loginLimiter.NeedsCaptcha(clientIp) {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoCaptchaRequired"))
+		return
+	}
+	captcha := loginLimiter.GenerateCaptcha(clientIp)
+	response.Success(c, gin.H{
+		"captcha": captcha,
+	})
+}
 
 // Logout 登出
 // @Tags 登录
@@ -90,10 +257,12 @@ func (ct *Login) Logout(c *gin.Context) {
 // @Failure 500 {object} response.ErrorResponse
 // @Router /admin/login-options [post]
 func (ct *Login) LoginOptions(c *gin.Context) {
+	ip := c.ClientIP()
 	ops := service.AllService.OauthService.GetOauthProviders()
 	response.Success(c, gin.H{
-		"ops":      ops,
-		"register": global.Config.App.Register,
+		"ops":          ops,
+		"register":     global.Config.App.Register,
+		"need_captcha": loginLimiter.NeedsCaptcha(ip),
 	})
 }
 
@@ -154,11 +323,10 @@ func (ct *Login) OidcAuthQuery(c *gin.Context) {
 	responseLoginSuccess(c, u, ut.Token)
 }
 
-
 func responseLoginSuccess(c *gin.Context, u *model.User, token string) {
 	lp := &adResp.LoginPayload{}
 	lp.FromUser(u)
 	lp.Token = token
 	lp.RouteNames = service.AllService.UserService.RouteNames(u)
 	response.Success(c, lp)
-}
+}

http/controller/admin/loginLog.go

@@ -1,12 +1,12 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 	"strconv"
 )
@@ -56,10 +56,6 @@ func (ct *LoginLog) List(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
 		return
 	}
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) || query.IsMy == 1 {
-		query.UserId = int(u.Id)
-	}
 	res := service.AllService.LoginLogService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
 		if query.UserId > 0 {
 			tx.Where("user_id = ?", query.UserId)
@@ -93,19 +89,45 @@ func (ct *LoginLog) Delete(c *gin.Context) {
 		return
 	}
 	l := service.AllService.LoginLogService.InfoById(f.Id)
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && l.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+	if l.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 		return
 	}
-	if l.Id > 0 {
-		err := service.AllService.LoginLogService.Delete(l)
-		if err == nil {
-			response.Success(c, nil)
-			return
-		}
-		response.Fail(c, 101, err.Error())
+	err := service.AllService.LoginLogService.Delete(l)
+	if err == nil {
+		response.Success(c, nil)
 		return
 	}
-	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+	response.Fail(c, 101, err.Error())
+}
+
+// BatchDelete 删除
+// @Tags 登录日志
+// @Summary 登录日志批量删除
+// @Description 登录日志批量删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.LoginLogIds true "登录日志"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/login_log/batchDelete [post]
+// @Security token
+func (ct *LoginLog) BatchDelete(c *gin.Context) {
+	f := &admin.LoginLogIds{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	if len(f.Ids) == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+
+	err := service.AllService.LoginLogService.BatchDelete(f.Ids)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, err.Error())
+	return
 }

http/controller/admin/my/addressBook.go

@@ -0,0 +1,271 @@
+package my
+
+import (
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"gorm.io/gorm"
+)
+
+type AddressBook struct{}
+
+// List 列表
+// @Tags 我的地址簿
+// @Summary 地址簿列表
+// @Description 地址簿列表
+// @Accept  json
+// @Produce  json
+// @Param page query int false "页码"
+// @Param page_size query int false "页大小"
+// @Param user_id query int false "用户id"
+// @Success 200 {object} response.Response{data=model.AddressBookList}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book/list [get]
+// @Security token
+func (ct *AddressBook) List(c *gin.Context) {
+	query := &admin.AddressBookQuery{}
+	if err := c.ShouldBindQuery(query); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	query.UserId = int(u.Id)
+	res := service.AllService.AddressBookService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
+		//预加载地址簿名称
+		tx.Preload("Collection", func(txc *gorm.DB) *gorm.DB {
+			return txc.Select("id,name")
+		})
+		if query.Id != "" {
+			tx.Where("id like ?", "%"+query.Id+"%")
+		}
+		tx.Where("user_id = ?", query.UserId)
+		if query.Username != "" {
+			tx.Where("username like ?", "%"+query.Username+"%")
+		}
+		if query.Hostname != "" {
+			tx.Where("hostname like ?", "%"+query.Hostname+"%")
+		}
+		if query.CollectionId != nil && *query.CollectionId >= 0 {
+			tx.Where("collection_id = ?", query.CollectionId)
+		}
+	})
+
+	abCIds := make([]uint, 0)
+	for _, ab := range res.AddressBooks {
+		abCIds = append(abCIds, ab.CollectionId)
+	}
+	response.Success(c, res)
+}
+
+// Create 创建地址簿
+// @Tags 我的地址簿
+// @Summary 创建地址簿
+// @Description 创建地址簿
+// @Accept  json
+// @Produce  json
+// @Param body body admin.AddressBookForm true "地址簿信息"
+// @Success 200 {object} response.Response{data=model.AddressBook}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book/create [post]
+// @Security token
+func (ct *AddressBook) Create(c *gin.Context) {
+	f := &admin.AddressBookForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	t := f.ToAddressBook()
+	u := service.AllService.UserService.CurUser(c)
+	t.UserId = u.Id
+	if t.CollectionId > 0 && !service.AllService.AddressBookService.CheckCollectionOwner(t.UserId, t.CollectionId) {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+
+	ex := service.AllService.AddressBookService.InfoByUserIdAndIdAndCid(t.UserId, t.Id, t.CollectionId)
+	if ex.RowId > 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemExists"))
+		return
+	}
+
+	err := service.AllService.AddressBookService.Create(t)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+// Update 编辑
+// @Tags 我的地址簿
+// @Summary 地址簿编辑
+// @Description 地址簿编辑
+// @Accept  json
+// @Produce  json
+// @Param body body admin.AddressBookForm true "地址簿信息"
+// @Success 200 {object} response.Response{data=model.AddressBook}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book/update [post]
+// @Security token
+func (ct *AddressBook) Update(c *gin.Context) {
+	f := &admin.AddressBookForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	if f.RowId == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	if f.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+
+	ex := service.AllService.AddressBookService.InfoByRowId(f.RowId)
+	if ex.RowId == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	if ex.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+	t := f.ToAddressBook()
+	if t.CollectionId > 0 && !service.AllService.AddressBookService.CheckCollectionOwner(t.UserId, t.CollectionId) {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	err := service.AllService.AddressBookService.UpdateAll(t)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+// Delete 删除
+// @Tags 我的地址簿
+// @Summary 地址簿删除
+// @Description 地址簿删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.AddressBookForm true "地址簿信息"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book/delete [post]
+// @Security token
+func (ct *AddressBook) Delete(c *gin.Context) {
+	f := &admin.AddressBookForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	id := f.RowId
+	errList := global.Validator.ValidVar(c, id, "required,gt=0")
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	ex := service.AllService.AddressBookService.InfoByRowId(f.RowId)
+	if ex.RowId == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	if ex.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+	err := service.AllService.AddressBookService.Delete(ex)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+	return
+}
+func (ct *AddressBook) BatchCreateFromPeers(c *gin.Context) {
+	f := &admin.BatchCreateFromPeersForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+
+	if f.CollectionId != 0 {
+		collection := service.AllService.AddressBookService.CollectionInfoById(f.CollectionId)
+		if collection.Id == 0 {
+			response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+			return
+		}
+		if collection.UserId != u.Id {
+			response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+			return
+		}
+	}
+	if len(f.PeerIds) == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	pl := int64(len(f.PeerIds))
+	peers := service.AllService.PeerService.List(1, uint(pl), func(tx *gorm.DB) {
+		tx.Where("row_id in ?", f.PeerIds)
+		tx.Where("user_id = ?", u.Id)
+	})
+	if peers.Total == 0 || pl != peers.Total {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+
+	tags, _ := json.Marshal(f.Tags)
+	for _, peer := range peers.Peers {
+		ab := service.AllService.AddressBookService.FromPeer(peer)
+		ab.Tags = tags
+		ab.CollectionId = f.CollectionId
+		ex := service.AllService.AddressBookService.InfoByUserIdAndIdAndCid(u.Id, ab.Id, ab.CollectionId)
+		if ex.RowId != 0 {
+			continue
+		}
+		service.AllService.AddressBookService.Create(ab)
+	}
+	response.Success(c, nil)
+}
+
+func (ct *AddressBook) BatchUpdateTags(c *gin.Context) {
+	f := &admin.BatchUpdateTagsForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+
+	abs := service.AllService.AddressBookService.List(1, 999, func(tx *gorm.DB) {
+		tx.Where("row_id in ?", f.RowIds)
+		tx.Where("user_id = ?", u.Id)
+	})
+	if abs.Total == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	err := service.AllService.AddressBookService.BatchUpdateTags(abs.AddressBooks, f.Tags)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}

http/controller/admin/my/addressBookCollection.go

@@ -0,0 +1,162 @@
+package my
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"gorm.io/gorm"
+)
+
+type AddressBookCollection struct {
+}
+
+// Create 创建地址簿名称
+// @Tags 我的地址簿名称
+// @Summary 创建地址簿名称
+// @Description 创建地址簿名称
+// @Accept  json
+// @Produce  json
+// @Param body body model.AddressBookCollection true "地址簿名称信息"
+// @Success 200 {object} response.Response{data=model.AddressBookCollection}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book_collection/create [post]
+// @Security token
+func (abc *AddressBookCollection) Create(c *gin.Context) {
+	f := &model.AddressBookCollection{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	f.UserId = u.Id
+	err := service.AllService.AddressBookService.CreateCollection(f)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+// List 列表
+// @Tags 我的地址簿名称
+// @Summary 地址簿名称列表
+// @Description 地址簿名称列表
+// @Accept  json
+// @Produce  json
+// @Param page query int false "页码"
+// @Param page_size query int false "页大小"
+// @Success 200 {object} response.Response{data=model.AddressBookCollectionList}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book_collection/list [get]
+// @Security token
+func (abc *AddressBookCollection) List(c *gin.Context) {
+	query := &admin.AddressBookCollectionQuery{}
+	if err := c.ShouldBindQuery(query); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	query.UserId = int(u.Id)
+	res := service.AllService.AddressBookService.ListCollection(query.Page, query.PageSize, func(tx *gorm.DB) {
+		tx.Where("user_id = ?", query.UserId)
+	})
+	response.Success(c, res)
+}
+
+// Update 编辑
+// @Tags 我的地址簿名称
+// @Summary 地址簿名称编辑
+// @Description 地址簿名称编辑
+// @Accept  json
+// @Produce  json
+// @Param body body model.AddressBookCollection true "地址簿名称信息"
+// @Success 200 {object} response.Response{data=model.AddressBookCollection}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book_collection/update [post]
+// @Security token
+func (abc *AddressBookCollection) Update(c *gin.Context) {
+	f := &model.AddressBookCollection{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	if f.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	if f.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+	ex := service.AllService.AddressBookService.CollectionInfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	if ex.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+
+	err := service.AllService.AddressBookService.UpdateCollection(f)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+// Delete 删除
+// @Tags 我的地址簿名称
+// @Summary 地址簿名称删除
+// @Description 地址簿名称删除
+// @Accept  json
+// @Produce  json
+// @Param body body model.AddressBookCollection true "地址簿名称信息"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book_collection/delete [post]
+// @Security token
+func (abc *AddressBookCollection) Delete(c *gin.Context) {
+	f := &model.AddressBookCollection{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	id := f.Id
+	errList := global.Validator.ValidVar(c, id, "required,gt=0")
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	ex := service.AllService.AddressBookService.CollectionInfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	if ex.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+	err := service.AllService.AddressBookService.DeleteCollection(ex)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+}

http/controller/admin/my/addressBookCollectionRule.go

@@ -0,0 +1,228 @@
+package my
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"gorm.io/gorm"
+)
+
+type AddressBookCollectionRule struct {
+}
+
+// List 列表
+// @Tags 我的地址簿规则
+// @Summary 地址簿规则列表
+// @Description 地址簿规则列表
+// @Accept  json
+// @Produce  json
+// @Param page query int false "页码"
+// @Param page_size query int false "页大小"
+// @Param is_my query int false "是否是我的"
+// @Param user_id query int false "用户id"
+// @Param collection_id query int false "地址簿集合id"
+// @Success 200 {object} response.Response{data=model.AddressBookCollectionList}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book_collection_rule/list [get]
+// @Security token
+func (abcr *AddressBookCollectionRule) List(c *gin.Context) {
+	query := &admin.AddressBookCollectionRuleQuery{}
+	if err := c.ShouldBindQuery(query); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	query.UserId = int(u.Id)
+
+	res := service.AllService.AddressBookService.ListRules(query.Page, query.PageSize, func(tx *gorm.DB) {
+		tx.Where("user_id = ?", query.UserId)
+		if query.CollectionId > 0 {
+			tx.Where("collection_id = ?", query.CollectionId)
+		}
+	})
+	response.Success(c, res)
+}
+
+// Create 创建地址簿规则
+// @Tags 我的地址簿规则
+// @Summary 创建地址簿规则
+// @Description 创建地址簿规则
+// @Accept  json
+// @Produce  json
+// @Param body body model.AddressBookCollectionRule true "地址簿规则信息"
+// @Success 200 {object} response.Response{data=model.AddressBookCollection}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book_collection_rule/create [post]
+// @Security token
+func (abcr *AddressBookCollectionRule) Create(c *gin.Context) {
+	f := &model.AddressBookCollectionRule{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	if f.Type != model.ShareAddressBookRuleTypePersonal && f.Type != model.ShareAddressBookRuleTypeGroup {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	//t := f.ToAddressBookCollection()
+	t := f
+	u := service.AllService.UserService.CurUser(c)
+	t.UserId = u.Id
+	msg, res := abcr.CheckForm(u, t)
+	if !res {
+		response.Fail(c, 101, response.TranslateMsg(c, msg))
+		return
+	}
+	err := service.AllService.AddressBookService.CreateRule(t)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+func (abcr *AddressBookCollectionRule) CheckForm(u *model.User, t *model.AddressBookCollectionRule) (string, bool) {
+	if t.UserId != u.Id {
+		return "NoAccess", false
+	}
+	if t.CollectionId > 0 && !service.AllService.AddressBookService.CheckCollectionOwner(t.UserId, t.CollectionId) {
+		return "ParamsError", false
+	}
+
+	//check to_id
+	if t.Type == model.ShareAddressBookRuleTypePersonal {
+		if t.ToId == t.UserId {
+			return "ParamsError", false
+		}
+		tou := service.AllService.UserService.InfoById(t.ToId)
+		if tou.Id == 0 {
+			return "ItemNotFound", false
+		}
+		//非管理员不能分享给非本组织用户
+		if tou.GroupId != u.GroupId {
+			return "NoAccess", false
+		}
+	} else if t.Type == model.ShareAddressBookRuleTypeGroup {
+		//非管理员不能分享给其他组
+		if t.ToId != u.GroupId {
+			return "NoAccess", false
+		}
+
+		tog := service.AllService.GroupService.InfoById(t.ToId)
+		if tog.Id == 0 {
+			return "ItemNotFound", false
+		}
+	} else {
+		return "ParamsError", false
+	}
+	// 重复检查
+	ex := service.AllService.AddressBookService.RulePersonalInfoByToIdAndCid(t.ToId, t.CollectionId)
+	if t.Id == 0 && ex.Id > 0 {
+		return "ItemExists", false
+	}
+	if t.Id > 0 && ex.Id > 0 && t.Id != ex.Id {
+		return "ItemExists", false
+	}
+	return "", true
+}
+
+// Update 编辑
+// @Tags 我的地址簿规则
+// @Summary 地址簿规则编辑
+// @Description 地址簿规则编辑
+// @Accept  json
+// @Produce  json
+// @Param body body model.AddressBookCollectionRule true "地址簿规则信息"
+// @Success 200 {object} response.Response{data=model.AddressBookCollection}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book_collection_rule/update [post]
+// @Security token
+func (abcr *AddressBookCollectionRule) Update(c *gin.Context) {
+	f := &model.AddressBookCollectionRule{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	if f.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+
+	ex := service.AllService.AddressBookService.RuleInfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	if ex.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+	t := f
+	msg, res := abcr.CheckForm(u, t)
+	if !res {
+		response.Fail(c, 101, response.TranslateMsg(c, msg))
+		return
+	}
+	err := service.AllService.AddressBookService.UpdateRule(t)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+// Delete 删除
+// @Tags 我的地址簿规则
+// @Summary 地址簿规则删除
+// @Description 地址簿规则删除
+// @Accept  json
+// @Produce  json
+// @Param body body model.AddressBookCollectionRule true "地址簿规则信息"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/address_book_collection_rule/delete [post]
+// @Security token
+func (abcr *AddressBookCollectionRule) Delete(c *gin.Context) {
+	f := &model.AddressBookCollectionRule{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	id := f.Id
+	errList := global.Validator.ValidVar(c, id, "required,gt=0")
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	ex := service.AllService.AddressBookService.RuleInfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	if ex.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+
+	err := service.AllService.AddressBookService.DeleteRule(ex)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+}

http/controller/admin/my/loginLog.go

@@ -0,0 +1,113 @@
+package my
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"gorm.io/gorm"
+)
+
+type LoginLog struct {
+}
+
+// List 列表
+// @Tags 我的登录日志
+// @Summary 登录日志列表
+// @Description 登录日志列表
+// @Accept  json
+// @Produce  json
+// @Param page query int false "页码"
+// @Param page_size query int false "页大小"
+// @Param user_id query int false "用户ID"
+// @Success 200 {object} response.Response{data=model.LoginLogList}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/login_log/list [get]
+// @Security token
+func (ct *LoginLog) List(c *gin.Context) {
+	query := &admin.LoginLogQuery{}
+	if err := c.ShouldBindQuery(query); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	res := service.AllService.LoginLogService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
+		tx.Where("user_id = ? and is_deleted = ?", u.Id, model.IsDeletedNo)
+		tx.Order("id desc")
+	})
+	response.Success(c, res)
+}
+
+// Delete 删除
+// @Tags 我的登录日志
+// @Summary 登录日志删除
+// @Description 登录日志删除
+// @Accept  json
+// @Produce  json
+// @Param body body model.LoginLog true "登录日志信息"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/login_log/delete [post]
+// @Security token
+func (ct *LoginLog) Delete(c *gin.Context) {
+	f := &model.LoginLog{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	id := f.Id
+	errList := global.Validator.ValidVar(c, id, "required,gt=0")
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	l := service.AllService.LoginLogService.InfoById(f.Id)
+	if l.Id == 0 || l.IsDeleted == model.IsDeletedYes {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	if l.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	err := service.AllService.LoginLogService.SoftDelete(l)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, err.Error())
+}
+
+// BatchDelete 删除
+// @Tags 我的登录日志
+// @Summary 登录日志批量删除
+// @Description 登录日志批量删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.LoginLogIds true "登录日志"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/login_log/batchDelete [post]
+// @Security token
+func (ct *LoginLog) BatchDelete(c *gin.Context) {
+	f := &admin.LoginLogIds{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	if len(f.Ids) == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	err := service.AllService.LoginLogService.BatchSoftDelete(u.Id, f.Ids)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, err.Error())
+	return
+}

http/controller/admin/my/peer.go

@@ -0,0 +1,59 @@
+package my
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"gorm.io/gorm"
+	"time"
+)
+
+type Peer struct {
+}
+
+// List 列表
+// @Tags 我的设备
+// @Summary 设备列表
+// @Description 设备列表
+// @Accept  json
+// @Produce  json
+// @Param page query int false "页码"
+// @Param page_size query int false "页大小"
+// @Param time_ago query int false "时间"
+// @Param id query string false "ID"
+// @Param hostname query string false "主机名"
+// @Param uuids query string false "uuids 用逗号分隔"
+// @Success 200 {object} response.Response{data=model.PeerList}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/peer/list [get]
+// @Security token
+func (ct *Peer) List(c *gin.Context) {
+	query := &admin.PeerQuery{}
+	if err := c.ShouldBindQuery(query); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	res := service.AllService.PeerService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
+		tx.Where("user_id = ?", u.Id)
+		if query.TimeAgo > 0 {
+			lt := time.Now().Unix() - int64(query.TimeAgo)
+			tx.Where("last_online_time < ?", lt)
+		}
+		if query.TimeAgo < 0 {
+			lt := time.Now().Unix() + int64(query.TimeAgo)
+			tx.Where("last_online_time > ?", lt)
+		}
+		if query.Id != "" {
+			tx.Where("id like ?", "%"+query.Id+"%")
+		}
+		if query.Hostname != "" {
+			tx.Where("hostname like ?", "%"+query.Hostname+"%")
+		}
+		if query.Uuids != "" {
+			tx.Where("uuid in (?)", query.Uuids)
+		}
+	})
+	response.Success(c, res)
+}

http/controller/admin/my/shareRecord.go

@@ -0,0 +1,119 @@
+package my
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"gorm.io/gorm"
+)
+
+type ShareRecord struct {
+}
+
+// List 分享记录列表
+// @Tags 我的分享记录
+// @Summary 分享记录列表
+// @Description 分享记录列表
+// @Accept  json
+// @Produce  json
+// @Param page query int false "页码"
+// @Param page_size query int false "页大小"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/share_record/list [get]
+// @Security token
+func (sr *ShareRecord) List(c *gin.Context) {
+	query := &admin.PageQuery{}
+	if err := c.ShouldBindQuery(query); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	res := service.AllService.ShareRecordService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
+		tx.Where("user_id = ?", u.Id)
+	})
+	response.Success(c, res)
+}
+
+// Delete 分享记录删除
+// @Tags 我的分享记录
+// @Summary 分享记录删除
+// @Description 分享记录删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.ShareRecordForm true "分享记录信息"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/share_record/delete [post]
+// @Security token
+func (sr *ShareRecord) Delete(c *gin.Context) {
+	f := &admin.ShareRecordForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	id := f.Id
+	errList := global.Validator.ValidVar(c, id, "required,gt=0")
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	i := service.AllService.ShareRecordService.InfoById(f.Id)
+	if i.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	if i.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	err := service.AllService.ShareRecordService.Delete(i)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+}
+
+// BatchDelete 批量删除我的分享记录
+// @Tags 我的
+// @Summary 批量删除我的分享记录
+// @Description 批量删除我的分享记录
+// @Accept  json
+// @Produce  json
+// @Param body body admin.PeerShareRecordBatchDeleteForm true "id"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/share_record/batchDelete [post]
+// @Security token
+func (sr *ShareRecord) BatchDelete(c *gin.Context) {
+	f := &admin.PeerShareRecordBatchDeleteForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	if len(f.Ids) == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	var l int64
+	l = int64(len(f.Ids))
+	res := service.AllService.ShareRecordService.List(1, uint(l), func(tx *gorm.DB) {
+		tx.Where("user_id = ?", u.Id)
+		tx.Where("id in ?", f.Ids)
+	})
+	if res.Total != l {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	err := service.AllService.ShareRecordService.BatchDelete(f.Ids)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}

http/controller/admin/my/tag.go

@@ -0,0 +1,176 @@
+package my
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"gorm.io/gorm"
+)
+
+type Tag struct{}
+
+// List 列表
+// @Tags 我的标签
+// @Summary 标签列表
+// @Description 标签列表
+// @Accept  json
+// @Produce  json
+// @Param page query int false "页码"
+// @Param page_size query int false "页大小"
+// @Param is_my query int false "是否是我的"
+// @Param user_id query int false "用户id"
+// @Success 200 {object} response.Response{data=model.TagList}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/tag/list [get]
+// @Security token
+func (ct *Tag) List(c *gin.Context) {
+	query := &admin.TagQuery{}
+	if err := c.ShouldBindQuery(query); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	query.UserId = int(u.Id)
+	res := service.AllService.TagService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
+		tx.Preload("Collection", func(txc *gorm.DB) *gorm.DB {
+			return txc.Select("id,name")
+		})
+		tx.Where("user_id = ?", query.UserId)
+		if query.CollectionId != nil && *query.CollectionId >= 0 {
+			tx.Where("collection_id = ?", query.CollectionId)
+		}
+	})
+	response.Success(c, res)
+}
+
+// Create 创建标签
+// @Tags 我的标签
+// @Summary 创建标签
+// @Description 创建标签
+// @Accept  json
+// @Produce  json
+// @Param body body admin.TagForm true "标签信息"
+// @Success 200 {object} response.Response{data=model.Tag}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/tag/create [post]
+// @Security token
+func (ct *Tag) Create(c *gin.Context) {
+	f := &admin.TagForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	t := f.ToTag()
+	u := service.AllService.UserService.CurUser(c)
+	t.UserId = u.Id
+	err := service.AllService.TagService.Create(t)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+// Update 编辑
+// @Tags 我的标签
+// @Summary 标签编辑
+// @Description 标签编辑
+// @Accept  json
+// @Produce  json
+// @Param body body admin.TagForm true "标签信息"
+// @Success 200 {object} response.Response{data=model.Tag}
+// @Failure 500 {object} response.Response
+// @Router /admin/my/tag/update [post]
+// @Security token
+func (ct *Tag) Update(c *gin.Context) {
+	f := &admin.TagForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	if f.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+
+	u := service.AllService.UserService.CurUser(c)
+	if f.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+	ex := service.AllService.TagService.InfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	if ex.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+
+	t := f.ToTag()
+	if t.CollectionId > 0 && !service.AllService.AddressBookService.CheckCollectionOwner(t.UserId, t.CollectionId) {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	err := service.AllService.TagService.Update(t)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+// Delete 删除
+// @Tags 标签
+// @Summary 标签删除
+// @Description 标签删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.TagForm true "标签信息"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/my/tag/delete [post]
+// @Security token
+func (ct *Tag) Delete(c *gin.Context) {
+	f := &admin.TagForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	id := f.Id
+	errList := global.Validator.ValidVar(c, id, "required,gt=0")
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	ex := service.AllService.TagService.InfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	u := service.AllService.UserService.CurUser(c)
+	if ex.UserId != u.Id {
+		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+		return
+	}
+	err := service.AllService.TagService.Delete(ex)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, err.Error())
+	return
+}

http/controller/admin/oauth.go

@@ -1,12 +1,12 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	adminReq "Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	adminReq "github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"strconv"
 )
 

http/controller/admin/peer.go

@@ -1,11 +1,11 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 	"strconv"
 	"time"

http/controller/admin/rustdesk.go

@@ -1,46 +1,128 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/response"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 )
 
 type Rustdesk struct {
 }
 
-// ServerConfig RUSTDESK服务配置
-// @Tags ADMIN
-// @Summary RUSTDESK服务配置
-// @Description 服务配置,给webclient提供api-server
-// @Accept  json
-// @Produce  json
-// @Success 200 {object} response.Response
-// @Failure 500 {object} response.Response
-// @Router /admin/server-config [get]
-// @Security token
-func (r *Rustdesk) ServerConfig(c *gin.Context) {
-	cf := &response.ServerConfigResponse{
-		IdServer:    global.Config.Rustdesk.IdServer,
-		Key:         global.Config.Rustdesk.Key,
-		RelayServer: global.Config.Rustdesk.RelayServer,
-		ApiServer:   global.Config.Rustdesk.ApiServer,
-	}
-	response.Success(c, cf)
+type RustdeskCmd struct {
+	Cmd    string `json:"cmd"`
+	Option string `json:"option"`
+	Target string `json:"target"`
 }
 
-// AppConfig APP服务配置
-// @Tags ADMIN
-// @Summary APP服务配置
-// @Description APP服务配置
-// @Accept  json
-// @Produce  json
-// @Success 200 {object} response.Response
-// @Failure 500 {object} response.Response
-// @Router /admin/app-config [get]
-// @Security token
-func (r *Rustdesk) AppConfig(c *gin.Context) {
-	response.Success(c, &gin.H{
-		"web_client": global.Config.App.WebClient,
-	})
+func (r *Rustdesk) CmdList(c *gin.Context) {
+	q := &admin.PageQuery{}
+	if err := c.ShouldBindQuery(q); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	res := service.AllService.ServerCmdService.List(q.Page, 9999)
+	//在列表前添加系统命令
+	list := make([]*model.ServerCmd, 0)
+	list = append(list, model.SysIdServerCmds...)
+	list = append(list, model.SysRelayServerCmds...)
+	list = append(list, res.ServerCmds...)
+	res.ServerCmds = list
+	response.Success(c, res)
+}
+
+func (r *Rustdesk) CmdDelete(c *gin.Context) {
+	f := &model.ServerCmd{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	if f.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+
+	ex := service.AllService.ServerCmdService.Info(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+
+	err := service.AllService.ServerCmdService.Delete(ex)
+	if err != nil {
+		response.Fail(c, 101, err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+func (r *Rustdesk) CmdCreate(c *gin.Context) {
+	f := &model.ServerCmd{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	err := service.AllService.ServerCmdService.Create(f)
+	if err != nil {
+		response.Fail(c, 101, err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+func (r *Rustdesk) CmdUpdate(c *gin.Context) {
+	f := &model.ServerCmd{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	errList := global.Validator.ValidStruct(c, f)
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	ex := service.AllService.ServerCmdService.Info(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+		return
+	}
+	err := service.AllService.ServerCmdService.Update(f)
+	if err != nil {
+		response.Fail(c, 101, err.Error())
+		return
+	}
+	response.Success(c, nil)
+}
+
+func (r *Rustdesk) SendCmd(c *gin.Context) {
+	rc := &RustdeskCmd{}
+	if err := c.ShouldBindJSON(rc); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	if rc.Cmd == "" {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	if rc.Target == "" {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	if rc.Target != model.ServerCmdTargetIdServer && rc.Target != model.ServerCmdTargetRelayServer {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	res, err := service.AllService.ServerCmdService.SendCmd(rc.Target, rc.Cmd, rc.Option)
+	if err != nil {
+		response.Fail(c, 101, err.Error())
+		return
+	}
+	response.Success(c, res)
 }

http/controller/admin/shareRecord.go

@@ -0,0 +1,105 @@
+package admin
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"gorm.io/gorm"
+)
+
+type ShareRecord struct {
+}
+
+// List 列表
+// @Tags 分享记录
+// @Summary 分享记录列表
+// @Description 分享记录列表
+// @Accept  json
+// @Produce  json
+// @Param user_id query int false "用户ID"
+// @Param page query int false "页码"
+// @Param page_size query int false "页大小"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/share_record/list [get]
+// @Security token
+func (sr *ShareRecord) List(c *gin.Context) {
+	query := &admin.ShareRecordQuery{}
+	if err := c.ShouldBindQuery(query); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	res := service.AllService.ShareRecordService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
+		if query.UserId > 0 {
+			tx.Where("user_id = ?", query.UserId)
+		}
+	})
+	response.Success(c, res)
+}
+
+// Delete 删除
+// @Tags 分享记录
+// @Summary 分享记录删除
+// @Description 分享记录删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.ShareRecordForm true "分享记录信息"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/share_record/delete [post]
+// @Security token
+func (sr *ShareRecord) Delete(c *gin.Context) {
+	f := &admin.ShareRecordForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	id := f.Id
+	errList := global.Validator.ValidVar(c, id, "required,gt=0")
+	if len(errList) > 0 {
+		response.Fail(c, 101, errList[0])
+		return
+	}
+	i := service.AllService.ShareRecordService.InfoById(f.Id)
+	if i.Id > 0 {
+		err := service.AllService.ShareRecordService.Delete(i)
+		if err == nil {
+			response.Success(c, nil)
+			return
+		}
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+}
+
+// BatchDelete 批量删除
+// @Tags 分享记录
+// @Summary 批量分享记录
+// @Description 批量分享记录
+// @Accept  json
+// @Produce  json
+// @Param body body admin.PeerShareRecordBatchDeleteForm true "id"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/share_record/batchDelete [post]
+// @Security token
+func (sr *ShareRecord) BatchDelete(c *gin.Context) {
+	f := &admin.PeerShareRecordBatchDeleteForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	if len(f.Ids) == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	err := service.AllService.ShareRecordService.BatchDelete(f.Ids)
+	if err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
+		return
+	}
+	response.Success(c, nil)
+}

http/controller/admin/tag.go

@@ -1,11 +1,11 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 	"strconv"
 )
@@ -64,9 +64,9 @@ func (ct *Tag) Create(c *gin.Context) {
 		return
 	}
 	t := f.ToTag()
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) || t.UserId == 0 {
-		t.UserId = u.Id
+	if t.UserId == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
 	}
 	err := service.AllService.TagService.Create(t)
 	if err != nil {
@@ -96,10 +96,6 @@ func (ct *Tag) List(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
 		return
 	}
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) || query.IsMy == 1 {
-		query.UserId = int(u.Id)
-	}
 	res := service.AllService.TagService.List(query.Page, query.PageSize, func(tx *gorm.DB) {
 		tx.Preload("Collection", func(txc *gorm.DB) *gorm.DB {
 			return txc.Select("id,name")
@@ -140,12 +136,12 @@ func (ct *Tag) Update(c *gin.Context) {
 		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
 		return
 	}
-	t := f.ToTag()
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+	ex := service.AllService.TagService.InfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 		return
 	}
+	t := f.ToTag()
 	err := service.AllService.TagService.Update(t)
 	if err != nil {
 		response.Fail(c, 101, response.TranslateMsg(c, "OperationFailed")+err.Error())
@@ -177,20 +173,15 @@ func (ct *Tag) Delete(c *gin.Context) {
 		response.Fail(c, 101, errList[0])
 		return
 	}
-	t := service.AllService.TagService.InfoById(f.Id)
-	u := service.AllService.UserService.CurUser(c)
-	if !service.AllService.UserService.IsAdmin(u) && t.UserId != u.Id {
-		response.Fail(c, 101, response.TranslateMsg(c, "NoAccess"))
+	ex := service.AllService.TagService.InfoById(f.Id)
+	if ex.Id == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 		return
 	}
-	if u.Id > 0 {
-		err := service.AllService.TagService.Delete(t)
-		if err == nil {
-			response.Success(c, nil)
-			return
-		}
-		response.Fail(c, 101, err.Error())
+	err := service.AllService.TagService.Delete(ex)
+	if err == nil {
+		response.Success(c, nil)
 		return
 	}
-	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
+	response.Fail(c, 101, err.Error())
 }

http/controller/admin/user.go

@@ -1,16 +1,15 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	adResp "Gwen/http/response/admin"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	adResp "github.com/lejianwen/rustdesk-api/v2/http/response/admin"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 	"strconv"
-	"time"
 )
 
 type User struct {
@@ -295,51 +294,6 @@ func (ct *User) MyOauth(c *gin.Context) {
 	response.Success(c, res)
 }
 
-// List 列表
-// @Tags 设备
-// @Summary 设备列表
-// @Description 设备列表
-// @Accept  json
-// @Produce  json
-// @Param page query int false "页码"
-// @Param page_size query int false "页大小"
-// @Param time_ago query int false "时间"
-// @Param id query string false "ID"
-// @Param hostname query string false "主机名"
-// @Param uuids query string false "uuids 用逗号分隔"
-// @Success 200 {object} response.Response{data=model.PeerList}
-// @Failure 500 {object} response.Response
-// @Router /admin/user/myPeer [get]
-// @Security token
-func (ct *User) MyPeer(c *gin.Context) {
-	query := &admin.PeerQuery{}
-	if err := c.ShouldBindQuery(query); err != nil {
-		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
-		return
-	}
-	u := service.AllService.UserService.CurUser(c)
-	res := service.AllService.PeerService.ListFilterByUserId(query.Page, query.PageSize, func(tx *gorm.DB) {
-		if query.TimeAgo > 0 {
-			lt := time.Now().Unix() - int64(query.TimeAgo)
-			tx.Where("last_online_time < ?", lt)
-		}
-		if query.TimeAgo < 0 {
-			lt := time.Now().Unix() + int64(query.TimeAgo)
-			tx.Where("last_online_time > ?", lt)
-		}
-		if query.Id != "" {
-			tx.Where("id like ?", "%"+query.Id+"%")
-		}
-		if query.Hostname != "" {
-			tx.Where("hostname like ?", "%"+query.Hostname+"%")
-		}
-		if query.Uuids != "" {
-			tx.Where("uuid in (?)", query.Uuids)
-		}
-	}, u.Id)
-	response.Success(c, res)
-}
-
 // groupUsers
 func (ct *User) GroupUsers(c *gin.Context) {
 	q := &admin.GroupUsersQuery{}

http/controller/admin/userToken.go

@@ -1,12 +1,12 @@
 package admin
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/admin"
-	"Gwen/http/response"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/admin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"gorm.io/gorm"
 )
 
@@ -81,3 +81,33 @@ func (ct *UserToken) Delete(c *gin.Context) {
 	}
 	response.Fail(c, 101, response.TranslateMsg(c, "ItemNotFound"))
 }
+
+// BatchDelete 批量删除
+// @Tags 登录凭证
+// @Summary 登录凭证批量删除
+// @Description 登录凭证批量删除
+// @Accept  json
+// @Produce  json
+// @Param body body admin.UserTokenBatchDeleteForm true "登录凭证信息"
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /admin/user_token/batchDelete [post]
+// @Security token
+func (ct *UserToken) BatchDelete(c *gin.Context) {
+	f := &admin.UserTokenBatchDeleteForm{}
+	if err := c.ShouldBindJSON(f); err != nil {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError")+err.Error())
+		return
+	}
+	ids := f.Ids
+	if len(ids) == 0 {
+		response.Fail(c, 101, response.TranslateMsg(c, "ParamsError"))
+		return
+	}
+	err := service.AllService.UserService.BatchDeleteUserToken(ids)
+	if err == nil {
+		response.Success(c, nil)
+		return
+	}
+	response.Fail(c, 101, err.Error())
+}

http/controller/api/ab.go

@@ -1,16 +1,16 @@
 package api
 
 import (
-	"Gwen/global"
-	requstform "Gwen/http/request/api"
-	"Gwen/http/response"
-	"Gwen/http/response/api"
-	"Gwen/model"
-	"Gwen/service"
-	"Gwen/utils"
 	"encoding/json"
 	"errors"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	requstform "github.com/lejianwen/rustdesk-api/v2/http/request/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/http/response/api"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
+	"github.com/lejianwen/rustdesk-api/v2/utils"
 	"net/http"
 	"strconv"
 	"strings"
@@ -32,8 +32,8 @@ type Ab struct {
 func (a *Ab) Ab(c *gin.Context) {
 	user := service.AllService.UserService.CurUser(c)
 
-	al := service.AllService.AddressBookService.ListByUserId(user.Id, 1, 1000)
-	tags := service.AllService.TagService.ListByUserId(user.Id)
+	al := service.AllService.AddressBookService.ListByUserIdAndCollectionId(user.Id, 0, 1, 1000)
+	tags := service.AllService.TagService.ListByUserIdAndCollectionId(user.Id, 0)
 
 	tagColors := map[string]uint{}
 	//将tags中的name转成一个以逗号分割的字符串
@@ -98,23 +98,6 @@ func (a *Ab) UpAb(c *gin.Context) {
 	c.JSON(http.StatusOK, nil)
 }
 
-// Tags
-// @Tags 地址
-// @Summary 标签
-// @Description 标签
-// @Accept  json
-// @Produce  json
-// @Success 200 {object} []model.Tag
-// @Failure 500 {object} response.ErrorResponse
-// @Router /tags [post]
-// @Security BearerAuth
-func (a *Ab) Tags(c *gin.Context) {
-	user := service.AllService.UserService.CurUser(c)
-
-	tags := service.AllService.TagService.ListByUserId(user.Id)
-	c.JSON(http.StatusOK, tags.Tags)
-}
-
 // PTags
 // @Tags 地址[Personal]
 // @Summary 标签

http/controller/api/audit.go

@@ -1,12 +1,12 @@
 package api
 
 import (
-	request "Gwen/http/request/api"
-	"Gwen/http/response"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
+	request "github.com/lejianwen/rustdesk-api/v2/http/request/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"time"
 )
 

http/controller/api/group.go

@@ -1,12 +1,12 @@
 package api
 
 import (
-	apiReq "Gwen/http/request/api"
-	"Gwen/http/response"
-	apiResp "Gwen/http/response/api"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	apiReq "github.com/lejianwen/rustdesk-api/v2/http/request/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	apiResp "github.com/lejianwen/rustdesk-api/v2/http/response/api"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"net/http"
 )
 

http/controller/api/index.go

@@ -1,12 +1,13 @@
 package api
 
 import (
-	requstform "Gwen/http/request/api"
-	"Gwen/http/response"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	requstform "github.com/lejianwen/rustdesk-api/v2/http/request/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"net/http"
+	"os"
 	"time"
 )
 
@@ -61,3 +62,25 @@ func (i *Index) Heartbeat(c *gin.Context) {
 	}
 	c.JSON(http.StatusOK, gin.H{})
 }
+
+// Version 版本
+// @Tags 首页
+// @Summary 版本
+// @Description 版本
+// @Accept  json
+// @Produce  json
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /version [get]
+func (i *Index) Version(c *gin.Context) {
+	//读取resources/version文件
+	v, err := os.ReadFile("resources/version")
+	if err != nil {
+		response.Fail(c, 101, err.Error())
+		return
+	}
+	response.Success(
+		c,
+		string(v),
+	)
+}

http/controller/api/login.go

@@ -1,15 +1,15 @@
 package api
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/api"
-	"Gwen/http/response"
-	apiResp "Gwen/http/response/api"
-	"Gwen/model"
-	"Gwen/service"
 	"encoding/json"
 	"fmt"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	apiResp "github.com/lejianwen/rustdesk-api/v2/http/response/api"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"net/http"
 )
 
@@ -27,6 +27,10 @@ type Login struct {
 // @Failure 500 {object} response.ErrorResponse
 // @Router /login [post]
 func (l *Login) Login(c *gin.Context) {
+	if global.Config.App.DisablePwdLogin {
+		response.Error(c, response.TranslateMsg(c, "PwdLoginDisabled"))
+		return
+	}
 	f := &api.LoginForm{}
 	err := c.ShouldBindJSON(f)
 	//fmt.Println(f)
@@ -51,6 +55,11 @@ func (l *Login) Login(c *gin.Context) {
 		return
 	}
 
+	if !service.AllService.UserService.CheckUserEnable(u) {
+		response.Error(c, response.TranslateMsg(c, "UserDisabled"))
+		return
+	}
+
 	//根据refer判断是webclient还是app
 	ref := c.GetHeader("referer")
 	if ref != "" {
@@ -85,7 +94,9 @@ func (l *Login) Login(c *gin.Context) {
 // @Router /login-options [get]
 func (l *Login) LoginOptions(c *gin.Context) {
 	ops := service.AllService.OauthService.GetOauthProviders()
-	ops = append(ops, model.OauthTypeWebauth)
+	if global.Config.App.WebSso {
+		ops = append(ops, model.OauthTypeWebauth)
+	}
 	var oidcItems []map[string]string
 	for _, v := range ops {
 		oidcItems = append(oidcItems, map[string]string{"name": v})

http/controller/api/ouath.go

@@ -1,13 +1,13 @@
 package api
 
 import (
-	"Gwen/global"
-	"Gwen/http/request/api"
-	"Gwen/http/response"
-	apiResp "Gwen/http/response/api"
-	"Gwen/model"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/request/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	apiResp "github.com/lejianwen/rustdesk-api/v2/http/response/api"
+	"github.com/lejianwen/rustdesk-api/v2/model"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"net/http"
 )
 

http/controller/api/peer.go

@@ -1,11 +1,11 @@
 package api
 
 import (
-	requstform "Gwen/http/request/api"
-	"Gwen/http/response"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
+	requstform "github.com/lejianwen/rustdesk-api/v2/http/request/api"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"net/http"
 )
 

http/controller/api/user.go

@@ -1,9 +1,9 @@
 package api
 
 import (
-	apiResp "Gwen/http/response/api"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	apiResp "github.com/lejianwen/rustdesk-api/v2/http/response/api"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"net/http"
 )
 
@@ -34,7 +34,7 @@ type User struct {
 // @Produce  json
 // @Success 200 {object} apiResp.UserPayload
 // @Failure 500 {object} response.Response
-// @Router /api [get]
+// @Router /currentUser [get]
 // @Security token
 func (u *User) Info(c *gin.Context) {
 	user := service.AllService.UserService.CurUser(c)

http/controller/api/webClient.go

@@ -1,11 +1,11 @@
 package api
 
 import (
-	"Gwen/global"
-	"Gwen/http/response"
-	"Gwen/http/response/api"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/http/response/api"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 	"time"
 )
 
@@ -26,7 +26,7 @@ func (i *WebClient) ServerConfig(c *gin.Context) {
 	u := service.AllService.UserService.CurUser(c)
 
 	peers := map[string]*api.WebClientPeerPayload{}
-	abs := service.AllService.AddressBookService.ListByUserId(u.Id, 1, 100)
+	abs := service.AllService.AddressBookService.ListByUserIdAndCollectionId(u.Id, 0, 1, 100)
 	for _, ab := range abs.AddressBooks {
 		pp := &api.WebClientPeerPayload{}
 		pp.FromAddressBook(ab)
@@ -64,12 +64,15 @@ func (i *WebClient) SharedPeer(c *gin.Context) {
 		response.Fail(c, 101, "share not found")
 		return
 	}
-	//判断是否过期,created_at + expire > now
-	ca := time.Time(sr.CreatedAt)
-	if ca.Add(time.Second * time.Duration(sr.Expire)).Before(time.Now()) {
-		response.Fail(c, 101, "share expired")
-		return
+	if sr.Expire != 0 {
+		//判断是否过期,created_at + expire > now
+		ca := time.Time(sr.CreatedAt)
+		if ca.Add(time.Second * time.Duration(sr.Expire)).Before(time.Now()) {
+			response.Fail(c, 101, "share expired")
+			return
+		}
 	}
+
 	ab := service.AllService.AddressBookService.InfoByUserIdAndId(sr.UserId, sr.PeerId)
 	if ab.RowId == 0 {
 		response.Fail(c, 101, "peer not found")
@@ -85,3 +88,23 @@ func (i *WebClient) SharedPeer(c *gin.Context) {
 		"peer":      pp,
 	})
 }
+
+// ServerConfigV2 服务配置
+// @Tags WEBCLIENT_V2
+// @Summary 服务配置
+// @Description 服务配置,给webclient提供api-server
+// @Accept  json
+// @Produce  json
+// @Success 200 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /server-config-v2 [get]
+// @Security token
+func (i *WebClient) ServerConfigV2(c *gin.Context) {
+	response.Success(
+		c,
+		gin.H{
+			"id_server": global.Config.Rustdesk.IdServer,
+			"key":       global.Config.Rustdesk.Key,
+		},
+	)
+}

http/controller/web/index.go

@@ -1,8 +1,9 @@
 package web
 
 import (
-	"Gwen/global"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"strconv"
 )
 
 type Index struct {
@@ -14,9 +15,13 @@ func (i *Index) Index(c *gin.Context) {
 
 func (i *Index) ConfigJs(c *gin.Context) {
 	apiServer := global.Config.Rustdesk.ApiServer
-
+	magicQueryonline := strconv.Itoa(global.Config.Rustdesk.WebclientMagicQueryonline)
 	tmp := `
 localStorage.setItem('api-server', "` + apiServer + `")
-`
+const ws2_prefix = 'wc-'
+localStorage.setItem(ws2_prefix+'api-server', "` + apiServer + `")
+
+window.webclient_magic_queryonline = ` + magicQueryonline + ``
+
 	c.String(200, tmp)
 }

http/http.go

@@ -1,10 +1,10 @@
 package http
 
 import (
-	"Gwen/global"
-	"Gwen/http/middleware"
-	"Gwen/http/router"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/middleware"
+	"github.com/lejianwen/rustdesk-api/v2/http/router"
 	"github.com/sirupsen/logrus"
 	"net/http"
 	"strings"

http/middleware/admin.go

@@ -1,13 +1,13 @@
 package middleware
 
 import (
-	"Gwen/http/response"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 )
 
-// AdminAuth 后台权限验证中间件
-func AdminAuth() gin.HandlerFunc {
+// BackendUserAuth 后台权限验证中间件
+func BackendUserAuth() gin.HandlerFunc {
 	return func(c *gin.Context) {
 
 		//测试先关闭
@@ -17,15 +17,25 @@ func AdminAuth() gin.HandlerFunc {
 			c.Abort()
 			return
 		}
-		user := service.AllService.UserService.InfoByAccessToken(token)
+		user, ut := service.AllService.UserService.InfoByAccessToken(token)
 		if user.Id == 0 {
 			response.Fail(c, 403, "请先登录")
 			c.Abort()
 			return
 		}
 
+		if !service.AllService.UserService.CheckUserEnable(user) {
+			c.JSON(401, gin.H{
+				"error": "Unauthorized",
+			})
+			c.Abort()
+			return
+		}
+
 		c.Set("curUser", user)
 		c.Set("token", token)
+		//如果时间小于1天,token自动续期
+		service.AllService.UserService.AutoRefreshAccessToken(ut)
 
 		c.Next()
 	}

http/middleware/admin_privilege.go

@@ -1,9 +1,9 @@
 package middleware
 
 import (
-	"Gwen/http/response"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 )
 
 // AdminPrivilege ...

http/middleware/jwt.go

@@ -1,10 +1,10 @@
 package middleware
 
 import (
-	"Gwen/global"
-	"Gwen/http/response"
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/http/response"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 )
 
 func JwtAuth() gin.HandlerFunc {

http/middleware/logger.go

@@ -1,8 +1,8 @@
 package middleware
 
 import (
-	"Gwen/global"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
 	"github.com/sirupsen/logrus"
 )
 

http/middleware/rustauth.go

@@ -1,8 +1,9 @@
 package middleware
 
 import (
-	"Gwen/service"
 	"github.com/gin-gonic/gin"
+	"github.com/lejianwen/rustdesk-api/v2/global"
+	"github.com/lejianwen/rustdesk-api/v2/service"
 )
 
 func RustAuth() gin.HandlerFunc {
@@ -27,8 +28,22 @@ func RustAuth() gin.HandlerFunc {
 		//提取token，格式是Bearer {token}
 		//这里只是简单的提取
 		token = token[7:]
+
 		//验证token
-		user := service.AllService.UserService.InfoByAccessToken(token)
+
+		//检查是否设置了jwt key
+		if len(global.Jwt.Key) > 0 {
+			uid, _ := service.AllService.UserService.VerifyJWT(token)
+			if uid == 0 {
+				c.JSON(401, gin.H{
+					"error": "Unauthorized",
+				})
+				c.Abort()
+				return
+			}
+		}
+
+		user, ut := service.AllService.UserService.InfoByAccessToken(token)
 		if user.Id == 0 {
 			c.JSON(401, gin.H{
 				"error": "Unauthorized",
@@ -38,7 +53,7 @@ func RustAuth() gin.HandlerFunc {
 		}
 		if !service.AllService.UserService.CheckUserEnable(user) {
 			c.JSON(401, gin.H{
-				"error": "账号已被禁用",
+				"error": "Unauthorized",
 			})
 			c.Abort()
 			return
@@ -46,6 +61,9 @@ func RustAuth() gin.HandlerFunc {
 
 		c.Set("curUser", user)
 		c.Set("token", token)
+
+		service.AllService.UserService.AutoRefreshAccessToken(ut)
+
 		c.Next()
 	}
 }

http/request/admin/addressBook.go

@@ -1,8 +1,8 @@
 package admin
 
 import (
-	"Gwen/model"
 	"encoding/json"
+	"github.com/lejianwen/rustdesk-api/v2/model"
 )
 
 type AddressBookForm struct {
@@ -122,3 +122,14 @@ type AddressBookCollectionRuleQuery struct {
 	IsMy         int `form:"is_my"`
 	PageQuery
 }
+
+type BatchCreateFromPeersForm struct {
+	CollectionId uint     `json:"collection_id"`
+	PeerIds      []uint   `json:"peer_ids"`
+	Tags         []string `json:"tags"`
+	UserId       uint     `json:"user_id"`
+}
+type BatchUpdateTagsForm struct {
+	RowIds []uint   `json:"row_ids"`
+	Tags   []string `json:"tags"`
+}

http/request/admin/audit.go

@@ -5,3 +5,10 @@ type AuditQuery struct {
 	FromPeer string `form:"from_peer"`
 	PageQuery
 }
+
+type AuditConnLogIds struct {
+	Ids []uint `json:"ids" validate:"required"`
+}
+type AuditFileLogIds struct {
+	Ids []uint `json:"ids" validate:"required"`
+}

http/request/admin/group.go

@@ -1,6 +1,6 @@
 package admin
 
-import "Gwen/model"
+import "github.com/lejianwen/rustdesk-api/v2/model"
 
 type GroupForm struct {
 	Id   uint   `json:"id"`

http/request/admin/login.go

@@ -4,6 +4,7 @@ type Login struct {
 	Username string `json:"username" validate:"required" label:"用户名"`
 	Password string `json:"password,omitempty" validate:"required" label:"密码"`
 	Platform string `json:"platform" label:"平台"`
+	Captcha  string `json:"captcha,omitempty" label:"验证码"`
 }
 
 type LoginLogQuery struct {
@@ -15,3 +16,7 @@ type LoginTokenQuery struct {
 	UserId int `form:"user_id"`
 	PageQuery
 }
+
+type LoginLogIds struct {
+	Ids []uint `json:"ids" validate:"required"`
+}