path: root/backend/main.py

import fastapi
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import PlainTextResponse
from apscheduler.schedulers.background import BackgroundScheduler
import onesignal
from onesignal.api import default_api
import sqlite3
from typing import Annotated
import datetime
from pydantic import BaseModel
import secrets
from enum import Enum
from dotenv import load_dotenv
from os import getenv

app = fastapi.FastAPI(title="Victoria Hall LaundryWeb", description="LaundryWeb Backend API", version="0.1")
conn = sqlite3.connect("db.db", check_same_thread=False)
cursor = conn.cursor()

scheduler = BackgroundScheduler()
scheduler.start()

load_dotenv()

onesignal_configuration = onesignal.Configuration(
    rest_api_key=getenv("REST_API_KEY"),
    organization_api_key=getenv("ORGANIZATION_API_KEY"),
)

api_client = onesignal.ApiClient(onesignal_configuration)
api_instance = default_api.DefaultApi(api_client)

origins = [
    "http://localhost",
    "http://localhost:998",
    "http://localhost:5173",
    "http://127.0.0.1",
    "http://127.0.0.1:998",
    "http://127.0.0.1:5173",
    "https://laundryweb.altafcreator.com"
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

cursor.execute("""
CREATE TABLE IF NOT EXISTS timers (
    timer_id INTEGER PRIMARY KEY,
    user_id VARCHAR(64) NOT NULL,
    start_time TEXT NOT NULL,
    duration INT NOT NULL,
    block INT NOT NULL,
    machine INT NOT NULL,
    status TEXT NOT NULL CHECK(status IN ('RUNNING', 'FINISHED'))
);
               """)  # block is either 1 or 2, machine (1-4), odd is dryer, even is machine.


class RequestData(BaseModel):
    duration: int
    block: int
    machine: int


class BlockRequestData(BaseModel):
    block: int

class FinishRequestData(BaseModel):
    id: int


class Status(Enum):
    EMPTY = 0,
    FINISHED = 1,
    RUNNING = 2,
    OUTOFSERVICE = 3,


machine_status = [[Status.EMPTY.name, Status.EMPTY.name, Status.EMPTY.name, Status.EMPTY.name],
                  [Status.EMPTY.name, Status.EMPTY.name, Status.EMPTY.name, Status.EMPTY.name]]
machine_times = [[None, None, None, None],
                 [None, None, None, None]]
machine_durations = [[None, None, None, None],
                     [None, None, None, None]]


# this method checks for any entry, and starts the previously-terminated schedules
# useful if you're restarting the server
def restart_terminated_schedules():
    cursor.execute("SELECT * FROM timers;")
    out = cursor.fetchall()
    print("unfinished timers: " + str(len(out)))

    for row in out:
        print(row)
        end_date = datetime.datetime.fromisoformat(row[2]) + datetime.timedelta(minutes=row[3])
        now = datetime.datetime.now()

        if now > end_date:
            print("unfinished timer was long gone")
            scheduler.add_job(final_timer_finished, 'date', run_date=(now + datetime.timedelta(seconds=1)), id=str(row[0]), args=[row[0]])
        elif now + datetime.timedelta(minutes=5) > end_date:
            print("unfinished timer ends in less than five mins")
            scheduler.add_job(final_timer_finished, 'date', run_date=end_date, id=str(row[0]), args=[row[0]])
        else:
            print("unfinished timer scheduler started")
            print(row[0])
            scheduler.add_job(reminder_timer_finished, 'date', run_date=end_date, id=str(row[0]), args=[row[0]])

        machine_status[row[4] - 1][row[5] - 1] = Status.RUNNING.name
        machine_times[row[4] - 1][row[5] - 1] = row[2]
        machine_durations[row[4] - 1][row[5] - 1] = row[3]


def reminder_timer_finished(timer_id):
    print("timer almost finished", timer_id)
    end_date = datetime.datetime.now() + datetime.timedelta(seconds=5)
    scheduler.add_job(final_timer_finished, 'date', run_date=end_date, id=str(timer_id), args=[timer_id])


def final_timer_finished(timer_id):
    print("timer finished!1", timer_id)
    cursor.execute(f"SELECT * FROM timers WHERE timer_id = '{timer_id}'")
    out = cursor.fetchall()

    for row in out:
        machine_status[row[4] - 1][row[5] - 1] = Status.FINISHED.name


def create_session(response: fastapi.Response):
    cookie = secrets.token_hex(32)
    response.set_cookie(key="session_key", value=cookie)
    return cookie


# ## beginning

print("Hello, world!")
restart_terminated_schedules()


# ## api endpoints

# --- starting new timer
@app.post("/start", response_class=PlainTextResponse)
async def start_new_timer(data: RequestData, response: fastapi.Response, session_key: Annotated[str | None, fastapi.Cookie()] = None):
    now = datetime.datetime.now()
    try:
        if not session_key:
            print("no session key, creating.")
            session_key = create_session(response)
    except Exception as exception:
        print("err @ key creation //", exception)
        response.status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
        return "something went wrong during session key creation"

    try:
        print("session key valid", session_key)
        cursor.execute(f"""
        INSERT INTO timers (user_id, start_time, duration, block, machine, status)
        VALUES ('{session_key}', '{now.isoformat()}', {data.duration * 30}, {data.block}, {data.machine}, 'RUNNING')
                       """)
        conn.commit()
        cursor.execute("SELECT * FROM timers;")
        out = cursor.fetchall()

        for row in out:
            print(row)

        end_date = now + datetime.timedelta(minutes=(data.duration * 30) - 5)
        timer_id = str(out[len(out) - 1][0])

        print("timer id", timer_id)
    except Exception as exception:
        print("err @ sql stuff //", exception)
        response.status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
        return "something went wrong during sql stuff"

    try:
        scheduler.add_job(reminder_timer_finished, 'date', run_date=end_date, id=timer_id, args=[timer_id])
    except Exception as exception:
        print("err @ scheduler //", exception)
        response.status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
        return "something went wrong during scheduler stuff"

    try:
        machine_status[data.block - 1][data.machine - 1] = Status.RUNNING.name
        machine_times[data.block - 1][data.machine - 1] = now.isoformat()
        machine_durations[data.block - 1][data.machine - 1] = data.duration * 30
    except Exception as exception:
        print("err @ machine_status //", exception)
        response.status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
        return "something went wrong during machine_status setting somehow"

    return "all good bro timer started"


# --- check whether user has laundry or not
@app.post("/check", response_class=PlainTextResponse)
def check_status(response: fastapi.Response, session_key: Annotated[str | None, fastapi.Cookie()] = None):
    if not session_key:
        print("no session key, creating.")
        session_key = create_session(response)

    cursor.execute(f"SELECT * FROM timers WHERE user_id = '{session_key}'")
    out = cursor.fetchall()

    for row in out:
        print(row)

    if len(out) > 0:
        return "you got laundry"
    else:
        return "no got laundry"


# --- fetch machine status for block
@app.post("/status")
def get_machine_status(data: BlockRequestData):
    block_idx = data.block - 1
    return [machine_status[block_idx], machine_times[block_idx], machine_durations[block_idx]]


# --- get laundr(y/ies) information of user
@app.post("/laundry")
def get_laundry_info(response: fastapi.Response, session_key: Annotated[str | None, fastapi.Cookie()] = None):
    if session_key:
        result = []

        cursor.execute(f"SELECT * FROM timers WHERE user_id = '{session_key}'")
        out = cursor.fetchall()

        for row in out:
            curr_timer = {
                "duration": 0,
                "start_time": 0,
                "machine": 0,
                "status": "RUNNING",
                "id": -1,
            }
            curr_timer["duration"] = row[3]
            curr_timer["start_time"] = row[2]
            curr_timer["machine"] = row[5]
            curr_timer["status"] = row[6]
            curr_timer["id"] = row[0]

            result.append(curr_timer)

        return result
    else:
        response.status_code = fastapi.status.HTTP_401_UNAUTHORIZED
        return "you got no session key cookie how am i supposed to identify you"


# --- finish one's laundry
@app.post("/finish")
def finish_laundry(data: FinishRequestData, response: fastapi.Response, session_key: Annotated[str | None, fastapi.Cookie()] = None):
    if session_key:
        cursor.execute(f"SELECT * FROM timers WHERE id = '{data.id}'")
        row = cursor.fetchall()[0]

        machine_status[row[4] - 1][row[5] - 1] = Status.EMPTY.name
        machine_times[row[4] - 1][row[5] - 1] = None
        machine_durations[row[4] - 1][row[5] - 1] = None

        cursor.execute(f"DELETE FROM timers WHERE timer_id = {row[0]}")
        conn.commit()

        if session_key != row[1]:
            response.status_code = fastapi.status.HTTP_401_UNAUTHORIZED
            return "session key mismatch with timer id, dubious and hence unauthorised."
    else:
        response.status_code = fastapi.status.HTTP_401_UNAUTHORIZED
        return "you got no session key, cannot"