Merge pull request #19 from nstankov-bg/main

[NEW FEATURE ADDED] 🚀 Add Status Page Endpoints and Error Handling 🛠️

Author: MedAziz11

.env.dist

@@ -0,0 +1,5 @@
+KUMA_SERVER=
+KUMA_USERNAME=
+KUMA_PASSWORD=
+ADMIN_PASSWORD=
+ACCESS_TOKEN_EXPIRATION=5

.gitignore

@@ -0,0 +1,2 @@
+.env
+db/*

Makefile

@@ -0,0 +1,6 @@
+up:
+	docker compose up --build
+
+test:
+	bash tests/monitor.sh
+	bash tests/statuspage.sh

README.md

@@ -1,75 +1,84 @@
 # Uptime-Kuma-Web-API
+
 ## A REST API wrapper for [Uptime Kuma](https://github.com/louislam/uptime-kuma) using [Uptime-Kuma-API](https://github.com/lucasheld/uptime-kuma-api)
+
 ---
-## EndPoints:
 
-![Alt text](./images/1.png )
-![Alt text](./images/2.png )
+## EndPoints:
 
+![Alt text](./images/1.png)
+![Alt text](./images/2.png)
 
 ## How to use it:
-----
+
+---
 
 ### Environment Variables :
-  You have to define these ENV VARS in order to connect to your KUMA server.
+
+You have to define these ENV VARS in order to connect to your KUMA server.
 
         KUMA_SERVER=<your_kuma_server>
         KUMA_USERNAME=<your_kuma_username>
         KUMA_PASSWORD=<your_kuma_password>
         ADMIN_PASSWORD=<your admin password so you can connect with via the api>
 
-  #### Note:
+#### Note:
 
-  You have to define your ADMIN_PASSWORD or you wont be able to connect to your rest api.
+You have to define your ADMIN_PASSWORD or you wont be able to connect to your rest api.
 
-  You will connect with those credentials:
+You will connect with those credentials:
 
     username = admin
     password = <ADMIN_PASSWORD>
 
 ### Features:
-  - Multi user Kuma api ( without privilege YET!!) with a small SQLite db
-  - Easy to use REST API with most of the Uptime-Kuma features
-  - Swagger Docs
-  - Dockerized [UptimeKuma_RestAPI Image](https://hub.docker.com/repository/docker/medaziz11/uptimekuma_restapi)
 
-### Example : 
-  You can simply create a docker compose file like this :
+- Multi user Kuma api ( without privilege YET!!) with a small SQLite db
+- Easy to use REST API with most of the Uptime-Kuma features
+- Swagger Docs
+- Dockerized [UptimeKuma_RestAPI Image](https://hub.docker.com/repository/docker/medaziz11/uptimekuma_restapi)
+- Multi-architecture support (amd64, arm64, arm/v7, arm/v6)
+
+### Example :
+
+You can simply create a docker compose file like this :
 
 ```yaml
-        version: '3.9'
-        services:
-        kuma:
-            container_name: uptime-kuma
-            image: louislam/uptime-kuma:latest
-            ports:
-            - "3001:3001"
-            restart: always
-            volumes:
-            - uptime-kuma:/app/data
-
-        api:
-            container_name: backend
-            image: medaziz11/uptimekuma_restapi
-            volumes:
-            - ./db:/db
-            restart: always
-            environment:
-            - KUMA_SERVER=http://kuma:3001
-            - KUMA_USERNAME=test
-            - KUMA_PASSWORD=123test.
-            - ADMIN_PASSWORD=admin
-            depends_on:
-            - kuma
-            ports:
-            - "8000:8000"
-
-        volumes:
-        uptime-kuma:
+version: "3.9"
+services:
+kuma:
+  container_name: uptime-kuma
+  image: louislam/uptime-kuma:latest
+  ports:
+    - "3001:3001"
+  restart: always
+  volumes:
+    - uptime-kuma:/app/data
+
+api:
+  container_name: backend
+  image: medaziz11/uptimekuma_restapi
+  volumes:
+    - ./db:/db
+  restart: always
+  environment:
+    - KUMA_SERVER=http://kuma:3001
+    - KUMA_USERNAME=test
+    - KUMA_PASSWORD=123test.
+    - ADMIN_PASSWORD=admin
+  depends_on:
+    - kuma
+  ports:
+    - "8000:8000"
+
+volumes:
+uptime-kuma:
 ```
-### In order for the example to work: You have to run kuma first then create your kuma username and password then re-run the compose file. 
+
+### In order for the example to work: You have to run kuma first then create your kuma username and password then re-run the compose file.
 
 ### Example CURL Script:
+
 ---
 
 ```bash

app/main.py

@@ -1,21 +1,21 @@
 from fastapi import FastAPI
 from fastapi.responses import RedirectResponse
 import os
-
+from routers import statuspage
 from routers import monitor, auth, tags, cert, info, uptime, ping, database, settings as settings, user, maintenance
 from config import settings as app_settings
 from utils.admin import check_admin
 
 from tortoise import Tortoise
 
-
 app = FastAPI(title=app_settings.PROJECT_NAME)
 app.router.redirect_slashes = True
 
 app.include_router(user.router, prefix="/users", tags=["Users"])
 app.include_router(settings.router, prefix="/settings", tags=["Settings"])
 app.include_router(database.router, prefix="/database", tags=["DataBase"])
 app.include_router(monitor.router, prefix="/monitors", tags=["Monitor"])
+app.include_router(statuspage.router, prefix="/statuspages", tags=["Status Page"])
 app.include_router(maintenance.router, prefix="/maintenance", tags=["Maintenance"])
 app.include_router(tags.router, prefix="/tags", tags=["Tags"])
 app.include_router(cert.router, prefix="/cert_info", tags=["Certification Info"])
@@ -36,16 +36,12 @@ async def startup_event():
 
     await Tortoise.generate_schemas()
 
-
-
     await check_admin()
 
-
 @app.on_event("shutdown")
 async def shutdown_event():
     await Tortoise.close_connections()
 
-
 @app.get("/", include_in_schema=False)
 async def root():
-    return RedirectResponse(url='/docs')
+    return RedirectResponse(url='/docs')

app/routers/statuspage.py

@@ -0,0 +1,94 @@
+from fastapi import APIRouter, Depends, HTTPException, Path, Body
+from uptime_kuma_api import UptimeKumaApi, UptimeKumaException
+from config import logger as logging
+from schemas.api import API
+from utils.deps import get_current_user
+from schemas.statuspage import StatusPageList, StatusPage, AddStatusPageResponse, AddStatusPageRequest,SaveStatusPageRequest,SaveStatusPageResponse, DeleteStatusPageResponse
+
+router = APIRouter(redirect_slashes=True)
+
+
+@router.get("", response_model=StatusPageList, description="Get all status pages")
+async def get_all_status_pages(cur_user: API = Depends(get_current_user)):
+    api: UptimeKumaApi = cur_user['api']
+    try:
+        return {"statuspages": api.get_status_pages()}
+    except Exception as e:
+        logging.fatal(e)
+        raise HTTPException(500, str(e))
+
+
+@router.get("/{slug}", response_model=StatusPage, description="Get a status page")
+async def get_status_page(slug: str, cur_user: API = Depends(get_current_user)):
+    api: UptimeKumaApi = cur_user['api']
+    try:
+        return api.get_status_page(slug)
+    except UptimeKumaException as e:
+        logging.error(e)
+        raise HTTPException(404, str(e))
+    except Exception as e:
+        logging.fatal(e)
+        raise HTTPException(500, str(e))
+
+
+@router.post("", response_model=AddStatusPageResponse, description="Add a status page")
+async def add_status_page(status_page_data: AddStatusPageRequest, cur_user: API = Depends(get_current_user)):
+    api: UptimeKumaApi = cur_user['api']
+    try:
+        return api.add_status_page(status_page_data.slug, status_page_data.title)
+    except UptimeKumaException as e:
+        logging.error(e)
+        raise HTTPException(400, str(e))
+    except Exception as e:
+        logging.fatal(e)
+        raise HTTPException(500, str(e))
+
+
+@router.post("/{slug}",response_model=SaveStatusPageResponse, description="Save a status page")
+async def save_status_page(
+    slug: str = Path(...),
+    status_page_data: SaveStatusPageRequest = Body(...),
+    cur_user: API = Depends(get_current_user),
+):  
+    api: UptimeKumaApi = cur_user['api']
+    try:
+        print (status_page_data.id)
+        return api.save_status_page(
+            slug,
+            id=status_page_data.id,
+            title=status_page_data.title,
+            description=status_page_data.description,
+            theme=status_page_data.theme,
+            published=status_page_data.published,
+            showTags=status_page_data.showTags,
+            domainNameList=status_page_data.domainNameList,
+            googleAnalyticsId=status_page_data.googleAnalyticsId,
+            customCSS=status_page_data.customCSS,
+            footerText=status_page_data.footerText,
+            showPoweredBy=status_page_data.showPoweredBy,
+            icon=status_page_data.icon,
+            publicGroupList=status_page_data.publicGroupList,
+        )
+    except UptimeKumaException as e:
+        logging.error(e)
+        raise HTTPException(400, str(e))
+    except Exception as e:
+        logging.fatal(e)
+        raise HTTPException(500, str(e))
+
+@router.delete("/{slug}", response_model=DeleteStatusPageResponse, description="Delete a status page")
+async def delete_status_page(slug: str = Path(...), cur_user: API = Depends(get_current_user)):
+    api: UptimeKumaApi = cur_user['api']
+    try:
+        return api.delete_status_page(slug)
+    #Catch type error...which is actually a success, go figgure. {"detail":"'NoneType' object has no attribute 'values'"}
+    except TypeError as e:
+        if "NoneType" in str(e):
+            logging.info("Status page deleted successfully")
+            return {"status": "success"}
+    except UptimeKumaException as e:
+        logging.error(e)
+        raise HTTPException(404, str(e))
+    except Exception as e:
+        logging.fatal(e)
+        raise HTTPException(500, str(e))

app/schemas/statuspage.py

@@ -0,0 +1,73 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field, HttpUrl, constr
+
+class Incident(BaseModel):
+    content: str
+    createdDate: str
+    id: int
+    lastUpdatedDate: Optional[str]
+    pin: int
+    style: str
+    title: str
+
+class Monitor(BaseModel):
+    id: int
+    maintenance: Optional[bool]
+    name: str
+    sendUrl: int
+
+class PublicGroup(BaseModel):
+    id: int
+    monitorList: List[Monitor]
+    name: str
+    weight: int
+
+class StatusPage(BaseModel):
+    customCSS: Optional[str] = None
+    description: Optional[str]
+    domainNameList: List[HttpUrl]
+    footerText: Optional[str]
+    googleAnalyticsId: Optional[str]
+    icon: str
+    id: int
+    incident: Optional[Incident]
+    maintenanceList: Optional[List]
+    published: bool
+    showPoweredBy: bool
+    showTags: bool
+    slug: constr(min_length=1)
+    theme: str
+    title: str
+    publicGroupList: Optional[List[PublicGroup]]
+
+class StatusPageList(BaseModel):
+    statuspages: List[StatusPage]
+
+class AddStatusPageRequest(BaseModel):
+    slug: Optional[str] = None
+    title:  Optional[str] = None
+    msg:  Optional[str] = None
+
+class AddStatusPageResponse(BaseModel):
+    msg:  Optional[str] = None
+class SaveStatusPageRequest(BaseModel):
+    id: int
+    title: str
+    slug: constr(min_length=1)
+    description: Optional[str] = None
+    theme: Optional[str] = "light"
+    published: Optional[bool] = True
+    showTags: Optional[bool] = False
+    domainNameList: Optional[List[HttpUrl]] = None
+    googleAnalyticsId: Optional[str] = None
+    customCSS: Optional[str] = ""
+    footerText: Optional[str] = None
+    showPoweredBy: Optional[bool] = True
+    icon: Optional[str] = "/icon.svg"
+    publicGroupList: Optional[List] = None
+
+class SaveStatusPageResponse(BaseModel):
+    detail: str
+
+class DeleteStatusPageResponse(BaseModel):
+    detail: str = "Status page deleted"

app/utils/admin.py

@@ -6,5 +6,4 @@ async def check_admin():
     admin_obj = await Users.get_or_none(username="admin")
     if not admin_obj:
         admin_obj = await Users.create(username="admin", password_hash=hash_password(settings.ADMIN_PASSWORD))
-        
     return admin_obj