Merge pull request 'Add AGPLv3 License' (#35) from add_license into master

Reviewed-on: GibCasa/GameServerSupervisor#35

.gitignore

@@ -1,2 +1,3 @@
 __pycache__
-db.sqlite3
+db.sqlite3
+.env

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.10-alpine
+
+ARG supervisor_dir="/usr/src/GameServerSupervisor"
+
+RUN mkdir -p $supervisor_dir
+
+WORKDIR $supervisor_dir
+
+COPY . $supervisor_dir
+
+RUN pip install --upgrade pip 
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 80

GameServerSupervisor/settings.py

@@ -118,7 +118,10 @@ USE_TZ = True
 
 STATIC_URL = "static/"
 
+MEDIA_URL = '/media/'
+MEDIA_ROOT = BASE_DIR / 'media'
+
 # Default primary key field type
 # https://docs.djangoproject.com/en/5.1/ref/settings/#default-auto-field
 
-DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"

LICENSE

@@ -0,0 +1,662 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 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 Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are 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.
+
+  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.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  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 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 work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero 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 Affero 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 Affero 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 Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero 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 Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero 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 your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  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 AGPL, see
+<https://www.gnu.org/licenses/>.
+

README.md

@@ -1,10 +1,23 @@
 # GibCasa GameServerSupervisor
 
-## Prerequisites
+## Table of Contents
+- [Installation using venv](#installation-using-venv)
+  - [Prerequisites](#prerequisites)
+  - [Installation](#installation)
+- [Installation using Podman](#installation-using-podman)
+  - [Prerequisites](#prerequisites-1)
+  - [Installation](#installation-1)
+- [Usage](#usage)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation using venv
+
+### Prerequisites
 
 Python 3.10 or above
 
-## Installation 
+### Installation
 
 1. Clone the repository:
 ```bash
@@ -22,19 +35,80 @@ Python 3.10 or above
 ```bash
   pip install -r requirements.txt
 ```
+5. Run tests:
+```bash
+  ./manage.py test
+```
+6. Run migrations:
+```bash
+  ./manage.py migrate
+```
+7. Create admin user:
+```bash
+  ./manage.py createsuperuser
+```
+8. Run server:
+```bash
+  ./manage.py runserver
+```
+## Installation using Podman
+
+### Prerequisites
+
+Podman
+
+### Installation
+
+1. Clone the repository:
+```bash
+  git clone https://git.com.de/GibCasa/GameServerSupervisor
+```
+2. Build the image:
+```bash
+  podman build . -t supervisor-image
+```
+3. Run a container in an interactive shell:
+```bash
+  podman run -it --network=host localhost/supervisor-image sh
+```
+4. Run tests:
+```bash
+  ./manage.py test
+```
 5. Run migrations:
 ```bash
-  python manage.py migrate
+  ./manage.py migrate
 ```
 6. Create admin user:
 ```bash
-  python manage.py createsuperuser
+  ./manage.py createsuperuser
 ```
 7. Run server:
 ```bash
-  python manage.py runserver
+  ./manage.py runserver
 ```
-* visit http://localhost:8000 for /public and 
+-------------
-  http://localhost:8000/admin/ to login via the superuser credentials
+
-* will need docker running 
+To live sync host directory with container folder, in Step 3:
+```bash
+podman run --network=host -itv /host/src/path:/usr/src/GameServerSupervisor supervisor-image sh
+```
+`/host/src/path` is the absolute path to the repository in the host machine.
+
+## Usage
+
+* Visit http://localhost:8000 for /public and 
+  http://localhost:8000/admin/ to login via the superuser credentials
+
+## Contributing
+
+1. Fork the repository.
+2. Create a new branch: `git checkout -b feature-name`.
+3. Make your changes.
+4. Push your branch: `git push origin feature-name`.
+5. Create a pull request.
+
+## License
+
+This project is licensed under the [AGPL](https://www.gnu.org/licenses/agpl-3.0.html).
 

requirements.txt

@@ -3,6 +3,7 @@ certifi==2024.12.14
 charset-normalizer==3.4.1
 Django==5.1.5
 idna==3.10
+pillow==11.2.1
 podman==5.2.0
 requests==2.32.3
 sqlparse==0.5.3

webpanel/admin.py

@@ -1,7 +1,44 @@
-from django.contrib import admin
+from django.contrib import admin, messages
 from .models import Game, Server
-from .utils import launch_pod_container, stop_pod_container, remove_pod_container
+from django import forms
-import podman
+from .widgets import PortMappingWidget
+
+class ServerForm(forms.ModelForm):
+    class Meta:
+        model = Server
+        fields = "__all__"
+        widgets = {
+            "port": PortMappingWidget(),
+        }
+    def clean_port(self):
+        keys = self.data.getlist("port_key")
+        values = self.data.getlist("port_value")
+
+        try:
+            return {
+                k.strip(): int(v)
+                for k, v in zip(keys, values)
+                if k.strip() and v.strip()
+            }
+        except ValueError:
+            raise forms.ValidationError("Port values must be integers.")
+@admin.action(description="Launch selected servers")
+def launch_servers(modeladmin, request, queryset):
+    for server in queryset:
+        result = server.launch_pod_container()
+        messages.info(request, f"{server.name}: {result}")
+
+@admin.action(description="Stop selected servers")
+def stop_servers(modeladmin, request, queryset):
+    for server in queryset:
+        result = server.stop_pod_container()
+        messages.info(request, f"{server.name}: {result}")
+
+@admin.action(description="Remove selected servers")
+def remove_servers(modeladmin, request, queryset):
+    for server in queryset:
+        result = server.remove_pod_container()
+        messages.info(request, f"{server.name}: {result}")
 
 @admin.register(Game)
 class GameAdmin(admin.ModelAdmin):
@@ -9,47 +46,19 @@ class GameAdmin(admin.ModelAdmin):
     search_fields = ('name', 'genre')
     ordering = ('name',)
 
-@admin.action(description='Launch Container')
-def launch_container(modeladmin, request, queryset):
-    client = podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
-    for server in queryset:
-        container_name = f"{server.game.name}_{server.ip_address}_{server.port}"
-        try:
-            # Ensure the command is passed as a list of strings
-            command = server.get_podman_run_command().split() if server.run_command else []
-            container = client.containers.run(
-                server.image,
-                detach=True,
-                name=container_name,
-                command=command,
-                ports={f"{server.port}/tcp": server.port},
-                remove=True,  # Automatically remove on stop
-            )
-            server.sync_status()
-            modeladmin.message_user(request, f"Container launched: {container.id}")
-        except Exception as e:
-            modeladmin.message_user(request, f"Failed to launch {server}: {e}", level="error")
-
-@admin.action(description='Stop Container')
-def stop_container(modeladmin, request, queryset):
-    for server in queryset:
-        container_name = f"{server.game.name}_{server.ip_address}_{server.port}"
-        result = stop_pod_container(container_name)
-        server.sync_status()
-        modeladmin.message_user(request, f"Stop container result for {server}: {result}")
-
-@admin.action(description='Remove Container')
-def remove_container(modeladmin, request, queryset):
-    for server in queryset:
-        container_name = f"{server.game.name}_{server.ip_address}_{server.port}"
-        result = remove_pod_container(container_name)
-        server.sync_status()
-        modeladmin.message_user(request, f"Remove container result for {server}: {result}")
 
 @admin.register(Server)
 class ServerAdmin(admin.ModelAdmin):
-    list_display = ('game', 'name', 'ip_address', 'port', 'status', 'image', 'run_command', 'command_args')
+    form = ServerForm
+    list_display = (
+        'game', 'name', 'ip_address', 'get_ports_display', 'status', 'image', 'run_command', 'command_args'
+    )
     search_fields = ('game__name', 'ip_address', 'port')
+    list_filter = ('status', 'game')
+    ordering = ('game', 'ip_address')
+    actions = [stop_servers, remove_servers, launch_servers]
+
+    readonly_fields = ('get_ports_display',)
 
     def save_model(self, request, obj, form, change):
         super().save_model(request, obj, form, change)
@@ -61,7 +70,3 @@ class ServerAdmin(admin.ModelAdmin):
             server.sync_status()
         return queryset
 
-    list_filter = ('status', 'game')
-    search_fields = ('ip_address', 'game__name', 'image')
-    ordering = ('game', 'ip_address')
-    actions = [launch_container, stop_container, remove_container]

webpanel/migrations/0007_game_thumbnail.py

@@ -1,4 +1,4 @@
-# Generated by Django 5.1.5 on 2025-02-11 01:27
+# Generated by Django 5.1.5 on 2025-04-15 19:28
 
 from django.db import migrations, models
 

webpanel/migrations/0008_alter_game_thumbnail.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.1.5 on 2025-04-16 08:59
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0007_game_thumbnail"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="game",
+            name="thumbnail",
+            field=models.ImageField(
+                blank=True, null=True, upload_to="media/game_thumbnails/"
+            ),
+        ),
+    ]

webpanel/migrations/0009_server_container_id_server_last_log.py

@@ -0,0 +1,23 @@
+# Generated by Django 5.1.5 on 2025-04-16 14:13
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0008_alter_game_thumbnail"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="server",
+            name="container_id",
+            field=models.CharField(blank=True, max_length=64, null=True),
+        ),
+        migrations.AddField(
+            model_name="server",
+            name="last_log",
+            field=models.TextField(blank=True, null=True),
+        ),
+    ]

webpanel/migrations/0010_alter_game_thumbnail.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.1.5 on 2025-04-20 18:59
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0009_server_container_id_server_last_log"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="game",
+            name="thumbnail",
+            field=models.ImageField(
+                blank=True, null=True, upload_to="game_thumbnails/"
+            ),
+        ),
+    ]

webpanel/migrations/0011_alter_server_port.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-04-22 19:39
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0010_alter_game_thumbnail"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="server",
+            name="port",
+            field=models.JSONField(default=dict),
+        ),
+    ]

webpanel/migrations/0012_alter_server_port.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-04-22 19:42
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0011_alter_server_port"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="server",
+            name="port",
+            field=models.JSONField(blank=True, default=dict),
+        ),
+    ]

webpanel/migrations/0013_migrate_port_to_dict.py

@@ -0,0 +1,32 @@
+# Generated by Django 5.1.5 on 2025-04-22 19:57
+
+from django.db import migrations
+import json
+
+def migrate_port_to_dict(apps, schema_editor):
+    Server = apps.get_model("webpanel", "Server")
+    for gs in Server.objects.all():
+        port = gs.port
+        if isinstance(port, int):
+            gs.port = {"default": port}
+            gs.save()
+        elif isinstance(port, str):
+            try:
+                parsed = json.loads(port)
+                if isinstance(parsed, dict):
+                    gs.port = parsed
+                    gs.save()
+            except json.JSONDecodeError:
+                # Fallback: store as a default port string
+                gs.port = {"default": port}
+                gs.save()
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0012_alter_server_port"),
+    ]
+
+    operations = [
+        migrations.RunPython(migrate_port_to_dict),
+    ]

webpanel/migrations/0014_server_query_protocol.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-04-23 09:42
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0013_migrate_port_to_dict"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="server",
+            name="query_protocol",
+            field=models.CharField(max_length=20, null=True),
+        ),
+    ]

webpanel/migrations/0015_remove_server_query_protocol_game_query_protocol.py

@@ -0,0 +1,22 @@
+# Generated by Django 5.1.5 on 2025-04-23 10:01
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0014_server_query_protocol"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="server",
+            name="query_protocol",
+        ),
+        migrations.AddField(
+            model_name="game",
+            name="query_protocol",
+            field=models.CharField(max_length=20, null=True),
+        ),
+    ]

webpanel/migrations/0016_game_default_query_port_key.py

@@ -0,0 +1,23 @@
+# Generated by Django 5.1.5 on 2025-04-23 10:05
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("webpanel", "0015_remove_server_query_protocol_game_query_protocol"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="game",
+            name="default_query_port_key",
+            field=models.CharField(
+                blank=True,
+                help_text="Default key (e.g., '27015/udp' or '27910') used for status queries within the Server's port mappings.",
+                max_length=20,
+                null=True,
+            ),
+        ),
+    ]

webpanel/models.py

@@ -1,13 +1,22 @@
 from django.db import models
 import podman
+import shlex
+import re
+from typing import Optional,List
 
 class Game(models.Model):
     name = models.CharField(max_length=100)
     genre = models.CharField(max_length=50, blank=True, null=True)
     thumbnail = models.ImageField(upload_to='game_thumbnails/', null=True, blank=True)
+    query_protocol=models.CharField(max_length=20, null=True)
+    default_query_port_key = models.CharField(
+        max_length=20,
+        blank=True,
+        null=True,
+        help_text="Default key (e.g., '27015/udp' or '27910') used for status queries within the Server's port mappings."
+    )
 
-
+    def __str__(self) -> str:
-    def __str__(self):
         return self.name
 
 class Server(models.Model):
@@ -15,25 +24,36 @@ class Server(models.Model):
         ('online', 'Online'),
         ('offline', 'Offline'),
     ]
-
+    last_log = models.TextField(blank=True, null=True)
     game = models.ForeignKey(Game, on_delete=models.CASCADE)
     name = models.CharField(max_length=100)
     ip_address = models.GenericIPAddressField(null=True)
-    port = models.PositiveIntegerField(null=True)
+    port = models.JSONField(default=dict, blank=True)
     image = models.CharField(max_length=200, null=True)
     run_command = models.CharField(max_length=500, blank=True, null=True) 
     command_args = models.TextField(blank=True, null=True)
+    container_id = models.CharField(max_length=64, blank=True, null=True)
     status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='offline')
 
-    def __str__(self):
+    def __str__(self)-> str:
         return f"{self.game.name} Server at {self.ip_address}:{self.port}"
 
-    def sync_status(self):
+    @property
+    def safe_name(self) -> str:
+        """Return a container-safe version of the server name"""
+        return re.sub(r'[^a-zA-Z0-9_.-]', '_', self.name)
+
+    def _log_error(self, msg):
+        self.last_log = msg
+        self.save(update_fields=["status", "last_log"])
+    def _get_podman_client(self) -> podman.PodmanClient:
+        """Get a configured Podman client instance."""
+        return podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
+
+    def sync_status(self) -> None:
         """Check the real-time status of the container and update the field."""
-        client = podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
-        container_name = f"{self.game.name}_{self.ip_address}_{self.port}"
         try:
-            container = client.containers.get(container_name)
+            container = self._get_podman_client().containers.get(self.safe_name)
             if container.status == "running":
                 self.status = "online"
             else:
@@ -41,17 +61,76 @@ class Server(models.Model):
         except podman.errors.NotFound:
             self.status = "offline"
         except Exception as e:
-            self.status = "offline"  # Fallback in case of unexpected errors
+            self.status = "offline"
         self.save()
 
-    def get_podman_run_command(self):
+    def get_ports_display(self):
-        """Returns the Podman run command, falling back to default image if not set."""
+        return ", ".join(f"{k}→{v}" for k, v in self.port.items())
-        if self.run_command:
+    get_ports_display.short_description = "Ports"  # display name in admin
-            # Return command as a string to be split later
+
-            return self.run_command
+
-        else:
+    def launch_pod_container(self) -> str:
-            # Default command with image and arguments
+        try:
-            base_command = f"{self.image}"
+            port_bindings = {
-            if self.command_args:
+                container_port: ('0.0.0.0', host_port)
-                base_command += " " + self.command_args
+                for container_port, host_port in self.port.items()
-            return base_command
+            }
+
+            container = self._get_podman_client().containers.create(
+                name=self.safe_name,
+                image=self.image,
+                ports=port_bindings,
+                command=shlex.split(self.run_command),
+                detach=True,
+            )
+            container.start()
+            self.container_id = container.id
+            self.last_log = f"Launched container {container.id}"
+            self.sync_status()
+            self.save()
+            return f"Container launched successfully: {container.id}"
+        except podman.errors.APIError as e:
+            self.last_log = f"API Error: {str(e)}"
+            self.save()
+            return f"API Error: {e}"
+        except Exception as e:
+            self.last_log = f"Error: {str(e)}"
+            self.save()
+            return f"Error: {e}"
+
+    def stop_pod_container(self) -> str:
+        try:
+            container = self._get_podman_client().containers.get(self.safe_name)
+            container.stop()
+            self.status = "offline"
+            self.last_log = f"Stopped container {container.id}"
+            self.sync_status()
+            self.save()
+            return f"Container stopped successfully: {container.id}"
+        except podman.errors.NotFound:
+            self.last_log = f"Container '{self.safe_name}' not found"
+            self.save()
+            return f"Error: Container '{self.safe_name}' not found"
+        except Exception as e:
+            self.last_log = f"Error stopping container: {str(e)}"
+            self.save()
+            return f"Error: {e}"
+
+    def remove_pod_container(self) -> str:
+        try:
+            container = self._get_podman_client().containers.get(self.safe_name)
+            container.remove(force=True)
+            self.status = "offline"
+            self.container_id = None
+            self.last_log = f"Removed container {self.safe_name}"
+            self.sync_status()
+            self.save()
+            return f"Container removed successfully: {self.safe_name}"
+        except podman.errors.NotFound:
+            self.last_log = f"Container '{self.safe_name}' not found"
+            self.save()
+            return f"Error: Container '{self.safe_name}' not found"
+        except Exception as e:
+            self.last_log = f"Error removing container: {str(e)}"
+            self.save()
+            return f"Error: {e}"

webpanel/templates/webpanel/base.html

@@ -4,7 +4,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{% block title %}Game Server Supervisor{% endblock %}</title>
+    <title>{% block title %}GibCasa{% endblock %}</title>
     <style>
         * {
             margin: 0;
@@ -165,36 +165,39 @@
             font-size: 14px;
         }
 
-        .game-box img {
+        /* .game-box img {
             width: 100%;
             height: 100%;
             object-fit: cover;
             border-radius: 5px;
-        }
+        } */
     </style>
 </head>
 
 <body>
     <div class="navbar">
-        <div class="left">
+        <div class="center">
             <pre>
 ┬   ┌┬┐ ┬─┐ ┌─┐ ┬─┐ ┐─┐ ┬─┐
 │    │  │─│ │   │─┤ └─┐ │─┤
 ┘─┘ └┴┘ │─┘ └─┘ ┘ │ ──┘ ┘ │
-
             </pre>
+        </div>
+        <div class="navbar">
+            <div class="left">
             <a href="{% url 'home' %}">Home</a>
             <a href="{% url 'games' %}">Games</a>
-            <a href="#">Mods</a>
         </div>
-        <!-- <div class="right">
+        </div>
-            <div class="search-box">
+        </div class="navbar">
+        <!-- <div class="right">  -->
+            <!-- <div class="search-box">
                 <input type="text" placeholder="Search...">
-            </div>
+            </div> -->
-            <a href="#">Auth / Settings</a> -->
+            <!-- <a href="#">Auth / Settings</a> -->
-            <div class="profile">Dp</div>
+            <!-- <div class="profile">Dp</div> -->
-        </div>
+        <!-- </div> -->
-    </div>
+    </div> 
 
     <div class="content">
         {% block content %}{% endblock %}
@@ -202,10 +205,10 @@
 
     <footer>
         <a href="https://ozFrags.net">Other Communities</a>
-        <a href="#">Terms of Service</a>
+        <a href="https://liberta.casa/rules.html">Terms of Service WIP</a>
-        <a href="#">License: AGPL</a>
+        <a href="#">License: AGPLish</a>
-        <a href="#">Donate</a>
+        <a href="#">Contribute (WIP)</a> 
-        <a href="ircs://irc.casa/#gibcasa">Support</a>
+        <a href="https://liberta.casa/gamja/#gibcasa">Support</a>
     </footer>
 </body>
 

webpanel/templates/webpanel/game_detail.html

@@ -3,29 +3,195 @@
 {% block title %}{{ game.name }} - Game Details{% endblock %}
 
 {% block content %}
-    <h2>{{ game.name }}</h2>
+<h2>{{ game.name }}</h2>
 
-    <!-- <nav class="sub-nav">
+{# --- Add the CSS from previous example for .server-box etc. --- #}
-        <a href="{% url 'home' %}">Home</a>
+<style>
-        <a href="{% url 'games' %}">Games</a>
+    .server-box {
-        <a href="#">Mods</a>
+        border: 1px solid #555;
-        <div class="right-links">
+        padding: 15px;
-            <a href="#">Show All Active Servers</a>
+        margin-bottom: 15px;
-            <a href="#">Request A Server</a>
+        background-color: #2a2a2a;
-        </div>
+        border-radius: 4px;
-    </nav> -->
+    }
 
-    <div class="game-detail">
+    .server-box legend {
-        <div class="game-image">
+        font-weight: bold;
-            <img src="{{ game.image_url }}" alt="{{ game.name }}">
+        color: #0f0;
-        </div>
+        /* Lime green */
-        <div class="game-info">
+        padding: 0 5px;
-            <p>Pull data from some open API to populate information about the game and render it.</p>
+    }
-            <ul>
+
-                <li>🔹 <strong>Active:</strong> Non-full, non-empty servers with connection info, map, and player count</li>
+    .server-details p {
-                <li>🔹 <strong>All Active:</strong> List of all active servers</li>
+        margin: 6px 0;
-                <li>🔹 <strong>Stopped:</strong> Available upon request</li>
+        font-size: 0.95em;
-            </ul>
+    }
-        </div>
+
+    .live-stats {
+        margin-top: 10px;
+        padding-top: 10px;
+        border-top: 1px dashed #444;
+        color: #eee;
+    }
+
+    .live-stats strong {
+        color: #bbb;
+        width: 120px;
+        display: inline-block;
+    }
+
+    /* Align labels */
+    .player-list {
+        list-style: none;
+        padding-left: 15px;
+        font-size: 0.9em;
+        color: #ccc;
+        max-height: 150px;
+        overflow-y: auto;
+        margin-top: 5px;
+        border-left: 2px solid #444;
+        padding-left: 10px;
+    }
+
+    .player-list li {
+        margin-bottom: 3px;
+    }
+
+    .error-msg {
+        color: #ff8888;
+        font-style: italic;
+        font-size: 0.9em;
+    }
+
+    .game-thumbnail {
+        float: left;
+        margin-right: 20px;
+        margin-bottom: 20px;
+        width: 150px;
+        text-align: center;
+    }
+
+    .server-lists {
+        overflow: hidden;
+    }
+
+    .clear-float {
+        clear: both;
+    }
+
+    h3 {
+        margin-top: 25px;
+        color: #ccc;
+        border-bottom: 1px solid #555;
+        padding-bottom: 5px;
+    }
+
+    hr.section-divider {
+        margin: 30px 0;
+        border: 0;
+        border-top: 1px solid #444;
+    }
+</style>
+
+<div class="game-detail">
+    <div class="game-thumbnail">
+        {% if game.thumbnail %}
+        <img src="{{ game.thumbnail.url }}" alt="{{ game.name }}"
+            style="width: 100%; height: auto; border: 1px solid #444;">
+        {% else %}
+        <div
+            style="width: 150px; height: 200px; background-color: #333; display: flex; align-items: center; justify-content: center; color: #888; border: 1px solid #444;">
+            No Thumbnail</div>
+        {% endif %}
+        <p style="margin-top: 5px;">{{ game.name }}</p>
     </div>
-{% endblock %}
+
+    <div class="server-lists">
+        <h3>Active Servers</h3>
+        {% if active_servers %}
+        {% for server in active_servers %}
+        {# --- CORRECTED FIELDSET FOR ACTIVE SERVERS --- #}
+        <fieldset class="server-box">
+            <legend>{{ server.name }}</legend>
+            <div class="server-details">
+                <p><strong>Podman Status:</strong> <span style="color: limegreen;">Online</span></p>
+                <p><strong>IP Address:</strong> {{ server.ip_address|default:"N/A" }}</p>
+                <p><strong>Port Mappings:</strong> {{ server.get_ports_display }}</p>
+                {# --- Live Stats Section (Checks Game Model Config & Query Result) --- #}
+                <div class="live-stats">
+                    {# Check if query succeeded and returned data #}
+                    {% if server.live_stats %}
+                    <p><strong>Live Status:</strong> <span style="color: lightgreen;">Reachable</span></p>
+                    {# Display common stats using consistent keys from the dictionary #}
+                    <p><strong>Server Name:</strong> {{ server.live_stats.server_name|default:"N/A" }}</p>
+                    <p><strong>Map:</strong> {{ server.live_stats.map_name|default:"N/A" }}</p>
+                    <p>
+                        <strong>Players:</strong>
+                        {{ server.live_stats.current_players|default:"0" }} /
+                            {{ server.live_stats.max_players|default:"?" }}
+                        {% if server.live_stats.bots is not None %} ({{ server.live_stats.bots }} bots){% endif %}
+                    </p>
+                    <p>
+                        <strong>Password:</strong>
+                        {% if server.live_stats.password_protected %}<span style="color: orange;">Yes</span>{% else
+                        %}No{% endif %}
+                    </p>
+                    {% if server.live_stats.vac_enabled is not None %}
+                    <p><strong>VAC Secured:</strong> {% if server.live_stats.vac_enabled %}Yes{% else %}No{% endif %}
+                    </p>
+                    {% endif %}
+                    {% if server.live_stats.players_list %} {# Raw list, e.g. from Q2 #}
+                    <p><strong>Player List (Raw):</strong></p>
+                    <ul class="player-list">
+                        {% for player_line in server.live_stats.players_list %}<li>{{ player_line }}</li>{% empty %}<li>
+                        </li>{% endfor %}
+                    </ul>
+                    {% endif %}
+
+                    {# Check if query was configured for this game (in Game model) but failed #}
+                    {% elif server.game.query_protocol != 'none' and server.game.default_query_port_key %}
+                    <p class="error-msg"><strong>Live Status:</strong> Unreachable (Timeout or Error)</p>
+                    {# Query was not configured for this game in the Game model #}
+                    {% else %}
+                    <p><em>(Live query not configured for {{ server.game.name }})</em></p>
+                    {% endif %}
+                </div>
+                {# --- End Live Stats Section --- #}
+            </div>
+        </fieldset>
+        {# --- END CORRECTED FIELDSET --- #}
+        {% endfor %}
+        {% else %}
+        <p>No active servers found for this game.</p>
+        {% endif %}
+
+        <hr class="section-divider"> {# Use HR for clearer separation #}
+
+        <h3>Dormant Servers</h3>
+        {% if dormant_servers %}
+        {% for server in dormant_servers %}
+        <fieldset class="server-box" style="opacity: 0.6;">
+            <legend>{{ server.name }}</legend>
+            <div class="server-details">
+                <p><strong>Podman Status:</strong> <span style="color: orange;">{{ server.status|title }}</span></p>
+                <p><strong>Image:</strong> {{ server.image }}</p>
+                <p><strong>Connect Info:</strong> {{ server.ip_address|default:"N/A" }} : {{ server.get_ports_display }}
+                </p>
+            </div>
+        </fieldset>
+        {% endfor %}
+        {% else %}
+        <p>No dormant servers found for this game.</p>
+        {% endif %}
+
+    </div> {# End server-lists #}
+
+    <div class="clear-float"></div> {# Clear float #}
+
+    <div class="game-info" style="margin-top: 30px; padding-top: 20px; border-top: 1px solid #444;">
+        <h4>About {{ game.name }}</h4>
+        <p>Genre: {{ game.genre|default:"N/A" }}</p>
+        {# TODO: Pull more data #}
+    </div>
+</div>
+{% endblock %}

webpanel/templates/webpanel/games.html

@@ -3,12 +3,12 @@
 {% block title %}Games - Game Servers{% endblock %}
 
 {% block content %}
-    <h2>Public Game Servers</h2>
+    <h2>Games</h2>
 
     <div class="game-grid" style="display: flex; flex-wrap: wrap; gap: 10px;">
         {% for game in games %}
             <div class="game-box" style="width: 150px; text-align: center;">
-                <a href="{% url 'games' %}">
+                <a href="{% url 'game_detail' game.name %}">
                     <img src="{{ game.thumbnail.url }}" alt="{{ game.name }}" style="width: 100%; height: auto;">
                     <p>{{ game.name }}</p>
                 </a>

webpanel/templates/webpanel/port_mapping_widget.html

@@ -0,0 +1,45 @@
+<div id="{{ widget.name }}_container">
+    {% for k, v in widget.value.items %}
+    <div class="port-entry">
+      <input type="text" name="{{ widget.name }}_key[]" value="{{ k }}" placeholder="port/proto">
+      <input type="number" name="{{ widget.name }}_value[]" value="{{ v }}" placeholder="host port">
+      <button type="button" class="remove-port-entry">×</button>
+    </div>
+    {% empty %}
+    <div class="port-entry">
+      <input type="text" name="{{ widget.name }}_key[]" placeholder="port/proto">
+      <input type="number" name="{{ widget.name }}_value[]" placeholder="host port">
+      <button type="button" class="remove-port-entry">×</button>
+    </div>
+    {% endfor %}
+  </div>
+  <button type="button" id="add-port-{{ widget.name|slugify }}">+ Add</button>
+  <script>
+    document.addEventListener("DOMContentLoaded", function () {
+      const container = document.getElementById("{{ widget.name }}_container");
+      const addButton = document.getElementById("add-port-{{ widget.name|slugify }}");
+      addButton.addEventListener("click", () => {
+        const div = document.createElement("div");
+        div.className = "port-entry";
+        div.innerHTML = `
+          <input type="text" name="{{ widget.name }}_key[]" placeholder="port/proto">
+          <input type="number" name="{{ widget.name }}_value[]" placeholder="host port">
+          <button type="button" class="remove-port-entry">×</button>
+        `;
+        container.appendChild(div);
+      });
+      container.addEventListener("click", (e) => {
+        if (e.target.classList.contains("remove-port-entry")) {
+          e.target.parentElement.remove();
+        }
+      });
+    });
+  </script>
+  <style>
+    .port-entry {
+      margin-bottom: 5px;
+    }
+    .port-entry input {
+      margin-right: 5px;
+    }
+  </style>

webpanel/test_models.py

@@ -0,0 +1,11 @@
+from django.test import TestCase
+from webpanel.models import Game
+
+class GameTestCase(TestCase):
+    def setUp(self):
+        Game.objects.create(name="Assassin's Creed")
+
+    def test_game_creation(self):
+        assassins = Game.objects.get(name="Assassin's Creed")
+        assert str(assassins) == "Assassin's Creed"
+

webpanel/tests.py

@@ -1,3 +0,0 @@
-from django.test import TestCase
-
-# Create your tests here.

webpanel/urls.py

@@ -3,14 +3,8 @@ from django.conf.urls.static import static
 from django.urls import path
 from . import views
 
-
 urlpatterns = [
     path('', views.home, name='home'),
     path('games/', views.games, name='games'),
-    path('games/<str:game>/', views.game_detail, name='game_detail'),
+    path('games/<str:game_name>/', views.game_detail, name='game_detail'),
-    # path('active-servers/', views.active_servers_view, name='active-servers'),
+] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
-    # path('games/<str:game_name>/', views.game_servers_view, name='game-servers'),
-]
-
-if settings.DEBUG:  # Only serve media files in development
-    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

webpanel/utils.py

@@ -1,51 +1,12 @@
-import podman
+import a2s
 
-def launch_pod_container(image, run_command, name, ports):
+# games tested by library author 
-    client = podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
+# Half-Life 2, Half-Life, Team Fortress 2, Counter-Strike: Global Offensive,
-    try:
+#  Counter-Strike 1.6, ARK: Survival Evolved, Rust
-        container = client.containers.create(
-            name=name,
-            image=image,
-            # ports=ports,
-            command=run_command,
-            detach=True,
-            network_mode='host'
-        )
-        container.start()
-        return f"Container launched successfully: {container.id}"
-    except podman.errors.APIError as e:
-        return f"API Error: {e}"
-    except Exception as e:
-        return f"Error: {e}"
 
-def stop_pod_container(name):
-    client = podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
-    try:
-        container = client.containers.get(name)
-        container.stop()
-        return f"Container stopped: {name}"
-    except podman.errors.NotFound:
-        return f"Container not found: {name}"
-    except Exception as e:
-        return f"Error stopping container {name}: {e}"
 
-def remove_pod_container(name):
+def a2s_query(ip, port):
-    client = podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
+    address = (ip, port)
-    try:
+    info = a2s.info(address)
-        container = client.containers.get(name)
+    return info
-        container.remove(force=True)  # Force removal if the container is running
-        return f"Container removed: {name}"
-    except podman.errors.NotFound:
-        return f"Container not found: {name}"
-    except Exception as e:
-        return f"Error removing container {name}: {e}"
 
-def is_container_running(name):
-    client = podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
-    try:
-        container = client.containers.get(name)
-        return container.status == "running"
-    except podman.errors.NotFound:
-        return False
-    except Exception as e:
-        return f"Error checking container {name}: {e}"

webpanel/views.py

@@ -1,5 +1,15 @@
 from django.shortcuts import render, get_object_or_404
 from .models import Game, Server
+from .utils import a2s_query
+import logging
+
+logger = logging.getLogger(__name__)
+
+PROTOCOL_FUNCTION_MAP = {
+    'a2s': a2s_query,
+    # Add other protocols here -> 'quake2': query_quake2, etc.
+}
+
 
 def home(request):
     """Display the home page with links to other views."""
@@ -11,5 +21,75 @@ def games(request):
     return render(request, 'webpanel/games.html', {'games': games})
 
 def game_detail(request, game_name):
-    game = get_object_or_404(Game, id=game_name)
+    logger.info(f"Accessing game detail for: {game_name}") # Use logger.info or logger.debug
-    return render(request, 'webpanel/game_detail.html', {'game': game})
+    game = get_object_or_404(Game, name__iexact=game_name) # Use iexact for case-insensitivity
+
+    query_protocol = getattr(game, 'query_protocol', 'none') # Safely get protocol
+    query_function = PROTOCOL_FUNCTION_MAP.get(query_protocol)
+    default_port_key = getattr(game, 'default_query_port_key', None) # Safely get port key
+
+    if not query_function:
+        logger.debug(f"Live query disabled for game '{game.name}' (protocol '{query_protocol}' not mapped or 'none').")
+    elif not default_port_key:
+         logger.warning(f"Live query configured for '{game.name}' (protocol '{query_protocol}') but 'Default query port key' is not set in Game model.")
+    else:
+         logger.debug(f"Live query configured for '{game.name}': Protocol='{query_protocol}', Port Key='{default_port_key}'")
+    servers_queryset = Server.objects.filter(game=game)
+
+    active_server_list = []
+    dormant_server_list = []
+
+    for server in servers_queryset:
+        server.sync_status()  
+        server.live_stats = None  
+
+        if server.status == 'online' and a2s_query and default_port_key:
+            logger.debug(f"Server '{server.name}' is online, attempting query using protocol '{query_protocol}'.")
+
+            query_port_host = None
+            port_keys_to_try = [default_port_key]
+            if '/' in default_port_key:
+                 port_keys_to_try.append(default_port_key.split('/')[0]) # Try without /udp suffix
+
+            for key in port_keys_to_try:
+                 if isinstance(server.port, dict) and key in server.port: # Check if server.port is a dict
+                     try:
+                         query_port_host = int(server.port[key])
+                         logger.debug(f"Found host query port {query_port_host} using key '{key}'.")
+                         break
+                     except (ValueError, TypeError):
+                        logger.warning(f"Invalid port value '{server.port[key]}' for key '{key}' in server '{server.name}'.")
+                        query_port_host = None
+
+            if query_port_host is None:
+                logger.warning(f"Could not find host port for key '{default_port_key}' (or fallback) in server '{server.name}'. Port data: {server.port}")
+
+            ip_to_query = server.ip_address
+            if not ip_to_query or ip_to_query in ["0.0.0.0", "::"]:
+                ip_to_query = "127.0.0.1" # Default to localhost
+                logger.debug(f"Using IP {ip_to_query} for query.")
+
+            if ip_to_query and query_port_host is not None:
+                try:
+                    logger.info(f"Querying {game.name} server '{server.name}' at {ip_to_query}:{query_port_host}")
+                    server.live_stats = a2s_query(ip=ip_to_query, port=query_port_host) # Call the mapped function
+                    if server.live_stats:
+                         logger.info(f"Query successful for '{server.name}'.") # Add more detail if needed
+                    else:
+                         logger.warning(f"Query returned no data for '{server.name}'.")
+                except Exception as e:
+                    logger.error(f"Error querying server '{server.name}': {e}", exc_info=True)
+                    server.live_stats = None # Ensure it's None on error
+            else:
+                logger.warning(f"Skipping query for '{server.name}': Missing IP or Host Port.")
+
+        if server.status == 'online':
+            active_server_list.append(server)
+        else:
+            dormant_server_list.append(server)
+
+    return render(request, 'webpanel/game_detail.html', {
+        'game': game,
+        'active_servers': active_server_list, # Use the list we built
+        'dormant_servers': dormant_server_list # Use the list we built
+    })

webpanel/widgets.py

@@ -0,0 +1,35 @@
+from django import forms
+from django.utils.safestring import mark_safe
+import json
+
+class PortMappingWidget(forms.Widget):
+    template_name = "webpanel/port_mapping_widget.html"
+
+    def format_value(self, value):
+        if isinstance(value, str):
+            try:
+                value = json.loads(value)
+            except json.JSONDecodeError:
+                value = {}
+        return value or {}
+
+    def value_from_datadict(self, data, files, name):
+        raw = {}
+        keys = data.getlist(f"{name}_key")
+        values = data.getlist(f"{name}_value")
+        for k, v in zip(keys, values):
+            if k:
+                try:
+                    raw[k] = int(v)
+                except ValueError:
+                    raw[k] = v
+        return json.dumps(raw)  # <-- FIX: return JSON string instead of dict
+
+    def get_context(self, name, value, attrs):
+        value = self.format_value(value)
+        context = super().get_context(name, value, attrs)
+        context["widget"].update({
+            "name": name,
+            "value": value,
+        })
+        return context