srab/исх/властелины/пользователи/учителя/учителя.tri

модуль учителя

импорт "стд::вывод"
импорт "исх/строка"
импорт "исх/спринтф"
импорт "исх/массивы"
импорт "исх/сеть/хттп"
импорт "исх/форматы/джесон"
импорт "исх/сеть/хттп/маршрутизатор"
импорт "исх/картотека"
импорт "исх/картотека/репозитории"
импорт "исх/бюрократия"

фн создать*(путь: Строка, параметры: массивы.Строки, обращение: маршрутизатор.Обращение): хттп.ХттпОтвет {
    пусть картотека = картотека.зайти()
    пусть оплошность := ""
    пусть данные = джесон.парсить(обращение.туловище, оплошность)

    если оплошность # "" {
        вернуть хттп.ответ_500()
    }

    пусть имя := данные.получить("имя").строка()
    пусть фамилия := данные.получить("фамилия").строка()
    пусть отчество := данные.получить("отчество").строка()
    пусть образование := данные.получить("образование").строка()
    пусть пароль := данные.получить("пароль").строка()
    пусть повтор пароля := данные.получить("повтор пароля").строка()
    пусть аватар = данные.получить("аватар").строка()
    пусть аватар урл := ""

    если имя = пусто | фамилия = пусто | отчество = пусто | образование = пусто | пароль = пусто | повтор пароля = пусто {
        вернуть хттп.ответ_400()
    }

    если имя^ = "" | фамилия^ = "" | отчество^ = "" | образование^ = "" | пароль^ = "" | повтор пароля^ = "" {
        вернуть хттп.ответ_400()
    }

    если пароль^ # повтор пароля^ {
        вернуть хттп.создать ответ(
            хттп.ответ_400(),
            хттп.ХттпОтвет{
                туловище: "Пароли не совпадают.",
            }
        )
    }

    пусть имя пользователя = спринтф.ф("$стр.$стр", имя^, фамилия^)

    пусть ответ = картотека.запросить безопасно(`
    INSERT INTO users (first_name, last_name, middle_name, username, password)
    VALUES (?, ?, ?, ?, ?)
    RETURNING id
    `, оплошность, имя^, фамилия^, отчество^, имя пользователя, пароль^)

    если оплошность # "" {
        вернуть хттп.ответ_500()
    }

    пусть айди пользователя = ответ.значения[0](:джесон.ДжесонОбъект).получить("id").число()

    если айди пользователя = пусто {
        авария("неверный ответ от базы данных")
    }

    если аватар # пусто & аватар^ # "" {
        пусть урл = хттп.парсить урл(аватар^, оплошность)

        если оплошность = "" {
            пусть ответ = хттп.послать на три буквы(урл.хост, урл.порт, урл.путь)
            пусть размер контента := 0

            цикл [номер]заглавие среди ответ.заглавия {
                если заглавие.имя = "Content-Length" {
                    пусть № байта := 0
                    строка.извлечь цел(заглавие.значение, № байта, размер контента)
                    прервать
                }
            }

            если размер контента > 0 & размер контента < 1000000 {
                аватар урл := аватар^
            }
        }
    }

    пусть учитель = картотека.запросить безопасно(`
    INSERT INTO teachers (user_id, education, avatar_url)
    VALUES (?, ?, ?)
    RETURNING id
    `, оплошность, айди пользователя^.значение, образование^, аватар урл)

    если оплошность # "" {
        вернуть хттп.ответ_500()
    }

    если длина(учитель.значения) = 0 {
        вернуть хттп.ответ_500()
    }

    пусть созданный учитель = учитель.значения[0](:джесон.ДжесонОбъект)
    пусть идентификатор учителя = созданный учитель.получить("id").число()

    если идентификатор учителя = пусто {
        вернуть хттп.ответ_500()
    }

    пусть тело = джесон.сериализовать(джесон.ДжесонОбъект{
        значения: джесон.ДжесонКлючЗначения[
            джесон.ДжесонКлючЗначение{ ключ: "идентификатор", значение: джесон.ДжесонЧисло{ значение: идентификатор учителя^.значение } },
            джесон.ДжесонКлючЗначение{ ключ: "образование", значение: джесон.ДжесонСтрока{ значение: образование^ } },
            джесон.ДжесонКлючЗначение{ ключ: "имя", значение: джесон.ДжесонСтрока{ значение: имя^ } },
            джесон.ДжесонКлючЗначение{ ключ: "фамилия", значение: джесон.ДжесонСтрока{ значение: фамилия^ } },
            джесон.ДжесонКлючЗначение{ ключ: "отчество", значение: джесон.ДжесонСтрока{ значение: отчество^ } },
            джесон.ДжесонКлючЗначение{ ключ: "имя пользователя", значение: джесон.ДжесонСтрока{ значение: имя пользователя } }
        ]
    })

    вернуть хттп.создать ответ(
        хттп.ответ_201(),
        хттп.ХттпОтвет{ туловище: тело }
    )
}

фн список*(путь: Строка, параметры: массивы.Строки, обращение: маршрутизатор.Обращение): хттп.ХттпОтвет {
    пусть оплошность := ""
    пусть картотека = картотека.зайти()

    пусть пользователь = репозитории.авторизовать по паспорту(бюрократия.получить данные паспорта(обращение), оплошность)

    если оплошность # "" {
        вернуть хттп.ответ_500()
    }

    если пользователь = пусто {
        вернуть хттп.ответ_401()
    }

    пусть админ = репозитории.пользователь админ(пользователь^.идентификатор, оплошность)

    если оплошность # "" {
        вернуть хттп.ответ_500()
    }

    если ~админ {
        вернуть хттп.ответ_403()
    }

    пусть размер страницы := 20
    пусть номер страницы := 1

    пусть параметр страница = обращение.запрос-в-пути.найти("страница")
    если параметр страница # пусто {
        пусть номер байта := 0
        строка.извлечь цел(параметр страница^.значение, номер байта, номер страницы)
    }

    если номер страницы < 1 {
        вернуть хттп.ответ_400()
    }

    пусть смещение := (номер страницы - 1) * размер страницы

    пусть учителя = картотека.запросить безопасно(`
    SELECT t.id, t.user_id, t.education, t.avatar_url,
           u.first_name, u.last_name, u.middle_name, u.username
    FROM teachers t
    JOIN users u ON u.id = t.user_id
    ORDER BY t.id
    LIMIT ? OFFSET ?
    `, оплошность, размер страницы, смещение)

    если оплошность # "" {
        вернуть хттп.ответ_500()
    }

    пусть джесон учителя = джесон.ДжесонМногоЗначений{}

    цикл [номер]запись среди учителя.значения {
        пусть объект = запись(:джесон.ДжесонОбъект)

        пусть идентификатор = объект.получить("id").число()
        пусть образование = объект.получить("education").строка()
        пусть имя = объект.получить("first_name").строка()
        пусть фамилия = объект.получить("last_name").строка()
        пусть отчество = объект.получить("middle_name").строка()
        пусть имя пользователя = объект.получить("username").строка()

        пусть учитель = джесон.ДжесонОбъект{}
        если идентификатор # пусто { учитель.вставить("идентификатор", джесон.ДжесонЧисло{ значение: идентификатор^.значение }) }
        если образование # пусто { учитель.вставить("образование", джесон.ДжесонСтрока{ значение: образование^ }) }
        если имя # пусто { учитель.вставить("имя", джесон.ДжесонСтрока{ значение: имя^ }) }
        если фамилия # пусто { учитель.вставить("фамилия", джесон.ДжесонСтрока{ значение: фамилия^ }) }
        если отчество # пусто { учитель.вставить("отчество", джесон.ДжесонСтрока{ значение: отчество^ }) }
        если имя пользователя # пусто { учитель.вставить("имя пользователя", джесон.ДжесонСтрока{ значение: имя пользователя^ }) }

        джесон учителя.значения.добавить(учитель)
    }

    пусть туловище = джесон.сериализовать(джесон.ДжесонОбъект{
        значения: джесон.ДжесонКлючЗначения[
            джесон.ДжесонКлючЗначение{ ключ: "учителя", значение: джесон учителя }
        ]
    })

    вернуть хттп.ХттпОтвет{ туловище: туловище }
}

фн добавить маршруты*(маршрутизатор: маршрутизатор.Маршрутизатор): маршрутизатор.Маршрутизатор {
    маршрутизатор.добавить маршрут("/api/users", массивы.Строки["POST"], создать)
    маршрутизатор.добавить маршрут("/api/teachers", массивы.Строки["GET"], список)

    вернуть маршрутизатор
}