replace name f1 -> b1

Dockerfile

@@ -1,7 +1,7 @@
-# Wybierz bazowy obraz. Debian jest dobrym wyborem ze względu na pyenv
+# Choose a base image. Debian is a good choice due to pyenv
 FROM debian:latest
 
-# Aktualizacja listy pakietów i instalacja niezbędnych zależności
+# Update the package list and install necessary dependencies
 RUN apt-get update && apt-get install -y \
     aptitude \
     tmux vim-nox nano mc git curl termshark procps \
@@ -13,67 +13,71 @@ RUN apt-get update && apt-get install -y \
     python3-pip \
     npm
 
-# Ustawienie hasła dla użytkownika root (opcjonalne, do konfiguracji)
+# Set password for root user (optional, for configuration)
 RUN echo 'root:rootpass' | chpasswd
 
-# Dodanie nowego użytkownika `user` z hasłem `pass` i przygotowanie środowiska
+# Add a new user `user` with password `pass` and prepare the environment
 RUN useradd -m user && echo 'user:pass' | chpasswd && adduser user sudo
 
-# Przełączenie na użytkownika `user`
+# Switch to user `user`
 USER user
 WORKDIR /home/user
 
-# Ustawienie zmiennych środowiskowych
+# Install pyenv
+RUN git clone https://github.com/pyenv/pyenv .pyenv
+
+# Install pyenv-virtualenv
+RUN git clone https://github.com/pyenv/pyenv-virtualenv .pyenv/plugins/pyenv-virtualenv
+
+# Set environment variables
 ENV HOME  /home/user
 ENV PYENV_ROOT $HOME/.pyenv
-ENV PATH $PYENV_ROOT/shims:$PYENV_ROOT/bin:$HOME/.local/bin:$PATH
-ENV PYENV_VERSION p3.12
+ENV PATH $PYENV_ROOT/shims:$PYENV_ROOT/bin:$PATH
 
-# Instalacja pyenv
-RUN git clone https://github.com/pyenv/pyenv $PYENV_ROOT
+# Add pyenv and pyenv-virtualenv configuration to .bashrc
+RUN echo 'export PYENV_ROOT="$HOME/.pyenv"' >> .bashrc
+RUN echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> .bashrc
+RUN echo 'eval "$(pyenv init -)"' >> .bashrc
+RUN echo 'eval "$(pyenv virtualenv-init -)"' >> .bashrc
 
-# Instalacja pyenv-virtualenv
-RUN git clone https://github.com/pyenv/pyenv-virtualenv $PYENV_ROOT/plugins/pyenv-virtualenv
+# Install Python 3.12 with --enable-shared
+RUN bash -i -c "source ~/.bashrc && env PYTHON_CONFIGURE_OPTS='--enable-shared' pyenv install 3.12"
 
-# Dodanie konfiguracji pyenv i pyenv-virtualenv do .bashrc
-RUN echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc \
- && echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc \
- && echo 'eval "$(pyenv init --path)"' >> ~/.bashrc \
- && echo 'eval "$(pyenv init -)"' >> ~/.bashrc \
- && echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.bashrc
+# Create a virtual environment p3.12
+RUN bash -i -c "source ~/.bashrc && pyenv virtualenv 3.12 p3.12"
 
-# Instalacja Pythona 3.12 z --enable-shared
-RUN env PYTHON_CONFIGURE_OPTS="--enable-shared" pyenv install 3.12.0
+# Set p3.12 as the default virtual environment
+RUN bash -i -c "source ~/.bashrc && pyenv local p3.12"
 
-# Utworzenie środowiska wirtualnego p3.12
-RUN pyenv virtualenv 3.12.0 p3.12
+# Install ipython in the p3.12 environment
+RUN bash -i -c "source ~/.bashrc && pyenv activate p3.12 && pip install ipython"
 
-# Ustawienie p3.12 jako globalnego środowiska
-RUN pyenv global p3.12
-
-# Instalacja ipython w środowisku p3.12
-RUN pip install ipython
-
-# Instalacja Vim-Plug do zarządzania wtyczkami Vim
+# Install Vim-Plug for Vim plugin management
 RUN curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
     https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
 
-# Kopiowanie plików konfiguracyjnych vim i tmux
-COPY --chown=user:user ./_confs/.vimrc /home/user/.vimrc
-COPY --chown=user:user ./_confs/.tmux.conf /home/user/.tmux.conf
+# Copy the vim configuration file for plugins
+COPY ./_confs/.vimrc /home/user/.vimrc
 
-# Instalacja wtyczek Vim za pomocą Vim-Plug
+# Install Vim plugins via Vim-Plug
 RUN vim +'PlugInstall --sync' +qall
 
-# Instalacja Poetry w środowisku p3.12
+# Install Poetry
 RUN curl -sSL https://install.python-poetry.org | python3 -
 
-# Kopiowanie projektu do obrazu
+# Copy the project into the image
 COPY --chown=user:user . /home/user/fapi
+COPY ./_confs/* ./
 
-# Instalacja zależności za pomocą Poetry z głównego katalogu
-RUN cd /home/user/fapi && poetry config virtualenvs.create false && poetry install
+# Set the working directory for installing dependencies
+WORKDIR /home/user/fapi
 
-# Uruchomienie aplikacji
-CMD ["python", "/home/user/fapi/entrypoint.py"]
+# Add Poetry path to PATH directly in the Dockerfile
+ENV PATH="$HOME/.local/bin:$PATH"
+
+# Install dependencies using Poetry
+RUN bash -i -c "source ~/.bashrc && poetry config virtualenvs.create false && poetry install"
+
+# Run the application
+CMD ["/bin/bash", "-c", "python entrypoint.py"]
 

__n1

@@ -1,7 +1,8 @@
 sudo docker run --rm \
 	-dit \
 	--privileged \
+	-p 9999:9999 \
 	-p 8888:8888 \
-	-v /home/user/work/fapi/fapi/src:/home/user/fapi \
-	--name f1 \
+	-v "$(pwd):/home/user/fapi" \
+	--name b1 \
 	fapi bash

__run2

@@ -1 +1 @@
-docker run --rm -it -p 8888:8888 --name cfapi fapi bash 
+docker run --rm -it -p 9999:9999 --name cfapi fapi bash 

app/database.py

@@ -4,7 +4,7 @@ from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
 
 #SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"  # Dla SQLite
-SQLALCHEMY_DATABASE_URL = "mysql+mysqldb://root:secret@172.19.0.4:3306/test"
+SQLALCHEMY_DATABASE_URL = "mysql+mysqldb://root:secret@172.18.0.2:3306/test"
 
 engine = create_engine(
     SQLALCHEMY_DATABASE_URL, 

app/main.py

@@ -1,25 +1,15 @@
 from fastapi import FastAPI, Depends, HTTPException
 from sqlalchemy.orm import Session
-from fastapi.middleware.cors import CORSMiddleware
-from app.database import SessionLocal, engine
-import app.models as models
-from app.schemas import Person, PersonCreate
+from . import models, schemas
+from .database import SessionLocal, engine
+from datetime import datetime
 
 app = FastAPI()
 
-origins = [
-    "http://localhost:8080",
-    "http://mpabi.pl:8888",
-]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+# Tworzenie tabel w bazie danych
+models.Base.metadata.create_all(bind=engine)
 
+# Dependency do sesji z bazą danych
 def get_db():
     db = SessionLocal()
     try:
@@ -27,31 +17,42 @@ def get_db():
     finally:
         db.close()
 
-# Endpoint do tworzenia nowej osoby (POST)
-@app.post("/persons/", response_model=Person)
-def create_person(person: PersonCreate, db: Session = Depends(get_db)):
-    db_person = models.Person(
-        last_name=person.last_name, 
-        first_name=person.first_name, 
-        address=person.address,
-        city=person.city
-    )
-    db.add(db_person)
+# Endpoint do pobierania ról
+@app.get("/roles/", response_model=list[schemas.Role])
+def read_roles(db: Session = Depends(get_db)):
+    return db.query(models.Role).all()
+
+# Endpoint do dodania roli
+@app.post("/roles/", response_model=schemas.Role)
+def create_role(role: schemas.RoleCreate, db: Session = Depends(get_db)):
+    db_role = models.Role(name=role.name)
+    db.add(db_role)
     db.commit()
-    db.refresh(db_person)
-    return db_person
+    db.refresh(db_role)
+    return db_role
 
-# Endpoint do odczytu listy osób (GET)
-@app.get("/persons/", response_model=list[Person])
-def read_persons(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    persons = db.query(models.Person).offset(skip).limit(limit).all()
-    return persons
+# Endpoint do pobierania zdarzeń
+@app.get("/events/", response_model=list[schemas.Event])
+def read_events(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
+    return db.query(models.Event).offset(skip).limit(limit).all()
 
-# Endpoint do odczytu osoby po ID (GET)
-@app.get("/persons/{person_id}", response_model=Person)
-def read_person(person_id: int, db: Session = Depends(get_db)):
-    person = db.query(models.Person).filter(models.Person.person_id == person_id).first()
-    if person is None:
-        raise HTTPException(status_code=404, detail="Person not found")
-    return person
+# Endpoint do dodania zdarzenia
+@app.post("/events/", response_model=schemas.Event)
+def create_event(event: schemas.EventCreate, db: Session = Depends(get_db)):
+    db_event = models.Event(
+        role_id=event.role_id,
+        student_id=event.student_id,
+        criteria_id=event.criteria_id,
+        description=event.description,
+        event_date=event.event_date or datetime.now()
+    )
+    db.add(db_event)
+    db.commit()
+    db.refresh(db_event)
+    return db_event
+
+# Endpoint do pobierania informacji o zdarzeniach dla konkretnego ucznia
+@app.get("/events/student/{student_id}", response_model=list[schemas.Event])
+def read_student_events(student_id: int, db: Session = Depends(get_db)):
+    return db.query(models.Event).filter(models.Event.student_id == student_id).all()
 

app/models.py

@@ -1,25 +1,54 @@
-from sqlalchemy import Column, Integer, String
-from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey
+from sqlalchemy.orm import relationship
+from .database import Base
 
-Base = declarative_base()
+class Criteria(Base):
+    __tablename__ = "criteria"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255))
 
-class Person(Base):
-    __tablename__ = "Persons"
+class Role(Base):
+    __tablename__ = "roles"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255))
 
-    person_id = Column("PersonID", Integer, primary_key=True, index=True, autoincrement=True)
-    last_name = Column("LastName", String(255), nullable=False)
-    first_name = Column("FirstName", String(255), nullable=True)
-    address = Column("Address", String(255), nullable=True)
-    city = Column("City", String(255), nullable=True)
+class Student(Base):
+    __tablename__ = "students"
+    id = Column(Integer, primary_key=True, index=True)
+    first_name = Column(String(50))
+    last_name = Column(String(50))
+    grade = Column(String(50), default="Brak ocen")
+    points = Column(Integer, nullable=True)
+    status = Column(Integer)
 
-"""
-SQL Insert statements:
-INSERT INTO Persons (PersonID, LastName, FirstName, Address, City)
-VALUES
-(1, 'Smith', 'John', '123 Maple St', 'New York'),
-(2, 'Johnson', 'Emily', '456 Oak Ave', 'Los Angeles'),
-(3, 'Williams', 'Michael', '789 Pine Dr', 'Chicago'),
-(4, 'Brown', 'Sarah', '101 Birch Ln', 'Houston'),
-(5, 'Jones', 'David', '202 Cedar Rd', 'Phoenix');
-"""
+class ClassInfo(Base):
+    __tablename__ = "class_info"
+    id = Column(Integer, primary_key=True, index=True)
+    school = Column(String(255))
+    city = Column(String(255))
+    year = Column(String(50))
+    semester = Column(String(50))
+    subject = Column(String(255))
+    level = Column(String(50))
+    publisher = Column(String(255))
+    class_name = Column(String(50))
+    group = Column(String(50))
+    profile = Column(String(255))
+    max_points = Column(Integer)
+    teacher = Column(String(255))
+    file_path = Column(String(255))
+    student_count = Column(Integer)
+
+class Event(Base):
+    __tablename__ = "events"
+    id = Column(Integer, primary_key=True, index=True)
+    role_id = Column(Integer, ForeignKey("roles.id"), nullable=False)
+    student_id = Column(Integer, ForeignKey("students.id"), nullable=False)
+    criteria_id = Column(Integer, ForeignKey("criteria.id"), nullable=False)
+    description = Column(String(255))
+    event_date = Column(DateTime)
+
+    role = relationship("Role")
+    student = relationship("Student")
+    criteria = relationship("Criteria")
 

app/schemas.py

@@ -1,19 +1,83 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
+from datetime import datetime
 
-# Schemat do tworzenia nowej osoby (POST)
-class PersonCreate(BaseModel):
-    last_name: str = Field(..., description="Nazwisko osoby", example="Kowalski")
-    first_name: str = Field(..., description="Imię osoby", example="Jan")
-    address: str | None = None
-    city: str | None = None
+class CriteriaBase(BaseModel):
+    name: str
 
-# Schemat reprezentujący osobę (GET)
-class Person(BaseModel):
-    person_id: int
-    last_name: str
-    first_name: str
-    address: str | None = None
-    city: str | None = None
+class CriteriaCreate(CriteriaBase):
+    pass
+
+class Criteria(CriteriaBase):
+    id: int
+
+    class Config:
+        orm_mode = True
+
+class RoleBase(BaseModel):
+    name: str
+
+class RoleCreate(RoleBase):
+    pass
+
+class Role(RoleBase):
+    id: int
+
+    class Config:
+        orm_mode = True
+
+class StudentBase(BaseModel):
+    first_name: str
+    last_name: str
+    grade: str
+    points: int
+    status: int
+
+class StudentCreate(StudentBase):
+    pass
+
+class Student(StudentBase):
+    id: int
+
+    class Config:
+        orm_mode = True
+
+class ClassInfoBase(BaseModel):
+    school: str
+    city: str
+    year: str
+    semester: str
+    subject: str
+    level: str
+    publisher: str
+    class_name: str
+    group: str
+    profile: str
+    max_points: int
+    teacher: str
+    file_path: str
+    student_count: int
+
+class ClassInfoCreate(ClassInfoBase):
+    pass
+
+class ClassInfo(ClassInfoBase):
+    id: int
+
+    class Config:
+        orm_mode = True
+
+class EventBase(BaseModel):
+    role_id: int
+    student_id: int
+    criteria_id: int
+    description: str
+    event_date: datetime
+
+class EventCreate(EventBase):
+    pass
+
+class Event(EventBase):
+    id: int
 
     class Config:
         orm_mode = True