Update

.gitignore

@@ -1 +1,2 @@
 *.env
+data/

.prettierignore

@@ -0,0 +1 @@
+bvplan/templates

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) 2023  Dominic Grimm <dominic@dergrimm.net>
+
+    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) 2023  Dominic Grimm <dominic@dergrimm.net>
+    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>.

Makefile

@@ -1,6 +1,9 @@
-.PHONY: all build
+.PHONY: all build ci
 
 all: build
 
 build:
+	docker compose build
+
+ci:
 	BUILDKIT_PROGRESS=plain docker compose build

backend/src/bin/api.rs

@@ -1,31 +0,0 @@
-#[cfg(not(target_env = "msvc"))]
-use tikv_jemallocator::Jemalloc;
-
-#[cfg(not(target_env = "msvc"))]
-#[global_allocator]
-static GLOBAL: Jemalloc = Jemalloc;
-
-use actix_cors::Cors;
-use actix_web::{http::header, middleware, App, HttpServer};
-
-#[actix_web::main]
-async fn main() -> std::io::Result<()> {
-    std::env::set_var("RUST_LOG", "info");
-    env_logger::init();
-
-    let server = HttpServer::new(move || {
-        App::new()
-            .wrap(
-                Cors::default()
-                    .allow_any_origin()
-                    .allowed_methods(vec!["POST", "GET"])
-                    .allowed_header(header::ACCEPT)
-                    .allowed_header(header::CONTENT_TYPE)
-                    .supports_credentials()
-                    .max_age(3600),
-            )
-            .wrap(middleware::Compress::default())
-            .wrap(middleware::Logger::default())
-    });
-    server.bind("0.0.0.0:80").unwrap().run().await
-}

backend/src/cache.rs

@@ -1,26 +0,0 @@
-use anyhow::Result;
-use lazy_static::lazy_static;
-use r2d2_redis::{r2d2, RedisConnectionManager};
-
-use crate::config;
-
-pub type CachePool = r2d2::Pool<RedisConnectionManager>;
-pub type ConnectionPool = r2d2::PooledConnection<RedisConnectionManager>;
-
-pub fn establish_connection() -> Result<RedisConnectionManager> {
-    Ok(RedisConnectionManager::new(
-        config::CONFIG.redis_url.as_str(),
-    )?)
-}
-
-pub fn pool() -> Result<CachePool> {
-    Ok(r2d2::Pool::builder().build(establish_connection()?)?)
-}
-
-lazy_static! {
-    pub static ref POOL: CachePool = pool().unwrap();
-}
-
-pub mod keys {
-    // pub const LAST_SUBSTITUTION_QUERY_ID: &str = "last_subst_query_id";
-}

bvplan/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
-name = "backend"
+name = "bvplan"
 version = "0.1.0"
 edition = "2021"
 
 [[bin]]
-name = "api"
+name = "web"
 
 [[bin]]
 name = "worker"
@@ -16,21 +16,24 @@ strip = true
 panic = "abort"
 
 [dependencies]
-actix-cors = "0.6.4"
 actix-web = "4.2.1"
 anyhow = { version = "1.0.66", features = ["backtrace"] }
+askama = { version = "0.11.1", features = ["serde-json"] }
 celery = { git = "https://github.com/rusty-celery/rusty-celery.git", branch = "main" }
 chrono = "0.4.23"
 diesel = { version = "2.0.2", features = ["i-implement-a-third-party-backend-and-opt-into-breaking-changes", "postgres", "chrono", "r2d2"] }
 env_logger = "0.9.3"
 envconfig = "0.10.0"
+fancy-regex = "0.11.0"
+flate2 = "1.0.25"
 lazy_static = "1.4.0"
 log = "0.4.17"
+minify-html = "0.10.8"
 r2d2_redis = "0.14.0"
-regex = "1.7.1"
 reqwest = "0.11.13"
 scraper = "0.14.0"
 serde = "1.0.148"
+serde_json = "1.0.93"
 stdext = "0.3.1"
 tokio = { version = "1.22.0", features = ["full"] }
 untis = { git = "https://git.dergrimm.net/dergrimm/untis.rs.git", branch = "main" }

bvplan/Dockerfile

@@ -13,10 +13,16 @@ FROM chef as builder
 WORKDIR /usr/src/backend
 COPY --from=planner /usr/src/backend/recipe.json .
 RUN cargo chef cook --recipe-path recipe.json
+COPY ./templates ./templates
 COPY ./src ./src
 RUN cargo build
 
 FROM docker.io/debian:bullseye-slim as runner
+LABEL maintainer="Dominic Grimm <dominic@dergrimm.net>" \
+    org.opencontainers.image.description="Bessrer Vertretungsplan" \
+    org.opencontainers.image.licenses="GPLv3" \
+    org.opencontainers.image.source="https://git.dergrimm.net/dergrimm/bvplan" \
+    org.opencontainers.image.url="https://git.dergrimm.net/dergrimm/bvplan"
 RUN apt update
 RUN apt install -y libpq5
 RUN apt install -y ca-certificates
@@ -29,6 +35,6 @@ WORKDIR /usr/src/backend
 COPY ./run.sh .
 RUN chmod +x ./run.sh
 COPY ./migrations ./migrations
-COPY --from=builder /usr/src/backend/target/debug/api /usr/src/backend/target/debug/worker ./bin/
+COPY --from=builder /usr/src/backend/target/debug/web /usr/src/backend/target/debug/worker ./bin/
 EXPOSE 80
 ENTRYPOINT [ "./run.sh" ]

bvplan/migrations/2022-12-03-124501_init/down.sql

@@ -18,6 +18,10 @@ DROP TABLE timegrid_time_unit;
 
 DROP TABLE timegrid_days;
 
+DROP TYPE day_of_week;
+
+DROP INDEX timegrids_active;
+
 DROP TABLE timegrids;
 
 DROP TABLE holidays;
@@ -36,4 +40,6 @@ DROP INDEX tenants_active;
 
 DROP TABLE tenants;
 
+DROP INDEX schoolyears_active;
+
 DROP TABLE schoolyears;

bvplan/migrations/2022-12-03-124501_init/up.sql

@@ -7,7 +7,7 @@ CREATE TABLE schoolyears (
     updated_at TIMESTAMP
 );
 
-CREATE UNIQUE INDEX schoolyears_unique ON schoolyears(active)
+CREATE UNIQUE INDEX schoolyears_active ON schoolyears(active)
 WHERE
     active;
 
@@ -92,14 +92,23 @@ CREATE TABLE holidays (
 CREATE TABLE timegrids (
     id SERIAL PRIMARY KEY,
     schoolyear_id INTEGER NOT NULL REFERENCES schoolyears(id),
+    active BOOLEAN NOT NULL,
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMP
 );
 
+CREATE UNIQUE INDEX timegrids_active ON timegrids(active)
+WHERE
+    active;
+
+CREATE TYPE weekday AS ENUM (
+    'mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'
+);
+
 CREATE TABLE timegrid_days (
     id SERIAL PRIMARY KEY,
     timegrid_id INTEGER NOT NULL REFERENCES timegrids(id),
-    day_index SMALLINT NOT NULL,
+    weekday weekday NOT NULL,
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMP
 );
@@ -160,6 +169,7 @@ CREATE TABLE substitution_classes (
     substitution_id INTEGER NOT NULL REFERENCES substitutions(id),
     position SMALLINT NOT NULL,
     class_id INTEGER NOT NULL REFERENCES classes(id),
+    original_id INTEGER REFERENCES classes(id),
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMP
 );
@@ -169,6 +179,7 @@ CREATE TABLE substitution_teachers (
     substitution_id INTEGER NOT NULL REFERENCES substitutions(id),
     position SMALLINT NOT NULL,
     teacher_id INTEGER REFERENCES teachers(id),
+    original_id INTEGER REFERENCES teachers(id),
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMP
 );
@@ -178,6 +189,7 @@ CREATE TABLE substitution_subjects (
     substitution_id INTEGER NOT NULL REFERENCES substitutions(id),
     position SMALLINT NOT NULL,
     subject_id INTEGER NOT NULL REFERENCES subjects(id),
+    original_id INTEGER REFERENCES subjects(id),
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMP
 );
@@ -187,7 +199,7 @@ CREATE TABLE substitution_rooms (
     substitution_id INTEGER NOT NULL REFERENCES substitutions(id),
     position SMALLINT NOT NULL,
     room_id INTEGER REFERENCES rooms(id),
-    original_room_id INTEGER REFERENCES rooms(id),
+    original_id INTEGER REFERENCES rooms(id),
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMP
 );

bvplan/run.sh

@@ -3,5 +3,6 @@
 
 DATABASE_URL="$BACKEND_DB_URL" diesel setup \
   --migration-dir ./migrations \
-  --locked-schema &&
+  --locked-schema
-  RUST_BACKTRACE=full "./bin/$1"
+
+RUST_BACKTRACE=1 RUST_LOG=info "./bin/$1"

bvplan/src/bin/web.rs

@@ -0,0 +1,48 @@
+#[cfg(not(target_env = "msvc"))]
+use tikv_jemallocator::Jemalloc;
+
+#[cfg(not(target_env = "msvc"))]
+#[global_allocator]
+static GLOBAL: Jemalloc = Jemalloc;
+
+use actix_web::{get, middleware, web::Data, App, HttpResponse, HttpServer};
+use r2d2_redis::redis;
+use std::ops::DerefMut;
+
+use bvplan::*;
+
+#[get("/")]
+async fn index(redis_pool: Data<cache::RedisPool>) -> HttpResponse {
+    let redis_conn = &mut match redis_pool.get() {
+        Ok(x) => x,
+        Err(_) => return HttpResponse::InternalServerError().finish(),
+    };
+
+    if let Some(html) = match redis::cmd("GET")
+        .arg(cache::keys::SUBSTITUTIONS_HTML)
+        .query::<Option<String>>(redis_conn.deref_mut())
+    {
+        Ok(x) => x,
+        Err(_) => return HttpResponse::InternalServerError().finish(),
+    } {
+        HttpResponse::Accepted()
+            .content_type("text/html; charset=utf-8")
+            .body(html)
+    } else {
+        HttpResponse::InternalServerError().finish()
+    }
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    env_logger::init();
+
+    let server = HttpServer::new(move || {
+        App::new()
+            .app_data(Data::new(cache::pool().unwrap()))
+            .wrap(middleware::Compress::default())
+            .wrap(middleware::Logger::default())
+            .service(index)
+    });
+    server.bind("0.0.0.0:80").unwrap().run().await
+}

bvplan/src/bin/worker.rs

@@ -7,18 +7,17 @@ static GLOBAL: Jemalloc = Jemalloc;
 
 use std::thread;
 
+use bvplan::*;
+
 #[tokio::main]
 async fn main() {
-    std::env::set_var("RUST_LOG", "info");
     env_logger::init();
 
     println!("Starting worker!");
-
+    worker::init_blocking();
-    backend::worker::init_blocking();
-
     thread::spawn(|| {
         tokio::runtime::Runtime::new().unwrap().block_on(async {
-            backend::worker::beat()
+            worker::beat()
                 .await
                 .unwrap()
                 .start()
@@ -27,11 +26,10 @@ async fn main() {
         });
     });
 
-    let app = backend::worker::APP.lock().unwrap();
+    let app = worker::APP.lock().unwrap();
     let app = app.as_ref().unwrap();
-
     app.display_pretty().await;
-    app.consume_from(&[backend::worker::QUEUE_NAME])
+    app.consume_from(&[worker::QUEUE_NAME])
         .await
         .unwrap();
 }

bvplan/src/cache.rs

@@ -0,0 +1,77 @@
+use anyhow::Result;
+
+use lazy_static::lazy_static;
+use r2d2_redis::{r2d2, redis, RedisConnectionManager};
+
+use crate::config;
+use crate::db;
+
+pub type RedisPool = r2d2::Pool<RedisConnectionManager>;
+pub type ConnectionPool = r2d2::PooledConnection<RedisConnectionManager>;
+pub type Connection = redis::Connection;
+
+pub fn establish_connection() -> Result<RedisConnectionManager> {
+    Ok(RedisConnectionManager::new(
+        config::CONFIG.redis_url.as_str(),
+    )?)
+}
+
+pub fn pool() -> Result<RedisPool> {
+    Ok(r2d2::Pool::builder().build(establish_connection()?)?)
+}
+
+lazy_static! {
+    pub static ref POOL: RedisPool = pool().unwrap();
+}
+
+pub mod keys {
+    use super::*;
+
+    // pub const SUBSTITUTIONS: &str = "substs";
+    pub const SUBSTITUTIONS_HTML: &str = "substs_html";
+
+    pub mod substitutions {
+        use chrono::prelude::*;
+        use serde::{Deserialize, Serialize};
+
+        use super::*;
+
+        #[derive(Deserialize, Serialize, Debug)]
+        pub struct Substitution {
+            #[serde(rename = "tm")]
+            pub time: (usize, Option<usize>),
+            #[serde(rename = "cl")]
+            pub classes: Vec<String>,
+            #[serde(rename = "ps")]
+            pub prev_subject: String,
+            #[serde(rename = "s")]
+            pub subject: Option<String>,
+            #[serde(rename = "t")]
+            pub teachers: Vec<String>,
+            #[serde(rename = "pr")]
+            pub prev_room: Option<String>,
+            #[serde(rename = "r")]
+            pub room: Option<String>,
+            #[serde(rename = "tx")]
+            pub text: Option<String>,
+        }
+
+        #[derive(Deserialize, Serialize, Debug)]
+        pub struct SubstitutionQuery {
+            #[serde(rename = "d")]
+            pub date: NaiveDate,
+            #[serde(rename = "w")]
+            pub week_type: db::models::WeekType,
+            #[serde(rename = "q")]
+            pub queried_at: NaiveDateTime,
+            #[serde(rename = "i")]
+            pub last_import_time: NaiveDateTime,
+            #[serde(rename = "y")]
+            pub schoolyear: String,
+            #[serde(rename = "t")]
+            pub tenant: String,
+            #[serde(rename = "s")]
+            pub substitutions: Vec<Substitution>,
+        }
+    }
+}

bvplan/src/config.rs

@@ -48,11 +48,12 @@ lazy_static! {
 
 pub fn untis_from_env() -> Result<untis::Client> {
     Ok(untis::Client {
-        api_url: Url::parse(&CONFIG.untis_api_url)?,
+        // api_url: Url::parse(&CONFIG.untis_api_url)?,
+        webuntis_url: Url::parse(&CONFIG.untis_api_url)?,
         rpc_url: untis::Client::gen_rpc_url(
-            Url::parse(&CONFIG.untis_rpc_url)?,
+            &Url::parse(&CONFIG.untis_rpc_url)?,
             &CONFIG.untis_school,
-        ),
+        )?,
         client_name: CONFIG.untis_client_name.to_owned(),
         user_agent: "Mozilla/5.0 (Windows NT 10.0; rv:108.0) Gecko/20100101 Firefox/108.0"
             .to_string(),

bvplan/src/db/mod.rs

@@ -10,8 +10,11 @@ pub mod models;
 pub mod schema;
 
 pub type DbPool = Pool<ConnectionManager<PgConnection>>;
+pub type Connection = PgConnection;
 
 pub fn establish_connection() -> ConnectionResult<PgConnection> {
+    use diesel::Connection;
+
     PgConnection::establish(&config::CONFIG.db_url)
 }
 

bvplan/src/db/models.rs

@@ -1,6 +1,10 @@
+use anyhow::bail;
 use chrono::prelude::*;
 use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::fmt::Display;
 use std::io::Write;
+use std::str::FromStr;
 
 use crate::db::schema;
 
@@ -160,8 +164,8 @@ pub struct NewDepartment<'a> {
 }
 
 #[derive(Identifiable, Queryable, Associations, Debug)]
-#[diesel(table_name = schema::holidays)]
 #[diesel(belongs_to(Schoolyear))]
+#[diesel(table_name = schema::holidays)]
 pub struct Holiday {
     pub id: i32,
     pub untis_id: i32,
@@ -185,13 +189,175 @@ pub struct NewHoliday<'a> {
     pub end_date: NaiveDate,
 }
 
+#[derive(Identifiable, Queryable, Associations, Debug)]
+#[diesel(belongs_to(Schoolyear))]
+#[diesel(table_name = schema::timegrids)]
+pub struct Timegrid {
+    pub id: i32,
+    pub schoolyear_id: i32,
+    pub active: bool,
+    pub created_at: NaiveDateTime,
+    pub updated_at: Option<NaiveDateTime>,
+}
+
+#[derive(Insertable, Debug)]
+#[diesel(table_name = schema::timegrids)]
+pub struct NewTimegrid {
+    pub schoolyear_id: i32,
+    pub active: bool,
+}
+
 #[derive(diesel::FromSqlRow, diesel::AsExpression, PartialEq, Eq, Clone, Debug)]
+#[diesel(sql_type = schema::sql_types::Weekday)]
+pub enum Weekday {
+    Mon,
+    Tue,
+    Wed,
+    Thu,
+    Fri,
+    Sat,
+    Sun,
+}
+
+impl TryFrom<u8> for Weekday {
+    type Error = anyhow::Error;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Ok(match value {
+            1 => Self::Sun,
+            2 => Self::Mon,
+            3 => Self::Tue,
+            4 => Self::Wed,
+            5 => Self::Thu,
+            6 => Self::Fri,
+            7 => Self::Sat,
+            _ => bail!("Invalid weekday: {:?}", value),
+        })
+    }
+}
+
+impl From<chrono::Weekday> for Weekday {
+    fn from(value: chrono::Weekday) -> Self {
+        match value {
+            chrono::Weekday::Mon => Self::Mon,
+            chrono::Weekday::Tue => Self::Tue,
+            chrono::Weekday::Wed => Self::Wed,
+            chrono::Weekday::Thu => Self::Thu,
+            chrono::Weekday::Fri => Self::Fri,
+            chrono::Weekday::Sat => Self::Sat,
+            chrono::Weekday::Sun => Self::Sun,
+        }
+    }
+}
+
+impl diesel::serialize::ToSql<schema::sql_types::Weekday, diesel::pg::Pg> for Weekday {
+    fn to_sql<'b>(
+        &'b self,
+        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,
+    ) -> diesel::serialize::Result {
+        match *self {
+            Self::Mon => out.write_all(b"mon")?,
+            Self::Tue => out.write_all(b"tue")?,
+            Self::Wed => out.write_all(b"wed")?,
+            Self::Thu => out.write_all(b"thu")?,
+            Self::Fri => out.write_all(b"fri")?,
+            Self::Sat => out.write_all(b"sat")?,
+            Self::Sun => out.write_all(b"sun")?,
+        }
+
+        Ok(diesel::serialize::IsNull::No)
+    }
+}
+
+impl diesel::deserialize::FromSql<schema::sql_types::Weekday, diesel::pg::Pg> for Weekday {
+    fn from_sql(
+        bytes: diesel::backend::RawValue<'_, diesel::pg::Pg>,
+    ) -> diesel::deserialize::Result<Self> {
+        match bytes.as_bytes() {
+            b"mon" => Ok(Self::Mon),
+            b"tue" => Ok(Self::Tue),
+            b"wed" => Ok(Self::Wed),
+            b"thu" => Ok(Self::Thu),
+            b"fri" => Ok(Self::Fri),
+            b"sat" => Ok(Self::Sat),
+            b"sun" => Ok(Self::Sun),
+            _ => Err("Unrecognized enum variant".into()),
+        }
+    }
+}
+
+#[derive(Identifiable, Queryable, Associations, Debug)]
+#[diesel(belongs_to(Timegrid))]
+#[diesel(table_name = schema::timegrid_days)]
+pub struct TimegridDay {
+    pub id: i32,
+    pub timegrid_id: i32,
+    pub weekday: Weekday,
+    pub created_at: NaiveDateTime,
+    pub updated_at: Option<NaiveDateTime>,
+}
+
+#[derive(Insertable, Debug)]
+#[diesel(table_name = schema::timegrid_days)]
+pub struct NewTimegridDay {
+    pub timegrid_id: i32,
+    pub weekday: Weekday,
+}
+
+#[derive(Identifiable, Queryable, Associations, Debug)]
+#[diesel(belongs_to(TimegridDay))]
+#[diesel(table_name = schema::timegrid_time_unit)]
+pub struct TimegridTimeUnit {
+    pub id: i32,
+    pub timegrid_day_id: i32,
+    pub start_time: NaiveTime,
+    pub end_time: NaiveTime,
+    pub created_at: NaiveDateTime,
+    pub updated_at: Option<NaiveDateTime>,
+}
+
+#[derive(Insertable, Debug)]
+#[diesel(table_name = schema::timegrid_time_unit)]
+pub struct NewTimegridTimeUnit {
+    pub timegrid_day_id: i32,
+    pub start_time: NaiveTime,
+    pub end_time: NaiveTime,
+}
+
+#[derive(
+    Serialize, Deserialize, diesel::FromSqlRow, diesel::AsExpression, PartialEq, Eq, Clone, Debug,
+)]
 #[diesel(sql_type = schema::sql_types::WeekType)]
 pub enum WeekType {
     A,
     B,
 }
 
+impl Display for WeekType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::A => "A",
+                Self::B => "B",
+            }
+        )
+    }
+}
+
+impl FromStr for WeekType {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "A" => Ok(Self::A),
+            "B" => Ok(Self::B),
+            _ => bail!("Unrecognized enum variant"),
+        }
+    }
+}
+
 impl diesel::serialize::ToSql<schema::sql_types::WeekType, diesel::pg::Pg> for WeekType {
     fn to_sql<'b>(
         &'b self,
@@ -373,6 +539,7 @@ pub struct SubstitutionClass {
     pub substitution_id: i32,
     pub position: i16,
     pub class_id: i32,
+    pub original_id: Option<i32>,
     pub created_at: NaiveDateTime,
     pub updated_at: Option<NaiveDateTime>,
 }
@@ -383,6 +550,7 @@ pub struct NewSubstitutionClass {
     pub substitution_id: i32,
     pub position: i16,
     pub class_id: i32,
+    pub original_id: Option<i32>,
 }
 
 #[derive(Identifiable, Queryable, Associations, Debug)]
@@ -394,6 +562,7 @@ pub struct SubstitutionTeacher {
     pub substitution_id: i32,
     pub position: i16,
     pub teacher_id: Option<i32>,
+    pub original_id: Option<i32>,
     pub created_at: NaiveDateTime,
     pub updated_at: Option<NaiveDateTime>,
 }
@@ -404,6 +573,7 @@ pub struct NewSubstitutionTeacher {
     pub substitution_id: i32,
     pub position: i16,
     pub teacher_id: Option<i32>,
+    pub original_id: Option<i32>,
 }
 
 #[derive(Identifiable, Queryable, Associations, Debug)]
@@ -415,6 +585,7 @@ pub struct SubstitutionSubject {
     pub substitution_id: i32,
     pub position: i16,
     pub subject_id: i32,
+    pub original_id: Option<i32>,
     pub created_at: NaiveDateTime,
     pub updated_at: Option<NaiveDateTime>,
 }
@@ -425,6 +596,7 @@ pub struct NewSubstitutionSubject {
     pub substitution_id: i32,
     pub position: i16,
     pub subject_id: i32,
+    pub original_id: Option<i32>,
 }
 
 #[derive(Identifiable, Queryable, Associations, Debug)]
@@ -435,9 +607,8 @@ pub struct SubstitutionRoom {
     pub id: i32,
     pub substitution_id: i32,
     pub position: i16,
-    pub index: i16,
     pub room_id: Option<i32>,
-    pub original_room_id: Option<i32>,
+    pub original_id: Option<i32>,
     pub created_at: NaiveDateTime,
     pub updated_at: Option<NaiveDateTime>,
 }
@@ -448,5 +619,5 @@ pub struct NewSubstitutionRoom {
     pub substitution_id: i32,
     pub position: i16,
     pub room_id: Option<i32>,
-    pub original_room_id: Option<i32>,
+    pub original_id: Option<i32>,
 }

bvplan/src/db/schema.rs

@@ -1,4 +1,8 @@
 pub mod sql_types {
+    #[derive(diesel::sql_types::SqlType)]
+    #[diesel(postgres_type(name = "weekday"))]
+    pub struct Weekday;
+
     #[derive(diesel::sql_types::SqlType)]
     #[diesel(postgres_type(name = "substitution_type"))]
     pub struct SubstitutionType;
@@ -111,17 +115,21 @@ diesel::table! {
     timegrids {
         id -> Integer,
         schoolyear_id -> Integer,
+        active -> Bool,
         created_at -> Timestamp,
         updated_at -> Nullable<Timestamp>,
     }
 }
 
 diesel::table! {
+    use diesel::sql_types::*;
+
+    use super::sql_types::*;
+
     timegrid_days {
         id -> Integer,
         timegrid_id -> Integer,
-        #[sql_name = "day_index"]
+        weekday -> Weekday,
-        day -> SmallInt,
         created_at -> Timestamp,
         updated_at -> Nullable<Timestamp>,
     }
@@ -130,7 +138,7 @@ diesel::table! {
 diesel::table! {
     timegrid_time_unit {
         id -> Integer,
-        timegrid_id -> Integer,
+        timegrid_day_id -> Integer,
         start_time -> Time,
         end_time -> Time,
         created_at -> Timestamp,
@@ -141,7 +149,7 @@ diesel::table! {
 diesel::table! {
     use diesel::sql_types::*;
 
-    use super::sql_types::WeekType;
+    use super::sql_types::*;
 
     substitution_queries {
         id -> Integer,
@@ -157,7 +165,7 @@ diesel::table! {
 diesel::table! {
     use diesel::sql_types::*;
 
-    use super::sql_types::SubstitutionType;
+    use super::sql_types::*;
 
     substitutions {
         id -> Integer,
@@ -178,6 +186,7 @@ diesel::table! {
         substitution_id -> Integer,
         position -> SmallInt,
         class_id -> Integer,
+        original_id -> Nullable<Integer>,
         created_at -> Timestamp,
         updated_at -> Nullable<Timestamp>,
     }
@@ -189,6 +198,7 @@ diesel::table! {
         substitution_id -> Integer,
         position -> SmallInt,
         teacher_id -> Nullable<Integer>,
+        original_id -> Nullable<Integer>,
         created_at -> Timestamp,
         updated_at -> Nullable<Timestamp>,
     }
@@ -200,6 +210,7 @@ diesel::table! {
         substitution_id -> Integer,
         position -> SmallInt,
         subject_id -> Integer,
+        original_id -> Nullable<Integer>,
         created_at -> Timestamp,
         updated_at -> Nullable<Timestamp>,
     }
@@ -211,7 +222,7 @@ diesel::table! {
         substitution_id -> Integer,
         position -> SmallInt,
         room_id -> Nullable<Integer>,
-        original_room_id -> Nullable<Integer>,
+        original_id -> Nullable<Integer>,
         created_at -> Timestamp,
         updated_at -> Nullable<Timestamp>,
     }

bvplan/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod cache;
 pub mod config;
 pub mod db;
+pub mod templates;
 pub mod worker;

bvplan/src/templates.rs

@@ -0,0 +1,9 @@
+use askama::Template;
+
+use crate::cache;
+
+#[derive(Template)]
+#[template(path = "bvplan.html")]
+pub struct BVplan {
+    pub data: cache::keys::substitutions::SubstitutionQuery,
+}

bvplan/src/worker/mod.rs

@@ -1,19 +1,19 @@
 use celery::beat::DeltaSchedule;
-use celery::broker::AMQPBroker;
 use lazy_static::lazy_static;
 use std::sync::{Arc, Mutex};
 use std::thread;
-use std::time;
+use std::time::Duration;
 use stdext::duration::DurationExt;
 
 use crate::config;
 
 pub mod update_info;
+pub mod update_meta;
 
 pub const QUEUE_NAME: &str = "celery";
 
 lazy_static! {
-    pub static ref APP: Mutex<Option<Arc<celery::Celery<AMQPBroker>>>> = Mutex::new(None);
+    pub static ref APP: Mutex<Option<Arc<celery::Celery>>> = Mutex::new(None);
 }
 
 #[tokio::main]
@@ -23,6 +23,7 @@ pub async fn init() {
             broker = AMQPBroker { &config::CONFIG.amqp_url },
             tasks = [
                 update_info::update_info,
+                update_meta::update_meta,
             ],
             task_routes = [
                 "*" => QUEUE_NAME,
@@ -35,12 +36,38 @@ pub async fn init() {
     );
 }
 
+pub fn beat() -> impl std::future::Future<
+    Output = Result<
+        celery::beat::Beat<celery::beat::LocalSchedulerBackend>,
+        celery::error::BeatError,
+    >,
+> {
+    celery::beat!(
+        broker = AMQPBroker { &config::CONFIG.amqp_url },
+        tasks = [
+            "update_info" => {
+                update_info::update_info,
+                schedule = DeltaSchedule::new(Duration::from_minutes(999)),
+                args = (),
+            },
+            "update_meta" => {
+                update_meta::update_meta,
+                schedule = DeltaSchedule::new(Duration::from_hours(6)),
+                args = (),
+            }
+        ],
+        task_routes = [
+            "*" => QUEUE_NAME,
+        ]
+    )
+}
+
 pub fn init_blocking() {
     thread::spawn(|| {
         tokio::runtime::Runtime::new().unwrap().spawn_blocking(init);
     });
 
-    let dur = time::Duration::from_secs(1);
+    let dur = Duration::from_secs(1);
     let mut i = 0;
     loop {
         if APP.lock().unwrap().is_some() {
@@ -54,24 +81,3 @@ pub fn init_blocking() {
         }
     }
 }
-
-pub fn beat() -> impl std::future::Future<
-    Output = Result<
-        celery::beat::Beat<AMQPBroker, celery::beat::LocalSchedulerBackend>,
-        celery::error::BeatError,
-    >,
-> {
-    celery::beat!(
-        broker = AMQPBroker { &config::CONFIG.amqp_url },
-        tasks = [
-            "update_info" => {
-                update_info::update_info,
-                schedule = DeltaSchedule::new(time::Duration::from_minutes(5)),
-                args = (),
-            }
-        ],
-        task_routes = [
-            "*" => QUEUE_NAME,
-        ]
-    )
-}

bvplan/src/worker/update_info.rs

@@ -1,49 +1,28 @@
 use anyhow::{Context, Result};
+use askama::Template;
 use celery::error::TaskError;
 use celery::task::TaskResult;
 use chrono::prelude::*;
 use diesel::prelude::*;
+use fancy_regex::Regex;
 use lazy_static::lazy_static;
-use regex::Regex;
+use r2d2_redis::redis;
+use std::fs;
+use std::io::Write;
+use std::path::Path;
 use std::thread;
 use std::time::Duration;
 
-use crate::{config, db};
+use crate::cache;
+use crate::config;
+use crate::db;
+use crate::templates;
 
-async fn fetch_schoolyears(client: &untis::Client, db_conn: &mut PgConnection) -> Result<i32> {
+async fn get_schoolyear(client: &untis::Client, db_conn: &mut db::Connection) -> Result<i32> {
-    let existing_schoolyears = db::schema::schoolyears::table
+    Ok(db::schema::schoolyears::table
-        .select(db::schema::schoolyears::untis_id)
-        .load::<i32>(db_conn)?;
-    diesel::insert_into(db::schema::schoolyears::table)
-        .values(
-            &client
-                .schoolyears()
-                .await?
-                .iter()
-                .filter(|y| !existing_schoolyears.contains(&y.id))
-                .map(|y| db::models::NewSchoolyear {
-                    untis_id: y.id,
-                    name: &y.name,
-                    active: false,
-                })
-                .collect::<Vec<db::models::NewSchoolyear>>(),
-        )
-        .execute(db_conn)?;
-
-    let id = db::schema::schoolyears::table
         .filter(db::schema::schoolyears::untis_id.eq(client.current_schoolyear().await?.id))
         .select(db::schema::schoolyears::id)
-        .first(db_conn)?;
+        .first(db_conn)?)
-
-    diesel::update(db::schema::schoolyears::table)
-        .set(db::schema::schoolyears::active.eq(false))
-        .execute(db_conn)?;
-    diesel::update(db::schema::schoolyears::table)
-        .filter(db::schema::schoolyears::id.eq(id))
-        .set(db::schema::schoolyears::active.eq(true))
-        .execute(db_conn)?;
-
-    Ok(id)
 }
 
 async fn fetch_current_tenant(
@@ -95,6 +74,50 @@ async fn fetch_current_tenant(
     Ok(())
 }
 
+async fn fetch_timegrid(
+    client: &untis::Client,
+    db_conn: &mut PgConnection,
+    schoolyear_id: i32,
+) -> Result<()> {
+    let days = client.timegrid().await?;
+
+    diesel::update(db::schema::timegrids::table)
+        .filter(db::schema::timegrids::active)
+        .set(db::schema::timegrids::active.eq(false))
+        .execute(db_conn)?;
+    let timegrid_id = diesel::insert_into(db::schema::timegrids::table)
+        .values(db::models::NewTimegrid {
+            schoolyear_id,
+            active: true,
+        })
+        .returning(db::schema::timegrids::id)
+        .get_result::<i32>(db_conn)?;
+
+    for day in days {
+        let timegrid_day_id = diesel::insert_into(db::schema::timegrid_days::table)
+            .values(db::models::NewTimegridDay {
+                timegrid_id,
+                weekday: day.day.try_into()?,
+            })
+            .returning(db::schema::timegrid_days::id)
+            .get_result::<i32>(db_conn)?;
+        diesel::insert_into(db::schema::timegrid_time_unit::table)
+            .values(
+                day.time_units
+                    .into_iter()
+                    .map(|x| db::models::NewTimegridTimeUnit {
+                        timegrid_day_id,
+                        start_time: x.start_time,
+                        end_time: x.end_time,
+                    })
+                    .collect::<Vec<_>>(),
+            )
+            .execute(db_conn)?;
+    }
+
+    Ok(())
+}
+
 async fn fetch_teachers(
     client: &untis::Client,
     db_conn: &mut PgConnection,
@@ -281,11 +304,10 @@ async fn fetch_substitutions(
     client: &untis::Client,
     db_conn: &mut PgConnection,
     schoolyear_id: i32,
-) -> Result<()> {
+) -> Result<i32> {
     lazy_static! {
         static ref TITLE_SELECTOR: scraper::Selector =
             scraper::Selector::parse(".mon_title").unwrap();
-        static ref DATE_REGEX: Regex = Regex::new(r"([^\s]+)").unwrap();
         static ref WEEK_TYPE_REGEX: Regex = Regex::new(r"\bWoche\s+\K\S+").unwrap();
     }
 
@@ -313,35 +335,23 @@ async fn fetch_substitutions(
             .text()
             .next()
             .context("\"mon_title\" element is empty")?;
-        dbg!(title);
-        dbg!(DATE_REGEX.captures(title));
-        dbg!(WEEK_TYPE_REGEX.captures(title));
 
         (
-            chrono::NaiveDate::parse_from_str("18.1.2023", "%d.%m.%Y")?,
+            NaiveDate::parse_from_str(
-            db::models::WeekType::A,
+                title
+                    .split_once(' ')
+                    .context("Could not split title string by whitespace")?
+                    .0,
+                "%d.%m.%Y",
+            )?,
+            WEEK_TYPE_REGEX
+                .captures(title)?
+                .context("No week type could be found")?
+                .get(0)
+                .context("No week type could be found")?
+                .as_str()
+                .parse::<db::models::WeekType>()?,
         )
-
-        // (
-        //     chrono::NaiveDate::parse_from_str(
-        //         title
-        //             .0
-        //             .split_whitespace()
-        //             .next()
-        //             .context("Could not find date")?,
-        //         "%d.%m.%Y",
-        //     )?,
-        //     match title
-        //         .1
-        //         .split_whitespace()
-        //         .last()
-        //         .context("Could not find week type indicator")?
-        //     {
-        //         "A" => db::models::WeekType::A,
-        //         "B" => db::models::WeekType::B,
-        //         x => bail!("Invalid week type: {:?}", x),
-        //     },
-        // )
     };
 
     let substitution_query_id = diesel::insert_into(db::schema::substitution_queries::table)
@@ -381,6 +391,16 @@ async fn fetch_substitutions(
                                 .filter(db::schema::classes::untis_id.eq(c.id))
                                 .select(db::schema::classes::id)
                                 .get_result::<i32>(db_conn)?,
+                            original_id: if let Some(original_id) = c.original_id {
+                                Some(
+                                    db::schema::classes::table
+                                        .filter(db::schema::classes::untis_id.eq(original_id))
+                                        .select(db::schema::classes::id)
+                                        .get_result::<i32>(db_conn)?,
+                                )
+                            } else {
+                                None
+                            },
                         })
                     })
                     .collect::<Result<Vec<db::models::NewSubstitutionClass>>>()?,
@@ -407,6 +427,16 @@ async fn fetch_substitutions(
                                         .get_result::<i32>(db_conn)?,
                                 )
                             },
+                            original_id: if let Some(original_id) = t.original_id {
+                                Some(
+                                    db::schema::teachers::table
+                                        .filter(db::schema::teachers::untis_id.eq(original_id))
+                                        .select(db::schema::teachers::id)
+                                        .get_result::<i32>(db_conn)?,
+                                )
+                            } else {
+                                None
+                            },
                         })
                     })
                     .collect::<Result<Vec<db::models::NewSubstitutionTeacher>>>()?,
@@ -427,6 +457,16 @@ async fn fetch_substitutions(
                                 .filter(db::schema::subjects::untis_id.eq(s.id))
                                 .select(db::schema::subjects::id)
                                 .get_result::<i32>(db_conn)?,
+                            original_id: if let Some(original_id) = s.original_id {
+                                Some(
+                                    db::schema::subjects::table
+                                        .filter(db::schema::subjects::untis_id.eq(original_id))
+                                        .select(db::schema::subjects::id)
+                                        .get_result::<i32>(db_conn)?,
+                                )
+                            } else {
+                                None
+                            },
                         })
                     })
                     .collect::<Result<Vec<db::models::NewSubstitutionSubject>>>()?,
@@ -453,7 +493,7 @@ async fn fetch_substitutions(
                                         .get_result::<i32>(db_conn)?,
                                 )
                             },
-                            original_room_id: if let Some(original_id) = r.original_id {
+                            original_id: if let Some(original_id) = r.original_id {
                                 Some(
                                     db::schema::rooms::table
                                         .filter(db::schema::rooms::untis_id.eq(original_id))
@@ -470,6 +510,209 @@ async fn fetch_substitutions(
             .execute(db_conn)?;
     }
 
+    Ok(substitution_query_id)
+}
+
+type StartEndTime = (NaiveTime, NaiveTime);
+
+fn get_period(times: &Vec<StartEndTime>, start: bool, time: NaiveTime) -> Option<usize> {
+    times
+        .iter()
+        .position(|x| (if start { x.0 } else { x.1 }) == time)
+        .map(|x| x + 1)
+}
+
+fn cache_substitutions(
+    db_conn: &mut PgConnection,
+    redis_conn: &mut cache::Connection,
+    substitution_query_id: i32,
+    last_import_time: NaiveDateTime,
+) -> Result<()> {
+    let (queried_at, date, week_type) = db::schema::substitution_queries::table
+        .select((
+            db::schema::substitution_queries::queried_at,
+            db::schema::substitution_queries::date,
+            db::schema::substitution_queries::week_type,
+        ))
+        .filter(db::schema::substitution_queries::id.eq(substitution_query_id))
+        .first::<(NaiveDateTime, NaiveDate, db::models::WeekType)>(db_conn)?;
+    let weekday: db::models::Weekday = date.weekday().into();
+
+    let timegrid_id = db::schema::timegrids::table
+        .select(db::schema::timegrids::id)
+        .filter(db::schema::timegrids::active)
+        .first::<i32>(db_conn)?;
+    let day_id: i32 = db::schema::timegrid_days::table
+        .select((
+            db::schema::timegrid_days::id,
+            db::schema::timegrid_days::weekday,
+        ))
+        .filter(db::schema::timegrid_days::timegrid_id.eq(timegrid_id))
+        .load::<(i32, db::models::Weekday)>(db_conn)?
+        .into_iter()
+        .find(|x| x.1 == weekday)
+        .context("Could not find timegrid day")?
+        .0;
+    let times: Vec<StartEndTime> = db::schema::timegrid_time_unit::table
+        .select((
+            db::schema::timegrid_time_unit::start_time,
+            db::schema::timegrid_time_unit::end_time,
+        ))
+        .filter(db::schema::timegrid_time_unit::timegrid_day_id.eq(day_id))
+        .order(db::schema::timegrid_time_unit::start_time.asc())
+        .load::<StartEndTime>(db_conn)?;
+
+    let query = cache::keys::substitutions::SubstitutionQuery {
+        date,
+        week_type,
+        queried_at,
+        last_import_time,
+        schoolyear: "schoolyear".to_string(),
+        tenant: "OHG Furtwangen".to_string(),
+        substitutions: db::schema::substitutions::table
+            .filter(db::schema::substitutions::substitution_query_id.eq(substitution_query_id))
+            .load::<db::models::Substitution>(db_conn)
+            .unwrap()
+            .into_iter()
+            .map(|s| {
+                if let Some(subst_subject) = db::schema::substitution_subjects::table
+                    .filter(db::schema::substitution_subjects::substitution_id.eq(s.id))
+                    .order(db::schema::substitution_subjects::position.asc())
+                    .first::<db::models::SubstitutionSubject>(db_conn)
+                    .optional()?
+                {
+                    let subst_class_ids = db::schema::substitution_classes::table
+                        .select(db::schema::substitution_classes::class_id)
+                        .filter(db::schema::substitution_classes::substitution_id.eq(s.id))
+                        .order(db::schema::substitution_classes::position.asc())
+                        .load::<i32>(db_conn)?;
+                    let classes = db::schema::classes::table
+                        .select(db::schema::classes::name)
+                        .filter(db::schema::classes::id.eq_any(subst_class_ids))
+                        .load::<String>(db_conn)?;
+
+                    let subst_teachers = db::schema::substitution_teachers::table
+                        .filter(db::schema::substitution_teachers::substitution_id.eq(s.id))
+                        .order(db::schema::substitution_teachers::position.asc())
+                        .load::<db::models::SubstitutionTeacher>(db_conn)?;
+
+                    let (prev_room, room) = if let Some(r) = db::schema::substitution_rooms::table
+                        .filter(db::schema::substitution_rooms::substitution_id.eq(s.id))
+                        .order(db::schema::substitution_rooms::position.asc())
+                        .first::<db::models::SubstitutionRoom>(db_conn)
+                        .optional()?
+                    {
+                        let name = if let Some(id) = r.room_id {
+                            Some(
+                                db::schema::rooms::table
+                                    .select(db::schema::rooms::name)
+                                    .filter(db::schema::rooms::id.eq(id))
+                                    .first::<String>(db_conn)?,
+                            )
+                        } else {
+                            None
+                        };
+
+                        match s.subst_type {
+                            db::models::SubstitutionType::Cancel => (name, None),
+                            _ => (
+                                if let Some(id) = r.original_id {
+                                    Some(
+                                        db::schema::rooms::table
+                                            .select(db::schema::rooms::name)
+                                            .filter(db::schema::rooms::id.eq(id))
+                                            .first::<String>(db_conn)?,
+                                    )
+                                } else {
+                                    None
+                                },
+                                name,
+                            ),
+                        }
+                    } else {
+                        (None, None)
+                    };
+
+                    let prev_subject = db::schema::subjects::table
+                        .select(db::schema::subjects::name)
+                        .filter(db::schema::subjects::id.eq(subst_subject.subject_id))
+                        .first::<String>(db_conn)?;
+
+                    let start_period = get_period(&times, true, s.start_time)
+                        .context("Could not find period from start time")?;
+
+                    Ok(Some(cache::keys::substitutions::Substitution {
+                        time: (start_period, None),
+                        classes,
+                        prev_subject: prev_subject.to_owned(),
+                        subject: match s.subst_type {
+                            db::models::SubstitutionType::Cancel => None,
+                            _ => match subst_subject.original_id {
+                                Some(id) => Some(
+                                    db::schema::subjects::table
+                                        .select(db::schema::subjects::name)
+                                        .filter(db::schema::subjects::id.eq(id))
+                                        .first::<String>(db_conn)?,
+                                ),
+                                None => Some(prev_subject),
+                            },
+                        },
+                        teachers: match s.subst_type {
+                            db::models::SubstitutionType::Cancel => vec![],
+                            _ => db::schema::teachers::table
+                                .select(db::schema::teachers::display_name)
+                                .filter(
+                                    db::schema::teachers::id.eq_any(
+                                        subst_teachers
+                                            .iter()
+                                            .filter_map(|t| t.teacher_id)
+                                            .collect::<Vec<i32>>(),
+                                    ),
+                                )
+                                .load::<String>(db_conn)?,
+                        },
+                        prev_room,
+                        room,
+                        text: s.text,
+                    }))
+                } else {
+                    Ok(None)
+                }
+            })
+            .collect::<Result<Vec<_>>>()
+            .unwrap()
+            .into_iter()
+            .filter_map(|s| s)
+            .collect::<Vec<_>>(),
+    };
+
+    fs::write(
+        Path::new("/backups").join(format!(
+            "{}_{}_{}.json.gz",
+            date, queried_at, substitution_query_id
+        )),
+        {
+            let mut e = flate2::write::ZlibEncoder::new(vec![], flate2::Compression::best());
+            e.write_all(serde_json::to_string(&query)?.as_bytes())?;
+            e.finish()?
+        },
+    )?;
+
+    redis::cmd("SET")
+        .arg(cache::keys::SUBSTITUTIONS_HTML)
+        .arg(minify_html::minify(
+            templates::BVplan { data: query }.render()?.as_bytes(),
+            &minify_html::Cfg {
+                do_not_minify_doctype: false,
+                ensure_spec_compliant_unquoted_attribute_values: false,
+                keep_spaces_between_attributes: false,
+                minify_css: true,
+                minify_js: true,
+                ..Default::default()
+            },
+        ))
+        .query::<()>(redis_conn)?;
+
     Ok(())
 }
 
@@ -480,64 +723,80 @@ pub async fn update_info() -> TaskResult<()> {
     thread::sleep(dur);
     let mut client = match config::untis_from_env() {
         Ok(x) => x,
-        Err(e) => return Err(TaskError::UnexpectedError(e.to_string())),
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
     };
     if let Err(e) = client.login().await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
     thread::sleep(dur);
 
     let db_conn = &mut match db::POOL.get() {
         Ok(x) => x,
-        Err(e) => return Err(TaskError::UnexpectedError(e.to_string())),
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
     };
-    // let redis_conn = &mut match cache::POOL.get() {
+    let redis_conn = &mut match cache::POOL.get() {
-    //     Ok(x) => x,
-    //     Err(e) => return Err(TaskError::UnexpectedError(e.to_string())),
-    // };
-
-    let schoolyear_id = match fetch_schoolyears(&client, db_conn).await {
         Ok(x) => x,
-        Err(e) => return Err(TaskError::UnexpectedError(e.to_string())),
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
+    };
+
+    let schoolyear_id = match get_schoolyear(&client, db_conn).await {
+        Ok(x) => x,
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
     };
     thread::sleep(dur);
     if let Err(e) = fetch_current_tenant(&client, db_conn, schoolyear_id).await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
+    }
+    thread::sleep(dur);
+    if let Err(e) = fetch_timegrid(&client, db_conn, schoolyear_id).await {
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
     thread::sleep(dur);
     if let Err(e) = fetch_teachers(&client, db_conn, schoolyear_id).await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
     thread::sleep(dur);
     if let Err(e) = fetch_classes(&client, db_conn, schoolyear_id).await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
     thread::sleep(dur);
     if let Err(e) = fetch_subjects(&client, db_conn, schoolyear_id).await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
     thread::sleep(dur);
     if let Err(e) = fetch_rooms(&client, db_conn, schoolyear_id).await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
     thread::sleep(dur);
     if let Err(e) = fetch_departments(&client, db_conn, schoolyear_id).await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
     thread::sleep(dur);
     if let Err(e) = fetch_holidays(&client, db_conn, schoolyear_id).await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
     thread::sleep(dur);
-    if let Err(e) = fetch_substitutions(&client, db_conn, schoolyear_id).await {
+    let last_import_time = match client.last_import_time().await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        Ok(x) => x,
-    }
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
+    };
+    thread::sleep(dur);
+    let substitution_query_id = match fetch_substitutions(&client, db_conn, schoolyear_id).await {
+        Ok(x) => x,
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
+    };
     thread::sleep(dur);
 
     if let Err(e) = client.logout().await {
-        return Err(TaskError::UnexpectedError(e.to_string()));
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
+    }
+    // thread::sleep(dur);
+
+    if let Err(e) =
+        cache_substitutions(db_conn, redis_conn, substitution_query_id, last_import_time)
+    {
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
     }
-    thread::sleep(dur);
 
     Ok(())
 }

bvplan/src/worker/update_meta.rs

@@ -0,0 +1,71 @@
+use anyhow::Result;
+use celery::{error::TaskError, task::TaskResult};
+use diesel::prelude::*;
+use std::thread;
+use std::time::Duration;
+
+use crate::config;
+use crate::db;
+
+async fn fetch_schoolyears(client: &untis::Client, db_conn: &mut db::Connection) -> Result<i32> {
+    let existing_schoolyears = db::schema::schoolyears::table
+        .select(db::schema::schoolyears::untis_id)
+        .load::<i32>(db_conn)?;
+    diesel::insert_into(db::schema::schoolyears::table)
+        .values(
+            &client
+                .schoolyears()
+                .await?
+                .iter()
+                .filter(|y| !existing_schoolyears.contains(&y.id))
+                .map(|y| db::models::NewSchoolyear {
+                    untis_id: y.id,
+                    name: &y.name,
+                    active: false,
+                })
+                .collect::<Vec<db::models::NewSchoolyear>>(),
+        )
+        .execute(db_conn)?;
+
+    let id = db::schema::schoolyears::table
+        .filter(db::schema::schoolyears::untis_id.eq(client.current_schoolyear().await?.id))
+        .select(db::schema::schoolyears::id)
+        .first(db_conn)?;
+
+    diesel::update(db::schema::schoolyears::table)
+        .set(db::schema::schoolyears::active.eq(false))
+        .execute(db_conn)?;
+    diesel::update(db::schema::schoolyears::table)
+        .filter(db::schema::schoolyears::id.eq(id))
+        .set(db::schema::schoolyears::active.eq(true))
+        .execute(db_conn)?;
+
+    Ok(id)
+}
+
+#[celery::task]
+pub async fn update_meta() -> TaskResult<()> {
+    let dur = Duration::from_secs(2);
+    let mut client = match config::untis_from_env() {
+        Ok(x) => x,
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
+    };
+    let db_conn = &mut match db::POOL.get() {
+        Ok(x) => x,
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
+    };
+    thread::sleep(dur);
+
+    let schoolyear_id = match fetch_schoolyears(&client, db_conn).await {
+        Ok(x) => x,
+        Err(e) => return Err(TaskError::UnexpectedError(format!("{:?}", e))),
+    };
+    dbg!(&schoolyear_id);
+    thread::sleep(dur);
+
+    if let Err(e) = client.logout().await {
+        return Err(TaskError::UnexpectedError(format!("{:?}", e)));
+    }
+
+    Ok(())
+}

bvplan/templates/bvplan.html

@@ -0,0 +1,287 @@
+<!DOCTYPE html>
+<html lang="de-DE">
+    <head>
+        <meta charset="UTF-8" />
+        <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>BVplan | dergrimm.net</title>
+
+        <meta name="generator" content="BVplan" />
+
+        <script id="data" type="application/json">{{ data.substitutions.len()|json|safe }}</script>
+
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.3/jquery.min.js"
+            integrity="sha512-STof4xm1wgkfm7heWqFJVn58Hm3EtS31XFaagaa8VMReCXAkQnJZ+jEy8PCC/iT18dFy95WcExNHFTqLyp72eQ=="
+            crossorigin="anonymous"
+            referrerpolicy="no-referrer"
+        ></script>
+
+        <style>
+            html, body {
+                height: 100%;
+                margin: 0;
+            }
+
+            body {
+                min-height: 100%;
+                margin: 0 5vw;
+                overflow: hidden;
+                display: flex;
+                flex-direction: column;
+                font-family: Arial, Helvetica, sans-serif;
+            }
+
+            #info {
+                margin-top: 1vh;
+                display: flex;
+                justify-content: space-between;
+            }
+
+            #info > .column {
+                margin-top: auto;
+            }
+
+            #title-wrapper {
+                color: #ee7f00;
+            }
+
+            #title-wrapper > * {
+                margin: 0;
+            }
+
+            #title {
+                font-weight: bold;
+            }
+
+            #tenant-info {
+                text-align: right;
+            }
+
+            #plan {
+                width: 100%;
+                margin-top: 1%;
+                border-collapse: collapse;
+                text-align: center;
+            }
+
+            #plan thead,
+            #plan tbody {
+                font-size: 0.9em;
+            }
+
+            #plan > caption {
+                font-weight: bold;
+            }
+
+            #plan th,
+            #plan td {
+                border: thin solid black;
+            }
+
+            #plan thead {
+                background-color: black;
+                color: white;
+            }
+
+            #plan th {
+                padding: 0.5rem 0.25rem;
+            }
+
+            #plan td {
+                padding: 0.25rem;
+            }
+
+            #plan tbody {
+                overflow: auto;
+            }
+
+            #plan tbody tr:not(:nth-child(even)) {
+                background-color: #fad3a6;
+            }
+
+            #plan tbody tr:nth-child(even) {
+                background-color: #fdecd9;
+            }
+
+            #footer {
+                margin: auto 0 1vh;
+                text-align: center;
+            }
+
+            #footer p {
+                margin: 0.25rem;
+            }
+
+            #footer > hr {
+                border: thin solid black;
+                margin: 1rem 0;
+            }
+
+            #footer .message,
+            #footer .powered-by {
+                margin: 0.5rem 0;
+            }
+        </style>
+    </head>
+    <body>
+        <header id="info">
+            <div id="title-wrapper" class="column">
+                <h1 id="title">BVplan</h1>
+                <span id="subtitle">dergrimm.net</span>
+            </div>
+            <div id="tenant-info" class="column">
+                <span>{{ data.tenant }}, {{ data.schoolyear }}</span>
+                <br />
+                <span>Stand: {{ data.queried_at }}</span>
+                <br />
+                <span>Untis: {{ data.last_import_time }}</span>
+            </div>
+        </header>
+
+        <main>
+            <table id="plan">
+                <caption>
+                    {{ data.date }}, Woche {{ data.week_type }}
+                </caption>
+
+                <colgroup>
+                    <col />
+                    <col />
+                    <col />
+                    <col style="width: 30%" />
+                    <col />
+                    <col />
+                    <col />
+                    <col style="width: 20%" />
+                </colgroup>
+
+                <thead>
+                    <tr>
+                        <th>Stunde</th>
+                        <th>Klasse(n)</th>
+                        <th>(Fach)</th>
+                        <th>Fach</th>
+                        <th>Vertreter</th>
+                        <th>(Raum)</th>
+                        <th>Raum</th>
+                        <th>Text</th>
+                    </tr>
+                </thead>
+
+                <tbody>
+                {% for subst in data.substitutions %}
+                    <tr>
+                        <td>
+                            {% match subst.time.1 %}
+                                {% when Some with (x) %}
+                                    {{ subst.time.0 }} - {{ x }}
+                                {% when None %}
+                                    {{ subst.time.0 }}
+                            {% endmatch %}
+                        </td>
+                        <td>{{ subst.classes|join(", ") }}</td>
+                        <td>{{ subst.prev_subject }}</td>
+                        <td>
+                            {% match subst.subject %}
+                                {% when Some with (x) %}
+                                    {{ x }}
+                                {% when None %}
+                                    ---
+                            {% endmatch %}
+                        </td>
+                        <td>{{ subst.teachers|join(", ") }}</td>
+                        <td>
+                            {% match subst.prev_room %}
+                                {% when Some with (x) %}
+                                    {{ x }}
+                                {% when None %}
+                                    ---
+                            {% endmatch %}
+                        </td>
+                        <td>
+                            {% match subst.room %}
+                                {% when Some with (x) %}
+                                    {{ x }}
+                                {% when None %}
+                                    ---
+                            {% endmatch %}
+                        </td>
+                        <td>
+                            {% match subst.text %}
+                                {% when Some with (x) %}
+                                    {{ x }}
+                                {% when None %}
+                            {% endmatch %}
+                        </td>
+                    </tr>
+                {% endfor %}
+                </tbody>
+            </table>
+        </main>
+
+        <footer id="footer">
+            <div class="message">
+                <p>
+                    BVplan - der bessre Vertretungsplan sogar mit UTF-8 Support!
+                    Wow
+                </p>
+                <p>
+                    <a href="https://git.dergrimm.net/bvplan">
+                        https://git.dergrimm.net/bvplan
+                    </a>
+                </p>
+            </div>
+            <hr />
+            <p class="powered-by">
+                <code>
+                    Powered by Dominic Grimm &lt;<a
+                        href="mailto:dominic@dergrimm.net"
+                        >dominic@dergrimm.net</a
+                    >&gt;
+                </code>
+            </p>
+        </footer>
+
+        <script>
+            window.onerror = function () {
+                console.log("js error detected");
+                setTimeout(function () {
+                    console.log("reloading page because of error");
+                    window.location.reload();
+                }, 30_000);
+            };
+
+            const elementCount = JSON.parse($("#data").text());
+            const waitDelay = 10_000;
+            const scrollDuration = elementCount * 200;
+
+            function scrollUp() {
+                $("html, body").animate(
+                    {
+                        scrollTop: 0,
+                    },
+                    scrollDuration,
+                    "linear"
+                );
+                setTimeout(function () {
+                    window.location.reload();
+                }, scrollDuration);
+            }
+
+            function scrollDown() {
+                $("html, body").animate(
+                    {
+                        scrollTop: $(document).height() - $(window).height(),
+                    },
+                    scrollDuration,
+                    "linear"
+                );
+                setTimeout(scrollUp, scrollDuration + waitDelay);
+            }
+
+            window.scrollTo(0, 0);
+            setTimeout(scrollDown, waitDelay);
+        </script>
+    </body>
+</html>

config/nginx/nginx.conf

@@ -15,8 +15,8 @@ http {
   server {
     listen 80;
 
-    location /graphql {
+    location / {
-      proxy_pass http://api:80/graphql;
+      proxy_pass http://web;
       proxy_buffering off;
       proxy_set_header Host $http_host;
       proxy_set_header X-Real-IP $remote_addr;
@@ -36,5 +36,33 @@ http {
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
     }
+
+    location /redis {
+      proxy_pass http://redis-commander:8081;
+      proxy_buffering off;
+      proxy_set_header Host $http_host;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location ~* /rabbitmq/api/(.*?)/(.*) {
+      proxy_pass http://rabbitmq:15672/api/$1/%2F/$2?$query_string;
+      proxy_buffering off;
+      proxy_set_header Host $http_host;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location ~* /rabbitmq/(.*) {
+      rewrite ^/rabbitmq/(.*)$ /$1 break;
+      proxy_pass http://rabbitmq:15672;
+      proxy_buffering off;
+      proxy_set_header Host $http_host;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header X-Forwarded-Proto $scheme;
+    }
   }
 }

docker-compose.yml

@@ -1,18 +1,18 @@
 version: "3"
 
-x-backend:
+x-bvplan:
-  &backend
+  &bvplan
   image: git.dergrimm.net/dergrimm/bvplan_backend:latest
   build:
-    context: ./backend
+    context: ./bvplan
   restart: always
   command: worker
   depends_on:
-    - postgres
+    - db
     - rabbitmq
     - redis
   environment:
-    BACKEND_DB_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_USER}
+    BACKEND_DB_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_USER}
     BACKEND_AMQP_URL: amqp://${RABBITMQ_USER}:${RABBITMQ_PASSWORD}@rabbitmq:5672
     BACKEND_REDIS_URL: redis://redis:6379
     BACKEND_UNTIS_API_URL: ${BACKEND_UNTIS_API_URL}
@@ -33,28 +33,30 @@ services:
       - ./config/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
     ports:
       - 80:80
+      - 8080:8080
     depends_on:
       - adminer
       - rabbitmq
-      - api
+      - web
+      - redis-commander
 
-  postgres:
+  db:
-    image: docker.io/postgres:alpine
+    image: docker.io/postgres:15-alpine
     restart: always
     environment:
       POSTGRES_USER: ${POSTGRES_USER}
       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
     volumes:
-      - postgres:/var/lib/postgresql/data
+      - db:/var/lib/postgresql/data
 
   adminer:
     image: docker.io/adminer:standalone
     restart: always
     depends_on:
-      - postgres
+      - db
 
   rabbitmq:
-    image: docker.io/rabbitmq:3-alpine
+    image: docker.io/rabbitmq:3-management-alpine
     restart: always
     environment:
       RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER}
@@ -68,20 +70,32 @@ services:
     volumes:
       - redis:/data
 
-  worker:
+  redis-commander:
-    <<: *backend
+    image: rediscommander/redis-commander:latest
-    command: worker
+    restart: always
-
+    environment:
-  api:
+      REDIS_HOSTS: local:redis:6379
-    <<: *backend
+      URL_PREFIX: /redis
-    command: api
     depends_on:
-      - postgres
+      - redis
+
+  worker:
+    <<: *bvplan
+    command: worker
+    volumes:
+      - ./data/backups:/backups
+
+  web:
+    <<: *bvplan
+    command: web
+    depends_on:
+      - db
       - rabbitmq
       - worker
+      - redis
 
 volumes:
-  postgres:
+  db:
   rabbitmq:
   redis: