dude wtf

Signed-off-by: Pratyush Desai <pratyush.desai@liberta.casa>

.gitignore

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

GameServerSupervisor/settings.py

@@ -118,10 +118,7 @@ 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

@@ -1,662 +0,0 @@
-                    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/>.
-

webpanel/admin.py

@@ -1,44 +1,7 @@
-from django.contrib import admin, messages
+from django.contrib import admin
 from .models import Game, Server
-from django import forms
-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}")
+from .utils import launch_pod_container, stop_pod_container, remove_pod_container
+import podman
 
 @admin.register(Game)
 class GameAdmin(admin.ModelAdmin):
@@ -46,19 +9,47 @@ 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):
-    form = ServerForm
-    list_display = (
-        'game', 'name', 'ip_address', 'get_ports_display', 'status', 'image', 'run_command', 'command_args'
-    )
+    list_display = ('game', 'name', 'ip_address', 'port', '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)
@@ -70,3 +61,7 @@ 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-04-15 19:28
+# Generated by Django 5.1.5 on 2025-02-11 01:27
 
 from django.db import migrations, models
 

webpanel/migrations/0008_alter_game_thumbnail.py

@@ -1,20 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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,22 +1,13 @@
 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):
@@ -24,36 +15,25 @@ 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.JSONField(default=dict, blank=True)
+    port = models.PositiveIntegerField(null=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)-> str:
+    def __str__(self):
         return f"{self.game.name} Server at {self.ip_address}:{self.port}"
 
-    @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:
+    def sync_status(self):
         """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 = self._get_podman_client().containers.get(self.safe_name)
+            container = client.containers.get(container_name)
             if container.status == "running":
                 self.status = "online"
             else:
@@ -61,76 +41,17 @@ class Server(models.Model):
         except podman.errors.NotFound:
             self.status = "offline"
         except Exception as e:
-            self.status = "offline"
+            self.status = "offline"  # Fallback in case of unexpected errors
         self.save()
 
-    def get_ports_display(self):
-        return ", ".join(f"{k}→{v}" for k, v in self.port.items())
-    get_ports_display.short_description = "Ports"  # display name in admin
-
-
-    def launch_pod_container(self) -> str:
-        try:
-            port_bindings = {
-                container_port: ('0.0.0.0', host_port)
-                for container_port, host_port in self.port.items()
-            }
-
-            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}"
+    def get_podman_run_command(self):
+        """Returns the Podman run command, falling back to default image if not set."""
+        if self.run_command:
+            # Return command as a string to be split later
+            return self.run_command
+        else:
+            # Default command with image and arguments
+            base_command = f"{self.image}"
+            if self.command_args:
+                base_command += " " + self.command_args
+            return base_command

webpanel/templates/webpanel/game_detail.html

@@ -3,195 +3,43 @@
 {% block title %}{{ game.name }} - Game Details{% endblock %}
 
 {% block content %}
-<h2>{{ game.name }}</h2>
+    <h2>{{ game.name }}</h2>
 
-{# --- Add the CSS from previous example for .server-box etc. --- #}
-<style>
-    .server-box {
-        border: 1px solid #555;
-        padding: 15px;
-        margin-bottom: 15px;
-        background-color: #2a2a2a;
-        border-radius: 4px;
-    }
+    <!-- <nav class="sub-nav">
+        <a href="{% url 'home' %}">Home</a>
+        <a href="{% url 'games' %}">Games</a>
+        <a href="#">Mods</a>
+        <div class="right-links">
+            <a href="#">Show All Active Servers</a>
+            <a href="#">Request A Server</a>
+        </div>
+    </nav> -->
 
-    .server-box legend {
-        font-weight: bold;
-        color: #0f0;
-        /* Lime green */
-        padding: 0 5px;
-    }
-
-    .server-details p {
-        margin: 6px 0;
-        font-size: 0.95em;
-    }
-
-    .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 class="game-detail">
+        <div class="game-box" style="width: 150px; text-align: center;">
+            <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>
+        </div>
+        <div class="active-servers">
+            {% if active_servers %}
+            {% for server in active_servers %}
+                <fieldset class="server-box">
+                    <legend>Server: {{ game.name }}</legend>
+                    <div class="server-details">
+                        <p><strong>IP Address:</strong> {{ server.ip_address }}</p>
+                        <p><strong>Port:</strong> {{ server.port }}</p>
+                        <p><strong>Status:</strong> Online</p>
+                    </div>
+                </fieldset>
+            {% endfor %}
+            {% else %}
+                <p>No active servers found for this game.</p>
+            {% endif %}
+        </div>
+        <div class="game-info">
+            <p>Pull data from some open API to populate information about the game and render it.</p>
+        </div>
     </div>
-
-    <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 %}
+{% endblock %}

webpanel/templates/webpanel/port_mapping_widget.html

@@ -1,45 +0,0 @@
-<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/urls.py

@@ -3,8 +3,14 @@ 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_name>/', views.game_detail, name='game_detail'),
-] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
+    # path('active-servers/', views.active_servers_view, name='active-servers'),
+    # 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,12 +1,51 @@
-import a2s
+import podman
 
-# games tested by library author 
-# Half-Life 2, Half-Life, Team Fortress 2, Counter-Strike: Global Offensive,
-#  Counter-Strike 1.6, ARK: Survival Evolved, Rust
+def launch_pod_container(image, run_command, name, ports):
+    client = podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
+    try:
+        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 a2s_query(ip, port):
-    address = (ip, port)
-    info = a2s.info(address)
-    return info
+def remove_pod_container(name):
+    client = podman.PodmanClient(base_url="unix:///run/user/1000/podman/podman.sock")
+    try:
+        container = client.containers.get(name)
+        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,15 +1,5 @@
 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."""
@@ -21,75 +11,12 @@ def games(request):
     return render(request, 'webpanel/games.html', {'games': games})
 
 def game_detail(request, game_name):
-    logger.info(f"Accessing game detail for: {game_name}") # Use logger.info or logger.debug
-    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
-    })
+    print(f"Looking for game: {game_name}")
+    game = get_object_or_404(Game, name=game_name)
+    servers = Server.objects.filter(game=game)
+    for server in servers:
+        server.sync_status()
+    dormant_servers = servers.filter(status='offline')
+    active_servers = servers.filter(status='online') 
+    return render(request, 'webpanel/game_detail.html', {'game': game,
+                'active_servers': active_servers, 'dormant_servers': dormant_servers})

webpanel/widgets.py

@@ -1,35 +0,0 @@
-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