Upload 9 files

Dockerfile

@@ -0,0 +1,15 @@
+# Usa una imagen base de Python
+FROM python:3.11
+# Establece el directorio de trabajo
+WORKDIR /code
+
+# Copia los archivos necesarios al contenedor
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir -r /code/requirements.txt
+
+COPY . .
+
+RUN chmod -R 777 /code
+
+# Comando para ejecutar la aplicación
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,70 @@
+import os
+from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi.responses import FileResponse
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+from create_database import create_db
+from routers import teacher, review, user
+
+# Cargar variables de entorno desde el archivo .env
+load_dotenv()
+if not os.path.exists("site.db"):
+    create_db()
+
+# Obtener credenciales de las variables de entorno
+BASIC_AUTH_USER = os.getenv("BASIC_AUTH_USER")
+BASIC_AUTH_PASSWORD = os.getenv("BASIC_AUTH_PASSWORD")
+
+
+app = FastAPI(
+    title="API de revisión de profesores",
+    description="API para revisar profesores",
+    version="2.8.7",
+    openapi_url="/teacher-openapi.json",
+    docs_url="/teacher-docs",
+    redoc_url="/teacher-redoc",
+    contact={
+        "name": "teacher",
+        "url": "https://www.test.com",
+        "email": "calificandoprofesoruniversidad@gmail.com",
+    },
+    license_info={"name": "MIT", "url": "https://opensource.org/licenses/MIT"},
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+security = HTTPBasic()
+
+
+def authenticate(credentials: HTTPBasicCredentials = Depends(security)):
+    if (
+        credentials.username != BASIC_AUTH_USER
+        or credentials.password != BASIC_AUTH_PASSWORD
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Credenciales incorrectas",
+            headers={"WWW-Authenticate": "Basic"},
+        )
+
+
+@app.get(
+    "/",
+    summary="Saludo",
+    description="Saludo de la API",
+)
+def read_root():
+    return {"message": "Bienvenido a la API de la revisión de profesores"}
+
+
+app.include_router(teacher.router, dependencies=[Depends(authenticate)])
+app.include_router(review.router, dependencies=[Depends(authenticate)])
+app.include_router(user.router, dependencies=[Depends(authenticate)])

create_database.py

@@ -0,0 +1,47 @@
+import sqlite3
+
+
+def create_db():
+    # Conexión a la base de datos
+    conn = sqlite3.connect("site.db")
+    cursor = conn.cursor()
+
+    # Crear tablas
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS user (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            email TEXT UNIQUE NOT NULL,
+            password TEXT NOT NULL
+        )
+    """
+    )
+
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS teacher (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            department TEXT NOT NULL
+        )
+    """
+    )
+
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS review (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            content TEXT NOT NULL,
+            rating INTEGER NOT NULL,
+            date_posted DATETIME NOT NULL DEFAULT (datetime('now')),
+            teacher_id INTEGER NOT NULL,
+            user_id INTEGER,
+            FOREIGN KEY (teacher_id) REFERENCES teacher(id),
+            FOREIGN KEY (user_id) REFERENCES user(id)
+        )
+    """
+    )
+
+    conn.commit()
+    conn.close()

models.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+from typing import Optional
+
+
+class User(BaseModel):
+    id: Optional[int] = None
+    username: str = Field(..., max_length=20)
+    email: str = Field(..., max_length=120)
+    password: str = Field(..., max_length=60)
+
+
+class Teacher(BaseModel):
+    id: int
+    name: str = Field(..., max_length=100)
+    department: str = Field(..., max_length=100)
+
+
+class Review(BaseModel):
+    id: Optional[int] = None
+    content: str
+    rating: int
+    date_posted: datetime = Field(default_factory=datetime.now)
+    teacher_id: int
+    user_id: Optional[int] = None

routers/review.py

@@ -0,0 +1,109 @@
+from datetime import datetime
+import sqlite3
+from typing import Optional
+from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
+from models import Review
+
+router = APIRouter(
+    prefix="/review",
+    tags=["Review"],
+    responses={404: {"description": "Not found"}},
+)
+
+"""
+        CREATE TABLE IF NOT EXISTS review (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            content TEXT NOT NULL,
+            rating INTEGER NOT NULL,
+            date_posted DATETIME NOT NULL DEFAULT (datetime('now')),
+            teacher_id INTEGER NOT NULL,
+            user_id INTEGER,
+            FOREIGN KEY (teacher_id) REFERENCES teacher(id),
+            FOREIGN KEY (user_id) REFERENCES user(id)
+        )
+    """
+
+
+@router.get("/")
+def get_reviews():
+    """
+    Get all reviews
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM review")
+        reviews = cursor.fetchall()
+        conn.close()
+        return reviews
+    except Exception as e:
+        return []
+
+
+@router.get("/{review_id}")
+def get_review(review_id: int):
+    """
+    Get a review by id
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM review WHERE id=?", (review_id,))
+        review = cursor.fetchone()
+        conn.close()
+        # retornar en formato json
+        review = Review(
+            id=review[0],
+            content=review[1],
+            rating=review[2],
+            date_posted=review[3],
+            teacher_id=review[4],
+            user_id=review[5],
+        )
+        return review
+    except Exception as e:
+        return []
+
+
+class ReviewPost(BaseModel):
+    content: str
+    rating: int
+    date_posted: datetime = Field(default_factory=datetime.now)
+    teacher_id: int
+
+
+@router.post("/")
+def create_review(r: ReviewPost):
+    """
+    Create a review
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO review (content, rating, teacher_id, user_id) VALUES (?, ?, ?, ?)",
+            (r.content, r.rating, r.teacher_id, 1),
+        )
+        conn.commit()
+        conn.close()
+        return {"message": "Review created"}
+    except Exception as e:
+        return {"message": "Error creating review"}
+
+
+@router.get("/search_review/{teacher_id}")
+def get_reviews_by_teacher(teacher_id: int):
+    """
+    Get all reviews for a teacher
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM review WHERE teacher_id=?", (teacher_id,))
+        reviews = cursor.fetchall()
+        conn.close()
+        return reviews
+    except Exception as e:
+        return []

routers/teacher.py

@@ -0,0 +1,119 @@
+import sqlite3
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from models import Teacher
+
+
+router = APIRouter(
+    prefix="/teacher",
+    tags=["Teacher"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+"""
+        CREATE TABLE IF NOT EXISTS teacher (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            department TEXT NOT NULL
+        )
+    """
+
+
+@router.get("/")
+def get_teachers():
+    """
+    Get all teachers
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM teacher")
+        teachers = cursor.fetchall()
+        conn.close()
+        teachers = [Teacher(id=t[0], name=t[1], department=t[2]) for t in teachers]
+        return teachers
+    except Exception as e:
+        return []
+
+
+@router.get("/{teacher_id}")
+def get_teacher(teacher_id: int):
+    """
+    Get a teacher by id
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM teacher WHERE id=?", (teacher_id,))
+        teacher = cursor.fetchone()
+        conn.close()
+        teacher = Teacher(id=teacher[0], name=teacher[1], department=teacher[2])
+        return teacher
+    except Exception as e:
+        return []
+
+
+class TeacherPost(BaseModel):
+    name: str
+    department: str
+
+
+@router.post("/")
+def create_teacher(t: TeacherPost):
+    """
+    Create a teacher
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO teacher (name, department) VALUES (?, ?)",
+            (t.name, t.department),
+        )
+        conn.commit()
+        conn.close()
+        return {"status": "success", "message": "Teacher created"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+# search by teacher name
+@router.get("/search/{teacher_name}")
+def search_teacher(teacher_name: str):
+    """
+    Search a teacher by name
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT * FROM teacher WHERE name LIKE ?", (f"%{teacher_name}%",)
+        )
+        teacher = cursor.fetchall()
+        conn.close()
+        teacher = [Teacher(id=t[0], name=t[1], department=t[2]) for t in teacher]
+        return teacher
+    except Exception as e:
+        return []
+
+
+# insertar una lista de profesores en la base de datos
+@router.post("/bulk")
+def bulk_teacher(teachers: list[TeacherPost]):
+    """
+    Bulk insert teachers
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        for t in teachers:
+            cursor.execute(
+                "INSERT INTO teacher (name, department) VALUES (?, ?)",
+                (t.name, t.department),
+            )
+        conn.commit()
+        conn.close()
+        return {"status": "success", "message": "Teachers created"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}

routers/user.py

@@ -0,0 +1,81 @@
+import sqlite3
+from typing import Optional
+from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
+from models import User
+
+router = APIRouter(
+    prefix="/user",
+    tags=["User"],
+    responses={404: {"description": "Not found"}},
+)
+
+"""
+        CREATE TABLE IF NOT EXISTS user (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            email TEXT UNIQUE NOT NULL,
+            password TEXT NOT NULL
+        )
+    """
+
+
+@router.get("/")
+def get_users():
+    """
+    Get all users
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM user")
+        users = cursor.fetchall()
+        conn.close()
+        users = [User(id=u[0], username=u[1], email=u[2], password=u[3]) for u in users]
+        return users
+    except Exception as e:
+        return []
+
+
+@router.get("/{user_id}")
+def get_user(user_id: int):
+    """
+    Get a user by id
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM user WHERE id=?", (user_id,))
+        user = cursor.fetchone()
+        conn.close()
+        user = User(id=user[0], username=user[1], email=user[2], password=user[3])
+        return user
+    except Exception as e:
+        return []
+
+
+class UserPost(BaseModel):
+    id: Optional[int] = None
+    username: str = Field(..., max_length=20)
+    email: str = Field(..., max_length=120)
+    password: str = Field(..., max_length=60)
+
+
+@router.post("/")
+def create_user(u: User):
+    """
+    Create a user
+    """
+    try:
+        conn = sqlite3.connect("site.db")
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO user (username, email, password) VALUES (?, ?, ?)",
+            (u.username, u.email, u.password),
+        )
+        conn.commit()
+        conn.close()
+        return {"message": "User created"}
+    except Exception as e:
+        return {"message": "Error"}