Merge pull request #2 from sinisaos/enviroment_variables

change the use of environment variables

Author: sinisaos

app/.env.example .env.exampleapp/.env.example renamed to .env.example

@@ -6,4 +6,3 @@ DB_PORT=5432
 USERNAME="piccolo"
 PASSWORD="piccolo123"
 EMAIL="[email protected]"
-ENCRIPTION_KEY="\xb7(\xa5\xa6\xa4&\xeb\x8eI\xfe_Y\x16\x12\xf4\xf4\xa8|\xc6#\xd1\x02\xa2s\x03]\xea\x12\xb9\xf1\xa2\xb3"

Dockerfile

@@ -1,11 +1,11 @@
-FROM python:3.11
+FROM python:3.11-slim
 
 WORKDIR /code
 
 COPY ./requirements.txt /code/requirements.txt
 
+COPY ./config.yaml /code/config.yaml
+
 RUN pip install --no-cache-dir -r /code/requirements.txt
 
 COPY ./app /code/app
-
-CMD ["python", "app/main.py"]

README.md

@@ -1,4 +1,4 @@
-Experimenting with using a dockerized Piccolo Admin with an existing (legacy) database.
+Dockerized Piccolo Admin to use existing (legacy) database.
 
 ### Usage
 
@@ -11,20 +11,77 @@ git clone https://github.com/piccolo-orm/piccolo-admin-docker.git
 Creating an `.env` file.
 
 ```bash
-cd app
 cp .env.example .env && rm .env.example
-cd ..
 ```
-Creating a Docker image.
+
+Run the Docker container.
 
 ```bash
-docker build -t piccolo_admin .
+docker-compose up -d
 ```
 
-Running a Docker image (use the `--network=host` flag for an existing database from the local machine).
+After site is running log in as admin user on [localhost:8000](http://localhost:8000) and use legacy database.
+
+Stop the Docker container.
 
 ```bash
-docker run -d --network=host --name admin_container piccolo_admin
+docker-compose down
 ```
 
-After site is running log in as admin user on [localhost:8000](http://localhost:8000/admin/) and use legacy database.
+### Additional Piccolo Admin configuration
+
+Piccolo Admin has a flexible UI with lots of configuration options to display only the columns you want your users to see. More information on Piccolo Admin [docs](https://piccolo-admin.readthedocs.io/en/latest/index.html).
+
+After Piccolo Admin is started with all the tables from the existing database, we can do additional configuration through the `config.yaml` file. 
+
+Example of `config.yaml`:
+
+```yaml
+tables:
+  # An example of additional Piccolo Admin configuration
+  Actor:
+    visible_columns:
+      - first_name
+    visible_filters:
+      - actor_id
+      - first_name
+    menu_group: Movies
+    link_column: first_name
+  Address:
+    visible_columns:
+      - address_id
+      - address
+      - city_id
+    visible_filters:
+      - address_id
+      - address
+      - city_id
+    menu_group: Location
+    rich_text_columns: address
+  City:
+    visible_columns:
+      - city_id
+      - city
+    visible_filters:
+      - city_id
+      - city
+    menu_group: Location
+  Country:
+    visible_columns:
+      - country_id
+      - country
+    visible_filters:
+      - country_id
+      - country
+    menu_group: Location
+
+sidebar_links:
+  Piccolo Admin: https://piccolo-admin.readthedocs.io/en/latest/index.html
+  Piccolo ORM: https://piccolo-orm.readthedocs.io/en/latest/index.html
+```
+
+For these changes to take effect, you must stop the container and rebuild it with.
+
+```bash
+docker-compose up -d --build
+```

app/main.py

@@ -1,26 +1,30 @@
 import asyncio
 import os
 
-from dotenv import find_dotenv, load_dotenv
+import yaml
 from hypercorn import Config
 from hypercorn.asyncio import serve
 from piccolo.apps.user.tables import BaseUser
 from piccolo.engine import PostgresEngine
 from piccolo.engine.sqlite import SQLiteEngine
 from piccolo.table import create_db_tables
 from piccolo.table_reflection import TableStorage
-from piccolo_admin import create_admin
+from piccolo_admin.endpoints import TableConfig, create_admin
 from piccolo_api.encryption.providers import XChaCha20Provider
 from piccolo_api.mfa.authenticator.provider import AuthenticatorProvider
 from piccolo_api.mfa.authenticator.tables import (
     AuthenticatorSecret as AuthenticatorSecret_,
 )
 from piccolo_api.session_auth.tables import SessionsBase
 
-DB = SQLiteEngine()
-
+with open("config.yaml") as stream:
+    try:
+        admin_config = yaml.safe_load(stream)
+        BASE_CONFIG = admin_config.get("tables")
+    except yaml.YAMLError as exc:
+        raise exc
 
-load_dotenv(find_dotenv())
+DB = SQLiteEngine()
 
 
 class Sessions(SessionsBase, db=DB):
@@ -67,29 +71,106 @@ async def main():
     storage = TableStorage(engine=db)
     await storage.reflect(schema_name="public")
 
-    # This tuple IS unique
-    # however auto_include_related within
-    # create_admin makes it non unique TableConfigs
-    found_tables = storage.tables.values()
-
-    for table_class in found_tables:
-        table_class._meta._db = db
+    # additional configuration of admin tables
+    if BASE_CONFIG is not None:
+        tables_to_show = [table.lower() for table in BASE_CONFIG]
+        found_tables = [
+            table
+            for table in storage.tables.values()
+            if table._meta.tablename in tables_to_show
+        ]
+        admin_tables = []
+        for table in found_tables:
+            capitalize_table_name = table._meta.tablename.capitalize()
+            # visible columns
+            try:
+                visible_columns = [
+                    column
+                    for column in table._meta.columns
+                    if column._meta.name
+                    in BASE_CONFIG[capitalize_table_name].get(
+                        "visible_columns", None
+                    )
+                ]
+            except TypeError:
+                visible_columns = None
+            # visible filters
+            try:
+                visible_filters = [
+                    column
+                    for column in table._meta.columns
+                    if column._meta.name
+                    in BASE_CONFIG[capitalize_table_name].get(
+                        "visible_filters", None
+                    )
+                ]
+            except TypeError:
+                visible_filters = None
+            # rich text columns
+            try:
+                rich_text_columns = [
+                    column
+                    for column in table._meta.columns
+                    if column._meta.name
+                    in BASE_CONFIG[capitalize_table_name].get(
+                        "rich_text_columns", None
+                    )
+                ]
+            except TypeError:
+                rich_text_columns = None
+            # link column
+            try:
+                link_column = [
+                    column
+                    for column in table._meta.columns
+                    if column._meta.name
+                    == BASE_CONFIG[capitalize_table_name].get(
+                        "link_column", None
+                    )
+                ][0]
+            except IndexError:
+                link_column = None
+            # menu_group
+            menu_group = BASE_CONFIG[capitalize_table_name].get(
+                "menu_group", None
+            )
+
+            admin_tables.append(
+                TableConfig(
+                    table_class=table,
+                    visible_columns=visible_columns,
+                    visible_filters=visible_filters,
+                    rich_text_columns=rich_text_columns,
+                    link_column=link_column,
+                    menu_group=menu_group,
+                )
+            )
+    else:
+        admin_tables = storage.tables.values()
+
+    for table in admin_tables:
+        if isinstance(table, TableConfig):
+            table.table_class._meta._db = db
+        else:
+            table._meta._db = db
+
+    # create new encription key for MFA
+    encryption_key = XChaCha20Provider.get_new_key()
 
     app = create_admin(
-        found_tables,
+        admin_tables,
         auth_table=User,
         session_table=Sessions,
         auto_include_related=False,
         mfa_providers=[
             AuthenticatorProvider(
                 encryption_provider=XChaCha20Provider(
-                    encryption_key=os.environb[b"ENCRIPTION_KEY"]
-                    .decode("unicode-escape")
-                    .encode("latin-1")
+                    encryption_key=encryption_key,
                 ),
                 secret_table=AuthenticatorSecret,
             ),
         ],
+        sidebar_links=admin_config.get("sidebar_links", None),
     )
 
     # Server

config.yaml

@@ -0,0 +1,4 @@
+tables:
+  # Additional tables configurations go here
+sidebar_links:
+  # External links go here

docker-compose.yml

@@ -0,0 +1,9 @@
+services:
+  web:
+    build: .
+    command: python app/main.py
+    volumes:
+      - .:/app
+    env_file:
+      - .env
+    network_mode: "host"

requirements.txt

@@ -4,4 +4,4 @@ hypercorn
 piccolo
 piccolo-admin
 piccolo_api[authenticator,pynacl]
-python-dotenv
+pyyaml