diff --git a/.gitignore b/.gitignore
index d8893996e28df927f473d67c23bce572aee09200..9513bf1c668686c72953f5b1f6ac8f0bd687af0a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -88,6 +88,6 @@ ehthumbs.db
Thumbs.db
# Personal ignore patterns
-**/firebasecredentials.json
+**/firebaseCredentials.json
**/.secrets
.env
\ No newline at end of file
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..48341c4406cbc06c416e1d6da36cc3b0dbcb295f
--- /dev/null
+++ b/.gitlab-ci.yml
@@ -0,0 +1,99 @@
+# GitLab CI configuration file for CI/CD pipeline
+
+# Define stages for the pipeline
+stages:
+ - Build
+ - Test
+ - Deploy
+
+# Default configuration
+default:
+ # Use Docker as the default image
+ image: docker
+ # Enable Docker-in-Docker service
+ services:
+ - name: 'docker:dind'
+ # Before script actions
+ before_script:
+ # Display Docker info
+ - docker info
+
+# Define variables
+variables:
+ # Set Docker TLS certificate directory
+ DOCKER_TLS_CERTDIR: '/certs'
+ # Set path for downloading secure files
+ SECURE_FILES_DOWNLOAD_PATH: './.secrets/'
+
+# Build stage
+Build:
+ stage: Build
+ # Before script actions
+ before_script:
+ # Change directory to Go directory
+ - cd ./Go/
+ # Build script
+ script:
+ # Build the Docker images using Docker Compose
+ - docker compose build
+
+# Test stage
+Test:
+ stage: Test
+ # Before script actions
+ before_script:
+ # Change directory to Go directory
+ - cd ./Go/
+ # Install required packages for testing
+ - apk add --no-cache curl bash
+ # Download secure files
+ - curl --silent "https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/download-secure-files/-/raw/main/installer" | bash > /dev/null 2>&1
+ # Test script
+ script:
+ # Start globeboard-test service and exit with the test result
+ - docker compose up globeboard-test --exit-code-from globeboard-test
+ # Copy the test report from the container to the host
+ - docker compose cp globeboard-test:/root/report.xml ./report.xml
+ # After script actions
+ after_script:
+ # Change directory to Go directory
+ - cd ./Go/
+ # Stop the globeboard-test service
+ - docker compose down globeboard-test
+ # Coverage regex
+ coverage: '/coverage:\s+(\d+\.\d+)%\s+of statements/'
+ # Define artifacts to be stored
+ artifacts:
+ # Define when to store the artifacts
+ when: always
+ # Define paths of the artifacts
+ paths:
+ - ./Go/report.xml
+ # Define test reports
+ reports:
+ junit: ./Go/report.xml
+
+# Deploy stage
+Deploy:
+ stage: Deploy
+ # Before script actions
+ before_script:
+ # Change directory to Go directory
+ - cd ./Go/
+ # Shut down all services
+ - docker compose down
+ # Install required packages for deployment
+ - apk add --no-cache curl bash
+ # Download secure files
+ - curl --silent "https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/download-secure-files/-/raw/main/installer" | bash > /dev/null 2>&1
+ # Deploy script
+ script:
+ # Start the globeboard service in detached mode
+ - docker compose up globeboard -d
+ # After script actions
+ after_script:
+ # Display running Docker containers
+ - docker ps
+ # Define when to trigger the deployment stage
+ only:
+ - main
\ No newline at end of file
diff --git a/readme/conduct.md b/CODE_OF_CONDUCT.md
similarity index 100%
rename from readme/conduct.md
rename to CODE_OF_CONDUCT.md
diff --git a/readme/contribute.md b/CONTRIBUTING.md
similarity index 88%
rename from readme/contribute.md
rename to CONTRIBUTING.md
index 75504e986b81c6fc4cc2bf6344c38168f546519d..16c39e8418f42fa610aa7ee86215cd090027e226 100644
--- a/readme/contribute.md
+++ b/CONTRIBUTING.md
@@ -12,7 +12,7 @@ Before contributing, please read and adhere to our Code of Conduct. We expect al
- Push your changes to your forked repository.
- Submit a pull request to the original repository, explaining your changes and why they should be included.
-Please note that we will only accept contributions that are consistent with the project purpose and goals. Additionally, any contributions must follow the code of conduct outlined in the [`conduct.md`](conduct.md) file.
+Please note that we will only accept contributions that are consistent with the project purpose and goals. Additionally, any contributions must follow the code of conduct outlined in the [`conduct.md`](CODE_OF_CONDUCT.md) file.
## Bug Reports and Feature Requests
If you encounter any issues or have ideas for improvements, please open an issue. Be sure to include a clear and concise description of the problem or feature request, steps to reproduce (if applicable), and any relevant screenshots or error messages.
@@ -24,6 +24,6 @@ By contributing to this project, you agree that your contributions will be licen
# Agreement
-By agreeing to this document you agree that you will not distribute, sell, or capitalize on the project.
+By agreeing to this document, you agree that you will not distribute, sell, or capitalize on the project.
By contributing to the project you automatically agree to this document,
-breach of this document will be handled per `Consequences of Unacceptable Behavior` as listed in [`conduct.md`](conduct.md)
\ No newline at end of file
+breach of this document will be handled per `Consequences of Unacceptable Behavior` as listed in [`conduct.md`](CODE_OF_CONDUCT.md)
\ No newline at end of file
diff --git a/Discord_Webhook_Example.jpg b/Discord_Webhook_Example.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..530b50d187325f158ba74380d8bf4e21e94c9a45
Binary files /dev/null and b/Discord_Webhook_Example.jpg differ
diff --git a/GlobeBoard (Openstack).postman_collection.json b/GlobeBoard (Openstack).postman_collection.json
new file mode 100644
index 0000000000000000000000000000000000000000..02f1983e85c198186381a6c25dbf6234393575f0
--- /dev/null
+++ b/GlobeBoard (Openstack).postman_collection.json
@@ -0,0 +1,600 @@
+{
+ "info": {
+ "_postman_id": "8200f1ea-1d74-4172-9b92-cf2aab793249",
+ "name": "GlobeBoard (Openstack)",
+ "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+ "_exporter_id": "33039772"
+ },
+ "item": [
+ {
+ "name": "root",
+ "item": [
+ {
+ "name": "Root (Openstack)",
+ "request": {
+ "method": "GET",
+ "header": [],
+ "url": {
+ "raw": "http://10.212.171.74:8080/",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ ""
+ ]
+ }
+ },
+ "response": []
+ }
+ ]
+ },
+ {
+ "name": "Register",
+ "item": [
+ {
+ "name": "Register User (Openstack)",
+ "request": {
+ "method": "POST",
+ "header": [],
+ "body": {
+ "mode": "urlencoded",
+ "urlencoded": [
+ {
+ "key": "username",
+ "value": "User @ Openstack",
+ "type": "text"
+ },
+ {
+ "key": "email",
+ "value": "User@stud.ntnu.no",
+ "type": "text"
+ },
+ {
+ "key": "password",
+ "value": "321Bananer?!",
+ "type": "text"
+ }
+ ]
+ },
+ "url": {
+ "raw": "http://10.212.171.74:8080/util/v1/user/register",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "util",
+ "v1",
+ "user",
+ "register"
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "Delete User (Localhost)",
+ "request": {
+ "method": "DELETE",
+ "header": [],
+ "url": {
+ "raw": "http://10.212.174.226:8080/util/v1/user/delete/FNkO9jnXieeJdJgWlR1ywZQdn2F3",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "174",
+ "226"
+ ],
+ "port": "8080",
+ "path": [
+ "util",
+ "v1",
+ "user",
+ "delete",
+ "FNkO9jnXieeJdJgWlR1ywZQdn2F3"
+ ]
+ }
+ },
+ "response": []
+ }
+ ]
+ },
+ {
+ "name": "Key",
+ "item": [
+ {
+ "name": "API Key Get (Openstack)",
+ "request": {
+ "method": "GET",
+ "header": [
+ {
+ "key": "Authorization",
+ "value": "A8iAepCGNahMowqbevaoZDLoFTC2",
+ "type": "text"
+ }
+ ],
+ "url": {
+ "raw": "http://10.212.171.74:8080/util/v1/key",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "util",
+ "v1",
+ "key"
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "API Key Delete (Openstack)",
+ "request": {
+ "method": "DELETE",
+ "header": [
+ {
+ "key": "Authorization",
+ "value": "A8iAepCGNahMowqbevaoZDLoFTC2",
+ "type": "text"
+ }
+ ],
+ "url": {
+ "raw": "http://10.212.171.74:8080/util/v1/key?token=sk-jRle0weXUotOITXnVqMRtTRjPvfCFQtb8B6McDi4jaKsXi",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "util",
+ "v1",
+ "key"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-jRle0weXUotOITXnVqMRtTRjPvfCFQtb8B6McDi4jaKsXi"
+ }
+ ]
+ }
+ },
+ "response": []
+ }
+ ]
+ },
+ {
+ "name": "Registrations",
+ "item": [
+ {
+ "name": "Registration Post (Openstack)",
+ "request": {
+ "method": "POST",
+ "header": [],
+ "body": {
+ "mode": "raw",
+ "raw": "{\r\n \"country\": \"Norway\",\r\n \"isoCode\": \"NO\",\r\n \"features\": {\r\n \"temperature\": true, // this value is to be changed\r\n \"precipitation\": true,\r\n \"capital\": true,\r\n \"coordinates\": true, \r\n \"population\": true,\r\n \"area\": true,\r\n \"targetCurrencies\": [\"EUR\", \"SEK\"] // this value is to be changed\r\n }\r\n}\r\n",
+ "options": {
+ "raw": {
+ "language": "json"
+ }
+ }
+ },
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/registrations?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "registrations"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "Registration Get All (Openstack)",
+ "protocolProfileBehavior": {
+ "disableBodyPruning": true
+ },
+ "request": {
+ "method": "GET",
+ "header": [],
+ "body": {
+ "mode": "raw",
+ "raw": "",
+ "options": {
+ "raw": {
+ "language": "json"
+ }
+ }
+ },
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/registrations?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "registrations"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "Registration Get specific (Openstack)",
+ "protocolProfileBehavior": {
+ "disableBodyPruning": true
+ },
+ "request": {
+ "method": "GET",
+ "header": [],
+ "body": {
+ "mode": "raw",
+ "raw": "",
+ "options": {
+ "raw": {
+ "language": "json"
+ }
+ }
+ },
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/registrations/XsdB3SfQMMT6zRQYbeuF?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "registrations",
+ "XsdB3SfQMMT6zRQYbeuF"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "Registration Patch (Openstack)",
+ "request": {
+ "method": "PATCH",
+ "header": [],
+ "body": {
+ "mode": "raw",
+ "raw": "{\r\n \"features\": {\r\n \"targetCurrencies\": [\"EUR\", \"SEK\", \"EUR\", \"USD\", \"JPY\"]\r\n }\r\n}",
+ "options": {
+ "raw": {
+ "language": "json"
+ }
+ }
+ },
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/registrations/XsdB3SfQMMT6zRQYbeuF?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "registrations",
+ "XsdB3SfQMMT6zRQYbeuF"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "Registration Delete (Openstack)",
+ "request": {
+ "method": "DELETE",
+ "header": [],
+ "body": {
+ "mode": "raw",
+ "raw": "",
+ "options": {
+ "raw": {
+ "language": "json"
+ }
+ }
+ },
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/registrations/XsdB3SfQMMT6zRQYbeuF?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "registrations",
+ "XsdB3SfQMMT6zRQYbeuF"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ }
+ ]
+ },
+ {
+ "name": "Dashboard",
+ "item": [
+ {
+ "name": "Dashboard Get (Openstack)",
+ "request": {
+ "method": "GET",
+ "header": [],
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/dashboard/XsdB3SfQMMT6zRQYbeuF?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "dashboard",
+ "XsdB3SfQMMT6zRQYbeuF"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ }
+ ]
+ },
+ {
+ "name": "Notifications",
+ "item": [
+ {
+ "name": "Notifications Get Specific (Openstack)",
+ "request": {
+ "method": "GET",
+ "header": [],
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/notifications/D5rF04PkyCgY0dppjzAY?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "notifications",
+ "D5rF04PkyCgY0dppjzAY"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "Notifications Delete (Openstack)",
+ "request": {
+ "method": "DELETE",
+ "header": [],
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/notifications/D5rF04PkyCgY0dppjzAY?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "notifications",
+ "D5rF04PkyCgY0dppjzAY"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "Notifications Get All (Openstack)",
+ "request": {
+ "method": "GET",
+ "header": [],
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/notifications?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "notifications"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ },
+ {
+ "name": "Notifications Post (Openstack)",
+ "request": {
+ "method": "POST",
+ "header": [],
+ "body": {
+ "mode": "raw",
+ "raw": "{\r\n \"url\": \"webhook.com/\",\r\n \"country\": \"\",\r\n \"event\": [\"INVOKE\"]\r\n}\r\n",
+ "options": {
+ "raw": {
+ "language": "json"
+ }
+ }
+ },
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/notifications?token=sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "notifications"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-7nitVmcWVrpvHYvcrmC0tTRjPvlb19wKBCynx5ZQ6lemrg"
+ }
+ ]
+ }
+ },
+ "response": []
+ }
+ ]
+ },
+ {
+ "name": "Status",
+ "item": [
+ {
+ "name": "Status (Openstack)",
+ "request": {
+ "method": "GET",
+ "header": [],
+ "url": {
+ "raw": "http://10.212.171.74:8080/dashboards/v1/status?token=sk-owVa9zHyH5U23Kj5mhAStTRjPvitfmC4nAXWRutxOpVaUE",
+ "protocol": "http",
+ "host": [
+ "10",
+ "212",
+ "171",
+ "74"
+ ],
+ "port": "8080",
+ "path": [
+ "dashboards",
+ "v1",
+ "status"
+ ],
+ "query": [
+ {
+ "key": "token",
+ "value": "sk-owVa9zHyH5U23Kj5mhAStTRjPvitfmC4nAXWRutxOpVaUE"
+ }
+ ]
+ }
+ },
+ "response": []
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Go/.dockerignore b/Go/.dockerignore
index 9b2b66851ab8e85967613e7e989357eb76a9afdd..002b2a5c46c9cc387b754b2a1efb318cd39a4784 100644
--- a/Go/.dockerignore
+++ b/Go/.dockerignore
@@ -88,7 +88,7 @@ ehthumbs.db
Thumbs.db
# Personal ignore patterns
-**/firebasecredentials.json
+**/firebaseCredentials.json
**/.secrets
.env
diff --git a/Go/.env.example b/Go/.env.example
index 056673cb7b779a73ad5f5b323bec63dfdf18836b..abdfc6f580a14e70f43a457ba491410702faa7c4 100644
--- a/Go/.env.example
+++ b/Go/.env.example
@@ -1,2 +1,10 @@
+# Configuration file (.env) for setting environment variables
+
+# Port number for the HTTP server
PORT=8080
-TOKEN=your_api_token #For Testing
+
+# Path to the Firebase credentials file
+FIREBASE_CREDENTIALS_FILE=./super_secret_folder/database_file.json
+
+# Firebase project ID for Firestore
+FIRESTORE_PROJECT_ID=firestore_project_1
diff --git a/Go/Dockerfile b/Go/Dockerfile
index 93d3706b30186f579ecb3a4a8f7446eeab5fbd81..15bfd86da988ff3573e284d1b2a7ed771ee152e7 100644
--- a/Go/Dockerfile
+++ b/Go/Dockerfile
@@ -1,37 +1,38 @@
# syntax=docker/dockerfile:1.2
+
+# Define the base image and setup build environment
FROM golang:1.22 AS builder
-# Set destination for COPY
+# Define Authors
+LABEL authors="Torgrim Thorsen"
+
+# Set the working directory
WORKDIR /app
-# Download Go modules
+# Copy go modules for dependencies
COPY go.mod go.sum ./
-RUN go mod download
-
# Copy the source code.
COPY ../ ./
-# Build
+# Build the application
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main ./cmd/globeboard
-# Use a minimal alpine image for the final build stage.
+# Use a minimal alpine image for the final build stage
FROM alpine:3.19
-# Install CA certificates.
+# Install CA certificates
RUN apk --no-cache add ca-certificates
+# Set the working directory
WORKDIR /root/
-# Copy the pre-built binary file from the previous stage.
+# Copy the pre-built binary file from the previous stage
COPY --from=builder /app/main .
-# Optional:
-# To bind to a TCP port, runtime parameters must be supplied to the docker command.
-# But we can document in the Dockerfile what ports
-# the application is going to listen on by default.
-# https://docs.docker.com/reference/dockerfile/#expose
+# Expose the port on which the application will listen
+# Note: This does not publish the port, but documents that the container will listen on this port
EXPOSE 8080
-# Run
+# Define the command to run the application
CMD ["./main"]
\ No newline at end of file
diff --git a/Go/Dockerfile-test b/Go/Dockerfile-test
index 72d70e4bf34660d3e5707773b37326a4c166af84..9b357aa01b9393fe0b619385679473513224f399 100644
--- a/Go/Dockerfile-test
+++ b/Go/Dockerfile-test
@@ -1,17 +1,37 @@
-# Use the official Golang image as a parent image
-FROM golang:1.22
+# syntax=docker/dockerfile:1.2
-# Set the working directory inside the container
+# Define the base image and setup build environment
+FROM golang:1.22 AS builder
+
+# Define Authors
+LABEL authors="Torgrim Thorsen"
+
+# Set the working directory
WORKDIR /app
-# Download Go modules
+# Copy go modules for dependencies
COPY go.mod go.sum ./
-# Download Go module dependencies
-RUN go mod download
-
-# Copy the rest of the service's source code
+# Copy the source code
COPY ../ ./
-# Specify the command to run tests
-CMD ["go", "test", "./..."]
+# Build the test binary
+RUN CGO_ENABLED=0 GOOS=linux go test -cover -coverpkg=./... -c -installsuffix cgo -o test ./cmd/globeboard
+
+# Use a minimal alpine image for the final build stage
+FROM golang:1.22-alpine
+
+# Install CA certificates and Go
+RUN apk --no-cache add ca-certificates
+
+# Install Go JUnit report tool
+RUN go install github.com/jstemmer/go-junit-report/v2@latest
+
+# Set the working directory
+WORKDIR /root/
+
+# Copy the pre-built test binary from the previous stage
+COPY --from=builder /app/test .
+
+# Define the command to run the tests and generate JUnit report
+CMD ./test -test.v | go-junit-report > report.xml && ./test -test.v
\ No newline at end of file
diff --git a/Go/auth/auth.go b/Go/auth/auth.go
index 654f74d3deae6132d48cd1c66dbfcc8b8c61062c..0288afa3410f05fed2c9cfd2cabc53ae0ffd9d36 100644
--- a/Go/auth/auth.go
+++ b/Go/auth/auth.go
@@ -1,37 +1,33 @@
+// Package authenticate provides functionality for initializing and accessing Firebase Authentication.
package authenticate
import (
"context"
firebase "firebase.google.com/go"
"firebase.google.com/go/auth"
- "globeboard/internal/utils/constants"
"google.golang.org/api/option"
"log"
+ "os"
)
var (
- // Use a context for Firebase operations
- ctx = context.Background()
+ ctx = context.Background() // Background context for Firebase operations
+ Client *auth.Client // Singleton Firebase Authentication client
)
-func GetFireBaseAuthClient() (*auth.Client, error) {
- // Using the credential file
- sa := option.WithCredentialsFile(constants.FirebaseCredentialPath)
+func init() {
+ // Load Firebase service account credentials from environment variable
+ sa := option.WithCredentialsFile(os.Getenv("FIREBASE_CREDENTIALS_FILE"))
+
+ // Initialize Firebase app with the loaded credentials
app, err := firebase.NewApp(ctx, nil, sa)
if err != nil {
- log.Println("Credentials not found: " + constants.FirebaseCredentialPath)
- log.Println("Error on getting the application")
- return nil, err
+ log.Panic("Firebase Failed to initialize: ", err)
}
- //No initial error, so a client is used to gather other information
- client, err := app.Auth(ctx)
+ // Initialize the Firebase Authentication client
+ Client, err = app.Auth(ctx)
if err != nil {
- // Logging the error
- log.Println("Credentials file: '" + constants.FirebaseCredentialPath + "' lead to an error.")
- return nil, err
+ log.Panic("Firebase Failed to initialize Authentication client: ", err)
}
-
- // No errors, so we return the test client and no error
- return client, nil
}
diff --git a/Go/cmd/globeboard/app.go b/Go/cmd/globeboard/app.go
index cc5934ef096b7cf09f18edd38b7b24ed631bf883..498d2d4f85ecab3ccb00ac6e575e65f7c127b016 100644
--- a/Go/cmd/globeboard/app.go
+++ b/Go/cmd/globeboard/app.go
@@ -1,10 +1,11 @@
+// Package main is the entry point for the application.
package main
import (
+ "globeboard/db"
"globeboard/internal/handlers"
"globeboard/internal/handlers/endpoint/dashboard"
"globeboard/internal/handlers/endpoint/util"
- "globeboard/internal/utils/constants"
"globeboard/internal/utils/constants/Endpoints"
"globeboard/internal/utils/constants/Paths"
"log"
@@ -12,8 +13,7 @@ import (
"os"
)
-// fileExists checks if a file exists and is not a directory before we
-// try using it to prevent further errors.
+// fileExists checks if a file exists, and is not a directory.
func fileExists(filename string) bool {
info, err := os.Stat(filename)
if os.IsNotExist(err) {
@@ -23,10 +23,16 @@ func fileExists(filename string) bool {
}
func main() {
- if !fileExists(constants.FirebaseCredentialPath) {
- log.Fatal("Firebase Credentials file is not mounted")
- return
+ // Confirm that the Firebase Credentials file is accessible, if not, panic.
+ if !fileExists(os.Getenv("FIREBASE_CREDENTIALS_FILE")) {
+ log.Panic("Firebase Credentials file is not mounted")
}
+ defer func() {
+ // Close the Firestore client connection on application exit
+ if err := db.Client.Close(); err != nil {
+ log.Printf("Error closing Firestore client: %v", err)
+ }
+ }()
// Get the port from the environment variable or set default to 8080
port := os.Getenv("PORT")
@@ -37,15 +43,16 @@ func main() {
// Define HTTP endpoints
mux := http.NewServeMux()
- mux.HandleFunc(Paths.Root, handlers.EmptyHandler)
- mux.HandleFunc(Endpoints.UserRegistration, util.UserRegistrationHandler)
- mux.HandleFunc(Endpoints.ApiKey, util.APIKeyHandler)
- mux.HandleFunc(Endpoints.RegistrationsID, dashboard.RegistrationsIdHandler)
- mux.HandleFunc(Endpoints.Registrations, dashboard.RegistrationsHandler)
- mux.HandleFunc(Endpoints.Dashboards, dashboard.DashboardsHandler)
- mux.HandleFunc(Endpoints.NotificationsID, dashboard.NotificationsHandler)
- mux.HandleFunc(Endpoints.Notifications, dashboard.NotificationsHandler)
- mux.HandleFunc(Endpoints.Status, dashboard.StatusHandler)
+ mux.HandleFunc(Paths.Root, handlers.EmptyHandler) // Root endpoint
+ mux.HandleFunc(Endpoints.UserRegistration, util.UserRegistrationHandler) // User registration endpoint
+ mux.HandleFunc(Endpoints.UserDeletionID, util.UserDeletionHandler) // User deletion endpoint
+ mux.HandleFunc(Endpoints.ApiKey, util.APIKeyHandler) // API key endpoint
+ mux.HandleFunc(Endpoints.RegistrationsID, dashboard.RegistrationsIdHandler) // Registrations by ID endpoint
+ mux.HandleFunc(Endpoints.Registrations, dashboard.RegistrationsHandler) // Registrations endpoint
+ mux.HandleFunc(Endpoints.DashboardsID, dashboard.DashboardsIdHandler) // Dashboards by ID endpoint
+ mux.HandleFunc(Endpoints.NotificationsID, dashboard.NotificationsIdHandler) // Notifications by ID endpoint
+ mux.HandleFunc(Endpoints.Notifications, dashboard.NotificationsHandler) // Notifications endpoint
+ mux.HandleFunc(Endpoints.Status, dashboard.StatusHandler) // Status endpoint
// Start the HTTP server
log.Println("Starting server on port " + port + " ...")
diff --git a/Go/cmd/globeboard/app_test.go b/Go/cmd/globeboard/app_test.go
index f509c8beae63bda63f261e3c8230f59353fec233..aee5b2f29134cc3e8c0cce05c37e5e14763f59de 100644
--- a/Go/cmd/globeboard/app_test.go
+++ b/Go/cmd/globeboard/app_test.go
@@ -1,670 +1,2085 @@
package main
import (
+ "bytes"
+ "encoding/json"
+ "fmt"
"globeboard/internal/handlers"
"globeboard/internal/handlers/endpoint/dashboard"
+ "globeboard/internal/handlers/endpoint/util"
"globeboard/internal/utils/constants/Endpoints"
"globeboard/internal/utils/constants/Paths"
+ "log"
"net/http"
"net/http/httptest"
+ "net/url"
"os"
+ "strings"
"testing"
)
-var token = os.Getenv("TOKEN")
+const (
+ DisplayName = "Tester Testing"
+ Email = "Tester@Testing.test"
+ Password = "TestTesting123?!"
+)
+
+var (
+ mux = http.NewServeMux()
+ wrongToken = "bhuiozdfbbjkwsrbnjlsfbjnklsdv" //Keyboard Mash
+ token = "sk-token-brrr-access"
+ UUID = "me_me_me_me"
+ docId1 = "420"
+ docId2 = "420"
+ webhookId1 = "69"
+ webhookId2 = "69"
+)
+
+func fileExistsTest(filename string) bool {
+ info, err := os.Stat(filename)
+ if os.IsNotExist(err) {
+ return false
+ }
+ return !info.IsDir()
+}
+
+func init() {
+ if !fileExistsTest(os.Getenv("FIREBASE_CREDENTIALS_FILE")) {
+ log.Panic("Firebase Credentials file is not mounted: ", os.Getenv("FIREBASE_CREDENTIALS_FILE"))
+ }
-// TestLibraryGet confirms that the Root Endpoint returns Status I'm a Teapot for All Request.
+ mux.HandleFunc(Paths.Root, handlers.EmptyHandler)
+ mux.HandleFunc(Endpoints.UserRegistration, util.UserRegistrationHandler)
+ mux.HandleFunc(Endpoints.UserDeletionID, util.UserDeletionHandler)
+ mux.HandleFunc(Endpoints.ApiKey, util.APIKeyHandler)
+ mux.HandleFunc(Endpoints.RegistrationsID, dashboard.RegistrationsIdHandler)
+ mux.HandleFunc(Endpoints.Registrations, dashboard.RegistrationsHandler)
+ mux.HandleFunc(Endpoints.DashboardsID, dashboard.DashboardsIdHandler)
+ mux.HandleFunc(Endpoints.NotificationsID, dashboard.NotificationsIdHandler)
+ mux.HandleFunc(Endpoints.Notifications, dashboard.NotificationsHandler)
+ mux.HandleFunc(Endpoints.Status, dashboard.StatusHandler)
+
+}
+
+/* Test Root Once */
+
+// TestRoot confirms that Root Endpoint returns 303 See Other for All Requests.
func TestRoot(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Paths.Root, nil)
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodGet, Paths.Root, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
- rr := httptest.NewRecorder()
- handler := http.HandlerFunc(handlers.EmptyHandler)
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusSeeOther {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusSeeOther)
+ }
+
+ req, err = http.NewRequest(http.MethodPost, Paths.Root, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusSeeOther {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusSeeOther)
+ }
+
+ req, err = http.NewRequest(http.MethodPut, Paths.Root, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusTeapot {
+ if status := rr.Code; status != http.StatusSeeOther {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusTeapot)
+ status, http.StatusSeeOther)
}
- req, err = http.NewRequest("POST", Paths.Root, nil)
+ req, err = http.NewRequest(http.MethodPatch, Paths.Root, nil)
if err != nil {
t.Fatal(err)
}
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusTeapot {
+ if status := rr.Code; status != http.StatusSeeOther {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusTeapot)
+ status, http.StatusSeeOther)
}
- req, err = http.NewRequest("PUT", Paths.Root, nil)
+ req, err = http.NewRequest(http.MethodDelete, Paths.Root, nil)
if err != nil {
t.Fatal(err)
}
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusTeapot {
+ if status := rr.Code; status != http.StatusSeeOther {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusTeapot)
+ status, http.StatusSeeOther)
}
}
-// TestBookCountGetLanguage confirms that the Bookcount Endpoint returns Status Bas Request for Get Request without language param.
-func TestBookCountGet(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Dashboards, nil)
+/* Run tests as intended */
+
+func TestRegisterHandlerRegister(t *testing.T) {
+ form := url.Values{}
+ form.Add("username", DisplayName)
+ form.Add("email", Email)
+ form.Add("password", Password)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.UserRegistration, strings.NewReader(form.Encode()))
if err != nil {
t.Fatal(err)
}
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusCreated {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusCreated)
+ }
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+ var response struct {
+ Token string `json:"token"`
+ UserID string `json:"userid"`
}
+
+ if err := json.NewDecoder(rr.Body).Decode(&response); err != nil {
+ t.Fatal("Failed to decode response body:", err)
+ }
+
+ token = response.Token
+ UUID = response.UserID
}
-// TestBookCountGetWrongKey confirms that the Bookcount Endpoint returns Status Not Accepted for GET Method with incorrect token.
-func TestBookCountGetWrongKey(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Dashboards+"?token=c35c5742", nil)
+func TestDeleteAPIKeyHandler(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.ApiKey+"?token="+token, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
- rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ req.Header.Add("Authorization", UUID)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusNotAcceptable {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotAcceptable)
+ if status := rr.Code; status != http.StatusNoContent {
+ t.Errorf("DELETE handler returned wrong status code: got %v want %v", status, http.StatusNoContent)
}
}
-// TestBookCountGetLanguageNoKey confirms that the Bookcount Endpoint returns Status Bad Request for Get Request without api key.
-func TestBookCountGetLanguageNoKey(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Dashboards+"?languages=no", nil)
+func TestGetAPIKeyHandler(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.ApiKey, nil)
if err != nil {
t.Fatal(err)
}
+ req.Header.Add("Authorization", UUID)
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusCreated {
+ t.Errorf("GET handler returned wrong status code: got %v want %v", status, http.StatusCreated)
+ }
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+ var response struct {
+ APIKey string `json:"token"`
}
+ if err := json.NewDecoder(rr.Body).Decode(&response); err != nil {
+ t.Fatal("Failed to decode response body:", err)
+ }
+
+ token = response.APIKey
}
-// TestBookCountGetLanguage confirms that the Bookcount Endpoint returns Status OK for Get Request with language param.
-func TestBookCountGetLanguage(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Dashboards+"?token="+token+"&languages=no", nil)
+func TestStatusGet(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Status+"?token="+token, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
-
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ mux.ServeHTTP(rr, req)
- // Check the status code
if status := rr.Code; status != http.StatusOK {
t.Errorf("handler returned wrong status code: got %v want %v",
status, http.StatusOK)
}
}
-// TestBookCountGetLanguageWrong confirms that the Bookcount Endpoint returns Status Bad Request for Get Request with wrongful language param.
-func TestBookCountGetLanguageWrong(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Dashboards+"?token="+token+"&languages=nog", nil)
+func TestNotificationsHandlerPostDiscord(t *testing.T) {
+ notificationData := []byte(`{
+ "url": "https://discord.com",
+ "country": "",
+ "event": ["INVOKE","REGISTER","CHANGE","DELETE"]
+ }`)
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Notifications+"?token="+token, bytes.NewBuffer(notificationData))
if err != nil {
t.Fatal(err)
}
+ req.Header.Set("Content-Type", "application/json")
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusCreated {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusCreated)
+ }
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+ var response struct {
+ ID string `json:"id"`
}
+
+ if err := json.NewDecoder(rr.Body).Decode(&response); err != nil {
+ t.Fatal("Failed to decode response body:", err)
+ }
+
+ webhookId1 = response.ID
}
-// TestBookCountGetLanguages confirms that the Bookcount Endpoint returns Status OK for Get Request with multiple language param.
-func TestBookCountGetLanguages(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Dashboards+"?token="+token+"&languages=no,es", nil)
+func TestNotificationsHandlerPost(t *testing.T) {
+ notificationData := []byte(`{
+ "url": "https://google.com/",
+ "country": "",
+ "event": ["INVOKE","DELETE"]
+ }`)
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Notifications+"?token="+token, bytes.NewBuffer(notificationData))
if err != nil {
t.Fatal(err)
}
+ req.Header.Set("Content-Type", "application/json")
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusCreated {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusCreated)
+ }
- // Check the status code
- if status := rr.Code; status != http.StatusOK {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusOK)
+ var response struct {
+ ID string `json:"id"`
+ }
+
+ if err := json.NewDecoder(rr.Body).Decode(&response); err != nil {
+ t.Fatal("Failed to decode response body:", err)
}
+
+ webhookId2 = response.ID
}
-// TestBookCountGetLanguagesWrong confirms that the Bookcount Endpoint returns Status Bad Request for Get Request with same language param.
-func TestBookCountGetLanguagesWrong(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Dashboards+"?token="+token+"&languages=no,no", nil)
+func TestNotificationsHandlerIdGet(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications+"/"+webhookId1+"?token="+token, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
+ }
+}
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+func TestNotificationsHandlerGet(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
}
}
-// TestBookcountMethodNotAllowed confirms that the Bookcount Endpoint returns Status Not Implemented for Methods other than GET.
-func TestBookcountMethodNotAllowed(t *testing.T) {
- // Create a request to your endpoint with a method other than GET
- req, err := http.NewRequest("POST", Endpoints.Dashboards, nil)
+func TestRegistrationsHandlerPost(t *testing.T) {
+ registrationData := []byte(`{
+ "isocode": "us",
+ "features": {
+ "temperature": true,
+ "coordinates": true
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+token, bytes.NewBuffer(registrationData))
if err != nil {
t.Fatal(err)
}
+ req.Header.Set("Content-Type", "application/json")
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusCreated {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusCreated)
+ }
- // Check the status code
- if status := rr.Code; status != http.StatusNotImplemented {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotImplemented)
+ var response struct {
+ ID string `json:"id"`
+ LastChange string `json:"lastChange"`
}
- req, err = http.NewRequest("PUT", Endpoints.Dashboards, nil)
+ if err := json.NewDecoder(rr.Body).Decode(&response); err != nil {
+ t.Fatal("Failed to decode response body:", err)
+ }
+
+ docId1 = response.ID
+}
+
+func TestRegistrationsHandlerPostMinimal(t *testing.T) {
+ registrationData := []byte(`{
+ "country": "norway",
+ "features": {
+ "temperature": true
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+token, bytes.NewBuffer(registrationData))
if err != nil {
t.Fatal(err)
}
+ req.Header.Set("Content-Type", "application/json")
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusNotImplemented {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotImplemented)
+ if status := rr.Code; status != http.StatusCreated {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusCreated)
+ }
+
+ var response struct {
+ ID string `json:"id"`
+ LastChange string `json:"lastChange"`
+ }
+
+ if err := json.NewDecoder(rr.Body).Decode(&response); err != nil {
+ t.Fatal("Failed to decode response body:", err)
}
+
+ docId2 = response.ID
}
-// TestReadershipGet confirms that the Notifications Endpoint returns Status Bas Request for Get Request without language param.
-func TestReadershipGet(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Notifications+"?token="+token+"", nil)
+func TestRegistrationsHandlerGet(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Registrations+"?token="+token, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.NotificationsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
+ }
+}
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+func TestRegistrationsIdHandlerPatch(t *testing.T) {
+ patchData := []byte(`{
+ "features": {
+ "temperature": true,
+ "precipitation": true,
+ "capital": true,
+ "coordinates": true,
+ "population": true,
+ "area": true,
+ "targetCurrencies": ["jpy", "nok", "eur","gbp"]
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusAccepted {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusAccepted)
}
}
-// TestSupportedLanguagesGetWrongKey confirms that the Notifications Endpoint returns Status Not Accepted for GET Method with incorrect token.
-func TestReadershipGetWrongKey(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Notifications+"?token=c35c5742", nil)
+func TestRegistrationsIdHandlerGet(t *testing.T) {
+ testUrl := fmt.Sprintf("%s/%s?token=%s", Endpoints.Registrations, docId1, token)
+ req, err := http.NewRequest(http.MethodGet, testUrl, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
+ }
+}
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+func TestDashboardIdHandlerGet(t *testing.T) {
+ testUrl := fmt.Sprintf("%s/%s?token=%s", Endpoints.Dashboards, docId1, token)
+ req, err := http.NewRequest(http.MethodGet, testUrl, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
- // Check the status code
- if status := rr.Code; status != http.StatusNotAcceptable {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotAcceptable)
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
}
}
-// TestReadershipGetLanguageNoKey confirms that the Notifications Endpoint returns Status Bad Request for Get Request without API Token.
-func TestReadershipGetLanguageNoKey(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Notifications+"no", nil)
+func TestDashboardIdHandlerGetMinimal(t *testing.T) {
+ testUrl := fmt.Sprintf("%s/%s?token=%s", Endpoints.Dashboards, docId2, token)
+ req, err := http.NewRequest(http.MethodGet, testUrl, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.NotificationsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
+ }
+}
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
- t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+func TestRegistrationsIdHandlerDeleteMinimal(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Registrations+"/"+docId2+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNoContent {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusNoContent)
}
}
-// TestReadershipGetLanguage confirms that the Notifications Endpoint returns Status OK for Get Request with language param.
-func TestReadershipGetLanguage(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Notifications+"no/?token="+token+"", nil)
+/* Run test with wrong token */
+
+func TestDeleteAPIKeyHandlerWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.ApiKey+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
+ req.Header.Add("Authorization", UUID)
+
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.NotificationsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusInternalServerError {
+ t.Errorf("DELETE handler returned wrong status code: got %v want %v", status, http.StatusInternalServerError)
+ }
+}
- // Check the status code
- if status := rr.Code; status != http.StatusOK {
+func TestStatusGetWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Status+"?token="+wrongToken, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusOK)
+ status, http.StatusNotAcceptable)
}
}
-// TestReadershipGetWrong confirms that the Notifications Endpoint returns Status Bad Request for Get Request with wrongful language param.
-func TestReadershipGetWrong(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Notifications+"nog/?token="+token+"", nil)
+func TestRegistrationsPostWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.NotificationsHandler)
-
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+ status, http.StatusNotAcceptable)
}
}
-// TestReadershipGetLanguages confirms that the Notifications Endpoint returns Status Bad Request for Get Request with multiple language param.
-func TestReadershipGetLanguages(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Notifications+"no,es/?token="+token+"", nil)
+func TestRegistrationsGetWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Registrations+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.NotificationsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
-
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+ status, http.StatusNotAcceptable)
}
}
-// TestReadershipGetLimit confirms that the Notifications Endpoint returns Status OK for Get Request with limit param.
-func TestReadershipGetLimit(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Notifications+"no/?token="+token+"&limit=1", nil)
+func TestRegistrationsGetIdWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Registrations+"/"+docId1+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.NotificationsHandler)
-
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusOK {
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusOK)
+ status, http.StatusNotAcceptable)
}
}
-// TestReadershipGetLimitWrong confirms that the Notifications Endpoint returns Status Bad Request for Get Request with wrongful limit param.
-func TestReadershipGetLimitWrong(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Notifications+"no/?token="+token+"&limit=one", nil)
+func TestRegistrationsPatchIdWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.NotificationsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
-
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+ status, http.StatusNotAcceptable)
}
}
-// TestReadershipMethodNotAllowed confirms that the Notifications Endpoint returns Status Not Implemented for Methods other than GET.
-func TestReadershipMethodNotAllowed(t *testing.T) {
- // Create a request to your endpoint with a method other than GET
- req, err := http.NewRequest("POST", Endpoints.Notifications, nil)
+func TestRegistrationsDeleteIdWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Registrations+"/"+docId1+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.NotificationsHandler)
-
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusNotImplemented {
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotImplemented)
+ status, http.StatusNotAcceptable)
}
+}
- req, err = http.NewRequest("PUT", Endpoints.Notifications, nil)
+func TestDashboardGetIdWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Dashboards+"/"+docId1+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusNotImplemented {
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotImplemented)
+ status, http.StatusNotAcceptable)
}
}
-// TestStatusGetNoKey confirms that the Status Endpoint returns Status Bad Request for GET Method without API token.
-func TestStatusGetNoKey(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Status, nil)
+func TestNotificationsPostWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Notifications+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.StatusHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
-
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+ status, http.StatusNotAcceptable)
}
}
-// TestStatusGet confirms that the Status Endpoint returns Status OK for GET Method.
-func TestStatusGet(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Status+"?token="+token+"", nil)
+func TestNotificationsGetWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.StatusHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
-
- // Check the status code
- if status := rr.Code; status != http.StatusOK {
+ if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusOK)
+ status, http.StatusNotAcceptable)
}
}
-// TestStatusGetWrongKey confirms that the Status Endpoint returns Status Not Accepted for GET Method with incorrect token.
-func TestStatusGetWrongKey(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.Status+"?token=c35c5742", nil)
+func TestNotificationsGetIdWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications+"/"+webhookId1+"?token="+wrongToken, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.DashboardsHandler)
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotAcceptable {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotAcceptable)
+ }
+}
+
+func TestNotificationsDeleteIdWrongToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Notifications+"/"+webhookId1+"?token="+wrongToken, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
- // Check the status code
if status := rr.Code; status != http.StatusNotAcceptable {
t.Errorf("handler returned wrong status code: got %v want %v",
status, http.StatusNotAcceptable)
}
}
-// TestStatusMethodNotAllowed confirms that the Status Endpoint returns Status Not Implemented for Methods other than GET.
-func TestStatusMethodNotAllowed(t *testing.T) {
- // Create a request to your endpoint with a method other than GET
- req, err := http.NewRequest("POST", Endpoints.Status, nil)
+/* Run tests without a token */
+
+func TestDeleteAPIKeyHandlerNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.ApiKey, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
+ req.Header.Add("Authorization", UUID)
+
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.StatusHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("DELETE handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
- // Check the status code
- if status := rr.Code; status != http.StatusNotImplemented {
+func TestStatusGetNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Status, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusUnauthorized {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotImplemented)
+ status, http.StatusUnauthorized)
}
+}
- req, err = http.NewRequest("PUT", Endpoints.Status, nil)
+func TestRegistrationsPostNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations, nil)
if err != nil {
t.Fatal(err)
}
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusNotImplemented {
+ if status := rr.Code; status != http.StatusUnauthorized {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotImplemented)
+ status, http.StatusUnauthorized)
}
}
-// TestSupportedLanguagesGetNoKey confirms that the Supported Languages Endpoint returns Status Bad Requests for GET Method without API token.
-func TestSupportedLanguagesGetNoKey(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.RegistrationsID, nil)
+func TestRegistrationsGetNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Registrations, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.RegistrationsHandler)
-
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusBadRequest {
+ if status := rr.Code; status != http.StatusUnauthorized {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusBadRequest)
+ status, http.StatusUnauthorized)
}
}
-// TestSupportedLanguagesGet confirms that the Supported Languages Endpoint returns Status OK for GET Method.
-func TestSupportedLanguagesGet(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.RegistrationsID+"?token="+token+"", nil)
+func TestRegistrationsGetIdNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Registrations+"/"+docId1, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.RegistrationsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
-
- // Check the status code
- if status := rr.Code; status != http.StatusOK {
+ if status := rr.Code; status != http.StatusUnauthorized {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusOK)
+ status, http.StatusUnauthorized)
}
}
-// TestSupportedLanguagesGetWrongKey confirms that the Supported Languages Endpoint returns Status Not Accepted for GET Method with incorrect token.
-func TestSupportedLanguagesGetWrongKey(t *testing.T) {
- // Create a request to your endpoint with the GET method
- req, err := http.NewRequest("GET", Endpoints.RegistrationsID+"?token=c35c5742", nil)
+func TestRegistrationsPatchIdNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.RegistrationsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusUnauthorized {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusUnauthorized)
+ }
+}
- // Check the status code
- if status := rr.Code; status != http.StatusNotAcceptable {
+func TestRegistrationsDeleteIdNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Registrations+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusUnauthorized {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotAcceptable)
+ status, http.StatusUnauthorized)
}
}
-// TestSupportedLanguagesMethodNotAllowed confirms that the Supported Languages Endpoint returns Status Not Implemented for Methods other than GET.
-func TestSupportedLanguagesMethodNotAllowed(t *testing.T) {
- // Create a request to your endpoint with a method other than GET
- req, err := http.NewRequest("POST", Endpoints.RegistrationsID, nil)
+func TestDashboardGetIdNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Dashboards+"/"+docId1, nil)
if err != nil {
t.Fatal(err)
}
- // Create a ResponseRecorder to record the response
rr := httptest.NewRecorder()
- handler := http.HandlerFunc(dashboard.RegistrationsHandler)
+ mux.ServeHTTP(rr, req)
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ if status := rr.Code; status != http.StatusUnauthorized {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusUnauthorized)
+ }
+}
- // Check the status code
- if status := rr.Code; status != http.StatusNotImplemented {
+func TestNotificationsPostNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Notifications, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusUnauthorized {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotImplemented)
+ status, http.StatusUnauthorized)
}
+}
- req, err = http.NewRequest("PUT", Endpoints.RegistrationsID, nil)
+func TestNotificationsGetNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications, nil)
if err != nil {
t.Fatal(err)
}
- // Serve the request to the handler
- handler.ServeHTTP(rr, req)
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
- // Check the status code
- if status := rr.Code; status != http.StatusNotImplemented {
+ if status := rr.Code; status != http.StatusUnauthorized {
t.Errorf("handler returned wrong status code: got %v want %v",
- status, http.StatusNotImplemented)
+ status, http.StatusUnauthorized)
+ }
+}
+
+func TestNotificationsGetIdNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications+"/"+webhookId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusUnauthorized {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusUnauthorized)
+ }
+}
+
+func TestNotificationsDeleteIdNoToken(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Notifications+"/"+webhookId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusUnauthorized {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusUnauthorized)
+ }
+}
+
+/* Empty ID */
+
+func TestRegistrationsGetEmptyId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Registrations+"/?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestRegistrationsPatchEmptyId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestRegistrationsDeleteEmptyId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Registrations+"/?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestDashboardGetEmptyId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Dashboards+"/?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestNotificationsGetEmptyId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications+"/?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestNotificationsDeleteEmptyId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Notifications+"/?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+/* Whitespace ID */
+
+func TestRegistrationsGetWhitespaceId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Registrations+"/%20?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsPatchWhitespaceId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/%20?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsDeleteWhitespaceId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Registrations+"/%20?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusBadRequest)
+ }
+}
+
+func TestDashboardGetWhitespaceId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Dashboards+"/%20?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusBadRequest)
+ }
+}
+
+func TestNotificationsGetWhitespaceId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications+"/%20?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusBadRequest)
+ }
+}
+
+func TestNotificationsDeleteWhitespaceId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Notifications+"/%20?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusBadRequest)
+ }
+}
+
+/* Wrong ID */
+
+func TestRegistrationsGetWrongId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Registrations+"/aaaaaaaaaaaaaaaaa?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestRegistrationsPatchWrongId(t *testing.T) {
+ patchData := []byte(`{
+ "features": {
+ "targetCurrencies": ["EUR", "USD", "NOK"]
+ }
+ }`)
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/aaaaaaaaaaaaaaaaa?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestRegistrationsDeleteWrongId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Registrations+"/aaaaaaaaaaaaaaaaa?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestDashboardGetWrongId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Dashboards+"/aaaaaaaaaaaaaaaaa?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestNotificationsGetWrongId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.Notifications+"/aaaaaaaaaaaaaaaaa?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotFound)
+ }
+}
+
+func TestNotificationsDeleteWrongId(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Notifications+"/aaaaaaaaaaaaaaaaa?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusInternalServerError {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusInternalServerError)
+ }
+}
+
+/* Register Wrong Email, Password */
+
+func TestRegisterHandlerRegisterBadEmail(t *testing.T) {
+ form := url.Values{}
+ form.Add("username", DisplayName)
+ form.Add("email", "TesterTesting.test")
+ form.Add("password", Password)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.UserRegistration, strings.NewReader(form.Encode()))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegisterHandlerRegisterBadPassword(t *testing.T) {
+ form := url.Values{}
+ form.Add("username", DisplayName)
+ form.Add("email", Email)
+ form.Add("password", "password")
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.UserRegistration, strings.NewReader(form.Encode()))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegisterHandlerRegisterBadLongPassword(t *testing.T) {
+ form := url.Values{}
+ form.Add("username", DisplayName)
+ form.Add("email", Email)
+ form.Add("password", "passwordpassword")
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.UserRegistration, strings.NewReader(form.Encode()))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+func TestRegisterHandlerRegisterBadLongPasswordUppercase(t *testing.T) {
+ form := url.Values{}
+ form.Add("username", DisplayName)
+ form.Add("email", Email)
+ form.Add("password", "PasswordPassword")
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.UserRegistration, strings.NewReader(form.Encode()))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegisterHandlerRegisterBadLongPasswordUppercaseNumber(t *testing.T) {
+ form := url.Values{}
+ form.Add("username", DisplayName)
+ form.Add("email", Email)
+ form.Add("password", "Passwordp455w0rd")
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.UserRegistration, strings.NewReader(form.Encode()))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+/* Empty POST/PATCH Body */
+
+func TestDeleteAPIKeyHandlerEmpty(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.ApiKey+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ req.Header.Add("Authorization", "")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusUnauthorized {
+ t.Errorf("DELETE handler returned wrong status code: got %v want %v", status, http.StatusUnauthorized)
+ }
+}
+
+func TestGetAPIKeyHandlerEmpty(t *testing.T) {
+ req, err := http.NewRequest(http.MethodGet, Endpoints.ApiKey, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Add("Authorization", "")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusUnauthorized {
+ t.Errorf("GET handler returned wrong status code: got %v want %v", status, http.StatusUnauthorized)
+ }
+}
+
+func TestRegisterHandlerEmptyRegister(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPost, Endpoints.UserRegistration, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestNotificationsHandlerEmptyPost(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Notifications+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsHandlerEmptyPost(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerEmptyPatch(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+/* Wrong POST/PATCH BODY */
+
+func TestRegistrationsIdHandlerPostNoFeatures(t *testing.T) {
+ patchData := []byte(`{
+ "country": "Sweden",
+ "features": {
+ "temperature": false,
+ "precipitation": false,
+ "capital": false,
+ "coordinates": false,
+ "population": false,
+ "area": false,
+ "targetCurrencies": []
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerPostEmptyFeatures(t *testing.T) {
+ patchData := []byte(`{
+ "country": "Sweden",
+ "features": {}
+ }`)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerPostWrongIso(t *testing.T) {
+ patchData := []byte(`{
+ "isocode": "sweden",
+ "features": {
+ "temperature": true,
+ "precipitation": true,
+ "capital": true,
+ "coordinates": true,
+ "population": true,
+ "area": true,
+ "targetCurrencies": ["jpy", "nok", "eur","gbp"]
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerPostWrongCountry(t *testing.T) {
+ patchData := []byte(`{
+ "country": "no",
+ "features": {
+ "temperature": true,
+ "precipitation": true,
+ "capital": true,
+ "coordinates": true,
+ "population": true,
+ "area": true,
+ "targetCurrencies": ["jpy", "nok", "eur","gbp"]
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerPostCountryIsoMismatch(t *testing.T) {
+ patchData := []byte(`{
+ "country": "sweden",
+ "isocode": "gb",
+ "features": {
+ "temperature": true,
+ "precipitation": true,
+ "capital": true,
+ "coordinates": true,
+ "population": true,
+ "area": true,
+ "targetCurrencies": ["jpy", "nok", "eur","gbp"]
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPost, Endpoints.Registrations+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerPatchCountry(t *testing.T) {
+ patchData := []byte(`{
+ "country": "Sweden",
+ "features": {
+ "temperature": true,
+ "precipitation": true,
+ "capital": true,
+ "coordinates": true,
+ "population": true,
+ "area": true,
+ "targetCurrencies": ["jpy", "nok", "eur","gbp"]
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerPatchIsocode(t *testing.T) {
+ patchData := []byte(`{
+ "isocode": "gb",
+ "features": {
+ "temperature": true,
+ "precipitation": true,
+ "capital": true,
+ "coordinates": true,
+ "population": true,
+ "area": true,
+ "targetCurrencies": ["jpy", "nok", "eur","gbp"]
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerPatchNoFeatures(t *testing.T) {
+ patchData := []byte(`{
+ }`)
+
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerPatchEmptyFeatures(t *testing.T) {
+ patchData := []byte(`{
+ "features": {}
+ }`)
+
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegistrationsIdHandlerAllFalse(t *testing.T) {
+ patchData := []byte(`{
+ "features": {
+ "temperature": false,
+ "precipitation": false,
+ "capital": false,
+ "coordinates": false,
+ "population": false,
+ "area": false,
+ "targetCurrencies": []
+ }
+ }`)
+
+ req, err := http.NewRequest(http.MethodPatch, Endpoints.Registrations+"/"+docId1+"?token="+token, bytes.NewBuffer(patchData))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+/* Delete User No UUID, Whitespace UUID & Wrong UUID */
+
+func TestRegisterHandlerDeleteNoUUID(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.UserDeletion+"/", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotFound {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusNotFound)
+ }
+}
+
+func TestRegisterHandlerDeleteWhitespaceUUID(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.UserDeletion+"/%20", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
+
+func TestRegisterHandlerDeleteWrongUUID(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.UserDeletion+"/NTNU2024", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusInternalServerError {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusInternalServerError)
+ }
+}
+
+/* Endpoint "Not Implemented" Methods Check */
+
+func TestUserRegister(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodGet, Endpoints.UserRegistration, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPut, Endpoints.UserRegistration, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPatch, Endpoints.UserRegistration, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodDelete, Endpoints.UserRegistration, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+func TestUserDeletion(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodGet, Endpoints.UserDeletion+"/"+UUID, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPut, Endpoints.UserDeletion+"/"+UUID, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPatch, Endpoints.UserDeletion+"/"+UUID, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPost, Endpoints.UserDeletion+"/"+UUID, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+func TestAPIKeyHandler(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodPut, Endpoints.ApiKey, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPatch, Endpoints.ApiKey, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPost, Endpoints.ApiKey, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+func TestStatus(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodPut, Endpoints.Status, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPatch, Endpoints.Status, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPost, Endpoints.Status, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodDelete, Endpoints.Status, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+func TestRegistrations(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodPut, Endpoints.Registrations, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPatch, Endpoints.Registrations, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodDelete, Endpoints.Registrations, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+func TestRegistrationsId(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodPut, Endpoints.Registrations+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPost, Endpoints.Registrations+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+func TestDashboardId(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodPut, Endpoints.Dashboards+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPost, Endpoints.Dashboards+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPatch, Endpoints.Dashboards+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodDelete, Endpoints.Dashboards+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+func TestNotifications(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodPut, Endpoints.Notifications, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPatch, Endpoints.Notifications, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodDelete, Endpoints.Notifications, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+func TestNotificationsId(t *testing.T) {
+ rr := httptest.NewRecorder()
+
+ req, err := http.NewRequest(http.MethodPut, Endpoints.Notifications+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPost, Endpoints.Notifications+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+
+ req, err = http.NewRequest(http.MethodPatch, Endpoints.Notifications+"/"+docId1, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNotImplemented {
+ t.Errorf("handler returned wrong status code: got %v want %v",
+ status, http.StatusNotImplemented)
+ }
+}
+
+/* Clean UP */
+
+func TestRegistrationsIdHandlerDelete(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Registrations+"/"+docId1+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNoContent {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusNoContent)
+ }
+}
+
+func TestNotificationsHandlerDeleteDiscord(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Notifications+"/"+webhookId1+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNoContent {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusNoContent)
+ }
+}
+
+func TestNotificationsHandlerDelete(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.Notifications+"/"+webhookId2+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNoContent {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusNoContent)
+ }
+}
+
+func TestDeleteAPIKey(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.ApiKey+"?token="+token, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ req.Header.Add("Authorization", UUID)
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNoContent {
+ t.Errorf("DELETE handler returned wrong status code: got %v want %v", status, http.StatusNoContent)
+ }
+}
+
+func TestRegisterHandlerDelete(t *testing.T) {
+ req, err := http.NewRequest(http.MethodDelete, Endpoints.UserDeletion+"/"+UUID, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusNoContent {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusNoContent)
}
}
diff --git a/Go/db/db.go b/Go/db/db.go
index f976fcfec0fce0009fc7affbc21d1614c9cebdd0..bc35df0ad6207cb8cbcb94e1495636979c9c210e 100644
--- a/Go/db/db.go
+++ b/Go/db/db.go
@@ -1,13 +1,12 @@
+// Package db provides data access functions for interacting with Firestore.
package db
import (
"cloud.google.com/go/firestore"
"context"
"errors"
- firebase "firebase.google.com/go"
"fmt"
authenticate "globeboard/auth"
- "globeboard/internal/utils/constants"
"globeboard/internal/utils/constants/Firestore"
"globeboard/internal/utils/structs"
"google.golang.org/api/iterator"
@@ -16,549 +15,428 @@ import (
"google.golang.org/grpc/status"
"log"
"net/http"
- "time"
+ "os"
)
const (
- FirebaseClosingErr = "Error closing access to firestore: %v\n"
- IterationFailed = "failed to iterate over query results: %v\n"
- ParsingError = "Error parsing document: %v\n"
+ // IterationFailed Error for when iteration over Firestore results fails.
+ IterationFailed = "failed to iterate over query results: %v\n"
)
var (
- // Use a context for Firestore operations
- ctx = context.Background()
+ ctx = context.Background() // Global context for Firestore operations, used across all Firestore calls.
+ Client *firestore.Client // Singleton Firestore client.
+ err error // Variable to handle errors globally within this package.
)
-func getFirestoreClient() (*firestore.Client, error) {
-
- // Using the credential file
- sa := option.WithCredentialsFile(constants.FirebaseCredentialPath)
- app, err := firebase.NewApp(ctx, nil, sa)
- if err != nil {
- log.Println("Credentials not found: " + constants.FirebaseCredentialPath)
- log.Println("Error on getting the application")
- return nil, err
- }
-
- //No initial error, so a client is used to gather other information
- client, err := app.Firestore(ctx)
+// init initializes the Firestore client using environment variables for credentials and project ID.
+func init() {
+ sa := option.WithCredentialsFile(os.Getenv("FIREBASE_CREDENTIALS_FILE")) // Set up the credential file from environment.
+ Client, err = firestore.NewClient(ctx, os.Getenv("FIRESTORE_PROJECT_ID"), sa) // Create a new Firestore client.
if err != nil {
- // Logging the error
- log.Println("Credentials file: '" + constants.FirebaseCredentialPath + "' lead to an error.")
- return nil, err
+ log.Panic("Firestore was unable to initialize: ", err) // Panic if Firestore client initialization fails.
}
-
- // No errors, so we return the test client and no error
- return client, nil
}
+// TestDBConnection tests the Firestore database connection by attempting to write and immediately read a document.
func TestDBConnection() string {
- client, err := getFirestoreClient()
- if err != nil {
- return fmt.Sprintf("%d %s: %v", http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError), err)
- }
- defer func() {
- if err := client.Close(); err != nil {
- log.Printf("Error closing Firestore client: %v", err)
- }
- }()
-
- collectionID := "Connectivity"
- documentID := "DB_Connection_Test"
+ collectionID := "Connectivity" // Define the collection ID for connection tests.
+ documentID := "DB_Connection_Test" // Define the document ID for connection tests.
- // Attempt to update a specific document to test connectivity and permissions.
- _, err = client.Collection(collectionID).Doc(documentID).Set(ctx, map[string]interface{}{
+ // Attempt to set a document in the Firestore collection, tagging it with server timestamp.
+ _, err = Client.Collection(collectionID).Doc(documentID).Set(ctx, map[string]interface{}{
"PSA": "DO NOT DELETE THIS DOCUMENT!",
- "lastChecked": time.Now(),
+ "lastChecked": firestore.ServerTimestamp,
}, firestore.MergeAll)
- if err != nil {
- grpcStatusCode := status.Code(err)
- switch grpcStatusCode {
- case codes.Canceled:
- return fmt.Sprintf("%d %s", http.StatusRequestTimeout, http.StatusText(http.StatusRequestTimeout))
- case codes.DeadlineExceeded:
- return fmt.Sprintf("%d %s", http.StatusGatewayTimeout, http.StatusText(http.StatusGatewayTimeout))
- case codes.PermissionDenied:
- return fmt.Sprintf("%d %s", http.StatusForbidden, http.StatusText(http.StatusForbidden))
- case codes.NotFound:
- // This might indicate the collection or document does not exist,
- //which for this purpose is treated as a connection success
- // since the error was Firestore-specific and not network or permission related.
- return fmt.Sprintf("%d %s", http.StatusOK, http.StatusText(http.StatusOK))
- case codes.ResourceExhausted:
- return fmt.Sprintf("%d %s", http.StatusTooManyRequests, http.StatusText(http.StatusTooManyRequests))
- case codes.Unauthenticated:
- return fmt.Sprintf("%d %s", http.StatusUnauthorized, http.StatusText(http.StatusUnauthorized))
- case codes.Unavailable:
- return fmt.Sprintf("%d %s", http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable))
- case codes.Unknown, codes.Internal:
- return fmt.Sprintf("%d %s", http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError))
- default:
- // For any other codes, return a generic HTTP 500 error
- return fmt.Sprintf("%d %s", http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError))
- }
+ // Handle potential errors and map them to HTTP status codes.
+ grpcStatusCode := status.Code(err)
+ switch grpcStatusCode {
+ case codes.OK:
+ return fmt.Sprintf("%d %s", http.StatusOK, http.StatusText(http.StatusOK))
+ case codes.Canceled:
+ return fmt.Sprintf("%d %s", http.StatusRequestTimeout, http.StatusText(http.StatusRequestTimeout))
+ case codes.DeadlineExceeded:
+ return fmt.Sprintf("%d %s", http.StatusGatewayTimeout, http.StatusText(http.StatusGatewayTimeout))
+ case codes.PermissionDenied:
+ return fmt.Sprintf("%d %s", http.StatusForbidden, http.StatusText(http.StatusForbidden))
+ case codes.NotFound:
+ // Treat not found as OK for this operation; it indicates collection/document was simply not found.
+ // Another error in-of-itself.
+ return fmt.Sprintf("%d %s", http.StatusOK, http.StatusText(http.StatusOK))
+ case codes.ResourceExhausted:
+ return fmt.Sprintf("%d %s", http.StatusTooManyRequests, http.StatusText(http.StatusTooManyRequests))
+ case codes.Unauthenticated:
+ return fmt.Sprintf("%d %s", http.StatusUnauthorized, http.StatusText(http.StatusUnauthorized))
+ case codes.Unavailable:
+ return fmt.Sprintf("%d %s", http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable))
+ case codes.Unknown, codes.Internal:
+ return fmt.Sprintf("%d %s", http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError))
+ default:
+ return fmt.Sprintf("%d %s", http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError))
}
-
- // If no error, the document update was successful, indicating good connectivity and permissions.
- return fmt.Sprintf("%d %s", http.StatusOK, http.StatusText(http.StatusOK))
}
+// AddApiKey adds a new API key to Firestore, ensuring it does not already exist for the provided user (UUID).
func AddApiKey(docID, UUID string, key string) error {
- client, err := getFirestoreClient()
- if err != nil {
- return err
- }
- defer func(client *firestore.Client) {
- err := client.Close()
- if err != nil {
- log.Printf(FirebaseClosingErr, err)
- return
- }
- }(client)
-
- // Create a reference to the Firestore collection
- ref := client.Collection(Firestore.ApiKeyCollection)
+ ref := Client.Collection(Firestore.ApiKeyCollection) // Reference to the APIKey collection in Firestore.
+ // Query for existing API keys with the same UUID.
iter := ref.Where("UUID", "==", UUID).Limit(1).Documents(ctx)
- defer iter.Stop()
+ defer iter.Stop() // Ensure the iterator is cleaned up properly.
for {
- doc, err := iter.Next()
+ _, err := iter.Next()
if errors.Is(err, iterator.Done) {
- break
+ break // Exit the loop if all documents have been iterated over.
}
if err != nil {
- return fmt.Errorf(IterationFailed, err)
+ return fmt.Errorf(IterationFailed, err) // Return formatted error if iteration fails.
}
- _ = doc
- err = fmt.Errorf("API key is already registered to user")
- return err
+ err = errors.New("API key is already registered to user")
+ return err // Return error if an existing key is found.
}
- apiKeys := structs.APIKey{
- UUID: UUID,
- APIKey: key,
- }
+ apiKeys := structs.APIKey{UUID: UUID, APIKey: key} // Create an APIKey struct to be saved.
- // Create a new document and add it to the firebase
- _, err = ref.Doc(docID).Set(ctx, apiKeys)
+ _, err = ref.Doc(docID).Set(ctx, apiKeys) // Set the APIKey document in Firestore.
if err != nil {
err := fmt.Errorf("error saving API key to Database: %v", err)
- return err
+ return err // Return formatted error if setting the document fails.
}
- return nil
+ log.Printf("API key %s created successfully.", apiKeys.APIKey) // Log success.
+ return nil // Return nil error on success.
}
-func DeleteApiKey(apiKey string) error {
- client, err := getFirestoreClient()
- if err != nil {
- return err
- }
- defer func(client *firestore.Client) {
- err := client.Close()
- if err != nil {
- log.Printf(FirebaseClosingErr, err)
- return
- }
- }(client)
-
- // Create a reference to the Firestore collection
- ref := client.Collection(Firestore.ApiKeyCollection)
+// DeleteApiKey deletes an API key from Firestore based on UUID and key value.
+func DeleteApiKey(UUID, apiKey string) error {
+ ref := Client.Collection(Firestore.ApiKeyCollection) // Reference to the APIKey collection in Firestore.
- iter := ref.Where("APIKey", "==", apiKey).Limit(1).Documents(ctx)
- defer iter.Stop()
+ // Query for the API key document based on UUID and key.
+ iter := ref.Where("UUID", "==", UUID).Where("APIKey", "==", apiKey).Limit(1).Documents(ctx)
+ defer iter.Stop() // Ensure the iterator is cleaned up properly.
- var docID string
+ var docID string // Variable to store the document ID of the found API key.
for {
doc, err := iter.Next()
if errors.Is(err, iterator.Done) {
- break
+ break // Exit the loop if all documents have been iterated over.
}
if err != nil {
- return fmt.Errorf(IterationFailed, err)
+ return fmt.Errorf(IterationFailed, err) // Return formatted error if iteration fails.
}
- docID = doc.Ref.ID
+ docID = doc.Ref.ID // Store the document ID.
}
- // If docID is empty, the API key does not exist in Firestore
if docID == "" {
- return fmt.Errorf("API key not found")
- }
+ return errors.New("API key not found") // Return error if no document ID was found.
+ } // Handle if the API key was not found.
- // Delete the document with the provided API key
- _, err = ref.Doc(docID).Delete(ctx)
+ _, err = ref.Doc(docID).Delete(ctx) // Delete the document from Firestore.
if err != nil {
- return fmt.Errorf("failed to delete document: %v", err)
+ return fmt.Errorf("failed to delete API Key: %v", err) // Return formatted error if delete fails.
}
- fmt.Printf("API key %s deleted successfully\n", apiKey)
- return nil
+ log.Printf("API key %s deleted successfully.", apiKey) // Log success.
+ return nil // Return nil error on success.
}
+// GetAPIKeyUUID retrieves the UUID associated with a specific API key from Firestore.
func GetAPIKeyUUID(apiKey string) string {
- client, err := getFirestoreClient()
- if err != nil {
- log.Printf("Error retriving firestore client: %v", err)
- return ""
- }
- defer func(client *firestore.Client) {
- err := client.Close()
- if err != nil {
- log.Printf(FirebaseClosingErr, err)
- return
- }
- }(client)
-
- // Create a reference to the Firestore collection
- ref := client.Collection(Firestore.ApiKeyCollection)
+ ref := Client.Collection(Firestore.ApiKeyCollection) // Reference to the APIKey collection in Firestore.
- // Query Firestore to check if the API key exists
+ // Query for the API key document based on the key value.
iter := ref.Where("APIKey", "==", apiKey).Limit(1).Documents(ctx)
- defer iter.Stop()
+ defer iter.Stop() // Ensure the iterator is cleaned up properly.
- var key structs.APIKey
-
- // Iterate over the query results
+ var key structs.APIKey // Variable to store the API key data.
for {
doc, err := iter.Next()
if errors.Is(err, iterator.Done) {
- break
+ break // Exit the loop if all documents have been iterated over.
}
if err != nil {
log.Printf(IterationFailed, err)
- return ""
+ return "" // Return an empty string on error.
}
if err := doc.DataTo(&key); err != nil {
log.Println("Error parsing document:", err)
- return ""
+ return "" // Return an empty string on parsing error.
}
}
- clientAuth, err := authenticate.GetFireBaseAuthClient() // Assuming you have your initFirebase function from earlier
- if err != nil {
- log.Printf("Error retriving firebase auth client: %v", err)
- return ""
- }
- _, err = clientAuth.GetUser(ctx, key.UUID)
+ _, err = authenticate.Client.GetUser(ctx, key.UUID) // Authenticate the user based on UUID.
if err != nil {
log.Println("Error getting user:", err)
- return ""
+ return "" // Return an empty string if user authentication fails.
} else {
- return key.UUID
+ log.Printf("UUID: %s successfully retrieved from API key: %s.", key.UUID, key.APIKey)
+ return key.UUID // Return the UUID on success.
}
}
-func AddRegistration(docID string, data *structs.CountryInfoGet) error {
- client, err := getFirestoreClient()
- if err != nil {
- return err
- }
- defer func(client *firestore.Client) {
- err := client.Close()
- if err != nil {
- log.Printf(FirebaseClosingErr, err)
- return
- }
- }(client)
+// AddRegistration adds a new registration document to Firestore.
+func AddRegistration(docID string, data *structs.CountryInfoInternal) error {
+ ref := Client.Collection(Firestore.RegistrationCollection) // Reference to the Registration collection.
- // Create a reference to the Firestore collection
- ref := client.Collection(Firestore.RegistrationCollection)
-
- // Create a new document and add to it
+ // Set the registration document in Firestore with the given ID and data.
_, err = ref.Doc(docID).Set(ctx, map[string]interface{}{
"ID": data.ID,
"UUID": data.UUID,
"Country": data.Country,
"IsoCode": data.IsoCode,
"Features": data.Features,
- "Lastchange": firestore.ServerTimestamp,
+ "Lastchange": firestore.ServerTimestamp, // Use server timestamp to record last change.
})
if err != nil {
- log.Println("Error saving data to database" + err.Error())
- return err
+ return err // Return error if the document set operation fails.
}
- return nil
+ log.Printf("Registration documents %s created successfully.", data.ID)
+ return nil // Return nil if the addition is successful.
}
-func GetRegistrations(UUID string) ([]*structs.CountryInfoGet, error) {
- client, err := getFirestoreClient()
+// GetRegistrations retrieves all registration documents for a given user (UUID) from Firestore.
+func GetRegistrations(UUID string) ([]*structs.CountryInfoInternal, error) {
+ ref := Client.Collection(Firestore.RegistrationCollection) // Reference to the Registration collection.
+
+ // Query and retrieve all documents where 'UUID' matches, ordered by 'Lastchange' descending.
+ docs, err := ref.Where("UUID", "==", UUID).OrderBy("Lastchange", firestore.Desc).Documents(ctx).GetAll()
if err != nil {
- return nil, err
+ return nil, err // Return error if the fetch operation fails.
}
- defer func() {
- if err := client.Close(); err != nil {
- log.Printf(FirebaseClosingErr, err)
- }
- }()
- // Reference to the Firestore collection
- ref := client.Collection(Firestore.RegistrationCollection)
+ var cis []*structs.CountryInfoInternal // Slice to store the fetched documents.
- // Query all documents
- iter := ref.Where("UUID", "==", UUID).OrderBy("Lastchange", firestore.Desc).Documents(ctx)
- defer iter.Stop()
-
- var cis []*structs.CountryInfoGet
-
- for {
- doc, err := iter.Next()
- if errors.Is(err, iterator.Done) {
- break
- }
- if err != nil {
- log.Printf("Error fetching document: %v", err)
- return nil, err
- }
- ci := new(structs.CountryInfoGet) // Allocate a new instance of CountryInfoGet
- if err := doc.DataTo(ci); err != nil {
- log.Printf("Parsing error: %v", err)
- return nil, err
+ for _, doc := range docs {
+ var ci *structs.CountryInfoInternal
+ if err := doc.DataTo(&ci); err != nil {
+ return nil, err // Return error if parsing any document fails.
}
- cis = append(cis, ci)
+ cis = append(cis, ci) // Append the parsed document to the slice.
}
-
- return cis, nil
+ log.Printf("Registration documents for user: %s retrieved successfully.", UUID)
+ return cis, nil // Return the slice of documents.
}
-func GetSpecificRegistration(ID, UUID string) (*structs.CountryInfoGet, error) {
- client, err := getFirestoreClient()
- if err != nil {
- return nil, err
- }
- defer func() {
- if err := client.Close(); err != nil {
- log.Printf(FirebaseClosingErr, err)
- }
- }()
-
- // Reference to the Firestore collection
- ref := client.Collection(Firestore.RegistrationCollection)
+// GetSpecificRegistration retrieves a specific registration document by ID and UUID from Firestore.
+func GetSpecificRegistration(ID, UUID string) (*structs.CountryInfoInternal, error) {
+ ref := Client.Collection(Firestore.RegistrationCollection) // Reference to the Registration collection.
+ // Query for the specific document with the given 'ID' and 'UUID'.
iter := ref.Where("ID", "==", ID).Where("UUID", "==", UUID).Limit(1).Documents(ctx)
- defer iter.Stop()
+ defer iter.Stop() // Ensure the iterator is cleaned up properly.
- var ci *structs.CountryInfoGet
+ var ci *structs.CountryInfoInternal // Variable to store the fetched document.
- // Iterate over the query results
for {
doc, err := iter.Next()
if errors.Is(err, iterator.Done) {
- break
+ break // Exit the loop if all documents have been iterated over.
}
if err != nil {
- return nil, fmt.Errorf(IterationFailed, err)
+ return nil, fmt.Errorf(IterationFailed, err) // Return formatted error if iteration fails.
}
if err := doc.DataTo(&ci); err != nil {
- log.Println("Error retrieving document:", err)
- // Optionally, continue to the next document instead of returning an error
- // continue
- return nil, err
+ return nil, err // Return error if parsing the document fails.
}
- return ci, nil
+ log.Printf("Registration document %s retrieved successfully.", ci.ID)
+ return ci, nil // Return the parsed document.
}
- return nil, errors.New("no document with that ID was found")
+ return nil, errors.New("no registration with that ID was found") // Return error if no document is found.
}
-func UpdateRegistration(ID, UUID string, data *structs.CountryInfoGet) error {
- client, err := getFirestoreClient()
- if err != nil {
- return err
- }
- defer func() {
- if err := client.Close(); err != nil {
- log.Printf(FirebaseClosingErr, err)
- }
- }()
-
- // Reference to the Firestore collection
- ref := client.Collection(Firestore.RegistrationCollection)
+// UpdateRegistration updates a specific registration document by ID and UUID in Firestore.
+func UpdateRegistration(ID, UUID string, data *structs.CountryInfoInternal) error {
+ ref := Client.Collection(Firestore.RegistrationCollection) // Reference to the Registration collection.
+ // Query for the specific document to update.
iter := ref.Where("ID", "==", ID).Where("UUID", "==", UUID).Limit(1).Documents(ctx)
- defer iter.Stop()
+ defer iter.Stop() // Ensure the iterator is cleaned up properly.
- // Iterate over the query results
for {
doc, err := iter.Next()
if errors.Is(err, iterator.Done) {
- break
+ break // Exit the loop if all documents have been iterated over.
}
if err != nil {
- return fmt.Errorf(IterationFailed, err)
+ return fmt.Errorf(IterationFailed, err) // Return formatted error if iteration fails.
}
+ // Update the document with the provided data.
_, err = ref.Doc(doc.Ref.ID).Set(ctx, map[string]interface{}{
"ID": data.ID,
"UUID": data.UUID,
"Country": data.Country,
"IsoCode": data.IsoCode,
"Features": data.Features,
- "Lastchange": firestore.ServerTimestamp,
+ "Lastchange": firestore.ServerTimestamp, // Use server timestamp to update 'Lastchange'.
})
if err != nil {
- log.Printf("Error saving data to database: %v\n", err)
- return err
+ return err // Return error if the document update operation fails.
}
- return nil
+ log.Printf("Registration document %s patched successfully.", doc.Ref.ID)
+ return nil // Return nil error if the update is successful.
}
- return errors.New("no document with that ID was found")
+ return errors.New("no registration with that ID was found") // Return error if no document is found.
}
+// DeleteRegistration deletes a specific registration document by ID and UUID from Firestore.
func DeleteRegistration(ID, UUID string) error {
- client, err := getFirestoreClient()
- if err != nil {
- return err
- }
- defer func(client *firestore.Client) {
- err := client.Close()
- if err != nil {
- log.Printf(FirebaseClosingErr, err)
- return
- }
- }(client)
-
- // Create a reference to the Firestore collection
- ref := client.Collection(Firestore.RegistrationCollection)
+ ref := Client.Collection(Firestore.RegistrationCollection) // Reference to the Registration collection.
+ // Query for the specific document to delete.
iter := ref.Where("ID", "==", ID).Where("UUID", "==", UUID).Limit(1).Documents(ctx)
- defer iter.Stop()
+ defer iter.Stop() // Ensure the iterator is cleaned up properly.
- var docID string
+ var docID string // Variable to store the document ID of the found registration.
for {
doc, err := iter.Next()
if errors.Is(err, iterator.Done) {
- break
+ break // Exit the loop if all documents have been iterated over.
}
if err != nil {
- return fmt.Errorf(IterationFailed, err)
+ return fmt.Errorf(IterationFailed, err) // Return formatted error if iteration fails.
}
- docID = doc.Ref.ID
+ docID = doc.Ref.ID // Store the document ID.
}
- // If docID is empty, the API key does not exist in Firestore
if docID == "" {
- return fmt.Errorf("ID match was not found")
+ return fmt.Errorf("ID match was not found") // Return error if no document ID was found.
}
- // Delete the document with the provided API key
- _, err = ref.Doc(docID).Delete(ctx)
+ _, err = ref.Doc(docID).Delete(ctx) // Delete the document from Firestore.
if err != nil {
- return fmt.Errorf("failed to delete document: %v", err)
+ return fmt.Errorf("failed to delete document: %v", err) // Return formatted error if delete fails.
}
- fmt.Printf("Registration document %s deleted successfully\n", docID)
- return nil
+ log.Printf("Registration document %s deleted successfully\n", docID)
+ return nil // Return nil if the deletion is successful.
}
-/*
-func AddWebhook(userID, docID string, webhook structs.WebhookPost) error {
- client, err := getFirestoreClient()
- if err != nil {
- return err
- }
- defer func(client *firestore.Client) {
- err := client.Close()
- if err != nil {
- log.Printf(FirebaseClosingErr, err)
- return
- }
- }(client)
-
- // Create a reference to the Firestore collection
- ref := client.Collection(Firestore.WebhookCollection)
+// AddWebhook creates a new webhook entry in Firestore.
+func AddWebhook(docID string, webhook *structs.WebhookInternal) error {
+ ref := Client.Collection(Firestore.WebhookCollection) // Reference to the Webhook collection in Firestore.
- // Create a new document and add it to the
- _, err = ref.Doc(docID).Set(ctx, map[string]interface{}{
- "id": userID,
- "url": webhook.URL,
- "country": webhook.Country,
- "event": webhook.Event,
- "lastChange": time.Now(),
- })
+ // Set the webhook document with the provided ID and data.
+ _, err = ref.Doc(docID).Set(ctx, webhook)
if err != nil {
- log.Printf(FirebaseClosingErr, err)
- return err
+ return err // Return error if addition fails.
}
- return nil
-}*/
-
-func GetAllWebhooks() ([]structs.WebhookGet, error) {
- client, err := getFirestoreClient()
- if err != nil {
- return nil, err
- }
- defer func() {
- if err := client.Close(); err != nil {
- log.Printf(FirebaseClosingErr, err)
- }
- }()
+ log.Printf("Webhook %s created successfully.", webhook.ID) // Log success.
+ return nil // Return nil error on successful addition.
+}
- // Reference to the Firestore collection
- ref := client.Collection(Firestore.WebhookCollection)
+// GetAllWebhooks retrieves all webhook entries from Firestore.
+func GetAllWebhooks() ([]structs.WebhookInternal, error) {
+ ref := Client.Collection(Firestore.WebhookCollection) // Reference to the Webhook collection.
- // Query all documents
+ // Retrieve all documents from the webhook collection.
docs, err := ref.Documents(ctx).GetAll()
if err != nil {
- log.Printf("Error fetching documents: %v\n", err)
- return nil, err
+ return nil, err // Return the error if the fetch operation fails.
}
- var webhooks []structs.WebhookGet
+ var webhooks []structs.WebhookInternal // Slice to store the fetched webhook documents.
for _, doc := range docs {
- var webhook structs.WebhookGet
+ var webhook structs.WebhookInternal
if err := doc.DataTo(&webhook); err != nil {
- log.Printf(ParsingError, err)
- // Optionally, continue to the next document instead of returning an error
- // continue
- return nil, err
+ return nil, err // Return error if parsing any document fails.
}
- webhooks = append(webhooks, webhook)
+ webhooks = append(webhooks, webhook) // Append the parsed document to the slice.
}
- return webhooks, nil
+ log.Printf("All Webhooks retrieved successfully.") // Log success.
+ return webhooks, nil // Return the slice of webhook documents.
}
-func GetWebhooksUser(UUID string) ([]structs.WebhookGet, error) {
- client, err := getFirestoreClient()
+// GetWebhooksUser retrieves all webhook entries for a specific user (UUID) from Firestore.
+func GetWebhooksUser(UUID string) ([]structs.WebhookResponse, error) {
+ ref := Client.Collection(Firestore.WebhookCollection) // Reference to the Webhook collection.
+
+ // Query and retrieve all documents from the webhook collection where 'UUID' matches the provided UUID.
+ docs, err := ref.Where("UUID", "==", UUID).Documents(ctx).GetAll()
if err != nil {
- return nil, err
+ return nil, err // Return the error if the fetch operation fails.
}
- defer func() {
- if err := client.Close(); err != nil {
- log.Printf(FirebaseClosingErr, err)
+
+ var webhooks []structs.WebhookResponse // Slice to store the fetched webhook documents for the user.
+
+ for _, doc := range docs {
+ var webhook structs.WebhookResponse
+ if err := doc.DataTo(&webhook); err != nil {
+ return nil, err // Return error if parsing any document fails.
}
- }()
+ webhooks = append(webhooks, webhook) // Append the parsed document to the slice.
+ }
- // Reference to the Firestore collection
- ref := client.Collection(Firestore.WebhookCollection)
+ log.Printf("Webhooks retrieved successfully for user: %s.", UUID) // Log success.
+ return webhooks, nil // Return the slice of webhook documents for the user.
+}
- iter := ref.Where("UUID", "==", UUID).Limit(1).Documents(ctx)
- defer iter.Stop()
+// GetSpecificWebhook retrieves a specific webhook entry by ID and UUID from Firestore.
+func GetSpecificWebhook(ID, UUID string) (*structs.WebhookResponse, error) {
+ ref := Client.Collection(Firestore.WebhookCollection) // Reference to the Webhook collection.
- var webhooks []structs.WebhookGet
+ // Query for the specific document with the given 'ID' and 'UUID'.
+ iter := ref.Where("ID", "==", ID).Where("UUID", "==", UUID).Limit(1).Documents(ctx)
+ defer iter.Stop() // Ensure the iterator is cleaned up properly.
+
+ var webhook *structs.WebhookResponse // Variable to store the fetched document.
- // Iterate over the query results
for {
doc, err := iter.Next()
if errors.Is(err, iterator.Done) {
- break
+ break // Exit the loop if all documents have been iterated over.
}
if err != nil {
- return nil, fmt.Errorf(IterationFailed, err)
+ return nil, fmt.Errorf(IterationFailed, err) // Return formatted error if iteration fails.
}
- var webhook structs.WebhookGet
if err := doc.DataTo(&webhook); err != nil {
- log.Printf(ParsingError, err)
- return nil, err
+ return nil, err // Return error if parsing the document fails.
+ }
+
+ log.Printf("Webhook %s retrieved successfully.", webhook.ID) // Log success.
+ return webhook, nil // Return the parsed document.
+ }
+
+ return nil, errors.New("no document with that ID was found") // Return error if no document is found.
+}
+
+// DeleteWebhook deletes a specific webhook entry by ID and UUID from Firestore.
+func DeleteWebhook(ID, UUID string) error {
+ ref := Client.Collection(Firestore.WebhookCollection) // Reference to the Webhook collection.
+
+ // Query for the specific document to delete.
+ iter := ref.Where("ID", "==", ID).Where("UUID", "==", UUID).Limit(1).Documents(ctx)
+ defer iter.Stop() // Ensure the iterator is cleaned up properly.
+
+ var docID string // Variable to store the document ID of the found webhook.
+ for {
+ doc, err := iter.Next()
+ if errors.Is(err, iterator.Done) {
+ break // Exit the loop if all documents have been iterated over.
+ }
+ if err != nil {
+ return fmt.Errorf(IterationFailed, err) // Return formatted error if iteration fails.
}
- webhooks = append(webhooks, webhook)
+ docID = doc.Ref.ID // Store the document ID.
+ }
+
+ if docID == "" {
+ return fmt.Errorf("ID match was not found") // Return error if no document ID was found.
+ }
+
+ _, err = ref.Doc(docID).Delete(ctx) // Delete the document from Firestore.
+ if err != nil {
+ log.Print(err) // Log errors during the delete operation.
+ return fmt.Errorf("failed to delete document: %v", err) // Return formatted error if delete fails.
}
- return webhooks, nil
+ log.Printf("Webhook %s deleted successfully.", docID) // Log success.
+ return nil // Return nil error on successful operation.
}
diff --git a/Go/docker-compose.yml b/Go/docker-compose.yml
index cdc84e02bad77db9817c8181845f027ff797e6f3..4eb0059d28ac14d79ec1df4dd6ad02700c458e47 100644
--- a/Go/docker-compose.yml
+++ b/Go/docker-compose.yml
@@ -1,20 +1,63 @@
-version: '3.8'
+# Docker Compose configuration file for defining services
services:
+ # Main service for globeboard application
globeboard:
+ # Docker image for globeboard
+ image: globeboard
+ # Build configuration
build:
+ # Build context
context: .
+ # Dockerfile location
dockerfile: Dockerfile
+ # Ports mapping
ports:
- '${PORT}:${PORT}'
+ # Restart policy
+ restart: unless-stopped
+ # Environment variables
environment:
- - PORT=${PORT}
- - TOKEN=${TOKEN}
+ # Port number
+ PORT: ${PORT}
+ # Path to Firebase credentials file
+ FIREBASE_CREDENTIALS_FILE: /run/secrets/Firebase
+ # Firestore project ID
+ FIRESTORE_PROJECT_ID: ${FIRESTORE_PROJECT_ID}
+ # Volumes
volumes:
- - ./.secrets:/root/.secrets:ro
+ - ./web:/root/web:ro
+ # Secrets configuration
+ secrets:
+ - Firebase
+
+ # Test service for globeboard
globeboard-test:
+ # Docker image for globeboard test
+ image: globeboard-test
+ # Build configuration
build:
+ # Build context
context: .
+ # Dockerfile location
dockerfile: Dockerfile-test
- depends_on:
- - globeboard
\ No newline at end of file
+ # Restart policy
+ restart: no
+ # Environment variables
+ environment:
+ # Path to Firebase credentials file
+ FIREBASE_CREDENTIALS_FILE: /run/secrets/Firebase
+ # Firestore project ID
+ FIRESTORE_PROJECT_ID: ${FIRESTORE_PROJECT_ID}
+ # Volumes
+ volumes:
+ - ./web:/root/web:ro
+ # Secrets configuration
+ secrets:
+ - Firebase
+
+# Secret definition
+secrets:
+ Firebase:
+ # Path to Firebase credentials file
+ file: ${FIREBASE_CREDENTIALS_FILE}
\ No newline at end of file
diff --git a/Go/internal/func/dashboardFunctions.go b/Go/internal/func/dashboardFunctions.go
new file mode 100644
index 0000000000000000000000000000000000000000..f6f0232549daf2e1de08f1648068c2a65bf5f129
--- /dev/null
+++ b/Go/internal/func/dashboardFunctions.go
@@ -0,0 +1,334 @@
+// Package _func provides developer-made utility functions for use within the application.
+package _func
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "globeboard/internal/utils/constants/External"
+ "globeboard/internal/utils/structs"
+ "io"
+ "log"
+ "net/http"
+ "strconv"
+ "strings"
+)
+
+// OpenMeteoTemp structure defines the JSON structure for temperature response from the OpenMeteo API.
+type OpenMeteoTemp struct {
+ Current struct {
+ Temperature float64 `json:"temperature_2m"` // Current temperature (2 meters above the ground).
+ } `json:"current"`
+}
+
+const (
+ alphaCodes = "alpha?codes=" // URL parameter for filtering requests by country ISO codes.
+ ResponseBodyCloseError = "Error closing response body: %v" // Log format for errors closing the response body.
+)
+
+// GetTemp fetches the current temperature for the specified coordinates using the OpenMeteo API.
+func GetTemp(coordinates structs.CoordinatesDashboard) (float64, error) {
+ // Constructing the URL to call the OpenMeteo API with query parameters for latitude and longitude.
+ response, err := http.Get(External.OpenMeteoAPI + "?latitude=" + coordinates.Latitude + "&longitude=" + coordinates.Longitude + "¤t=temperature_2m")
+ if err != nil {
+ log.Print(err)
+ return 0, err // Return zero temperature and the error if the GET request fails.
+ }
+ defer func(Body io.ReadCloser) {
+ err := Body.Close()
+ if err != nil {
+ log.Printf(ResponseBodyCloseError, err)
+ }
+ }(response.Body) // Ensure the response body is closed after the function returns.
+
+ body, err := io.ReadAll(response.Body) // Read the response body.
+ if err != nil {
+ log.Print(err)
+ return 0, err // Return zero temperature and the error if an issue with reading the response occurs.
+ }
+
+ var openMeteo OpenMeteoTemp // Declaring a variable to store unmarshalled JSON data.
+ if err := json.Unmarshal(body, &openMeteo); err != nil { // Unmarshal JSON data into OpenMeteoTemp struct.
+ return 0, err
+ }
+ temp := openMeteo.Current.Temperature // Extracting the temperature from the struct.
+
+ return temp, nil // Return the fetched temperature.
+}
+
+// OpenMeteoPrecipitation structure defines the JSON structure for precipitation response from OpenMeteo API.
+type OpenMeteoPrecipitation struct {
+ Current struct {
+ Precipitation float64 `json:"precipitation"` // Current precipitation amount.
+ } `json:"current"`
+}
+
+// GetPrecipitation fetches the current precipitation for the specified coordinates.
+func GetPrecipitation(coordinates structs.CoordinatesDashboard) (float64, error) {
+ // Construct the API request URL with coordinates.
+ response, err := http.Get(External.OpenMeteoAPI + "?latitude=" + coordinates.Latitude + "&longitude=" + coordinates.Longitude + "¤t=precipitation")
+ if err != nil {
+ log.Print(err)
+ return 0, err // Return zero precipitations and the error if the GET request fails.
+ }
+ defer func(Body io.ReadCloser) {
+ err := Body.Close()
+ if err != nil {
+ log.Printf(ResponseBodyCloseError, err)
+ }
+ }(response.Body) // Ensuring the response body is properly closed.
+
+ body, err := io.ReadAll(response.Body) // Read the response body.
+ if err != nil {
+ log.Print(err)
+ return 0, err // Return zero precipitations and the error if an issue with reading the response occurs.
+ }
+
+ var openMeteo OpenMeteoPrecipitation // Struct to hold the precipitation data.
+ if err := json.Unmarshal(body, &openMeteo); err != nil { // Parse the JSON response into the struct.
+ return 0, err
+ }
+
+ precipitation := openMeteo.Current.Precipitation // Extract the precipitation value.
+
+ return precipitation, nil // Return the precipitation data.
+}
+
+// Country structure for parsing country capital information from a JSON response.
+type Country struct {
+ Capital []string `json:"capital"` // Capital is expected as an array of strings,
+ // though typically containing only one element.
+}
+
+// GetCapital fetches the capital city of a country identified by its ISO code.
+func GetCapital(isocode string) (string, error) {
+ // Construct the request URL with ISO code and fields parameter.
+ response, err := http.Get(External.CountriesAPI + alphaCodes + isocode + "&fields=capital")
+ if err != nil {
+ log.Print(err)
+ return "Earth", err // Return "Earth" and the error if GET requests fails.
+ }
+ defer func(Body io.ReadCloser) {
+ err := Body.Close()
+ if err != nil {
+ log.Printf(ResponseBodyCloseError, err)
+ }
+ }(response.Body) // Ensure to close the response body on function exit.
+
+ body, err := io.ReadAll(response.Body) // Read the entire response body.
+ if err != nil {
+ log.Print(err)
+ return "Earth", err //Return "Earth" and the error if an issue with reading the response occurs.
+ }
+
+ var countries []Country // Slice to hold the parsed JSON data.
+ if err := json.Unmarshal(body, &countries); err != nil {
+ return "", err // Handle JSON parsing errors.
+ }
+ if len(countries) == 0 || len(countries[0].Capital) == 0 {
+ return "Earth", errors.New("no capital found for the specified ISO code") // Handle cases where no capital is available.
+ }
+ capital := countries[0].Capital[0] // Assume the first element is the desired capital.
+
+ return capital, nil // Return the capital city.
+}
+
+// CountryCoordinates structure for parsing geographical coordinates from a JSON response.
+type CountryCoordinates struct {
+ LatLng []float64 `json:"latlng"` // Array of latitude and longitude.
+}
+
+// GetCoordinates fetches the geographical coordinates (latitude and longitude) of a country specified by its ISO code.
+func GetCoordinates(isocode string) (structs.CoordinatesDashboard, error) {
+ var empty = structs.CoordinatesDashboard{} // A default struct in case of errors.
+
+ // Construct the request URL.
+ response, err := http.Get(External.CountriesAPI + alphaCodes + isocode + "&fields=latlng")
+ if err != nil {
+ log.Print(err)
+ return empty, err
+ }
+
+ body, err := io.ReadAll(response.Body) // Read the response body.
+ if err != nil {
+ log.Print(err)
+ return empty, err
+ }
+
+ var countriesCoords []CountryCoordinates // Slice to store parsed data.
+ if err := json.Unmarshal(body, &countriesCoords); err != nil {
+ return empty, err // Handle JSON parsing errors.
+ }
+
+ // Assume the first entry contains the correct coordinates.
+ var coords = structs.CoordinatesDashboard{
+ Latitude: strconv.FormatFloat(countriesCoords[0].LatLng[0], 'f', 5, 64),
+ Longitude: strconv.FormatFloat(countriesCoords[0].LatLng[1], 'f', 5, 64),
+ }
+
+ return coords, nil // Return the coordinates in a struct.
+}
+
+// CountryPopulation structure for parsing population data from a JSON response.
+type CountryPopulation struct {
+ Population int `json:"population"` // Population as an integer.
+}
+
+// GetPopulation fetches the population of a country specified by its ISO code.
+func GetPopulation(isocode string) (int, error) {
+ // Construct the API request URL.
+ response, err := http.Get(External.CountriesAPI + alphaCodes + isocode + "&fields=population")
+ if err != nil {
+ log.Print(err)
+ return 0, err
+ }
+
+ body, err := io.ReadAll(response.Body) // Read the entire response body.
+ if err != nil {
+ log.Print(err)
+ return 0, err
+ }
+
+ var populationData []CountryPopulation // Slice to hold parsed data.
+ if err := json.Unmarshal(body, &populationData); err != nil {
+ return 0, err // Handle JSON parsing errors.
+ }
+
+ if len(populationData) == 0 {
+ return 0, errors.New("no population data found for the specified ISO code") // Handle cases where no data is found.
+ }
+ population := populationData[0].Population // Assume the first entry is the correct one.
+
+ return population, nil // Return the population.
+}
+
+// CountryArea structure for parsing area data from a JSON response.
+type CountryArea struct {
+ Area float64 `json:"area"` // Area in square kilometers as a float64.
+}
+
+// GetArea fetches the total land area of a country specified by its ISO code.
+func GetArea(isocode string) (float64, error) {
+ // Construct the API request URL.
+ response, err := http.Get(External.CountriesAPI + alphaCodes + isocode + "&fields=area")
+ if err != nil {
+ log.Print(err)
+ return 0, err
+ }
+ defer func(Body io.ReadCloser) {
+ err := Body.Close()
+ if err != nil {
+ log.Printf(ResponseBodyCloseError, err)
+ }
+ }(response.Body) // Ensure the response body is closed.
+
+ body, err := io.ReadAll(response.Body) // Read the response body.
+ if err != nil {
+ log.Print(err)
+ return 0, err
+ }
+
+ var countryArea []CountryArea // Slice to hold parsed data.
+ if err := json.Unmarshal(body, &countryArea); err != nil {
+ return 0, err // Handle JSON parsing errors.
+ }
+
+ if len(countryArea) == 0 {
+ return 0, errors.New("no area data found for the specified ISO code") // Handle cases where no data is available.
+ }
+ area := countryArea[0].Area // Assume the first entry contains the correct area.
+
+ return area, nil // Return the area.
+}
+
+// CurrencyResponse defines the structure for parsing currency information from a JSON response.
+type CurrencyResponse []struct {
+ Currencies map[string]struct {
+ Name string `json:"name"` // Name of the currency.
+ Symbol string `json:"symbol"` // Symbol of the currency.
+ } `json:"currencies"`
+}
+
+// RatesResponse defines the structure for parsing exchange rate information from a JSON response.
+type RatesResponse struct {
+ Rates map[string]float64 `json:"rates"` // Map of currency codes to their respective exchange rates.
+}
+
+// GetExchangeRate computes the exchange rates for specified currencies against a base currency
+// specified by the ISO code.
+func GetExchangeRate(isocode string, currencies []string) (map[string]float64, error) {
+ exchangeRateList, err := getExchangeRateList(isocode) // Fetch the list of all exchange rates for the base currency.
+ if err != nil {
+ log.Print(err)
+ return nil, err
+ }
+
+ exchangeRate := make(map[string]float64) // Map to hold the filtered exchange rates.
+ for _, currency := range currencies {
+ exchangeRate[strings.ToUpper(currency)] = exchangeRateList[strings.ToUpper(currency)] // Filter and add the relevant rates.
+ }
+
+ return exchangeRate, nil // Return the map of exchange rates.
+}
+
+// fetchCurrencyRates retrieves the exchange rates for all currencies against a specified base currency.
+func fetchCurrencyRates(currency string) (map[string]float64, error) {
+ // Construct the API request URL.
+ response, err := http.Get(External.CurrencyAPI + currency)
+ if err != nil {
+ log.Print(err)
+ return nil, err
+ }
+ defer func(Body io.ReadCloser) {
+ err := Body.Close()
+ if err != nil {
+ log.Printf(ResponseBodyCloseError, err)
+ }
+ }(response.Body) // Ensure the response body is closed.
+
+ body, err := io.ReadAll(response.Body) // Read the response body.
+ if err != nil {
+ log.Print(err)
+ return nil, err
+ }
+
+ var ratesData RatesResponse // Struct to hold the parsed data.
+ if err := json.Unmarshal(body, &ratesData); err != nil {
+ return nil, err // Handle JSON parsing errors.
+ }
+
+ return ratesData.Rates, nil // Return the map of exchange rates.
+}
+
+// getExchangeRateList fetches the exchange rates for all currencies against the base currency
+// specified by the ISO code.
+func getExchangeRateList(isocode string) (map[string]float64, error) {
+ // Construct the API request URL for fetching currency information.
+ response, err := http.Get(External.CountriesAPI + alphaCodes + isocode + "&fields=currencies")
+ if err != nil {
+ log.Print(err)
+ return nil, err
+ }
+
+ body, err := io.ReadAll(response.Body) // Read the response body.
+ if err != nil {
+ log.Print(err)
+ return nil, err
+ }
+
+ var currencyData CurrencyResponse // Struct to hold the parsed currency information.
+ if err := json.Unmarshal(body, ¤cyData); err != nil {
+ return nil, err // Handle JSON parsing errors.
+ }
+
+ for currency := range currencyData[0].Currencies {
+ rates, err := fetchCurrencyRates(currency) // Fetch the exchange rates for the base currency.
+ if err != nil {
+ log.Printf("Error fetching currency rates: %v", err)
+ return nil, fmt.Errorf("error fetching currency rates: %v", err) // Handle errors in fetching exchange rates.
+ }
+ return rates, nil // Return the map of exchange rates.
+ }
+
+ return nil, errors.New("no currency data found") // Return an error if no currency information is found.
+}
diff --git a/Go/internal/func/keyGen.go b/Go/internal/func/keyGen.go
index ad06b25cdf5207758c482df5088b1f24b979a1e5..ff1a2688e88a280409bc2187bfe59631c4747f2b 100644
--- a/Go/internal/func/keyGen.go
+++ b/Go/internal/func/keyGen.go
@@ -1,3 +1,4 @@
+// Package _func provides developer-made utility functions for use within the application.
package _func
import (
@@ -5,33 +6,36 @@ import (
"time"
)
-// initialize the package
+// init initializes the package by seeding the random number generator with the current time.
func init() {
- // Seed rand with time, making it nondeterministic
- rand.New(rand.NewSource(time.Now().UnixNano()))
+ rand.New(rand.NewSource(time.Now().UnixNano())) // Seed rand with time, making it nondeterministic.
}
-// Runes list of characters to use for ID
+// Runes is the list of characters to use for generating IDs.
var Runes = []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
+// GenerateAPIKey generates an API key of length 'n'.
func GenerateAPIKey(n int) string {
+ // Make two slices that are 'n' long, a and b.
a := make([]rune, n)
b := make([]rune, n)
+ // loop through the slices and insert a random character at each index for each slice.
for i := range a {
a[i] = Runes[rand.Intn(len(Runes))]
b[i] = Runes[rand.Intn(len(Runes))]
}
+ // concatenate the slices to strings, following standard format.
return "sk-" + string(a) + "tTRjPv" + string(b)
}
-// GenerateUID returns a Unique Identifier that is 'n' long
+// GenerateUID returns a Unique Identifier of length 'n'.
func GenerateUID(n int) string {
- // Make a slice that is 'n' long
+ // Make a slice that is 'n' long.
b := make([]rune, n)
- //loop through the slice and insert a random character at each index
+ // loop through the slice and insert a random character at each index.
for i := range b {
b[i] = Runes[rand.Intn(len(Runes))]
}
- // concatenate the slice to string
+ // concatenate the slice to string.
return string(b)
}
diff --git a/Go/internal/func/supported_countries.go b/Go/internal/func/supported_countries.go
index 010474baba590f27d4fd28389c014282c4750c34..520e5a47ddbaa9e394981eb5abe67b3c5224f7ca 100644
--- a/Go/internal/func/supported_countries.go
+++ b/Go/internal/func/supported_countries.go
@@ -1,3 +1,4 @@
+// Package _func provides developer-made utility functions for use within the application.
package _func
import (
@@ -8,110 +9,128 @@ import (
"globeboard/internal/utils/structs"
"golang.org/x/text/cases"
"golang.org/x/text/language"
+ "io"
+ "log"
"net/http"
"strings"
"time"
)
-// CountryInfo represents the necessary information about a country, focusing on its common name and cca2 code.
-type CountryInfo struct {
- CommonName string `json:"commonName"`
- ISOCode string `json:"isoCode"`
-}
-
-// GetSupportedCountries fetches countries with their common names and cca2 codes.
+// getSupportedCountries fetches supported countries with their common names and ISO 3166-1 alpha-2 codes.
func getSupportedCountries() (map[string]string, error) {
- url := fmt.Sprintf("%sall?fields=name,cca2", External.CountriesAPI)
- var responseData []struct {
+ url := fmt.Sprintf("%sall?fields=name,cca2", External.CountriesAPI) // Constructing the API request URL.
+ var responseData []struct { // Struct to parse the JSON response.
Name struct {
- Common string `json:"common"`
+ Common string `json:"common"` // Common name of the country.
} `json:"name"`
- CCA2 string `json:"cca2"`
+ CCA2 string `json:"cca2"` // ISO 3166-1 alpha-2 code of the country.
}
- client := &http.Client{Timeout: 10 * time.Second}
- req, err := http.NewRequest(http.MethodGet, url, nil)
+ client := &http.Client{Timeout: 10 * time.Second} // HTTP client with a timeout.
+ req, err := http.NewRequest(http.MethodGet, url, nil) // Creating a new HTTP GET request.
if err != nil {
- return nil, fmt.Errorf("error creating request: %s", err)
+ log.Printf("Error creating request: %v", err)
+ return nil, fmt.Errorf("error creating request: %v", err)
}
- req.Header.Add("content-type", "application/json")
+ req.Header.Add("content-type", "application/json") // Setting content-type of the request.
- res, err := client.Do(req)
+ res, err := client.Do(req) // Send the request.
if err != nil {
- return nil, fmt.Errorf("error issuing request: %s", err)
+ log.Printf("Error issuing request: %v", err)
+ return nil, fmt.Errorf("error issuing request: %v", err)
}
+ defer func(Body io.ReadCloser) {
+ err := Body.Close()
+ if err != nil {
+ log.Printf("Error closing response body: %v", err)
+ }
+ }(res.Body) // Ensure the response body is closed after processing.
- err = json.NewDecoder(res.Body).Decode(&responseData)
+ err = json.NewDecoder(res.Body).Decode(&responseData) // Decoding the JSON response into the struct.
if err != nil {
- return nil, fmt.Errorf("error decoding JSON: %s", err)
+ log.Printf("Error decoding JSON: %v", err)
+ return nil, fmt.Errorf("error decoding JSON: %v", err)
}
- countriesMap := make(map[string]string)
+ countriesMap := make(map[string]string) // Map to hold country codes and their common names.
+ // Loop over the response data and map the supported countries by ISO code.
for _, item := range responseData {
countriesMap[item.CCA2] = item.Name.Common
}
- return countriesMap, nil
+ return countriesMap, nil // Returning the map.
}
-func ValidateCountryInfo(ci *structs.CountryInfoGet) error {
- err := validateCountryNameIsoCode(ci)
+// ValidateCountryInfo validates the country information.
+func ValidateCountryInfo(ci *structs.CountryInfoInternal) error {
+ err := validateCountryNameIsoCode(ci) // Validate the name and ISO code.
if err != nil {
return err
}
+ // Ensure that at least one feature is populated.
if !ci.Features.Temperature && !ci.Features.Precipitation && !ci.Features.Capital &&
- !ci.Features.Coordinates && !ci.Features.Population && !ci.Features.Area {
- return errors.New("at least one feature must be true")
+ !ci.Features.Coordinates && !ci.Features.Population && !ci.Features.Area &&
+ (ci.Features.TargetCurrencies == nil || len(ci.Features.TargetCurrencies) == 0) {
+ return errors.New("at least one feature must be populated")
}
return nil
}
-func validateCountryNameIsoCode(ci *structs.CountryInfoGet) error {
- validCountries, err := getSupportedCountries() // Adjusted to use the map version.
+// validateCountryNameIsoCode validates the provided country name and/or ISO code against supported countries.
+func validateCountryNameIsoCode(ci *structs.CountryInfoInternal) error {
+ validCountries, err := getSupportedCountries() // Fetch the list of supported countries.
if err != nil {
- return errors.New("error validating country")
+ log.Printf("Error retriving supported countries: %v", err)
+ return fmt.Errorf("error retriving supported countries: %v", err)
}
-
+ // Validate that a country has been specified.
if err := validateCountryOrIsoCodeProvided(ci); err != nil {
return err
}
-
- if err := validateIsoCode(ci, validCountries); err != nil {
+ // Validate the ISO, and update country name based on ISO. (If country name wasn't provided)
+ if err := validateIsoCodeUpdateEmptyCountry(ci, validCountries); err != nil {
return err
}
-
- if err := updateAndValidateIsoCodeForCountry(ci, validCountries); err != nil {
+ // Validate the country name, and update ISO based on country. (If ISO name wasn't provided)
+ if err := updateIsoCodeAndValidateCountry(ci, validCountries); err != nil {
return err
}
-
+ // Validate that the provided country and ISO correspond.
return validateCorrespondence(ci, validCountries)
}
-func validateCountryOrIsoCodeProvided(ci *structs.CountryInfoGet) error {
+// validateCountryOrIsoCodeProvided checks that either country name or ISO code is provided.
+func validateCountryOrIsoCodeProvided(ci *structs.CountryInfoInternal) error {
if ci.Country == "" && ci.IsoCode == "" {
return errors.New("either country name or ISO code must be provided")
}
return nil
}
-func validateIsoCode(ci *structs.CountryInfoGet, validCountries map[string]string) error {
- if ci.IsoCode != "" {
- ci.IsoCode = strings.ToTitle(ci.IsoCode)
- if country, exists := validCountries[ci.IsoCode]; !exists {
+// validateIsoCodeUpdateEmptyCountry checks if the provided ISO code is valid and updates the country name accordingly,
+// if empty.
+func validateIsoCodeUpdateEmptyCountry(ci *structs.CountryInfoInternal, validCountries map[string]string) error {
+ if ci.IsoCode != "" { // Validate non-empty ISO.
+ ci.IsoCode = strings.ToTitle(ci.IsoCode) // Convert ISO code to title case to match keys in validCountries.
+ if country, exists := validCountries[ci.IsoCode]; !exists { // Validate ISO against validCountries.
return errors.New("invalid ISO code")
} else {
- ci.Country = country
+ if ci.Country == "" {
+ ci.Country = country // Update the country name based on the ISO code, if empty.
+ }
}
}
return nil
}
-func updateAndValidateIsoCodeForCountry(ci *structs.CountryInfoGet, validCountries map[string]string) error {
+// updateIsoCodeAndValidateCountry
+// checks if only the country name was provided it validates it and updates the ISO code.
+func updateIsoCodeAndValidateCountry(ci *structs.CountryInfoInternal, validCountries map[string]string) error {
if ci.IsoCode == "" && ci.Country != "" {
- ci.Country = cases.Title(language.English, cases.Compact).String(ci.Country)
+ ci.Country = cases.Title(language.English, cases.Compact).String(ci.Country) // Normalize country name to title case.
for code, name := range validCountries {
if name == ci.Country {
- ci.IsoCode = code
+ ci.IsoCode = code // Update ISO code if the country name is valid.
return nil
}
}
@@ -120,9 +139,10 @@ func updateAndValidateIsoCodeForCountry(ci *structs.CountryInfoGet, validCountri
return nil
}
-func validateCorrespondence(ci *structs.CountryInfoGet, validCountries map[string]string) error {
+// validateCorrespondence checks that the provided country name and ISO code match.
+func validateCorrespondence(ci *structs.CountryInfoInternal, validCountries map[string]string) error {
if ci.Country != "" && ci.IsoCode != "" {
- ci.Country = cases.Title(language.English, cases.Compact).String(ci.Country)
+ ci.Country = cases.Title(language.English, cases.Compact).String(ci.Country) // Normalize the country name.
if validCountries[ci.IsoCode] != ci.Country {
return errors.New("ISO code and country name do not match")
}
diff --git a/Go/internal/func/webhook_payload.go b/Go/internal/func/webhook_payload.go
index dc1686db5686203d07e3fd1fad5ea9ca3fb8411c..2472410243d94f1390a6fb2eca60612e2bafa2c3 100644
--- a/Go/internal/func/webhook_payload.go
+++ b/Go/internal/func/webhook_payload.go
@@ -1,3 +1,4 @@
+// Package _func provides developer-made utility functions for use within the application.
package _func
import (
@@ -7,42 +8,38 @@ import (
"fmt"
authenticate "globeboard/auth"
"globeboard/db"
+ "globeboard/internal/utils/constants/Endpoints"
"globeboard/internal/utils/constants/Webhooks"
"globeboard/internal/utils/structs"
- "io"
"log"
"net/http"
"strings"
"time"
)
-func LoopSendWebhooks(caller string, ci *structs.CountryInfoGet, endpoint, eventAction string) {
- client, err := authenticate.GetFireBaseAuthClient()
- if err != nil {
- log.Printf("Error initializing Firebase Auth: %v", err)
- return
- }
+var (
+ isocode = "" // Variable to store ISO code.
+ title = "" // Variable to store the title for webhook messages.
+ color = 0 // Variable to store the color code for webhook messages.
+ method = "" // Variable to store the HTTP method by which the webhook triggered.
+)
+// LoopSendWebhooksRegistrations sends notifications to registered webhooks about registration events.
+func LoopSendWebhooksRegistrations(caller string, ci *structs.CountryInfoExternal, endpoint, eventAction string) {
ctx := context.Background()
- // Remove UUID from webhook json
- ci.UUID = ""
-
- // Ignoring error as we've already confirmed the caller at the endpoint.
- user, _ := client.GetUser(ctx, caller)
-
+ // Retrieve user information; ignore error as the user is pre-validated.
+ user, _ := authenticate.Client.GetUser(ctx, caller)
email := user.DisplayName + " (" + strings.ToLower(user.Email) + ")"
- title := ""
- color := 0
- method := ""
+ // Select appropriate message components based on the event type.
switch eventAction {
case Webhooks.EventRegister:
title = Webhooks.POSTTitle
color = Webhooks.POSTColor
method = http.MethodPost
case Webhooks.EventChange:
- title = Webhooks.PUTTitle
+ title = Webhooks.PATCHTitle
color = Webhooks.PUTColor
method = http.MethodPatch
case Webhooks.EventDelete:
@@ -53,49 +50,88 @@ func LoopSendWebhooks(caller string, ci *structs.CountryInfoGet, endpoint, event
title = Webhooks.GETTitle
color = Webhooks.GETColor
method = http.MethodGet
+ }
+
+ // Get the isocode from the payload data.
+ isocode = ci.IsoCode
+
+ // Fetch all webhooks from the database.
+ webhooks, err := db.GetAllWebhooks()
+ if err != nil {
+ log.Printf("Error retrieving webhooks from database: %v", err)
+ return
+ }
+ // Iterate through each webhook and send notifications if conditions are met.
+ for _, webhook := range webhooks {
+ if isRegistrationWebhookValid(caller, ci, eventAction, webhook) {
+ if strings.Contains(webhook.URL, "https://discord.com") {
+ sendDiscordWebhookPayload(email, title, color, method, endpoint, ci, webhook.URL)
+ } else {
+ sendWebhookPayload(email, title, method, endpoint, isocode, webhook.URL)
+ }
+ }
}
+}
+
+// LoopSendWebhooksDashboard sends notifications to registered webhooks about dashboard events.
+func LoopSendWebhooksDashboard(caller string, dr *structs.DashboardResponse) {
+ ctx := context.Background()
+
+ // Retrieve user information; ignore error as the user is pre-validated.
+ user, _ := authenticate.Client.GetUser(ctx, caller)
+ email := user.DisplayName + " (" + strings.ToLower(user.Email) + ")"
+
+ // Default to INVOKE title as Dashboard endpoint GET populated dashboards at this time.
+ title = Webhooks.GETTitle
+ color = Webhooks.GETColor
+ method = Webhooks.EventInvoke
+
+ // Get the isocode from the payload data.
+ isocode = dr.IsoCode
+
+ // Fetch all webhooks from the database.
webhooks, err := db.GetAllWebhooks()
if err != nil {
- log.Printf("Error retriving webhooks from database: %v", err)
+ log.Printf("Error retrieving webhooks from database: %v", err)
return
}
+ // Iterate through each webhook and send notifications if conditions are met.
for _, webhook := range webhooks {
- if isWebhookValid(caller, ci, eventAction, webhook) && strings.Contains(webhook.URL, "discord") {
- sendDiscordWebhookPayload(
- email,
- title,
- color,
- method,
- endpoint,
- ci,
- webhook.URL)
- } else {
- sendWebhookPayload(
- email,
- title,
- method,
- endpoint,
- ci.IsoCode,
- webhook.URL)
+ if isDashboardWebhookValid(caller, dr, Webhooks.EventInvoke, webhook) {
+ if strings.Contains(webhook.URL, "discord") {
+ sendDiscordWebhookPayload(email, title, color, method, Endpoints.DashboardsID, dr, webhook.URL)
+ } else {
+ sendWebhookPayload(email, title, method, Endpoints.DashboardsID, isocode, webhook.URL)
+ }
+ }
+ }
+}
+
+// isRegistrationWebhookValid checks if the webhook should trigger for the registration event.
+func isRegistrationWebhookValid(caller string, ci *structs.CountryInfoExternal, eventAction string, webhook structs.WebhookInternal) bool {
+ if webhook.UUID == "" || webhook.UUID == caller { // Validate that the webhook is associated with the user.
+ // (Empty UUID is for developer webhooks)
+ if webhook.Country == "" || webhook.Country == ci.IsoCode { // Validate webhook for country.
+ // The event is about.
+ return stringListContains(webhook.Event, eventAction) // Validate and return if webhook contains trigger event.
}
}
+ return false
}
-func isWebhookValid(caller string, ci *structs.CountryInfoGet, eventAction string, webhook structs.WebhookGet) bool {
+// isDashboardWebhookValid checks if the webhook should trigger for the dashboard event.
+func isDashboardWebhookValid(caller string, dr *structs.DashboardResponse, eventAction string, webhook structs.WebhookInternal) bool {
if webhook.UUID == "" || webhook.UUID == caller {
- if webhook.Country == "" || webhook.Country == ci.IsoCode {
- if stringListContains(webhook.Event, eventAction) {
- return true
- }
- return false
+ if webhook.Country == "" || webhook.Country == dr.IsoCode {
+ return stringListContains(webhook.Event, eventAction)
}
- return false
}
return false
}
+// stringListContains checks if a string is present in a slice of strings.
func stringListContains(s []string, str string) bool {
for _, v := range s {
if v == str {
@@ -105,40 +141,23 @@ func stringListContains(s []string, str string) bool {
return false
}
-func sendDiscordWebhookPayload(email, title string, color int, event, endpoint string, requestBody *structs.CountryInfoGet, payloadUrl string) {
- // Serialize the requestBody to a JSON string with pretty printing
- requestBodyJSON, err := json.MarshalIndent(requestBody, "", " ")
+// sendDiscordWebhookPayload sends a structured message as a Discord webhook.
+func sendDiscordWebhookPayload(email, title string, color int, event, endpoint string, requestBody interface{}, payloadUrl string) {
+ requestBodyJSON, err := json.MarshalIndent(requestBody, "", " ") // Pretty-print JSON for readability.
if err != nil {
- fmt.Println("Error marshaling request body:", err)
+ log.Println("Error marshaling request body:", err)
return
}
- // Remove the UUID field from the payload.
+
requestBodyString := string(requestBodyJSON)
- requestBodyString = strings.Replace(requestBodyString, " \"uuid\": \"\",\n", "", -1)
- requestBodyString = fmt.Sprintf("```json\n%s\n```", requestBodyString)
+ requestBodyString = fmt.Sprintf("```json\n%s\n```", requestBodyString) // Format JSON for Discord code block.
- // Define default and dynamic fields
+ // Create the payload for the Discord webhook.
fields := []structs.Field{
- {
- Name: "Event",
- Value: event,
- Inline: true,
- },
- {
- Name: "Endpoint",
- Value: endpoint,
- Inline: true,
- },
- {
- Name: "Country",
- Value: requestBody.IsoCode,
- Inline: true,
- },
- {
- Name: "Payload",
- Value: requestBodyString,
- Inline: false,
- },
+ {Name: "Event", Value: event, Inline: true},
+ {Name: "Endpoint", Value: endpoint, Inline: true},
+ {Name: "Country", Value: isocode, Inline: true},
+ {Name: "Payload", Value: requestBodyString, Inline: false},
}
payload := structs.WebhookPayload{
@@ -146,101 +165,69 @@ func sendDiscordWebhookPayload(email, title string, color int, event, endpoint s
AvatarURL: "https://i.imgur.com/vjsvcxU.png",
Embeds: []structs.Embed{
{
- Title: title,
- Author: structs.Author{
- Name: "User: " + email,
- },
+ Title: title,
+ Author: structs.Author{Name: "User: " + email},
Description: "-------------------------------------------------------------------------------------",
- Timestamp: time.Now().Format(time.RFC3339), // Formatting the current time to RFC 3339
+ Timestamp: time.Now().Format(time.RFC3339),
Color: color,
Fields: fields,
- Footer: structs.Footer{
- Text: "Webhook Triggered:",
- },
+ Footer: structs.Footer{Text: "Webhook Triggered:"},
},
},
}
- // Convert the payload into a JSON string
- payloadBytes, err := json.Marshal(payload)
+ payloadBytes, err := json.Marshal(payload) // Serialize the payload into JSON.
if err != nil {
- fmt.Println("Error marshaling payload:", err)
+ log.Println("Error marshaling payload:", err)
return
}
- // Create a new request using http
- req, err := http.NewRequest("POST", payloadUrl, bytes.NewBuffer(payloadBytes))
+ req, err := http.NewRequest("POST", payloadUrl, bytes.NewBuffer(payloadBytes)) // Create a POST request with the payload.
if err != nil {
- fmt.Println("Error creating request:", err)
+ log.Println("Error creating request:", err)
return
}
- // Set headers
- req.Header.Set("Content-Type", "application/json")
+ req.Header.Set("Content-Type", "application/json") // Set content type to JSON.
- // Execute the request
client := &http.Client{}
- resp, err := client.Do(req)
+ _, err = client.Do(req) // Send the request.
if err != nil {
- fmt.Println("Error sending request:", err)
+ log.Println("Error sending request:", err)
return
}
-
- // Read the response body
- body, err := io.ReadAll(resp.Body)
- if err != nil {
- fmt.Println("Error reading response body:", err)
- return
- }
-
- // You can now log the response status and body
- fmt.Println("Response Status:", resp.Status)
- fmt.Println("Response Body:", string(body))
}
+// sendWebhookPayload sends a JSON formatted message to a generic webhook.
func sendWebhookPayload(email, title string, event, endpoint, country string, payloadUrl string) {
-
+ // Create the generic webhook payload.
payload := map[string]interface{}{
"User": email,
"title": title,
"event": event,
"endpoint": endpoint,
"country": country,
- "timestamp": time.Now().Format(time.RFC3339), // Formatting the current time to RFC 3339
+ "timestamp": time.Now().UTC().Format("2006-01-02T15:04:05.999Z"), // Format current time in ISO8601 format.
}
- // Convert the payload into a JSON string
- payloadBytes, err := json.Marshal(payload)
+ payloadBytes, err := json.Marshal(payload) // Serialize the payload into JSON.
if err != nil {
- fmt.Println("Error marshaling payload:", err)
+ log.Println("Error marshaling payload:", err)
return
}
- // Create a new request using http
- req, err := http.NewRequest(http.MethodPost, payloadUrl, bytes.NewBuffer(payloadBytes))
+ req, err := http.NewRequest(http.MethodPost, payloadUrl, bytes.NewBuffer(payloadBytes)) // Create a POST request with the payload.
if err != nil {
- fmt.Println("Error creating request:", err)
+ log.Println("Error creating request:", err)
return
}
- // Set headers
- req.Header.Set("Content-Type", "application/json")
+ req.Header.Set("Content-Type", "application/json") // Set content type to JSON.
- // Execute the request
client := &http.Client{}
- resp, err := client.Do(req)
+ _, err = client.Do(req) // Send the request.
if err != nil {
- fmt.Println("Error sending request:", err)
+ log.Println("Error sending request:", err)
return
}
-
- // Read the response body
- body, err := io.ReadAll(resp.Body)
- if err != nil {
- fmt.Println("Error reading response body:", err)
- return
- }
-
- // You can now log the response status and body
- log.Println("Response Status:" + resp.Status + "Response Body:" + string(body))
}
diff --git a/Go/internal/handlers/empty_handler.go b/Go/internal/handlers/empty_handler.go
index f0a799a246a8c2246c9e989cfc462e3c2d9f9471..a6d47804617f739efe782ad902f0e0d328ae6b4e 100644
--- a/Go/internal/handlers/empty_handler.go
+++ b/Go/internal/handlers/empty_handler.go
@@ -1,4 +1,4 @@
-// Package handlers provide HTTP request handlers for routing and handling requests within the Gutendex API.
+// Package handlers provide HTTP request handlers for routing and handling requests within the application.
package handlers
import (
@@ -9,44 +9,42 @@ import (
)
const (
- ISE = "Internal Server Error"
+ ISE = "Internal Server Error" // ISE defines the error message returned when an internal server error occurs.
)
-// EmptyHandler handles every request to the root path by redirecting to the endpoints.
+// EmptyHandler serves the "root.html" file at the root URL ("/") and returns a 404 Not Found error for other paths.
func EmptyHandler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
- http.NotFound(w, r)
+ http.NotFound(w, r) // Return a 404 Not Found error if the path is not the root.
return
}
- filePath := "./web/root.html"
+ filePath := "./web/root.html" // Path to the "root.html" file.
- // Set the "Content-Type" header.
- w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ w.Header().Set("Content-Type", "text/html; charset=utf-8") // Set the "Content-Type" header.
+ w.WriteHeader(http.StatusSeeOther) // Set the status code to 303 See Other,
+ // indicating redirection.
- // Set the status code to indicate the redirection.
- w.WriteHeader(http.StatusSeeOther)
-
- // Open the file.
- file, err := os.Open(filePath)
+ file, err := os.Open(filePath) // Open the "root.html" file.
if err != nil {
- log.Print("Error opening root file: ", err)
- http.Error(w, ISE, http.StatusInternalServerError)
+ log.Print("Error opening root file: ", err) // Log error if file opening fails.
+ http.Error(w, ISE, http.StatusInternalServerError) // Return a 500 Internal Server Error if the file cannot be opened.
return
}
- defer func(file *os.File) {
+ defer func(file *os.File) { // Ensure the file is closed after serving it.
err := file.Close()
if err != nil {
- log.Print("Error closing root file: ", err)
- http.Error(w, ISE, http.StatusInternalServerError)
- return
+ log.Print("Error closing root file: ", err) // Log error if file closing fails.
+ http.Error(w, ISE, http.StatusInternalServerError) // Return a 500 Internal Server Error
+ // if the file cannot be closed.
}
}(file)
- _, err = io.Copy(w, file)
+ _, err = io.Copy(w, file) // Copy the file content to the response writer.
if err != nil {
- log.Print("Error copying root file to ResponseWriter: ", err)
- http.Error(w, ISE, http.StatusInternalServerError)
+ log.Print("Error copying root file to ResponseWriter: ", err) // Log error if copying fails.
+ http.Error(w, ISE, http.StatusInternalServerError) // Return a 500 Internal Server Error
+ // if content cannot be copied.
return
}
}
diff --git a/Go/internal/handlers/endpoint/dashboard/dashboards_handler.go b/Go/internal/handlers/endpoint/dashboard/dashboards_handler.go
deleted file mode 100644
index 67348733d16121a72d0bf93243063c6059182710..0000000000000000000000000000000000000000
--- a/Go/internal/handlers/endpoint/dashboard/dashboards_handler.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Package dashboard provides handlers for dashboard-related endpoints.
-package dashboard
-
-import (
- "net/http"
-)
-
-// DashboardsHandler handles requests to the book count API endpoint.
-func DashboardsHandler(w http.ResponseWriter, r *http.Request) {
- switch r.Method {
- case http.MethodGet:
- handleBookCountGetRequest(w, r)
- default:
- http.Error(w, "REST Method: "+r.Method+" not supported. Currently no methods are supported.", http.StatusNotImplemented)
- return
- }
-}
-
-// handleBookCountGetRequest handles GET requests to retrieve book count information.
-func handleBookCountGetRequest(w http.ResponseWriter, r *http.Request) {
- //TODO::Complete HTTP Method Requests
-}
diff --git a/Go/internal/handlers/endpoint/dashboard/dashboards_id_handler.go b/Go/internal/handlers/endpoint/dashboard/dashboards_id_handler.go
new file mode 100644
index 0000000000000000000000000000000000000000..db30e52dc0e2871e8e1bd4ca9d161116caf1dbbb
--- /dev/null
+++ b/Go/internal/handlers/endpoint/dashboard/dashboards_id_handler.go
@@ -0,0 +1,196 @@
+// Package dashboard provides handlers for managing dashboard-related functionalities through HTTP endpoints.
+package dashboard
+
+import (
+ "encoding/json"
+ "fmt"
+ "globeboard/db"
+ _func "globeboard/internal/func"
+ "globeboard/internal/utils/constants"
+ "globeboard/internal/utils/constants/Endpoints"
+ "globeboard/internal/utils/structs"
+ "log"
+ "net/http"
+ "strconv"
+ "time"
+)
+
+const (
+ APIInfoRetrivalError = "Error getting country information" // Error message for when country information cannot be retrieved.
+ APICoordsRetrivalError = "Error getting Coordinates Information: " // Error message for when coordinates information cannot be retrieved.
+)
+
+// DashboardsIdHandler handles requests to the dashboard endpoint.
+func DashboardsIdHandler(w http.ResponseWriter, r *http.Request) {
+ switch r.Method {
+ case http.MethodGet: // Handle GET request.
+ handleDashboardGetRequest(w, r)
+ default:
+ // Log and return an error for unsupported HTTP methods
+ log.Printf(constants.ClientConnectUnsupported, Endpoints.DashboardsID, r.Method)
+ http.Error(w, "REST Method: "+r.Method+" not supported. Only supported methods for this endpoint is:\n"+http.MethodGet, http.StatusNotImplemented)
+ return
+ }
+}
+
+// handleDashboardGetRequest processes GET requests to retrieve dashboards by ID.
+func handleDashboardGetRequest(w http.ResponseWriter, r *http.Request) {
+ ID := r.PathValue("ID") // Retrieve ID from URL path.
+ query := r.URL.Query() // Extract the query parameters.
+ token := query.Get("token") // Retrieve token from URL query parameters.
+ if token == "" { // Check if a token is provided.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.DashboardsID)
+ http.Error(w, ProvideAPI, http.StatusUnauthorized)
+ return
+ }
+ UUID := db.GetAPIKeyUUID(token) // Retrieve UUID associated with API token.
+ if UUID == "" { // Check if UUID is retrieved.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.DashboardsID)
+ err := fmt.Sprintf(APINotAccepted)
+ http.Error(w, err, http.StatusNotAcceptable)
+ return
+ }
+ if ID == "" || ID == " " { // Check if the ID is valid.
+ log.Printf(constants.ClientConnectNoID, r.Method, Endpoints.DashboardsID)
+ http.Error(w, ProvideID, http.StatusBadRequest)
+ return
+ }
+
+ reg, err := db.GetSpecificRegistration(ID, UUID) // Retrieve registration by ID for user (UUID).
+ if err != nil {
+ log.Printf("Error getting registration: %v", err)
+ err := fmt.Sprintf("Dashboard doesn't exist: %v", err)
+ http.Error(w, err, http.StatusNotFound)
+ return
+ }
+
+ dr := new(structs.DashboardResponse) // Initialize new DashboardResponse struct.
+
+ // Set retrieved values to response.
+ dr.ID = reg.ID
+ dr.Country = reg.Country
+ dr.IsoCode = reg.IsoCode
+
+ // Country information API integration.
+ if getCountryInfo(w, reg, dr) {
+ return
+ }
+
+ // Currency information API integration.
+ if getCurrencyInfo(w, reg, dr) {
+ return
+ }
+
+ // Weather information API integration.
+ if getWeatherInfo(w, reg, dr) {
+ return
+ }
+
+ // Set the LastRetrieval time and format it to ISO8601 format to mirror Firestore Server Timestamp.
+ dr.LastRetrieval = time.Now().UTC().Format("2006-01-02T15:04:05.999Z")
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusOK)
+ err = json.NewEncoder(w).Encode(dr) // Encode the dashboard response into JSON and write to the response writer.
+ if err != nil {
+ log.Print(err)
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ _func.LoopSendWebhooksDashboard(UUID, dr) // Send notifications to webhooks.
+}
+
+// getWeatherInfo fetches weather information for a specific registration and updates the dashboard response.
+func getWeatherInfo(w http.ResponseWriter, reg *structs.CountryInfoInternal, dr *structs.DashboardResponse) bool {
+ if reg.Features.Temperature { // Check if the temperature feature is enabled.
+ coords, err := _func.GetCoordinates(reg.IsoCode) // Get coordinates for the ISO code.
+ if err != nil {
+ log.Print(APICoordsRetrivalError, err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ temp, err := _func.GetTemp(coords) // Get temperature for the coordinates.
+ if err != nil {
+ log.Print("Error getting Temperature Information: ", err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ dr.Features.Temperature = strconv.FormatFloat(temp, 'f', 1, 64) // Format temperature and set to dashboard response.
+ }
+
+ if reg.Features.Precipitation { // Check if the precipitation feature is enabled.
+ coords, err := _func.GetCoordinates(reg.IsoCode) // Get coordinates for the ISO code.
+ if err != nil {
+ log.Print(APICoordsRetrivalError, err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ precipitation, err := _func.GetPrecipitation(coords) // Get precipitation for the coordinates.
+ if err != nil {
+ log.Print("Error getting Temperature Information: ", err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ dr.Features.Precipitation = strconv.FormatFloat(precipitation, 'f', 2, 64) // Format precipitation and set to dashboard response.
+ }
+ return false
+}
+
+// getCurrencyInfo fetches currency exchange information for a specific registration and updates the dashboard response.
+func getCurrencyInfo(w http.ResponseWriter, reg *structs.CountryInfoInternal, dr *structs.DashboardResponse) bool {
+ if reg.Features.TargetCurrencies != nil && len(reg.Features.TargetCurrencies) > 0 { // Check if target-currencies feature is non nil and non-empty.
+ exchangeRate, err := _func.GetExchangeRate(reg.IsoCode, reg.Features.TargetCurrencies) // Get exchange rates for the target currencies.
+ if err != nil {
+ log.Print("Error getting Exchange Rate Information: ", err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ dr.Features.TargetCurrencies = exchangeRate // Set exchange rates to dashboard response.
+ }
+ return false
+}
+
+// getCountryInfo fetches country-specific information for a specific registration and updates the dashboard response.
+func getCountryInfo(w http.ResponseWriter, reg *structs.CountryInfoInternal, dr *structs.DashboardResponse) bool {
+ if reg.Features.Capital { // Check if the capital feature is enabled.
+ capital, err := _func.GetCapital(reg.IsoCode) // Get capital for the ISO code.
+ if err != nil {
+ log.Print("Error getting Capital Information: ", err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ dr.Features.Capital = capital // Set capital to dashboard response.
+ }
+
+ if reg.Features.Coordinates { // Check if the coordinate feature is enabled.
+ coords, err := _func.GetCoordinates(reg.IsoCode) // Get coordinates for the ISO code.
+ if err != nil {
+ log.Print(APICoordsRetrivalError, err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ dr.Features.Coordinates = &coords // Set coordinates to dashboard response.
+ }
+
+ if reg.Features.Population { // Check if the population feature is enabled.
+ pop, err := _func.GetPopulation(reg.IsoCode) // Get population for the ISO code.
+ if err != nil {
+ log.Print("Error getting Population Information: ", err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ dr.Features.Population = pop // Set population to dashboard response.
+ }
+
+ if reg.Features.Area { // Check if area feature is enabled.
+ area, err := _func.GetArea(reg.IsoCode) // Get area for the ISO code.
+ if err != nil {
+ log.Print("Error getting Area Information: ", err)
+ http.Error(w, APIInfoRetrivalError, http.StatusInternalServerError)
+ return true
+ }
+ dr.Features.Area = strconv.FormatFloat(area, 'f', 1, 64) // Format area and set to dashboard response.
+ }
+ return false
+}
diff --git a/Go/internal/handlers/endpoint/dashboard/notifications_id_handler.go b/Go/internal/handlers/endpoint/dashboard/notifications_id_handler.go
new file mode 100644
index 0000000000000000000000000000000000000000..22ad4d78747e9d86b53ff344468c90f9da96b4ee
--- /dev/null
+++ b/Go/internal/handlers/endpoint/dashboard/notifications_id_handler.go
@@ -0,0 +1,104 @@
+// Package dashboard provides handlers for managing dashboard-related functionalities through HTTP endpoints.
+package dashboard
+
+import (
+ "encoding/json"
+ "fmt"
+ "globeboard/db"
+ "globeboard/internal/utils/constants"
+ "globeboard/internal/utils/constants/Endpoints"
+ "log"
+ "net/http"
+)
+
+// NotificationsIdHandler handles HTTP requests related to specific notification settings by ID.
+func NotificationsIdHandler(w http.ResponseWriter, r *http.Request) {
+ switch r.Method {
+ case http.MethodGet: // Handle GET request
+ handleNotifGetRequest(w, r)
+ case http.MethodDelete: // Handle DELETE request
+ handleNotifDeleteRequest(w, r)
+ default:
+ // Log and return an error for unsupported HTTP methods
+ log.Printf(constants.ClientConnectUnsupported, Endpoints.NotificationsID, r.Method)
+ http.Error(w, "REST Method: "+r.Method+" not supported. Only supported methods for this endpoint are:\n"+http.MethodGet+"\n"+http.MethodDelete, http.StatusNotImplemented)
+ return
+ }
+}
+
+// handleNotifGetRequest processes GET requests to retrieve a specific notification webhook by its ID.
+func handleNotifGetRequest(w http.ResponseWriter, r *http.Request) {
+ ID := r.PathValue("ID") // Retrieve the ID from the URL path.
+ query := r.URL.Query() // Extract the query parameters.
+ token := query.Get("token") // Retrieve token from the URL query parameters.
+ if token == "" { // Check if a token is provided.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.NotificationsID)
+ http.Error(w, ProvideAPI, http.StatusUnauthorized)
+ return
+ }
+ UUID := db.GetAPIKeyUUID(token) // Retrieve UUID associated with the API token.
+ if UUID == "" { // Check if UUID is valid.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.NotificationsID)
+ err := fmt.Sprintf(APINotAccepted)
+ http.Error(w, err, http.StatusNotAcceptable)
+ return
+ }
+ if ID == "" || ID == " " { // Check if the ID is valid.
+ log.Printf(constants.ClientConnectNoID, r.Method, Endpoints.NotificationsID)
+ http.Error(w, ProvideID, http.StatusBadRequest)
+ return
+ }
+
+ hook, err := db.GetSpecificWebhook(ID, UUID) // Retrieve the specific webhook by ID and UUID.
+ if err != nil {
+ log.Printf("Error getting webhook from database: %v", err)
+ err := fmt.Sprintf("Error getting webhook from database: %v", err)
+ http.Error(w, err, http.StatusNotFound)
+ return
+ }
+
+ w.Header().Set(ContentType, ApplicationJSON) // Set the content type of the response.
+
+ w.WriteHeader(http.StatusOK) // Set HTTP status to "OK".
+
+ err = json.NewEncoder(w).Encode(hook) // Encode the webhook as JSON and send it.
+ if err != nil {
+ log.Print(err)
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+}
+
+// handleNotifDeleteRequest processes DELETE requests to remove a specific notification webhook by its ID.
+func handleNotifDeleteRequest(w http.ResponseWriter, r *http.Request) {
+ ID := r.PathValue("ID") // Retrieve the ID from the URL path.
+ query := r.URL.Query() // Extract the query parameters.
+ token := query.Get("token") // Retrieve token from the URL query parameters.
+ if token == "" { // Check if a token is provided.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.NotificationsID)
+ http.Error(w, ProvideAPI, http.StatusUnauthorized)
+ return
+ }
+ UUID := db.GetAPIKeyUUID(token) // Retrieve UUID associated with the API token.
+ if UUID == "" { // Check if UUID is valid.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.NotificationsID)
+ err := fmt.Sprintf(APINotAccepted)
+ http.Error(w, err, http.StatusNotAcceptable)
+ return
+ }
+ if ID == "" || ID == " " { // Check if the ID is valid.
+ log.Printf(constants.ClientConnectNoID, r.Method, Endpoints.NotificationsID)
+ http.Error(w, ProvideID, http.StatusBadRequest)
+ return
+ }
+
+ err := db.DeleteWebhook(ID, UUID) // Delete the specific webhook by ID and UUID from the database.
+ if err != nil {
+ log.Printf("Error deleting data from database: %v", err)
+ err := fmt.Sprintf("Error deleting data from database: %v", err)
+ http.Error(w, err, http.StatusInternalServerError)
+ return
+ }
+
+ w.WriteHeader(http.StatusNoContent) // Set HTTP status to "No Content" upon successful deletion.
+}
diff --git a/Go/internal/handlers/endpoint/dashboard/registrations_handler.go b/Go/internal/handlers/endpoint/dashboard/registrations_handler.go
index 27b374b6643c9df10a17c47e96d3d61107335de2..99b60454f9e8afc89d3c59427e2c94217df461e2 100644
--- a/Go/internal/handlers/endpoint/dashboard/registrations_handler.go
+++ b/Go/internal/handlers/endpoint/dashboard/registrations_handler.go
@@ -1,4 +1,4 @@
-// Package dashboard provides handlers for dashboard-related endpoints.
+// Package dashboard provides handlers for managing dashboard-related functionalities through HTTP endpoints.
package dashboard
import (
@@ -15,146 +15,168 @@ import (
"net/http"
)
+// Constant strings used for API responses and header configurations
const (
- ProvideAPI = "Please provide API Token"
- APINotAccepted = "API key not accepted"
- ContentType = "Content-Type"
- ApplicationJSON = "application/json"
+ ProvideAPI = "Please provide API Token" // Message prompting for API token
+ APINotAccepted = "API key not accepted" // Message for an unauthorized API token
+ ContentType = "Content-Type" // HTTP header field for content-type
+ ApplicationJSON = "application/json" // MIME type for JSON
)
-// RegistrationsHandler handles HTTP GET requests to retrieve supported languages.
+// RegistrationsHandler routes the HTTP request based on the method (POST, GET) to appropriate handlers
func RegistrationsHandler(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodPost:
- handleRegPostRequest(w, r)
+ handleRegPostRequest(w, r) // Handle POST requests
case http.MethodGet:
- handleRegGetAllRequest(w, r)
+ handleRegGetAllRequest(w, r) // Handle GET requests
default:
+ // Log and return an error for unsupported HTTP methods
+ log.Printf(constants.ClientConnectUnsupported, Endpoints.Registrations, r.Method)
http.Error(w, "REST Method: "+r.Method+" not supported. Only supported methods for this endpoint is:\n"+http.MethodPost+"\n"+http.MethodGet+"\n"+http.MethodPatch, http.StatusNotImplemented)
return
}
}
-func DecodeCountryInfo(data io.ReadCloser) (*structs.CountryInfoGet, error) {
- var ci *structs.CountryInfoGet
+// DecodeCountryInfo decodes JSON data from the request body into a CountryInfoInternal struct
+func DecodeCountryInfo(data io.ReadCloser) (*structs.CountryInfoInternal, error) {
+ var ci *structs.CountryInfoInternal
if err := json.NewDecoder(data).Decode(&ci); err != nil {
- return nil, err
+ return nil, err // Return error if decoding fails
}
- err := _func.ValidateCountryInfo(ci)
+ err := _func.ValidateCountryInfo(ci) // Validate the decoded information
if err != nil {
- return nil, err
+ return nil, err // Return validation errors
}
- return ci, nil
+ return ci, nil // Return the decoded and validated country information
}
-// handleRegPostRequest handles POST requests to register a country.
+// handleRegPostRequest handles the POST requests for registration endpoint
func handleRegPostRequest(w http.ResponseWriter, r *http.Request) {
- query := r.URL.Query()
- token := query.Get("token")
- if token == "" {
+ query := r.URL.Query() // Extract the query parameters.
+ token := query.Get("token") // Extract the 'token' parameter from the query.
+ if token == "" { // Validate token presence.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.Registrations)
http.Error(w, ProvideAPI, http.StatusUnauthorized)
return
}
- UUID := db.GetAPIKeyUUID(token)
- if UUID == "" {
+ UUID := db.GetAPIKeyUUID(token) // Retrieve the UUID for the API key.
+ if UUID == "" { // Validate UUID presence.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.Registrations)
err := fmt.Sprintf(APINotAccepted)
http.Error(w, err, http.StatusNotAcceptable)
return
}
- if r.Body == nil {
+ if r.Body == nil { // Validate that the request body is not empty.
+ log.Printf(constants.ClientConnectEmptyBody, r.Method, Endpoints.Registrations)
err := fmt.Sprintf("Please send a request body")
http.Error(w, err, http.StatusBadRequest)
return
}
- // Decode the body into a CountryInfoPost struct
- ci, err := DecodeCountryInfo(r.Body)
+ ci, err := DecodeCountryInfo(r.Body) // Decode request body into CountryInfoInternal struct.
if err != nil {
+ log.Printf("Error decoding request body: %v", err)
err := fmt.Sprintf("Error decoding request body: %v", err)
http.Error(w, err, http.StatusBadRequest)
return
}
- UDID := _func.GenerateUID(constants.DocIdLength)
- URID := _func.GenerateUID(constants.RegIdLength)
+ UDID := _func.GenerateUID(constants.DocIdLength) // Generate a unique ID for document
+ URID := _func.GenerateUID(constants.IdLength) // Generate a unique ID for registration
ci.ID = URID
ci.UUID = UUID
- err = db.AddRegistration(UDID, ci)
+ err = db.AddRegistration(UDID, ci) // Add Registration to the Database.
if err != nil {
+ log.Println("Error saving data to database" + err.Error())
http.Error(w, "Error storing data in database", http.StatusInternalServerError)
return
}
- reg, err := db.GetSpecificRegistration(URID, UUID)
+ reg, err := db.GetSpecificRegistration(URID, UUID) // Retrieve specific registration details.
if err != nil {
log.Print("Error getting document from database: ", err)
http.Error(w, "Error confirming data added to database", http.StatusInternalServerError)
return
}
- response := map[string]interface{}{
+ response := map[string]interface{}{ // construct JSON response.
"id": reg.ID,
"lastChange": reg.Lastchange,
}
- // Set Content-Type header
- w.Header().Set(ContentType, ApplicationJSON)
+ w.Header().Set(ContentType, ApplicationJSON) // Set the content type of response
- // Write the status code to the response
- w.WriteHeader(http.StatusCreated)
+ w.WriteHeader(http.StatusCreated) // Set HTTP status code to 201 Created
- // Serialize the struct to JSON and write it to the response
- err = json.NewEncoder(w).Encode(response)
+ err = json.NewEncoder(w).Encode(response) // Encode and send the response
if err != nil {
- // Handle error
+ log.Print(err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
- _func.LoopSendWebhooks(UUID, ci, Endpoints.Registrations, Webhooks.EventRegister)
+ cie := new(structs.CountryInfoExternal) // Create new external country info struct.
+ cie.ID = reg.ID
+ cie.Country = reg.Country
+ cie.IsoCode = reg.IsoCode
+ cie.Features = reg.Features
+
+ _func.LoopSendWebhooksRegistrations(UUID, cie, Endpoints.Registrations, Webhooks.EventRegister) // Send webhook notifications
}
-// handleRegGetAllRequest handles GET requests to retrieve a registered country.
+// handleRegGetAllRequest handles the GET requests for registration endpoint to retrieve all registrations
func handleRegGetAllRequest(w http.ResponseWriter, r *http.Request) {
- query := r.URL.Query()
- token := query.Get("token")
- if token == "" {
+ query := r.URL.Query() // Extract the query parameters.
+ token := query.Get("token") // Extract the 'token' parameter from the query.
+ if token == "" { // Validate token presence.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.Registrations)
http.Error(w, ProvideAPI, http.StatusUnauthorized)
return
}
- UUID := db.GetAPIKeyUUID(token)
- if UUID == "" {
+ UUID := db.GetAPIKeyUUID(token) // Extract the UUID parameter from the API token.
+ if UUID == "" { // Validate UUID presence.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.Registrations)
err := fmt.Sprintf(APINotAccepted)
http.Error(w, err, http.StatusNotAcceptable)
return
}
- regs, err := db.GetRegistrations(UUID)
+ regs, err := db.GetRegistrations(UUID) // Retrieve the user's Registrations.
if err != nil {
- errmsg := fmt.Sprint("Error retrieving document from database: ", err)
+ log.Printf("Error retrieving documents from database: %s", err)
+ errmsg := fmt.Sprint("Error retrieving documents from database: ", err)
http.Error(w, errmsg, http.StatusInternalServerError)
return
}
- // Set Content-Type header
- w.Header().Set(ContentType, ApplicationJSON)
+ w.Header().Set(ContentType, ApplicationJSON) // Set the content type of response
+
+ w.WriteHeader(http.StatusOK) // Set HTTP status code to 200 OK
- // Write the status code to the response
- w.WriteHeader(http.StatusOK)
+ var cies []*structs.CountryInfoExternal // Construct CountryInfoExternal slice.
+ for _, reg := range regs { // Loop over the retrieved registrations and parse them to CountryInfoExternal struct.
+ cie := new(structs.CountryInfoExternal)
+ cie.ID = reg.ID
+ cie.Country = reg.Country
+ cie.IsoCode = reg.IsoCode
+ cie.Features = reg.Features
+ cie.Lastchange = reg.Lastchange
+ cies = append(cies, cie) // Append the individual CountryInfoExternal structs to the slice.
+ }
- // Serialize the struct to JSON and write it to the response
- err = json.NewEncoder(w).Encode(regs)
+ err = json.NewEncoder(w).Encode(cies) // Encode and send the response
if err != nil {
- // Handle error
+ log.Print(err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
- for _, reg := range regs {
- _func.LoopSendWebhooks(UUID, reg, Endpoints.Registrations, Webhooks.EventInvoke)
+ for _, cie := range cies {
+ _func.LoopSendWebhooksRegistrations(UUID, cie, Endpoints.Registrations, Webhooks.EventInvoke) // Send webhook notifications on data retrieval
}
}
diff --git a/Go/internal/handlers/endpoint/dashboard/registrations_id_handler.go b/Go/internal/handlers/endpoint/dashboard/registrations_id_handler.go
index 3f4644a2a7a8bd646afb28cc7878d9375deca7b9..98ebc1b5c8e6cfa8e49dac6f26dc05207c5a6979 100644
--- a/Go/internal/handlers/endpoint/dashboard/registrations_id_handler.go
+++ b/Go/internal/handlers/endpoint/dashboard/registrations_id_handler.go
@@ -1,3 +1,4 @@
+// Package dashboard provides handlers for managing dashboard-related functionalities through HTTP endpoints.
package dashboard
import (
@@ -6,6 +7,7 @@ import (
"fmt"
"globeboard/db"
_func "globeboard/internal/func"
+ "globeboard/internal/utils/constants"
"globeboard/internal/utils/constants/Endpoints"
"globeboard/internal/utils/constants/Webhooks"
"globeboard/internal/utils/structs"
@@ -14,175 +16,229 @@ import (
"net/http"
)
+// Constants for error and informational messages.
const (
- ProvideID = "Please Provide ID"
+ ProvideID = "Please Provide ID" // Message to request ID provision when missing.
+ RegistrationRetrivalError = "Error getting registration: %v" // Error message template for retrieval issues.
+ RegistrationPatchError = "Error patching registration: %v" // Error message template for patching issues.
)
-// RegistrationsIdHandler handles HTTP GET requests to retrieve supported languages.
+// RegistrationsIdHandler handles requests for the /registrations/{ID} endpoint.
func RegistrationsIdHandler(w http.ResponseWriter, r *http.Request) {
switch r.Method {
- case http.MethodGet:
+ case http.MethodGet: // Handle GET requests.
handleRegGetRequest(w, r)
- case http.MethodPatch:
+ case http.MethodPatch: // Handle PATCH requests.
handleRegPatchRequest(w, r)
- case http.MethodDelete:
+ case http.MethodDelete: // Handle DELETE requests.
handleRegDeleteRequest(w, r)
default:
+ // Log and return an error for unsupported HTTP methods
+ log.Printf(constants.ClientConnectUnsupported, Endpoints.RegistrationsID, r.Method)
http.Error(w, "REST Method: "+r.Method+" not supported. Only supported methods for this endpoint is:\n"+http.MethodGet+"\n"+http.MethodPatch+"\n"+http.MethodDelete, http.StatusNotImplemented)
return
}
}
-// handleRegGetRequest handles GET requests to retrieve a registered country.
+// handleRegGetRequest processes GET requests for registration data by ID.
func handleRegGetRequest(w http.ResponseWriter, r *http.Request) {
- ID := r.PathValue("ID")
- query := r.URL.Query()
- token := query.Get("token")
- if token == "" {
+ ID := r.PathValue("ID") // Extract the 'ID' parameter from the URL path.
+ query := r.URL.Query() // Extract the query parameters.
+ token := query.Get("token") // Extract the 'token' parameter from the query.
+ if token == "" { // Validate token presence.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.RegistrationsID)
http.Error(w, ProvideAPI, http.StatusUnauthorized)
return
}
- UUID := db.GetAPIKeyUUID(token)
- if UUID == "" {
+ UUID := db.GetAPIKeyUUID(token) // Retrieve the UUID for the API key.
+ if UUID == "" { // Validate UUID presence.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.RegistrationsID)
err := fmt.Sprintf(APINotAccepted)
http.Error(w, err, http.StatusNotAcceptable)
return
}
- if ID == "" {
+ if ID == "" || ID == " " { // Validate ID presence.
+ log.Printf(constants.ClientConnectNoID, r.Method, Endpoints.RegistrationsID)
http.Error(w, ProvideID, http.StatusBadRequest)
return
}
- reg, err := db.GetSpecificRegistration(ID, UUID)
+ reg, err := db.GetSpecificRegistration(ID, UUID) // Retrieve registration data from the database.
if err != nil {
- log.Print("Error getting document from database: ", err)
- http.Error(w, "Error retrieving data from database", http.StatusInternalServerError)
+ log.Printf(RegistrationRetrivalError, err)
+ http.Error(w, "Error retrieving data from database", http.StatusNotFound)
return
}
- // Set Content-Type header
- w.Header().Set(ContentType, ApplicationJSON)
+ w.Header().Set(ContentType, ApplicationJSON) // Set the Content-Type header.
- // Write the status code to the response
- w.WriteHeader(http.StatusOK)
+ w.WriteHeader(http.StatusOK) // Set the HTTP status code to 200.
- // Serialize the struct to JSON and write it to the response
- err = json.NewEncoder(w).Encode(reg)
+ cie := new(structs.CountryInfoExternal) // Create new external country info struct.
+ cie.ID = reg.ID
+ cie.Country = reg.Country
+ cie.IsoCode = reg.IsoCode
+ cie.Features = reg.Features
+ cie.Lastchange = reg.Lastchange
+
+ err = json.NewEncoder(w).Encode(cie) // Encode the external country info into JSON and write to the response.
if err != nil {
- // Handle error
+ log.Print(err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
- _func.LoopSendWebhooks(UUID, reg, Endpoints.RegistrationsID, Webhooks.EventInvoke)
+ _func.LoopSendWebhooksRegistrations(UUID, cie, Endpoints.RegistrationsID, Webhooks.EventInvoke) // Trigger webhooks for the registration.
}
-// handleRegPatchRequest handles PUT requests to Update a registered country.
+// handleRegPatchRequest processes PATCH requests to update registration data by ID.
func handleRegPatchRequest(w http.ResponseWriter, r *http.Request) {
- ID := r.PathValue("ID")
- query := r.URL.Query()
- token := query.Get("token")
- if token == "" {
+ ID := r.PathValue("ID") // Extract the 'ID' parameter from the URL path.
+ query := r.URL.Query() // Extract the query parameters.
+ token := query.Get("token") // Extract the 'token' parameter from the query.
+ if token == "" { // Validate token presence.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.RegistrationsID)
http.Error(w, ProvideAPI, http.StatusUnauthorized)
return
}
- UUID := db.GetAPIKeyUUID(token)
- if UUID == "" {
+ UUID := db.GetAPIKeyUUID(token) // Retrieve the UUID for the API key.
+ if UUID == "" { // Validate UUID presence.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.RegistrationsID)
err := fmt.Sprintf(APINotAccepted)
http.Error(w, err, http.StatusNotAcceptable)
return
}
- if ID == "" {
+ if ID == "" || ID == " " { // Validate ID presence.
+ log.Printf(constants.ClientConnectNoID, r.Method, Endpoints.RegistrationsID)
http.Error(w, ProvideID, http.StatusBadRequest)
return
}
- if r.Body == nil {
+ if r.Body == nil { // Validate that the request body is not empty.
+ log.Printf(constants.ClientConnectEmptyBody, r.Method, Endpoints.RegistrationsID)
err := fmt.Sprintf("Please send a request body")
http.Error(w, err, http.StatusBadRequest)
return
}
- countryInfo, err, errcode := patchCountryInformation(r, ID, UUID)
+ ci, err, errcode := patchCountryInformation(r, ID, UUID) // Process the patch request.
if err != nil {
- err := fmt.Sprintf("Error patching data together: %v", err)
+ log.Printf(RegistrationPatchError, err)
+ err := fmt.Sprintf(RegistrationPatchError, err)
http.Error(w, err, errcode)
return
}
- err = _func.ValidateCountryInfo(countryInfo)
+ err = _func.ValidateCountryInfo(ci) // Validate the patched country information.
if err != nil {
- http.Error(w, err.Error(), http.StatusBadRequest)
+ log.Printf(RegistrationPatchError, err)
+ err := fmt.Sprintf(RegistrationPatchError, err)
+ http.Error(w, err, http.StatusBadRequest)
return
}
- err = db.UpdateRegistration(ID, UUID, countryInfo)
+ err = db.UpdateRegistration(ID, UUID, ci) // Update the registration in the database.
if err != nil {
+ log.Printf("Error saving patched data to database: %v", err)
err := fmt.Sprintf("Error saving patched data to database: %v", err)
http.Error(w, err, http.StatusInternalServerError)
return
}
- w.WriteHeader(http.StatusAccepted)
+ reg, err := db.GetSpecificRegistration(ID, UUID) // Retrieve the updated registration.
+ if err != nil {
+ log.Printf(RegistrationRetrivalError, err)
+ err := fmt.Sprint("Error retrieving updated document: ", err)
+ http.Error(w, err, http.StatusNotFound)
+ return
+ }
+
+ cie := new(structs.CountryInfoExternal) // Create new external country info struct.
+ cie.ID = reg.ID
+ cie.Country = reg.Country
+ cie.IsoCode = reg.IsoCode
+ cie.Features = reg.Features
+ cie.Lastchange = reg.Lastchange
- _func.LoopSendWebhooks(UUID, countryInfo, Endpoints.RegistrationsID, Webhooks.EventChange)
+ w.Header().Set("content-type", "application/json") // Set the Content-Type header.
+ w.WriteHeader(http.StatusAccepted) // Set the HTTP status code to 202.
+
+ response := map[string]interface{}{
+ "lastChange": cie.Lastchange, // Prepare the response data.
+ }
+
+ err = json.NewEncoder(w).Encode(response) // Encode the response data into JSON and write to the response.
+ if err != nil {
+ log.Print(err)
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ _func.LoopSendWebhooksRegistrations(UUID, cie, Endpoints.RegistrationsID, Webhooks.EventChange) // Trigger webhooks for the change event.
}
-func patchCountryInformation(r *http.Request, ID, UUID string) (*structs.CountryInfoGet, error, int) {
- reg, err := db.GetSpecificRegistration(ID, UUID)
+// patchCountryInformation updates the country information based on the provided patch data.
+func patchCountryInformation(r *http.Request, ID, UUID string) (*structs.CountryInfoInternal, error, int) {
+ reg, err := db.GetSpecificRegistration(ID, UUID) // Retrieve the specific registration.
if err != nil {
- return nil, err, http.StatusInternalServerError
+ log.Printf(RegistrationRetrivalError, err)
+ return nil, err, http.StatusNotFound
}
- bytes, err := json.Marshal(reg)
+ bytes, err := json.Marshal(reg) // Marshal the registration data to JSON bytes.
if err != nil {
+ log.Print(err)
return nil, err, http.StatusInternalServerError
}
- var originalData map[string]interface{}
+ var originalData map[string]interface{} // Unmarshal the JSON bytes back to a map.
err = json.Unmarshal(bytes, &originalData)
if err != nil {
+ log.Print(err)
return nil, err, http.StatusInternalServerError
}
- all, err := io.ReadAll(r.Body)
+ all, err := io.ReadAll(r.Body) // Read all data from the request body.
if err != nil {
+ log.Print(err)
return nil, err, http.StatusInternalServerError
}
- var patchData map[string]interface{}
+ var patchData map[string]interface{} // Unmarshal the patch data from the request body.
err = json.Unmarshal(all, &patchData)
if err != nil {
+ log.Print(err)
return nil, err, http.StatusInternalServerError
}
- patchFeatures, err, errcode := validatePatchData(patchData, originalData)
+ patchFeatures, err, errcode := validatePatchData(patchData, originalData) // Validate and extract the patch data.
if err != nil {
return nil, err, errcode
}
- if originalData["features"] != nil {
+ if originalData["features"] != nil { // Merge the patch features into the original features.
originalFeatures := originalData["features"].(map[string]interface{})
for key, value := range patchFeatures {
originalFeatures[key] = value
}
}
- // Marshal the original data back to JSON.
- jsonData, err := json.Marshal(originalData)
+ jsonData, err := json.Marshal(originalData) // Marshal the updated data to JSON.
if err != nil {
+ log.Print(err)
return nil, err, http.StatusInternalServerError
}
- // Unmarshal the JSON data into the CountryInfoGet struct.
- var countryInfo *structs.CountryInfoGet
+ var countryInfo *structs.CountryInfoInternal // Unmarshal the JSON data to a CountryInfoInternal struct.
err = json.Unmarshal(jsonData, &countryInfo)
if err != nil {
+ log.Print(err)
return nil, err, http.StatusInternalServerError
}
return countryInfo, nil, http.StatusOK
}
+// validatePatchData checks the validity of the patch data against the original data.
func validatePatchData(patchData map[string]interface{}, originalData map[string]interface{}) (map[string]interface{}, error, int) {
// Check if "country" or "isoCode" fields are provided and if they are non-empty and differ from the original data.
if country, ok := patchData["country"]; ok {
@@ -191,9 +247,9 @@ func validatePatchData(patchData map[string]interface{}, originalData map[string
}
}
- if isoCode, ok := patchData["isoCode"]; ok {
- if isoCodeStr, isStr := isoCode.(string); isStr && isoCodeStr != "" && originalData["isoCode"] != isoCode {
- return nil, errors.New("modification of 'isoCode' field is not allowed"), http.StatusBadRequest
+ if isoCode, ok := patchData["isocode"]; ok {
+ if isoCodeStr, isStr := isoCode.(string); isStr && isoCodeStr != "" && originalData["isocode"] != isoCode {
+ return nil, errors.New("modification of 'isocode' field is not allowed"), http.StatusBadRequest
}
}
@@ -209,40 +265,53 @@ func validatePatchData(patchData map[string]interface{}, originalData map[string
return patchFeatures, nil, http.StatusOK
}
+// handleRegDeleteRequest processes DELETE requests to remove registration data by ID.
func handleRegDeleteRequest(w http.ResponseWriter, r *http.Request) {
- ID := r.PathValue("ID")
- query := r.URL.Query()
- token := query.Get("token")
- if token == "" {
+ ID := r.PathValue("ID") // Extract the 'ID' parameter from the URL path.
+ query := r.URL.Query() // Extract the query parameters.
+ token := query.Get("token") // Extract the 'token' parameter from the query.
+ if token == "" { // Validate token presence.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.RegistrationsID)
http.Error(w, ProvideAPI, http.StatusUnauthorized)
return
}
- UUID := db.GetAPIKeyUUID(token)
- if UUID == "" {
+ UUID := db.GetAPIKeyUUID(token) // Retrieve the UUID for the API key.
+ if UUID == "" { // Validate UUID presence.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.RegistrationsID)
err := fmt.Sprintf(APINotAccepted)
http.Error(w, err, http.StatusNotAcceptable)
return
}
- if ID == "" {
+ if ID == "" || ID == " " { // Validate ID presence.
+ log.Printf(constants.ClientConnectNoID, r.Method, Endpoints.RegistrationsID)
http.Error(w, ProvideID, http.StatusBadRequest)
return
}
- reg, err := db.GetSpecificRegistration(ID, UUID)
+ reg, err := db.GetSpecificRegistration(ID, UUID) // Retrieve the specific registration to be deleted.
if err != nil {
- err := fmt.Sprint("Document doesn't exist: ", err)
+ log.Printf(RegistrationRetrivalError, err)
+ err := fmt.Sprint("Error getting registration: ", err)
http.Error(w, err, http.StatusNotFound)
return
}
- err = db.DeleteRegistration(ID, UUID)
+ err = db.DeleteRegistration(ID, UUID) // Delete the registration from the database.
if err != nil {
- err := fmt.Sprintf("Error deleting data from database: %v", err)
+ log.Printf("Error deleting registration from database: %v", err)
+ err := fmt.Sprintf("Error deleting registration from database: %v", err)
http.Error(w, err, http.StatusInternalServerError)
return
}
- w.WriteHeader(http.StatusNoContent)
+ w.WriteHeader(http.StatusNoContent) // Set the HTTP status code to 204 (No Content).
+
+ cie := new(structs.CountryInfoExternal) // Create new external country info struct.
+ cie.ID = reg.ID
+ cie.Country = reg.Country
+ cie.IsoCode = reg.IsoCode
+ cie.Features = reg.Features
+ cie.Lastchange = reg.Lastchange
- _func.LoopSendWebhooks(UUID, reg, Endpoints.RegistrationsID, Webhooks.EventDelete)
+ _func.LoopSendWebhooksRegistrations(UUID, cie, Endpoints.RegistrationsID, Webhooks.EventDelete) // Trigger webhooks for the delete event.
}
diff --git a/Go/internal/handlers/endpoint/dashboard/status_handler.go b/Go/internal/handlers/endpoint/dashboard/status_handler.go
index 23fbe73f1df30b92a19148ca9c654caef14ba06a..11dc1a199b711329f8ebf515fecbd4affe87aaf7 100644
--- a/Go/internal/handlers/endpoint/dashboard/status_handler.go
+++ b/Go/internal/handlers/endpoint/dashboard/status_handler.go
@@ -1,4 +1,4 @@
-// Package dashboard provides handlers for dashboard-related endpoints.
+// Package dashboard provides handlers for managing dashboard-related functionalities through HTTP endpoints.
package dashboard
import (
@@ -6,6 +6,7 @@ import (
"fmt"
"globeboard/db"
"globeboard/internal/utils/constants"
+ "globeboard/internal/utils/constants/Endpoints"
"globeboard/internal/utils/constants/External"
"globeboard/internal/utils/structs"
"log"
@@ -13,90 +14,88 @@ import (
"time"
)
-// getEndpointStatus returns the HTTP status code of the provided endpoint.
+// getEndpointStatus sends a GET request to the specified endpoint URL and returns the HTTP status code as a string.
func getEndpointStatus(endpointURL string) string {
- // Create new request
- r, err := http.NewRequest(http.MethodGet, endpointURL, nil)
+ r, err := http.NewRequest(http.MethodGet, endpointURL, nil) // Create a new GET request for the endpoint URL.
if err != nil {
- // Log and handle the error if request creation fails.
- err := fmt.Errorf("error in creating request: %s", err.Error())
- log.Println(err)
+ log.Printf("error in creating request: %v", err)
+ return "Failed to create request"
}
- // Set content type header
- r.Header.Add("content-type", "application/json")
+ r.Header.Add("content-type", "application/json") // Set content-type of request.
- // Create an HTTP client
- client := &http.Client{}
- defer client.CloseIdleConnections()
+ client := &http.Client{Timeout: 10 * time.Second} // Initialize a new HTTP client with a timeout.
+ defer client.CloseIdleConnections() // Ensure that idle connections are closed upon function exit.
- // Issue request
- res, err := client.Do(r)
+ res, err := client.Do(r) // Execute the request.
if err != nil {
- // Log and handle the error if request execution fails.
- err := fmt.Errorf("error in response: %s", err.Error())
- log.Println(err)
+ log.Printf("error in receiving response: %v", err)
+ return "Failed to connect"
}
+ // Ensure the response body is closed after the function exits, checking for errors.
+ defer func() {
+ if err := res.Body.Close(); err != nil {
+ log.Printf("error closing response body: %v", err)
+ }
+ }()
- return res.Status
+ return res.Status // Return the status code of the response.
}
-// StatusHandler handles requests to retrieve the status of Endpoints.
+// StatusHandler routes requests based on HTTP method to handle status retrieval.
func StatusHandler(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
- handleStatusGetRequest(w, r)
+ handleStatusGetRequest(w, r) // Handle GET requests with handleStatusGetRequest.
default:
- // If the method is not supported, return an error response.
- http.Error(w, "REST Method: "+r.Method+" not supported. Only supported methods for this endpoint is: "+http.MethodGet, http.StatusNotImplemented)
- return
+ // Log and return an error for unsupported HTTP methods
+ log.Printf(constants.ClientConnectUnsupported, Endpoints.Status, r.Method)
+ http.Error(w, fmt.Sprintf("REST Method: %s not supported. Only GET is supported for this endpoint", r.Method), http.StatusNotImplemented)
}
}
-// handleStatusGetRequest handles GET requests to retrieve the status of Endpoints.
+// handleStatusGetRequest processes GET requests to retrieve and report the status of various services and endpoints.
func handleStatusGetRequest(w http.ResponseWriter, r *http.Request) {
- token := r.URL.Query().Get("token")
- if token == "" {
- http.Error(w, "Please provide API Token", http.StatusBadRequest)
+ token := r.URL.Query().Get("token") // Retrieve the API token from query parameters.
+ if token == "" { // Validate token presence.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.Status)
+ http.Error(w, "Please provide API Token", http.StatusUnauthorized)
return
}
- UUID := db.GetAPIKeyUUID(token)
- if UUID == "" {
- err := fmt.Sprintf("API key not accepted")
- http.Error(w, err, http.StatusNotAcceptable)
+
+ UUID := db.GetAPIKeyUUID(token) // Retrieve the UUID associated with the API token.
+ if UUID == "" { // Validate UUID presence.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.Status)
+ http.Error(w, "API key not accepted", http.StatusNotAcceptable)
return
}
- user, err := db.GetWebhooksUser(UUID)
+ webhooksUser, err := db.GetWebhooksUser(UUID) // Retrieve user data associated with webhooks.
if err != nil {
- log.Print("Error retrieving users webhooks:", err)
+ log.Printf("Error retrieving user's webhooks: %v", err)
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
return
}
- // Initialize a status response.
+ // Create a status response object.
status := structs.StatusResponse{
- CountriesApi: getEndpointStatus(External.CountriesAPI + "all"),
- MeteoApi: getEndpointStatus(External.OpenMeteoAPI),
- CurrencyApi: getEndpointStatus(External.CurrencyAPI + "nok"),
- FirebaseDB: db.TestDBConnection(),
- Webhooks: len(user),
- Version: constants.APIVersion,
- // Calculate uptime since the last restart of the service.
- UptimeInSeconds: fmt.Sprintf("%f Seconds", time.Since(startTime).Seconds()),
+ CountriesApi: getEndpointStatus(External.CountriesAPI + "alpha?codes=no"),
+ MeteoApi: getEndpointStatus(External.OpenMeteoAPI),
+ CurrencyApi: getEndpointStatus(External.CurrencyAPI + "nok"),
+ FirebaseDB: db.TestDBConnection(), // Test the database connection.
+ Webhooks: len(webhooksUser),
+ Version: constants.APIVersion, // Include the API version.
+ UptimeInSeconds: fmt.Sprintf("%f Seconds", time.Since(startTime).Seconds()), // Calculate uptime.
}
- // Set content type header
- w.Header().Add("content-type", "application/json")
+ w.Header().Set("Content-Type", "application/json") // Set response content type to application/json.
- // Encode status as JSON and send the response.
- err = json.NewEncoder(w).Encode(status)
+ err = json.NewEncoder(w).Encode(status) // Encode the status response to JSON and send it.
if err != nil {
- // If encoding fails, return an error response.
- http.Error(w, "Error during encoding: "+err.Error(), http.StatusInternalServerError)
+ log.Print(err)
+ http.Error(w, fmt.Sprintf("Error during encoding: %v", err), http.StatusInternalServerError)
return
}
}
-// startTime keeps track of the service start time.
-var startTime = time.Now()
+var startTime = time.Now() // Track the start time of the application.
diff --git a/Go/internal/handlers/endpoint/util/apikey_handler.go b/Go/internal/handlers/endpoint/util/apikey_handler.go
index 4df57638b6f537856b6305174d6f4b219b0bff69..206c1586593d4f36403f2ac1c210d1007fd15bb3 100644
--- a/Go/internal/handlers/endpoint/util/apikey_handler.go
+++ b/Go/internal/handlers/endpoint/util/apikey_handler.go
@@ -1,3 +1,4 @@
+// Package util provides HTTP handlers for user and API key management within the application.
package util
import (
@@ -8,76 +9,94 @@ import (
"globeboard/db"
_func "globeboard/internal/func"
"globeboard/internal/utils/constants"
+ "globeboard/internal/utils/constants/Endpoints"
"log"
"net/http"
)
+// APIKeyHandler routes API Key management requests to the appropriate functions based on the HTTP method.
func APIKeyHandler(w http.ResponseWriter, r *http.Request) {
switch r.Method {
- case http.MethodGet:
+ case http.MethodGet: // Handle GET requests
handleApiKeyGetRequest(w, r)
- case http.MethodDelete:
+ case http.MethodDelete: // Handle DELETE requests
handleApiKeyDeleteRequest(w, r)
default:
- http.Error(w, "REST Method: "+r.Method+" not supported. Only supported methods for this endpoint is: "+http.MethodGet, http.StatusNotImplemented)
+ // Log and return an error for unsupported HTTP methods
+ log.Printf(constants.ClientConnectUnsupported, Endpoints.ApiKey, r.Method)
+ http.Error(w, "REST Method: "+r.Method+" not supported. Only supported methods for this endpoint are: GET, DELETE", http.StatusNotImplemented)
return
}
}
+// handleApiKeyDeleteRequest handles the deletion of an API key.
func handleApiKeyDeleteRequest(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
- token := query.Get("token")
+ token := query.Get("token") // Retrieve the token from query parameters.
- if token == "" {
- http.Error(w, "Please specify API Key to delete: '?token={API_Key}' ", http.StatusBadRequest)
+ UUID := r.Header.Get("Authorization") // Retrieve the UUID from the Authorization header.
+
+ ctx := context.Background() // Create a new background context.
+
+ _, err := authenticate.Client.GetUser(ctx, UUID) // Verify the UUID with Firebase Authentication.
+ if err != nil {
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.ApiKey)
+ log.Printf("Error verifying UUID: %v\n", err)
+ http.Error(w, "Not Authorized", http.StatusUnauthorized) // Respond with unauthorized if UUID is invalid.
+ return
+ }
+
+ if token == "" || token == " " { // Validate token presence.
+ log.Printf(constants.ClientConnectNoToken, r.Method, Endpoints.ApiKey)
+ http.Error(w, "Please specify API Key to delete: '?token={API_Key}'", http.StatusBadRequest)
return
}
- err := db.DeleteApiKey(token)
+ err = db.DeleteApiKey(UUID, token) // Attempt to delete the API key.
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ log.Printf("Error deleting API Key: %v", err)
+ http.Error(w, err.Error(), http.StatusInternalServerError) // Respond with internal server error if deletion fails.
return
}
+ w.WriteHeader(http.StatusNoContent) // Respond with no content on successful deletion.
}
+// handleApiKeyGetRequest handles the creation and retrieval of a new API key.
func handleApiKeyGetRequest(w http.ResponseWriter, r *http.Request) {
- UDID := _func.GenerateUID(constants.DocIdLength)
- key := _func.GenerateAPIKey(constants.ApiKeyLength)
+ UDID := _func.GenerateUID(constants.DocIdLength) // Generate a unique document ID.
+ key := _func.GenerateAPIKey(constants.ApiKeyLength) // Generate a new API key.
- UUID := r.Header.Get("Authorization")
+ UUID := r.Header.Get("Authorization") // Retrieve the UUID from the Authorization header.
- w.Header().Set("Content-Type", "application/json")
+ w.Header().Set("Content-Type", "application/json") // Set the content type of the response to application/json.
- ctx := context.Background()
+ ctx := context.Background() // Create a new background context.
- client, err := authenticate.GetFireBaseAuthClient()
+ _, err := authenticate.Client.GetUser(ctx, UUID) // Verify the UUID with Firebase Authentication.
if err != nil {
- log.Printf("error getting Auth client: %v\n", err)
- http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.ApiKey)
+ log.Printf("Error verifying UUID: %v\n", err)
+ http.Error(w, "Not Authorized", http.StatusUnauthorized) // Respond with unauthorized if UUID is invalid.
return
}
- // Verify the ID token
- _, err = client.GetUser(ctx, UUID)
+ err = db.AddApiKey(UDID, UUID, key) // Attempt to add the new API key to the database.
if err != nil {
- log.Printf("error verifying UUID: %v\n", err)
- http.Error(w, "Not Authorized", http.StatusUnauthorized)
+ log.Printf("Error creating API Key: %v", err)
+ errorMessage := fmt.Sprintf("Error creating API Key: %v", err)
+ http.Error(w, errorMessage, http.StatusInternalServerError) // Respond with internal server error if addition fails.
return
}
- err = db.AddApiKey(UDID, UUID, key)
- if err != nil {
- err := fmt.Sprintf("Error creating API Key: %v", err)
- http.Error(w, err, http.StatusInternalServerError)
- return
- }
+ w.WriteHeader(http.StatusCreated) // Set HTTP status to 201 Created on successful API key creation.
- w.WriteHeader(http.StatusCreated)
+ response := map[string]string{
+ "token": key, // Include the new API key in the response.
+ }
- // Encode books as JSON and send the response.
- if err := json.NewEncoder(w).Encode(key); err != nil {
- http.Error(w, "Error encoding JSON response: "+err.Error(), http.StatusInternalServerError)
+ if err := json.NewEncoder(w).Encode(response); err != nil {
+ http.Error(w, "Error encoding JSON response: "+err.Error(), http.StatusInternalServerError) // Handle errors in JSON encoding.
return
}
}
diff --git a/Go/internal/handlers/endpoint/util/user_delete_handler.go b/Go/internal/handlers/endpoint/util/user_delete_handler.go
new file mode 100644
index 0000000000000000000000000000000000000000..3f944797ed57ac956bcb9a87298207f1281c059a
--- /dev/null
+++ b/Go/internal/handlers/endpoint/util/user_delete_handler.go
@@ -0,0 +1,46 @@
+// Package util provides HTTP handlers for user and API key management within the application.
+package util
+
+import (
+ "context"
+ authenticate "globeboard/auth"
+ "globeboard/internal/utils/constants"
+ "globeboard/internal/utils/constants/Endpoints"
+ "log"
+ "net/http"
+)
+
+// UserDeletionHandler handles HTTP requests for user deletion.
+func UserDeletionHandler(w http.ResponseWriter, r *http.Request) {
+ switch r.Method {
+ case http.MethodDelete:
+ deleteUser(w, r) // Handle DELETE requests
+ default:
+ // Log and return an error for unsupported HTTP methods
+ log.Printf(constants.ClientConnectUnsupported, Endpoints.UserDeletionID, r.Method)
+ http.Error(w, "REST Method: "+r.Method+" not supported. Only supported method for this endpoint is:\n"+http.MethodDelete, http.StatusNotImplemented)
+ return
+ }
+}
+
+// deleteUser processes the user deletion using the user ID from the request path.
+func deleteUser(w http.ResponseWriter, r *http.Request) {
+ ID := r.PathValue("ID") // Extract user ID from the URL path.
+ if ID == "" || ID == " " { // Check if the user ID is provided.
+ log.Printf(constants.ClientConnectUnauthorized, r.Method, Endpoints.UserDeletionID)
+ http.Error(w, "Please provide User ID", http.StatusBadRequest) // Return an error if user ID is missing.
+ return
+ }
+
+ ctx := context.Background() // Create a new background context.
+
+ err := authenticate.Client.DeleteUser(ctx, ID) // Attempt to delete user in Firebase.
+ if err != nil {
+ log.Printf("Error deleting user: %v\n", err) // Log the error.
+ http.Error(w, err.Error(), http.StatusInternalServerError) // Report deletion error.
+ return
+ }
+
+ w.WriteHeader(http.StatusNoContent) // Set HTTP status to 204 No Content on successful deletion.
+ log.Printf("Successfully deleted user: %v\n", ID) // Log successful deletion.
+}
diff --git a/Go/internal/handlers/endpoint/util/user_register_handler.go b/Go/internal/handlers/endpoint/util/user_register_handler.go
index 846e481f6868daebb4d7f0dfdc6424a70f381e6c..f6939c464c1db57587b40379aab6c5f5614cffde 100644
--- a/Go/internal/handlers/endpoint/util/user_register_handler.go
+++ b/Go/internal/handlers/endpoint/util/user_register_handler.go
@@ -1,121 +1,121 @@
+// Package util provides HTTP handlers for user and API key management within the application.
package util
import (
"context"
+ "encoding/json"
"firebase.google.com/go/auth"
- "fmt"
authenticate "globeboard/auth"
"globeboard/db"
_func "globeboard/internal/func"
"globeboard/internal/utils/constants"
+ "globeboard/internal/utils/constants/Endpoints"
"log"
"net/http"
"regexp"
)
const (
- ISE = "Internal Server Error"
+ ISE = "Internal Server Error" // ISE is the error message used when an internal server error occurs.
)
-// UserRegistrationHandler handles HTTP GET requests to retrieve supported languages.
+// UserRegistrationHandler handles HTTP requests for user registration.
func UserRegistrationHandler(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodPost:
- registerUser(w, r)
+ registerUser(w, r) // Handle POST requests
default:
+ // Log and return an error for unsupported HTTP methods
+ log.Printf(constants.ClientConnectUnsupported, Endpoints.UserRegistration, r.Method)
http.Error(w, "REST Method: "+r.Method+" not supported. Only supported methods for this endpoint is:\n"+http.MethodPost, http.StatusNotImplemented)
return
}
}
+// registerUser processes the user registration, including input validation and user creation.
func registerUser(w http.ResponseWriter, r *http.Request) {
+ name := r.FormValue("username") // Extract username from form data.
+ email := r.FormValue("email") // Extract email from form data.
+ password := r.FormValue("password") // Extract password from form data.
- // Initialize Firebase
- client, err := authenticate.GetFireBaseAuthClient() // Assuming you have your initFirebase function from earlier
- if err != nil {
- http.Error(w, "Error initializing Firebase Auth", http.StatusInternalServerError)
- return
- }
- name := r.FormValue("name")
- email := r.FormValue("email")
- password := r.FormValue("password")
-
- // Validate email format
- if !isValidEmail(email) {
+ if !isValidEmail(email) { // Validate the email.
+ // Log a message indicating that a client attempted to register using a malformed email.
+ log.Printf("Client attempted to register a user with malformed email.")
http.Error(w, "Invalid email format", http.StatusBadRequest)
return
}
- // Validate password strength
- if !isValidPassword(password) {
+ if !isValidPassword(password) { // Validate password strength.
+ // Log a message indicating that a client attempted to register using a weak password.
+ log.Printf("Client attempted to register a user with a weak password.")
http.Error(w, "Password does not meet complexity requirements", http.StatusBadRequest)
return
}
- ctx := context.Background()
+ ctx := context.Background() // Create a new background context.
+ // Define user creation parameters.
params := (&auth.UserToCreate{}).
DisplayName(name).
Email(email).
Password(password)
- u, err := client.CreateUser(ctx, params)
+
+ u, err := authenticate.Client.CreateUser(ctx, params) // Attempt to create user in Firebase.
if err != nil {
- log.Printf("error creating user: %v\n", err)
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ log.Printf("Error creating user: %v\n", err) // Log the error.
+ http.Error(w, err.Error(), http.StatusInternalServerError) // Report creation error.
return
}
- w.Header().Set("content-type", "text/html")
+ w.Header().Set("content-type", "application/json") // Set response content type.
- UDID := _func.GenerateUID(constants.DocIdLength)
- key := _func.GenerateAPIKey(constants.ApiKeyLength)
+ UDID := _func.GenerateUID(constants.DocIdLength) // Generate a unique document ID.
+ key := _func.GenerateAPIKey(constants.ApiKeyLength) // Generate a new API key.
- err = db.AddApiKey(UDID, u.UID, key)
+ err = db.AddApiKey(UDID, u.UID, key) // Store the new API key in the database.
if err != nil {
- log.Printf("error saving API Key: %v\n", err)
- http.Error(w, ISE, http.StatusInternalServerError)
+ log.Printf("Error saving API Key: %v\n", err) // Log the error.
+ http.Error(w, ISE, http.StatusInternalServerError) // Report API key storage error.
return
}
- _, err = fmt.Fprintf(w, "Successfully registered user: %s\n"+
- "API Key: %s \n\n"+
- "To delete and get a new API Key utilize: Authorization: \"%v\" at:\n<a href=\"/util/v1/key\">/util/v1/key</a>", u.DisplayName, key, u.UID)
+ // Prepare the JSON response with the user ID and token.
+ response := struct {
+ Token string `json:"token"` // API token.
+ UserID string `json:"userid"` // Firebase user ID.
+ }{
+ Token: key,
+ UserID: u.UID,
+ }
+
+ w.WriteHeader(http.StatusCreated) // Set HTTP status to 201 Created.
+
+ encoder := json.NewEncoder(w) // Initialize JSON encoder.
+ err = encoder.Encode(response) // Encode the response as JSON.
if err != nil {
- log.Print("Error writing response to ResponseWriter: ", err)
- http.Error(w, ISE, http.StatusInternalServerError)
+ log.Printf("Error encoding JSON response: %v\n", err) // Log encoding error.
+ http.Error(w, ISE, http.StatusInternalServerError) // Report encoding error.
return
}
+
+ // Log successful creation events.
+ log.Printf("Successfully created user: %v with API Key: %v\n", response.UserID, response.Token)
}
+// isValidEmail checks if the provided email string matches the expected format.
func isValidEmail(email string) bool {
- regex := regexp.MustCompile(`^[a-z0-9._%+\-]+@[a-z0-9.\-]+\.[a-z]{2,4}$`)
- return regex.MatchString(email)
+ regex := regexp.MustCompile(`(?i)^[a-z0-9._%+\-]+@[a-z0-9.\-]+\.[a-z]{2,4}$`) // Regular expression for email validation.
+ return regex.MatchString(email) // Return true
+ // if email matches the regex.
}
+// isValidPassword checks if the provided password meets complexity requirements.
func isValidPassword(password string) bool {
- // Check the length
- if len(password) < 12 {
+ if len(password) < 12 { // Password length should be at least 12 characters.
return false
}
-
- // Check for at least one uppercase letter
- hasUppercase := regexp.MustCompile(`[A-Z]`).MatchString(password)
- if !hasUppercase {
- return false
- }
-
- // Check for at least one digit
- hasDigit := regexp.MustCompile(`[0-9]`).MatchString(password)
- if !hasDigit {
- return false
- }
-
- // Check for at least one special character
- hasSpecial := regexp.MustCompile(`[!@#$&*]`).MatchString(password)
- if !hasSpecial {
- return false
- }
-
- // If all checks pass
- return true
+ hasUppercase := regexp.MustCompile(`[A-Z]`).MatchString(password) // Check for at least one uppercase letter.
+ hasDigit := regexp.MustCompile(`[0-9]`).MatchString(password) // Check for at least one digit.
+ hasSpecial := regexp.MustCompile(`[!@#$&*]`).MatchString(password) // Check for at least one special character.
+ return hasUppercase && hasDigit && hasSpecial // Return true if all conditions are met.
}
diff --git a/Go/internal/utils/constants/Endpoints/endpoints.go b/Go/internal/utils/constants/Endpoints/endpoints.go
index 70efdddd8310fe998a0d804a6a4a565f31939b72..bf77b59c30085e408c3861bf4c6e27162afa729e 100644
--- a/Go/internal/utils/constants/Endpoints/endpoints.go
+++ b/Go/internal/utils/constants/Endpoints/endpoints.go
@@ -1,18 +1,33 @@
-// Package Endpoints provides constant endpoint paths used in the application.
+// Package Endpoints provides constants for fully constructed endpoint paths
+// using base paths and versions defined in other packages.
package Endpoints
import (
- "globeboard/internal/utils/constants"
- "globeboard/internal/utils/constants/Paths"
+ "globeboard/internal/utils/constants" // Imports constants for the API version.
+ "globeboard/internal/utils/constants/Paths" // Imports base paths for endpoints.
)
const (
- ApiKey = Paths.Util + constants.APIVersion + "/key"
- UserRegistration = Paths.Util + constants.APIVersion + "/register"
- RegistrationsID = Paths.Dashboard + constants.APIVersion + "/registrations/{ID}"
- Registrations = Paths.Dashboard + constants.APIVersion + "/registrations"
- Dashboards = Paths.Dashboard + constants.APIVersion + "/dashboards/{ID}"
- NotificationsID = Paths.Dashboard + constants.APIVersion + "/notifications/{ID}"
- Notifications = Paths.Dashboard + constants.APIVersion + "/notifications"
- Status = Paths.Dashboard + constants.APIVersion + "/status"
+ // ApiKey endpoint for API key operations.
+ ApiKey = Paths.Util + constants.APIVersion + "/key"
+ // UserRegistration endpoint for user registration operations.
+ UserRegistration = Paths.Util + constants.APIVersion + "/user/register"
+ // UserDeletion endpoint URL for user registration operations without the ID wildcard.
+ UserDeletion = Paths.Util + constants.APIVersion + "/user/delete"
+ // UserDeletionID endpoint for user deletion operations by ID.
+ UserDeletionID = Paths.Util + constants.APIVersion + "/user/delete/{ID}"
+ // RegistrationsID endpoint for accessing specific registration by ID.
+ RegistrationsID = Paths.Dashboards + constants.APIVersion + "/registrations/{ID}"
+ // Registrations endpoint for accessing registrations without ID.
+ Registrations = Paths.Dashboards + constants.APIVersion + "/registrations"
+ // DashboardsID endpoint for accessing specific dashboard by ID.
+ DashboardsID = Paths.Dashboards + constants.APIVersion + "/dashboard/{ID}"
+ // Dashboards endpoint URL for dashboard operations without the ID wildcard.
+ Dashboards = Paths.Dashboards + constants.APIVersion + "/dashboard"
+ // NotificationsID endpoint for accessing specific notification by ID.
+ NotificationsID = Paths.Dashboards + constants.APIVersion + "/notifications/{ID}"
+ // Notifications endpoint for accessing notifications operations without ID.
+ Notifications = Paths.Dashboards + constants.APIVersion + "/notifications"
+ // Status endpoint for checking the status of the dashboard services.
+ Status = Paths.Dashboards + constants.APIVersion + "/status"
)
diff --git a/Go/internal/utils/constants/External/external.go b/Go/internal/utils/constants/External/external.go
index 7092541b5befe1510035c875f742b387f92e4c27..ecc6dd035be3c7e42456f886eb28a26b924958f9 100644
--- a/Go/internal/utils/constants/External/external.go
+++ b/Go/internal/utils/constants/External/external.go
@@ -1,11 +1,8 @@
-// Package External provides external API endpoints used in the application.
+// Package External defines constants for URLs to external API endpoints used within the application.
package External
-// CurrencyAPI represents the endpoint for the Currency API.
-// OpenMeteoAPI represents the endpoint for the Open-Meteo API.
-// CountriesAPI represents the endpoint for the RESTCountries API.
const (
- CurrencyAPI = "http://129.241.150.113:9090/currency/"
- OpenMeteoAPI = "https://google.com/" //TODO::Set Actual API Endpoint
- CountriesAPI = "http://129.241.150.113:8080/v3.1/"
+ CurrencyAPI = "http://129.241.150.113:9090/currency/" // CurrencyAPI specifies the endpoint URL for the Currency API.
+ OpenMeteoAPI = "https://api.open-meteo.com/v1/forecast" // OpenMeteoAPI specifies the endpoint URL for the Open-Meteo API.
+ CountriesAPI = "http://129.241.150.113:8080/v3.1/" // CountriesAPI specifies the endpoint URL for the RESTCountries API.
)
diff --git a/Go/internal/utils/constants/Firestore/firebase.go b/Go/internal/utils/constants/Firestore/firebase.go
index 71af290e113cf8b8cedd1e5993481259cf31f49a..57e1067928e4026465296b97eb47075ce830ef37 100644
--- a/Go/internal/utils/constants/Firestore/firebase.go
+++ b/Go/internal/utils/constants/Firestore/firebase.go
@@ -1,7 +1,8 @@
+// Package Firestore defines constants for the names of Firestore collections used in the application.
package Firestore
const (
- ApiKeyCollection = "API_keys"
- RegistrationCollection = "Registrations"
- WebhookCollection = "Webhooks"
+ ApiKeyCollection = "API_keys" // ApiKeyCollection specifies the Firestore collection name for API keys.
+ RegistrationCollection = "Registrations" // RegistrationCollection specifies the Firestore collection name for country registrations.
+ WebhookCollection = "Webhooks" // WebhookCollection specifies the Firestore collection name for webhook data.
)
diff --git a/Go/internal/utils/constants/Paths/paths.go b/Go/internal/utils/constants/Paths/paths.go
index a98053b9392ebb8e850c499857a8720d450fba39..d4e504c9e8818a3dbb0b4d41a0a7a90be48341d9 100644
--- a/Go/internal/utils/constants/Paths/paths.go
+++ b/Go/internal/utils/constants/Paths/paths.go
@@ -1,11 +1,8 @@
-// Package Paths provides constant paths used in the application.
+// Package Paths defines constant URL paths used within the application to reference different endpoint roots.
package Paths
-// Root represents the root path.
-// Util represents the root path to the util endpoints
-// Dashboard represents the root path to the util stats endpoints
const (
- Root = "/"
- Util = "/util/"
- Dashboard = "/dashboard/"
+ Root = "/" // Root represents the root path of the application.
+ Util = "/util/" // Util represents the root path to the utility-specific endpoints.
+ Dashboards = "/dashboards/" // Dashboards represent the root path to the dashboard endpoints.
)
diff --git a/Go/internal/utils/constants/Webhooks/webhooks.go b/Go/internal/utils/constants/Webhooks/webhooks.go
index e39aa200c7d5c5554564caed67a24ee34f9ea09a..c30ee35218f74a91365497a91a1102aff98f2280 100644
--- a/Go/internal/utils/constants/Webhooks/webhooks.go
+++ b/Go/internal/utils/constants/Webhooks/webhooks.go
@@ -1,18 +1,19 @@
+// Package Webhooks defines constants for webhook titles, colors, and event types used for Webhook notifications.
package Webhooks
const (
- POSTTitle = "Registered New Country Data to GlobeBoard"
- PUTTitle = "Changed Country Data on GlobeBoard"
- DELETETitle = "Deleted Country Data from GlobeBoard"
- GETTitle = "Invoked Country Data from GlobeBoard"
+ POSTTitle = "Registered New Country Data to GlobeBoard" // POSTTitle defines the title for POST webhook events.
+ PATCHTitle = "Changed Country Data on GlobeBoard" // PATCHTitle defines the title for PATCH webhook events.
+ DELETETitle = "Deleted Country Data from GlobeBoard" // DELETETitle defines the title for DELETE webhook events.
+ GETTitle = "Invoked Country Data from GlobeBoard" // GETTitle defines the title for GET webhook events.
- POSTColor = 2664261 //Success Color
- PUTColor = 16761095 //Update Color
- DELETEColor = 14431557 //Warning Color
- GETColor = 1548984 //Info Color
+ POSTColor = 2664261 // Success Color - light green
+ PUTColor = 16761095 // Update Color - bright orange
+ DELETEColor = 14431557 // Warning Color - pale red
+ GETColor = 1548984 // Info Color - light blue
- EventRegister = "REGISTER" // POST
- EventChange = "CHANGE" // PUT
- EventDelete = "DELETE" // DELETE
- EventInvoke = "INVOKE" // GET
+ EventRegister = "REGISTER" // EventRegister defines the event type for POST operations.
+ EventChange = "CHANGE" // EventChange defines the event type for PATCH operations.
+ EventDelete = "DELETE" // EventDelete defines the event type for DELETE operations.
+ EventInvoke = "INVOKE" // EventInvoke defines the event type for GET operations.
)
diff --git a/Go/internal/utils/constants/constants.go b/Go/internal/utils/constants/constants.go
index 996fdc63c8e20d7ad739ab5d5672413c0b7ba64e..ea1de77d4e70da4c506584fe6ab16b4ee2bb0f90 100644
--- a/Go/internal/utils/constants/constants.go
+++ b/Go/internal/utils/constants/constants.go
@@ -1,11 +1,20 @@
-// Package constants provide constant values used throughout the application.
+// Package constants provide constant values that are used within the application.
package constants
-// APIVersion represents the version of the API.
const (
- APIVersion = "v1"
- FirebaseCredentialPath = "./.secrets/firebaseCredentials.json"
- ApiKeyLength = 20
- DocIdLength = 24
- RegIdLength = 16
+ APIVersion = "v1" // APIVersion specifies the version of the API being used.
+ ApiKeyLength = 20 // ApiKeyLength specifies the length of API keys generated.
+ DocIdLength = 24 // DocIdLength specifies the length of document identifiers.
+ IdLength = 20 // IdLength specifies the length of general purpose identifiers.
+
+ // ClientConnectUnsupported formats an error message for when a client tries to connect using an unsupported method.
+ ClientConnectUnsupported = "Client attempted to connect to %s with unsupported method: %s\n"
+ // ClientConnectNoToken formats an error message for connection attempts where no token is provided.
+ ClientConnectNoToken = "Failed %s attempt to %s: No Token.\n"
+ // ClientConnectNoID formats an error message for connection attempts where no ID is provided.
+ ClientConnectNoID = "Failed %s attempt to %s: No ID.\n"
+ // ClientConnectUnauthorized formats an error message for unauthorized connection attempts.
+ ClientConnectUnauthorized = "Unauthorized %s attempted to %s.\n"
+ // ClientConnectEmptyBody formats an error message for connection attempts with no body content.
+ ClientConnectEmptyBody = "Failed %s attempt to %s: No Body.\n"
)
diff --git a/Go/internal/utils/structs/structs.go b/Go/internal/utils/structs/structs.go
index 9093200dcb67316fc581a05c59a6fa2b08b59fb1..1fe04c347f4540bf008a0271950a0cf47a2e8f32 100644
--- a/Go/internal/utils/structs/structs.go
+++ b/Go/internal/utils/structs/structs.go
@@ -1,87 +1,129 @@
-// Package structs define structures used within the application.
+// Package structs define data structures used within the application.
package structs
import "time"
+// APIKey represents a structure for storing an API key associated with a unique identifier (UUID).
type APIKey struct {
- UUID string `json:"uuid"`
- APIKey string `json:"api_key"`
+ UUID string `json:"uuid"` // The unique identifier for the API key
+ APIKey string `json:"api_key"` // The actual API key string
}
-// Registrations Structs
+// CountryInfoExternal is a structure to store external-facing country information.
+type CountryInfoExternal struct {
+ ID string `json:"id"` // Unique identifier for the country information
+ Country string `json:"country"` // Name of the country
+ IsoCode string `json:"isoCode"` // ISO code for the country
+ Features Features `json:"features"` // Features available for the country
+ Lastchange time.Time `json:"lastchange"` // The last time the information was updated
+}
-type CountryInfoGet struct {
- ID string `json:"id"`
- UUID string `json:"uuid"`
- Country string `json:"country"`
- IsoCode string `json:"isoCode"`
- Features Features `json:"features"`
- Lastchange time.Time `json:"lastchange"`
+// CountryInfoInternal is a structure to store internal country information.
+type CountryInfoInternal struct {
+ ID string `json:"id"` // Unique identifier for the country information
+ UUID string `json:"uuid"` // An additional UUID for internal use
+ Country string `json:"country"` // Name of the country
+ IsoCode string `json:"isoCode"` // ISO code for the country
+ Features Features `json:"features"` // Features available for the country
+ Lastchange time.Time `json:"lastchange"` // The last time the information was updated
}
+// Features struct encapsulates different geographical and demographic features of a country.
type Features struct {
- Temperature bool `json:"temperature"`
- Precipitation bool `json:"precipitation"`
- Capital bool `json:"capital"`
- Coordinates bool `json:"coordinates"`
- Population bool `json:"population"`
- Area bool `json:"area"`
- TargetCurrencies []string `json:"targetCurrencies"`
+ Temperature bool `json:"temperature"` // Boolean flag indicating retrival of temperature data
+ Precipitation bool `json:"precipitation"` // Boolean flag indicating retrival of precipitation data
+ Capital bool `json:"capital"` // Boolean flag indicating retrival of capital information
+ Coordinates bool `json:"coordinates"` // Boolean flag indicating retrival of geographical coordinates
+ Population bool `json:"population"` // Boolean flag indicating retrival of population data
+ Area bool `json:"area"` // Boolean flag indicating retrival of area data
+ TargetCurrencies []string `json:"targetCurrencies"` // List of target currencies
}
-// StatusResponse represents the status response structure.
-type StatusResponse struct {
- CountriesApi string `json:"countries_api"`
- MeteoApi string `json:"meteo_api"`
- CurrencyApi string `json:"currency_api"`
- FirebaseDB string `json:"firebase_db"`
- Webhooks int `json:"webhooks"`
- Version string `json:"version"`
- UptimeInSeconds string `json:"uptime"`
+// DashboardResponse defines the structure for dashboard service responses.
+type DashboardResponse struct {
+ ID string `json:"id"` // Unique identifier for the dashboard entry
+ Country string `json:"country"` // Country name
+ IsoCode string `json:"iso_code"` // ISO code for the country
+ Features FeaturesDashboard `json:"features"` // Detailed features used in the dashboard
+ LastRetrieval string `json:"lastRetrieval"` // Last retrieval time of the data
+}
+
+// FeaturesDashboard defines detailed features available on the dashboard for a country.
+type FeaturesDashboard struct {
+ Temperature string `json:"temperature,omitempty"` // Temperature information
+ Precipitation string `json:"precipitation,omitempty"` // Precipitation information
+ Capital string `json:"capital,omitempty"` // Capital city
+ Coordinates *CoordinatesDashboard `json:"coordinates,omitempty"` // Geographical coordinates
+ Population int `json:"population,omitempty"` // Population number
+ Area string `json:"area,omitempty"` // Area in square kilometers
+ TargetCurrencies map[string]float64 `json:"targetCurrencies,omitempty"` // Currency exchange rates
}
-// Webhooks Structs
+// CoordinatesDashboard defines latitude and longitude for a geographical location.
+type CoordinatesDashboard struct {
+ Latitude string `json:"latitude,omitempty"` // Latitude
+ Longitude string `json:"longitude,omitempty"` // Longitude
+}
+
+// StatusResponse defines the current status of various APIs and services used by the application.
+type StatusResponse struct {
+ CountriesApi string `json:"countries_api"` // Status of the countries API
+ MeteoApi string `json:"meteo_api"` // Status of the meteorological API
+ CurrencyApi string `json:"currency_api"` // Status of the currency exchange API
+ FirebaseDB string `json:"firebase_db"` // Status of the Firebase database
+ Webhooks int `json:"webhooks"` // Number of active webhooks
+ Version string `json:"version"` // Current version of the application
+ UptimeInSeconds string `json:"uptime"` // Uptime in seconds
+}
-type WebhookPost struct {
- URL string `json:"url"`
- Country string `json:"country"`
- Event []string `json:"event"`
+// WebhookResponse defines the structure for external webhook responses.
+type WebhookResponse struct {
+ ID string `json:"id"` // Unique identifier for the webhook
+ URL string `json:"url"` // URL of the webhook
+ Country string `json:"country,omitempty"` // Country associated with the webhook
+ Event []string `json:"event"` // Events that trigger the webhook
}
-type WebhookGet struct {
- ID string `json:"id"`
- UUID string `json:"uuid"`
- URL string `json:"url"`
- Country string `json:"country,omitempty"`
- Event []string `json:"event"`
+// WebhookInternal is a structure to store internal-facing webhook information.
+type WebhookInternal struct {
+ ID string `json:"id"` // Unique identifier for the webhook
+ UUID string `json:"uuid"` // UUID associated with the webhook
+ URL string `json:"url"` // URL of the webhook
+ Country string `json:"country,omitempty"` // Country associated with the webhook
+ Event []string `json:"event"` // Events that trigger the webhook
}
+// Author defines an author element for use in structured messages.
type Author struct {
- Name string `json:"name"`
+ Name string `json:"name"` // Name of the author
}
+// Field defines a single field in a structured message.
type Field struct {
- Name string `json:"name"`
- Value string `json:"value"`
- Inline bool `json:"inline"`
+ Name string `json:"name"` // Name of the field
+ Value string `json:"value"` // Value of the field
+ Inline bool `json:"inline"` // Whether the field is inline
}
+// Footer defines a footer element for use in structured messages.
type Footer struct {
- Text string `json:"text"`
+ Text string `json:"text"` // Text content of the footer
}
+// Embed defines the structure for embedded content in messages.
type Embed struct {
- Title string `json:"title"`
- Author Author `json:"author"`
- Description string `json:"description"`
- Timestamp string `json:"timestamp"`
- Color int `json:"color"`
- Fields []Field `json:"fields"`
- Footer Footer `json:"footer"`
+ Title string `json:"title"` // Title of the embed
+ Author Author `json:"author"` // Author information
+ Description string `json:"description"` // Description text
+ Timestamp string `json:"timestamp"` // Timestamp for the embed
+ Color int `json:"color"` // Color code for the embed bar
+ Fields []Field `json:"fields"` // Fields included in the embed
+ Footer Footer `json:"footer"` // Footer information
}
+// WebhookPayload defines the payload structure for webhook messages.
type WebhookPayload struct {
- Username string `json:"username"`
- AvatarURL string `json:"avatar_url"`
- Embeds []Embed `json:"embeds"`
+ Username string `json:"username"` // Username for the webhook message
+ AvatarURL string `json:"avatar_url"` // URL to the avatar image
+ Embeds []Embed `json:"embeds"` // Embedded content in the message
}
diff --git a/Go/web/root.html b/Go/web/root.html
index de51d6dc3c34bed5ac95fc41ce2d5e031ee1696a..2c7c6efc8bc224b3387bc4aea6ddfff436c99ce8 100644
--- a/Go/web/root.html
+++ b/Go/web/root.html
@@ -8,12 +8,14 @@
<div>
<h2>This service does not provide any functionality on root level.</h2>
<h3>Please use endpoints:</h3>
- <a href="/dashboard/v1/registrations">/dashboard/v1/registrations</a>
- <a href="/dashboard/v1/dashboards">/dashboard/v1/dashboards</a>
- <a href="/dashboard/v1/notifications">/dashboard/v1/notifications</a>
- <a href="/dashboard/v1/status">/dashboard/v1/status</a>
+ <a href="/dashboards/v1/registrations">/dashboards/v1/registrations</a>
+ <a href="/dashboards/v1/dashboard">/dashboards/v1/dashboard</a>
+ <a href="/dashboards/v1/notifications">/dashboards/v1/notifications</a>
+ <a href="/dashboards/v1/status">/dashboards/v1/status</a>
<h3>Before you can access the endpoints, please register as a user to acquire an API key:</h3>
- <a href="/util/v1/register">/util/v1/register</a>
+ <a href="/util/v1/user/register">/util/v1/user/register</a>
+ <h3>If you want to delete your user account, refer to:</h3>
+ <a href="/util/v1/user/delete">/util/v1/user/delete</a>
<h3>Please Refer to Git Repo for documentation:<a href="https://git.gvk.idi.ntnu.no/course/prog2005/prog2005-2024-workspace/nintendo_alex/globeboard">NTNU Gjøvik GitLab</a></h3>
</div>
</body>
diff --git a/LICENCE.md b/LICENCE.md
new file mode 100644
index 0000000000000000000000000000000000000000..23a440efdefdbd952ec4fec991a49d33fd048918
--- /dev/null
+++ b/LICENCE.md
@@ -0,0 +1,18 @@
+# License
+
+## Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License
+
+Copyright (c) 2024 [Your Full Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, and share the Software in any medium or format for any non-commercial purposes, subject to the following conditions:
+
+**Attribution** — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+
+**NonCommercial** — You may not use the material for commercial purposes.
+
+**NoDerivatives** — If you remix, transform, or build upon the material, you may not distribute the modified material.
+
+The above copyright notice and this permission notice shall be included in all copies or significant portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..579238b57daec4f6dcfb2e3eb5ab7f98116a65c1
--- /dev/null
+++ b/README.md
@@ -0,0 +1,759 @@
+
+# GlobeBoard Go REST API
+
+## Introduction
+
+[](https://git.gvk.idi.ntnu.no/Nintendo_Alex/globeboard_cicd/-/commits/main)
+[](https://git.gvk.idi.ntnu.no/Nintendo_Alex/globeboard_cicd/-/commits/main)
+[](https://creativecommons.org/licenses/by-nc-nd/4.0/)
+
+GlobeBoard Go REST API is a REST API service designed to provide GeoLocational Information.
+
+## Authors
+This code was developed by:
+- Torgrim Thorsen [@Nintendo_Alex](https://git.gvk.idi.ntnu.no/Nintendo_Alex)
+
+## Features
+
+- User Registration through Firestore Auth
+- API Key Access
+- GitLab CI/CD Testing and Deployment
+- Docker Compose Containerization
+- Discord Webhook Integration
+
+
+
+## Tech Stack
+
+### API Implementation
+- **Language:** Go
+
+### Deployment
+
+Project is hosted on NTNU Openstack: [NTNU Openstack](http://10.212.171.74:8080/)
+
+Must be connected to NTNU Internal Network to access.
+
+- **Platform:** OpenStack
+- **Containerization:** Docker Compose
+ - **Description:** Services are containerized using Docker Compose to facilitate easy deployment and scaling.
+
+## API Reference / Documentation
+
+<details>
+<summary><h4>Register as a user to receive an API key:</h4></summary>
+
+```http
+ POST /util/v1/user/register
+```
+| Content-Type |
+|:------------------------------------|
+| `application/x-www-form-urlencoded` |
+
+| Key | Value: Type | Description |
+|:-----------|:------------|:----------------------------|
+| `username` | `string` | **Required**. Your Username |
+| `email` | `string` | **Required**. Your Email |
+| `password` | `string` | **Required**. Your Password |
+
+#### Response:
+
+| Status Code | Content-Type |
+|:--------------|:-------------------|
+| `201 Created` | `application/json` |
+
+```json
+{
+ "token": "your API key",
+ "userid": "your Unique User ID (UUID)"
+}
+```
+
+</details>
+
+<details>
+<summary><h4>Delete your user profile:</h4></summary>
+
+```http
+ DELETE /util/v1/user/delete/{ID}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:------------------------|
+| `ID` | `string` | **Required**. Your UUID |
+
+#### Response:
+
+| Status Code | `204 No Content` |
+|:------------|:-----------------|
+
+</details>
+
+<details>
+<summary><h4>Get a New API key: (Old must be deleted first, only allowed one)</h4></summary>
+
+```http
+ GET /util/v1/key/
+```
+
+| Authorization | `Your UUID` |
+|:--------------|:------------|
+
+#### Response:
+
+| Status Code | Content-Type |
+|:--------------|:-------------------|
+| `201 Created` | `application/json` |
+
+```json
+{
+ "token": "your new API key"
+}
+```
+
+</details>
+
+<details>
+<summary><h4>Delete your API key:</h4></summary>
+
+```http
+ DELETE /util/v1/key/?token={token}
+```
+| Authorization | `Your UUID` |
+|:--------------|:------------|
+
+| Parameter | Type | Description |
+|:----------|:---------|:------------------------------------------|
+| `token` | `string` | **Required**. Your API key, to be deleted |
+
+#### Response:
+
+| Status Code | `204 No Content` |
+|:------------|:-----------------|
+
+</details>
+
+<details>
+<summary><h4>Check API Statuses: (Firestore, independent third party API, Version, Uptime)</h4></summary>
+
+```http
+ GET /dashboards/v1/status?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:---------------------------|
+| `token` | `string` | **Required**. Your API key |
+
+#### Response:
+
+| Status Code | Content-Type |
+|:-------------|:-------------------|
+| `200 OK` | `application/json` |
+
+```json
+{
+ "countries_api": "Status of the REST Countries API",
+ "meteo_api": "Status of the Open-Meteo API",
+ "currency_api": "Status of the REST Currency API",
+ "firebase_db": "Status of your Firestore Database",
+ "webhooks": "Number of webhooks tied to your user",
+ "version": "API Version",
+ "uptime": "Time since last server reboot (In Seconds)"
+}
+```
+
+</details>
+
+<details>
+<summary><h4>Register a Country to get information for:</h4></summary>
+
+```http
+ POST /dashboards/v1/registrations?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:---------------------------|
+| `token` | `string` | **Required**. Your API key |
+
+##### Example POST-Body:
+```json
+{
+ //The Name of the Country Can be omitted if "isocode" is provided. Case-Insensitive
+ "country": "Norway",
+ //Isocode for the Country Can be omitted if "country" is provided. Case-Insensitive
+ "isoCode": "NO",
+ // Map of Features to include when querying the dashboard endpoint,
+ // features to not include can be omitted
+ "features": {
+ "temperature": true,
+ "precipitation": true,
+ "capital": true,
+ "coordinates": true,
+ "population": true,
+ "area": true,
+ // List of currencies to retrieve the exchange rate for relative to local currency, NOK in this case. Case-Insensitive
+ "targetCurrencies": ["JPY", "usd", "EUR"]
+ }
+}
+```
+#### Example of minimal allowed POST Body:
+```json
+{
+ "isocode": "us",
+ "features": {
+ "targetCurrencies": ["NOK"]
+ }
+}
+```
+
+#### Response:
+
+| Status Code | Content-Type |
+|:--------------|:-------------------|
+| `201 Created` | `application/json` |
+
+```json
+{
+ "id": "The registration's ID",
+ "lastChange": "Firestore timestamp indicating creation (ISO8601 Format)",
+}
+
+```
+
+</details>
+
+<details>
+<summary><h4>Retrieve all registered countries:</h4></summary>
+
+```http
+ GET /dashboards/v1/registrations?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:---------------------------|
+| `token` | `string` | **Required**. Your API key |
+
+
+#### Response:
+
+| Status Code | Content-Type |
+|:-------------|:-------------------|
+| `200 OK` | `application/json` |
+
+##### Example Response Body:
+```json
+[
+ {
+ "id": "4SiQmF4Vo6wyq2yW",
+ "country": "United States",
+ "isoCode": "US",
+ "features": {
+ "temperature": true,
+ "precipitation": false,
+ "capital": false,
+ "coordinates": false,
+ "population": false,
+ "area": false,
+ "targetCurrencies": [
+ "NOK"
+ ]
+ },
+ "lastchange": "2024-04-18T22:21:54.105Z"
+ },
+ {
+ "id": "29dr0SFCfv6fyabb",
+ "country": "Norway",
+ "isoCode": "NO",
+ "features": {
+ "temperature": true,
+ "precipitation": true,
+ "capital": true,
+ "coordinates": true,
+ "population": true,
+ "area": true,
+ "targetCurrencies": [
+ "JPY",
+ "USD",
+ "EUR"
+ ]
+ },
+ "lastchange": "2024-04-18T22:19:48.651Z"
+ },
+ ...
+]
+```
+
+</details>
+
+<details>
+<summary><h4>Retrieve a specific registration:</h4></summary>
+
+```http
+ GET /dashboards/v1/registrations/{ID}?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:----------------------------------|
+| `ID` | `string` | **Required**. The Registration ID |
+| `token` | `string` | **Required**. Your API key |
+
+
+#### Response:
+
+| Status Code | Content-Type |
+|:-------------|:-------------------|
+| `200 OK` | `application/json` |
+
+##### Example Response Body:
+```json
+{
+ "id": "4SiQmF4Vo6wyq2yW", // The Requested ID
+ "country": "United States",
+ "isoCode": "US",
+ "features": {
+ "temperature": true,
+ "precipitation": false,
+ "capital": false,
+ "coordinates": false,
+ "population": false,
+ "area": false,
+ "targetCurrencies": [
+ "NOK"
+ ]
+ },
+ "lastchange": "2024-04-18T22:21:54.105Z"
+}
+```
+
+</details>
+
+<details>
+<summary><h4>Update a specific registration:</h4></summary>
+
+```http
+ PATCH /dashboards/v1/registrations/{ID}?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:----------------------------------|
+| `ID` | `string` | **Required**. The Registration ID |
+| `token` | `string` | **Required**. Your API key |
+
+Specify features to update, Country/Isocode cannot be updated;
+every feature is not allowed to be false, at least one feature must be true.
+
+##### Example POST-Body:
+```json
+{
+ "features": {
+ "temperature": true,
+ "capital": true,
+ "coordinates": true,
+ "targetCurrencies": ["NOK", "EUR"]
+ }
+}
+```
+
+#### Response:
+
+| Status Code | Content-Type |
+|:---------------|:-------------------|
+| `202 Accepted` | `application/json` |
+
+```json
+{
+ "lastChange": "Updated Server timestamp indicating successful update"
+}
+```
+
+</details>
+
+<details>
+<summary><h4>Delete a specific registration:</h4></summary>
+
+```http
+ DELETE /dashboards/v1/registrations/{ID}?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:----------------------------------|
+| `ID` | `string` | **Required**. The Registration ID |
+| `token` | `string` | **Required**. Your API key |
+
+#### Response:
+
+| Status Code | `204 No Content` |
+|:--------------|:-------------------|
+
+</details>
+
+<details>
+<summary><h4>Retrieve a populated specific registration:</h4></summary>
+
+```http
+ GET /dashboards/v1/dashboard/{ID}?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:----------------------------------|
+| `ID` | `string` | **Required**. The Registration ID |
+| `token` | `string` | **Required**. Your API key |
+
+#### Response:
+
+| Status Code | Content-Type |
+|:---------------|:-------------------|
+| `200 OK` | `application/json` |
+
+##### Example Response Body:
+```json
+{
+ "id": "29dr0SFCfv6fyabb",
+ "country": "Norway",
+ "iso_code": "NO",
+ "features": {
+ "temperature": "-5.4",
+ "precipitation": "0.00",
+ "capital": "Oslo",
+ "coordinates": {
+ "latitude": "62.00000",
+ "longitude": "62.00000"
+ },
+ "population": 5379475,
+ "area": "323802.0",
+ "targetCurrencies": {
+ "EUR": 0.085272,
+ "JPY": 14.04044,
+ "USD": 0.090918
+ }
+ },
+ "lastRetrieval": "2024-04-18T23:43:04.501Z"
+}
+```
+#### Example minimal Response Body: (Registration with only temperature)
+```json
+{
+ "id": "29dr0SFCfv6fyabb",
+ "country": "Norway",
+ "iso_code": "NO",
+ "features": {
+ "temperature": "-5.2"
+ },
+ "lastRetrieval": "2024-04-19T00:01:39.642Z"
+}
+```
+
+</details>
+
+<details>
+<summary><h4>Register a Webhook:</h4></summary>
+
+```http
+ POST /dashboards/v1/notifications?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:---------------------------|
+| `token` | `string` | **Required**. Your API key |
+
+##### Example POST-Body:
+```json
+{
+ "url": "Where to send the webhook payload", //Discord, webhook.site, etc...
+ "country": "isocode for the country the webhook applies to, leave empty for all.",
+ "event": ["List of events the webhook applies to."]
+}
+```
+##### List of Webhook Events:
+| Event | Description |
+|:-----------|:---------------------------------------|
+| `INVOKE` | Envoke Webhook on retrival events. |
+| `REGISTER` | Envoke Webhook on registration events. |
+| `CHANGE` | Envoke Webhook on update events. |
+| `DELETE` | Envoke Webhook on deletion events. |
+
+#### Response:
+
+| Status Code | Content-Type |
+|:---------------|:-------------------|
+| `201 Created` | `application/json` |
+
+##### Example Response Body:
+```json
+{
+ "id": "Webhook ID"
+}
+```
+
+</details>
+
+<details>
+<summary><h4>Retrieve all Webhooks:</h4></summary>
+
+```http
+ GET /dashboards/v1/notifications?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:---------------------------|
+| `token` | `string` | **Required**. Your API key |
+
+#### Response:
+
+| Status Code | Content-Type |
+|:---------------|:-------------------|
+| `200 OK` | `application/json` |
+
+##### Example Response Body:
+```json
+[
+ {
+ "id": "J0Y5k6KCuRpPKC8n",
+ "url": "https://discord.com/api/webhooks",
+ "event": [
+ "INVOKE",
+ "REGISTER",
+ "CHANGE",
+ "DELETE"
+ ]
+ },
+ {
+ "id": "FfbtRI0kEcRVus3D",
+ "url": "https://webhook.site/",
+ "country": "NO",
+ "event": [
+ "INVOKE"
+ ]
+ }
+]
+```
+
+</details>
+
+<details>
+<summary><h4>Retrieve specific Webhook:</h4></summary>
+
+```http
+ GET /dashboards/v1/notifications/{ID}?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:-----------------------------|
+| `ID` | `string` | **Required**. The Webhook ID |
+| `token` | `string` | **Required**. Your API key |
+
+#### Response:
+
+| Status Code | Content-Type |
+|:---------------|:-------------------|
+| `200 OK` | `application/json` |
+
+##### Example Response Body:
+```json
+{
+ "id": "FfbtRI0kEcRVus3D",
+ "url": "https://webhook.site/",
+ "country": "NO",
+ "event": [
+ "INVOKE"
+ ]
+}
+```
+
+</details>
+
+<details>
+<summary><h4>Delete a Webhook:</h4></summary>
+
+```http
+ DELETE /dashboards/v1/notifications/{ID}?token={token}
+```
+
+| Parameter | Type | Description |
+|:----------|:---------|:-----------------------------|
+| `ID` | `string` | **Required**. The Webhook ID |
+| `token` | `string` | **Required**. Your API key |
+
+#### Response:
+
+| Status Code | `204 No Content` |
+|:--------------|:-------------------|
+
+</details>
+
+## Environment Variables
+
+To run this project, you will need to add the following environment variables to your .env file, or project environment.
+
+`PORT` - Port to run the project on.
+
+`FIREBASE_CREDENTIALS_FILE` - Path to your Firebase credentials file.
+
+`FIRESTORE_PROJECT_ID` - Project ID from Google Firebase that contains Firestore.
+
+## Test in Postman (Against Hosted Site)
+
+- Clone the repository
+
+```bash
+ git clone git@git.gvk.idi.ntnu.no:course/prog2005/prog2005-2024-workspace/nintendo_alex/globeboard.git
+```
+
+ - Navigate to the project directory:
+
+ ```bash
+ cd globeboard
+ ```
+ - Copy the Postman collection:
+ ```bash
+ cp ./GlobeBoard (Openstack).postman_collection.json ~
+ ```
+ - In Postman:
+ - Menu (Top Right) -> File -> Import.
+ - Select the copied file.
+
+NOTE: Must be connected to NTNU internal Network.
+
+## Run Locally
+
+- Clone the repository
+
+```bash
+ git clone git@git.gvk.idi.ntnu.no:course/prog2005/prog2005-2024-workspace/nintendo_alex/globeboard.git
+```
+
+- Navigate to the project directory:
+
+```bash
+cd globeboard/Go/
+```
+- ### Run using Go:
+ ```bash
+ go run ./cmd/globeboard/app.go
+ ```
+ - From Build:
+ ```bash
+ go build -a -o app ./cmd/globeboard
+ ```
+ ```bash
+ ./app
+ ```
+
+- ### Run using Docker:
+ ```bash
+ docker compose build
+ ```
+ - #### Attached—Command line remains connected:
+ ```bash
+ docker compose up globeboard
+ ```
+
+ - #### Detached—Start the container in the background:
+ ```bash
+ docker compose up globeboard -d
+ ```
+
+ - #### View Logs:
+ ```bash
+ docker compose logs globeboard
+ ```
+
+ - #### Follow Logs:
+ ```bash
+ docker compose logs globeboard -f
+ ```
+
+ - #### Stop Services:
+ ```bash
+ docker compose down globeboard
+ ```
+
+## Running Tests
+
+To run tests, navigate to the project directory:
+
+```bash
+cd globeboard/Go/
+```
+- ### Run test using Go:
+ ```bash
+ go test ./cmd/globeboard
+ ```
+ - From Build:
+ ```bash
+ go test -c -o test ./cmd/globeboard
+ ```
+ ```bash
+ ./app
+ ```
+ - With Coverage using Go: (Full Project)
+ ```bash
+ go test -cover -coverpkg=./... ./cmd/globeboar
+ ```
+ - With Coverage from Build:
+ ```bash
+ go test -c -cover -coverpkg=./... -o test ./cmd/globeboard
+ ```
+ ```bash
+ ./test
+ ```
+
+- ### Run test in Docker:
+ ```bash
+ docker compose build
+ ```
+ - #### Attached—Command line remains connected:
+ ```bash
+ docker compose up globeboard-test
+ ```
+
+ - #### Detached—Start the container in the background:
+ ```bash
+ docker compose up globeboard-test -d
+ ```
+
+ - #### View Logs:
+ ```bash
+ docker compose logs globeboard-test
+ ```
+
+ - #### Follow Logs:
+ ```bash
+ docker compose logs globeboard-test -f
+ ```
+
+ - #### Stop Services:
+ ```bash
+ docker compose down globeboard-test
+ ```
+
+## Roadmap
+
+- Implement more secure registration for users to the application.
+ - Actual authentication of users before registration.
+ - Implement check if user has authenticated before registration.
+
+## Contributing
+
+Contributions to the GlobeBoard REST API are welcome! To contribute, follow these steps:
+
+- Fork the repository.
+- Clone your forked repository to your local machine.
+- Create a new branch for your changes.
+- Make your changes and commit them with clear and concise messages.
+- Push your changes to your forked repository.
+- Submit a pull request to the original repository, explaining your changes and their significance.
+
+Please adhere to the project's code of conduct and contribution guidelines provided in the [`./CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md) and [`./CONTRIBUTING.md`](CONTRIBUTING.md) files, respectively.
+
+## Support
+
+For support, email `torgrilt@stud.ntnu.no` or `torgrim.l.thorsen@gmail.com`.
+
+## License
+This project is licensed under:
+[](https://creativecommons.org/licenses/by-nc-nd/4.0/)
+
+You are free to download and use this code for educational, personal learning, or non-commercial purposes.
+And while we encourage these uses, please note that using this project for commercial distribution,
+sales, or any form of monetization is not permitted.
\ No newline at end of file
diff --git a/readme/go.jpg b/go.jpg
similarity index 100%
rename from readme/go.jpg
rename to go.jpg
diff --git a/readme.md b/readme.md
deleted file mode 100644
index da6c9773461e623cd67495a08772796cb78519b3..0000000000000000000000000000000000000000
--- a/readme.md
+++ /dev/null
@@ -1,108 +0,0 @@
-# GlobeBoard Go REST API [](https://opensource.org/license/mit/)
-
-
-
-## Introduction
-GlobeBoard Go REST API is a webapplication REST API service designed to provide GeoLocational Information.
-
-## Author
-This code was developed by:
-- Torgrim Thorsen [@Nintendo_Alex](https://git.gvk.idi.ntnu.no/Nintendo_Alex)
-- Robin Jahre [@robinja](https://git.gvk.idi.ntnu.no/Nrobinja)
-- Phrot Vedal [@BossTheModern](https://git.gvk.idi.ntnu.no/BossTheModern)
-
-
-## Features
-- TODO
-
-## Endpoints
-
-### Library
-- **Endpoint**: `/library/v1/?languages={:two_letter_language_code+}{&search={:string}}{&page={:number}}`
-- **Method**: GET
-- **Description**: This endpoint provides access to the Gutendex library, allowing users to retrieve various information about books and their metadata. Users can specify parameters to filter the results:
- - `languages`: Optional parameter to filter books by language. Users can specify one or more two-letter language codes.
- - `search`: Optional parameter to search for books based on a provided string.
- - `page`: Optional parameter to paginate through the results, specifying the page number.
-
-Example:
-```
-/library/v1/?languages=en,fr&search=charles&page=1
-```
-
-This endpoint enables users to query the Gutendex library and retrieve relevant book information based on their criteria.
-
-### Supported Languages
-- **Endpoint**: `/librarystats/v1/supported_languages/`
-- **Method**: GET
-- **Description**: This endpoint returns a list of supported languages for the Gutendex library.
-
-### Book Count
-- **Endpoint**: `/librarystats/v1/bookcount/?languages={:two_letter_language_code+}/`
-- **Method**: GET
-- **Description**: This endpoint allows users to retrieve the count of books, authors, and pages available in the Gutendex library for the specified languages.
-- **Parameters**:
- - `languages`: (Required) Specifies the languages for which book count is requested. It accepts one or more two-letter language codes.
-- **Example**:
- ```
- /librarystats/v1/bookcount/?languages=en,fr
- ```
-
-### Readership
-- **Endpoint**: `/librarystats/v1/readership/{:two_letter_language_code}/{?limit={:number}}`
-- **Description**: This endpoint retrieves statistics related to readership, such as the number of possible readers for the Gutendex library from countries for a specified language.
-- **Parameters**:
- - `language_code`: (Required) Specifies the language for which readership statistics are requested.
- - `limit`: (Optional) Limits the number of results returned. Defaults to all readership statistics if not provided.
-- **Example**:
- ```
- /librarystats/v1/readership/en/?limit=10
- ```
-
-### Status
-- **Endpoint**: `/librarystats/v1/status/`
-- **Method**: GET
-- **Description**: This endpoint returns the current status of the Gutendex library, providing information about the uptime, version number, and the status of the APIs Gutendex is communicating with. Users can utilize this endpoint to monitor the availability and operational status of the Gutendex service.
-
-These endpoints enable users to interact with the Gutendex REST API, accessing various functionalities and retrieving relevant data.
-
-## Setup
-To Run Gutendex REST API locally, follow these steps:
-
-1. Clone the repository:
- ```bash
- git clone https://git.gvk.idi.ntnu.no/course/prog2005/prog2005-2024-workspace/nintendo_alex/globeboard.git
- ```
-
-2. Navigate to the project directory:
- ```bash
- cd GlobeBoard/Go/cmd/globeboard
- ```
-
-3. Run the Go server:
- ```bash
- go run app.go
- ```
-
-4. Access the REST API endpoints through your preferred HTTP client.
-
-## Roadmap
-- TODO
-
-## Contributing
-Contributions to the GlobeBoard REST API are welcome! To contribute, follow these steps:
-
-1. Fork the repository.
-2. Clone your forked repository to your local machine.
-3. Create a new branch for your changes.
-4. Make your changes and commit them with clear and concise messages.
-5. Push your changes to your forked repository.
-6. Submit a pull request to the original repository, explaining your changes and their significance.
-
-Please adhere to the project's code of conduct and contribution guidelines provided in the [`./readme/conduct.md`](./readme/conduct.md) and [`./readme/contribute.md`](./readme/contribute.md) files, respectively.
-
-## License
-This project is licensed under:
-[](https://opensource.org/license/mit/)
-
-You are free to download and use the code for academic or non-commercial purposes, but distribution, selling, or capitalizing on the project is strictly prohibited.
\ No newline at end of file