Merge pull request #616 from thsrite/fix

- 修复了RSS模式指定订阅站点时不刷新订阅的问题
- 推荐页面后退时会记住浏览位置
- 订阅及搜索支持设置全局包含和排除规则

.dockerignore

@@ -0,0 +1,3 @@
+# Ignore git
+.github
+.git

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 blank_issues_enabled: false
 contact_links:
+  - name: 项目讨论
+    url: https://github.com/jxxghp/MoviePilot/discussions/new/choose
+    about: discussion
   - name: Telegram 频道
     url: https://t.me/moviepilot_channel
     about: 更新日志

.github/ISSUE_TEMPLATE/discussion.yml

@@ -1,17 +0,0 @@
-name: 项目讨论
-description: discussion
-title: "[Discussion]: "
-labels: ["discussion"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        [BUG](https://github.com/jxxghp/MoviePilot/issues/new?assignees=&labels=bug&template=bug_report.yml&title=%5BBUG%5D%3A) 与 [Feature Request](https://github.com/jxxghp/MoviePilot/issues/new?assignees=&labels=feature+request&template=feature_request.yml&title=%5BFeature+Request%5D%3A+) 请转到对应位置提交。
-  - type: textarea
-    id: discussion
-    attributes:
-      label: 项目讨论
-      description: 请详细描述需要讨论的内容。
-      placeholder: "项目讨论"
-    validations:
-      required: true

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: MoviePilot Docker
+name: MoviePilot Builder
 on:
   workflow_dispatch:
   push:
@@ -14,13 +14,7 @@ jobs:
     steps:
       -
         name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot
+        uses: actions/checkout@v4
 
       -
         name: Release version
@@ -29,34 +23,42 @@ jobs:
           app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
           echo "app_version=$app_version" >> $GITHUB_ENV
 
+      - 
+        name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot
+          tags: |
+            type=raw,value=${{ env.app_version }}
+            type=raw,value=latest
+
       -
         name: Set Up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
 
       -
         name: Set Up Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
 
       -
         name: Login DockerHub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       -
         name: Build Image
-        uses: docker/build-push-action@v4
+        uses: docker/build-push-action@v5
         with:
           context: .
           file: Dockerfile
           platforms: |
             linux/amd64
-            linux/arm64
+            linux/arm64/v8
           push: true
           build-args: |
             MOVIEPILOT_VERSION=${{ env.app_version }}
-          tags: |
-            ${{ secrets.DOCKER_USERNAME }}/moviepilot:latest
-            ${{ secrets.DOCKER_USERNAME }}/moviepilot:${{ env.app_version }}
+          tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

.github/workflows/release.yml

@@ -0,0 +1,36 @@
+name: MoviePilot Release
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - version.py
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Build Docker Image
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v4
+
+      -
+        name: Release Version
+        id: release_version
+        run: |
+          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
+          echo "app_version=$app_version" >> $GITHUB_ENV
+
+      -
+        name: Generate Release
+        uses: actions/create-release@latest
+        with:
+          tag_name: v${{ env.app_version }}
+          release_name: v${{ env.app_version }}
+          body: ${{ github.event.commits[0].message }}
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Dockerfile

@@ -8,6 +8,8 @@ ENV LANG="C.UTF-8" \
     PGID=0 \
     UMASK=000 \
     MOVIEPILOT_AUTO_UPDATE=true \
+    MOVIEPILOT_AUTO_UPDATE_DEV=false \
+    PORT=3001 \
     NGINX_PORT=3000 \
     CONFIG_DIR="/config" \
     API_TOKEN="moviepilot" \
@@ -18,7 +20,7 @@ ENV LANG="C.UTF-8" \
     LIBRARY_PATH="" \
     LIBRARY_CATEGORY="false" \
     TRANSFER_TYPE="copy" \
-    COOKIECLOUD_HOST="https://nastool.org/cookiecloud" \
+    COOKIECLOUD_HOST="https://movie-pilot.org/cookiecloud" \
     COOKIECLOUD_KEY="" \
     COOKIECLOUD_PASSWORD="" \
     MESSAGER="telegram" \
@@ -47,6 +49,7 @@ RUN apt-get update \
         busybox \
         dumb-init \
         jq \
+        haproxy \
     && \
     if [ "$(uname -m)" = "x86_64" ]; \
         then ln -s /usr/lib/x86_64-linux-musl/libc.so /lib/libc.musl-x86_64.so.1; \
@@ -57,11 +60,12 @@ RUN apt-get update \
     && cp -f /app/update /usr/local/bin/mp_update \
     && cp -f /app/entrypoint /entrypoint \
     && chmod +x /entrypoint /usr/local/bin/mp_update \
-    && mkdir -p ${HOME} \
+    && mkdir -p ${HOME} /var/lib/haproxy/server-state \
     && groupadd -r moviepilot -g 911 \
     && useradd -r moviepilot -g moviepilot -d ${HOME} -s /bin/bash -u 911 \
     && apt-get install -y build-essential \
     && pip install --upgrade pip \
+    && pip install Cython \
     && pip install -r requirements.txt \
     && playwright install-deps chromium \
     && python_ver=$(python3 -V | awk '{print $2}') \
@@ -81,5 +85,5 @@ RUN apt-get update \
         /var/lib/apt/lists/* \
         /var/tmp/*
 EXPOSE 3000
-VOLUME ["/config"]
+VOLUME [ "/config" ]
 ENTRYPOINT [ "/entrypoint" ]

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -21,22 +21,19 @@ Docker：https://hub.docker.com/r/jxxghp/moviepilot
 
 2. **安装CookieCloud服务端（可选）**
 
-MoviePilot内置了NAStool使用的公共CookieCloud服务器，如果需要自建服务，可参考 [CookieCloud](https://github.com/easychen/CookieCloud) 项目进行搭建。
-```shell
-docker pull easychen/cookiecloud:latest
-```
+MoviePilot内置了公共CookieCloud服务器，如果需要自建服务，可参考 [CookieCloud](https://github.com/easychen/CookieCloud) 项目进行搭建，docker镜像请点击 [这里](https://hub.docker.com/r/easychen/cookiecloud)。
 
 **声明：** 本项目不会收集用户敏感数据，Cookie同步也是基于CookieCloud项目实现，非本项目提供的能力。技术角度上CookieCloud采用端到端加密，在个人不泄露`用户KEY`和`端对端加密密码`的情况下第三方无法窃取任何用户信息（包括服务器持有者）。如果你不放心，可以不使用公共服务或者不使用本项目，但如果使用后发生了任何信息泄露与本项目无关！
 
 3. **安装配套管理软件**
 
-MoviePilot跟NAStool一样，需要配套下载器和媒体服务器使用。
+MoviePilot需要配套下载器和媒体服务器配合使用。
 - 下载器支持：qBittorrent、Transmission，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，推荐使用QB。
 - 媒体服务器支持：Jellyfin、Emby、Plex，推荐使用Emby。
 
 4. **安装MoviePilot**
 
-目前仅提供docker镜像，后续可能会提供更多安装方式。
+目前仅提供docker镜像，点击 [这里](https://hub.docker.com/r/jxxghp/moviepilot) 或执行命令：
 
 ```shell
 docker pull jxxghp/moviepilot:latest
@@ -54,30 +51,39 @@ docker pull jxxghp/moviepilot:latest
 - **PGID**：运行程序用户的`gid`，默认`0`
 - **UMASK**：掩码权限，默认`000`，可以考虑设置为`022`
 - **MOVIEPILOT_AUTO_UPDATE**：重启更新，`true`/`false`，默认`true` **注意：如果出现网络问题可以配置`PROXY_HOST`，具体看下方`PROXY_HOST`解释**
-- **NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，但不能为`3001`
+- **NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，不能与API服务端口冲突
+- **PORT：** API服务端口，默认`3001`，可自行修改，不能与WEB服务端口冲突
 - **SUPERUSER：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面
 - **SUPERUSER_PASSWORD：** 超级管理员初始密码，默认`password`，建议修改为复杂密码
 - **API_TOKEN：** API密钥，默认`moviepilot`，在媒体服务器Webhook、微信回调等地址配置中需要加上`?token=`该值，建议修改为复杂字符串
 - **PROXY_HOST：** 网络代理（可选），访问themoviedb或者重启更新需要使用代理访问，格式为`http(s)://ip:port`
 - **TMDB_API_DOMAIN：** TMDB API地址，默认`api.themoviedb.org`，也可配置为`api.tmdb.org`或其它中转代理服务地址，能连通即可
 - **DOWNLOAD_PATH：** 下载保存目录，**注意：需要将`moviepilot`及`下载器`的映射路径保持一致**，否则会导致下载文件无法转移
-- **DOWNLOAD_MOVIE_PATH：** 电影下载保存目录，**必须是`DOWNLOAD_PATH`的下级路径**，不设置则下载到`DOWNLOAD_PATH`
-- **DOWNLOAD_TV_PATH：** 电视剧下载保存目录，**必须是`DOWNLOAD_PATH`的下级路径**，不设置则下载到`DOWNLOAD_PATH`
+- **DOWNLOAD_MOVIE_PATH：** 电影下载保存目录，不设置则下载到`DOWNLOAD_PATH`
+- **DOWNLOAD_TV_PATH：** 电视剧下载保存目录，不设置则下载到`DOWNLOAD_PATH`
+- **DOWNLOAD_ANIME_PATH：** 动漫下载保存目录，不设置则下载到`DOWNLOAD_PATH`
 - **DOWNLOAD_CATEGORY：** 下载二级分类开关，`true`/`false`，默认`false`，开启后会根据配置`category.yaml`自动在下载目录下建立二级目录分类
 - **DOWNLOAD_SUBTITLE：** 下载站点字幕，`true`/`false`，默认`true`
 - **REFRESH_MEDIASERVER：** 入库刷新媒体库，`true`/`false`，默认`true`
 - **SCRAP_METADATA：** 刮削入库的媒体文件，`true`/`false`，默认`true`
+- **SCRAP_FOLLOW_TMDB：** 新增已入库媒体是否跟随TMDB信息变化，`true`/`false`，默认`true`
 - **TORRENT_TAG：** 种子标签，默认为`MOVIEPILOT`，设置后只有MoviePilot添加的下载才会处理，留空所有下载器中的任务均会处理
 - **LIBRARY_PATH：** 媒体库目录，多个目录使用`,`分隔
 - **LIBRARY_MOVIE_NAME：** 电影媒体库目录名，默认`电影`
 - **LIBRARY_TV_NAME：** 电视剧媒体库目录名，默认`电视剧`
+- **LIBRARY_ANIME_NAME：** 动漫媒体库目录名，默认`电视剧/动漫`
 - **LIBRARY_CATEGORY：** 媒体库二级分类开关，`true`/`false`，默认`false`，开启后会根据配置`category.yaml`自动在媒体库目录下建立二级目录分类
 - **TRANSFER_TYPE：** 转移方式，支持`link`/`copy`/`move`/`softlink`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响**
-- **COOKIECLOUD_HOST：** CookieCloud服务器地址，格式：`http://ip:port`，必须配置，否则无法添加站点
+- **COOKIECLOUD_HOST：** CookieCloud服务器地址，格式：`http(s)://ip:port`，不配置默认使用内建服务器`https://movie-pilot.org/cookiecloud`
 - **COOKIECLOUD_KEY：** CookieCloud用户KEY
 - **COOKIECLOUD_PASSWORD：** CookieCloud端对端加密密码
 - **COOKIECLOUD_INTERVAL：** CookieCloud同步间隔（分钟）
+- **OCR_HOST：** OCR识别服务器地址，格式：`http(s)://ip:port`，用于识别站点二维码实现自动登录获取Cookie等，不配置默认使用内建服务器`https://movie-pilot.org`，可使用 [这个镜像](https://hub.docker.com/r/jxxghp/moviepilot-ocr) 自行搭建。
 - **USER_AGENT：** CookieCloud对应的浏览器UA，可选，设置后可增加连接站点的成功率，同步站点后可以在管理界面中修改
+- **AUTO_DOWNLOAD_USER：** 交互搜索自动下载用户ID，使用,分割
+- **SUBSCRIBE_MODE：** 订阅模式，`rss`/`spider`，默认`spider`，`rss`模式通过定时刷新RSS来匹配订阅（RSS地址会自动获取，也可手动维护），对站点压力小，同时可设置订阅刷新周期，24小时运行，但订阅和下载通知不能过滤和显示免费，推荐使用rss模式。
+- **SUBSCRIBE_RSS_INTERVAL：** RSS订阅模式刷新时间间隔（分钟），默认`30`分钟，不能小于5分钟。
+- **SUBSCRIBE_SEARCH：** 订阅搜索，`true`/`false`，默认`false`，开启后会每隔24小时对所有订阅进行全量搜索，以补齐缺失剧集（一般情况下正常订阅即可，订阅搜索只做为兜底，会增加站点压力，不建议开启）。
 - **MESSAGER：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`
 
   - `wechat`设置项：
@@ -111,6 +117,7 @@ docker pull jxxghp/moviepilot:latest
     - **QB_HOST：** qbittorrent地址，格式：`ip:port`，https需要添加`https://`前缀
     - **QB_USER：** qbittorrent用户名
     - **QB_PASSWORD：** qbittorrent密码
+    - **QB_CATEGORY：** qbittorrent分类自动管理，`true`/`false`，默认`false`，开启后会将下载二级分类传递到下载器，由下载器管理下载目录，需要同步开启`DOWNLOAD_CATEGORY`
 
   - `transmission`设置项：
 
@@ -142,23 +149,24 @@ docker pull jxxghp/moviepilot:latest
 
 ### 2. **用户认证**
 
-- **AUTH_SITE：** 认证站点，支持`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`iyuu`
+- **AUTH_SITE：** 认证站点，支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`
 
 `MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数。
 
-| 站点 | 参数                                                    |
-|:--:|:-----------------------------------------------------:|
-| iyuu | `IYUU_SIGN`：IYUU登录令牌                                  |
-| hhclub | `HHCLUB_USERNAME`：用户名<br/>`HHCLUB_PASSKEY`：密钥         |
-| audiences | `AUDIENCES_UID`：用户ID<br/>`AUDIENCES_PASSKEY`：密钥       |
-| hddolby | `HDDOLBY_ID`：用户ID<br/>`HDDOLBY_PASSKEY`：密钥            |
-| zmpt | `ZMPT_UID`：用户ID<br/>`ZMPT_PASSKEY`：密钥                 |
-| freefarm | `FREEFARM_UID`：用户ID<br/>`FREEFARM_PASSKEY`：密钥         |
-| hdfans | `HDFANS_UID`：用户ID<br/>`HDFANS_PASSKEY`：密钥             |
+|      站点      |                          参数                           |
+|:------------:|:-----------------------------------------------------:|
+|     iyuu     |                 `IYUU_SIGN`：IYUU登录令牌                  |
+|    hhclub    |     `HHCLUB_USERNAME`：用户名<br/>`HHCLUB_PASSKEY`：密钥     |
+|  audiences   |    `AUDIENCES_UID`：用户ID<br/>`AUDIENCES_PASSKEY`：密钥    |
+|   hddolby    |      `HDDOLBY_ID`：用户ID<br/>`HDDOLBY_PASSKEY`：密钥       |
+|     zmpt     |         `ZMPT_UID`：用户ID<br/>`ZMPT_PASSKEY`：密钥         |
+|   freefarm   |     `FREEFARM_UID`：用户ID<br/>`FREEFARM_PASSKEY`：密钥     |
+|    hdfans    |       `HDFANS_UID`：用户ID<br/>`HDFANS_PASSKEY`：密钥       |
 | wintersakura | `WINTERSAKURA_UID`：用户ID<br/>`WINTERSAKURA_PASSKEY`：密钥 |
-| leaves | `LEAVES_UID`：用户ID<br/>`LEAVES_PASSKEY`：密钥             |
-| 1ptba | `1PTBA_UID`：用户ID<br/>`1PTBA_PASSKEY`：密钥               |
-| icc2022 | `ICC2022_UID`：用户ID<br/>`ICC2022_PASSKEY`：密钥           |
+|    leaves    |       `LEAVES_UID`：用户ID<br/>`LEAVES_PASSKEY`：密钥       |
+|    1ptba     |        `1PTBA_UID`：用户ID<br/>`1PTBA_PASSKEY`：密钥        |
+|   icc2022    |      `ICC2022_UID`：用户ID<br/>`ICC2022_PASSKEY`：密钥      |
+|    ptlsp     |        `PTLSP_UID`：用户ID<br/>`PTLSP_PASSKEY`：密钥        |
 
 
 ### 2. **进阶配置**
@@ -217,12 +225,13 @@ docker pull jxxghp/moviepilot:latest
 
 ## 使用
 
-- 通过CookieCloud同步快速同步站点，不需要使用的站点可在WEB管理界面中禁用。
-- 通过下载器监控实现自动整理入库刮削。
-- 通过微信/Telegram/Slack远程管理，其中Telegram将会自动添加操作菜单。微信回调相对路径为`/api/v1/message/`。
-- 通过WEB进行管理，将WEB添加到手机桌面获得类App使用效果，管理界面端口：`3000`。
-- 设置媒体服务器Webhook，通过MoviePilot发送播放通知等。Webhook回调相对路径为`/api/v1/webhook?token=moviepilot`，其中`moviepilot`为设置的`API_TOKEN`。
-- 将MoviePilot做为Radarr或Sonarr服务器添加到Overseerr或Jellyseerr，可使用Overseerr/Jellyseerr浏览订阅。
+- 通过CookieCloud同步快速同步站点，不需要使用的站点可在WEB管理界面中禁用，无法同步的站点可手动新增。
+- 通过WEB进行管理，将WEB添加到手机桌面获得类App使用效果，管理界面端口：`3000`，后台API端口：`3001`。
+- 通过下载器监控或使用目录监控插件实现自动整理入库刮削（二选一）。
+- 通过微信/Telegram/Slack远程管理，其中微信/Telegram将会自动添加操作菜单（微信菜单条数有限制，部分菜单不显示），微信需要在官方页面设置回调地址，地址相对路径为：`/api/v1/message/`。
+- 设置媒体服务器Webhook，通过MoviePilot发送播放通知等。Webhook回调相对路径为`/api/v1/webhook?token=moviepilot`（`3001`端口），其中`moviepilot`为设置的`API_TOKEN`。
+- 将MoviePilot做为Radarr或Sonarr服务器添加到Overseerr或Jellyseerr（`3001`端口），可使用Overseerr/Jellyseerr浏览订阅。
+- 映射宿主机docker.sock文件到容器`/var/run/docker.sock`，以支持内建重启操作。实例：`-v /var/run/docker.sock:/var/run/docker.sock:ro`
 
 **注意**
 
@@ -237,11 +246,24 @@ location / {
     proxy_set_header X-Forwarded-Proto $scheme;
 }
 ```
+3) 新建的企业微信应用需要固定公网IP的代理才能收到消息，代理添加以下代码：
+```nginx configuration
+location /cgi-bin/gettoken {
+    proxy_pass https://qyapi.weixin.qq.com;
+}
+location /cgi-bin/message/send {
+    proxy_pass https://qyapi.weixin.qq.com;
+}
+location  /cgi-bin/menu/create {
+    proxy_pass https://qyapi.weixin.qq.com;
+}
+```
 
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/b8f0238d-847f-4f9d-b210-e905837362b9)
+![image](https://github.com/jxxghp/MoviePilot/assets/51039935/f2654b09-26f3-464f-a0af-1de3f97832ee)
 
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/28219233-ec7d-479b-b184-9a901c947dd1)
+![image](https://github.com/jxxghp/MoviePilot/assets/51039935/fcb87529-56dd-43df-8337-6e34b8582819)
 
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/f7df0806-668d-4c8b-ad41-133bf8f0bf73)
+![image](https://github.com/jxxghp/MoviePilot/assets/51039935/bfa77c71-510a-46a6-9c1e-cf98cb101e3a)
+
+![image](https://github.com/jxxghp/MoviePilot/assets/51039935/51cafd09-e38c-47f9-ae62-1e83ab8bf89b)
 
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/f7ea77cd-0362-4c35-967c-7f1b22dbef05)

alembic/versions/1e169250e949_1_0_4.py

@@ -0,0 +1,30 @@
+"""1.0.4
+
+Revision ID: 1e169250e949
+Revises: 52ab4930be04
+Create Date: 2023-09-01 09:56:33.907661
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '1e169250e949'
+down_revision = '52ab4930be04'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    try:
+        with op.batch_alter_table("subscribe") as batch_op:
+            batch_op.add_column(sa.Column('date', sa.String, nullable=True))
+    except Exception as e:
+        pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    pass

alembic/versions/52ab4930be04_1_0_3.py

@@ -0,0 +1,28 @@
+"""1_0_3
+
+Revision ID: 52ab4930be04
+Revises: ec5fb51fc300
+Create Date: 2023-08-28 13:21:45.152012
+
+"""
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = '52ab4930be04'
+down_revision = 'ec5fb51fc300'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.execute("delete from systemconfig where key = 'RssSites';")
+    op.execute("insert into systemconfig(key, value) VALUES('RssSites', (select value from systemconfig where key= 'IndexerSites'));")
+    op.execute("delete from systemconfig where key = 'SearchResults';")
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

alembic/versions/e734c7fe6056_1_0_5.py

@@ -0,0 +1,27 @@
+"""1.0.5
+
+Revision ID: e734c7fe6056
+Revises: 1e169250e949
+Create Date: 2023-09-07 18:19:41.250957
+
+"""
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = 'e734c7fe6056'
+down_revision = '1e169250e949'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    try:
+        op.create_index('ix_transferhistory_tmdbid', 'transferhistory', ['tmdbid'], unique=False)
+    except Exception as err:
+        pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    pass

app/api/apiv1.py

@@ -1,7 +1,7 @@
 from fastapi import APIRouter
 
 from app.api.endpoints import login, user, site, message, webhook, subscribe, \
-    media, douban, search, plugin, tmdb, history, system, download, dashboard, rss
+    media, douban, search, plugin, tmdb, history, system, download, dashboard, filebrowser, transfer
 
 api_router = APIRouter()
 api_router.include_router(login.router, prefix="/login", tags=["login"])
@@ -19,4 +19,5 @@ api_router.include_router(system.router, prefix="/system", tags=["system"])
 api_router.include_router(plugin.router, prefix="/plugin", tags=["plugin"])
 api_router.include_router(download.router, prefix="/download", tags=["download"])
 api_router.include_router(dashboard.router, prefix="/dashboard", tags=["dashboard"])
-api_router.include_router(rss.router, prefix="/rss", tags=["rss"])
+api_router.include_router(filebrowser.router, prefix="/filebrowser", tags=["filebrowser"])
+api_router.include_router(transfer.router, prefix="/transfer", tags=["transfer"])

app/api/endpoints/dashboard.py

@@ -41,12 +41,7 @@ def storage(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询存储空间信息
     """
-    if settings.LIBRARY_PATH:
-        total_storage, free_storage = SystemUtils.space_usage(
-            [Path(path) for path in settings.LIBRARY_PATH.split(",")]
-        )
-    else:
-        total_storage, free_storage = 0, 0
+    total_storage, free_storage = SystemUtils.space_usage(settings.LIBRARY_PATHS)
     return schemas.Storage(
         total_storage=total_storage,
         used_storage=total_storage - free_storage
@@ -124,3 +119,19 @@ def transfer(days: int = 7, db: Session = Depends(get_db),
     """
     transfer_stat = TransferHistory.statistic(db, days)
     return [stat[1] for stat in transfer_stat]
+
+
+@router.get("/cpu", summary="获取当前CPU使用率", response_model=int)
+def cpu(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取当前CPU使用率
+    """
+    return SystemUtils.cpu_usage()
+
+
+@router.get("/memory", summary="获取当前内存使用量和使用率", response_model=List[int])
+def memory(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取当前内存使用率
+    """
+    return SystemUtils.memory_usage()

app/api/endpoints/douban.py

@@ -45,6 +45,21 @@ def recognize_doubanid(doubanid: str,
         return schemas.Context()
 
 
+@router.get("/showing", summary="豆瓣正在热映", response_model=List[schemas.MediaInfo])
+def movie_showing(page: int = 1,
+                  count: int = 30,
+                  db: Session = Depends(get_db),
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣正在热映
+    """
+    movies = DoubanChain(db).movie_showing(page=page, count=count)
+    if not movies:
+        return []
+    medias = [MediaInfo(douban_info=movie) for movie in movies]
+    return [media.to_dict() for media in medias]
+
+
 @router.get("/movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
 def douban_movies(sort: str = "R",
                   tags: str = "",

app/api/endpoints/filebrowser.py

@@ -0,0 +1,183 @@
+import shutil
+from pathlib import Path
+from typing import Any, List
+
+from fastapi import APIRouter, Depends
+from starlette.responses import FileResponse, Response
+
+from app import schemas
+from app.core.config import settings
+from app.core.security import verify_token
+from app.log import logger
+from app.utils.system import SystemUtils
+
+router = APIRouter()
+
+IMAGE_TYPES = [".jpg", ".png", ".gif", ".bmp", ".jpeg", ".webp"]
+
+
+@router.get("/list", summary="所有插件", response_model=List[schemas.FileItem])
+def list_path(path: str, sort: str = 'time', _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询当前目录下所有目录和文件
+    """
+    # 返回结果
+    ret_items = []
+    if not path or path == "/":
+        if SystemUtils.is_windows():
+            partitions = SystemUtils.get_windows_drives() or ["C:/"]
+            for partition in partitions:
+                ret_items.append(schemas.FileItem(
+                    type="dir",
+                    path=partition + "/",
+                    name=partition,
+                    basename=partition
+                ))
+            return ret_items
+        else:
+            path = "/"
+    else:
+        if not SystemUtils.is_windows() and not path.startswith("/"):
+            path = "/" + path
+
+    # 遍历目录
+    path_obj = Path(path)
+    if not path_obj.exists():
+        logger.error(f"目录不存在：{path}")
+        return []
+
+    # 如果是文件
+    if path_obj.is_file():
+        ret_items.append(schemas.FileItem(
+            type="file",
+            path=str(path_obj).replace("\\", "/"),
+            name=path_obj.name,
+            basename=path_obj.stem,
+            extension=path_obj.suffix[1:],
+            size=path_obj.stat().st_size,
+            modify_time=path_obj.stat().st_mtime,
+        ))
+        return ret_items
+
+    # 扁历所有目录
+    for item in SystemUtils.list_sub_directory(path_obj):
+        ret_items.append(schemas.FileItem(
+            type="dir",
+            path=str(item).replace("\\", "/") + "/",
+            name=item.name,
+            basename=item.stem,
+            modify_time=item.stat().st_mtime,
+        ))
+
+    # 遍历所有文件，不含子目录
+    for item in SystemUtils.list_sub_files(path_obj,
+                                           settings.RMT_MEDIAEXT
+                                           + settings.RMT_SUBEXT
+                                           + IMAGE_TYPES
+                                           + [".nfo"]):
+        ret_items.append(schemas.FileItem(
+            type="file",
+            path=str(item).replace("\\", "/"),
+            name=item.name,
+            basename=item.stem,
+            extension=item.suffix[1:],
+            size=item.stat().st_size,
+            modify_time=item.stat().st_mtime,
+        ))
+    # 排序
+    if sort == 'time':
+        ret_items.sort(key=lambda x: x.modify_time, reverse=True)
+    else:
+        ret_items.sort(key=lambda x: x.name, reverse=False)
+    return ret_items
+
+
+@router.get("/mkdir", summary="创建目录", response_model=schemas.Response)
+def mkdir(path: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    创建目录
+    """
+    if not path:
+        return schemas.Response(success=False)
+    path_obj = Path(path)
+    if path_obj.exists():
+        return schemas.Response(success=False)
+    path_obj.mkdir(parents=True, exist_ok=True)
+    return schemas.Response(success=True)
+
+
+@router.get("/delete", summary="删除文件或目录", response_model=schemas.Response)
+def delete(path: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    删除文件或目录
+    """
+    if not path:
+        return schemas.Response(success=False)
+    path_obj = Path(path)
+    if not path_obj.exists():
+        return schemas.Response(success=True)
+    if path_obj.is_file():
+        path_obj.unlink()
+    else:
+        shutil.rmtree(path_obj, ignore_errors=True)
+    return schemas.Response(success=True)
+
+
+@router.get("/download", summary="下载文件或目录")
+def download(path: str, token: str) -> Any:
+    """
+    下载文件或目录
+    """
+    if not path:
+        return schemas.Response(success=False)
+    # 认证token
+    if not verify_token(token):
+        return None
+    path_obj = Path(path)
+    if not path_obj.exists():
+        return schemas.Response(success=False)
+    if path_obj.is_file():
+        # 做为文件流式下载
+        return FileResponse(path_obj)
+    else:
+        # 做为压缩包下载
+        shutil.make_archive(base_name=path_obj.stem, format="zip", root_dir=path_obj)
+        reponse = Response(content=path_obj.read_bytes(), media_type="application/zip")
+        # 删除压缩包
+        Path(f"{path_obj.stem}.zip").unlink()
+        return reponse
+
+
+@router.get("/rename", summary="重命名文件或目录", response_model=schemas.Response)
+def rename(path: str, new_name: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    重命名文件或目录
+    """
+    if not path or not new_name:
+        return schemas.Response(success=False)
+    path_obj = Path(path)
+    if not path_obj.exists():
+        return schemas.Response(success=False)
+    path_obj.rename(path_obj.parent / new_name)
+    return schemas.Response(success=True)
+
+
+@router.get("/image", summary="读取图片")
+def image(path: str, token: str) -> Any:
+    """
+    读取图片
+    """
+    if not path:
+        return None
+    # 认证token
+    if not verify_token(token):
+        return None
+    path_obj = Path(path)
+    if not path_obj.exists():
+        return None
+    if not path_obj.is_file():
+        return None
+    # 判断是否图片文件
+    if path_obj.suffix.lower() not in IMAGE_TYPES:
+        return None
+    return Response(content=path_obj.read_bytes(), media_type="image/jpeg")

app/api/endpoints/history.py

@@ -74,7 +74,8 @@ def delete_transfer_history(history_in: schemas.TransferHistory,
         if not history:
             return schemas.Response(success=False, msg="记录不存在")
         # 册除文件
-        TransferChain(db).delete_files(Path(history.dest))
+        if history.dest:
+            TransferChain(db).delete_files(Path(history.dest))
     # 删除记录
     TransferHistory.delete(db, history_in.id)
     return schemas.Response(success=True)

app/api/endpoints/login.py

@@ -56,6 +56,9 @@ async def login_access_token(
             user.id, expires_delta=access_token_expires
         ),
         token_type="bearer",
+        super_user=user.is_superuser,
+        user_name=user.name,
+        avatar=user.avatar
     )
 
 

app/api/endpoints/media.py

@@ -17,7 +17,7 @@ from app.schemas import MediaType
 router = APIRouter()
 
 
-@router.get("/recognize", summary="识别媒体信息", response_model=schemas.Context)
+@router.get("/recognize", summary="识别媒体信息（种子）", response_model=schemas.Context)
 def recognize(title: str,
               subtitle: str = None,
               db: Session = Depends(get_db),
@@ -32,6 +32,20 @@ def recognize(title: str,
     return schemas.Context()
 
 
+@router.get("/recognize_file", summary="识别媒体信息（文件）", response_model=schemas.Context)
+def recognize(path: str,
+              db: Session = Depends(get_db),
+              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据文件路径识别媒体信息
+    """
+    # 识别媒体信息
+    context = MediaChain(db).recognize_by_path(path)
+    if context:
+        return context.to_dict()
+    return schemas.Context()
+
+
 @router.get("/search", summary="搜索媒体信息", response_model=List[schemas.MediaInfo])
 def search_by_title(title: str,
                     page: int = 1,

app/api/endpoints/message.py

@@ -64,14 +64,13 @@ def wechat_verify(echostr: str, msg_signature: str,
 
 
 @router.get("/switchs", summary="查询通知消息渠道开关", response_model=List[NotificationSwitch])
-def read_switchs(db: Session = Depends(get_db),
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def read_switchs(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询通知消息渠道开关
     """
     return_list = []
     # 读取数据库
-    switchs = SystemConfigOper(db).get(SystemConfigKey.NotificationChannels)
+    switchs = SystemConfigOper().get(SystemConfigKey.NotificationChannels)
     if not switchs:
         for noti in NotificationType:
             return_list.append(NotificationSwitch(mtype=noti.value, wechat=True, telegram=True, slack=True))
@@ -83,7 +82,6 @@ def read_switchs(db: Session = Depends(get_db),
 
 @router.post("/switchs", summary="设置通知消息渠道开关", response_model=schemas.Response)
 def set_switchs(switchs: List[NotificationSwitch],
-                db: Session = Depends(get_db),
                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询通知消息渠道开关
@@ -92,6 +90,6 @@ def set_switchs(switchs: List[NotificationSwitch],
     for switch in switchs:
         switch_list.append(switch.dict())
     # 存入数据库
-    SystemConfigOper(db).set(SystemConfigKey.NotificationChannels, switch_list)
+    SystemConfigOper().set(SystemConfigKey.NotificationChannels, switch_list)
 
     return schemas.Response(success=True)

app/api/endpoints/plugin.py

@@ -22,28 +22,26 @@ def all_plugins(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/installed", summary="已安装插件", response_model=List[str])
-def installed_plugins(db: Session = Depends(get_db),
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def installed_plugins(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询用户已安装插件清单
     """
-    return SystemConfigOper(db).get(SystemConfigKey.UserInstalledPlugins) or []
+    return SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
 
 
 @router.get("/install/{plugin_id}", summary="安装插件", response_model=schemas.Response)
 def install_plugin(plugin_id: str,
-                   db: Session = Depends(get_db),
                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     安装插件
     """
     # 已安装插件
-    install_plugins = SystemConfigOper(db).get(SystemConfigKey.UserInstalledPlugins) or []
+    install_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
     # 安装插件
     if plugin_id not in install_plugins:
         install_plugins.append(plugin_id)
         # 保存设置
-        SystemConfigOper(db).set(SystemConfigKey.UserInstalledPlugins, install_plugins)
+        SystemConfigOper().set(SystemConfigKey.UserInstalledPlugins, install_plugins)
         # 重载插件管理器
         PluginManager().init_config()
     return schemas.Response(success=True)
@@ -93,19 +91,18 @@ def set_plugin_config(plugin_id: str, conf: dict,
 
 @router.delete("/{plugin_id}", summary="卸载插件", response_model=schemas.Response)
 def uninstall_plugin(plugin_id: str,
-                     db: Session = Depends(get_db),
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     卸载插件
     """
     # 删除已安装信息
-    install_plugins = SystemConfigOper(db).get(SystemConfigKey.UserInstalledPlugins) or []
+    install_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
     for plugin in install_plugins:
         if plugin == plugin_id:
             install_plugins.remove(plugin)
             break
     # 保存
-    SystemConfigOper(db).set(SystemConfigKey.UserInstalledPlugins, install_plugins)
+    SystemConfigOper().set(SystemConfigKey.UserInstalledPlugins, install_plugins)
     # 重载插件管理器
     PluginManager().init_config()
     return schemas.Response(success=True)

app/api/endpoints/rss.py

@@ -1,135 +0,0 @@
-from typing import List, Any
-
-from fastapi import APIRouter, Depends
-from sqlalchemy.orm import Session
-from starlette.background import BackgroundTasks
-
-from app import schemas
-from app.chain.rss import RssChain
-from app.core.security import verify_token
-from app.db import get_db
-from app.db.models.rss import Rss
-from app.helper.rss import RssHelper
-from app.schemas import MediaType
-
-router = APIRouter()
-
-
-def start_rss_refresh(db: Session, rssid: int = None):
-    """
-    启动自定义订阅刷新
-    """
-    RssChain(db).refresh(rssid=rssid, manual=True)
-
-
-@router.get("/", summary="所有自定义订阅", response_model=List[schemas.Rss])
-def read_rsses(
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询所有自定义订阅
-    """
-    return Rss.list(db)
-
-
-@router.post("/", summary="新增自定义订阅", response_model=schemas.Response)
-def create_rss(
-        *,
-        rss_in: schemas.Rss,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)
-) -> Any:
-    """
-    新增自定义订阅
-    """
-    if rss_in.type:
-        mtype = MediaType(rss_in.type)
-    else:
-        mtype = None
-    rssid, errormsg = RssChain(db).add(
-        mtype=mtype,
-        **rss_in.dict()
-    )
-    if not rssid:
-        return schemas.Response(success=False, message=errormsg)
-    return schemas.Response(success=True, data={
-        "id": rssid
-    })
-
-
-@router.put("/", summary="更新自定义订阅", response_model=schemas.Response)
-def update_rss(
-        *,
-        rss_in: schemas.Rss,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)
-) -> Any:
-    """
-    更新自定义订阅信息
-    """
-    rss = Rss.get(db, rss_in.id)
-    if not rss:
-        return schemas.Response(success=False, message="自定义订阅不存在")
-
-    rss.update(db, rss_in.dict())
-    return schemas.Response(success=True)
-
-
-@router.get("/preview/{rssid}", summary="预览自定义订阅", response_model=List[schemas.TorrentInfo])
-def preview_rss(
-        rssid: int,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    根据ID查询自定义订阅RSS报文
-    """
-    rssinfo: Rss = Rss.get(db, rssid)
-    if not rssinfo:
-        return []
-    torrents = RssHelper.parse(rssinfo.url, proxy=True if rssinfo.proxy else False) or []
-    return [schemas.TorrentInfo(
-        title=t.get("title"),
-        description=t.get("description"),
-        enclosure=t.get("enclosure"),
-        size=t.get("size"),
-        page_url=t.get("link"),
-        pubdate=t["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if t.get("pubdate") else None,
-    ) for t in torrents]
-
-
-@router.get("/refresh/{rssid}", summary="刷新自定义订阅", response_model=schemas.Response)
-def refresh_rss(
-        rssid: int,
-        background_tasks: BackgroundTasks,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    根据ID刷新自定义订阅
-    """
-    background_tasks.add_task(start_rss_refresh,
-                              db=db,
-                              rssid=rssid)
-    return schemas.Response(success=True)
-
-
-@router.get("/{rssid}", summary="查询自定义订阅详情", response_model=schemas.Rss)
-def read_rss(
-        rssid: int,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    根据ID查询自定义订阅详情
-    """
-    return Rss.get(db, rssid)
-
-
-@router.delete("/{rssid}", summary="删除自定义订阅", response_model=schemas.Response)
-def read_rss(
-        rssid: int,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    根据ID删除自定义订阅
-    """
-    Rss.delete(db, rssid)
-    return schemas.Response(success=True)

app/api/endpoints/search.py

@@ -1,6 +1,6 @@
 from typing import List, Any
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
@@ -42,7 +42,7 @@ def search_by_tmdbid(mediaid: str,
         # 识别豆瓣信息
         context = DoubanChain(db).recognize_by_doubanid(doubanid)
         if not context or not context.media_info or not context.media_info.tmdb_id:
-            raise HTTPException(status_code=404, detail="无法识别TMDB媒体信息！")
+            return []
         torrents = SearchChain(db).search_by_tmdbid(tmdbid=context.media_info.tmdb_id,
                                                     mtype=context.media_info.type,
                                                     area=area)

app/api/endpoints/site.py

@@ -6,8 +6,8 @@ from starlette.background import BackgroundTasks
 
 from app import schemas
 from app.chain.cookiecloud import CookieCloudChain
-from app.chain.search import SearchChain
 from app.chain.site import SiteChain
+from app.chain.torrents import TorrentsChain
 from app.core.event import EventManager
 from app.core.security import verify_token
 from app.db import get_db
@@ -117,8 +117,9 @@ def cookie_cloud_sync(db: Session = Depends(get_db),
     清空所有站点数据并重新同步CookieCloud站点信息
     """
     Site.reset(db)
-    SystemConfigOper(db).set(SystemConfigKey.IndexerSites, [])
-    CookieCloudChain(db).process(manual=True)
+    SystemConfigOper().set(SystemConfigKey.IndexerSites, [])
+    SystemConfigOper().set(SystemConfigKey.RssSites, [])
+    CookieCloudChain().process(manual=True)
     # 插件站点删除
     EventManager().send_event(EventType.SiteDeleted,
                               {
@@ -190,7 +191,7 @@ def site_icon(site_id: int,
 
 
 @router.get("/resource/{site_id}", summary="站点资源", response_model=List[schemas.TorrentInfo])
-def site_resource(site_id: int, keyword: str = None,
+def site_resource(site_id: int,
                   db: Session = Depends(get_db),
                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -202,7 +203,7 @@ def site_resource(site_id: int, keyword: str = None,
             status_code=404,
             detail=f"站点 {site_id} 不存在",
         )
-    torrents = SearchChain(db).browse(site.domain, keyword)
+    torrents = TorrentsChain().browse(domain=site.domain)
     if not torrents:
         return []
     return [torrent.to_dict() for torrent in torrents]
@@ -227,6 +228,23 @@ def read_site_by_domain(
     return site
 
 
+@router.get("/rss", summary="所有订阅站点", response_model=List[schemas.Site])
+def read_rss_sites(db: Session = Depends(get_db)) -> List[dict]:
+    """
+    获取站点列表
+    """
+    # 选中的rss站点
+    selected_sites = SystemConfigOper().get(SystemConfigKey.RssSites) or []
+    # 所有站点
+    all_site = Site.list_order_by_pri(db)
+    if not selected_sites or not all_site:
+        return []
+
+    # 选中的rss站点
+    rss_sites = [site for site in all_site if site and site.id in selected_sites]
+    return rss_sites
+
+
 @router.get("/{site_id}", summary="站点详情", response_model=schemas.Site)
 def read_site(
         site_id: int,

app/api/endpoints/subscribe.py

@@ -138,6 +138,53 @@ def subscribe_mediaid(
     return result if result else Subscribe()
 
 
+@router.get("/refresh", summary="刷新订阅", response_model=schemas.Response)
+def refresh_subscribes(
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    刷新所有订阅
+    """
+    SubscribeChain(db).refresh()
+    return schemas.Response(success=True)
+
+
+@router.get("/check", summary="刷新订阅 TMDB 信息", response_model=schemas.Response)
+def check_subscribes(
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    刷新所有订阅
+    """
+    SubscribeChain(db).check()
+    return schemas.Response(success=True)
+
+
+@router.get("/search", summary="搜索所有订阅", response_model=schemas.Response)
+def search_subscribes(
+        background_tasks: BackgroundTasks,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    搜索所有订阅
+    """
+    background_tasks.add_task(start_subscribe_search, db=db, sid=None, state='R')
+    return schemas.Response(success=True)
+
+
+@router.get("/search/{subscribe_id}", summary="搜索订阅", response_model=schemas.Response)
+def search_subscribe(
+        subscribe_id: int,
+        background_tasks: BackgroundTasks,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据订阅编号搜索订阅
+    """
+    background_tasks.add_task(start_subscribe_search, db=db, sid=subscribe_id, state=None)
+    return schemas.Response(success=True)
+
+
 @router.get("/{subscribe_id}", summary="订阅详情", response_model=schemas.Subscribe)
 def read_subscribe(
         subscribe_id: int,
@@ -243,39 +290,3 @@ async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
                                       username=user_name)
 
     return schemas.Response(success=True)
-
-
-@router.get("/refresh", summary="刷新订阅", response_model=schemas.Response)
-def refresh_subscribes(
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    刷新所有订阅
-    """
-    SubscribeChain(db).refresh()
-    return schemas.Response(success=True)
-
-
-@router.get("/search/{subscribe_id}", summary="搜索订阅", response_model=schemas.Response)
-def search_subscribe(
-        subscribe_id: int,
-        background_tasks: BackgroundTasks,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    搜索所有订阅
-    """
-    background_tasks.add_task(start_subscribe_search, db=db, sid=subscribe_id, state=None)
-    return schemas.Response(success=True)
-
-
-@router.get("/search", summary="搜索所有订阅", response_model=schemas.Response)
-def search_subscribes(
-        background_tasks: BackgroundTasks,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    搜索所有订阅
-    """
-    background_tasks.add_task(start_subscribe_search, db=db, sid=None, state='R')
-    return schemas.Response(success=True)

app/api/endpoints/system.py

@@ -9,20 +9,23 @@ from fastapi.responses import StreamingResponse
 from sqlalchemy.orm import Session
 
 from app import schemas
+from app.chain.search import SearchChain
 from app.core.config import settings
 from app.core.security import verify_token
 from app.db import get_db
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.message import MessageHelper
 from app.helper.progress import ProgressHelper
+from app.schemas.types import SystemConfigKey
 from app.utils.http import RequestUtils
+from app.utils.system import SystemUtils
 from version import APP_VERSION
 
 router = APIRouter()
 
 
 @router.get("/env", summary="查询系统环境变量", response_model=schemas.Response)
-def get_setting(_: schemas.TokenPayload = Depends(verify_token)):
+def get_env_setting(_: schemas.TokenPayload = Depends(verify_token)):
     """
     查询系统环境变量，包括当前版本号
     """
@@ -60,29 +63,27 @@ def get_progress(process_type: str, token: str):
 
 @router.get("/setting/{key}", summary="查询系统设置", response_model=schemas.Response)
 def get_setting(key: str,
-                db: Session = Depends(get_db),
                 _: schemas.TokenPayload = Depends(verify_token)):
     """
     查询系统设置
     """
     return schemas.Response(success=True, data={
-        "value": SystemConfigOper(db).get(key)
+        "value": SystemConfigOper().get(key)
     })
 
 
 @router.post("/setting/{key}", summary="更新系统设置", response_model=schemas.Response)
 def set_setting(key: str, value: Union[list, dict, str, int] = None,
-                db: Session = Depends(get_db),
                 _: schemas.TokenPayload = Depends(verify_token)):
     """
     更新系统设置
     """
-    SystemConfigOper(db).set(key, value)
+    SystemConfigOper().set(key, value)
     return schemas.Response(success=True)
 
 
 @router.get("/message", summary="实时消息")
-def get_progress(token: str):
+def get_message(token: str):
     """
     实时获取系统消息，返回格式为SSE
     """
@@ -166,3 +167,45 @@ def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
         if ver_json:
             return schemas.Response(success=True, data=ver_json)
     return schemas.Response(success=False)
+
+
+@router.get("/ruletest", summary="过滤规则测试", response_model=schemas.Response)
+def ruletest(title: str,
+             subtitle: str = None,
+             ruletype: str = None,
+             db: Session = Depends(get_db),
+             _: schemas.TokenPayload = Depends(verify_token)):
+    """
+    过滤规则测试，规则类型 1-订阅，2-洗版
+    """
+    torrent = schemas.TorrentInfo(
+        title=title,
+        description=subtitle,
+    )
+    if ruletype == "2":
+        rule_string = SystemConfigOper().get(SystemConfigKey.FilterRules2)
+    else:
+        rule_string = SystemConfigOper().get(SystemConfigKey.FilterRules)
+    if not rule_string:
+        return schemas.Response(success=False, message="过滤规则未设置！")
+
+    # 过滤
+    result = SearchChain(db).filter_torrents(rule_string=rule_string,
+                                             torrent_list=[torrent])
+    if not result:
+        return schemas.Response(success=False, message="不符合过滤规则！")
+    return schemas.Response(success=True, data={
+        "priority": 100 - result[0].pri_order + 1
+    })
+
+
+@router.get("/restart", summary="重启系统", response_model=schemas.Response)
+def restart_system(_: schemas.TokenPayload = Depends(verify_token)):
+    """
+    重启系统
+    """
+    if not SystemUtils.can_restart():
+        return schemas.Response(success=False, message="当前运行环境不支持重启操作！")
+    # 执行重启
+    ret, msg = SystemUtils.restart()
+    return schemas.Response(success=ret, message=msg)

app/api/endpoints/transfer.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app import schemas
+from app.chain.transfer import TransferChain
+from app.core.security import verify_token
+from app.db import get_db
+from app.schemas import MediaType
+
+router = APIRouter()
+
+
+@router.post("/manual", summary="手动转移", response_model=schemas.Response)
+def manual_transfer(path: str,
+                    target: str = None,
+                    tmdbid: int = None,
+                    type_name: str = None,
+                    season: int = None,
+                    transfer_type: str = None,
+                    episode_format: str = None,
+                    episode_detail: str = None,
+                    episode_part: str = None,
+                    episode_offset: int = 0,
+                    min_filesize: int = 0,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    手动转移，支持自定义剧集识别格式
+    :param path: 转移路径或文件
+    :param target: 目标路径
+    :param type_name: 媒体类型、电影/电视剧
+    :param tmdbid: tmdbid
+    :param season: 剧集季号
+    :param transfer_type: 转移类型，move/copy
+    :param episode_format: 剧集识别格式
+    :param episode_detail: 剧集识别详细信息
+    :param episode_part: 剧集识别分集信息
+    :param episode_offset: 剧集识别偏移量
+    :param min_filesize: 最小文件大小(MB)
+    :param db: 数据库
+    :param _: Token校验
+    """
+    in_path = Path(path)
+    if target:
+        target = Path(target)
+        if not target.exists():
+            return schemas.Response(success=False, message=f"目标路径不存在")
+    # 类型
+    mtype = MediaType(type_name) if type_name else None
+    # 自定义格式
+    epformat = None
+    if episode_offset or episode_part or episode_detail or episode_format:
+        epformat = schemas.EpisodeFormat(
+            format=episode_format,
+            detail=episode_detail,
+            part=episode_part,
+            offset=episode_offset,
+        )
+    # 开始转移
+    state, errormsg = TransferChain(db).manual_transfer(
+        in_path=in_path,
+        target=target,
+        tmdbid=tmdbid,
+        mtype=mtype,
+        season=season,
+        transfer_type=transfer_type,
+        epformat=epformat,
+        min_filesize=min_filesize
+    )
+    # 失败
+    if not state:
+        if isinstance(errormsg, list):
+            errormsg = f"整理完成，{len(errormsg)} 个文件转移失败！"
+        return schemas.Response(success=False, message=errormsg)
+    # 成功
+    return schemas.Response(success=True)

app/api/servarr.py

@@ -132,13 +132,10 @@ def arr_rootfolder(apikey: str) -> Any:
             status_code=403,
             detail="认证失败！",
         )
-    library_path = "/"
-    if settings.LIBRARY_PATH:
-        library_path = settings.LIBRARY_PATH.split(",")[0]
     return [
         {
             "id": 1,
-            "path": library_path,
+            "path": "/" if not settings.LIBRARY_PATHS else str(settings.LIBRARY_PATHS[0]),
             "accessible": True,
             "freeSpace": 0,
             "unmappedFolders": []

app/chain/__init__.py

@@ -197,7 +197,7 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("search_medias", meta=meta)
 
     def search_torrents(self, site: CommentedMap,
-                        mediainfo: Optional[MediaInfo] = None,
+                        mediainfo: MediaInfo,
                         keyword: str = None,
                         page: int = 0,
                         area: str = "title") -> List[TorrentInfo]:
@@ -234,32 +234,31 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("filter_torrents", rule_string=rule_string,
                                torrent_list=torrent_list, season_episodes=season_episodes)
 
-    def download(self, torrent_path: Path, download_dir: Path, cookie: str,
-                 episodes: Set[int] = None,
+    def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
+                 episodes: Set[int] = None, category: str = None
                  ) -> Optional[Tuple[Optional[str], str]]:
         """
         根据种子文件，选择并添加下载任务
-        :param torrent_path:  种子文件地址
+        :param content:  种子文件地址或者磁力链接
         :param download_dir:  下载目录
         :param cookie:  cookie
         :param episodes:  需要下载的集数
+        :param category:  种子分类
         :return: 种子Hash，错误信息
         """
-        return self.run_module("download", torrent_path=torrent_path, download_dir=download_dir,
-                               cookie=cookie, episodes=episodes, )
+        return self.run_module("download", content=content, download_dir=download_dir,
+                               cookie=cookie, episodes=episodes, category=category)
 
-    def download_added(self, context: Context, torrent_path: Path, download_dir: Path) -> None:
+    def download_added(self, context: Context, download_dir: Path, torrent_path: Path = None) -> None:
         """
         添加下载任务成功后，从站点下载字幕，保存到下载目录
         :param context:  上下文，包括识别信息、媒体信息、种子信息
-        :param torrent_path:  种子文件地址
         :param download_dir:  下载目录
+        :param torrent_path:  种子文件地址
         :return: None，该方法可被多个模块同时处理
         """
-        if settings.DOWNLOAD_SUBTITLE:
-            return self.run_module("download_added", context=context, torrent_path=torrent_path,
-                                   download_dir=download_dir)
-        return None
+        return self.run_module("download_added", context=context, torrent_path=torrent_path,
+                               download_dir=download_dir)
 
     def list_torrents(self, status: TorrentStatus = None,
                       hashs: Union[list, str] = None) -> Optional[List[Union[TransferTorrent, DownloadingTorrent]]]:
@@ -271,29 +270,27 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("list_torrents", status=status, hashs=hashs)
 
-    def transfer(self, path: Path, mediainfo: MediaInfo,
-                 transfer_type: str,
-                 target: Path = None,
-                 meta: MetaBase = None) -> Optional[TransferInfo]:
+    def transfer(self, path: Path, meta: MetaBase, mediainfo: MediaInfo,
+                 transfer_type: str, target: Path = None) -> Optional[TransferInfo]:
         """
         文件转移
         :param path:  文件路径
+        :param meta: 预识别的元数据
         :param mediainfo:  识别的媒体信息
         :param transfer_type:  转移模式
         :param target:  转移目标路径
-        :param meta: 预识别的元数据，仅单文件转移时传递
         :return: {path, target_path, message}
         """
-        return self.run_module("transfer", path=path, mediainfo=mediainfo,
-                               transfer_type=transfer_type, target=target, meta=meta)
+        return self.run_module("transfer", path=path, meta=meta, mediainfo=mediainfo,
+                               transfer_type=transfer_type, target=target)
 
-    def transfer_completed(self, hashs: Union[str, list], transinfo: TransferInfo = None) -> None:
+    def transfer_completed(self, hashs: Union[str, list], path: Path = None) -> None:
         """
         转移完成后的处理
         :param hashs:  种子Hash
-        :param transinfo:  转移信息
+        :param path:  源目录
         """
-        return self.run_module("transfer_completed", hashs=hashs, transinfo=transinfo)
+        return self.run_module("transfer_completed", hashs=hashs, path=path)
 
     def remove_torrents(self, hashs: Union[str, list]) -> bool:
         """
@@ -343,9 +340,7 @@ class ChainBase(metaclass=ABCMeta):
         :param file_path:  文件路径
         :return: 成功或失败
         """
-        if settings.REFRESH_MEDIASERVER:
-            return self.run_module("refresh_mediaserver", mediainfo=mediainfo, file_path=file_path)
-        return None
+        return self.run_module("refresh_mediaserver", mediainfo=mediainfo, file_path=file_path)
 
     def post_message(self, message: Notification) -> None:
         """
@@ -393,11 +388,9 @@ class ChainBase(metaclass=ABCMeta):
         :param mediainfo:  识别的媒体信息
         :return: 成功或失败
         """
-        if settings.SCRAP_METADATA:
-            return self.run_module("scrape_metadata", path=path, mediainfo=mediainfo)
-        return None
+        return self.run_module("scrape_metadata", path=path, mediainfo=mediainfo)
 
-    def register_commands(self, commands: dict) -> None:
+    def register_commands(self, commands: Dict[str, dict]) -> None:
         """
         注册菜单命令
         """

app/chain/cookiecloud.py

@@ -13,6 +13,7 @@ from app.db.siteicon_oper import SiteIconOper
 from app.helper.cloudflare import under_challenge
 from app.helper.cookiecloud import CookieCloudHelper
 from app.helper.message import MessageHelper
+from app.helper.rss import RssHelper
 from app.helper.sites import SitesHelper
 from app.log import logger
 from app.schemas import Notification, NotificationType, MessageChannel
@@ -30,6 +31,7 @@ class CookieCloudChain(ChainBase):
         self.siteoper = SiteOper(self._db)
         self.siteiconoper = SiteIconOper(self._db)
         self.siteshelper = SitesHelper()
+        self.rsshelper = RssHelper()
         self.sitechain = SiteChain(self._db)
         self.message = MessageHelper()
         self.cookiecloud = CookieCloudHelper(
@@ -78,8 +80,23 @@ class CookieCloudChain(ChainBase):
                 # 更新站点Cookie
                 if status:
                     logger.info(f"站点【{site_info.name}】连通性正常，不同步CookieCloud数据")
+                    # 更新站点rss地址
+                    if not site_info.public and not site_info.rss:
+                        # 自动生成rss地址
+                        rss_url, errmsg = self.rsshelper.get_rss_link(
+                            url=site_info.url,
+                            cookie=cookie,
+                            ua=settings.USER_AGENT,
+                            proxy=True if site_info.proxy else False
+                        )
+                        if rss_url:
+                            logger.info(f"更新站点 {domain} RSS地址 ...")
+                            self.siteoper.update_rss(domain=domain, rss=rss_url)
+                        else:
+                            logger.warn(errmsg)
                     continue
                 # 更新站点Cookie
+                logger.info(f"更新站点 {domain} Cookie ...")
                 self.siteoper.update_cookie(domain=domain, cookies=cookie)
                 _update_count += 1
             elif indexer:
@@ -104,12 +121,25 @@ class CookieCloudChain(ChainBase):
                     _fail_count += 1
                     logger.warn(f"站点 {indexer.get('name')} 连接失败，无法添加站点")
                     continue
+                # 获取rss地址
+                rss_url = None
+                if not indexer.get("public") and indexer.get("domain"):
+                    # 自动生成rss地址
+                    rss_url, errmsg = self.rsshelper.get_rss_link(url=indexer.get("domain"),
+                                                                  cookie=cookie,
+                                                                  ua=settings.USER_AGENT)
+                    if errmsg:
+                        logger.warn(errmsg)
+                # 插入数据库
+                logger.info(f"新增站点 {indexer.get('name')} ...")
                 self.siteoper.add(name=indexer.get("name"),
                                   url=indexer.get("domain"),
                                   domain=domain,
                                   cookie=cookie,
+                                  rss=rss_url,
                                   public=1 if indexer.get("public") else 0)
                 _add_count += 1
+
             # 保存站点图标
             if indexer:
                 site_icon = self.siteiconoper.get_by_domain(domain)

app/chain/download.py

@@ -8,6 +8,7 @@ from app.chain import ChainBase
 from app.core.config import settings
 from app.core.context import MediaInfo, TorrentInfo, Context
 from app.core.meta import MetaBase
+from app.core.metainfo import MetaInfo
 from app.db.downloadhistory_oper import DownloadHistoryOper
 from app.db.mediaserver_oper import MediaServerOper
 from app.helper.torrent import TorrentHelper
@@ -47,9 +48,12 @@ class DownloadChain(ChainBase):
             msg_text = f"{msg_text}\n大小：{size}"
         if torrent.title:
             msg_text = f"{msg_text}\n种子：{torrent.title}"
+        if torrent.pubdate:
+            msg_text = f"{msg_text}\n发布时间：{torrent.pubdate}"
         if torrent.seeders:
             msg_text = f"{msg_text}\n做种数：{torrent.seeders}"
-        msg_text = f"{msg_text}\n促销：{torrent.volume_factor}"
+        if torrent.uploadvolumefactor and torrent.downloadvolumefactor:
+            msg_text = f"{msg_text}\n促销：{torrent.volume_factor}"
         if torrent.hit_and_run:
             msg_text = f"{msg_text}\nHit&Run：是"
         if torrent.description:
@@ -69,25 +73,33 @@ class DownloadChain(ChainBase):
 
     def download_torrent(self, torrent: TorrentInfo,
                          channel: MessageChannel = None,
-                         userid: Union[str, int] = None) -> Tuple[Optional[Path], str, list]:
+                         userid: Union[str, int] = None
+                         ) -> Tuple[Optional[Union[Path, str]], str, list]:
         """
-        下载种子文件
+        下载种子文件，如果是磁力链，会返回磁力链接本身
         :return: 种子路径，种子目录名，种子文件清单
         """
-        torrent_file, _, download_folder, files, error_msg = self.torrent.download_torrent(
+        torrent_file, content, download_folder, files, error_msg = self.torrent.download_torrent(
             url=torrent.enclosure,
             cookie=torrent.site_cookie,
             ua=torrent.site_ua,
             proxy=torrent.site_proxy)
+
+        if isinstance(content, str):
+            # 磁力链
+            return content, "", []
+
         if not torrent_file:
             logger.error(f"下载种子文件失败：{torrent.title} - {torrent.enclosure}")
             self.post_message(Notification(
                 channel=channel,
                 mtype=NotificationType.Manual,
                 title=f"{torrent.title} 种子下载失败！",
-                text=f"错误信息：{error_msg}\n种子链接：{torrent.enclosure}",
+                text=f"错误信息：{error_msg}\n站点：{torrent.site_name}",
                 userid=userid))
             return None, "", []
+
+        # 返回 种子文件路径，种子目录名，种子文件清单
         return torrent_file, download_folder, files
 
     def download_single(self, context: Context, torrent_file: Path = None,
@@ -97,46 +109,85 @@ class DownloadChain(ChainBase):
                         userid: Union[str, int] = None) -> Optional[str]:
         """
         下载及发送通知
+        :param context: 资源上下文
+        :param torrent_file: 种子文件路径
+        :param episodes: 需要下载的集数
+        :param channel: 通知渠道
+        :param save_path: 保存路径
+        :param userid: 用户ID
         """
         _torrent = context.torrent_info
         _media = context.media_info
         _meta = context.meta_info
         _folder_name = ""
         if not torrent_file:
-            # 下载种子文件
-            torrent_file, _folder_name, _ = self.download_torrent(_torrent, userid=userid)
-            if not torrent_file:
+            # 下载种子文件，得到的可能是文件也可能是磁力链
+            content, _folder_name, _file_list = self.download_torrent(_torrent, userid=userid)
+            if not content:
                 return
+        else:
+            content = torrent_file
+            # 获取种子文件的文件夹名和文件清单
+            _folder_name, _file_list = self.torrent.get_torrent_info(torrent_file)
+
         # 下载目录
         if not save_path:
             if settings.DOWNLOAD_CATEGORY and _media and _media.category:
+                # 开启下载二级目录
                 if _media.type == MediaType.MOVIE:
+                    # 电影
                     download_dir = Path(settings.DOWNLOAD_MOVIE_PATH or settings.DOWNLOAD_PATH) / _media.category
                 else:
-                    download_dir = Path(settings.DOWNLOAD_TV_PATH or settings.DOWNLOAD_PATH) / _media.category
+                    if settings.DOWNLOAD_ANIME_PATH \
+                            and _media.genre_ids \
+                            and set(_media.genre_ids).intersection(set(settings.ANIME_GENREIDS)):
+                        # 动漫
+                        download_dir = Path(settings.DOWNLOAD_ANIME_PATH)
+                    else:
+                        # 电视剧
+                        download_dir = Path(settings.DOWNLOAD_TV_PATH or settings.DOWNLOAD_PATH) / _media.category
             elif _media:
+                # 未开启下载二级目录
                 if _media.type == MediaType.MOVIE:
+                    # 电影
                     download_dir = Path(settings.DOWNLOAD_MOVIE_PATH or settings.DOWNLOAD_PATH)
                 else:
-                    download_dir = Path(settings.DOWNLOAD_TV_PATH or settings.DOWNLOAD_PATH)
+                    if settings.DOWNLOAD_ANIME_PATH \
+                            and _media.genre_ids \
+                            and set(_media.genre_ids).intersection(set(settings.ANIME_GENREIDS)):
+                        # 动漫
+                        download_dir = Path(settings.DOWNLOAD_ANIME_PATH)
+                    else:
+                        # 电视剧
+                        download_dir = Path(settings.DOWNLOAD_TV_PATH or settings.DOWNLOAD_PATH)
             else:
+                # 未识别
                 download_dir = Path(settings.DOWNLOAD_PATH)
         else:
+            # 自定义下载目录
             download_dir = Path(save_path)
+
         # 添加下载
-        result: Optional[tuple] = self.download(torrent_path=torrent_file,
+        result: Optional[tuple] = self.download(content=content,
                                                 cookie=_torrent.site_cookie,
                                                 episodes=episodes,
-                                                download_dir=download_dir)
+                                                download_dir=download_dir,
+                                                category=_media.category)
         if result:
             _hash, error_msg = result
         else:
             _hash, error_msg = None, "未知错误"
 
         if _hash:
+            # 下载文件路径
+            if _folder_name:
+                download_path = download_dir / _folder_name
+            else:
+                download_path = download_dir / _file_list[0] if _file_list else download_dir
+
             # 登记下载记录
             self.downloadhis.add(
-                path=_folder_name or _torrent.title,
+                path=str(download_path),
                 type=_media.type.value,
                 title=_media.title,
                 year=_media.year,
@@ -152,14 +203,34 @@ class DownloadChain(ChainBase):
                 torrent_description=_torrent.description,
                 torrent_site=_torrent.site_name
             )
+
+            # 登记下载文件
+            files_to_add = []
+            for file in _file_list:
+                if episodes:
+                    # 识别文件集
+                    file_meta = MetaInfo(Path(file).stem)
+                    if not file_meta.begin_episode \
+                            or file_meta.begin_episode not in episodes:
+                        continue
+                files_to_add.append({
+                    "download_hash": _hash,
+                    "downloader": settings.DOWNLOADER,
+                    "fullpath": str(download_dir / _folder_name / file),
+                    "savepath": str(download_dir / _folder_name),
+                    "filepath": file,
+                    "torrentname": _meta.org_string,
+                })
+            if files_to_add:
+                self.downloadhis.add_files(files_to_add)
+
             # 发送消息
             self.post_download_message(meta=_meta, mediainfo=_media, torrent=_torrent, channel=channel)
             # 下载成功后处理
-            self.download_added(context=context, torrent_path=torrent_file, download_dir=download_dir)
+            self.download_added(context=context, download_dir=download_dir, torrent_path=torrent_file)
             # 广播事件
             self.eventmanager.send_event(EventType.DownloadAdded, {
                 "hash": _hash,
-                "torrent_file": torrent_file,
                 "context": context
             })
         else:
@@ -173,7 +244,6 @@ class DownloadChain(ChainBase):
                       % (_media.title_year, _meta.season_episode),
                 text=f"站点：{_torrent.site_name}\n"
                      f"种子名称：{_meta.org_string}\n"
-                     f"种子链接：{_torrent.enclosure}\n"
                      f"错误信息：{error_msg}",
                 image=_media.get_message_image(),
                 userid=userid))
@@ -241,10 +311,10 @@ class DownloadChain(ChainBase):
             获取需要的季的集数
             """
             if not no_exists.get(tmdbid):
-                return 0
+                return 9999
             no_exist = no_exists.get(tmdbid)
             if not no_exist.get(season):
-                return 0
+                return 9999
             return no_exist[season].total_episode
 
         # 分组排序
@@ -294,22 +364,34 @@ class DownloadChain(ChainBase):
                         if set(torrent_season).issubset(set(need_season)):
                             if len(torrent_season) == 1:
                                 # 只有一季的可能是命名错误，需要打开种子鉴别，只有实际集数大于等于总集数才下载
-                                torrent_path, _, torrent_files = self.download_torrent(torrent)
-                                if not torrent_path:
+                                content, _, torrent_files = self.download_torrent(torrent)
+                                if not content:
+                                    continue
+                                if isinstance(content, str):
+                                    logger.warn(f"{meta.org_string} 下载地址是磁力链，无法确定种子文件集数")
                                     continue
                                 torrent_episodes = self.torrent.get_torrent_episodes(torrent_files)
-                                if not torrent_episodes \
-                                        or len(torrent_episodes) >= __get_season_episodes(need_tmdbid,
-                                                                                          torrent_season[0]):
-                                    # 下载
-                                    download_id = self.download_single(context=context,
-                                                                       torrent_file=torrent_path,
-                                                                       save_path=save_path,
-                                                                       userid=userid)
-                                else:
-                                    logger.info(
-                                        f"{meta.org_string} 解析文件集数为 {len(torrent_episodes)}，未含所需集数")
+                                logger.info(f"{meta.org_string} 解析文件集数为 {torrent_episodes}")
+                                if not torrent_episodes:
                                     continue
+                                # 总集数
+                                need_total = __get_season_episodes(need_tmdbid, torrent_season[0])
+                                if len(torrent_episodes) < need_total:
+                                    # 更新集数范围
+                                    begin_ep = min(torrent_episodes)
+                                    end_ep = max(torrent_episodes)
+                                    meta.set_episodes(begin=begin_ep, end=end_ep)
+                                    logger.info(
+                                        f"{meta.org_string} 解析文件集数发现不是完整合集")
+                                    continue
+                                else:
+                                    # 下载
+                                    download_id = self.download_single(
+                                        context=context,
+                                        torrent_file=content if isinstance(content, Path) else None,
+                                        save_path=save_path,
+                                        userid=userid
+                                    )
                             else:
                                 # 下载
                                 download_id = self.download_single(context, save_path=save_path, userid=userid)
@@ -426,22 +508,29 @@ class DownloadChain(ChainBase):
                                 and len(meta.season_list) == 1 \
                                 and meta.season_list[0] == need_season:
                             # 检查种子看是否有需要的集
-                            torrent_path, _, torrent_files = self.download_torrent(torrent, userid=userid)
-                            if not torrent_path:
+                            content, _, torrent_files = self.download_torrent(torrent, userid=userid)
+                            if not content:
+                                continue
+                            if isinstance(content, str):
+                                logger.warn(f"{meta.org_string} 下载地址是磁力链，无法解析种子文件集数")
                                 continue
                             # 种子全部集
                             torrent_episodes = self.torrent.get_torrent_episodes(torrent_files)
+                            logger.info(f"{torrent.site_name} - {meta.org_string} 解析文件集数：{torrent_episodes}")
                             # 选中的集
                             selected_episodes = set(torrent_episodes).intersection(set(need_episodes))
                             if not selected_episodes:
                                 logger.info(f"{torrent.site_name} - {torrent.title} 没有需要的集，跳过...")
                                 continue
+                            logger.info(f"{torrent.site_name} - {torrent.title} 选中集数：{selected_episodes}")
                             # 添加下载
-                            download_id = self.download_single(context=context,
-                                                               torrent_file=torrent_path,
-                                                               episodes=selected_episodes,
-                                                               save_path=save_path,
-                                                               userid=userid)
+                            download_id = self.download_single(
+                                context=context,
+                                torrent_file=content if isinstance(content, Path) else None,
+                                episodes=selected_episodes,
+                                save_path=save_path,
+                                userid=userid
+                            )
                             if not download_id:
                                 continue
                             # 把识别的集更新到上下文
@@ -460,13 +549,15 @@ class DownloadChain(ChainBase):
 
     def get_no_exists_info(self, meta: MetaBase,
                            mediainfo: MediaInfo,
-                           no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None
+                           no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
+                           totals: Dict[int, int] = None
                            ) -> Tuple[bool, Dict[int, Dict[int, NotExistMediaInfo]]]:
         """
         检查媒体库，查询是否存在，对于剧集同时返回不存在的季集信息
         :param meta: 元数据
         :param mediainfo: 已识别的媒体信息
         :param no_exists: 在调用该方法前已经存储的不存在的季集信息，有传入时该函数搜索的内容将会叠加后输出
+        :param totals: 电视剧每季的总集数
         :return: 当前媒体是否缺失，各标题总的季集和缺失的季集
         """
 
@@ -499,6 +590,10 @@ class DownloadChain(ChainBase):
 
         if not no_exists:
             no_exists = {}
+
+        if not totals:
+            totals = {}
+
         if mediainfo.type == MediaType.MOVIE:
             # 电影
             itemid = self.mediaserver.get_item_id(mtype=mediainfo.type.value,
@@ -523,40 +618,54 @@ class DownloadChain(ChainBase):
             itemid = self.mediaserver.get_item_id(mtype=mediainfo.type.value,
                                                   tmdbid=mediainfo.tmdb_id,
                                                   season=mediainfo.season)
+            # 媒体库已存在的剧集
             exists_tvs: Optional[ExistMediaInfo] = self.media_exists(mediainfo=mediainfo, itemid=itemid)
             if not exists_tvs:
-                # 所有剧集均缺失
+                # 所有季集均缺失
                 for season, episodes in mediainfo.seasons.items():
                     if not episodes:
                         continue
                     # 全季不存在
-                    if meta.begin_season \
+                    if meta.season_list \
                             and season not in meta.season_list:
                         continue
-                    __append_no_exists(_season=season, _episodes=[], _total=len(episodes), _start=min(episodes))
+                    # 总集数
+                    total_ep = totals.get(season) or len(episodes)
+                    __append_no_exists(_season=season, _episodes=[],
+                                       _total=total_ep, _start=min(episodes))
                 return False, no_exists
             else:
-                # 存在一些，检查缺失的季集
+                # 存在一些，检查每季缺失的季集
                 for season, episodes in mediainfo.seasons.items():
                     if meta.begin_season \
                             and season not in meta.season_list:
                         continue
                     if not episodes:
                         continue
-                    exist_seasons = exists_tvs.seasons
-                    if exist_seasons.get(season):
-                        # 取差集
-                        lack_episodes = list(set(episodes).difference(set(exist_seasons[season])))
+                    # 该季总集数
+                    season_total = totals.get(season) or len(episodes)
+                    # 该季已存在的集
+                    exist_episodes = exists_tvs.seasons.get(season)
+                    if exist_episodes:
+                        # 已存在取差集
+                        if totals.get(season):
+                            # 按总集数计算缺失集（开始集为TMDB中的最小集）
+                            lack_episodes = list(set(range(min(episodes),
+                                                           season_total + min(episodes))
+                                                     ).difference(set(exist_episodes)))
+                        else:
+                            # 按TMDB集数计算缺失集
+                            lack_episodes = list(set(episodes).difference(set(exist_episodes)))
                         if not lack_episodes:
                             # 全部集存在
                             continue
                         # 添加不存在的季集信息
                         __append_no_exists(_season=season, _episodes=lack_episodes,
-                                           _total=len(episodes), _start=min(episodes))
+                                           _total=season_total, _start=min(lack_episodes))
                     else:
                         # 全季不存在
                         __append_no_exists(_season=season, _episodes=[],
-                                           _total=len(episodes), _start=min(episodes))
+                                           _total=season_total, _start=min(episodes))
             # 存在不完整的剧集
             if no_exists:
                 logger.debug(f"媒体库中已存在部分剧集，缺失：{no_exists}")
@@ -573,7 +682,8 @@ class DownloadChain(ChainBase):
             self.post_message(Notification(
                 channel=channel,
                 mtype=NotificationType.Download,
-                title="没有正在下载的任务！"))
+                title="没有正在下载的任务！",
+                userid=userid))
             return
         # 发送消息
         title = f"共 {len(torrents)} 个任务正在下载："
@@ -582,7 +692,7 @@ class DownloadChain(ChainBase):
         for torrent in torrents:
             messages.append(f"{index}. {torrent.title} "
                             f"{StringUtils.str_filesize(torrent.size)} "
-                            f"{round(torrent.progress * 100, 1)}%")
+                            f"{round(torrent.progress, 1)}%")
             index += 1
         self.post_message(Notification(
             channel=channel, mtype=NotificationType.Download,

app/chain/media.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import Optional, List, Tuple
 
 from app.chain import ChainBase
@@ -31,6 +32,29 @@ class MediaChain(ChainBase):
         # 返回上下文
         return Context(meta_info=metainfo, media_info=mediainfo)
 
+    def recognize_by_path(self, path: str) -> Optional[Context]:
+        """
+        根据文件路径识别媒体信息
+        """
+        logger.info(f'开始识别媒体信息，文件：{path} ...')
+        file_path = Path(path)
+        # 上级目录元数据
+        dir_meta = MetaInfo(title=file_path.parent.name)
+        # 文件元数据，不包含后缀
+        file_meta = MetaInfo(title=file_path.stem)
+        # 合并元数据
+        file_meta.merge(dir_meta)
+        # 识别媒体信息
+        mediainfo = self.recognize_media(meta=file_meta)
+        if not mediainfo:
+            logger.warn(f'{path} 未识别到媒体信息')
+            return Context(meta_info=file_meta)
+        logger.info(f'{path} 识别到媒体信息：{mediainfo.type.value} {mediainfo.title_year}')
+        # 更新媒体图片
+        self.obtain_images(mediainfo=mediainfo)
+        # 返回上下文
+        return Context(meta_info=file_meta, media_info=mediainfo)
+
     def search(self, title: str) -> Tuple[MetaBase, List[MediaInfo]]:
         """
         搜索媒体信息

app/chain/mediaserver.py

@@ -7,6 +7,7 @@ from sqlalchemy.orm import Session
 from app import schemas
 from app.chain import ChainBase
 from app.core.config import settings
+from app.db import SessionFactory
 from app.db.mediaserver_oper import MediaServerOper
 from app.log import logger
 from app.schemas import MessageChannel, Notification
@@ -21,7 +22,6 @@ class MediaServerChain(ChainBase):
 
     def __init__(self, db: Session = None):
         super().__init__(db)
-        self.mediaserverdb = MediaServerOper(db)
 
     def librarys(self) -> List[schemas.MediaServerLibrary]:
         """
@@ -56,11 +56,14 @@ class MediaServerChain(ChainBase):
         同步媒体库所有数据到本地数据库
         """
         with lock:
+            # 媒体服务器同步使用独立的会话
+            _db = SessionFactory()
+            _dbOper = MediaServerOper(_db)
             logger.info("开始同步媒体库数据 ...")
             # 汇总统计
             total_count = 0
             # 清空登记薄
-            self.mediaserverdb.empty(server=settings.MEDIASERVER)
+            _dbOper.empty(server=settings.MEDIASERVER)
             for library in self.librarys():
                 logger.info(f"正在同步媒体库 {library.name} ...")
                 library_count = 0
@@ -83,8 +86,11 @@ class MediaServerChain(ChainBase):
                     item_dict = item.dict()
                     item_dict['seasoninfo'] = json.dumps(seasoninfo)
                     item_dict['item_type'] = item_type
-                    self.mediaserverdb.add(**item_dict)
+                    _dbOper.add(**item_dict)
                 logger.info(f"媒体库 {library.name} 同步完成，共同步数量：{library_count}")
                 # 总数累加
                 total_count += library_count
+            # 关闭数据库连接
+            if _db:
+                _db.close()
             logger.info("【MediaServer】媒体库数据同步完成，同步数量：%s" % total_count)

app/chain/message.py

@@ -130,19 +130,29 @@ class MessageChain(ChainBase):
                     return
                 # 搜索结果排序
                 contexts = self.torrenthelper.sort_torrents(contexts)
-                # 更新缓存
-                user_cache[userid] = {
-                    "type": "Torrent",
-                    "items": contexts
-                }
-                _current_page = 0
-                # 发送种子数据
-                logger.info(f"搜索到 {len(contexts)} 条数据，开始发送选择消息 ...")
-                self.__post_torrents_message(channel=channel,
-                                             title=mediainfo.title,
-                                             items=contexts[:self._page_size],
-                                             userid=userid,
-                                             total=len(contexts))
+                # 判断是否设置自动下载
+                auto_download_user = settings.AUTO_DOWNLOAD_USER
+                # 匹配到自动下载用户
+                if auto_download_user and any(userid == user for user in auto_download_user.split(",")):
+                    logger.info(f"用户 {userid} 在自动下载用户中，开始自动择优下载")
+                    # 自动选择下载
+                    self.__auto_download(channel=channel,
+                                         cache_list=contexts,
+                                         userid=userid,
+                                         username=username)
+                else:
+                    # 更新缓存
+                    user_cache[userid] = {
+                        "type": "Torrent",
+                        "items": contexts
+                    }
+                    # 发送种子数据
+                    logger.info(f"搜索到 {len(contexts)} 条数据，开始发送选择消息 ...")
+                    self.__post_torrents_message(channel=channel,
+                                                 title=mediainfo.title,
+                                                 items=contexts[:self._page_size],
+                                                 userid=userid,
+                                                 total=len(contexts))
 
             elif cache_type == "Subscribe":
                 # 订阅媒体
@@ -169,36 +179,10 @@ class MessageChain(ChainBase):
             elif cache_type == "Torrent":
                 if int(text) == 0:
                     # 自动选择下载
-                    # 查询缺失的媒体信息
-                    exist_flag, no_exists = self.downloadchain.get_no_exists_info(meta=_current_meta,
-                                                                                  mediainfo=_current_media)
-                    if exist_flag:
-                        self.post_message(Notification(
-                            channel=channel,
-                            title=f"{_current_media.title_year}"
-                                  f"{_current_meta.sea} 媒体库中已存在",
-                            userid=userid))
-                        return
-                    # 批量下载
-                    downloads, lefts = self.downloadchain.batch_download(contexts=cache_list,
-                                                                         no_exists=no_exists,
-                                                                         userid=userid)
-                    if downloads and not lefts:
-                        # 全部下载完成
-                        logger.info(f'{_current_media.title_year} 下载完成')
-                    else:
-                        # 未完成下载
-                        logger.info(f'{_current_media.title_year} 未下载未完整，添加订阅 ...')
-                        # 添加订阅，状态为R
-                        self.subscribechain.add(title=_current_media.title,
-                                                year=_current_media.year,
-                                                mtype=_current_media.type,
-                                                tmdbid=_current_media.tmdb_id,
-                                                season=_current_meta.begin_season,
-                                                channel=channel,
-                                                userid=userid,
-                                                username=username,
-                                                state="R")
+                    self.__auto_download(channel=channel,
+                                         cache_list=cache_list,
+                                         userid=userid,
+                                         username=username)
                 else:
                     # 下载种子
                     context: Context = cache_list[int(text) - 1]
@@ -230,6 +214,11 @@ class MessageChain(ChainBase):
                 start = _current_page * self._page_size
                 end = start + self._page_size
             if cache_type == "Torrent":
+                # 更新缓存
+                user_cache[userid] = {
+                    "type": "Torrent",
+                    "items": cache_list[start:end]
+                }
                 # 发送种子数据
                 self.__post_torrents_message(channel=channel,
                                              title=_current_media.title,
@@ -267,6 +256,11 @@ class MessageChain(ChainBase):
                 # 加一页
                 _current_page += 1
                 if cache_type == "Torrent":
+                    # 更新缓存
+                    user_cache[userid] = {
+                        "type": "Torrent",
+                        "items": cache_list
+                    }
                     # 发送种子数据
                     self.__post_torrents_message(channel=channel,
                                                  title=_current_media.title,
@@ -337,6 +331,41 @@ class MessageChain(ChainBase):
         # 保存缓存
         self.save_cache(user_cache, self._cache_file)
 
+    def __auto_download(self, channel, cache_list, userid, username):
+        """
+        自动择优下载
+        """
+        # 查询缺失的媒体信息
+        exist_flag, no_exists = self.downloadchain.get_no_exists_info(meta=_current_meta,
+                                                                      mediainfo=_current_media)
+        if exist_flag:
+            self.post_message(Notification(
+                channel=channel,
+                title=f"{_current_media.title_year}"
+                      f"{_current_meta.sea} 媒体库中已存在",
+                userid=userid))
+            return
+        # 批量下载
+        downloads, lefts = self.downloadchain.batch_download(contexts=cache_list,
+                                                             no_exists=no_exists,
+                                                             userid=userid)
+        if downloads and not lefts:
+            # 全部下载完成
+            logger.info(f'{_current_media.title_year} 下载完成')
+        else:
+            # 未完成下载
+            logger.info(f'{_current_media.title_year} 未下载未完整，添加订阅 ...')
+            # 添加订阅，状态为R
+            self.subscribechain.add(title=_current_media.title,
+                                    year=_current_media.year,
+                                    mtype=_current_media.type,
+                                    tmdbid=_current_media.tmdb_id,
+                                    season=_current_meta.begin_season,
+                                    channel=channel,
+                                    userid=userid,
+                                    username=username,
+                                    state="R")
+
     def __post_medias_message(self, channel: MessageChannel,
                               title: str, items: list, userid: str, total: int):
         """

app/chain/rss.py

@@ -1,279 +0,0 @@
-import json
-import re
-from datetime import datetime
-from typing import Tuple, Optional
-
-from sqlalchemy.orm import Session
-
-from app.chain import ChainBase
-from app.chain.download import DownloadChain
-from app.core.config import settings
-from app.core.context import Context, TorrentInfo, MediaInfo
-from app.core.metainfo import MetaInfo
-from app.db.rss_oper import RssOper
-from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.message import MessageHelper
-from app.helper.rss import RssHelper
-from app.helper.sites import SitesHelper
-from app.log import logger
-from app.schemas import Notification, NotExistMediaInfo
-from app.schemas.types import SystemConfigKey, MediaType, NotificationType
-from app.utils.string import StringUtils
-
-
-class RssChain(ChainBase):
-    """
-    RSS处理链
-    """
-
-    def __init__(self, db: Session = None):
-        super().__init__(db)
-        self.rssoper = RssOper(self._db)
-        self.sites = SitesHelper()
-        self.systemconfig = SystemConfigOper(self._db)
-        self.downloadchain = DownloadChain(self._db)
-        self.message = MessageHelper()
-
-    def add(self, title: str, year: str,
-            mtype: MediaType = None,
-            season: int = None,
-            **kwargs) -> Tuple[Optional[int], str]:
-        """
-        识别媒体信息并添加订阅
-        """
-        logger.info(f'开始添加自定义订阅，标题：{title} ...')
-        # 识别元数据
-        metainfo = MetaInfo(title)
-        if year:
-            metainfo.year = year
-        if mtype:
-            metainfo.type = mtype
-        if season:
-            metainfo.type = MediaType.TV
-            metainfo.begin_season = season
-        # 识别媒体信息
-        mediainfo: MediaInfo = self.recognize_media(meta=metainfo)
-        if not mediainfo:
-            logger.warn(f'{title} 未识别到媒体信息')
-            return None, "未识别到媒体信息"
-        # 更新媒体图片
-        self.obtain_images(mediainfo=mediainfo)
-        # 总集数
-        if mediainfo.type == MediaType.TV:
-            if not season:
-                season = 1
-            # 总集数
-            if not kwargs.get('total_episode'):
-                if not mediainfo.seasons:
-                    # 补充媒体信息
-                    mediainfo: MediaInfo = self.recognize_media(mtype=mediainfo.type,
-                                                                tmdbid=mediainfo.tmdb_id)
-                    if not mediainfo:
-                        logger.error(f"媒体信息识别失败！")
-                        return None, "媒体信息识别失败"
-                    if not mediainfo.seasons:
-                        logger.error(f"{title} 媒体信息中没有季集信息")
-                        return None, "媒体信息中没有季集信息"
-                total_episode = len(mediainfo.seasons.get(season) or [])
-                if not total_episode:
-                    logger.error(f'{title} 未获取到总集数')
-                    return None, "未获取到总集数"
-                kwargs.update({
-                    'total_episode': total_episode
-                })
-        # 检查是否存在
-        if self.rssoper.exists(tmdbid=mediainfo.tmdb_id, season=season):
-            logger.warn(f'{mediainfo.title} 已存在')
-            return None, f'{mediainfo.title} 自定义订阅已存在'
-        if not kwargs.get("name"):
-            kwargs.update({
-                "name": mediainfo.title
-            })
-        kwargs.update({
-            "tmdbid": mediainfo.tmdb_id,
-            "poster": mediainfo.get_poster_image(),
-            "backdrop": mediainfo.get_backdrop_image(),
-            "vote": mediainfo.vote_average,
-            "description": mediainfo.overview,
-        })
-        # 添加订阅
-        sid = self.rssoper.add(title=title, year=year, season=season, **kwargs)
-        if not sid:
-            logger.error(f'{mediainfo.title_year} 添加自定义订阅失败')
-            return None, "添加自定义订阅失败"
-        else:
-            logger.info(f'{mediainfo.title_year} {metainfo.season} 添加订阅成功')
-
-        # 返回结果
-        return sid, ""
-
-    def refresh(self, rssid: int = None, manual: bool = False):
-        """
-        刷新RSS订阅数据
-        """
-        # 所有RSS订阅
-        logger.info("开始刷新RSS订阅数据 ...")
-        rss_tasks = self.rssoper.list(rssid) or []
-        for rss_task in rss_tasks:
-            if not rss_task:
-                continue
-            if not rss_task.url:
-                continue
-            # 下载Rss报文
-            items = RssHelper.parse(rss_task.url, True if rss_task.proxy else False)
-            if not items:
-                logger.error(f"RSS未下载到数据：{rss_task.url}")
-            logger.info(f"{rss_task.name} RSS下载到数据：{len(items)}")
-            # 检查站点
-            domain = StringUtils.get_url_domain(rss_task.url)
-            site_info = self.sites.get_indexer(domain) or {}
-            # 过滤规则
-            if rss_task.best_version:
-                filter_rule = self.systemconfig.get(SystemConfigKey.FilterRules2)
-            else:
-                filter_rule = self.systemconfig.get(SystemConfigKey.FilterRules)
-            # 处理RSS条目
-            matched_contexts = []
-            # 处理过的title
-            processed_data = json.loads(rss_task.note) if rss_task.note else {
-                "titles": [],
-                "season_episodes": []
-            }
-            for item in items:
-                if not item.get("title"):
-                    continue
-                # 标题是否已处理过
-                if item.get("title") in processed_data.get('titles'):
-                    logger.info(f"{item.get('title')} 已处理过")
-                    continue
-                # 基本要素匹配
-                if rss_task.include \
-                        and not re.search(r"%s" % rss_task.include, item.get("title")):
-                    logger.info(f"{item.get('title')} 未包含 {rss_task.include}")
-                    continue
-                if rss_task.exclude \
-                        and re.search(r"%s" % rss_task.exclude, item.get("title")):
-                    logger.info(f"{item.get('title')} 包含 {rss_task.exclude}")
-                    continue
-                # 识别媒体信息
-                meta = MetaInfo(title=item.get("title"), subtitle=item.get("description"))
-                if not meta.name:
-                    logger.error(f"{item.get('title')} 未识别到有效信息")
-                    continue
-                mediainfo = self.recognize_media(meta=meta)
-                if not mediainfo:
-                    logger.error(f"{item.get('title')} 未识别到TMDB媒体信息")
-                    continue
-                if mediainfo.tmdb_id != rss_task.tmdbid:
-                    logger.error(f"{item.get('title')} 不匹配")
-                    continue
-                # 季集是否已处理过
-                if meta.season_episode in processed_data.get('season_episodes'):
-                    logger.info(f"{meta.season_episode} 已处理过")
-                    continue
-                # 种子
-                torrentinfo = TorrentInfo(
-                    site=site_info.get("id"),
-                    site_name=site_info.get("name"),
-                    site_cookie=site_info.get("cookie"),
-                    site_ua=site_info.get("cookie") or settings.USER_AGENT,
-                    site_proxy=site_info.get("proxy") or rss_task.proxy,
-                    site_order=site_info.get("pri"),
-                    title=item.get("title"),
-                    description=item.get("description"),
-                    enclosure=item.get("enclosure"),
-                    page_url=item.get("link"),
-                    size=item.get("size"),
-                    pubdate=item["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if item.get("pubdate") else None,
-                )
-                # 过滤种子
-                if rss_task.filter:
-                    result = self.filter_torrents(
-                        rule_string=filter_rule,
-                        torrent_list=[torrentinfo]
-                    )
-                    if not result:
-                        logger.info(f"{rss_task.name} 不匹配过滤规则")
-                        continue
-                # 更新已处理数据
-                processed_data['titles'].append(item.get("title"))
-                processed_data['season_episodes'].append(meta.season_episode)
-                # 清除多条数据
-                mediainfo.clear()
-                # 匹配到的数据
-                matched_contexts.append(Context(
-                    meta_info=meta,
-                    media_info=mediainfo,
-                    torrent_info=torrentinfo
-                ))
-            # 更新已处理过的title
-            self.rssoper.update(rssid=rss_task.id, note=json.dumps(processed_data))
-            if not matched_contexts:
-                logger.info(f"{rss_task.name} 未匹配到数据")
-                continue
-            logger.info(f"{rss_task.name} 匹配到 {len(matched_contexts)} 条数据")
-            # 查询本地存在情况
-            if not rss_task.best_version:
-                # 查询缺失的媒体信息
-                rss_meta = MetaInfo(title=rss_task.title)
-                rss_meta.year = rss_task.year
-                rss_meta.begin_season = rss_task.season
-                rss_meta.type = MediaType(rss_task.type)
-                exist_flag, no_exists = self.downloadchain.get_no_exists_info(
-                    meta=rss_meta,
-                    mediainfo=MediaInfo(
-                        title=rss_task.title,
-                        year=rss_task.year,
-                        tmdb_id=rss_task.tmdbid,
-                        season=rss_task.season
-                    ),
-                )
-                if exist_flag:
-                    logger.info(f'{rss_task.name} 媒体库中已存在，完成订阅')
-                    self.rssoper.delete(rss_task.id)
-                    # 发送通知
-                    self.post_message(Notification(mtype=NotificationType.Subscribe,
-                                                   title=f'自定义订阅 {rss_task.name} 已完成',
-                                                   image=rss_task.backdrop))
-                    continue
-                elif rss_meta.type == MediaType.TV.value:
-                    # 打印缺失集信息
-                    if no_exists and no_exists.get(rss_task.tmdbid):
-                        no_exists_info = no_exists.get(rss_task.tmdbid).get(rss_task.season)
-                        if no_exists_info:
-                            logger.info(f'订阅 {rss_task.name} 缺失集：{no_exists_info.episodes}')
-            else:
-                if rss_task.type == MediaType.TV.value:
-                    no_exists = {
-                        rss_task.season: NotExistMediaInfo(
-                            season=rss_task.season,
-                            episodes=[],
-                            total_episode=rss_task.total_episode,
-                            start_episode=1)
-                    }
-                else:
-                    no_exists = {}
-            # 开始下载
-            downloads, lefts = self.downloadchain.batch_download(contexts=matched_contexts,
-                                                                 no_exists=no_exists,
-                                                                 save_path=rss_task.save_path)
-            if downloads and not lefts:
-                if not rss_task.best_version:
-                    self.rssoper.delete(rss_task.id)
-                    # 发送通知
-                    self.post_message(Notification(mtype=NotificationType.Subscribe,
-                                                   title=f'自定义订阅 {rss_task.name} 已完成',
-                                                   image=rss_task.backdrop))
-            # 未完成下载
-            logger.info(f'{rss_task.name} 未下载未完整，继续订阅 ...')
-            if downloads:
-                # 更新最后更新时间和已处理数量
-                self.rssoper.update(rssid=rss_task.id,
-                                    processed=(rss_task.processed or 0) + len(downloads),
-                                    last_update=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
-        logger.info("刷新RSS订阅数据完成")
-        if manual:
-            if len(rss_tasks) == 1:
-                self.message.put(f"{rss_tasks[0].name} 自定义订阅刷新完成")
-            else:
-                self.message.put(f"自定义订阅刷新完成")

app/chain/search.py

@@ -29,7 +29,7 @@ class SearchChain(ChainBase):
         super().__init__(db)
         self.siteshelper = SitesHelper()
         self.progress = ProgressHelper()
-        self.systemconfig = SystemConfigOper(self._db)
+        self.systemconfig = SystemConfigOper()
         self.torrenthelper = TorrentHelper()
 
     def search_by_tmdbid(self, tmdbid: int, mtype: MediaType = None, area: str = "title") -> List[Context]:
@@ -76,22 +76,6 @@ class SearchChain(ChainBase):
             print(str(e))
             return []
 
-    def browse(self, domain: str, keyword: str = None) -> List[TorrentInfo]:
-        """
-        浏览站点首页内容
-        :param domain: 站点域名
-        :param keyword: 关键词，有值时为搜索
-        """
-        if not keyword:
-            logger.info(f'开始浏览站点首页内容，站点：{domain} ...')
-        else:
-            logger.info(f'开始搜索资源，关键词：{keyword}，站点：{domain} ...')
-        site = self.siteshelper.get_indexer(domain)
-        if not site:
-            logger.error(f'站点 {domain} 不存在！')
-            return []
-        return self.search_torrents(site=site, keyword=keyword)
-
     def process(self, mediainfo: MediaInfo,
                 keyword: str = None,
                 no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
@@ -189,29 +173,42 @@ class SearchChain(ChainBase):
                 # 比对年份
                 if mediainfo.year:
                     if mediainfo.type == MediaType.TV:
-                        # 需要剧集
+                        # 剧集年份，每季的年份可能不同
                         if torrent_meta.year and torrent_meta.year not in [year for year in
                                                                            mediainfo.season_years.values()]:
                             logger.warn(f'{torrent.site_name} - {torrent.title} 年份不匹配')
                             continue
                     else:
-                        # 需要电影
-                        if torrent_meta.year != mediainfo.year:
+                        # 电影年份，上下浮动1年
+                        if torrent_meta.year not in [str(int(mediainfo.year) - 1),
+                                                     mediainfo.year,
+                                                     str(int(mediainfo.year) + 1)]:
                             logger.warn(f'{torrent.site_name} - {torrent.title} 年份不匹配')
                             continue
-                # 比对标题
+                # 比对标题和原语种标题
                 meta_name = StringUtils.clear_upper(torrent_meta.name)
                 if meta_name in [
                     StringUtils.clear_upper(mediainfo.title),
                     StringUtils.clear_upper(mediainfo.original_title)
                 ]:
-                    logger.info(f'{mediainfo.title} 匹配到资源：{torrent.site_name} - {torrent.title}')
+                    logger.info(f'{mediainfo.title} 通过标题匹配到资源：{torrent.site_name} - {torrent.title}')
                     _match_torrents.append(torrent)
                     continue
+                # 在副标题中判断是否存在标题与原语种标题
+                if torrent.description:
+                    subtitle = torrent.description.split()
+                    if (StringUtils.is_chinese(mediainfo.title)
+                        and str(mediainfo.title) in subtitle) \
+                            or (StringUtils.is_chinese(mediainfo.original_title)
+                                and str(mediainfo.original_title) in subtitle):
+                        logger.info(f'{mediainfo.title} 通过副标题匹配到资源：{torrent.site_name} - {torrent.title}，'
+                                    f'副标题：{torrent.description}')
+                        _match_torrents.append(torrent)
+                        continue
                 # 比对别名和译名
                 for name in mediainfo.names:
                     if StringUtils.clear_upper(name) == meta_name:
-                        logger.info(f'{mediainfo.title} 匹配到资源：{torrent.site_name} - {torrent.title}')
+                        logger.info(f'{mediainfo.title} 通过别名或译名匹配到资源：{torrent.site_name} - {torrent.title}')
                         _match_torrents.append(torrent)
                         break
                 else:
@@ -250,14 +247,14 @@ class SearchChain(ChainBase):
         """
         # 未开启的站点不搜索
         indexer_sites = []
+
         # 配置的索引站点
-        if sites:
-            config_indexers = [str(sid) for sid in sites]
-        else:
-            config_indexers = [str(sid) for sid in self.systemconfig.get(SystemConfigKey.IndexerSites) or []]
+        if not sites:
+            sites = self.systemconfig.get(SystemConfigKey.IndexerSites) or []
+
         for indexer in self.siteshelper.get_indexers():
             # 检查站点索引开关
-            if not config_indexers or str(indexer.get("id")) in config_indexers:
+            if not sites or indexer.get("id") in sites:
                 # 站点流控
                 state, msg = self.siteshelper.check(indexer.get("domain"))
                 if state:
@@ -267,6 +264,7 @@ class SearchChain(ChainBase):
         if not indexer_sites:
             logger.warn('未开启任何有效站点，无法搜索资源')
             return []
+
         # 开始进度
         self.progress.start(ProgressKey.Search)
         # 开始计时

app/chain/site.py

@@ -91,7 +91,8 @@ class SiteChain(ChainBase):
         if not site_list:
             self.post_message(Notification(
                 channel=channel,
-                title="没有维护任何站点信息！"))
+                title="没有维护任何站点信息！",
+                userid=userid))
         title = f"共有 {len(site_list)} 个站点，回复对应指令操作：" \
                 f"\n- 禁用站点：/site_disable [id]" \
                 f"\n- 启用站点：/site_enable [id]" \
@@ -221,8 +222,8 @@ class SiteChain(ChainBase):
                 title=f"站点编号 {site_id} 不存在！", userid=userid))
             return
         self.post_message(Notification(
-                channel=channel,
-                title=f"开始更新【{site_info.name}】Cookie&UA ...", userid=userid))
+            channel=channel,
+            title=f"开始更新【{site_info.name}】Cookie&UA ...", userid=userid))
         # 用户名
         username = args[1]
         # 密码

app/chain/subscribe.py

@@ -8,7 +8,7 @@ from requests import Session
 from app.chain import ChainBase
 from app.chain.download import DownloadChain
 from app.chain.search import SearchChain
-from app.core.config import settings
+from app.chain.torrents import TorrentsChain
 from app.core.context import TorrentInfo, Context, MediaInfo
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo
@@ -16,11 +16,9 @@ from app.db.models.subscribe import Subscribe
 from app.db.subscribe_oper import SubscribeOper
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.message import MessageHelper
-from app.helper.sites import SitesHelper
 from app.log import logger
 from app.schemas import NotExistMediaInfo, Notification
 from app.schemas.types import MediaType, SystemConfigKey, MessageChannel, NotificationType
-from app.utils.string import StringUtils
 
 
 class SubscribeChain(ChainBase):
@@ -28,16 +26,14 @@ class SubscribeChain(ChainBase):
     订阅管理处理链
     """
 
-    _cache_file = "__torrents_cache__"
-
     def __init__(self, db: Session = None):
         super().__init__(db)
         self.downloadchain = DownloadChain(self._db)
         self.searchchain = SearchChain(self._db)
         self.subscribeoper = SubscribeOper(self._db)
-        self.siteshelper = SitesHelper()
+        self.torrentschain = TorrentsChain()
         self.message = MessageHelper()
-        self.systemconfig = SystemConfigOper(self._db)
+        self.systemconfig = SystemConfigOper()
 
     def add(self, title: str, year: str,
             mtype: MediaType = None,
@@ -189,6 +185,13 @@ class SubscribeChain(ChainBase):
             subscribes = self.subscribeoper.list(state)
         # 遍历订阅
         for subscribe in subscribes:
+            # 校验当前时间减订阅创建时间是否大于1分钟，否则跳过先，留出编辑订阅的时间
+            if subscribe.date:
+                now = datetime.now()
+                subscribe_time = datetime.strptime(subscribe.date, '%Y-%m-%d %H:%M:%S')
+                if (now - subscribe_time).total_seconds() < 60:
+                    logger.debug(f"订阅标题：{subscribe.name} 新增小于1分钟，暂不搜索...")
+                    continue
             logger.info(f'开始搜索订阅，标题：{subscribe.name} ...')
             # 如果状态为N则更新为R
             if subscribe.state == 'N':
@@ -206,8 +209,18 @@ class SubscribeChain(ChainBase):
 
             # 非洗版状态
             if not subscribe.best_version:
+                # 每季总集数
+                totals = {}
+                if subscribe.season and subscribe.total_episode:
+                    totals = {
+                        subscribe.season: subscribe.total_episode
+                    }
                 # 查询缺失的媒体信息
-                exist_flag, no_exists = self.downloadchain.get_no_exists_info(meta=meta, mediainfo=mediainfo)
+                exist_flag, no_exists = self.downloadchain.get_no_exists_info(
+                    meta=meta,
+                    mediainfo=mediainfo,
+                    totals=totals
+                )
                 if exist_flag:
                     logger.info(f'{mediainfo.title_year} 媒体库中已存在，完成订阅')
                     self.subscribeoper.delete(subscribe.id)
@@ -264,7 +277,7 @@ class SubscribeChain(ChainBase):
                 logger.warn(f'订阅 {subscribe.keyword or subscribe.name} 未搜索到资源')
                 if meta.type == MediaType.TV:
                     # 未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
-                    self.__upate_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
+                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
                 continue
             # 过滤
             matched_contexts = []
@@ -272,22 +285,28 @@ class SubscribeChain(ChainBase):
                 torrent_meta = context.meta_info
                 torrent_info = context.torrent_info
                 torrent_mediainfo = context.media_info
+                # 包含与排除规则
+                default_include_exclude = self.systemconfig.get(SystemConfigKey.DefaultIncludeExcludeFilter) or {}
+                include = subscribe.include or default_include_exclude.get("include")
+                exclude = subscribe.exclude or default_include_exclude.get("exclude")
                 # 包含
-                if subscribe.include:
-                    if not re.search(r"%s" % subscribe.include,
+                if include:
+                    if not re.search(r"%s" % include,
                                      f"{torrent_info.title} {torrent_info.description}", re.I):
+                        logger.info(f"{torrent_info.title} 不匹配包含规则 {include}")
                         continue
                 # 排除
-                if subscribe.exclude:
-                    if re.search(r"%s" % subscribe.exclude,
+                if exclude:
+                    if re.search(r"%s" % exclude,
                                  f"{torrent_info.title} {torrent_info.description}", re.I):
+                        logger.info(f"{torrent_info.title} 匹配排除规则 {exclude}")
                         continue
                 # 非洗版
                 if not subscribe.best_version:
                     # 如果是电视剧过滤掉已经下载的集数
                     if torrent_mediainfo.type == MediaType.TV:
                         if self.__check_subscribe_note(subscribe, torrent_meta.episode_list):
-                            logger.info(f'{torrent_info.title} 对应剧集 {torrent_meta.episodes} 已下载过')
+                            logger.info(f'{torrent_info.title} 对应剧集 {torrent_meta.episode_list} 已下载过')
                             continue
                 else:
                     # 洗版时，非整季不要
@@ -295,12 +314,17 @@ class SubscribeChain(ChainBase):
                         if torrent_meta.episode_list:
                             logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
                             continue
+                    # 优先级小于已下载优先级的不要
+                    if subscribe.current_priority \
+                            and torrent_info.pri_order < subscribe.current_priority:
+                        logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于已下载优先级')
+                        continue
                 matched_contexts.append(context)
             if not matched_contexts:
                 logger.warn(f'订阅 {subscribe.name} 没有符合过滤条件的资源')
                 # 非洗版未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
                 if meta.type == MediaType.TV and not subscribe.best_version:
-                    self.__upate_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
+                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
                 continue
             # 自动下载
             downloads, lefts = self.downloadchain.batch_download(contexts=matched_contexts,
@@ -317,18 +341,18 @@ class SubscribeChain(ChainBase):
                                              mediainfo=mediainfo, downloads=downloads)
             else:
                 # 未完成下载
-                logger.info(f'{mediainfo.title_year} 未下载未完整，继续订阅 ...')
+                logger.info(f'{mediainfo.title_year} 未下载完整，继续订阅 ...')
                 if meta.type == MediaType.TV and not subscribe.best_version:
                     # 更新订阅剩余集数和时间
                     update_date = True if downloads else False
-                    self.__upate_lack_episodes(lefts=lefts, subscribe=subscribe,
-                                               mediainfo=mediainfo, update_date=update_date)
+                    self.__update_lack_episodes(lefts=lefts, subscribe=subscribe,
+                                                mediainfo=mediainfo, update_date=update_date)
         # 手动触发时发送系统消息
         if manual:
             if sid:
                 self.message.put(f'订阅 {subscribes[0].name} 搜索完成！')
             else:
-                self.message.put(f'所有订阅搜索完成！')
+                self.message.put('所有订阅搜索完成！')
 
     def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaInfo,
                                 mediainfo: MediaInfo, downloads: List[Context]):
@@ -362,73 +386,40 @@ class SubscribeChain(ChainBase):
 
     def refresh(self):
         """
-        刷新站点最新资源
+        订阅刷新
         """
-        # 所有订阅
+        # 触发刷新站点资源，从缓存中匹配订阅
+        sites = self.get_subscribed_sites()
+        if sites is None:
+            return
+        self.match(
+            self.torrentschain.refresh(sites=sites)
+        )
+
+    def get_subscribed_sites(self) -> Optional[List[int]]:
+        """
+        获取订阅中涉及的所有站点清单（节约资源）
+        :return: 返回[]代表所有站点命中，返回None代表没有订阅
+        """
+        # 查询所有订阅
         subscribes = self.subscribeoper.list('R')
         if not subscribes:
-            # 没有订阅不运行
-            return
-        # 读取缓存
-        torrents_cache: Dict[str, List[Context]] = self.load_cache(self._cache_file) or {}
+            return None
+        ret_sites = []
+        # 刷新订阅选中的Rss站点
+        for subscribe in subscribes:
+            # 如果有一个订阅没有选择站点，则刷新所有订阅站点
+            if not subscribe.sites:
+                return []
+            # 刷新选中的站点
+            sub_sites = json.loads(subscribe.sites)
+            if sub_sites:
+                ret_sites.extend(sub_sites)
+        # 去重
+        if ret_sites:
+            ret_sites = list(set(ret_sites))
 
-        # 所有站点索引
-        indexers = self.siteshelper.get_indexers()
-        # 配置的索引站点
-        config_indexers = [str(sid) for sid in self.systemconfig.get(SystemConfigKey.IndexerSites) or []]
-        # 遍历站点缓存资源
-        for indexer in indexers:
-            # 未开启的站点不搜索
-            if config_indexers and str(indexer.get("id")) not in config_indexers:
-                continue
-            logger.info(f'开始刷新 {indexer.get("name")} 最新种子 ...')
-            domain = StringUtils.get_url_domain(indexer.get("domain"))
-            torrents: List[TorrentInfo] = self.refresh_torrents(site=indexer)
-            # 按pubdate降序排列
-            torrents.sort(key=lambda x: x.pubdate or '', reverse=True)
-            # 取前N条
-            torrents = torrents[:settings.CACHE_CONF.get('refresh')]
-            if torrents:
-                # 过滤出没有处理过的种子
-                torrents = [torrent for torrent in torrents
-                            if f'{torrent.title}{torrent.description}'
-                            not in [f'{t.torrent_info.title}{t.torrent_info.description}'
-                                    for t in torrents_cache.get(domain) or []]]
-                if torrents:
-                    logger.info(f'{indexer.get("name")} 有 {len(torrents)} 个新种子')
-                else:
-                    logger.info(f'{indexer.get("name")} 没有新种子')
-                    continue
-                for torrent in torrents:
-                    logger.info(f'处理资源：{torrent.title} ...')
-                    # 识别
-                    meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
-                    # 识别媒体信息
-                    mediainfo: MediaInfo = self.recognize_media(meta=meta)
-                    if not mediainfo:
-                        logger.warn(f'未识别到媒体信息，标题：{torrent.title}')
-                        # 存储空的媒体信息
-                        mediainfo = MediaInfo()
-                    # 清理多余数据
-                    mediainfo.clear()
-                    # 上下文
-                    context = Context(meta_info=meta, media_info=mediainfo, torrent_info=torrent)
-                    # 添加到缓存
-                    if not torrents_cache.get(domain):
-                        torrents_cache[domain] = [context]
-                    else:
-                        torrents_cache[domain].append(context)
-                    # 如果超过了限制条数则移除掉前面的
-                    if len(torrents_cache[domain]) > settings.CACHE_CONF.get('torrents'):
-                        torrents_cache[domain] = torrents_cache[domain][-settings.CACHE_CONF.get('torrents'):]
-                # 回收资源
-                del torrents
-            else:
-                logger.info(f'{indexer.get("name")} 没有获取到种子')
-        # 从缓存中匹配订阅
-        self.match(torrents_cache)
-        # 保存缓存到本地
-        self.save_cache(torrents_cache, self._cache_file)
+        return ret_sites
 
     def match(self, torrents: Dict[str, List[Context]]):
         """
@@ -454,8 +445,18 @@ class SubscribeChain(ChainBase):
                 continue
             # 非洗版
             if not subscribe.best_version:
+                # 每季总集数
+                totals = {}
+                if subscribe.season and subscribe.total_episode:
+                    totals = {
+                        subscribe.season: subscribe.total_episode
+                    }
                 # 查询缺失的媒体信息
-                exist_flag, no_exists = self.downloadchain.get_no_exists_info(meta=meta, mediainfo=mediainfo)
+                exist_flag, no_exists = self.downloadchain.get_no_exists_info(
+                    meta=meta,
+                    mediainfo=mediainfo,
+                    totals=totals
+                )
                 if exist_flag:
                     logger.info(f'{mediainfo.title_year} 媒体库中已存在，完成订阅')
                     self.subscribeoper.delete(subscribe.id)
@@ -514,11 +515,13 @@ class SubscribeChain(ChainBase):
                         torrent_list=[torrent_info])
                     if result is not None and not result:
                         # 不符合过滤规则
+                        logger.info(f"{torrent_info.title} 不匹配当前过滤规则")
                         continue
                     # 不在订阅站点范围的不处理
                     if subscribe.sites:
                         sub_sites = json.loads(subscribe.sites)
                         if sub_sites and torrent_info.site not in sub_sites:
+                            logger.info(f"{torrent_info.title} 不符合 {torrent_mediainfo.title_year} 订阅站点要求")
                             continue
                     # 如果是电视剧
                     if torrent_mediainfo.type == MediaType.TV:
@@ -548,11 +551,11 @@ class SubscribeChain(ChainBase):
                                                 set(torrent_meta.episode_list)
                                             ):
                                         logger.info(
-                                            f'{torrent_info.title} 对应剧集 {torrent_meta.episodes} 未包含缺失的剧集')
+                                            f'{torrent_info.title} 对应剧集 {torrent_meta.episode_list} 未包含缺失的剧集')
                                         continue
                             # 过滤掉已经下载的集数
                             if self.__check_subscribe_note(subscribe, torrent_meta.episode_list):
-                                logger.info(f'{torrent_info.title} 对应剧集 {torrent_meta.episodes} 已下载过')
+                                logger.info(f'{torrent_info.title} 对应剧集 {torrent_meta.episode_list} 已下载过')
                                 continue
                         else:
                             # 洗版时，非整季不要
@@ -560,15 +563,21 @@ class SubscribeChain(ChainBase):
                                 if torrent_meta.episode_list:
                                     logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
                                     continue
+                    # 包含与排除规则
+                    default_include_exclude = self.systemconfig.get(SystemConfigKey.DefaultIncludeExcludeFilter) or {}
+                    include = subscribe.include or default_include_exclude.get("include")
+                    exclude = subscribe.exclude or default_include_exclude.get("exclude")
                     # 包含
-                    if subscribe.include:
-                        if not re.search(r"%s" % subscribe.include,
+                    if include:
+                        if not re.search(r"%s" % include,
                                          f"{torrent_info.title} {torrent_info.description}", re.I):
+                            logger.info(f"{torrent_info.title} 不匹配包含规则 {include}")
                             continue
                     # 排除
-                    if subscribe.exclude:
-                        if re.search(r"%s" % subscribe.exclude,
+                    if exclude:
+                        if re.search(r"%s" % exclude,
                                      f"{torrent_info.title} {torrent_info.description}", re.I):
+                            logger.info(f"{torrent_info.title} 匹配排除规则 {exclude}")
                             continue
                     # 匹配成功
                     logger.info(f'{mediainfo.title_year} 匹配成功：{torrent_info.title}')
@@ -590,12 +599,59 @@ class SubscribeChain(ChainBase):
                     if meta.type == MediaType.TV and not subscribe.best_version:
                         update_date = True if downloads else False
                         # 未完成下载，计算剩余集数
-                        self.__upate_lack_episodes(lefts=lefts, subscribe=subscribe,
-                                                   mediainfo=mediainfo, update_date=update_date)
+                        self.__update_lack_episodes(lefts=lefts, subscribe=subscribe,
+                                                    mediainfo=mediainfo, update_date=update_date)
             else:
                 if meta.type == MediaType.TV:
                     # 未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
-                    self.__upate_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
+                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
+
+    def check(self):
+        """
+        定时检查订阅，更新订阅信息
+        """
+        # 查询所有订阅
+        subscribes = self.subscribeoper.list()
+        if not subscribes:
+            # 没有订阅不运行
+            return
+        # 遍历订阅
+        for subscribe in subscribes:
+            logger.info(f'开始检查订阅：{subscribe.name} ...')
+            # 生成元数据
+            meta = MetaInfo(subscribe.name)
+            meta.year = subscribe.year
+            meta.begin_season = subscribe.season or None
+            meta.type = MediaType(subscribe.type)
+            # 识别媒体信息
+            mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type, tmdbid=subscribe.tmdbid)
+            if not mediainfo:
+                logger.warn(f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}')
+                continue
+            # 对于电视剧，获取当前季的总集数
+            episodes = mediainfo.seasons.get(subscribe.season) or []
+            if len(episodes) > (subscribe.total_episode or 0):
+                total_episode = len(episodes)
+                lack_episode = subscribe.lack_episode + (total_episode - subscribe.total_episode)
+                logger.info(
+                    f'订阅 {subscribe.name} 总集数变化，更新总集数为{total_episode}，缺失集数为{lack_episode} ...')
+            else:
+                total_episode = subscribe.total_episode
+                lack_episode = subscribe.lack_episode
+            # 更新TMDB信息
+            self.subscribeoper.update(subscribe.id, {
+                "name": mediainfo.title,
+                "year": mediainfo.year,
+                "vote": mediainfo.vote_average,
+                "poster": mediainfo.get_poster_image(),
+                "backdrop": mediainfo.get_backdrop_image(),
+                "description": mediainfo.overview,
+                "imdbid": mediainfo.imdb_id,
+                "tvdbid": mediainfo.tvdb_id,
+                "total_episode": total_episode,
+                "lack_episode": lack_episode
+            })
+            logger.info(f'订阅 {subscribe.name} 更新完成')
 
     def __update_subscribe_note(self, subscribe: Subscribe, downloads: List[Context]):
         """
@@ -638,10 +694,10 @@ class SubscribeChain(ChainBase):
             return True
         return False
 
-    def __upate_lack_episodes(self, lefts: Dict[int, Dict[int, NotExistMediaInfo]],
-                              subscribe: Subscribe,
-                              mediainfo: MediaInfo,
-                              update_date: bool = False):
+    def __update_lack_episodes(self, lefts: Dict[int, Dict[int, NotExistMediaInfo]],
+                               subscribe: Subscribe,
+                               mediainfo: MediaInfo,
+                               update_date: bool = False):
         """
         更新订阅剩余集数
         """
@@ -650,16 +706,20 @@ class SubscribeChain(ChainBase):
             season = season_info.season
             if season == subscribe.season:
                 left_episodes = season_info.episodes
-                logger.info(f'{mediainfo.title_year} 季 {season} 更新缺失集数为{len(left_episodes)} ...')
+                if not left_episodes:
+                    lack_episode = season_info.total_episode
+                else:
+                    lack_episode = len(left_episodes)
+                logger.info(f'{mediainfo.title_year} 季 {season} 更新缺失集数为{lack_episode} ...')
                 if update_date:
                     # 同时更新最后时间
                     self.subscribeoper.update(subscribe.id, {
-                        "lack_episode": len(left_episodes),
+                        "lack_episode": lack_episode,
                         "last_update": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                     })
                 else:
                     self.subscribeoper.update(subscribe.id, {
-                        "lack_episode": len(left_episodes)
+                        "lack_episode": lack_episode
                     })
 
     def remote_list(self, channel: MessageChannel, userid: Union[str, int] = None):
@@ -722,43 +782,50 @@ class SubscribeChain(ChainBase):
                                  total_episode: int,
                                  start_episode: int):
         """
-        根据订阅开始集数和总结数，结合TMDB信息计算当前订阅的缺失集数
+        根据订阅开始集数和总集数，结合TMDB信息计算当前订阅的缺失集数
         :param no_exists: 缺失季集列表
         :param tmdb_id: TMDB ID
         :param begin_season: 开始季
-        :param total_episode: 总集数
-        :param start_episode: 开始集数
+        :param total_episode: 订阅设定总集数
+        :param start_episode: 订阅设定开始集数
         """
         # 使用订阅的总集数和开始集数替换no_exists
         if no_exists \
                 and no_exists.get(tmdb_id) \
                 and (total_episode or start_episode):
+            # 该季原缺失信息
             no_exist_season = no_exists.get(tmdb_id).get(begin_season)
             if no_exist_season:
-                # 原季集列表
+                # 原集列表
                 episode_list = no_exist_season.episodes
-                # 整季缺失且没有开始集数的的不处理
-                if not episode_list and not start_episode:
-                    return no_exists
                 # 原总集数
                 total = no_exist_season.total_episode
-                if total_episode and start_episode:
-                    # 有开始集和总集数
-                    episodes = list(range(start_episode, total_episode + 1))
-                elif not start_episode:
-                    # 有总集数没有开始集
-                    episodes = list(range(min(episode_list or [1]), total_episode + 1))
-                    start_episode = min(episode_list or [1])
-                elif not total_episode:
-                    # 有开始集没有总集数
-                    episodes = list(range(start_episode, max(episode_list or [total]) + 1))
-                    total_episode = max(episode_list or [total])
+                # 原开始集数
+                start = no_exist_season.start_episode
+
+                # 更新剧集列表、开始集数、总集数
+                if not episode_list:
+                    # 整季缺失
+                    episodes = []
+                    start_episode = start_episode or start
+                    total_episode = total_episode or total
                 else:
-                    return no_exists
-                # 与原有集取交集
-                if episode_list:
-                    episodes = list(set(episodes).intersection(set(episode_list)))
-                # 处理集合
+                    # 部分缺失
+                    if not start_episode \
+                            and not total_episode:
+                        # 无需调整
+                        return no_exists
+                    if not start_episode:
+                        # 没有自定义开始集
+                        start_episode = start
+                    if not total_episode:
+                        # 没有自定义总集数
+                        total_episode = total
+                    # 新的集列表
+                    new_episodes = list(range(max(start_episode, start), total_episode + 1))
+                    # 与原集列表取交集
+                    episodes = list(set(episode_list).intersection(set(new_episodes)))
+                # 更新集合
                 no_exists[tmdb_id][begin_season] = NotExistMediaInfo(
                     season=begin_season,
                     episodes=episodes,

app/chain/torrents.py

@@ -0,0 +1,234 @@
+import re
+from typing import Dict, List, Union
+
+from cachetools import cached, TTLCache
+
+from app.chain import ChainBase
+from app.core.config import settings
+from app.core.context import TorrentInfo, Context, MediaInfo
+from app.core.metainfo import MetaInfo
+from app.db import SessionFactory
+from app.db.site_oper import SiteOper
+from app.db.systemconfig_oper import SystemConfigOper
+from app.helper.rss import RssHelper
+from app.helper.sites import SitesHelper
+from app.log import logger
+from app.schemas import Notification
+from app.schemas.types import SystemConfigKey, MessageChannel, NotificationType
+from app.utils.singleton import Singleton
+from app.utils.string import StringUtils
+
+
+class TorrentsChain(ChainBase, metaclass=Singleton):
+    """
+    站点首页或RSS种子处理链，服务于订阅、刷流等
+    """
+
+    _spider_file = "__torrents_cache__"
+    _rss_file = "__rss_cache__"
+
+    def __init__(self):
+        self._db = SessionFactory()
+        super().__init__(self._db)
+        self.siteshelper = SitesHelper()
+        self.siteoper = SiteOper(self._db)
+        self.rsshelper = RssHelper()
+        self.systemconfig = SystemConfigOper()
+
+    def remote_refresh(self, channel: MessageChannel, userid: Union[str, int] = None):
+        """
+        远程刷新订阅，发送消息
+        """
+        self.post_message(Notification(channel=channel,
+                                       title=f"开始刷新种子 ...", userid=userid))
+        self.refresh()
+        self.post_message(Notification(channel=channel,
+                                       title=f"种子刷新完成！", userid=userid))
+
+    def get_torrents(self, stype: str = None) -> Dict[str, List[Context]]:
+        """
+        获取当前缓存的种子
+        :param stype: 强制指定缓存类型，spider:爬虫缓存，rss:rss缓存
+        """
+
+        if not stype:
+            stype = settings.SUBSCRIBE_MODE
+
+        # 读取缓存
+        if stype == 'spider':
+            return self.load_cache(self._spider_file) or {}
+        else:
+            return self.load_cache(self._rss_file) or {}
+
+    @cached(cache=TTLCache(maxsize=128, ttl=600))
+    def browse(self, domain: str) -> List[TorrentInfo]:
+        """
+        浏览站点首页内容，返回种子清单，TTL缓存10分钟
+        :param domain: 站点域名
+        """
+        logger.info(f'开始获取站点 {domain} 最新种子 ...')
+        site = self.siteshelper.get_indexer(domain)
+        if not site:
+            logger.error(f'站点 {domain} 不存在！')
+            return []
+        return self.refresh_torrents(site=site)
+
+    @cached(cache=TTLCache(maxsize=128, ttl=300))
+    def rss(self, domain: str) -> List[TorrentInfo]:
+        """
+        获取站点RSS内容，返回种子清单，TTL缓存5分钟
+        :param domain: 站点域名
+        """
+        logger.info(f'开始获取站点 {domain} RSS ...')
+        site = self.siteshelper.get_indexer(domain)
+        if not site:
+            logger.error(f'站点 {domain} 不存在！')
+            return []
+        if not site.get("rss"):
+            logger.error(f'站点 {domain} 未配置RSS地址！')
+            return []
+        rss_items = self.rsshelper.parse(site.get("rss"), True if site.get("proxy") else False)
+        if rss_items is None:
+            # rss过期，尝试保留原配置生成新的rss
+            self.__renew_rss_url(domain=domain, site=site)
+            return []
+        if not rss_items:
+            logger.error(f'站点 {domain} 未获取到RSS数据！')
+            return []
+        # 组装种子
+        ret_torrents: List[TorrentInfo] = []
+        for item in rss_items:
+            if not item.get("title"):
+                continue
+            torrentinfo = TorrentInfo(
+                site=site.get("id"),
+                site_name=site.get("name"),
+                site_cookie=site.get("cookie"),
+                site_ua=site.get("ua") or settings.USER_AGENT,
+                site_proxy=site.get("proxy"),
+                site_order=site.get("pri"),
+                title=item.get("title"),
+                enclosure=item.get("enclosure"),
+                page_url=item.get("link"),
+                size=item.get("size"),
+                pubdate=item["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if item.get("pubdate") else None,
+            )
+            ret_torrents.append(torrentinfo)
+
+        return ret_torrents
+
+    def refresh(self, stype: str = None, sites: List[int] = None) -> Dict[str, List[Context]]:
+        """
+        刷新站点最新资源，识别并缓存起来
+        :param stype: 强制指定缓存类型，spider:爬虫缓存，rss:rss缓存
+        :param sites: 强制指定站点ID列表，为空则读取设置的订阅站点
+        """
+        # 刷新类型
+        if not stype:
+            stype = settings.SUBSCRIBE_MODE
+
+        # 刷新站点
+        if not sites:
+            sites = self.systemconfig.get(SystemConfigKey.RssSites) or []
+
+        # 读取缓存
+        torrents_cache = self.get_torrents()
+
+        # 所有站点索引
+        indexers = self.siteshelper.get_indexers()
+        # 遍历站点缓存资源
+        for indexer in indexers:
+            # 未开启的站点不刷新
+            if sites and indexer.get("id") not in sites:
+                continue
+            domain = StringUtils.get_url_domain(indexer.get("domain"))
+            if stype == "spider":
+                # 刷新首页种子
+                torrents: List[TorrentInfo] = self.browse(domain=domain)
+            else:
+                # 刷新RSS种子
+                torrents: List[TorrentInfo] = self.rss(domain=domain)
+            # 按pubdate降序排列
+            torrents.sort(key=lambda x: x.pubdate or '', reverse=True)
+            # 取前N条
+            torrents = torrents[:settings.CACHE_CONF.get('refresh')]
+            if torrents:
+                # 过滤出没有处理过的种子
+                torrents = [torrent for torrent in torrents
+                            if f'{torrent.title}{torrent.description}'
+                            not in [f'{t.torrent_info.title}{t.torrent_info.description}'
+                                    for t in torrents_cache.get(domain) or []]]
+                if torrents:
+                    logger.info(f'{indexer.get("name")} 有 {len(torrents)} 个新种子')
+                else:
+                    logger.info(f'{indexer.get("name")} 没有新种子')
+                    continue
+                for torrent in torrents:
+                    logger.info(f'处理资源：{torrent.title} ...')
+                    # 识别
+                    meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
+                    # 识别媒体信息
+                    mediainfo: MediaInfo = self.recognize_media(meta=meta)
+                    if not mediainfo:
+                        logger.warn(f'未识别到媒体信息，标题：{torrent.title}')
+                        # 存储空的媒体信息
+                        mediainfo = MediaInfo()
+                    # 清理多余数据
+                    mediainfo.clear()
+                    # 上下文
+                    context = Context(meta_info=meta, media_info=mediainfo, torrent_info=torrent)
+                    # 添加到缓存
+                    if not torrents_cache.get(domain):
+                        torrents_cache[domain] = [context]
+                    else:
+                        torrents_cache[domain].append(context)
+                    # 如果超过了限制条数则移除掉前面的
+                    if len(torrents_cache[domain]) > settings.CACHE_CONF.get('torrents'):
+                        torrents_cache[domain] = torrents_cache[domain][-settings.CACHE_CONF.get('torrents'):]
+                # 回收资源
+                del torrents
+            else:
+                logger.info(f'{indexer.get("name")} 没有获取到种子')
+
+        # 保存缓存到本地
+        if stype == "spider":
+            self.save_cache(torrents_cache, self._spider_file)
+        else:
+            self.save_cache(torrents_cache, self._rss_file)
+
+        # 返回
+        return torrents_cache
+
+    def __renew_rss_url(self, domain: str, site: dict):
+        """
+        保留原配置生成新的rss地址
+        """
+        try:
+            # RSS链接过期
+            logger.error(f"站点 {domain} RSS链接已过期，正在尝试自动获取！")
+            # 自动生成rss地址
+            rss_url, errmsg = self.rsshelper.get_rss_link(
+                url=site.get("url"),
+                cookie=site.get("cookie"),
+                ua=site.get("ua") or settings.USER_AGENT,
+                proxy=True if site.get("proxy") else False
+            )
+            if rss_url:
+                # 获取新的日期的passkey
+                match = re.search(r'passkey=([a-zA-Z0-9]+)', rss_url)
+                if match:
+                    new_passkey = match.group(1)
+                    # 获取过期rss除去passkey部分
+                    new_rss = re.sub(r'&passkey=([a-zA-Z0-9]+)', f'&passkey={new_passkey}', site.get("rss"))
+                    logger.info(f"更新站点 {domain} RSS地址 ...")
+                    self.siteoper.update_rss(domain=domain, rss=new_rss)
+                else:
+                    # 发送消息
+                    self.post_message(
+                        Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期"))
+            else:
+                self.post_message(
+                    Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期"))
+        except Exception as e:
+            print(str(e))
+            self.post_message(Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期"))

app/chain/transfer.py

@@ -1,12 +1,13 @@
-import json
+import re
 import shutil
 import threading
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union, Dict
 
 from sqlalchemy.orm import Session
 
 from app.chain import ChainBase
+from app.chain.media import MediaChain
 from app.core.config import settings
 from app.core.context import MediaInfo
 from app.core.meta import MetaBase
@@ -14,11 +15,14 @@ from app.core.metainfo import MetaInfo
 from app.db.downloadhistory_oper import DownloadHistoryOper
 from app.db.models.downloadhistory import DownloadHistory
 from app.db.models.transferhistory import TransferHistory
+from app.db.systemconfig_oper import SystemConfigOper
 from app.db.transferhistory_oper import TransferHistoryOper
+from app.helper.format import FormatParser
 from app.helper.progress import ProgressHelper
 from app.log import logger
-from app.schemas import TransferInfo, TransferTorrent, Notification
-from app.schemas.types import TorrentStatus, EventType, MediaType, ProgressKey, NotificationType, MessageChannel
+from app.schemas import TransferInfo, TransferTorrent, Notification, EpisodeFormat
+from app.schemas.types import TorrentStatus, EventType, MediaType, ProgressKey, NotificationType, MessageChannel, \
+    SystemConfigKey
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
 
@@ -35,6 +39,8 @@ class TransferChain(ChainBase):
         self.downloadhis = DownloadHistoryOper(self._db)
         self.transferhis = TransferHistoryOper(self._db)
         self.progress = ProgressHelper()
+        self.mediachain = MediaChain(self._db)
+        self.systemconfig = SystemConfigOper()
 
     def process(self) -> bool:
         """
@@ -51,132 +57,341 @@ class TransferChain(ChainBase):
                 return False
 
             logger.info(f"获取到 {len(torrents)} 个已完成的下载任务")
-            # 开始进度
-            self.progress.start(ProgressKey.FileTransfer)
-            # 总数
-            total_num = len(torrents)
-            # 已处理数量
-            processed_num = 0
-            self.progress.update(value=0,
-                                 text=f"开始转移下载任务文件，共 {total_num} 个任务 ...",
-                                 key=ProgressKey.FileTransfer)
 
             for torrent in torrents:
-                # 更新进度
-                self.progress.update(value=processed_num / total_num * 100,
-                                     text=f"正在转移 {torrent.title} ...",
-                                     key=ProgressKey.FileTransfer)
-                # 识别元数据
-                meta: MetaBase = MetaInfo(title=torrent.title)
-                if not meta.name:
-                    logger.error(f'未识别到元数据，标题：{torrent.title}')
-                    continue
-
                 # 查询下载记录识别情况
                 downloadhis: DownloadHistory = self.downloadhis.get_by_hash(torrent.hash)
                 if downloadhis:
                     # 类型
                     mtype = MediaType(downloadhis.type)
-                    # 补充剧集信息
-                    if mtype == MediaType.TV \
-                            and ((not meta.season_list and downloadhis.seasons)
-                                 or (not meta.episode_list and downloadhis.episodes)):
-                        meta = MetaInfo(f"{torrent.title} {downloadhis.seasons} {downloadhis.episodes}")
                     # 按TMDBID识别
                     mediainfo = self.recognize_media(mtype=mtype,
                                                      tmdbid=downloadhis.tmdbid)
                 else:
-                    mediainfo = self.recognize_media(meta=meta)
+                    # 非MoviePilot下载的任务，按文件识别
+                    mediainfo = None
+
+                # 执行转移
+                self.do_transfer(path=torrent.path, mediainfo=mediainfo,
+                                 download_hash=torrent.hash)
+
+                # 设置下载任务状态
+                self.transfer_completed(hashs=torrent.hash, path=torrent.path)
+            # 结束
+            logger.info("下载器文件转移执行完成")
+            return True
+
+    def do_transfer(self, path: Path, meta: MetaBase = None,
+                    mediainfo: MediaInfo = None, download_hash: str = None,
+                    target: Path = None, transfer_type: str = None,
+                    season: int = None, epformat: EpisodeFormat = None,
+                    min_filesize: int = 0, force: bool = False) -> Tuple[bool, str]:
+        """
+        执行一个复杂目录的转移操作
+        :param path: 待转移目录或文件
+        :param meta: 元数据
+        :param mediainfo: 媒体信息
+        :param download_hash: 下载记录hash
+        :param target: 目标路径
+        :param transfer_type: 转移类型
+        :param season: 季
+        :param epformat: 剧集格式
+        :param min_filesize: 最小文件大小(MB)
+        :param force: 是否强制转移
+        返回：成功标识，错误信息
+        """
+        if not transfer_type:
+            transfer_type = settings.TRANSFER_TYPE
+
+        # 获取待转移路径清单
+        trans_paths = self.__get_trans_paths(path)
+        if not trans_paths:
+            logger.warn(f"{path.name} 没有找到可转移的媒体文件")
+            return False, f"{path.name} 没有找到可转移的媒体文件"
+
+        # 汇总错误信息
+        err_msgs: List[str] = []
+        # 汇总季集清单
+        season_episodes: Dict[Tuple, List[int]] = {}
+        # 汇总元数据
+        metas: Dict[Tuple, MetaBase] = {}
+        # 汇总媒体信息
+        medias: Dict[Tuple, MediaInfo] = {}
+        # 汇总转移信息
+        transfers: Dict[Tuple, TransferInfo] = {}
+
+        # 有集自定义格式
+        formaterHandler = FormatParser(eformat=epformat.format,
+                                       details=epformat.detail,
+                                       part=epformat.part,
+                                       offset=epformat.offset) if epformat else None
+
+        # 开始进度
+        self.progress.start(ProgressKey.FileTransfer)
+        # 总数
+        transfer_files = SystemUtils.list_files(directory=path,
+                                                extensions=settings.RMT_MEDIAEXT,
+                                                min_filesize=min_filesize)
+        if formaterHandler:
+            # 有集自定义格式，过滤文件
+            transfer_files = [f for f in transfer_files if formaterHandler.match(f.name)]
+        # 总数
+        total_num = len(transfer_files)
+        # 已处理数量
+        processed_num = 0
+        self.progress.update(value=0,
+                             text=f"开始转移 {path}，共 {total_num} 个文件 ...",
+                             key=ProgressKey.FileTransfer)
+
+        # 整理屏蔽词
+        transfer_exclude_words = self.systemconfig.get(SystemConfigKey.TransferExcludeWords)
+
+        # 处理所有待转移目录或文件，默认一个转移路径或文件只有一个媒体信息
+        for trans_path in trans_paths:
+            # 如果是目录且不是⼀蓝光原盘，获取所有文件并转移
+            if (not trans_path.is_file()
+                    and not SystemUtils.is_bluray_dir(trans_path)):
+                # 遍历获取下载目录所有文件
+                file_paths = SystemUtils.list_files(directory=trans_path,
+                                                    extensions=settings.RMT_MEDIAEXT,
+                                                    min_filesize=min_filesize)
+            else:
+                file_paths = [trans_path]
+
+            if formaterHandler:
+                # 有集自定义格式，过滤文件
+                file_paths = [f for f in file_paths if formaterHandler.match(f.name)]
+
+            # 转移所有文件
+            for file_path in file_paths:
+
+                # 回收站及隐藏的文件不处理
+                file_path_str = str(file_path)
+                if file_path_str.find('/@Recycle/') != -1 \
+                        or file_path_str.find('/#recycle/') != -1 \
+                        or file_path_str.find('/.') != -1 \
+                        or file_path_str.find('/@eaDir') != -1:
+                    logger.debug(f"{file_path_str} 是回收站或隐藏的文件")
+                    continue
+
+                # 整理屏蔽词不处理
+                is_blocked = False
+                if transfer_exclude_words:
+                    for keyword in transfer_exclude_words:
+                        if not keyword:
+                            continue
+                        if keyword and re.search(r"%s" % keyword, file_path_str, re.IGNORECASE):
+                            logger.info(f"{file_path} 命中整理屏蔽词 {keyword}，不处理")
+                            is_blocked = True
+                            break
+                if is_blocked:
+                    err_msgs.append(f"{file_path.name} 命中整理屏蔽词")
+                    continue
+
+                # 转移成功的不再处理
+                if not force:
+                    transferd = self.transferhis.get_by_src(file_path_str)
+                    if transferd and transferd.status:
+                        logger.info(f"{file_path} 已成功转移过，如需重新处理，请删除历史记录。")
+                        continue
+
+                # 更新进度
+                self.progress.update(value=processed_num / total_num * 100,
+                                     text=f"正在转移 （{processed_num + 1}/{total_num}）{file_path.name} ...",
+                                     key=ProgressKey.FileTransfer)
+
+                if not meta:
+                    # 上级目录元数据
+                    dir_meta = MetaInfo(title=file_path.parent.name)
+                    # 文件元数据，不包含后缀
+                    file_meta = MetaInfo(title=file_path.stem)
+                    # 合并元数据
+                    file_meta.merge(dir_meta)
+                else:
+                    file_meta = meta
+
+                # 合并季
+                if season is not None:
+                    file_meta.begin_season = season
+
+                if not file_meta:
+                    logger.error(f"{file_path} 无法识别有效信息")
+                    err_msgs.append(f"{file_path} 无法识别有效信息")
+                    continue
+
+                # 自定义识别
+                if formaterHandler:
+                    # 开始集、结束集、PART
+                    begin_ep, end_ep, part = formaterHandler.split_episode(file_path.stem)
+                    if begin_ep is not None:
+                        file_meta.begin_episode = begin_ep
+                        file_meta.part = part
+                    if end_ep is not None:
+                        file_meta.end_episode = end_ep
 
                 if not mediainfo:
-                    logger.warn(f'未识别到媒体信息，标题：{torrent.title}')
+                    # 识别媒体信息
+                    file_mediainfo = self.recognize_media(meta=file_meta)
+                else:
+                    file_mediainfo = mediainfo
+
+                if not file_mediainfo:
+                    logger.warn(f'{file_path} 未识别到媒体信息')
                     # 新增转移失败历史记录
-                    his = self.__insert_fail_history(
-                        src_path=torrent.path,
-                        download_hash=torrent.hash,
-                        meta=meta
+                    his = self.transferhis.add_fail(
+                        src_path=file_path,
+                        mode=settings.TRANSFER_TYPE,
+                        meta=file_meta,
+                        download_hash=download_hash
                     )
                     self.post_message(Notification(
                         mtype=NotificationType.Manual,
-                        title=f"{torrent.title} 未识别到媒体信息，无法入库！\n"
+                        title=f"{file_path.name} 未识别到媒体信息，无法入库！\n"
                               f"回复：```\n/redo {his.id} [tmdbid]|[类型]\n``` 手动识别转移。"
                     ))
-                    # 设置种子状态，避免一直报错
-                    self.transfer_completed(hashs=torrent.hash)
                     continue
 
-                logger.info(f"{torrent.title} 识别为：{mediainfo.type.value} {mediainfo.title_year}")
+                # 如果未开启新增已入库媒体是否跟随TMDB信息变化则根据tmdbid查询之前的title
+                if not settings.SCRAP_FOLLOW_TMDB:
+                    transfer_history = self.transferhis.get_by_type_tmdbid(tmdbid=file_mediainfo.tmdb_id,
+                                                                           mtype=file_mediainfo.type.value)
+                    if transfer_history:
+                        file_mediainfo.title = transfer_history.title
+
+                logger.info(f"{file_path.name} 识别为：{file_mediainfo.type.value} {file_mediainfo.title_year}")
+
+                # 电视剧没有集无法转移
+                if file_mediainfo.type == MediaType.TV and not file_meta.episode:
+                    # 转移失败
+                    logger.warn(f"{file_path.name} 入库失败：未识别到集数")
+                    err_msgs.append(f"{file_path.name} 未识别到集数")
+                    # 新增转移失败历史记录
+                    self.transferhis.add_fail(
+                        src_path=file_path,
+                        mode=settings.TRANSFER_TYPE,
+                        download_hash=download_hash,
+                        meta=file_meta,
+                        mediainfo=file_mediainfo
+                    )
+                    # 发送消息
+                    self.post_message(Notification(
+                        mtype=NotificationType.Manual,
+                        title=f"{file_path.name} 入库失败！",
+                        text=f"原因：未识别到集数",
+                        image=file_mediainfo.get_message_image()
+                    ))
+                    continue
 
                 # 更新媒体图片
-                self.obtain_images(mediainfo=mediainfo)
+                self.obtain_images(mediainfo=file_mediainfo)
 
-                # 获取待转移路径清单
-                trans_paths = self.__get_trans_paths(torrent.path)
-                if not trans_paths:
-                    logger.warn(f"{torrent.title} 对应目录没有找到媒体文件")
-                    continue
+                if not download_hash:
+                    download_file = self.downloadhis.get_file_by_fullpath(file_path_str)
+                    if download_file:
+                        download_hash = download_file.download_hash
 
-                # 转移所有文件
-                for trans_path in trans_paths:
-                    transferinfo: TransferInfo = self.transfer(mediainfo=mediainfo,
-                                                               path=trans_path,
-                                                               transfer_type=settings.TRANSFER_TYPE)
-                    if not transferinfo:
-                        logger.error("文件转移模块运行失败")
-                        continue
-                    if not transferinfo.target_path:
-                        # 转移失败
-                        logger.warn(f"{torrent.title} 入库失败：{transferinfo.message}")
-                        # 新增转移失败历史记录
-                        self.__insert_fail_history(
-                            src_path=trans_path,
-                            download_hash=torrent.hash,
-                            meta=meta,
-                            mediainfo=mediainfo,
-                            transferinfo=transferinfo
-                        )
-                        # 发送消息
-                        self.post_message(Notification(
-                            title=f"{mediainfo.title_year} {meta.season_episode} 入库失败！",
-                            text=f"原因：{transferinfo.message or '未知'}",
-                            image=mediainfo.get_message_image()
-                        ))
-                        continue
-
-                    # 新增转移成功历史记录
-                    self.__insert_sucess_history(
-                        src_path=trans_path,
-                        download_hash=torrent.hash,
-                        meta=meta,
-                        mediainfo=mediainfo,
+                # 执行转移
+                transferinfo: TransferInfo = self.transfer(meta=file_meta,
+                                                           mediainfo=file_mediainfo,
+                                                           path=file_path,
+                                                           transfer_type=transfer_type,
+                                                           target=target)
+                if not transferinfo:
+                    logger.error("文件转移模块运行失败")
+                    return False, "文件转移模块运行失败"
+                if not transferinfo.target_path:
+                    # 转移失败
+                    logger.warn(f"{file_path.name} 入库失败：{transferinfo.message}")
+                    err_msgs.append(f"{file_path.name} {transferinfo.message}")
+                    # 新增转移失败历史记录
+                    self.transferhis.add_fail(
+                        src_path=file_path,
+                        mode=settings.TRANSFER_TYPE,
+                        download_hash=download_hash,
+                        meta=file_meta,
+                        mediainfo=file_mediainfo,
                         transferinfo=transferinfo
                     )
-                    # 刮削元数据
-                    self.scrape_metadata(path=transferinfo.target_path, mediainfo=mediainfo)
-                    # 刷新媒体库
-                    self.refresh_mediaserver(mediainfo=mediainfo, file_path=transferinfo.target_path)
-                    # 发送通知
-                    self.send_transfer_message(meta=meta, mediainfo=mediainfo, transferinfo=transferinfo)
-                    # 广播事件
-                    self.eventmanager.send_event(EventType.TransferComplete, {
-                        'meta': meta,
-                        'mediainfo': mediainfo,
-                        'transferinfo': transferinfo
-                    })
+                    # 发送消息
+                    self.post_message(Notification(
+                        mtype=NotificationType.Manual,
+                        title=f"{file_mediainfo.title_year} {file_meta.season_episode} 入库失败！",
+                        text=f"原因：{transferinfo.message or '未知'}",
+                        image=file_mediainfo.get_message_image()
+                    ))
+                    continue
 
-                # 转移完成
-                self.transfer_completed(hashs=torrent.hash, transinfo=transferinfo)
+                # 汇总信息
+                mkey = (file_mediainfo.tmdb_id, file_meta.begin_season)
+                if mkey not in medias:
+                    # 新增信息
+                    metas[mkey] = file_meta
+                    medias[mkey] = file_mediainfo
+                    season_episodes[mkey] = file_meta.episode_list
+                    transfers[mkey] = transferinfo
+                else:
+                    # 合并季集清单
+                    season_episodes[mkey] = list(set(season_episodes[mkey] + file_meta.episode_list))
+                    # 合并转移数据
+                    transfers[mkey].file_count += transferinfo.file_count
+                    transfers[mkey].total_size += transferinfo.total_size
+                    transfers[mkey].file_list.extend(transferinfo.file_list)
+                    transfers[mkey].file_list_new.extend(transferinfo.file_list_new)
+                    transfers[mkey].fail_list.extend(transferinfo.fail_list)
 
-                # 计数
-                processed_num += 1
+                # 新增转移成功历史记录
+                self.transferhis.add_success(
+                    src_path=file_path,
+                    mode=settings.TRANSFER_TYPE,
+                    download_hash=download_hash,
+                    meta=file_meta,
+                    mediainfo=file_mediainfo,
+                    transferinfo=transferinfo
+                )
+                # 刮削单个文件
+                if settings.SCRAP_METADATA:
+                    self.scrape_metadata(path=transferinfo.target_path, mediainfo=file_mediainfo)
                 # 更新进度
+                processed_num += 1
                 self.progress.update(value=processed_num / total_num * 100,
-                                     text=f"{torrent.title} 转移完成",
+                                     text=f"{file_path.name} 转移完成",
                                      key=ProgressKey.FileTransfer)
+
+            # 目录或文件转移完成
+            self.progress.update(value=100,
+                                 text=f"所有文件转移完成，正在执行后续处理 ...",
+                                 key=ProgressKey.FileTransfer)
+
+            # 执行后续处理
+            for mkey, media in medias.items():
+                transfer_meta = metas[mkey]
+                transfer_info = transfers[mkey]
+                # 媒体目录
+                if transfer_info.target_path.is_file():
+                    transfer_info.target_path = transfer_info.target_path.parent
+                # 刷新媒体库，根目录或季目录
+                if settings.REFRESH_MEDIASERVER:
+                    self.refresh_mediaserver(mediainfo=media, file_path=transfer_info.target_path)
+                # 发送通知
+                se_str = None
+                if media.type == MediaType.TV:
+                    se_str = f"{transfer_meta.season} {StringUtils.format_ep(season_episodes[mkey])}"
+                self.send_transfer_message(meta=transfer_meta,
+                                           mediainfo=media,
+                                           transferinfo=transfer_info,
+                                           season_episode=se_str)
+                # 广播事件
+                self.eventmanager.send_event(EventType.TransferComplete, {
+                    'meta': transfer_meta,
+                    'mediainfo': media,
+                    'transferinfo': transfer_info
+                })
             # 结束进度
+            logger.info(f"{path} 转移完成，共 {total_num} 个文件，"
+                        f"成功 {total_num - len(err_msgs)} 个，失败 {len(err_msgs)} 个")
             self.progress.end(ProgressKey.FileTransfer)
-            logger.info("下载器文件转移执行完成")
-            return True
+
+        return True, "\n".join(err_msgs)
 
     @staticmethod
     def __get_trans_paths(directory: Path):
@@ -188,18 +403,25 @@ class TransferChain(ChainBase):
             logger.warn(f"目录不存在：{directory}")
             return []
 
+        # 单文件
         if directory.is_file():
             return [directory]
 
+        # 蓝光原盘
+        if SystemUtils.is_bluray_dir(directory):
+            return [directory]
+
         # 需要转移的路径列表
         trans_paths = []
 
         # 先检查当前目录的下级目录，以支持合集的情况
         for sub_dir in SystemUtils.list_sub_directory(directory):
+            # 如果是蓝光原盘
+            if SystemUtils.is_bluray_dir(sub_dir):
+                trans_paths.append(sub_dir)
             # 没有媒体文件的目录跳过
-            if not SystemUtils.list_files(sub_dir, extensions=settings.RMT_MEDIAEXT):
-                continue
-            trans_paths.append(sub_dir)
+            elif SystemUtils.list_files(sub_dir, extensions=settings.RMT_MEDIAEXT):
+                trans_paths.append(sub_dir)
 
         if not trans_paths:
             # 没有有效子目录，直接转移当前目录
@@ -215,6 +437,7 @@ class TransferChain(ChainBase):
         """
         远程重新转移，参数 历史记录ID TMDBID|类型
         """
+
         def args_error():
             self.post_message(Notification(channel=channel,
                                            title="请输入正确的命令格式：/redo [id] [tmdbid]|[类型]，"
@@ -266,10 +489,6 @@ class TransferChain(ChainBase):
         src_path = Path(history.src)
         if not src_path.exists():
             return False, f"源目录不存在：{src_path}"
-        # 识别元数据
-        meta = MetaInfo(title=src_path.stem)
-        if not meta.name:
-            return False, f"未识别到元数据，标题：{src_path.stem}"
         # 查询媒体信息
         mediainfo = self.recognize_media(mtype=mtype, tmdbid=tmdbid)
         if not mediainfo:
@@ -279,123 +498,83 @@ class TransferChain(ChainBase):
         # 更新媒体图片
         self.obtain_images(mediainfo=mediainfo)
 
-        # 转移
-        transferinfo: TransferInfo = self.transfer(mediainfo=mediainfo,
-                                                   path=src_path,
-                                                   transfer_type=settings.TRANSFER_TYPE)
-        if not transferinfo:
-            logger.error("文件转移模块运行失败")
-            return False, "文件转移模块运行失败"
+        # 删除旧的已整理文件
+        if history.dest:
+            self.delete_files(Path(history.dest))
 
-        # 删除旧历史记录
-        self.transferhis.delete(logid)
-
-        if not transferinfo.target_path:
-            # 转移失败
-            logger.warn(f"{src_path} 入库失败：{transferinfo.message}")
-            # 新增转移失败历史记录
-            self.__insert_fail_history(
-                src_path=src_path,
-                download_hash=history.download_hash,
-                meta=meta,
-                mediainfo=mediainfo,
-                transferinfo=transferinfo
-            )
-            return False, transferinfo.message
-
-        # 新增转移成功历史记录
-        self.__insert_sucess_history(
-            src_path=src_path,
-            download_hash=history.download_hash,
-            meta=meta,
-            mediainfo=mediainfo,
-            transferinfo=transferinfo
-        )
-        # 刮削元数据
-        self.scrape_metadata(path=transferinfo.target_path, mediainfo=mediainfo)
-        # 刷新媒体库
-        self.refresh_mediaserver(mediainfo=mediainfo, file_path=transferinfo.target_path)
-        # 发送通知
-        self.send_transfer_message(meta=meta, mediainfo=mediainfo, transferinfo=transferinfo)
-        # 广播事件
-        self.eventmanager.send_event(EventType.TransferComplete, {
-            'meta': meta,
-            'mediainfo': mediainfo,
-            'transferinfo': transferinfo
-        })
+        # 强制转移
+        state, errmsg = self.do_transfer(path=src_path,
+                                         mediainfo=mediainfo,
+                                         download_hash=history.download_hash,
+                                         force=True)
+        if not state:
+            return False, errmsg
 
         return True, ""
 
-    def __insert_sucess_history(self, src_path: Path, download_hash: str, meta: MetaBase,
-                                mediainfo: MediaInfo, transferinfo: TransferInfo):
+    def manual_transfer(self, in_path: Path,
+                        target: Path = None,
+                        tmdbid: int = None,
+                        mtype: MediaType = None,
+                        season: int = None,
+                        transfer_type: str = None,
+                        epformat: EpisodeFormat = None,
+                        min_filesize: int = 0) -> Tuple[bool, Union[str, list]]:
         """
-        新增转移成功历史记录
+        手动转移
+        :param in_path: 源文件路径
+        :param target: 目标路径
+        :param tmdbid: TMDB ID
+        :param mtype: 媒体类型
+        :param season: 季度
+        :param transfer_type: 转移类型
+        :param epformat: 剧集格式
+        :param min_filesize: 最小文件大小(MB)
         """
-        self.transferhis.add(
-            src=str(src_path),
-            dest=str(transferinfo.target_path),
-            mode=settings.TRANSFER_TYPE,
-            type=mediainfo.type.value,
-            category=mediainfo.category,
-            title=mediainfo.title,
-            year=mediainfo.year,
-            tmdbid=mediainfo.tmdb_id,
-            imdbid=mediainfo.imdb_id,
-            tvdbid=mediainfo.tvdb_id,
-            doubanid=mediainfo.douban_id,
-            seasons=meta.season,
-            episodes=meta.episode,
-            image=mediainfo.get_poster_image(),
-            download_hash=download_hash,
-            status=1,
-            files=json.dumps(transferinfo.file_list)
-        )
+        logger.info(f"手动转移：{in_path} ...")
 
-    def __insert_fail_history(self, src_path: Path, download_hash: str, meta: MetaBase,
-                              transferinfo: TransferInfo = None, mediainfo: MediaInfo = None):
-        """
-        新增转移失败历史记录，不能按download_hash判重
-        """
-        if mediainfo and transferinfo:
-            his = self.transferhis.add(
-                src=str(src_path),
-                dest=str(transferinfo.target_path),
-                mode=settings.TRANSFER_TYPE,
-                type=mediainfo.type.value,
-                category=mediainfo.category,
-                title=mediainfo.title or meta.name,
-                year=mediainfo.year or meta.year,
-                tmdbid=mediainfo.tmdb_id,
-                imdbid=mediainfo.imdb_id,
-                tvdbid=mediainfo.tvdb_id,
-                doubanid=mediainfo.douban_id,
-                seasons=meta.season,
-                episodes=meta.episode,
-                image=mediainfo.get_poster_image(),
-                download_hash=download_hash,
-                status=0,
-                errmsg=transferinfo.message or '未知错误',
-                files=json.dumps(transferinfo.file_list)
+        if tmdbid:
+            # 有输入TMDBID时单个识别
+            # 识别媒体信息
+            mediainfo: MediaInfo = self.mediachain.recognize_media(tmdbid=tmdbid, mtype=mtype)
+            if not mediainfo:
+                return False, f"媒体信息识别失败，tmdbid: {tmdbid}, type: {mtype.value}"
+            # 开始进度
+            self.progress.start(ProgressKey.FileTransfer)
+            self.progress.update(value=0,
+                                 text=f"开始转移 {in_path} ...",
+                                 key=ProgressKey.FileTransfer)
+            # 开始转移
+            state, errmsg = self.do_transfer(
+                path=in_path,
+                mediainfo=mediainfo,
+                target=target,
+                season=season,
+                epformat=epformat,
+                min_filesize=min_filesize
             )
+            if not state:
+                return False, errmsg
+
+            self.progress.end(ProgressKey.FileTransfer)
+            logger.info(f"{in_path} 转移完成")
+            return True, ""
         else:
-            his = self.transferhis.add(
-                title=meta.name,
-                year=meta.year,
-                src=str(src_path),
-                mode=settings.TRANSFER_TYPE,
-                seasons=meta.season,
-                episodes=meta.episode,
-                download_hash=download_hash,
-                status=0,
-                errmsg="未识别到媒体信息"
-            )
-        return his
+            # 没有输入TMDBID时，按文件识别
+            state, errmsg = self.do_transfer(path=in_path,
+                                             target=target,
+                                             transfer_type=transfer_type,
+                                             season=season,
+                                             epformat=epformat,
+                                             min_filesize=min_filesize)
+            return state, errmsg
 
-    def send_transfer_message(self, meta: MetaBase, mediainfo: MediaInfo, transferinfo: TransferInfo):
+    def send_transfer_message(self, meta: MetaBase, mediainfo: MediaInfo,
+                              transferinfo: TransferInfo, season_episode: str = None):
         """
         发送入库成功的消息
         """
-        msg_title = f"{mediainfo.title_year} {meta.season_episode} 已入库"
+        msg_title = f"{mediainfo.title_year} {meta.season_episode if not season_episode else season_episode} 已入库"
         if mediainfo.vote_average:
             msg_str = f"评分：{mediainfo.vote_average}，类型：{mediainfo.type.value}"
         else:
@@ -420,22 +599,27 @@ class TransferChain(ChainBase):
         """
         logger.info(f"开始删除文件以及空目录：{path} ...")
         if not path.exists():
-            logger.error(f"{path} 不存在")
             return
-        elif path.is_file():
+        if path.is_file():
             # 删除文件
             path.unlink()
             logger.warn(f"文件 {path} 已删除")
-            # 判断目录是否为空, 为空则删除
-            if str(path.parent.parent) != str(path.root):
-                # 父目录非根目录，才删除父目录
-                files = SystemUtils.list_files(path.parent, settings.RMT_MEDIAEXT)
-                if not files:
-                    shutil.rmtree(path.parent)
-                    logger.warn(f"目录 {path.parent} 已删除")
+            # 需要删除父目录
+        elif str(path.parent) == str(path.root):
+            # 根目录，不删除
+            logger.warn(f"根目录 {path} 不能删除！")
+            return
         else:
-            if str(path.parent) != str(path.root):
-                # 父目录非根目录，才删除目录
-                shutil.rmtree(path)
-                # 删除目录
-                logger.warn(f"目录 {path} 已删除")
+            # 非根目录，才删除目录
+            shutil.rmtree(path)
+            # 删除目录
+            logger.warn(f"目录 {path} 已删除")
+            # 需要删除父目录
+        # 判断父目录是否为空, 为空则删除
+        for parent_path in path.parents:
+            if str(parent_path.parent) != str(path.root):
+                # 父目录非根目录，才删除父目录
+                files = SystemUtils.list_files(parent_path, settings.RMT_MEDIAEXT)
+                if not files:
+                    shutil.rmtree(parent_path)
+                    logger.warn(f"目录 {parent_path} 已删除")

app/command.py

@@ -13,11 +13,12 @@ from app.chain.transfer import TransferChain
 from app.core.event import Event as ManagerEvent
 from app.core.event import eventmanager, EventManager
 from app.core.plugin import PluginManager
-from app.db import SessionLocal
+from app.db import SessionFactory
 from app.log import logger
 from app.schemas.types import EventType, MessageChannel
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
+from app.utils.system import SystemUtils
 
 
 class CommandChian(ChainBase):
@@ -41,7 +42,7 @@ class Command(metaclass=Singleton):
 
     def __init__(self):
         # 数据库连接
-        self._db = SessionLocal()
+        self._db = SessionFactory()
         # 事件管理器
         self.eventmanager = EventManager()
         # 插件管理器
@@ -53,11 +54,13 @@ class Command(metaclass=Singleton):
             "/cookiecloud": {
                 "func": CookieCloudChain(self._db).remote_sync,
                 "description": "同步站点",
+                "category": "站点",
                 "data": {}
             },
             "/sites": {
                 "func": SiteChain(self._db).remote_list,
                 "description": "查询站点",
+                "category": "站点",
                 "data": {}
             },
             "/site_cookie": {
@@ -78,21 +81,25 @@ class Command(metaclass=Singleton):
             "/mediaserver_sync": {
                 "func": MediaServerChain(self._db).remote_sync,
                 "description": "同步媒体服务器",
+                "category": "管理",
                 "data": {}
             },
             "/subscribes": {
                 "func": SubscribeChain(self._db).remote_list,
                 "description": "查询订阅",
+                "category": "订阅",
                 "data": {}
             },
             "/subscribe_refresh": {
                 "func": SubscribeChain(self._db).remote_refresh,
                 "description": "刷新订阅",
+                "category": "订阅",
                 "data": {}
             },
             "/subscribe_search": {
                 "func": SubscribeChain(self._db).remote_search,
                 "description": "搜索订阅",
+                "category": "订阅",
                 "data": {}
             },
             "/subscribe_delete": {
@@ -103,11 +110,13 @@ class Command(metaclass=Singleton):
             "/downloading": {
                 "func": DownloadChain(self._db).remote_downloading,
                 "description": "正在下载",
+                "category": "管理",
                 "data": {}
             },
             "/transfer": {
                 "func": TransferChain(self._db).process,
                 "description": "下载文件整理",
+                "category": "管理",
                 "data": {}
             },
             "/redo": {
@@ -118,6 +127,13 @@ class Command(metaclass=Singleton):
             "/clear_cache": {
                 "func": SystemChain(self._db).remote_clear_cache,
                 "description": "清理缓存",
+                "category": "管理",
+                "data": {}
+            },
+            "/restart": {
+                "func": SystemUtils.restart,
+                "description": "重启系统",
+                "category": "管理",
                 "data": {}
             }
         }
@@ -128,6 +144,7 @@ class Command(metaclass=Singleton):
                 cmd=command.get('cmd'),
                 func=Command.send_plugin_event,
                 desc=command.get('desc'),
+                category=command.get('category'),
                 data={
                     'etype': command.get('event'),
                     'data': command.get('data')
@@ -164,6 +181,8 @@ class Command(metaclass=Singleton):
         """
         self._event.set()
         self._thread.join()
+        if self._db:
+            self._db.close()
 
     def get_commands(self):
         """
@@ -171,13 +190,15 @@ class Command(metaclass=Singleton):
         """
         return self._commands
 
-    def register(self, cmd: str, func: Any, data: dict = None, desc: str = None) -> None:
+    def register(self, cmd: str, func: Any, data: dict = None,
+                 desc: str = None, category: str = None) -> None:
         """
         注册命令
         """
         self._commands[cmd] = {
             "func": func,
             "description": desc,
+            "category": category,
             "data": data or {}
         }
 
@@ -201,6 +222,10 @@ class Command(metaclass=Singleton):
                 if args_num > 0:
                     if cmd_data:
                         # 有内置参数直接使用内置参数
+                        data = cmd_data.get("data") or {}
+                        data['channel'] = channel
+                        data['user'] = userid
+                        cmd_data['data'] = data
                         command['func'](**cmd_data)
                     elif args_num == 2:
                         # 没有输入参数，只输入渠道和用户ID
@@ -242,7 +267,3 @@ class Command(metaclass=Singleton):
             args = " ".join(event_str.split()[1:])
             if self.get(cmd):
                 self.execute(cmd, args, event_channel, event_user)
-
-    def __del__(self):
-        if self._db:
-            self._db.close()

app/core/config.py

@@ -1,5 +1,6 @@
 import secrets
 from pathlib import Path
+from typing import List
 
 from pydantic import BaseSettings
 
@@ -39,6 +40,8 @@ class Settings(BaseSettings):
     SEARCH_SOURCE: str = "themoviedb"
     # 刮削入库的媒体文件
     SCRAP_METADATA: bool = True
+    # 新增已入库媒体是否跟随TMDB信息变化
+    SCRAP_FOLLOW_TMDB: bool = True
     # 刮削来源
     SCRAP_SOURCE: str = "themoviedb"
     # TMDB图片地址
@@ -63,8 +66,16 @@ class Settings(BaseSettings):
     RMT_AUDIO_TRACK_EXT: list = ['.mka']
     # 索引器
     INDEXER: str = "builtin"
-    # 用户认证站点 hhclub/audiences/hddolby/zmpt/freefarm/hdfans/wintersakura/leaves/1ptba/icc2022/iyuu
+    # 订阅模式
+    SUBSCRIBE_MODE: str = "spider"
+    # RSS订阅模式刷新时间间隔（分钟）
+    SUBSCRIBE_RSS_INTERVAL: int = 30
+    # 订阅搜索开关
+    SUBSCRIBE_SEARCH: bool = False
+    # 用户认证站点
     AUTH_SITE: str = ""
+    # 交互搜索自动下载用户ID，使用,分割
+    AUTO_DOWNLOAD_USER: str = None
     # 消息通知渠道 telegram/wechat/slack
     MESSAGER: str = "telegram"
     # WeChat企业ID
@@ -105,6 +116,8 @@ class Settings(BaseSettings):
     QB_USER: str = None
     # Qbittorrent密码
     QB_PASSWORD: str = None
+    # Qbittorrent分类自动管理
+    QB_CATEGORY: bool = False
     # Transmission地址，IP:PORT
     TR_HOST: str = None
     # Transmission用户名
@@ -119,6 +132,8 @@ class Settings(BaseSettings):
     DOWNLOAD_MOVIE_PATH: str = None
     # 电视剧下载保存目录，容器内映射路径需要一致
     DOWNLOAD_TV_PATH: str = None
+    # 动漫下载保存目录，容器内映射路径需要一致
+    DOWNLOAD_ANIME_PATH: str = None
     # 下载目录二级分类
     DOWNLOAD_CATEGORY: bool = False
     # 下载站点字幕
@@ -144,23 +159,29 @@ class Settings(BaseSettings):
     # 转移方式 link/copy/move/softlink
     TRANSFER_TYPE: str = "copy"
     # CookieCloud服务器地址
-    COOKIECLOUD_HOST: str = "https://nastool.org/cookiecloud"
+    COOKIECLOUD_HOST: str = "https://movie-pilot.org/cookiecloud"
     # CookieCloud用户KEY
     COOKIECLOUD_KEY: str = None
     # CookieCloud端对端加密密码
     COOKIECLOUD_PASSWORD: str = None
     # CookieCloud同步间隔（分钟）
     COOKIECLOUD_INTERVAL: int = 60 * 24
+    # OCR服务器地址
+    OCR_HOST: str = "https://movie-pilot.org"
     # CookieCloud对应的浏览器UA
     USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.57"
-    # 媒体库目录
+    # 媒体库目录，多个目录使用,分隔
     LIBRARY_PATH: str = None
     # 电影媒体库目录名，默认"电影"
     LIBRARY_MOVIE_NAME: str = None
     # 电视剧媒体库目录名，默认"电视剧"
     LIBRARY_TV_NAME: str = None
+    # 动漫媒体库目录名，默认"电视剧/动漫"
+    LIBRARY_ANIME_NAME: str = None
     # 二级分类
     LIBRARY_CATEGORY: bool = True
+    # 电视剧动漫的分类genre_ids
+    ANIME_GENREIDS = [16]
     # 电影重命名格式
     MOVIE_RENAME_FORMAT: str = "{{title}}{% if year %} ({{year}}){% endif %}" \
                                "/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}" \
@@ -235,6 +256,12 @@ class Settings(BaseSettings):
                 "server": self.PROXY_HOST
             }
 
+    @property
+    def LIBRARY_PATHS(self) -> List[Path]:
+        if self.LIBRARY_PATH:
+            return [Path(path) for path in self.LIBRARY_PATH.split(",")]
+        return []
+
     def __init__(self):
         super().__init__()
         with self.CONFIG_PATH as p:

app/core/context.py

@@ -148,6 +148,8 @@ class MediaInfo:
     vote_average: int = 0
     # 描述
     overview: str = None
+    # 风格ID
+    genre_ids: list = field(default_factory=list)
     # 所有别名和译名
     names: list = field(default_factory=list)
     # 各季的剧集清单信息
@@ -250,6 +252,15 @@ class MediaInfo:
         """
         setattr(self, f"{name}_path", image)
 
+    def get_image(self, name: str):
+        """
+        获取图片地址
+        """
+        try:
+            return getattr(self, f"{name}_path")
+        except AttributeError:
+            return None
+
     def set_category(self, cat: str):
         """
         设置二级分类
@@ -338,6 +349,8 @@ class MediaInfo:
         self.vote_average = round(float(info.get('vote_average')), 1) if info.get('vote_average') else 0
         # 描述
         self.overview = info.get('overview')
+        # 风格
+        self.genre_ids = info.get('genre_ids') or []
         # 原语种
         self.original_language = info.get('original_language')
         if self.type == MediaType.MOVIE:
@@ -442,6 +455,8 @@ class MediaInfo:
             self.poster_path = info.get("pic", {}).get("large")
             if not self.poster_path and info.get("cover_url"):
                 self.poster_path = info.get("cover_url")
+            if not self.poster_path and info.get("cover"):
+                self.poster_path = info.get("cover").get("url")
         # 简介
         if not self.overview:
             self.overview = info.get("intro") or info.get("card_subtitle") or ""
@@ -549,7 +564,6 @@ class MediaInfo:
         dicts["type"] = self.type.value if self.type else None
         dicts["detail_link"] = self.detail_link
         dicts["title_year"] = self.title_year
-        dicts["tmdb_info"]["media_type"] = self.type.value if self.type else None
         return dicts
 
     def clear(self):

app/core/meta/metabase.py

@@ -15,9 +15,9 @@ class MetaBase(object):
     """
     # 是否处理的文件
     isfile: bool = False
-    # 原标题字符串
+    # 原标题字符串（未经过识别词处理）
     title: str = ""
-    # 识别用字符串
+    # 识别用字符串（经过识别词处理后）
     org_string: Optional[str] = None
     # 副标题
     subtitle: Optional[str] = None
@@ -243,7 +243,7 @@ class MetaBase(object):
         else:
             return [self.begin_season]
 
-    @ property
+    @property
     def episode(self) -> str:
         """
         返回开始集、结束集字符串
@@ -440,9 +440,21 @@ class MetaBase(object):
             elif len(ep) > 1 and str(ep[0]).isdigit() and str(ep[-1]).isdigit():
                 self.begin_episode = int(ep[0])
                 self.end_episode = int(ep[-1])
+                self.total_episode = (self.end_episode - self.begin_episode) + 1
         elif str(ep).isdigit():
             self.begin_episode = int(ep)
             self.end_episode = None
+
+    def set_episodes(self, begin: int, end: int):
+        """
+        设置开始集结束集
+        """
+        if begin:
+            self.begin_episode = begin
+        if end:
+            self.end_episode = end
+        if self.begin_episode and self.end_episode:
+            self.total_episode = (self.end_episode - self.begin_episode) + 1
             
     def merge(self, meta: Self):
         """

app/core/meta/metavideo.py

@@ -371,6 +371,8 @@ class MetaVideo(MetaBase):
                 self.type = MediaType.TV
         elif token.upper() == "SEASON" and self.begin_season is None:
             self._last_token_type = "SEASON"
+        elif self.type == MediaType.TV and self.begin_season is None:
+            self.begin_season = 1
 
     def __init_episode(self, token: str):
         re_res = re.findall(r"%s" % self._episode_re, token, re.IGNORECASE)

app/core/meta/words.py

@@ -28,7 +28,23 @@ class WordsMatcher(metaclass=Singleton):
             if not word:
                 continue
             try:
-                if word.count(" => "):
+                if word.count(" => ") and word.count(" && ") and word.count(" >> ") and word.count(" <> "):
+                    # 替换词
+                    thc = str(re.findall(r'(.*?)\s*=>', word)[0]).strip()
+                    # 被替换词
+                    bthc = str(re.findall(r'=>\s*(.*?)\s*&&', word)[0]).strip()
+                    # 集偏移前字段
+                    pyq = str(re.findall(r'&&\s*(.*?)\s*<>', word)[0]).strip()
+                    # 集偏移后字段
+                    pyh = str(re.findall(r'<>(.*?)\s*>>', word)[0]).strip()
+                    # 集偏移
+                    offsets = str(re.findall(r'>>\s*(.*?)$', word)[0]).strip()
+                    # 替换词
+                    title, message, state = self.__replace_regex(title, thc, bthc)
+                    if state:
+                        # 替换词成功再进行集偏移
+                        title, message, state = self.__episode_offset(title, pyq, pyh, offsets)
+                elif word.count(" => "):
                     # 替换词
                     strings = word.split(" => ")
                     title, message, state = self.__replace_regex(title, strings[0], strings[1])

app/core/plugin.py

@@ -3,6 +3,7 @@ from typing import List, Any, Dict, Tuple
 
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.module import ModuleHelper
+from app.helper.sites import SitesHelper
 from app.log import logger
 from app.schemas.types import SystemConfigKey
 from app.utils.object import ObjectUtils
@@ -23,6 +24,7 @@ class PluginManager(metaclass=Singleton):
     _config_key: str = "plugin.%s"
 
     def __init__(self):
+        self.siteshelper = SitesHelper()
         self.init_config()
 
     def init_config(self):
@@ -37,6 +39,7 @@ class PluginManager(metaclass=Singleton):
         """
         启动加载插件
         """
+
         # 扫描插件目录
         plugins = ModuleHelper.load(
             "app.plugins",
@@ -80,8 +83,15 @@ class PluginManager(metaclass=Singleton):
         """
         # 停止所有插件
         for plugin in self._running_plugins.values():
+            # 关闭数据库
+            if hasattr(plugin, "close"):
+                plugin.close()
+            # 关闭插件
             if hasattr(plugin, "stop_service"):
                 plugin.stop_service()
+        # 清空对像
+        self._plugins = {}
+        self._running_plugins = {}
 
     def get_plugin_config(self, pid: str) -> dict:
         """
@@ -176,6 +186,8 @@ class PluginManager(metaclass=Singleton):
         # 已安装插件
         installed_apps = self.systemconfig.get(SystemConfigKey.UserInstalledPlugins) or []
         for pid, plugin in self._plugins.items():
+            # 运行状插件
+            plugin_obj = self._running_plugins.get(pid)
             # 基本属性
             conf = {}
             # ID
@@ -186,11 +198,20 @@ class PluginManager(metaclass=Singleton):
             else:
                 conf.update({"installed": False})
             # 运行状态
-            if pid in self._running_plugins.keys() and hasattr(plugin, "get_state"):
-                plugin_obj = self._running_plugins.get(pid)
+            if plugin_obj and hasattr(plugin, "get_state"):
                 conf.update({"state": plugin_obj.get_state()})
             else:
                 conf.update({"state": False})
+            # 是否有详情页面
+            if hasattr(plugin, "get_page"):
+                if ObjectUtils.check_method(plugin.get_page):
+                    conf.update({"has_page": True})
+                else:
+                    conf.update({"has_page": False})
+            # 权限
+            if hasattr(plugin, "auth_level"):
+                if self.siteshelper.auth_level < plugin.auth_level:
+                    continue
             # 名称
             if hasattr(plugin, "plugin_name"):
                 conf.update({"plugin_name": plugin.plugin_name})

app/db/__init__.py

@@ -1,5 +1,5 @@
 from sqlalchemy import create_engine, QueuePool
-from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.orm import sessionmaker, Session, scoped_session
 
 from app.core.config import settings
 
@@ -8,11 +8,16 @@ Engine = create_engine(f"sqlite:///{settings.CONFIG_PATH}/user.db",
                        pool_pre_ping=True,
                        echo=False,
                        poolclass=QueuePool,
-                       pool_size=1000,
-                       pool_recycle=60 * 10,
-                       max_overflow=0)
-# 数据库会话
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=Engine)
+                       pool_size=1024,
+                       pool_recycle=600,
+                       pool_timeout=180,
+                       max_overflow=0,
+                       connect_args={"timeout": 60})
+# 会话工厂
+SessionFactory = sessionmaker(autocommit=False, autoflush=False, bind=Engine)
+
+# 多线程全局使用的数据库会话
+ScopedSession = scoped_session(SessionFactory)
 
 
 def get_db():
@@ -22,7 +27,7 @@ def get_db():
     """
     db = None
     try:
-        db = SessionLocal()
+        db = SessionFactory()
         yield db
     finally:
         if db:
@@ -30,15 +35,10 @@ def get_db():
 
 
 class DbOper:
-
     _db: Session = None
 
     def __init__(self, db: Session = None):
         if db:
             self._db = db
         else:
-            self._db = SessionLocal()
-
-    def __del__(self):
-        if self._db:
-            self._db.close()
+            self._db = ScopedSession()

app/db/downloadhistory_oper.py

@@ -1,8 +1,8 @@
 from pathlib import Path
-from typing import Any
+from typing import List
 
 from app.db import DbOper
-from app.db.models.downloadhistory import DownloadHistory
+from app.db.models.downloadhistory import DownloadHistory, DownloadFiles
 
 
 class DownloadHistoryOper(DbOper):
@@ -10,28 +10,71 @@ class DownloadHistoryOper(DbOper):
     下载历史管理
     """
 
-    def get_by_path(self, path: Path) -> Any:
+    def get_by_path(self, path: Path) -> DownloadHistory:
         """
         按路径查询下载记录
         :param path: 数据key
         """
         return DownloadHistory.get_by_path(self._db, str(path))
 
-    def get_by_hash(self, download_hash: str) -> Any:
+    def get_by_hash(self, download_hash: str) -> DownloadHistory:
         """
         按Hash查询下载记录
         :param download_hash: 数据key
         """
         return DownloadHistory.get_by_hash(self._db, download_hash)
 
-    def add(self, **kwargs):
+    def add(self, **kwargs) -> DownloadHistory:
         """
         新增下载历史
         """
         downloadhistory = DownloadHistory(**kwargs)
         return downloadhistory.create(self._db)
 
-    def list_by_page(self, page: int = 1, count: int = 30):
+    def add_files(self, file_items: List[dict]):
+        """
+        新增下载历史文件
+        """
+        for file_item in file_items:
+            downloadfile = DownloadFiles(**file_item)
+            downloadfile.create(self._db)
+
+    def truncate_files(self):
+        """
+        清空下载历史文件记录
+        """
+        DownloadFiles.truncate(self._db)
+
+    def get_files_by_hash(self, download_hash: str, state: int = None) -> List[DownloadFiles]:
+        """
+        按Hash查询下载文件记录
+        :param download_hash: 数据key
+        :param state: 删除状态
+        """
+        return DownloadFiles.get_by_hash(self._db, download_hash, state)
+
+    def get_file_by_fullpath(self, fullpath: str) -> DownloadFiles:
+        """
+        按fullpath查询下载文件记录
+        :param fullpath: 数据key
+        """
+        return DownloadFiles.get_by_fullpath(self._db, fullpath)
+
+    def get_files_by_savepath(self, fullpath: str) -> List[DownloadFiles]:
+        """
+        按savepath查询下载文件记录
+        :param fullpath: 数据key
+        """
+        return DownloadFiles.get_by_savepath(self._db, fullpath)
+
+    def delete_file_by_fullpath(self, fullpath: str):
+        """
+        按fullpath删除下载文件记录
+        :param fullpath: 数据key
+        """
+        DownloadFiles.delete_by_fullpath(self._db, fullpath)
+
+    def list_by_page(self, page: int = 1, count: int = 30) -> List[DownloadHistory]:
         """
         分页查询下载历史
         """
@@ -44,7 +87,7 @@ class DownloadHistoryOper(DbOper):
         DownloadHistory.truncate(self._db)
 
     def get_last_by(self, mtype=None, title: str = None, year: str = None,
-                    season: str = None, episode: str = None, tmdbid=None):
+                    season: str = None, episode: str = None, tmdbid=None) -> List[DownloadHistory]:
         """
         按类型、标题、年份、季集查询下载记录
         """

app/db/init.py

@@ -6,7 +6,7 @@ from alembic.config import Config
 
 from app.core.config import settings
 from app.core.security import get_password_hash
-from app.db import Engine, SessionLocal
+from app.db import Engine, SessionFactory
 from app.db.models import Base
 from app.db.models.user import User
 from app.log import logger
@@ -22,15 +22,16 @@ def init_db():
     # 全量建表
     Base.metadata.create_all(bind=Engine)
     # 初始化超级管理员
-    _db = SessionLocal()
-    user = User.get_by_name(db=_db, name=settings.SUPERUSER)
+    db = SessionFactory()
+    user = User.get_by_name(db=db, name=settings.SUPERUSER)
     if not user:
         user = User(
             name=settings.SUPERUSER,
             hashed_password=get_password_hash(settings.SUPERUSER_PASSWORD),
             is_superuser=True,
         )
-        user.create(_db)
+        user.create(db)
+    db.close()
 
 
 def update_db():

app/db/models/__init__.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from sqlalchemy.orm import as_declarative, declared_attr
+from sqlalchemy.orm import as_declarative, declared_attr, Session
 
 
 @as_declarative()
@@ -8,33 +8,41 @@ class Base:
     id: Any
     __name__: str
 
-    def create(self, db):
+    @staticmethod
+    def commit(db: Session):
+        try:
+            db.commit()
+        except Exception as err:
+            db.rollback()
+            raise err
+
+    def create(self, db: Session):
         db.add(self)
-        db.commit()
+        self.commit(db)
         return self
 
     @classmethod
-    def get(cls, db, rid: int):
+    def get(cls, db: Session, rid: int):
         return db.query(cls).filter(cls.id == rid).first()
 
-    def update(self, db, payload: dict):
+    def update(self, db: Session, payload: dict):
         payload = {k: v for k, v in payload.items() if v is not None}
         for key, value in payload.items():
             setattr(self, key, value)
-        db.commit()
+        Base.commit(db)
 
     @classmethod
-    def delete(cls, db, rid):
+    def delete(cls, db: Session, rid):
         db.query(cls).filter(cls.id == rid).delete()
-        db.commit()
+        Base.commit(db)
 
     @classmethod
-    def truncate(cls, db):
+    def truncate(cls, db: Session):
         db.query(cls).delete()
-        db.commit()
+        Base.commit(db)
 
     @classmethod
-    def list(cls, db):
+    def list(cls, db: Session):
         return db.query(cls).all()
 
     def to_dict(self):

app/db/models/downloadhistory.py

@@ -52,7 +52,7 @@ class DownloadHistory(Base):
 
     @staticmethod
     def get_last_by(db: Session, mtype: str = None, title: str = None, year: int = None, season: str = None,
-                    episode: str = None, tmdbid: str = None):
+                    episode: str = None, tmdbid: int = None):
         """
         据tmdbid、season、season_episode查询转移记录
         """
@@ -89,3 +89,51 @@ class DownloadHistory(Base):
                                                     DownloadHistory.seasons == season,
                                                     DownloadHistory.episodes == episode).order_by(
                 DownloadHistory.id.desc()).all()
+
+
+class DownloadFiles(Base):
+    """
+    下载文件记录
+    """
+    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    # 下载任务Hash
+    download_hash = Column(String, index=True)
+    # 下载器
+    downloader = Column(String)
+    # 完整路径
+    fullpath = Column(String, index=True)
+    # 保存路径
+    savepath = Column(String, index=True)
+    # 文件相对路径/名称
+    filepath = Column(String)
+    # 种子名称
+    torrentname = Column(String)
+    # 状态 0-已删除 1-正常
+    state = Column(Integer, nullable=False, default=1)
+
+    @staticmethod
+    def get_by_hash(db: Session, download_hash: str, state: int = None):
+        if state:
+            return db.query(DownloadFiles).filter(DownloadFiles.download_hash == download_hash,
+                                                  DownloadFiles.state == state).all()
+        else:
+            return db.query(DownloadFiles).filter(DownloadFiles.download_hash == download_hash).all()
+
+    @staticmethod
+    def get_by_fullpath(db: Session, fullpath: str):
+        return db.query(DownloadFiles).filter(DownloadFiles.fullpath == fullpath).order_by(
+            DownloadFiles.id.desc()).first()
+
+    @staticmethod
+    def get_by_savepath(db: Session, savepath: str):
+        return db.query(DownloadFiles).filter(DownloadFiles.savepath == savepath).all()
+
+    @staticmethod
+    def delete_by_fullpath(db: Session, fullpath: str):
+        db.query(DownloadFiles).filter(DownloadFiles.fullpath == fullpath,
+                                       DownloadFiles.state == 1).update(
+            {
+                "state": 0
+            }
+        )
+        Base.commit(db)

app/db/models/mediaserver.py

@@ -47,7 +47,7 @@ class MediaServerItem(Base):
     @staticmethod
     def empty(db: Session, server: str):
         db.query(MediaServerItem).filter(MediaServerItem.server == server).delete()
-        db.commit()
+        Base.commit(db)
 
     @staticmethod
     def exist_by_tmdbid(db: Session, tmdbid: int, mtype: str):

app/db/models/plugin.py

@@ -23,7 +23,8 @@ class PluginData(Base):
 
     @staticmethod
     def del_plugin_data_by_key(db: Session, plugin_id: str, key: str):
-        return db.query(PluginData).filter(PluginData.plugin_id == plugin_id, PluginData.key == key).delete()
+        db.query(PluginData).filter(PluginData.plugin_id == plugin_id, PluginData.key == key).delete()
+        Base.commit(db)
 
     @staticmethod
     def get_plugin_data_by_plugin_id(db: Session, plugin_id: str):

app/db/models/rss.py

@@ -1,66 +0,0 @@
-from sqlalchemy import Column, Integer, String, Sequence
-from sqlalchemy.orm import Session
-
-from app.db.models import Base
-
-
-class Rss(Base):
-    """
-    RSS订阅
-    """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
-    # 名称
-    name = Column(String, nullable=False)
-    # RSS地址
-    url = Column(String, nullable=False)
-    # 类型
-    type = Column(String)
-    # 标题
-    title = Column(String)
-    # 年份
-    year = Column(String)
-    # TMDBID
-    tmdbid = Column(Integer, index=True)
-    # 季号
-    season = Column(Integer)
-    # 海报
-    poster = Column(String)
-    # 背景图
-    backdrop = Column(String)
-    # 评分
-    vote = Column(Integer)
-    # 简介
-    description = Column(String)
-    # 总集数
-    total_episode = Column(Integer)
-    # 包含
-    include = Column(String)
-    # 排除
-    exclude = Column(String)
-    # 洗版
-    best_version = Column(Integer)
-    # 是否使用代理服务器
-    proxy = Column(Integer)
-    # 是否使用过滤规则
-    filter = Column(Integer)
-    # 保存路径
-    save_path = Column(String)
-    # 已处理数量
-    processed = Column(Integer)
-    # 附加信息，已处理数据
-    note = Column(String)
-    # 最后更新时间
-    last_update = Column(String)
-    # 状态 0-停用，1-启用
-    state = Column(Integer, default=1)
-
-    @staticmethod
-    def get_by_tmdbid(db: Session, tmdbid: int, season: int = None):
-        if season:
-            return db.query(Rss).filter(Rss.tmdbid == tmdbid,
-                                        Rss.season == season).all()
-        return db.query(Rss).filter(Rss.tmdbid == tmdbid).all()
-
-    @staticmethod
-    def get_by_title(db: Session, title: str):
-        return db.query(Rss).filter(Rss.title == title).first()

app/db/models/site.py

@@ -61,4 +61,4 @@ class Site(Base):
     @staticmethod
     def reset(db: Session):
         db.query(Site).delete()
-        db.commit()
+        Base.commit(db)

app/db/models/subscribe.py

@@ -49,6 +49,8 @@ class Subscribe(Base):
     state = Column(String, nullable=False, index=True, default='N')
     # 最后更新时间
     last_update = Column(String)
+    # 创建时间
+    date = Column(String)
     # 订阅用户
     username = Column(String)
     # 订阅站点

app/db/models/transferhistory.py

@@ -25,7 +25,7 @@ class TransferHistory(Base):
     title = Column(String, index=True)
     # 年份
     year = Column(String)
-    tmdbid = Column(Integer)
+    tmdbid = Column(Integer, index=True)
     imdbid = Column(String)
     tvdbid = Column(Integer)
     doubanid = Column(String)
@@ -85,32 +85,75 @@ class TransferHistory(Base):
         return db.query(func.count(TransferHistory.id)).filter(TransferHistory.title.like(f'%{title}%')).first()[0]
 
     @staticmethod
-    def list_by(db: Session, title: str = None, year: int = None, season: str = None,
-                episode: str = None, tmdbid: str = None):
+    def list_by(db: Session, mtype: str = None, title: str = None, year: str = None, season: str = None,
+                episode: str = None, tmdbid: int = None, dest: str = None):
         """
         据tmdbid、season、season_episode查询转移记录
+        tmdbid + mtype 或 title + year 必输
         """
-        if tmdbid and not season and not episode:
-            return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid).all()
-        if tmdbid and season and not episode:
-            return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
-                                                    TransferHistory.seasons == season).all()
-        if tmdbid and season and episode:
-            return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
-                                                    TransferHistory.seasons == season,
-                                                    TransferHistory.episodes == episode).all()
-        # 电视剧所有季集｜电影
-        if not season and not episode:
-            return db.query(TransferHistory).filter(TransferHistory.title == title,
-                                                    TransferHistory.year == year).all()
-        # 电视剧某季
-        if season and not episode:
-            return db.query(TransferHistory).filter(TransferHistory.title == title,
-                                                    TransferHistory.year == year,
-                                                    TransferHistory.seasons == season).all()
-        # 电视剧某季某集
-        if season and episode:
-            return db.query(TransferHistory).filter(TransferHistory.title == title,
-                                                    TransferHistory.year == year,
-                                                    TransferHistory.seasons == season,
-                                                    TransferHistory.episodes == episode).all()
+        # TMDBID + 类型
+        if tmdbid and mtype:
+            # 电视剧某季某集
+            if season and episode:
+                return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                        TransferHistory.type == mtype,
+                                                        TransferHistory.seasons == season,
+                                                        TransferHistory.episodes == episode,
+                                                        TransferHistory.dest == dest).all()
+            # 电视剧某季
+            elif season:
+                return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                        TransferHistory.type == mtype,
+                                                        TransferHistory.seasons == season).all()
+            else:
+                if dest:
+                    # 电影
+                    return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                            TransferHistory.type == mtype,
+                                                            TransferHistory.dest == dest).all()
+                else:
+                    # 电视剧所有季集
+                    return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                            TransferHistory.type == mtype).all()
+        # 标题 + 年份
+        elif title and year:
+            # 电视剧某季某集
+            if season and episode:
+                return db.query(TransferHistory).filter(TransferHistory.title == title,
+                                                        TransferHistory.year == year,
+                                                        TransferHistory.seasons == season,
+                                                        TransferHistory.episodes == episode,
+                                                        TransferHistory.dest == dest).all()
+            # 电视剧某季
+            elif season:
+                return db.query(TransferHistory).filter(TransferHistory.title == title,
+                                                        TransferHistory.year == year,
+                                                        TransferHistory.seasons == season).all()
+            else:
+                if dest:
+                    # 电影
+                    return db.query(TransferHistory).filter(TransferHistory.title == title,
+                                                            TransferHistory.year == year,
+                                                            TransferHistory.dest == dest).all()
+                else:
+                    # 电视剧所有季集
+                    return db.query(TransferHistory).filter(TransferHistory.title == title,
+                                                            TransferHistory.year == year).all()
+        return []
+
+    @staticmethod
+    def get_by_type_tmdbid(db: Session, mtype: str = None, tmdbid: int = None):
+        """
+        据tmdbid、type查询转移记录
+        """
+        return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                TransferHistory.type == mtype).first()
+
+    @staticmethod
+    def update_download_hash(db: Session, historyid: int = None, download_hash: str = None):
+        db.query(TransferHistory).filter(TransferHistory.id == historyid).update(
+            {
+                "download_hash": download_hash
+            }
+        )
+        Base.commit(db)

app/db/plugindata_oper.py

@@ -2,7 +2,6 @@ import json
 from typing import Any
 
 from app.db import DbOper
-from app.db.models import Base
 from app.db.models.plugin import PluginData
 from app.utils.object import ObjectUtils
 
@@ -12,7 +11,7 @@ class PluginDataOper(DbOper):
     插件数据管理
     """
 
-    def save(self, plugin_id: str, key: str, value: Any) -> Base:
+    def save(self, plugin_id: str, key: str, value: Any) -> PluginData:
         """
         保存插件数据
         :param plugin_id: 插件id

app/db/rss_oper.py

@@ -1,57 +0,0 @@
-from typing import List
-
-from sqlalchemy.orm import Session
-
-from app.db import DbOper
-from app.db.models.rss import Rss
-
-
-class RssOper(DbOper):
-    """
-    RSS订阅数据管理
-    """
-
-    def __init__(self, db: Session = None):
-        super().__init__(db)
-
-    def add(self, **kwargs) -> bool:
-        """
-        新增RSS订阅
-        """
-        item = Rss(**kwargs)
-        item.create(self._db)
-        return True
-
-    def exists(self, tmdbid: int, season: int = None):
-        """
-        判断是否存在
-        """
-        return Rss.get_by_tmdbid(self._db, tmdbid, season)
-
-    def list(self, rssid: int = None) -> List[Rss]:
-        """
-        查询所有RSS订阅
-        """
-        if rssid:
-            return [Rss.get(self._db, rssid)]
-        return Rss.list(self._db)
-
-    def delete(self, rssid: int) -> bool:
-        """
-        删除RSS订阅
-        """
-        item = Rss.get(self._db, rssid)
-        if item:
-            item.delete(self._db)
-            return True
-        return False
-
-    def update(self, rssid: int, **kwargs) -> bool:
-        """
-        更新RSS订阅
-        """
-        item = Rss.get(self._db, rssid)
-        if item:
-            item.update(self._db, kwargs)
-            return True
-        return False

app/db/site_oper.py

@@ -19,7 +19,7 @@ class SiteOper(DbOper):
             return True, "新增站点成功"
         return False, "站点已存在"
 
-    def get(self, sid: int):
+    def get(self, sid: int) -> Site:
         """
         查询单个站点
         """
@@ -31,7 +31,7 @@ class SiteOper(DbOper):
         """
         return Site.list(self._db)
 
-    def list_active(self):
+    def list_active(self) -> List[Site]:
         """
         按状态获取站点列表
         """
@@ -41,9 +41,9 @@ class SiteOper(DbOper):
         """
         删除站点
         """
-        return Site.delete(self._db, sid)
+        Site.delete(self._db, sid)
 
-    def update(self, sid: int, payload: dict):
+    def update(self, sid: int, payload: dict) -> Site:
         """
         更新站点
         """
@@ -74,3 +74,15 @@ class SiteOper(DbOper):
             "cookie": cookies
         })
         return True, "更新站点Cookie成功"
+
+    def update_rss(self, domain: str, rss: str) -> Tuple[bool, str]:
+        """
+        更新站点rss
+        """
+        site = Site.get_by_domain(self._db, domain)
+        if not site:
+            return False, "站点不存在"
+        site.update(self._db, {
+            "rss": rss
+        })
+        return True, "更新站点RSS地址成功"

app/db/subscribe_oper.py

@@ -1,3 +1,4 @@
+import time
 from typing import Tuple, List
 
 from app.core.context import MediaInfo
@@ -26,13 +27,14 @@ class SubscribeOper(DbOper):
                                   backdrop=mediainfo.get_backdrop_image(),
                                   vote=mediainfo.vote_average,
                                   description=mediainfo.overview,
+                                  date=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
                                   **kwargs)
             subscribe.create(self._db)
             return subscribe.id, "新增订阅成功"
         else:
             return subscribe.id, "订阅已存在"
 
-    def exists(self, tmdbid: int, season: int):
+    def exists(self, tmdbid: int, season: int) -> bool:
         """
         判断是否存在
         """
@@ -61,7 +63,7 @@ class SubscribeOper(DbOper):
         """
         Subscribe.delete(self._db, rid=sid)
 
-    def update(self, sid: int, payload: dict):
+    def update(self, sid: int, payload: dict) -> Subscribe:
         """
         更新订阅
         """

app/db/systemconfig_oper.py

@@ -1,9 +1,7 @@
 import json
 from typing import Any, Union
 
-from sqlalchemy.orm import Session
-
-from app.db import DbOper
+from app.db import DbOper, SessionFactory
 from app.db.models.systemconfig import SystemConfig
 from app.schemas.types import SystemConfigKey
 from app.utils.object import ObjectUtils
@@ -14,11 +12,12 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
     # 配置对象
     __SYSTEMCONF: dict = {}
 
-    def __init__(self, db: Session = None):
+    def __init__(self):
         """
         加载配置到内存
         """
-        super().__init__(db)
+        self._db = SessionFactory()
+        super().__init__(self._db)
         for item in SystemConfig.list(self._db):
             if ObjectUtils.is_obj(item.value):
                 self.__SYSTEMCONF[item.key] = json.loads(item.value)
@@ -35,18 +34,20 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
         self.__SYSTEMCONF[key] = value
         # 写入数据库
         if ObjectUtils.is_obj(value):
-            if value is not None:
-                value = json.dumps(value)
-            else:
-                value = ''
+            value = json.dumps(value)
+        elif value is None:
+            value = ''
         conf = SystemConfig.get_by_key(self._db, key)
         if conf:
-            conf.update(self._db, {"value": value})
+            if value:
+                conf.update(self._db, {"value": value})
+            else:
+                conf.delete(self._db, conf.id)
         else:
             conf = SystemConfig(key=key, value=value)
             conf.create(self._db)
 
-    def get(self, key: Union[str, SystemConfigKey] = None):
+    def get(self, key: Union[str, SystemConfigKey] = None) -> Any:
         """
         获取系统设置
         """
@@ -55,3 +56,7 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
         if not key:
             return self.__SYSTEMCONF
         return self.__SYSTEMCONF.get(key)
+
+    def __del__(self):
+        if self._db:
+            self._db.close()

app/db/transferhistory_oper.py

@@ -1,8 +1,13 @@
+import json
 import time
-from typing import Any
+from pathlib import Path
+from typing import Any, List
 
+from app.core.context import MediaInfo
+from app.core.meta import MetaBase
 from app.db import DbOper
 from app.db.models.transferhistory import TransferHistory
+from app.schemas import TransferInfo
 
 
 class TransferHistoryOper(DbOper):
@@ -10,28 +15,28 @@ class TransferHistoryOper(DbOper):
     转移历史管理
     """
 
-    def get(self, historyid: int) -> Any:
+    def get(self, historyid: int) -> TransferHistory:
         """
         获取转移历史
         :param historyid: 转移历史id
         """
         return TransferHistory.get(self._db, historyid)
 
-    def get_by_title(self, title: str) -> Any:
+    def get_by_title(self, title: str) -> List[TransferHistory]:
         """
         按标题查询转移记录
         :param title: 数据key
         """
         return TransferHistory.list_by_title(self._db, title)
 
-    def get_by_src(self, src: str) -> Any:
+    def get_by_src(self, src: str) -> TransferHistory:
         """
         按源查询转移记录
         :param src: 数据key
         """
         return TransferHistory.get_by_src(self._db, src)
 
-    def add(self, **kwargs):
+    def add(self, **kwargs) -> TransferHistory:
         """
         新增转移历史
         """
@@ -40,24 +45,34 @@ class TransferHistoryOper(DbOper):
         })
         return TransferHistory(**kwargs).create(self._db)
 
-    def statistic(self, days: int = 7):
+    def statistic(self, days: int = 7) -> List[Any]:
         """
         统计最近days天的下载历史数量
         """
         return TransferHistory.statistic(self._db, days)
 
-    def get_by(self, title: str = None, year: str = None,
-               season: str = None, episode: str = None, tmdbid: str = None) -> Any:
+    def get_by(self, title: str = None, year: str = None, mtype: str = None,
+               season: str = None, episode: str = None, tmdbid: int = None, dest: str = None) -> List[TransferHistory]:
         """
         按类型、标题、年份、季集查询转移记录
         """
         return TransferHistory.list_by(db=self._db,
+                                       mtype=mtype,
                                        title=title,
+                                       dest=dest,
                                        year=year,
                                        season=season,
                                        episode=episode,
                                        tmdbid=tmdbid)
 
+    def get_by_type_tmdbid(self, mtype: str = None, tmdbid: int = None) -> TransferHistory:
+        """
+        按类型、tmdb查询转移记录
+        """
+        return TransferHistory.get_by_type_tmdbid(db=self._db,
+                                                  mtype=mtype,
+                                                  tmdbid=tmdbid)
+
     def delete(self, historyid):
         """
         删除转移记录
@@ -70,7 +85,7 @@ class TransferHistoryOper(DbOper):
         """
         TransferHistory.truncate(self._db)
 
-    def add_force(self, **kwargs):
+    def add_force(self, **kwargs) -> TransferHistory:
         """
         新增转移历史，相同源目录的记录会被删除
         """
@@ -78,4 +93,79 @@ class TransferHistoryOper(DbOper):
             transferhistory = TransferHistory.get_by_src(self._db, kwargs.get("src"))
             if transferhistory:
                 transferhistory.delete(self._db, transferhistory.id)
+        kwargs.update({
+            "date": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+        })
         return TransferHistory(**kwargs).create(self._db)
+
+    def update_download_hash(self, historyid, download_hash):
+        """
+        补充转移记录download_hash
+        """
+        TransferHistory.update_download_hash(self._db, historyid, download_hash)
+
+    def add_success(self, src_path: Path, mode: str, meta: MetaBase,
+                    mediainfo: MediaInfo, transferinfo: TransferInfo,
+                    download_hash: str = None):
+        """
+        新增转移成功历史记录
+        """
+        self.add_force(
+            src=str(src_path),
+            dest=str(transferinfo.target_path),
+            mode=mode,
+            type=mediainfo.type.value,
+            category=mediainfo.category,
+            title=mediainfo.title,
+            year=mediainfo.year,
+            tmdbid=mediainfo.tmdb_id,
+            imdbid=mediainfo.imdb_id,
+            tvdbid=mediainfo.tvdb_id,
+            doubanid=mediainfo.douban_id,
+            seasons=meta.season,
+            episodes=meta.episode,
+            image=mediainfo.get_poster_image(),
+            download_hash=download_hash,
+            status=1,
+            files=json.dumps(transferinfo.file_list)
+        )
+
+    def add_fail(self, src_path: Path, mode: str, meta: MetaBase, mediainfo: MediaInfo = None,
+                 transferinfo: TransferInfo = None, download_hash: str = None):
+        """
+        新增转移失败历史记录
+        """
+        if mediainfo and transferinfo:
+            his = self.add_force(
+                src=str(src_path),
+                dest=str(transferinfo.target_path),
+                mode=mode,
+                type=mediainfo.type.value,
+                category=mediainfo.category,
+                title=mediainfo.title or meta.name,
+                year=mediainfo.year or meta.year,
+                tmdbid=mediainfo.tmdb_id,
+                imdbid=mediainfo.imdb_id,
+                tvdbid=mediainfo.tvdb_id,
+                doubanid=mediainfo.douban_id,
+                seasons=meta.season,
+                episodes=meta.episode,
+                image=mediainfo.get_poster_image(),
+                download_hash=download_hash,
+                status=0,
+                errmsg=transferinfo.message or '未知错误',
+                files=json.dumps(transferinfo.file_list)
+            )
+        else:
+            his = self.add_force(
+                title=meta.name,
+                year=meta.year,
+                src=str(src_path),
+                mode=mode,
+                seasons=meta.season,
+                episodes=meta.episode,
+                download_hash=download_hash,
+                status=0,
+                errmsg="未识别到媒体信息"
+            )
+        return his

app/helper/format.py

@@ -0,0 +1,108 @@
+import re
+from typing import Tuple, Optional
+
+import parse
+
+
+class FormatParser(object):
+    _key = ""
+    _split_chars = r"\.|\s+|\(|\)|\[|]|-|\+|【|】|/|～|;|&|\||#|_|「|」|~"
+
+    def __init__(self, eformat: str, details: str = None, part: str = None,
+                 offset: int = None, key: str = "ep"):
+        """
+        :params eformat: 格式化字符串
+        :params details: 格式化详情
+        :params part: 分集
+        :params offset: 偏移量
+        :prams key: EP关键字
+        """
+        self._format = eformat
+        self._start_ep = None
+        self._end_ep = None
+        self._part = None
+        if part:
+            self._part = part
+        if details:
+            if re.compile("\\d{1,4}-\\d{1,4}").match(details):
+                self._start_ep = details
+                self._end_ep = details
+            else:
+                tmp = details.split(",")
+                if len(tmp) > 1:
+                    self._start_ep = int(tmp[0])
+                    self._end_ep = int(tmp[0]) if int(tmp[0]) > int(tmp[1]) else int(tmp[1])
+                else:
+                    self._start_ep = self._end_ep = int(tmp[0])
+        self.__offset = int(offset) if offset else 0
+        self._key = key
+
+    @property
+    def format(self):
+        return self._format
+
+    @property
+    def start_ep(self):
+        return self._start_ep
+
+    @property
+    def end_ep(self):
+        return self._end_ep
+
+    @property
+    def part(self):
+        return self._part
+
+    @property
+    def offset(self):
+        return self.__offset
+
+    def match(self, file: str) -> bool:
+        if not self._format:
+            return True
+        s, e = self.__handle_single(file)
+        if not s:
+            return False
+        if self._start_ep is None:
+            return True
+        if self._start_ep <= s <= self._end_ep:
+            return True
+        return False
+
+    def split_episode(self, file_name: str) -> Tuple[Optional[int], Optional[int], Optional[str]]:
+        """
+        拆分集数，返回开始集数，结束集数，Part信息
+        """
+        # 指定的具体集数，直接返回
+        if self._start_ep is not None and self._start_ep == self._end_ep:
+            if isinstance(self._start_ep, str):
+                s, e = self._start_ep.split("-")
+                if int(s) == int(e):
+                    return int(s) + self.__offset, None, self.part
+                return int(s) + self.__offset, int(e) + self.__offset, self.part
+            return self._start_ep + self.__offset, None, self.part
+        if not self._format:
+            return None, None, None
+        s, e = self.__handle_single(file_name)
+        return s + self.__offset if s is not None else None, \
+            e + self.__offset if e is not None else None, self.part
+
+    def __handle_single(self, file: str) -> Tuple[Optional[int], Optional[int]]:
+        """
+        处理单集，返回单集的开始和结束集数
+        """
+        if not self._format:
+            return None, None
+        ret = parse.parse(self._format, file)
+        if not ret or not ret.__contains__(self._key):
+            return None, None
+        episodes = ret.__getitem__(self._key)
+        if not re.compile(r"^(EP)?(\d{1,4})(-(EP)?(\d{1,4}))?$", re.IGNORECASE).match(episodes):
+            return None, None
+        episode_splits = list(filter(lambda x: re.compile(r'[a-zA-Z]*\d{1,4}', re.IGNORECASE).match(x),
+                                     re.split(r'%s' % self._split_chars, episodes)))
+        if len(episode_splits) == 1:
+            return int(re.compile(r'[a-zA-Z]*', re.IGNORECASE).sub("", episode_splits[0])), None
+        else:
+            return int(re.compile(r'[a-zA-Z]*', re.IGNORECASE).sub("", episode_splits[0])), int(
+                re.compile(r'[a-zA-Z]*', re.IGNORECASE).sub("", episode_splits[1]))

app/helper/ocr.py

@@ -1,11 +1,12 @@
 import base64
 
+from app.core.config import settings
 from app.utils.http import RequestUtils
 
 
 class OcrHelper:
 
-    _ocr_b64_url = "https://nastool.org/captcha/base64"
+    _ocr_b64_url = f"{settings.OCR_HOST}/captcha/base64"
 
     def get_captcha_text(self, image_url=None, image_b64=None, cookie=None, ua=None):
         """

app/helper/rss.py

@@ -1,16 +1,227 @@
 import xml.dom.minidom
-from typing import List
+from typing import List, Tuple, Union
+from urllib.parse import urljoin
+
+from lxml import etree
 
 from app.core.config import settings
+from app.helper.browser import PlaywrightHelper
 from app.utils.dom import DomUtils
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
 
 class RssHelper:
-    
+    """
+    RSS帮助类，解析RSS报文、获取RSS地址等
+    """
+    # 各站点RSS链接获取配置
+    rss_link_conf = {
+        "default": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+            }
+        },
+        "hares.top": {
+            "xpath": "//*[@id='layui-layer100001']/div[2]/div/p[4]/a/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+            }
+        },
+        "et8.org": {
+            "xpath": "//*[@id='outer']/table/tbody/tr/td/table/tbody/tr/td/a[2]/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+            }
+        },
+        "pttime.org": {
+            "xpath": "//*[@id='outer']/table/tbody/tr/td/table/tbody/tr/td/text()[5]",
+            "url": "getrss.php",
+            "params": {
+                "showrows": 10,
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1
+            }
+        },
+        "ourbits.club": {
+            "xpath": "//a[@class='gen_rsslink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+            }
+        },
+        "totheglory.im": {
+            "xpath": "//textarea/text()",
+            "url": "rsstools.php?c51=51&c52=52&c53=53&c54=54&c108=108&c109=109&c62=62&c63=63&c67=67&c69=69&c70=70&c73=73&c76=76&c75=75&c74=74&c87=87&c88=88&c99=99&c90=90&c58=58&c103=103&c101=101&c60=60",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+            }
+        },
+        "monikadesign.uk": {
+            "xpath": "//a/@href",
+            "url": "rss",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+            }
+        },
+        "zhuque.in": {
+            "xpath": "//a/@href",
+            "url": "user/rss",
+            "render": True,
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+            }
+        },
+        "hdchina.org": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+                "rsscart": 0
+            }
+        },
+        "audiences.me": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+                "torrent_type": 1,
+                "exp": 180
+            }
+        },
+        "shadowflow.org": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "paid": 0,
+                "search_mode": 0,
+                "showrows": 30
+            }
+        },
+        "hddolby.com": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+                "exp": 180
+            }
+        },
+        "hdhome.org": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+                "exp": 180
+            }
+        },
+        "pthome.net": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+                "exp": 180
+            }
+        },
+        "ptsbao.club": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+                "size": 0
+            }
+        },
+        "leaves.red": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 0,
+                "paid": 2
+            }
+        },
+        "hdtime.org": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 0,
+            }
+        },
+        "m-team.io": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "showrows": 50,
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "https": 1
+            }
+        },
+        "u2.dmhy.org": {
+            "xpath": "//a[@class='faqlink']/@href",
+            "url": "getrss.php",
+            "params": {
+                "inclbookmarked": 0,
+                "itemsmalldescr": 1,
+                "showrows": 50,
+                "search_mode": 1,
+                "inclautochecked": 1,
+                "trackerssl": 1
+            }
+        },
+    }
+
     @staticmethod
-    def parse(url, proxy: bool = False) -> List[dict]:
+    def parse(url, proxy: bool = False) -> Union[List[dict], None]:
         """
         解析RSS订阅URL，获取RSS中的种子信息
         :param url: RSS地址
@@ -77,4 +288,61 @@ class RssHelper:
                         continue
             except Exception as e2:
                 print(str(e2))
+                # RSS过期 观众RSS 链接已过期，您需要获得一个新的！  pthome RSS Link has expired, You need to get a new one!
+                _rss_expired_msg = [
+                    "RSS 链接已过期, 您需要获得一个新的!",
+                    "RSS Link has expired, You need to get a new one!",
+                    "RSS Link has expired, You need to get new!"
+                ]
+                if ret_xml in _rss_expired_msg:
+                    return None
         return ret_array
+
+    def get_rss_link(self, url: str, cookie: str, ua: str, proxy: bool = False) -> Tuple[str, str]:
+        """
+        获取站点rss地址
+        :param url: 站点地址
+        :param cookie: 站点cookie
+        :param ua: 站点ua
+        :param proxy: 是否使用代理
+        :return: rss地址、错误信息
+        """
+        try:
+            # 获取站点域名
+            domain = StringUtils.get_url_domain(url)
+            # 获取配置
+            site_conf = self.rss_link_conf.get(domain) or self.rss_link_conf.get("default")
+            # RSS地址
+            rss_url = urljoin(url, site_conf.get("url"))
+            # RSS请求参数
+            rss_params = site_conf.get("params")
+            # 请求RSS页面
+            if site_conf.get("render"):
+                html_text = PlaywrightHelper().get_page_source(
+                    url=rss_url,
+                    cookies=cookie,
+                    ua=ua,
+                    proxies=settings.PROXY if proxy else None
+                )
+            else:
+                res = RequestUtils(
+                    cookies=cookie,
+                    timeout=60,
+                    ua=ua,
+                    proxies=settings.PROXY if proxy else None
+                ).post_res(url=rss_url, data=rss_params)
+                if res:
+                    html_text = res.text
+                elif res is not None:
+                    return "", f"获取 {url} RSS链接失败，错误码：{res.status_code}，错误原因：{res.reason}"
+                else:
+                    return "", f"获取RSS链接失败：无法连接 {url} "
+            # 解析HTML
+            html = etree.HTML(html_text)
+            if html:
+                rss_link = html.xpath(site_conf.get("xpath"))
+                if rss_link:
+                    return str(rss_link[-1]), ""
+            return "", f"获取RSS链接失败：{url}"
+        except Exception as e:
+            return "", f"获取 {url} RSS链接失败：{str(e)}"

app/helper/torrent.py

@@ -130,21 +130,34 @@ class TorrentHelper:
         """
         获取种子文件的文件夹名和文件清单
         :param torrent_path: 种子文件路径
-        :return: 文件夹名、文件清单
+        :return: 文件夹名、文件清单，单文件种子返回空文件夹名
         """
         if not torrent_path or not torrent_path.exists():
             return "", []
         try:
             torrentinfo = Torrent.from_file(torrent_path)
-            # 获取目录名
-            folder_name = torrentinfo.name
             # 获取文件清单
-            if len(torrentinfo.files) <= 1:
+            if (not torrentinfo.files
+                    or (len(torrentinfo.files) == 1
+                        and torrentinfo.files[0].name == torrentinfo.name)):
+                # 单文件种子目录名返回空
+                folder_name = ""
                 # 单文件种子
                 file_list = [torrentinfo.name]
             else:
-                file_list = [fileinfo.name for fileinfo in torrentinfo.files]
-            logger.debug(f"{torrent_path.stem} -> 目录：{folder_name}，文件清单：{file_list}")
+                # 目录名
+                folder_name = torrentinfo.name
+                # 文件清单，如果一级目录与种子名相同则去掉
+                file_list = []
+                for fileinfo in torrentinfo.files:
+                    file_path = Path(fileinfo.name)
+                    # 根路径
+                    root_path = file_path.parts[0]
+                    if root_path == folder_name:
+                        file_list.append(str(file_path.relative_to(root_path)))
+                    else:
+                        file_list.append(fileinfo.name)
+            logger.info(f"解析种子：{torrent_path.name} => 目录：{folder_name}，文件清单：{file_list}")
             return folder_name, file_list
         except Exception as err:
             logger.error(f"种子文件解析失败：{err}")
@@ -254,9 +267,11 @@ class TorrentHelper:
         for file in files:
             if not file:
                 continue
-            if Path(file).suffix not in settings.RMT_MEDIAEXT:
+            file_path = Path(file)
+            if file_path.suffix not in settings.RMT_MEDIAEXT:
                 continue
-            meta = MetaInfo(file)
+            # 只使用文件名识别
+            meta = MetaInfo(file_path.stem)
             if not meta.begin_episode:
                 continue
             episodes = list(set(episodes).union(set(meta.episode_list)))

app/modules/douban/__init__.py

@@ -166,22 +166,42 @@ class DoubanModule(_ModuleBase):
         """
         if settings.SCRAP_SOURCE != "douban":
             return None
-        # 目录下的所有文件
-        for file in SystemUtils.list_files(path, settings.RMT_MEDIAEXT):
-            if not file:
-                continue
-            logger.info(f"开始刮削媒体库文件：{file} ...")
-            try:
-                meta = MetaInfo(file.stem)
-                if not meta.name:
+        if SystemUtils.is_bluray_dir(path):
+            # 蓝光原盘
+            logger.info(f"开始刮削蓝光原盘：{path} ...")
+            meta = MetaInfo(path.stem)
+            if not meta.name:
+                return
+            # 根据名称查询豆瓣数据
+            doubaninfo = self.__match(name=mediainfo.title, year=mediainfo.year, season=meta.begin_season)
+            if not doubaninfo:
+                logger.warn(f"未找到 {mediainfo.title} 的豆瓣信息")
+                return
+            scrape_path = path / path.name
+            self.scraper.gen_scraper_files(meta=meta,
+                                           mediainfo=MediaInfo(douban_info=doubaninfo),
+                                           file_path=scrape_path)
+        else:
+            # 目录下的所有文件
+            for file in SystemUtils.list_files(path, settings.RMT_MEDIAEXT):
+                if not file:
                     continue
-                # 根据名称查询豆瓣数据
-                doubaninfo = self.__match(name=mediainfo.title, year=mediainfo.year, season=meta.begin_season)
-                if not doubaninfo:
-                    logger.warn(f"未找到 {mediainfo.title} 的豆瓣信息")
-                    break
-                # 刮削
-                self.scraper.gen_scraper_files(meta, MediaInfo(douban_info=doubaninfo), file)
-            except Exception as e:
-                logger.error(f"刮削文件 {file} 失败，原因：{e}")
-            logger.info(f"{file} 刮削完成")
+                logger.info(f"开始刮削媒体库文件：{file} ...")
+                try:
+                    meta = MetaInfo(file.stem)
+                    if not meta.name:
+                        continue
+                    # 根据名称查询豆瓣数据
+                    doubaninfo = self.__match(name=mediainfo.title,
+                                              year=mediainfo.year,
+                                              season=meta.begin_season)
+                    if not doubaninfo:
+                        logger.warn(f"未找到 {mediainfo.title} 的豆瓣信息")
+                        break
+                    # 刮削
+                    self.scraper.gen_scraper_files(meta=meta,
+                                                   mediainfo=MediaInfo(douban_info=doubaninfo),
+                                                   file_path=file)
+                except Exception as e:
+                    logger.error(f"刮削文件 {file} 失败，原因：{e}")
+        logger.info(f"{path} 刮削完成")

app/modules/douban/scraper.py

@@ -17,7 +17,7 @@ class DoubanScraper:
         生成刮削文件
         :param meta: 元数据
         :param mediainfo: 媒体信息
-        :param file_path: 文件路径
+        :param file_path: 文件路径或者目录路径
         """
 
         try:

app/modules/emby/__init__.py

@@ -23,6 +23,14 @@ class EmbyModule(_ModuleBase):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         return "MEDIASERVER", "emby"
 
+    def scheduler_job(self) -> None:
+        """
+        定时任务，每10分钟调用一次
+        """
+        # 定时重连
+        if not self.emby.is_inactive():
+            self.emby = Emby()
+
     def user_authenticate(self, name: str, password: str) -> Optional[str]:
         """
         使用Emby用户辅助完成用户认证
@@ -60,7 +68,7 @@ class EmbyModule(_ModuleBase):
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
                     return ExistMediaInfo(type=MediaType.MOVIE)
-            movies = self.emby.get_movies(title=mediainfo.title, year=mediainfo.year)
+            movies = self.emby.get_movies(title=mediainfo.title, year=mediainfo.year, tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None

app/modules/emby/emby.py

@@ -24,8 +24,16 @@ class Emby(metaclass=Singleton):
             if not self._host.startswith("http"):
                 self._host = "http://" + self._host
         self._apikey = settings.EMBY_API_KEY
-        self._user = self.get_user()
-        self._folders = self.get_emby_folders()
+        self.user = self.get_user()
+        self.folders = self.get_emby_folders()
+
+    def is_inactive(self) -> bool:
+        """
+        判断是否需要重连
+        """
+        if not self._host or not self._apikey:
+            return False
+        return True if not self.user else False
 
     def get_emby_folders(self) -> List[dict]:
         """
@@ -51,7 +59,7 @@ class Emby(metaclass=Singleton):
         """
         if not self._host or not self._apikey:
             return []
-        req_url = f"{self._host}emby/Users/{self._user}/Views?api_key={self._apikey}"
+        req_url = f"{self._host}emby/Users/{self.user}/Views?api_key={self._apikey}"
         try:
             res = RequestUtils().get_res(req_url)
             if res:
@@ -264,11 +272,15 @@ class Emby(metaclass=Singleton):
             return None
         return ""
 
-    def get_movies(self, title: str, year: str = None) -> Optional[List[dict]]:
+    def get_movies(self,
+                   title: str,
+                   year: str = None,
+                   tmdb_id: int = None) -> Optional[List[dict]]:
         """
         根据标题和年份，检查电影是否在Emby中存在，存在则返回列表
         :param title: 标题
         :param year: 年份，可以为空，为空时不按年份过滤
+        :param tmdb_id: TMDB ID
         :return: 含title、year属性的字典列表
         """
         if not self._host or not self._apikey:
@@ -283,11 +295,19 @@ class Emby(metaclass=Singleton):
                 if res_items:
                     ret_movies = []
                     for res_item in res_items:
+                        item_tmdbid = res_item.get("ProviderIds", {}).get("Tmdb")
+                        if tmdb_id and item_tmdbid:
+                            if str(item_tmdbid) != str(tmdb_id):
+                                continue
+                            else:
+                                ret_movies.append(
+                                    {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
+                                continue
                         if res_item.get('Name') == title and (
                                 not year or str(res_item.get('ProductionYear')) == str(year)):
                             ret_movies.append(
                                 {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
-                            return ret_movies
+                    return ret_movies
         except Exception as e:
             logger.error(f"连接Items出错：" + str(e))
             return None
@@ -318,10 +338,12 @@ class Emby(metaclass=Singleton):
             if not item_id:
                 return {}
         # 验证tmdbid是否相同
-        item_tmdbid = self.get_iteminfo(item_id).get("ProviderIds", {}).get("Tmdb")
-        if tmdb_id and item_tmdbid:
-            if str(tmdb_id) != str(item_tmdbid):
-                return {}
+        item_info = self.get_iteminfo(item_id)
+        if item_info:
+            item_tmdbid = (item_info.get("ProviderIds") or {}).get("Tmdb")
+            if tmdb_id and item_tmdbid:
+                if str(tmdb_id) != str(item_tmdbid):
+                    return {}
         # /Shows/Id/Episodes 查集的信息
         if not season:
             season = ""
@@ -452,32 +474,16 @@ class Emby(metaclass=Singleton):
                 return None
         # 查找需要刷新的媒体库ID
         item_path = Path(item.target_path)
-        for folder in self._folders:
-            # 找同级路径最多的媒体库（要求容器内映射路径与实际一致）
-            max_comm_path = ""
-            match_num = 0
-            match_id = None
+        for folder in self.folders:
             # 匹配子目录
             for subfolder in folder.get("SubFolders"):
                 try:
-                    # 查询最大公共路径
+                    # 匹配子目录
                     subfolder_path = Path(subfolder.get("Path"))
-                    item_path_parents = list(item_path.parents)
-                    subfolder_path_parents = list(subfolder_path.parents)
-                    common_path = next(p1 for p1, p2 in zip(reversed(item_path_parents),
-                                                            reversed(subfolder_path_parents)
-                                                            ) if p1 == p2)
-                    if len(common_path) > len(max_comm_path):
-                        max_comm_path = common_path
-                        match_id = subfolder.get("Id")
-                        match_num += 1
-                except StopIteration:
-                    continue
+                    if item_path.is_relative_to(subfolder_path):
+                        return subfolder.get("Id")
                 except Exception as err:
                     print(str(err))
-            # 检查匹配情况
-            if match_id:
-                return match_id if match_num == 1 else folder.get("Id")
             # 如果找不到，只要路径中有分类目录名就命中
             for subfolder in folder.get("SubFolders"):
                 if subfolder.get("Path") and re.search(r"[/\\]%s" % item.category,
@@ -494,7 +500,7 @@ class Emby(metaclass=Singleton):
             return {}
         if not self._host or not self._apikey:
             return {}
-        req_url = "%semby/Users/%s/Items/%s?api_key=%s" % (self._host, self._user, itemid, self._apikey)
+        req_url = "%semby/Users/%s/Items/%s?api_key=%s" % (self._host, self.user, itemid, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
             if res and res.status_code == 200:
@@ -511,7 +517,7 @@ class Emby(metaclass=Singleton):
             yield {}
         if not self._host or not self._apikey:
             yield {}
-        req_url = "%semby/Users/%s/Items?ParentId=%s&api_key=%s" % (self._host, self._user, parent, self._apikey)
+        req_url = "%semby/Users/%s/Items?ParentId=%s&api_key=%s" % (self._host, self.user, parent, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
             if res and res.status_code == 200:
@@ -778,6 +784,7 @@ class Emby(metaclass=Singleton):
         }
         """
         message = json.loads(message_str)
+        logger.info(f"接收到emby webhook：{message}")
         eventItem = WebhookEventInfo(event=message.get('Event', ''), channel="emby")
         if message.get('Item'):
             if message.get('Item', {}).get('Type') == 'Episode':
@@ -806,9 +813,9 @@ class Emby(metaclass=Singleton):
                 eventItem.item_type = "MOV"
                 eventItem.item_name = "%s %s" % (
                     message.get('Item', {}).get('Name'), "(" + str(message.get('Item', {}).get('ProductionYear')) + ")")
-                eventItem.item_path = message.get('Item', {}).get('Path')
                 eventItem.item_id = message.get('Item', {}).get('Id')
 
+            eventItem.item_path = message.get('Item', {}).get('Path')
             eventItem.tmdb_id = message.get('Item', {}).get('ProviderIds', {}).get('Tmdb')
             if message.get('Item', {}).get('Overview') and len(message.get('Item', {}).get('Overview')) > 100:
                 eventItem.overview = str(message.get('Item', {}).get('Overview'))[:100] + "..."
@@ -849,9 +856,9 @@ class Emby(metaclass=Singleton):
         """
         if not self._host or not self._apikey:
             return None
-        url = url.replace("{HOST}", self._host)\
-            .replace("{APIKEY}", self._apikey)\
-            .replace("{USER}", self._user)
+        url = url.replace("{HOST}", self._host) \
+            .replace("{APIKEY}", self._apikey) \
+            .replace("{USER}", self.user)
         try:
             return RequestUtils().get_res(url=url)
         except Exception as e:

app/modules/fanart/__init__.py

@@ -11,6 +11,299 @@ from app.schemas.types import MediaType
 
 class FanartModule(_ModuleBase):
 
+    """
+    {
+        "name": "The Wheel of Time",
+        "thetvdb_id": "355730",
+        "tvposter": [
+            {
+                "id": "174068",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvposter/the-wheel-of-time-64b009de9548d.jpg",
+                "lang": "en",
+                "likes": "3"
+            },
+            {
+                "id": "176424",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvposter/the-wheel-of-time-64de44fe42073.jpg",
+                "lang": "00",
+                "likes": "3"
+            },
+            {
+                "id": "176407",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvposter/the-wheel-of-time-64dde63c7c941.jpg",
+                "lang": "en",
+                "likes": "0"
+            },
+            {
+                "id": "177321",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvposter/the-wheel-of-time-64eda10599c3d.jpg",
+                "lang": "cz",
+                "likes": "0"
+            },
+            {
+                "id": "155050",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvposter/the-wheel-of-time-6313adbd1fd58.jpg",
+                "lang": "pl",
+                "likes": "0"
+            },
+            {
+                "id": "140198",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvposter/the-wheel-of-time-61a0d7b11952e.jpg",
+                "lang": "en",
+                "likes": "0"
+            },
+            {
+                "id": "140034",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvposter/the-wheel-of-time-619e65b73871d.jpg",
+                "lang": "en",
+                "likes": "0"
+            }
+        ],
+        "hdtvlogo": [
+            {
+                "id": "139835",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-6197d9392faba.png",
+                "lang": "en",
+                "likes": "3"
+            },
+            {
+                "id": "140039",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-619e87941a128.png",
+                "lang": "pt",
+                "likes": "3"
+            },
+            {
+                "id": "140092",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-619fa2347bada.png",
+                "lang": "en",
+                "likes": "3"
+            },
+            {
+                "id": "164312",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-63c8185cb8824.png",
+                "lang": "hu",
+                "likes": "1"
+            },
+            {
+                "id": "139827",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-6197539658a9e.png",
+                "lang": "en",
+                "likes": "1"
+            },
+            {
+                "id": "177214",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-64ebae44c23a6.png",
+                "lang": "cz",
+                "likes": "0"
+            },
+            {
+                "id": "177215",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-64ebae472deef.png",
+                "lang": "cz",
+                "likes": "0"
+            },
+            {
+                "id": "156163",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-63316bef1ff9d.png",
+                "lang": "cz",
+                "likes": "0"
+            },
+            {
+                "id": "155051",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-6313add04ca92.png",
+                "lang": "pl",
+                "likes": "0"
+            },
+            {
+                "id": "152668",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-62ced3775a40a.png",
+                "lang": "pl",
+                "likes": "0"
+            },
+            {
+                "id": "142266",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdtvlogo/the-wheel-of-time-61ccd93eeac2b.png",
+                "lang": "de",
+                "likes": "0"
+            }
+        ],
+        "hdclearart": [
+            {
+                "id": "164313",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdclearart/the-wheel-of-time-63c81871c982c.png",
+                "lang": "en",
+                "likes": "3"
+            },
+            {
+                "id": "140284",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdclearart/the-wheel-of-time-61a2128ed1df2.png",
+                "lang": "pt",
+                "likes": "3"
+            },
+            {
+                "id": "139828",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdclearart/the-wheel-of-time-61975401e894c.png",
+                "lang": "en",
+                "likes": "1"
+            },
+            {
+                "id": "164314",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdclearart/the-wheel-of-time-63c8188488a5f.png",
+                "lang": "hu",
+                "likes": "1"
+            },
+            {
+                "id": "177322",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdclearart/the-wheel-of-time-64eda135933b6.png",
+                "lang": "cz",
+                "likes": "0"
+            },
+            {
+                "id": "142267",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/hdclearart/the-wheel-of-time-61ccda9918c5c.png",
+                "lang": "de",
+                "likes": "0"
+            }
+        ],
+        "seasonposter": [
+            {
+                "id": "140199",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/seasonposter/the-wheel-of-time-61a0d7c2976de.jpg",
+                "lang": "en",
+                "likes": "1",
+                "season": "1"
+            },
+            {
+                "id": "176395",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/seasonposter/the-wheel-of-time-64dd80b3d79a9.jpg",
+                "lang": "en",
+                "likes": "0",
+                "season": "1"
+            },
+            {
+                "id": "140035",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/seasonposter/the-wheel-of-time-619e65c4d5357.jpg",
+                "lang": "en",
+                "likes": "0",
+                "season": "1"
+            }
+        ],
+        "tvthumb": [
+            {
+                "id": "140242",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvthumb/the-wheel-of-time-61a1813035506.jpg",
+                "lang": "en",
+                "likes": "1"
+            },
+            {
+                "id": "177323",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvthumb/the-wheel-of-time-64eda15b6dce6.jpg",
+                "lang": "cz",
+                "likes": "0"
+            },
+            {
+                "id": "176399",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvthumb/the-wheel-of-time-64dd85c9b618c.jpg",
+                "lang": "en",
+                "likes": "0"
+            },
+            {
+                "id": "152669",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvthumb/the-wheel-of-time-62ced53d16574.jpg",
+                "lang": "pl",
+                "likes": "0"
+            },
+            {
+                "id": "141983",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvthumb/the-wheel-of-time-61c6d04a6d701.jpg",
+                "lang": "en",
+                "likes": "0"
+            }
+        ],
+        "showbackground": [
+            {
+                "id": "177324",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/showbackground/the-wheel-of-time-64eda1833ccb1.jpg",
+                "lang": "",
+                "likes": "0",
+                "season": "all"
+            },
+            {
+                "id": "141986",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/showbackground/the-wheel-of-time-61c6d08f7c7e2.jpg",
+                "lang": "",
+                "likes": "0",
+                "season": "all"
+            },
+            {
+                "id": "139868",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/showbackground/the-wheel-of-time-6198ce358b98a.jpg",
+                "lang": "",
+                "likes": "0",
+                "season": "all"
+            }
+        ],
+        "seasonthumb": [
+            {
+                "id": "176396",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/seasonthumb/the-wheel-of-time-64dd80c8593f9.jpg",
+                "lang": "en",
+                "likes": "0",
+                "season": "1"
+            },
+            {
+                "id": "176400",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/seasonthumb/the-wheel-of-time-64dd85da7c5e9.jpg",
+                "lang": "en",
+                "likes": "0",
+                "season": "0"
+            }
+        ],
+        "tvbanner": [
+            {
+                "id": "176397",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvbanner/the-wheel-of-time-64dd80da9a255.jpg",
+                "lang": "en",
+                "likes": "0"
+            },
+            {
+                "id": "176401",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvbanner/the-wheel-of-time-64dd85e8904ea.jpg",
+                "lang": "en",
+                "likes": "0"
+            },
+            {
+                "id": "141988",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvbanner/the-wheel-of-time-61c6d34bceb5f.jpg",
+                "lang": "en",
+                "likes": "0"
+            },
+            {
+                "id": "141984",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/tvbanner/the-wheel-of-time-61c6d06c1c21c.jpg",
+                "lang": "en",
+                "likes": "0"
+            }
+        ],
+        "seasonbanner": [
+            {
+                "id": "176398",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/seasonbanner/the-wheel-of-time-64dd80e7dbd9f.jpg",
+                "lang": "en",
+                "likes": "0",
+                "season": "1"
+            },
+            {
+                "id": "176402",
+                "url": "http://assets.fanart.tv/fanart/tv/355730/seasonbanner/the-wheel-of-time-64dd85fb4f1b1.jpg",
+                "lang": "en",
+                "likes": "0",
+                "season": "0"
+            }
+        ]
+    }
+    """
+
     # 代理
     _proxies: dict = settings.PROXY
 
@@ -40,6 +333,7 @@ class FanartModule(_ModuleBase):
         if not result or result.get('status') == 'error':
             logger.warn(f"没有获取到 {mediainfo.title_year} 的Fanart图片数据")
             return
+        # 获取所有图片
         for name, images in result.items():
             if not images:
                 continue
@@ -47,7 +341,17 @@ class FanartModule(_ModuleBase):
                 continue
             # 按欢迎程度倒排
             images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
-            mediainfo.set_image(self.__name(name), images[0].get('url'))
+            # 取第一张图片
+            image_obj = images[0]
+            # 图片属性xx_path
+            image_name = self.__name(name)
+            image_season = image_obj.get('season')
+            # 设置图片
+            if image_name.startswith("season") and image_season:
+                # 季图片格式 seasonxx-poster
+                image_name = f"season{str(image_season).rjust(2, '0')}-{image_name[6:]}"
+            if not mediainfo.get_image(image_name):
+                mediainfo.set_image(image_name, image_obj.get('url'))
 
         return mediainfo
 

app/modules/filetransfer/__init__.py

@@ -1,19 +1,19 @@
 import re
 from pathlib import Path
 from threading import Lock
-from typing import Optional, List, Tuple, Union
+from typing import Optional, List, Tuple, Union, Dict
 
 from jinja2 import Template
 
-from app.core.context import MediaInfo
-from app.core.metainfo import MetaInfo
 from app.core.config import settings
+from app.core.context import MediaInfo
 from app.core.meta import MetaBase
+from app.core.metainfo import MetaInfo
 from app.log import logger
 from app.modules import _ModuleBase
-from app.schemas import TransferInfo
-from app.utils.system import SystemUtils
+from app.schemas import TransferInfo, ExistMediaInfo
 from app.schemas.types import MediaType
+from app.utils.system import SystemUtils
 
 lock = Lock()
 
@@ -29,15 +29,15 @@ class FileTransferModule(_ModuleBase):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         pass
 
-    def transfer(self, path: Path, mediainfo: MediaInfo,
-                 transfer_type: str, target: Path = None, meta: MetaBase = None) -> TransferInfo:
+    def transfer(self, path: Path, meta: MetaBase, mediainfo: MediaInfo,
+                 transfer_type: str, target: Path = None) -> TransferInfo:
         """
         文件转移
         :param path:  文件路径
+        :param meta: 预识别的元数据，仅单文件转移时传递
         :param mediainfo:  识别的媒体信息
         :param transfer_type:  转移方式
         :param target:  目标路径
-        :param meta: 预识别的元数据，仅单文件转移时传递
         :return: {path, target_path, message}
         """
         # 获取目标路径
@@ -48,10 +48,10 @@ class FileTransferModule(_ModuleBase):
             return TransferInfo(message="未找到媒体库目录，无法转移文件")
         # 转移
         return self.transfer_media(in_path=path,
+                                   in_meta=meta,
                                    mediainfo=mediainfo,
                                    transfer_type=transfer_type,
-                                   target_dir=target,
-                                   in_meta=meta)
+                                   target_dir=target)
 
     @staticmethod
     def __transfer_command(file_item: Path, target_file: Path, transfer_type: str) -> int:
@@ -236,9 +236,9 @@ class FileTransferModule(_ModuleBase):
                     logger.error(f"音轨文件 {file_name} {transfer_type}失败：{reason}")
         return 0
 
-    def __transfer_bluray_dir(self, file_path: Path, new_path: Path, transfer_type: str) -> int:
+    def __transfer_dir(self, file_path: Path, new_path: Path, transfer_type: str) -> int:
         """
-        转移蓝光文件夹
+        转移整个文件夹
         :param file_path: 原路径
         :param new_path: 新路径
         :param transfer_type: RmtMode转移方式
@@ -257,14 +257,18 @@ class FileTransferModule(_ModuleBase):
 
     def __transfer_dir_files(self, src_dir: Path, target_dir: Path, transfer_type: str) -> int:
         """
-        按目录结构转移所有文件
+        按目录结构转移目录下所有文件
         :param src_dir: 原路径
         :param target_dir: 新路径
         :param transfer_type: RmtMode转移方式
         """
         retcode = 0
         for file in src_dir.glob("**/*"):
-            new_file = target_dir.with_name(src_dir.name)
+            # 过滤掉目录
+            if file.is_dir():
+                continue
+            # 使用target_dir的父目录作为新的父目录
+            new_file = target_dir.joinpath(file.relative_to(src_dir))
             if new_file.exists():
                 logger.warn(f"{new_file} 文件已存在")
                 continue
@@ -279,7 +283,7 @@ class FileTransferModule(_ModuleBase):
         return retcode
 
     def __transfer_file(self, file_item: Path, new_file: Path, transfer_type: str,
-                        over_flag: bool = False, old_file: Path = None) -> int:
+                        over_flag: bool = False) -> int:
         """
         转移一个文件，同时处理其他相关文件
         :param file_item: 原文件路径
@@ -287,12 +291,13 @@ class FileTransferModule(_ModuleBase):
         :param transfer_type: RmtMode转移方式
         :param over_flag: 是否覆盖，为True时会先删除再转移
         """
-        if not over_flag and new_file.exists():
-            logger.warn(f"文件已存在：{new_file}")
-            return 0
-        if over_flag and old_file and old_file.exists():
-            logger.info(f"正在删除已存在的文件：{old_file}")
-            old_file.unlink()
+        if new_file.exists():
+            if not over_flag:
+                logger.warn(f"文件已存在：{new_file}")
+                return 0
+            else:
+                logger.info(f"正在删除已存在的文件：{new_file}")
+                new_file.unlink()
         logger.info(f"正在转移文件：{file_item} 到 {new_file}")
         # 创建父目录
         new_file.parent.mkdir(parents=True, exist_ok=True)
@@ -311,32 +316,47 @@ class FileTransferModule(_ModuleBase):
                                            over_flag=over_flag)
 
     @staticmethod
-    def __is_bluray_dir(dir_path: Path) -> bool:
+    def __get_library_dir(mediainfo: MediaInfo, target_dir: Path) -> Path:
         """
-        判断是否为蓝光原盘目录
+        根据设置并装媒体库目录
         """
-        # 蓝光原盘目录必备的文件或文件夹
-        required_files = ['BDMV', 'CERTIFICATE']
-        # 检查目录下是否存在所需文件或文件夹
-        for item in required_files:
-            if (dir_path / item).exists():
-                return True
-        return False
+        if mediainfo.type == MediaType.MOVIE:
+            # 电影
+            if settings.LIBRARY_MOVIE_NAME:
+                target_dir = target_dir / settings.LIBRARY_MOVIE_NAME / mediainfo.category
+            else:
+                # 目的目录加上类型和二级分类
+                target_dir = target_dir / mediainfo.type.value / mediainfo.category
+
+        if mediainfo.type == MediaType.TV:
+            # 电视剧
+            if settings.LIBRARY_ANIME_NAME \
+                    and mediainfo.genre_ids \
+                    and set(mediainfo.genre_ids).intersection(set(settings.ANIME_GENREIDS)):
+                # 动漫
+                target_dir = target_dir / settings.LIBRARY_ANIME_NAME / mediainfo.category
+            elif settings.LIBRARY_TV_NAME:
+                # 电视剧
+                target_dir = target_dir / settings.LIBRARY_TV_NAME / mediainfo.category
+            else:
+                # 目的目录加上类型和二级分类
+                target_dir = target_dir / mediainfo.type.value / mediainfo.category
+        return target_dir
 
     def transfer_media(self,
                        in_path: Path,
+                       in_meta: MetaBase,
                        mediainfo: MediaInfo,
                        transfer_type: str,
-                       target_dir: Path = None,
-                       in_meta: MetaBase = None
+                       target_dir: Path,
                        ) -> TransferInfo:
         """
-        识别并转移一个文件、多个文件或者目录
+        识别并转移一个文件或者一个目录下的所有文件
         :param in_path: 转移的路径，可能是一个文件也可以是一个目录
+        :param in_meta：预识别元数据
         :param mediainfo: 媒体信息
         :param target_dir: 目的文件夹，非空的转移到该文件夹，为空时则按类型转移到配置文件中的媒体库文件夹
         :param transfer_type: 文件转移方式
-        :param in_meta：预识别元数，为空则重新识别
         :return: TransferInfo、错误信息
         """
         # 检查目录路径
@@ -346,152 +366,91 @@ class FileTransferModule(_ModuleBase):
         if not target_dir.exists():
             return TransferInfo(message=f"{target_dir} 目标路径不存在")
 
-        if mediainfo.type == MediaType.MOVIE:
-            if settings.LIBRARY_MOVIE_NAME:
-                target_dir = target_dir / settings.LIBRARY_MOVIE_NAME / mediainfo.category
-            else:
-                # 目的目录加上类型和二级分类
-                target_dir = target_dir / mediainfo.type.value / mediainfo.category
-
-        if mediainfo.type == MediaType.TV:
-            if settings.LIBRARY_TV_NAME:
-                target_dir = target_dir / settings.LIBRARY_TV_NAME / mediainfo.category
-            else:
-                # 目的目录加上类型和二级分类
-                target_dir = target_dir / mediainfo.type.value / mediainfo.category
+        # 媒体库目录
+        target_dir = self.__get_library_dir(mediainfo=mediainfo, target_dir=target_dir)
 
         # 重命名格式
         rename_format = settings.TV_RENAME_FORMAT \
             if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
 
-        # 总大小
-        total_filesize = 0
-
-        # 处理文件清单
-        file_list = []
-
-        # 目标文件清单
-        file_list_new = []
-
-        # 失败文件清单
-        fail_list = []
-
-        # 错误信息
-        err_msgs = []
-
-        # 判断是否为蓝光原盘
-        bluray_flag = self.__is_bluray_dir(in_path)
-        if bluray_flag:
-            # 识别目录名称，不包括后缀
-            meta = MetaInfo(in_path.stem)
+        # 判断是否为文件夹
+        if in_path.is_dir():
+            # 转移整个目录
+            # 是否蓝光原盘
+            bluray_flag = SystemUtils.is_bluray_dir(in_path)
+            if bluray_flag:
+                logger.info(f"{in_path} 是蓝光原盘文件夹")
             # 目的路径
             new_path = self.get_rename_path(
                 path=target_dir,
                 template_string=rename_format,
-                rename_dict=self.__get_naming_dict(meta=meta,
+                rename_dict=self.__get_naming_dict(meta=in_meta,
                                                    mediainfo=mediainfo)
             ).parent
             # 转移蓝光原盘
-            retcode = self.__transfer_bluray_dir(file_path=in_path,
-                                                 new_path=new_path,
-                                                 transfer_type=transfer_type)
+            retcode = self.__transfer_dir(file_path=in_path,
+                                          new_path=new_path,
+                                          transfer_type=transfer_type)
             if retcode != 0:
-                return TransferInfo(message=f"{retcode}，蓝光原盘转移失败")
-            else:
-                # 计算大小
-                total_filesize += in_path.stat().st_size
-                # 返回转移后的路径
-                return TransferInfo(path=in_path,
-                                    target_path=new_path,
-                                    total_size=total_filesize,
-                                    is_bluray=bluray_flag,
-                                    file_list=[],
-                                    file_list_new=[])
-        else:
-            # 获取文件清单
-            transfer_files: List[Path] = SystemUtils.list_files(in_path, settings.RMT_MEDIAEXT)
-            if len(transfer_files) == 0:
-                return TransferInfo(message=f"{in_path} 目录下没有找到可转移的文件")
-            if not in_meta:
-                # 识别目录名称，不包括后缀
-                meta = MetaInfo(in_path.stem)
-            else:
-                meta = in_meta
-            # 目的路径
-            new_path = target_dir / (self.get_rename_path(
-                template_string=rename_format,
-                rename_dict=self.__get_naming_dict(meta=meta,
-                                                   mediainfo=mediainfo)).parents[-2].name)
-            # 转移所有文件
-            for transfer_file in transfer_files:
-                try:
-                    if not in_meta:
-                        # 识别文件元数据，不包含后缀
-                        file_meta = MetaInfo(transfer_file.stem)
-                        # 合并元数据
-                        file_meta.merge(meta)
-                    else:
-                        file_meta = in_meta
-
-                    # 文件结束季为空
-                    file_meta.end_season = None
-                    # 文件总季数为1
-                    if file_meta.total_season:
-                        file_meta.total_season = 1
-                    # 文件不可能有多集
-                    if file_meta.total_episode > 2:
-                        file_meta.total_episode = 1
-                        file_meta.end_episode = None
-
-                    # 目的文件名
-                    new_file = self.get_rename_path(
-                        path=target_dir,
-                        template_string=rename_format,
-                        rename_dict=self.__get_naming_dict(meta=file_meta,
-                                                           mediainfo=mediainfo,
-                                                           file_ext=transfer_file.suffix)
-                    )
-
-                    # 判断是否要覆盖
-                    overflag = False
-                    if new_file.exists():
-                        if new_file.stat().st_size < transfer_file.stat().st_size:
-                            logger.info(f"目标文件已存在，但文件大小更小，将覆盖：{new_file}")
-                            overflag = True
-                    # 转移文件
-                    retcode = self.__transfer_file(file_item=transfer_file,
-                                                   new_file=new_file,
-                                                   transfer_type=transfer_type,
-                                                   over_flag=overflag)
-                    if retcode != 0:
-                        logger.error(f"{transfer_file} 转移文件失败，错误码：{retcode}")
-                        err_msgs.append(f"{transfer_file.name}：错误码 {retcode}")
-                        fail_list.append(transfer_file)
-                        continue
-                    # 源文件清单
-                    file_list.append(str(transfer_file))
-                    # 目的文件清单
-                    file_list_new.append(str(new_file))
-                    # 计算总大小
-                    total_filesize += new_file.stat().st_size
-                except Exception as err:
-                    err_msgs.append(f"{transfer_file.name}：{err}")
-                    logger.error(f"{transfer_file}转移失败：{err}")
-                    fail_list.append(transfer_file)
-
-            if not file_list:
-                # 没有成功的
-                return TransferInfo(message="\n".join(err_msgs))
+                logger.error(f"文件夹 {in_path} 转移失败，错误码：{retcode}")
+                return TransferInfo(message=f"文件夹 {in_path} 转移失败，错误码：{retcode}")
 
+            logger.info(f"文件夹 {in_path} 转移成功")
+            # 返回转移后的路径
             return TransferInfo(path=in_path,
                                 target_path=new_path,
-                                message="\n".join(err_msgs),
-                                file_count=len(file_list),
-                                total_size=total_filesize,
-                                fail_list=fail_list,
-                                is_bluray=bluray_flag,
-                                file_list=file_list,
-                                file_list_new=file_list_new)
+                                total_size=new_path.stat().st_size,
+                                is_bluray=bluray_flag)
+        else:
+            # 转移单个文件
+            # 文件结束季为空
+            in_meta.end_season = None
+
+            # 文件总季数为1
+            if in_meta.total_season:
+                in_meta.total_season = 1
+
+            # 文件不可能有多集
+            if in_meta.total_episode > 2:
+                in_meta.total_episode = 1
+                in_meta.end_episode = None
+
+            # 目的文件名
+            new_file = self.get_rename_path(
+                path=target_dir,
+                template_string=rename_format,
+                rename_dict=self.__get_naming_dict(
+                    meta=in_meta,
+                    mediainfo=mediainfo,
+                    file_ext=in_path.suffix
+                )
+            )
+
+            # 判断是否要覆盖
+            overflag = False
+            if new_file.exists():
+                if new_file.stat().st_size < in_path.stat().st_size:
+                    logger.info(f"目标文件已存在，但文件大小更小，将覆盖：{new_file}")
+                    overflag = True
+
+            # 转移文件
+            retcode = self.__transfer_file(file_item=in_path,
+                                           new_file=new_file,
+                                           transfer_type=transfer_type,
+                                           over_flag=overflag)
+            if retcode != 0:
+                logger.error(f"文件 {in_path} 转移失败，错误码：{retcode}")
+                return TransferInfo(message=f"文件 {in_path.name} 转移失败，错误码：{retcode}",
+                                    fail_list=[str(in_path)])
+
+            logger.info(f"文件 {in_path} 转移成功")
+            return TransferInfo(path=in_path,
+                                target_path=new_file,
+                                file_count=1,
+                                total_size=new_file.stat().st_size,
+                                is_bluray=False,
+                                file_list=[str(in_path)],
+                                file_list_new=[str(new_file)])
 
     @staticmethod
     def __get_naming_dict(meta: MetaBase, mediainfo: MediaInfo, file_ext: str = None) -> dict:
@@ -561,13 +520,13 @@ class FileTransferModule(_ModuleBase):
         计算一个最好的目的目录，有in_path时找与in_path同路径的，没有in_path时，顺序查找1个符合大小要求的，没有in_path和size时，返回第1个
         :param in_path: 源目录
         """
-        if not settings.LIBRARY_PATH:
+        if not settings.LIBRARY_PATHS:
             return None
         # 目的路径，多路径以,分隔
-        dest_paths = str(settings.LIBRARY_PATH).split(",")
+        dest_paths = settings.LIBRARY_PATHS
         # 只有一个路径，直接返回
         if len(dest_paths) == 1:
-            return Path(dest_paths[0])
+            return dest_paths[0]
         # 匹配有最长共同上级路径的目录
         max_length = 0
         target_path = None
@@ -579,14 +538,80 @@ class FileTransferModule(_ModuleBase):
                         max_length = len(relative)
                         target_path = path
                 except Exception as e:
+                    logger.debug(f"计算目标路径时出错：{e}")
                     continue
             if target_path:
-                return Path(target_path)
+                return target_path
         # 顺序匹配第1个满足空间存储要求的目录
         if in_path.exists():
             file_size = in_path.stat().st_size
             for path in dest_paths:
-                if SystemUtils.free_space(Path(path)) > file_size:
-                    return Path(path)
+                if SystemUtils.free_space(path) > file_size:
+                    return path
         # 默认返回第1个
-        return Path(dest_paths[0])
+        return dest_paths[0]
+
+    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
+        """
+        判断媒体文件是否存在于本地文件系统
+        :param mediainfo:  识别的媒体信息
+        :param itemid:  媒体服务器ItemID
+        :return: 如不存在返回None，存在时返回信息，包括每季已存在所有集{type: movie/tv, seasons: {season: [episodes]}}
+        """
+        if not settings.LIBRARY_PATHS:
+            return None
+        # 目的路径
+        dest_paths = settings.LIBRARY_PATHS
+        # 检查每一个媒体库目录
+        for dest_path in dest_paths:
+            # 媒体库路径
+            target_dir = self.get_target_path(dest_path)
+            if not target_dir:
+                continue
+            # 媒体分类路径
+            target_dir = self.__get_library_dir(mediainfo=mediainfo, target_dir=target_dir)
+            # 重命名格式
+            rename_format = settings.TV_RENAME_FORMAT \
+                if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
+            # 相对路径
+            rel_path = self.get_rename_path(
+                template_string=rename_format,
+                rename_dict=self.__get_naming_dict(meta=MetaInfo(mediainfo.title),
+                                                   mediainfo=mediainfo)
+            )
+            # 取相对路径的第1层目录
+            if rel_path.parts:
+                media_path = target_dir / rel_path.parts[0]
+            else:
+                continue
+
+            # 检查媒体文件夹是否存在
+            if not media_path.exists():
+                continue
+
+            # 检索媒体文件
+            media_files = SystemUtils.list_files(directory=media_path, extensions=settings.RMT_MEDIAEXT)
+            if not media_files:
+                continue
+
+            if mediainfo.type == MediaType.MOVIE:
+                # 电影存在任何文件为存在
+                logger.info(f"文件系统已存在：{mediainfo.title_year}")
+                return ExistMediaInfo(type=MediaType.MOVIE)
+            else:
+                # 电视剧检索集数
+                seasons: Dict[int, list] = {}
+                for media_file in media_files:
+                    file_meta = MetaInfo(media_file.stem)
+                    season_index = file_meta.begin_season or 1
+                    episode_index = file_meta.begin_episode
+                    if not episode_index:
+                        continue
+                    if season_index not in seasons:
+                        seasons[season_index] = []
+                    seasons[season_index].append(episode_index)
+                # 返回剧集情况
+                logger.info(f"{mediainfo.title_year} 文件系统已存在：{seasons}")
+                return ExistMediaInfo(type=MediaType.TV, seasons=seasons)
+        # 不存在
+        return None

app/modules/filter/__init__.py

@@ -18,7 +18,7 @@ class FilterModule(_ModuleBase):
         # 蓝光原盘
         "BLU": {
             "include": [r'Blu-?Ray.+VC-?1|Blu-?Ray.+AVC|UHD.+blu-?ray.+HEVC|MiniBD'],
-            "exclude": []
+            "exclude": [r'[Hx].?264|[Hx].?265|WEB-?DL|WEB-?RIP|REMUX']
         },
         # 4K
         "4K": {
@@ -67,7 +67,7 @@ class FilterModule(_ModuleBase):
         },
         # 杜比
         "DOLBY": {
-            "include": [r"DOLBY|DOVI|[\s.]+DV[\s.]+|杜比"],
+            "include": [r"Dolby[\s.]+Vision|DOVI|[\s.]+DV[\s.]+|杜比视界"],
             "exclude": []
         },
         # HDR

app/modules/indexer/__init__.py

@@ -53,6 +53,10 @@ class IndexerModule(_ModuleBase):
             logger.warn(f"{site.get('name')} 不支持中文搜索")
             return []
 
+        # 去除搜索关键字中的特殊字符
+        if search_word:
+            search_word = StringUtils.clear(search_word, replace_word=" ", allow_space=True)
+
         # 开始索引
         result_array = []
         # 开始计时

app/modules/indexer/spider.py

@@ -262,7 +262,12 @@ class TorrentSpider:
                         # 解码为字符串
                         page_source = raw_data.decode(encoding)
                     except Exception as e:
-                        logger.error(f"chardet解码失败：{e}")
+                        logger.debug(f"chardet解码失败：{e}")
+                        # 探测utf-8解码
+                        if re.search(r"charset=\"?utf-8\"?", ret.text, re.IGNORECASE):
+                            ret.encoding = "utf-8"
+                        else:
+                            ret.encoding = ret.apparent_encoding
                         page_source = ret.text
                 else:
                     page_source = ret.text

app/modules/jellyfin/__init__.py

@@ -17,12 +17,20 @@ class JellyfinModule(_ModuleBase):
     def init_module(self) -> None:
         self.jellyfin = Jellyfin()
 
-    def stop(self):
-        pass
-
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         return "MEDIASERVER", "jellyfin"
 
+    def scheduler_job(self) -> None:
+        """
+        定时任务，每10分钟调用一次
+        """
+        # 定时重连
+        if not self.jellyfin.is_inactive():
+            self.jellyfin = Jellyfin()
+
+    def stop(self):
+        pass
+
     def user_authenticate(self, name: str, password: str) -> Optional[str]:
         """
         使用Emby用户辅助完成用户认证
@@ -56,7 +64,7 @@ class JellyfinModule(_ModuleBase):
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
                     return ExistMediaInfo(type=MediaType.MOVIE)
-            movies = self.jellyfin.get_movies(title=mediainfo.title, year=mediainfo.year)
+            movies = self.jellyfin.get_movies(title=mediainfo.title, year=mediainfo.year, tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None

app/modules/jellyfin/jellyfin.py

@@ -22,8 +22,16 @@ class Jellyfin(metaclass=Singleton):
             if not self._host.startswith("http"):
                 self._host = "http://" + self._host
         self._apikey = settings.JELLYFIN_API_KEY
-        self._user = self.get_user()
-        self._serverid = self.get_server_id()
+        self.user = self.get_user()
+        self.serverid = self.get_server_id()
+
+    def is_inactive(self) -> bool:
+        """
+        判断是否需要重连
+        """
+        if not self._host or not self._apikey:
+            return False
+        return True if not self.user else False
 
     def __get_jellyfin_librarys(self) -> List[dict]:
         """
@@ -31,7 +39,7 @@ class Jellyfin(metaclass=Singleton):
         """
         if not self._host or not self._apikey:
             return []
-        req_url = f"{self._host}Users/{self._user}/Views?api_key={self._apikey}"
+        req_url = f"{self._host}Users/{self.user}/Views?api_key={self._apikey}"
         try:
             res = RequestUtils().get_res(req_url)
             if res:
@@ -222,10 +230,10 @@ class Jellyfin(metaclass=Singleton):
         """
         根据名称查询Jellyfin中剧集的SeriesId
         """
-        if not self._host or not self._apikey or not self._user:
+        if not self._host or not self._apikey or not self.user:
             return None
         req_url = "%sUsers/%s/Items?api_key=%s&searchTerm=%s&IncludeItemTypes=Series&Limit=10&Recursive=true" % (
-            self._host, self._user, self._apikey, name)
+            self._host, self.user, self._apikey, name)
         try:
             res = RequestUtils().get_res(req_url)
             if res:
@@ -240,17 +248,21 @@ class Jellyfin(metaclass=Singleton):
             return None
         return ""
 
-    def get_movies(self, title: str, year: str = None) -> Optional[List[dict]]:
+    def get_movies(self, 
+                   title: str, 
+                   year: str = None,
+                   tmdb_id: int = None) -> Optional[List[dict]]:
         """
         根据标题和年份，检查电影是否在Jellyfin中存在，存在则返回列表
         :param title: 标题
         :param year: 年份，为空则不过滤
+        :param tmdb_id: TMDB ID
         :return: 含title、year属性的字典列表
         """
-        if not self._host or not self._apikey or not self._user:
+        if not self._host or not self._apikey or not self.user:
             return None
         req_url = "%sUsers/%s/Items?api_key=%s&searchTerm=%s&IncludeItemTypes=Movie&Limit=10&Recursive=true" % (
-            self._host, self._user, self._apikey, title)
+            self._host, self.user, self._apikey, title)
         try:
             res = RequestUtils().get_res(req_url)
             if res:
@@ -258,11 +270,19 @@ class Jellyfin(metaclass=Singleton):
                 if res_items:
                     ret_movies = []
                     for res_item in res_items:
+                        item_tmdbid = res_item.get("ProviderIds", {}).get("Tmdb")
+                        if tmdb_id and item_tmdbid:
+                            if str(item_tmdbid) != str(tmdb_id):
+                                continue
+                            else:
+                                ret_movies.append(
+                                    {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
+                                continue
                         if res_item.get('Name') == title and (
                                 not year or str(res_item.get('ProductionYear')) == str(year)):
                             ret_movies.append(
                                 {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
-                            return ret_movies
+                    return ret_movies
         except Exception as e:
             logger.error(f"连接Items出错：" + str(e))
             return None
@@ -283,7 +303,7 @@ class Jellyfin(metaclass=Singleton):
         :param season: 季
         :return: 集号的列表
         """
-        if not self._host or not self._apikey or not self._user:
+        if not self._host or not self._apikey or not self.user:
             return None
         # 查TVID
         if not item_id:
@@ -293,7 +313,7 @@ class Jellyfin(metaclass=Singleton):
             if not item_id:
                 return {}
         # 验证tmdbid是否相同
-        item_tmdbid = self.get_iteminfo(item_id).get("ProviderIds", {}).get("Tmdb")
+        item_tmdbid = (self.get_iteminfo(item_id).get("ProviderIds") or {}).get("Tmdb")
         if tmdb_id and item_tmdbid:
             if str(tmdb_id) != str(item_tmdbid):
                 return {}
@@ -301,7 +321,7 @@ class Jellyfin(metaclass=Singleton):
             season = ""
         try:
             req_url = "%sShows/%s/Episodes?season=%s&&userId=%s&isMissing=false&api_key=%s" % (
-                self._host, item_id, season, self._user, self._apikey)
+                self._host, item_id, season, self.user, self._apikey)
             res_json = RequestUtils().get_res(req_url)
             if res_json:
                 res_items = res_json.json().get("Items")
@@ -370,24 +390,100 @@ class Jellyfin(metaclass=Singleton):
     def get_webhook_message(self, message: dict) -> WebhookEventInfo:
         """
         解析Jellyfin报文
+        {
+          "ServerId": "d79d3a6261614419a114595a585xxxxx",
+          "ServerName": "nyanmisaka-jellyfin1",
+          "ServerVersion": "10.8.10",
+          "ServerUrl": "http://xxxxxxxx:8098",
+          "NotificationType": "PlaybackStart",
+          "Timestamp": "2023-09-10T08:35:25.3996506+00:00",
+          "UtcTimestamp": "2023-09-10T08:35:25.3996527Z",
+          "Name": "慕灼华逃婚离开",
+          "Overview": "慕灼华假装在读书，她害怕大娘子说她不务正业。",
+          "Tagline": "",
+          "ItemId": "4b92551344f53b560fb55cd6700xxxxx",
+          "ItemType": "Episode",
+          "RunTimeTicks": 27074985984,
+          "RunTime": "00:45:07",
+          "Year": 2023,
+          "SeriesName": "灼灼风流",
+          "SeasonNumber": 1,
+          "SeasonNumber00": "01",
+          "SeasonNumber000": "001",
+          "EpisodeNumber": 1,
+          "EpisodeNumber00": "01",
+          "EpisodeNumber000": "001",
+          "Provider_tmdb": "229210",
+          "Video_0_Title": "4K HEVC SDR",
+          "Video_0_Type": "Video",
+          "Video_0_Codec": "hevc",
+          "Video_0_Profile": "Main",
+          "Video_0_Level": 150,
+          "Video_0_Height": 2160,
+          "Video_0_Width": 3840,
+          "Video_0_AspectRatio": "16:9",
+          "Video_0_Interlaced": false,
+          "Video_0_FrameRate": 25,
+          "Video_0_VideoRange": "SDR",
+          "Video_0_ColorSpace": "bt709",
+          "Video_0_ColorTransfer": "bt709",
+          "Video_0_ColorPrimaries": "bt709",
+          "Video_0_PixelFormat": "yuv420p",
+          "Video_0_RefFrames": 1,
+          "Audio_0_Title": "AAC - Stereo - Default",
+          "Audio_0_Type": "Audio",
+          "Audio_0_Language": "und",
+          "Audio_0_Codec": "aac",
+          "Audio_0_Channels": 2,
+          "Audio_0_Bitrate": 125360,
+          "Audio_0_SampleRate": 48000,
+          "Audio_0_Default": true,
+          "PlaybackPositionTicks": 1000000,
+          "PlaybackPosition": "00:00:00",
+          "MediaSourceId": "4b92551344f53b560fb55cd6700ebc86",
+          "IsPaused": false,
+          "IsAutomated": false,
+          "DeviceId": "TW96aWxsxxxxxjA",
+          "DeviceName": "Edge Chromium",
+          "ClientName": "Jellyfin Web",
+          "NotificationUsername": "Jeaven",
+          "UserId": "9783d2432b0d40a8a716b6aa46xxxxx"
+        }
         """
+        logger.info(f"接收到jellyfin webhook：{message}")
         eventItem = WebhookEventInfo(
             event=message.get('NotificationType', ''),
-            item_id=message.get('ItemId'),
-            item_name=message.get('Name'),
-            item_type=message.get('ItemType'),
-            item_favorite=message.get('Favorite'),
-            save_reason=message.get('SaveReason'),
-            tmdb_id=message.get('Provider_tmdb'),
-            user_name=message.get('NotificationUsername'),
             channel="jellyfin"
         )
+        eventItem.item_id = message.get('ItemId')
+        eventItem.tmdb_id = message.get('Provider_tmdb')
+        eventItem.overview = message.get('Overview')
+        eventItem.device_name = message.get('DeviceName')
+        eventItem.user_name = message.get('NotificationUsername')
+        eventItem.client = message.get('ClientName')
+        if message.get("ItemType") == "Episode":
+            # 剧集
+            eventItem.item_type = "TV"
+            eventItem.season_id = message.get('SeasonNumber')
+            eventItem.episode_id = message.get('EpisodeNumber')
+            eventItem.item_name = "%s %s%s %s" % (
+                message.get('SeriesName'),
+                "S" + str(eventItem.season_id),
+                "E" + str(eventItem.episode_id),
+                message.get('Name'))
+        else:
+            # 电影
+            eventItem.item_type = "MOV"
+            eventItem.item_name = "%s %s" % (
+                message.get('Name'), "(" + str(message.get('Year')) + ")")
 
         # 获取消息图片
         if eventItem.item_id:
             # 根据返回的item_id去调用媒体服务器获取
-            eventItem.image_url = self.get_remote_image_by_id(item_id=eventItem.item_id,
-                                                              image_type="Backdrop")
+            eventItem.image_url = self.get_remote_image_by_id(
+                item_id=eventItem.item_id,
+                image_type="Backdrop"
+            )
 
         return eventItem
 
@@ -400,7 +496,7 @@ class Jellyfin(metaclass=Singleton):
         if not self._host or not self._apikey:
             return {}
         req_url = "%sUsers/%s/Items/%s?api_key=%s" % (
-            self._host, self._user, itemid, self._apikey)
+            self._host, self.user, itemid, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
             if res and res.status_code == 200:
@@ -417,7 +513,7 @@ class Jellyfin(metaclass=Singleton):
             yield {}
         if not self._host or not self._apikey:
             yield {}
-        req_url = "%sUsers/%s/Items?parentId=%s&api_key=%s" % (self._host, self._user, parent, self._apikey)
+        req_url = "%sUsers/%s/Items?parentId=%s&api_key=%s" % (self._host, self.user, parent, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
             if res and res.status_code == 200:
@@ -452,9 +548,9 @@ class Jellyfin(metaclass=Singleton):
         """
         if not self._host or not self._apikey:
             return None
-        url = url.replace("{HOST}", self._host)\
-            .replace("{APIKEY}", self._apikey)\
-            .replace("{USER}", self._user)
+        url = url.replace("{HOST}", self._host) \
+            .replace("{APIKEY}", self._apikey) \
+            .replace("{USER}", self.user)
         try:
             return RequestUtils().get_res(url=url)
         except Exception as e:

app/modules/plex/__init__.py

@@ -23,6 +23,14 @@ class PlexModule(_ModuleBase):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         return "MEDIASERVER", "plex"
 
+    def scheduler_job(self) -> None:
+        """
+        定时任务，每10分钟调用一次
+        """
+        # 定时重连
+        if not self.plex.is_inactive():
+            self.plex = Plex()
+
     def webhook_parser(self, body: Any, form: Any, args: Any) -> WebhookEventInfo:
         """
         解析Webhook报文体
@@ -46,7 +54,10 @@ class PlexModule(_ModuleBase):
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
                     return ExistMediaInfo(type=MediaType.MOVIE)
-            movies = self.plex.get_movies(title=mediainfo.title, year=mediainfo.year)
+            movies = self.plex.get_movies(title=mediainfo.title,
+                                          original_title=mediainfo.original_title, 
+                                          year=mediainfo.year, 
+                                          tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
@@ -55,7 +66,9 @@ class PlexModule(_ModuleBase):
                 return ExistMediaInfo(type=MediaType.MOVIE)
         else:
             tvs = self.plex.get_tv_episodes(title=mediainfo.title,
+                                            original_title=mediainfo.original_title,
                                             year=mediainfo.year,
+                                            tmdb_id=mediainfo.tmdb_id,
                                             item_id=itemid)
             if not tvs:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")

app/modules/plex/plex.py

@@ -30,6 +30,14 @@ class Plex(metaclass=Singleton):
                 self._plex = None
                 logger.error(f"Plex服务器连接失败：{str(e)}")
 
+    def is_inactive(self) -> bool:
+        """
+        判断是否需要重连
+        """
+        if not self._host or not self._token:
+            return False
+        return True if not self._plex else False
+
     def get_librarys(self):
         """
         获取媒体服务器所有媒体库列表
@@ -120,11 +128,17 @@ class Plex(metaclass=Singleton):
             "EpisodeCount": EpisodeCount
         }
 
-    def get_movies(self, title: str, year: str = None) -> Optional[List[dict]]:
+    def get_movies(self, 
+                   title: str, 
+                   original_title: str = None,
+                   year: str = None,
+                   tmdb_id: int = None) -> Optional[List[dict]]:
         """
         根据标题和年份，检查电影是否在Plex中存在，存在则返回列表
         :param title: 标题
+        :param original_title: 原产地标题
         :param year: 年份，为空则不过滤
+        :param tmdb_id: TMDB ID
         :return: 含title、year属性的字典列表
         """
         if not self._plex:
@@ -132,22 +146,35 @@ class Plex(metaclass=Singleton):
         ret_movies = []
         if year:
             movies = self._plex.library.search(title=title, year=year, libtype="movie")
+            # 根据原标题再查一遍
+            if original_title and str(original_title) != str(title):
+                movies.extend(self._plex.library.search(title=original_title, year=year, libtype="movie"))
         else:
             movies = self._plex.library.search(title=title, libtype="movie")
-        for movie in movies:
+            if original_title and str(original_title) != str(title):
+                movies.extend(self._plex.library.search(title=original_title, year=year, libtype="movie"))
+        for movie in set(movies):
+            movie_tmdbid = self.__get_ids(movie.guids).get("tmdb_id")
+            if tmdb_id and movie_tmdbid:
+                if str(movie_tmdbid) != str(tmdb_id):
+                    continue
             ret_movies.append({'title': movie.title, 'year': movie.year})
         return ret_movies
 
     def get_tv_episodes(self,
                         item_id: str = None,
                         title: str = None,
+                        original_title: str = None,
                         year: str = None,
+                        tmdb_id: int = None,
                         season: int = None) -> Optional[Dict[int, list]]:
         """
         根据标题、年份、季查询电视剧所有集信息
         :param item_id: 媒体ID
         :param title: 标题
+        :param original_title: 原产地标题
         :param year: 年份，可以为空，为空时不按年份过滤
+        :param tmdb_id: TMDB ID
         :param season: 季号，数字
         :return: 所有集的列表
         """
@@ -156,13 +183,19 @@ class Plex(metaclass=Singleton):
         if item_id:
             videos = self._plex.fetchItem(item_id)
         else:
+            # 根据标题和年份模糊搜索，该结果不够准确
             videos = self._plex.library.search(title=title, year=year, libtype="show")
+            if not videos and original_title and str(original_title) != str(title):
+                videos = self._plex.library.search(title=original_title, year=year, libtype="show")
         if not videos:
             return {}
         if isinstance(videos, list):
-            episodes = videos[0].episodes()
-        else:
-            episodes = videos.episodes()
+            videos = videos[0]
+        video_tmdbid = self.__get_ids(videos.guids).get('tmdb_id')
+        if tmdb_id and video_tmdbid:
+            if str(video_tmdbid) != str(tmdb_id):
+                return {}
+        episodes = videos.episodes()
         season_episodes = {}
         for episode in episodes:
             if season and episode.seasonNumber != int(season):
@@ -329,9 +362,104 @@ class Plex(metaclass=Singleton):
         item_name  TV:琅琊榜 S1E6 剖心明志 虎口脱险
                    MOV:猪猪侠大冒险(2001)
         overview   剧情描述
+        {
+          "event": "media.scrobble",
+          "user": false,
+          "owner": true,
+          "Account": {
+            "id": 31646104,
+            "thumb": "https://plex.tv/users/xx",
+            "title": "播放"
+          },
+          "Server": {
+            "title": "Media-Server",
+            "uuid": "xxxx"
+          },
+          "Player": {
+            "local": false,
+            "publicAddress": "xx.xx.xx.xx",
+            "title": "MagicBook",
+            "uuid": "wu0uoa1ujfq90t0c5p9f7fw0"
+          },
+          "Metadata": {
+            "librarySectionType": "show",
+            "ratingKey": "40294",
+            "key": "/library/metadata/40294",
+            "parentRatingKey": "40291",
+            "grandparentRatingKey": "40275",
+            "guid": "plex://episode/615580a9fa828e7f1a0caabd",
+            "parentGuid": "plex://season/615580a9fa828e7f1a0caab8",
+            "grandparentGuid": "plex://show/60e81fd8d8000e002d7d2976",
+            "type": "episode",
+            "title": "The World's Strongest Senior",
+            "titleSort": "World's Strongest Senior",
+            "grandparentKey": "/library/metadata/40275",
+            "parentKey": "/library/metadata/40291",
+            "librarySectionTitle": "动漫剧集",
+            "librarySectionID": 7,
+            "librarySectionKey": "/library/sections/7",
+            "grandparentTitle": "范马刃牙",
+            "parentTitle": "Combat Shadow Fighting Saga / Great Prison Battle Saga",
+            "originalTitle": "Baki Hanma",
+            "contentRating": "TV-MA",
+            "summary": "The world is shaken by news of a man taking down a monstrous elephant with his bare hands. Back in Japan, Baki is confronted by a knife-wielding child.",
+            "index": 1,
+            "parentIndex": 1,
+            "audienceRating": 8.5,
+            "viewCount": 1,
+            "lastViewedAt": 1694320444,
+            "year": 2021,
+            "thumb": "/library/metadata/40294/thumb/1693544504",
+            "art": "/library/metadata/40275/art/1693952979",
+            "parentThumb": "/library/metadata/40291/thumb/1691115271",
+            "grandparentThumb": "/library/metadata/40275/thumb/1693952979",
+            "grandparentArt": "/library/metadata/40275/art/1693952979",
+            "duration": 1500000,
+            "originallyAvailableAt": "2021-09-30",
+            "addedAt": 1691115281,
+            "updatedAt": 1693544504,
+            "audienceRatingImage": "themoviedb://image.rating",
+            "Guid": [
+              {
+                "id": "imdb://tt14765720"
+              },
+              {
+                "id": "tmdb://3087250"
+              },
+              {
+                "id": "tvdb://8530933"
+              }
+            ],
+            "Rating": [
+              {
+                "image": "themoviedb://image.rating",
+                "value": 8.5,
+                "type": "audience"
+              }
+            ],
+            "Director": [
+              {
+                "id": 115144,
+                "filter": "director=115144",
+                "tag": "Keiya Saito",
+                "tagKey": "5f401c8d04a86500409ea6c1"
+              }
+            ],
+            "Writer": [
+              {
+                "id": 115135,
+                "filter": "writer=115135",
+                "tag": "Tatsuhiko Urahata",
+                "tagKey": "5d7768e07a53e9001e6db1ce",
+                "thumb": "https://metadata-static.plex.tv/f/people/f6f90dc89fa87d459f85d40a09720c05.jpg"
+              }
+            ]
+          }
+        }
         """
         message = json.loads(message_str)
-        eventItem = WebhookEventInfo(event=message.get('Event', ''), channel="plex")
+        logger.info(f"接收到plex webhook：{message}")
+        eventItem = WebhookEventInfo(event=message.get('event', ''), channel="plex")
         if message.get('Metadata'):
             if message.get('Metadata', {}).get('type') == 'episode':
                 eventItem.item_type = "TV"

app/modules/qbittorrent/__init__.py

@@ -10,7 +10,7 @@ from app.core.metainfo import MetaInfo
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.qbittorrent.qbittorrent import Qbittorrent
-from app.schemas import TransferInfo, TransferTorrent, DownloadingTorrent
+from app.schemas import TransferTorrent, DownloadingTorrent
 from app.schemas.types import TorrentStatus
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
@@ -28,18 +28,30 @@ class QbittorrentModule(_ModuleBase):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         return "DOWNLOADER", "qbittorrent"
 
-    def download(self, torrent_path: Path, download_dir: Path, cookie: str,
-                 episodes: Set[int] = None) -> Optional[Tuple[Optional[str], str]]:
+    def scheduler_job(self) -> None:
+        """
+        定时任务，每10分钟调用一次
+        """
+        # 定时重连
+        if self.qbittorrent.is_inactive():
+            self.qbittorrent = Qbittorrent()
+
+    def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
+                 episodes: Set[int] = None, category: str = None) -> Optional[Tuple[Optional[str], str]]:
         """
         根据种子文件，选择并添加下载任务
-        :param torrent_path:  种子文件地址
+        :param content:  种子文件地址或者磁力链接
         :param download_dir:  下载目录
         :param cookie:  cookie
         :param episodes:  需要下载的集数
+        :param category:  分类
         :return: 种子Hash，错误信息
         """
-        if not torrent_path or not torrent_path.exists():
-            return None, f"种子文件不存在：{torrent_path}"
+        if not content:
+            return
+        if isinstance(content, Path) and not content.exists():
+            return None, f"种子文件不存在：{content}"
+
         # 生成随机Tag
         tag = StringUtils.generate_random_str(10)
         if settings.TORRENT_TAG:
@@ -49,18 +61,21 @@ class QbittorrentModule(_ModuleBase):
         # 如果要选择文件则先暂停
         is_paused = True if episodes else False
         # 添加任务
-        state = self.qbittorrent.add_torrent(content=torrent_path.read_bytes(),
-                                             download_dir=str(download_dir),
-                                             is_paused=is_paused,
-                                             tag=tags,
-                                             cookie=cookie)
+        state = self.qbittorrent.add_torrent(
+            content=content.read_bytes() if isinstance(content, Path) else content,
+            download_dir=str(download_dir),
+            is_paused=is_paused,
+            tag=tags,
+            cookie=cookie,
+            category=category
+        )
         if not state:
-            return None, f"添加种子任务失败：{torrent_path}"
+            return None, f"添加种子任务失败：{content}"
         else:
             # 获取种子Hash
             torrent_hash = self.qbittorrent.get_torrent_id_by_tag(tags=tag)
             if not torrent_hash:
-                return None, f"获取种子Hash失败：{torrent_path}"
+                return None, f"获取种子Hash失败：{content}"
             else:
                 if is_paused:
                     # 种子文件
@@ -156,11 +171,11 @@ class QbittorrentModule(_ModuleBase):
         return ret_torrents
 
     def transfer_completed(self, hashs: Union[str, list],
-                           transinfo: TransferInfo = None) -> None:
+                           path: Path = None) -> None:
         """
         转移完成后的处理
         :param hashs:  种子Hash
-        :param transinfo:  转移信息
+        :param path:  源目录
         """
         self.qbittorrent.set_torrents_tag(ids=hashs, tags=['已整理'])
         # 移动模式删除种子
@@ -168,11 +183,11 @@ class QbittorrentModule(_ModuleBase):
             if self.remove_torrents(hashs):
                 logger.info(f"移动模式删除种子成功：{hashs} ")
             # 删除残留文件
-            if transinfo and transinfo.path and transinfo.path.exists():
-                files = SystemUtils.list_files(transinfo.path, settings.RMT_MEDIAEXT)
+            if path and path.exists():
+                files = SystemUtils.list_files(path, settings.RMT_MEDIAEXT)
                 if not files:
-                    logger.warn(f"删除残留文件夹：{transinfo.path}")
-                    shutil.rmtree(transinfo.path, ignore_errors=True)
+                    logger.warn(f"删除残留文件夹：{path}")
+                    shutil.rmtree(path, ignore_errors=True)
 
     def remove_torrents(self, hashs: Union[str, list]) -> bool:
         """

app/modules/qbittorrent/qbittorrent.py

@@ -27,6 +27,14 @@ class Qbittorrent(metaclass=Singleton):
         if self._host and self._port:
             self.qbc = self.__login_qbittorrent()
 
+    def is_inactive(self) -> bool:
+        """
+        判断是否需要重连
+        """
+        if not self._host or not self._port:
+            return False
+        return True if not self.qbc else False
+
     def __login_qbittorrent(self) -> Optional[Client]:
         """
         连接qbittorrent
@@ -83,8 +91,8 @@ class Qbittorrent(metaclass=Singleton):
         """
         if not self.qbc:
             return None
-        # completed会包含移动状态 更改为获取活动上传状态和正在做种状态
-        torrents, error = self.get_torrents(status=["completed"], ids=ids, tags=tags)
+        # completed会包含移动状态 改为获取seeding状态 包含活动上传, 正在做种, 及强制做种
+        torrents, error = self.get_torrents(status=["seeding"], ids=ids, tags=tags)
         return None if error else torrents or []
 
     def get_downloading_torrents(self, ids: Union[str, list] = None,
@@ -177,13 +185,16 @@ class Qbittorrent(metaclass=Singleton):
                     is_paused: bool = False,
                     download_dir: str = None,
                     tag: Union[str, list] = None,
-                    cookie=None
+                    category: str = None,
+                    cookie=None,
+                    **kwargs
                     ) -> bool:
         """
         添加种子
         :param content: 种子urls或文件内容
         :param is_paused: 添加后暂停
         :param tag: 标签
+        :param category: 种子分类
         :param download_dir: 下载路径
         :param cookie: 站点Cookie用于辅助下载种子
         :return: bool
@@ -191,6 +202,7 @@ class Qbittorrent(metaclass=Singleton):
         if not self.qbc or not content:
             return False
 
+        # 下载内容
         if isinstance(content, str):
             urls = content
             torrent_files = None
@@ -198,20 +210,26 @@ class Qbittorrent(metaclass=Singleton):
             urls = None
             torrent_files = content
 
+        # 保存目录
         if download_dir:
             save_path = download_dir
-            is_auto = False
         else:
             save_path = None
-            is_auto = None
 
+        # 标签
         if tag:
             tags = tag
         else:
             tags = None
 
-        try:
+        # 分类自动管理
+        if category and settings.QB_CATEGORY:
+            is_auto = True
+        else:
+            is_auto = False
+            category = None
 
+        try:
             # 添加下载
             qbc_ret = self.qbc.torrents_add(urls=urls,
                                             torrent_files=torrent_files,
@@ -219,7 +237,10 @@ class Qbittorrent(metaclass=Singleton):
                                             is_paused=is_paused,
                                             tags=tags,
                                             use_auto_torrent_management=is_auto,
-                                            cookie=cookie)
+                                            is_sequential_download=True,
+                                            cookie=cookie,
+                                            category=category,
+                                            **kwargs)
             return True if qbc_ret and str(qbc_ret).find("Ok") != -1 else False
         except Exception as err:
             logger.error(f"添加种子出错：{err}")
@@ -320,6 +341,7 @@ class Qbittorrent(metaclass=Singleton):
         try:
             self.qbc.transfer.upload_limit = int(upload_limit)
             self.qbc.transfer.download_limit = int(download_limit)
+            return True
         except Exception as err:
             logger.error(f"设置速度限制出错：{err}")
             return False

app/modules/slack/slack.py

@@ -146,7 +146,7 @@ class Slack:
             # 发送
             result = self._client.chat_postMessage(
                 channel=channel,
-                text=message_text,
+                text=message_text[:1000],
                 blocks=blocks,
                 mrkdwn=True
             )
@@ -272,6 +272,7 @@ class Slack:
                 link = torrent.page_url
                 title = f"{meta.season_episode} " \
                         f"{meta.resource_term} " \
+                        f"{meta.video_term} " \
                         f"{meta.release_group}"
                 title = re.sub(r"\s+", " ", title).strip()
                 free = torrent.volume_factor

app/modules/subtitle/__init__.py

@@ -34,15 +34,22 @@ class SubtitleModule(_ModuleBase):
     def stop(self) -> None:
         pass
 
-    def download_added(self, context: Context, torrent_path: Path, download_dir: Path) -> None:
+    def download_added(self, context: Context, download_dir: Path, torrent_path: Path = None) -> None:
         """
         添加下载任务成功后，从站点下载字幕，保存到下载目录
         :param context:  上下文，包括识别信息、媒体信息、种子信息
-        :param torrent_path:  种子文件地址
         :param download_dir:  下载目录
+        :param torrent_path:  种子文件地址
         :return: None，该方法可被多个模块同时处理
         """
-        # 种子信息
+        if not settings.DOWNLOAD_SUBTITLE:
+            return None
+
+        # 没有种子文件不处理
+        if not torrent_path:
+            return
+
+        # 没有详情页不处理
         torrent = context.torrent_info
         if not torrent.page_url:
             return
@@ -50,21 +57,16 @@ class SubtitleModule(_ModuleBase):
         logger.info("开始从站点下载字幕：%s" % torrent.page_url)
         # 获取种子信息
         folder_name, _ = TorrentHelper.get_torrent_info(torrent_path)
-        # 下载目录，也可能是文件名
-        download_dir = download_dir / (folder_name or "")
-        # 等待文件或者目录存在
+        # 文件保存目录，如果是单文件种子，则folder_name是空，此时文件保存目录就是下载目录
+        download_dir = download_dir / folder_name
+        # 等待目录存在
         for _ in range(30):
             if download_dir.exists():
                 break
             time.sleep(1)
-        # 目录仍然不存在，且是目录则创建目录
-        if not download_dir.exists() \
-                and download_dir.suffix not in settings.RMT_MEDIAEXT:
+        # 目录仍然不存在，且有文件夹名，则创建目录
+        if not download_dir.exists() and folder_name:
             download_dir.mkdir(parents=True, exist_ok=True)
-        # 不是目录说明是单文件种子，直接使用下载目录
-        if download_dir.is_file() \
-                or download_dir.suffix in settings.RMT_MEDIAEXT:
-            download_dir = download_dir.parent
         # 读取网站代码
         request = RequestUtils(cookies=torrent.site_cookie, ua=torrent.site_ua)
         res = request.get_res(torrent.page_url)

app/modules/telegram/__init__.py

@@ -1,5 +1,5 @@
 import json
-from typing import Optional, Union, List, Tuple, Any
+from typing import Optional, Union, List, Tuple, Any, Dict
 
 from app.core.context import MediaInfo, Context
 from app.core.config import settings
@@ -120,7 +120,7 @@ class TelegramModule(_ModuleBase):
         """
         return self.telegram.send_torrents_msg(title=message.title, torrents=torrents, userid=message.userid)
 
-    def register_commands(self, commands: dict):
+    def register_commands(self, commands: Dict[str, dict]):
         """
         注册命令，实现这个函数接收系统可用的命令菜单
         :param commands: 命令字典

app/modules/telegram/telegram.py

@@ -2,7 +2,7 @@ import re
 import threading
 from pathlib import Path
 from threading import Event
-from typing import Optional, List
+from typing import Optional, List, Dict
 
 import telebot
 from telebot import apihelper
@@ -153,6 +153,7 @@ class Telegram(metaclass=Singleton):
                 link = torrent.page_url
                 title = f"{meta.season_episode} " \
                         f"{meta.resource_term} " \
+                        f"{meta.video_term} " \
                         f"{meta.release_group}"
                 title = re.sub(r"\s+", " ", title).strip()
                 free = torrent.volume_factor
@@ -198,7 +199,7 @@ class Telegram(metaclass=Singleton):
 
         return True if ret else False
 
-    def register_commands(self, commands: dict):
+    def register_commands(self, commands: Dict[str, dict]):
         """
         注册菜单命令
         """

app/modules/themoviedb/__init__.py

@@ -74,8 +74,8 @@ class TheMovieDbModule(_ModuleBase):
                                                mtype=meta.type,
                                                season_year=meta.year,
                                                season_number=meta.begin_season)
-                        if meta.year:
-                            # 非严格模式下去掉年份再查一次
+                        if not info:
+                            # 去掉年份再查一次
                             info = self.tmdb.match(name=meta.name,
                                                    mtype=meta.type)
                     else:
@@ -132,6 +132,12 @@ class TheMovieDbModule(_ModuleBase):
             else:
                 logger.info(f"{tmdbid} 识别结果：{mediainfo.type.value} "
                             f"{mediainfo.title_year}")
+
+            # 补充剧集年份
+            if mediainfo.type == MediaType.TV:
+                episode_years = self.tmdb.get_tv_episode_years(info.get("id"))
+                if episode_years:
+                    mediainfo.season_years = episode_years
             return mediainfo
         else:
             logger.info(f"{meta.name if meta else tmdbid} 未匹配到媒体信息")
@@ -187,14 +193,27 @@ class TheMovieDbModule(_ModuleBase):
         """
         if settings.SCRAP_SOURCE != "themoviedb":
             return None
-        # 目录下的所有文件
-        for file in SystemUtils.list_files(path, settings.RMT_MEDIAEXT):
-            if not file:
-                continue
-            logger.info(f"开始刮削媒体库文件：{file} ...")
+
+        if SystemUtils.is_bluray_dir(path):
+            # 蓝光原盘
+            logger.info(f"开始刮削蓝光原盘：{path} ...")
+            scrape_path = path / path.name
             self.scraper.gen_scraper_files(mediainfo=mediainfo,
-                                           file_path=file)
-            logger.info(f"{file} 刮削完成")
+                                           file_path=scrape_path)
+        elif path.is_file():
+            # 单个文件
+            logger.info(f"开始刮削媒体库文件：{path} ...")
+            self.scraper.gen_scraper_files(mediainfo=mediainfo,
+                                           file_path=path)
+        else:
+            # 目录下的所有文件
+            logger.info(f"开始刮削目录：{path} ...")
+            for file in SystemUtils.list_files(path, settings.RMT_MEDIAEXT):
+                if not file:
+                    continue
+                self.scraper.gen_scraper_files(mediainfo=mediainfo,
+                                               file_path=file)
+        logger.info(f"{path} 刮削完成")
 
     def tmdb_discover(self, mtype: MediaType, sort_by: str, with_genres: str, with_original_language: str,
                       page: int = 1) -> Optional[List[dict]]:

app/modules/themoviedb/scraper.py

@@ -2,17 +2,19 @@ import time
 from pathlib import Path
 from xml.dom import minidom
 
+from requests import RequestException
+
 from app.core.config import settings
 from app.core.context import MediaInfo
 from app.core.metainfo import MetaInfo
 from app.log import logger
 from app.schemas.types import MediaType
+from app.utils.common import retry
 from app.utils.dom import DomUtils
 from app.utils.http import RequestUtils
 
 
 class TmdbScraper:
-
     tmdb = None
 
     def __init__(self, tmdb):
@@ -20,9 +22,9 @@ class TmdbScraper:
 
     def gen_scraper_files(self, mediainfo: MediaInfo, file_path: Path):
         """
-        生成刮削文件
+        生成刮削文件，包括NFO和图片，传入路径为文件路径
         :param mediainfo: 媒体信息
-        :param file_path: 文件路径
+        :param file_path: 文件路径或者目录路径
         """
 
         def __get_episode_detail(_seasoninfo: dict, _episode: int):
@@ -35,9 +37,9 @@ class TmdbScraper:
             return {}
 
         try:
-            # 电影
+            # 电影，路径为文件名 名称/名称.xxx 或者蓝光原盘目录 名称/名称
             if mediainfo.type == MediaType.MOVIE:
-                # 强制或者不已存在时才处理
+                # 不已存在时才处理
                 if not file_path.with_name("movie.nfo").exists() \
                         and not file_path.with_suffix(".nfo").exists():
                     #  生成电影描述文件
@@ -53,11 +55,11 @@ class TmdbScraper:
                         image_name = attr_name.replace("_path", "") + Path(attr_value).suffix
                         self.__save_image(url=attr_value,
                                           file_path=file_path.with_name(image_name))
-            # 电视剧
+            # 电视剧，路径为每一季的文件名 名称/Season xx/名称 SxxExx.xxx
             else:
                 # 识别
                 meta = MetaInfo(file_path.stem)
-                # 不存在时才处理
+                # 根目录不存在时才处理
                 if not file_path.parent.with_name("tvshow.nfo").exists():
                     # 根目录描述文件
                     self.__gen_tv_nfo_file(mediainfo=mediainfo,
@@ -81,19 +83,25 @@ class TmdbScraper:
                         self.__gen_tv_season_nfo_file(seasoninfo=seasoninfo,
                                                       season=meta.begin_season,
                                                       season_path=file_path.parent)
-                    # 季的图片
+                    # TMDB季poster图片
+                    sea_seq = str(meta.begin_season).rjust(2, '0')
+                    if seasoninfo.get("poster_path"):
+                        # 后缀
+                        ext = Path(seasoninfo.get('poster_path')).suffix
+                        # URL
+                        url = f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{seasoninfo.get('poster_path')}"
+                        self.__save_image(url, file_path.parent.with_name(f"season{sea_seq}-poster{ext}"))
+                    # 季的其它图片
                     for attr_name, attr_value in vars(mediainfo).items():
                         if attr_value \
                                 and attr_name.startswith("season") \
+                                and not attr_name.endswith("poster_path") \
                                 and attr_value \
                                 and isinstance(attr_value, str) \
                                 and attr_value.startswith("http"):
-                            image_name = attr_name.replace("_path",
-                                                           "").replace("season",
-                                                                       f"{str(meta.begin_season).rjust(2, '0')}-") \
-                                         + Path(attr_value).suffix
+                            image_name = attr_name.replace("_path", "") + Path(attr_value).suffix
                             self.__save_image(url=attr_value,
-                                              file_path=file_path.parent.with_name(f"season{image_name}"))
+                                              file_path=file_path.parent.with_name(image_name))
                 # 查询集详情
                 episodeinfo = __get_episode_detail(seasoninfo, meta.begin_episode)
                 if episodeinfo:
@@ -105,10 +113,11 @@ class TmdbScraper:
                                                        episode=meta.begin_episode,
                                                        file_path=file_path)
                     # 集的图片
-                    if episodeinfo.get('still_path'):
+                    episode_image = episodeinfo.get("still_path")
+                    if episode_image:
                         self.__save_image(
-                            f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{episodeinfo.get('still_path')}",
-                            file_path.with_suffix(Path(episodeinfo.get('still_path')).suffix))
+                            f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{episode_image}",
+                            file_path.with_suffix(Path(episode_image).suffix))
         except Exception as e:
             logger.error(f"{file_path} 刮削失败：{e}")
 
@@ -312,6 +321,7 @@ class TmdbScraper:
         self.__save_nfo(doc, file_path.with_suffix(".nfo"))
 
     @staticmethod
+    @retry(RequestException, logger=logger)
     def __save_image(url: str, file_path: Path):
         """
         下载图片并保存
@@ -320,7 +330,7 @@ class TmdbScraper:
             return
         try:
             logger.info(f"正在下载{file_path.stem}图片：{url} ...")
-            r = RequestUtils().get_res(url=url)
+            r = RequestUtils().get_res(url=url, raise_exception=True)
             if r:
                 file_path.write_bytes(r.content)
                 logger.info(f"图片已保存：{file_path}")

app/modules/themoviedb/tmdbapi.py

@@ -393,7 +393,7 @@ class TmdbHelper:
 
     def match_multi(self, name: str) -> Optional[dict]:
         """
-        根据名称同时查询电影和电视剧，不带年份
+        根据名称同时查询电影和电视剧，没有类型也没有年份时使用
         :param name: 识别的文件名或种子名
         :return: 匹配的媒体信息
         """
@@ -407,35 +407,51 @@ class TmdbHelper:
             print(traceback.print_exc())
             return None
         logger.debug(f"API返回：{str(self.search.total_results)}")
+        # 返回结果
+        ret_info = {}
         if len(multis) == 0:
             logger.debug(f"{name} 未找到相关媒体息!")
+            return {}
         else:
-            # 按年份降序排列
+            # 按年份降序排列，电影在前面
             multis = sorted(
                 multis,
-                key=lambda x: x.get('release_date') or x.get('first_air_date') or '0000-00-00',
+                key=lambda x: ("1"
+                               if x.get("media_type") == "movie"
+                               else "0") + (x.get('release_date')
+                                            or x.get('first_air_date')
+                                            or '0000-00-00'),
                 reverse=True
             )
             for multi in multis:
                 if multi.get("media_type") == "movie":
                     if self.__compare_names(name, multi.get('title')) \
                             or self.__compare_names(name, multi.get('original_title')):
-                        return multi
+                        ret_info = multi
+                        break
                     # 匹配别名、译名
                     if not multi.get("names"):
                         multi = self.get_info(mtype=MediaType.MOVIE, tmdbid=multi.get("id"))
                     if multi and self.__compare_names(name, multi.get("names")):
-                        return multi
+                        ret_info = multi
+                        break
                 elif multi.get("media_type") == "tv":
                     if self.__compare_names(name, multi.get('name')) \
                             or self.__compare_names(name, multi.get('original_name')):
-                        return multi
+                        ret_info = multi
+                        break
                     # 匹配别名、译名
                     if not multi.get("names"):
                         multi = self.get_info(mtype=MediaType.TV, tmdbid=multi.get("id"))
                     if multi and self.__compare_names(name, multi.get("names")):
-                        return multi
-        return {}
+                        ret_info = multi
+                        break
+            # 类型变更
+            if (ret_info
+                    and not isinstance(ret_info.get("media_type"), MediaType)):
+                ret_info['media_type'] = MediaType.MOVIE if ret_info.get("media_type") == "movie" else MediaType.TV
+
+            return ret_info
 
     @lru_cache(maxsize=settings.CACHE_CONF.get('tmdb'))
     def match_web(self, name: str, mtype: MediaType) -> Optional[dict]:
@@ -1152,3 +1168,35 @@ class TmdbHelper:
         清除缓存
         """
         self.tmdb.cache_clear()
+
+    def get_tv_episode_years(self, tv_id: int):
+        """
+        查询剧集组年份
+        """
+        try:
+            episode_groups = self.tv.episode_groups(tv_id)
+            if not episode_groups:
+                return {}
+            episode_years = {}
+            for episode_group in episode_groups:
+                logger.info(f"正在获取剧集组年份：{episode_group.get('id')}...")
+                if episode_group.get('type') != 6:
+                    # 只处理剧集部分
+                    continue
+                group_episodes = self.tv.group_episodes(episode_group.get('id'))
+                if not group_episodes:
+                    continue
+                for group_episode in group_episodes:
+                    order = group_episode.get('order')
+                    episodes = group_episode.get('episodes')
+                    if not episodes or not order:
+                        continue
+                    # 当前季第一季时间
+                    first_date = episodes[0].get("air_date")
+                    if not first_date and str(first_date).split("-") != 3:
+                        continue
+                    episode_years[order] = str(first_date).split("-")[0]
+            return episode_years
+        except Exception as e:
+            print(str(e))
+            return {}

app/modules/themoviedb/tmdbv3api/objs/tv.py

@@ -33,6 +33,7 @@ class TV(TMDb):
         "on_the_air": "/tv/on_the_air",
         "popular": "/tv/popular",
         "top_rated": "/tv/top_rated",
+        "group_episodes": "/tv/episode_group/%s",
     }
 
     def details(self, tv_id, append_to_response="videos,trailers,images,credits,translations"):
@@ -130,6 +131,17 @@ class TV(TMDb):
             key="results"
         )
 
+    def group_episodes(self, group_id):
+        """
+        查询剧集组所有剧集
+        :param group_id: int
+        :return:
+        """
+        return self._request_obj(
+            self._urls["group_episodes"] % group_id,
+            key="groups"
+        )
+
     def external_ids(self, tv_id):
         """
         Get the external ids for a TV show.

app/modules/thetvdb/__init__.py

@@ -1,18 +1,21 @@
 from typing import Optional, Tuple, Union
 
-import tvdb_api
 
 from app.core.config import settings
 from app.log import logger
 from app.modules import _ModuleBase
+from app.modules.thetvdb import tvdbapi
 
 
 class TheTvDbModule(_ModuleBase):
 
-    tvdb: tvdb_api.Tvdb = None
+    tvdb: tvdbapi.Tvdb = None
 
     def init_module(self) -> None:
-        self.tvdb = tvdb_api.Tvdb(apikey=settings.TVDB_API_KEY, cache=False, select_first=True)
+        self.tvdb = tvdbapi.Tvdb(apikey=settings.TVDB_API_KEY,
+                                 cache=False,
+                                 select_first=True,
+                                 proxies=settings.PROXY)
 
     def stop(self):
         pass

app/modules/transmission/__init__.py

@@ -10,7 +10,7 @@ from app.core.metainfo import MetaInfo
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.transmission.transmission import Transmission
-from app.schemas import TransferInfo, TransferTorrent, DownloadingTorrent
+from app.schemas import TransferTorrent, DownloadingTorrent
 from app.schemas.types import TorrentStatus
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
@@ -28,16 +28,30 @@ class TransmissionModule(_ModuleBase):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         return "DOWNLOADER", "transmission"
 
-    def download(self, torrent_path: Path, download_dir: Path, cookie: str,
-                 episodes: Set[int] = None) -> Optional[Tuple[Optional[str], str]]:
+    def scheduler_job(self) -> None:
+        """
+        定时任务，每10分钟调用一次
+        """
+        # 定时重连
+        if not self.transmission.is_inactive():
+            self.transmission = Transmission()
+
+    def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
+                 episodes: Set[int] = None, category: str = None) -> Optional[Tuple[Optional[str], str]]:
         """
         根据种子文件，选择并添加下载任务
-        :param torrent_path:  种子文件地址
+        :param content:  种子文件地址或者磁力链接
         :param download_dir:  下载目录
         :param cookie:  cookie
         :param episodes:  需要下载的集数
+        :param category:  分类，TR中未使用
         :return: 种子Hash
         """
+        if not content:
+            return
+        if isinstance(content, Path) and not content.exists():
+            return None, f"种子文件不存在：{content}"
+
         # 如果要选择文件则先暂停
         is_paused = True if episodes else False
         # 标签
@@ -46,13 +60,15 @@ class TransmissionModule(_ModuleBase):
         else:
             labels = None
         # 添加任务
-        torrent = self.transmission.add_torrent(content=torrent_path.read_bytes(),
-                                                download_dir=str(download_dir),
-                                                is_paused=is_paused,
-                                                labels=labels,
-                                                cookie=cookie)
+        torrent = self.transmission.add_torrent(
+            content=content.read_bytes() if isinstance(content, Path) else content,
+            download_dir=str(download_dir),
+            is_paused=is_paused,
+            labels=labels,
+            cookie=cookie
+        )
         if not torrent:
-            return None, f"添加种子任务失败：{torrent_path}"
+            return None, f"添加种子任务失败：{content}"
         else:
             torrent_hash = torrent.hashString
             if is_paused:
@@ -96,7 +112,7 @@ class TransmissionModule(_ModuleBase):
                     title=torrent.name,
                     path=Path(torrent.download_dir) / torrent.name,
                     hash=torrent.hashString,
-                    tags=torrent.labels
+                    tags=",".join(torrent.labels or [])
                 ))
         elif status == TorrentStatus.TRANSFER:
             # 获取已完成且未整理的
@@ -122,6 +138,8 @@ class TransmissionModule(_ModuleBase):
             torrents = self.transmission.get_downloading_torrents(tags=settings.TORRENT_TAG)
             for torrent in torrents or []:
                 meta = MetaInfo(torrent.name)
+                dlspeed = torrent.rate_download if hasattr(torrent, "rate_download") else torrent.rateDownload
+                upspeed = torrent.rate_upload if hasattr(torrent, "rate_upload") else torrent.rateUpload
                 ret_torrents.append(DownloadingTorrent(
                     hash=torrent.hashString,
                     title=torrent.name,
@@ -131,19 +149,19 @@ class TransmissionModule(_ModuleBase):
                     progress=torrent.progress,
                     size=torrent.total_size,
                     state="paused" if torrent.status == "stopped" else "downloading",
-                    dlspeed=StringUtils.str_filesize(torrent.download_speed),
-                    ulspeed=StringUtils.str_filesize(torrent.upload_speed),
+                    dlspeed=StringUtils.str_filesize(dlspeed),
+                    upspeed=StringUtils.str_filesize(upspeed),
                 ))
         else:
             return None
         return ret_torrents
 
     def transfer_completed(self, hashs: Union[str, list],
-                           transinfo: TransferInfo = None) -> None:
+                           path: Path = None) -> None:
         """
         转移完成后的处理
         :param hashs:  种子Hash
-        :param transinfo:  转移信息
+        :param path:  源目录
         :return: None
         """
         self.transmission.set_torrent_tag(ids=hashs, tags=['已整理'])
@@ -152,11 +170,11 @@ class TransmissionModule(_ModuleBase):
             if self.remove_torrents(hashs):
                 logger.info(f"移动模式删除种子成功：{hashs} ")
             # 删除残留文件
-            if transinfo and transinfo.path and transinfo.path.exists():
-                files = SystemUtils.list_files(transinfo.path, settings.RMT_MEDIAEXT)
+            if path and path.exists():
+                files = SystemUtils.list_files(path, settings.RMT_MEDIAEXT)
                 if not files:
-                    logger.warn(f"删除残留文件夹：{transinfo.path}")
-                    shutil.rmtree(transinfo.path, ignore_errors=True)
+                    logger.warn(f"删除残留文件夹：{path}")
+                    shutil.rmtree(path, ignore_errors=True)
 
     def remove_torrents(self, hashs: Union[str, list]) -> bool:
         """

app/modules/transmission/transmission.py

@@ -28,7 +28,7 @@ class Transmission(metaclass=Singleton):
         self._host, self._port = StringUtils.get_domain_address(address=settings.TR_HOST, prefix=False)
         self._username = settings.TR_USER
         self._password = settings.TR_PASSWORD
-        if self._host and self._port and self._username and self._password:
+        if self._host and self._port:
             self.trc = self.__login_transmission()
 
     def __login_transmission(self) -> Optional[Client]:
@@ -48,6 +48,14 @@ class Transmission(metaclass=Singleton):
             logger.error(f"transmission 连接出错：{err}")
             return None
 
+    def is_inactive(self) -> bool:
+        """
+        判断是否需要重连
+        """
+        if not self._host or not self._port:
+            return False
+        return True if not self.trc else False
+
     def get_torrents(self, ids: Union[str, list] = None, status: Union[str, list] = None,
                      tags: Union[str, list] = None) -> Tuple[List[Torrent], bool]:
         """
@@ -235,14 +243,14 @@ class Transmission(metaclass=Singleton):
             logger.error(f"获取传输信息出错：{err}")
             return None
 
-    def set_speed_limit(self, download_limit: float = None, upload_limit: float = None):
+    def set_speed_limit(self, download_limit: float = None, upload_limit: float = None) -> bool:
         """
         设置速度限制
         :param download_limit: 下载速度限制，单位KB/s
         :param upload_limit: 上传速度限制，单位kB/s
         """
         if not self.trc:
-            return
+            return False
         try:
             download_limit_enabled = True if download_limit else False
             upload_limit_enabled = True if upload_limit else False
@@ -252,6 +260,7 @@ class Transmission(metaclass=Singleton):
                 speed_limit_down_enabled=download_limit_enabled,
                 speed_limit_up_enabled=upload_limit_enabled
             )
+            return True
         except Exception as err:
             logger.error(f"设置速度限制出错：{err}")
             return False
@@ -279,3 +288,58 @@ class Transmission(metaclass=Singleton):
         except Exception as err:
             logger.error(f"添加Tracker出错：{err}")
             return False
+
+    def change_torrent(self,
+                       hash_string: str,
+                       upload_limit=None,
+                       download_limit=None,
+                       ratio_limit=None,
+                       seeding_time_limit=None):
+        """
+        设置种子
+        :param hash_string: ID
+        :param upload_limit: 上传限速 Kb/s
+        :param download_limit: 下载限速 Kb/s
+        :param ratio_limit: 分享率限制
+        :param seeding_time_limit: 做种时间限制
+        :return: bool
+        """
+        if not hash_string:
+            return False
+        if upload_limit:
+            uploadLimited = True
+            uploadLimit = int(upload_limit)
+        else:
+            uploadLimited = False
+            uploadLimit = 0
+        if download_limit:
+            downloadLimited = True
+            downloadLimit = int(download_limit)
+        else:
+            downloadLimited = False
+            downloadLimit = 0
+        if ratio_limit:
+            seedRatioMode = 1
+            seedRatioLimit = round(float(ratio_limit), 2)
+        else:
+            seedRatioMode = 2
+            seedRatioLimit = 0
+        if seeding_time_limit:
+            seedIdleMode = 1
+            seedIdleLimit = int(seeding_time_limit)
+        else:
+            seedIdleMode = 2
+            seedIdleLimit = 0
+        try:
+            self.trc.change_torrent(ids=hash_string,
+                                    uploadLimited=uploadLimited,
+                                    uploadLimit=uploadLimit,
+                                    downloadLimited=downloadLimited,
+                                    downloadLimit=downloadLimit,
+                                    seedRatioMode=seedRatioMode,
+                                    seedRatioLimit=seedRatioLimit,
+                                    seedIdleMode=seedIdleMode,
+                                    seedIdleLimit=seedIdleLimit)
+        except Exception as err:
+            logger.error(f"设置种子出错：{err}")
+            return False

app/modules/wechat/__init__.py

@@ -1,5 +1,5 @@
 import xml.dom.minidom
-from typing import Optional, Union, List, Tuple, Any
+from typing import Optional, Union, List, Tuple, Any, Dict
 
 from app.core.config import settings
 from app.core.context import Context, MediaInfo
@@ -96,16 +96,23 @@ class WechatModule(_ModuleBase):
             # 解析消息内容
             if msg_type == "event" and event == "click":
                 # 校验用户有权限执行交互命令
-                wechat_admins = settings.WECHAT_ADMINS.split(',')
-                if wechat_admins and not any(
-                        user_id == admin_user for admin_user in wechat_admins):
-                    self.wechat.send_msg(title="用户无权限执行菜单命令", userid=user_id)
-                    return None
+                if settings.WECHAT_ADMINS:
+                    wechat_admins = settings.WECHAT_ADMINS.split(',')
+                    if wechat_admins and not any(
+                            user_id == admin_user for admin_user in wechat_admins):
+                        self.wechat.send_msg(title="用户无权限执行菜单命令", userid=user_id)
+                        return None
+                # 根据EventKey执行命令
+                content = DomUtils.tag_value(root_node, "EventKey")
+                logger.info(f"收到微信事件：userid={user_id}, event={content}")
             elif msg_type == "text":
                 # 文本消息
                 content = DomUtils.tag_value(root_node, "Content", default="")
-                if content:
-                    logger.info(f"收到微信消息：userid={user_id}, text={content}")
+                logger.info(f"收到微信消息：userid={user_id}, text={content}")
+            else:
+                return None
+
+            if content:
                 # 处理消息内容
                 return CommingMessage(channel=MessageChannel.Wechat,
                                       userid=user_id, username=user_id, text=content)
@@ -145,3 +152,10 @@ class WechatModule(_ModuleBase):
         :return: 成功或失败
         """
         return self.wechat.send_torrents_msg(title=message.title, torrents=torrents, userid=message.userid)
+
+    def register_commands(self, commands: Dict[str, dict]):
+        """
+        注册命令，实现这个函数接收系统可用的命令菜单
+        :param commands: 命令字典
+        """
+        self.wechat.create_menus(commands)

app/modules/wechat/wechat.py

@@ -2,7 +2,7 @@ import json
 import re
 import threading
 from datetime import datetime
-from typing import Optional, List
+from typing import Optional, List, Dict
 
 from app.core.config import settings
 from app.core.context import MediaInfo, Context
@@ -33,6 +33,8 @@ class WeChat(metaclass=Singleton):
     _send_msg_url = f"{settings.WECHAT_PROXY}/cgi-bin/message/send?access_token=%s"
     # 企业微信获取TokenURL
     _token_url = f"{settings.WECHAT_PROXY}/cgi-bin/gettoken?corpid=%s&corpsecret=%s"
+    # 企业微信创新菜单URL
+    _create_menu_url = f"{settings.WECHAT_PROXY}/cgi-bin/menu/create?access_token=%s&agentid=%s"
 
     def __init__(self):
         """
@@ -69,6 +71,10 @@ class WeChat(metaclass=Singleton):
                         self._access_token = ret_json.get('access_token')
                         self._expires_in = ret_json.get('expires_in')
                         self._access_token_time = datetime.now()
+                elif res is not None:
+                    logger.error(f"获取微信access_token失败，错误码：{res.status_code}，错误原因：{res.reason}")
+                else:
+                    logger.error(f"获取微信access_token失败，未获取到返回信息")
             except Exception as e:
                 logger.error(f"获取微信access_token失败，错误信息：{e}")
                 return None
@@ -216,6 +222,7 @@ class WeChat(metaclass=Singleton):
             torrent_title = f"{index}.【{torrent.site_name}】" \
                             f"{meta.season_episode} " \
                             f"{meta.resource_term} " \
+                            f"{meta.video_term} " \
                             f"{meta.release_group} " \
                             f"{StringUtils.str_filesize(torrent.size)} " \
                             f"{torrent.volume_factor} " \
@@ -255,14 +262,87 @@ class WeChat(metaclass=Singleton):
                 else:
                     if ret_json.get('errcode') == 42001:
                         self.__get_access_token(force=True)
-                    logger.error(f"发送消息失败，错误信息：{ret_json.get('errmsg')}")
+                    logger.error(f"发送请求失败，错误信息：{ret_json.get('errmsg')}")
                     return False
             elif res is not None:
-                logger.error(f"发送消息失败，错误码：{res.status_code}，错误原因：{res.reason}")
+                logger.error(f"发送请求失败，错误码：{res.status_code}，错误原因：{res.reason}")
                 return False
             else:
-                logger.error(f"发送消息失败，未获取到返回信息")
+                logger.error(f"发送请求失败，未获取到返回信息")
                 return False
         except Exception as err:
-            logger.error(f"发送消息失败，错误信息：{err}")
+            logger.error(f"发送请求失败，错误信息：{err}")
             return False
+
+    def create_menus(self, commands: Dict[str, dict]):
+        """
+        自动注册微信菜单
+        :param commands: 命令字典
+        命令字典：
+        {
+            "/cookiecloud": {
+                "func": CookieCloudChain(self._db).remote_sync,
+                "description": "同步站点",
+                "category": "站点",
+                "data": {}
+            }
+        }
+        注册报文格式，一级菜单只有最多3条，子菜单最多只有5条：
+        {
+           "button":[
+               {
+                   "type":"click",
+                   "name":"今日歌曲",
+                   "key":"V1001_TODAY_MUSIC"
+               },
+               {
+                   "name":"菜单",
+                   "sub_button":[
+                       {
+                           "type":"view",
+                           "name":"搜索",
+                           "url":"http://www.soso.com/"
+                       },
+                       {
+                           "type":"click",
+                           "name":"赞一下我们",
+                           "key":"V1001_GOOD"
+                       }
+                   ]
+              }
+           ]
+        }
+        """
+        # 请求URL
+        req_url = self._create_menu_url % (self.__get_access_token(), self._appid)
+
+        # 对commands按category分组
+        category_dict = {}
+        for key, value in commands.items():
+            category: Dict[str, dict] = value.get("category")
+            if category:
+                if not category_dict.get(category):
+                    category_dict[category] = {}
+                category_dict[category][key] = value
+
+        # 一级菜单
+        buttons = []
+        for category, menu in category_dict.items():
+            # 二级菜单
+            sub_buttons = []
+            for key, value in menu.items():
+                sub_buttons.append({
+                    "type": "click",
+                    "name": value.get("description"),
+                    "key": key
+                })
+            buttons.append({
+                "name": category,
+                "sub_button": sub_buttons[:5]
+            })
+
+        if buttons:
+            # 发送请求
+            self.__post_request(req_url, {
+                "button": buttons[:3]
+            })