---
# System prepended metadata

title: Zapytania API

---

#  Zapytania API


## Zapytania związane z CRUD poza exchange
### Pobranie wydziałów:
* getFaculties
    * przyjmuje
        ```
        {
            token
        }
        ```
    * zwraca
        * OK
        ```
        {
            code: 200,
            faculties: [{name: string, id: int}], # shortname wydział
            message: ""
        }
        ```
        * NOK
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
### Dodawanie wykładowcy:
* addLecturer
    * dodaje danego wykładowce
    * waliduje czy name/surname nie jest puste
    * waliduje czy rating jest w zakresie -> opcjonalny argument, domyślnie -1
    * nie waliduje stopnia bo jest on z naszej listy -> opcjonalny argument, domyślnie “”, na końcu i tak bd waluduje
    * zwraca:
        * NOK
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        * OK
        ```
        {
            code: 200,
            message: ""
        }
        ```
* getLecturerDegrees
    * daje liste potencjalnych stopni, ponieważ powinny być listą żeby nie był problem że user pisze magister a my chcemy mgr
    * zwraca:
    ```
    {
        code: 200,
        message: ""
        degrees: [string] # shortname tytułu
    }
    ```

### Dodanie klasy:
* addClassroom
    * sprawdza czy długość numeru klasy i faculty zgadza się z wymaganiami
    * jeżeli próba dodania tej samej klasy na tym samym wydziale, bd wywala błąd
    * przyjmuje
        ```
        {
            facultyId: int    # wzięte z listy wydziałów
            classNr: str,
        }
        ```
    * zwraca:
        * NOK
        ```
        {
            code: 500,
            message: "BD foult" # w tym problem że klasa na ty samym wydziale już istnieje
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        * OK
        ```
        {
            code: 200,
            message: ""
        }
        ```

### Dodanie kursu:
* getCourseTypes
    * zwraca:
        ```
        {
            code: 200,
            message: "",
            courses: [string]    # nazwy kursów
        }
        ```
* addCourse
    * przyjmuje:
        ```
        {
            type: str,
            name: str,    # nie obligatoryjne ale "" musi być
            code: str
            facultyId: int    # wzięte z listy wydziałów
        }
        ```
    * faculty_id powinno być wyjęte z listy zaciągniętej z getFaculties
    * type powinien być wyjęty z getCourseTypes
    * waliduje długość code, i długość name
    * type i faculty_id jak złe to  bd się wywala
    * zwraca:
        * NOK
            ```
            {
                code: 500,
                message: "BD foult"
            }
            ```
            ```
            {
                code: 400,
                message: "request problem"
            }
            ```
        * OK
            ```
            {
                code: 200,
                message: ""
            }
            ```
### Dodanie grupy:
* addGroup
    * dodaje grupę na postawie której można robić potem exchange
    * waliduje:
        * poprawność czasu i poprawność dnia, reszta jak zła to zwróci 500 bo BD constrints
    * przyjmuje:
        ```
        {
            timeStart: int,    #minuty od początku dnia
            timeEnd: int,      # -||-
            day: int, # (0-6)
            classroomId: int,  # wybierane z listy clas id z getClasses
            lecturerId: int,   # z listy getLecturers
            courseId: int,     # z listy getCourses
            groupNr: int       # podane przez użytkownika
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ```
* getClassrooms
    * zwraca liste klas
    * przyjmuje:
        ```
        {
            facultyId: int
        }
        ```
    * zwraca:
        ```
        {
            code: 200
            classrooms: [{id: int, nr: str}]    # numer to str bo np CS502
        }
        ```
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
* getLecturers
    * istnieje tylko jedna osoba o danym imieniu i nazwisku
    * przyjmuje:
        ```
        {
            token
        }
        ```
    * zwraca:
        ```
        {
            code: 200
            lecturers: [{title: str, name: str, surname: str, lecturerId: int}]
        }
        ```
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
* getCourses
    * zwraca wszystkie aktualnie wpisane kursy dla danego wydziału
    * przyjmuje:
        ```
        {
            facultyId: int
        }
        ```
    * zwraca:
        ```
        {
            code: 200
            courses: [{name: str, courseId: int}]
        }
        ```
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
* getGroups #TODO zmiana nazwy
    * zwraca grupy wpisane dotychczas do bazy danych dla konkretnego kursu
    * przyjmuje:
        ```
        {
            token
            courseId: int
        }
        ```
    * zwraca:
        ```
        {
            code: 200
            groups: [{groupId: int, groupNr: int, courseCode: str, facultyShortname: str}]
        }
        ```
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
    
## Zapytania związane z użytkownikami

### Dodanie użytkownika
* loginValid
    * sprawdza czy login poprawny
    * przyjmuje:
        ```
        {
            login: str,
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "costumowy message"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ``` 
* addUser
    * waliduje: nic
    * przyjmuje:
        ```
        {
            login: str,    
            password: str,      
            name: str,     # nie obowiązkowe, "" musi być
            surname: str,  # nie obowiązkowe, "" musi być
            email: str,    # nie obowiązkowe, "" musi być
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ```
* getUserInfo
    * przyjmuje:
        ```
        {
            token
            login: str
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            email: str,
            firstName: str,
            surname: str,
            message: ""
        }
* addEmail
    * przyjmuje:
        ```
        {
            login: str,
            email: str,
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ```
* addFirstname
    * przyjmuje:
        ```
        {
            login: str,
            firstName: str,
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ```
* addSurname
    * przyjmuje:
        ```
        {
            login: str,
            surname: str,
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ```
* addUserGroup
     * przyjmuje:
        ```
        {
            login: str,
            groupId: int, # wzięte z getGroups
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ```
* getUserGroups
    * przyjmuje:
        ```
        {
            login: str
        }
        ```
    * zwraca: #TODO godziny i dzień
        ```
        {
            code: 500,
            message: "BD foult"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200
            groups: [{groupId: int, groupNr: int, courseCode: str, facultyShortname: str}] 
        }
        ```
### Walidowanie użytkownika
* authenticateUser
    * sprawdza token danego usera i jak aktualny to go przedłuża
    * przymuje:
        ```
        {
            login: str,    
            password: str,
        }
        ```
    * zwraca:
        ```
        {
            code: 401,
            message: "incorrect password or login"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ```
### Zmiana hasła
* changePassword
    * zmienia hasło danego użytkownika
    * przymuje:
        ```
        {
            login: str,    
            old: str,    # stare haslo
            new: str     # nowe haslo
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "problem with db"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: ""
        }
        ```
## Zapytania związane z wymianami
### Wpidanie wymiany
* enterExchange
    * generalnie kiedy ktoś wybiera exchange w celu poprawnego działania powinien on wybrać grupę z grup danych przez getUserGroups, żeby user najpierw dodał swoją grupę a dopiero potem mógł ją wybrać do wymiany, aby była w tabeli 'user_groups'
    * przymuje:
        ```
        {
            login: str,    
            sellGroupId: int,    # wyjęte z zapytania getUserGroups
            buyGroupIds: [int]     # ustawione w priorytecie
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "problem with db"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200,
            message: "Exchange done" / "Exchange added, but not done"
        }
        ```
* getExchanges
    * wszystkie aktualne i spełnione wymiany użytkownika
    * zwraca
    * TODO
    ```
    {
        code: 200
        exchanges: [{ 
                    insertionDate: str,
                    sellGroup: {groupNr: int,
                                timeStart: int,    #minuty od początku dnia
                                timeEnd: int,
                                courseCode: str,
                                day: int}    # 0-6,
                    complete: bool
                    buyGroups: [{groupNr: int,
                                timeStart: int,    #minuty od początku dnia
                                timeEnd: int,
                                courseCode: str,
                                day: int}]    # 0-6
                  }]
    }
    ```
* getAllExchanges -- get all exchanges
    * wszystie wymiany na rynku
    * przymuje:
        ```
        {
            login: str,
            coursesIds = [int],
            jak nie ma kursów (inaczej ignoruje facultyID ale i tak musi być takie pole):
                facultyId = int
            all: bool #jak true to wszystkie jak false to dla użytkownika
        }
        ```
    * zwraca:
        ```
        {
            code: 500,
            message: "problem with db"
        }
        ```
        ```
        {
            code: 400,
            message: "request problem"
        }
        ```
        ```
        {
            code: 200
            exchanges: [{insertionDate: str,
                        sellGroup: {groupNr: int,
                                    timeStart: int,    #minuty od początku dnia
                                    timeEnd: int,
                                    courseCode: str,
                                    day: int}    # 0-6,
                        complete: bool
                        buyGroups: [{groupNr: int,
                                    timeStart: int,    #minuty od początku dnia
                                    timeEnd: int,
                                    courseCode: str,
                                    day: int}]    # 0-6
                      }]
        }
        ```

Do dodania:
- getAllExchanges
- 