Dokumentace třídy Httpd::RequestMapper

Zpracovává HTTP požadavky, vyřizuje speciální požadavky. ...

#include <requestmapper.h>

Diagram dědičnosti pro třídu Httpd::RequestMapper:

Veřejné metody
	RequestMapper (HobrasoftHttpd::HttpConnection *parent)
	Konstruktor.
void	service (HobrasoftHttpd::HttpRequest *request, HobrasoftHttpd::HttpResponse *response)
	Vyřizuje jeden požadavek.

Privátní metody
void	serviceShtmlFile (HobrasoftHttpd::HttpRequest *request, HobrasoftHttpd::HttpResponse *response)
QByteArray	readFile (const QString &path, HobrasoftHttpd::HttpResponse *response)

Privátní atributy
QString	m_path
	Obsluhovaná cesta (URL adresa).
RequestAuthorizer *	m_authorizer

Detailní popis

Zpracovává HTTP požadavky, vyřizuje speciální požadavky.

Statické soubory a shtml stačí zpracovávat defaultním handlerem HobrasoftHttpd::HttpRequestHandler, ale požadavky dotazující vnitřní stav aplikace musejí být naprogramované v C++

Definice je uvedena na řádku 32 v souboru requestmapper.h.

Dokumentace konstruktoru a destruktoru

~RequestMapper()

RequestMapper::~RequestMapper

(

)

Definice je uvedena na řádku 75 v souboru requestmapper.cpp.

                              {
}

RequestMapper()

RequestMapper::RequestMapper

(

HobrasoftHttpd::HttpConnection *

parent

)

Konstruktor.

Definice je uvedena na řádku 79 v souboru requestmapper.cpp.

                                                                 : HobrasoftHttpd::HttpRequestHandler(parent) {
    // PDEBUG << parent->thread() << this->thread();
    m_authorizer = new RequestAuthorizer(parent);
}

Dokumentace členských funkcí

readFile()

QByteArray RequestMapper::readFile ( const QString & path, HobrasoftHttpd::HttpResponse * response )

private

Definice je uvedena na řádku 191 v souboru requestmapper.cpp.

                                                                              {
    QByteArray data;
    if (path.startsWith("/..") || path.startsWith("..")) {
        response->setStatus(403,"Forbidden");
        response->write(QString("403 Forbidden: %1<br>\nDo not use ../ in your file path").arg(path).toUtf8());
        response->flush();
        throw false;
        }
 
    QFile file(connection()->settings()->docroot()+"/"+path);
    if (!file.exists()) {
        response->setStatus(404, "Not found");
        response->write(QString("404 File not found: %1").arg(file.fileName()).toUtf8());
        response->flush();
        throw false;
        }
 
    if (!file.open(QIODevice::ReadOnly)) {
        response->setStatus(403, "Forbidden");
        response->write(QString("403 Forbidden: %1").arg(file.fileName()).toUtf8());
        response->flush();
        throw false;
        }
 
    QString rolename = Security::Roles::toString(m_authorizer->role());
 
    while (!file.atEnd()) {
        QString line = QString::fromUtf8(file.readLine());
        line = line.replace("${ROLE}", rolename);
        // if (line.contains(QRegExp("^\\s*<!--\\s*#include\\s+\".+\"\\s*-->\\s*$"))) {
        if (line.contains(QRegExp(R"X(^\s*<!--\s*#include\s+['"].+['"]\s*-->\s*$)X"))) {
            QStringList lineparts = line.split(QRegExp(R"X(['"])X"));
            if (lineparts.size() != 3) {
                continue;
                }
            data += readFile(lineparts[1], response);
            continue;
            }
        data += line.toUtf8();
        }
 
    file.close();
    return data;
}

service()

void RequestMapper::service	(	HobrasoftHttpd::HttpRequest *	request,
		HobrasoftHttpd::HttpResponse *	response )

Vyřizuje jeden požadavek.

Rozděluje podle typu požadavku do specializovaných handlerů

Po přihlášení zpracovává ostatní speciální požadavky (event streamy).

Definice je uvedena na řádku 85 v souboru requestmapper.cpp.

                                                                        {
    m_path = request->path();
    PDEBUG << request->method() << request->fullPath();
 
    #define ROUTER(adresa, trida) {                                     \
        if (m_path.contains(QRegularExpression(adresa))) {              \
            AbstractController *controller = new trida (connection());  \
            controller->setAuthorizer(m_authorizer);                    \
            controller->service(request, response);                     \
            return;                                                     \
            }                                                           \
        }
 
    if (m_path.contains(QRegExp("^/public/.*\\.shtml"))) {
        serviceShtmlFile(request, response);
        response->flush();
        return;
        }
 
    if (m_path.startsWith("/index.html") || m_path == "/") {
        StaticFileController(connection()).service(request, response);
        response->flush();
        return;
        }
 
    if (m_path.startsWith("/public/")) {
        StaticFileController(connection()).service(request, response);
        response->flush();
        return;
        }
 
 
    // Možné bez přihlášení
    ROUTER("^/api/v1/overview/0x",       ControllerOverviewPublic);
    ROUTER("^/api/v1/server/about",      ControllerServer);
 
    // Kontrola přihlášení
    if (!m_authorizer->isLoggedIn(request, response)) {
        return;
        }

    ROUTER("^/api/v1/doors/(\\d+)/employees(?:/(\\d+))?/?", ControllerDoorEmployees);
    ROUTER("^/api/v1/departments/(\\d+)/employees(?:/(\\d+))?/?", ControllerDepartmentEmployees);
    ROUTER("^/api/v1/departments/(\\d+)/managers(?:/(\\d+))?/?", ControllerDepartmentHasManager);
    ROUTER("^/api/v1/rfids/(\\d+)/employees(?:/(\\d+))?/?", ControllerRfidEmployees);
    ROUTER("^/api/v1/categoriessiblings",               ControllerCategoriesSiblings);
    ROUTER("^/api/v1/tickettimesheets",                 ControllerTicketTimesheets);
    ROUTER("^/api/v1/categoriestoroot",                 ControllerCategoriesToRoot);
    ROUTER("^/api/v1/statustemplates",                  ControllerStatusTemplates);
    ROUTER("^/api/v1/userscategories",                  ControllerUsersCategories);
    ROUTER("^/api/v1/categoriestree",                   ControllerCategoriesTree);
    ROUTER("^/api/v1/ticketvalues",                     ControllerTicketValues);
    ROUTER("^/api/v1/ticketstatus",                     ControllerTicketStatus);
    ROUTER("^/api/v1/ticketfiles",                      ControllerTicketFiles);
    ROUTER("^/api/v1/departments",                      ControllerDepartments);
    ROUTER("^/api/v1/statusorder",                      ControllerStatusOrder);
    ROUTER("^/api/v1/categories",                       ControllerCategories);
    ROUTER("^/api/v1/eventtypes",                       ControllerEventTypes);
    ROUTER("^/api/v1/ticketsvw",                        ControllerTicketsVw);
    ROUTER("^/api/v1/timesheet",                        ControllerTimesheet);
    ROUTER("^/api/v1/employees",                        ControllerEmployees);
    ROUTER("^/api/v1/overview",                         ControllerOverview);
    ROUTER("^/api/v1/statuses",                         ControllerStatuses);
    ROUTER("^/api/v1/tickets",                          ControllerTickets);
    ROUTER("^/api/v1/server",                           ControllerServer);
    ROUTER("^/api/v1/events",                           ControllerEvents);
    ROUTER("^/api/v1/users",                            ControllerUsers);
    ROUTER("^/api/v1/doors",                            ControllerDoors);
    ROUTER("^/api/v1/rfids",                            ControllerRfids);
    ROUTER("^/api/v1/holidays/copy/(\\d+)/(\\d+)$",     ControllerHolidays);
    ROUTER("^/api/v1/holidays",                         ControllerHolidays);
    ROUTER("^/api/v1/workcalendar/generate/(\\d+)$",    ControllerWorkCalendar);
    ROUTER("^/api/v1/workcalendar",                     ControllerWorkCalendar);
    ROUTER("^/api/v1/attendancechecklist",              ControllerAttendanceChecklist);
    ROUTER("^/api/v1/attendancepresent",                ControllerAttendancePresent);
    ROUTER("^/api/v1/attendancerecent",                 ControllerAttendanceRecent);
    ROUTER("^/api/v1/attendancesummary",                ControllerAttendanceSummary);
 
    if (m_path.contains(QRegularExpression(".*\\.shtml"))) {
        serviceShtmlFile(request, response);
        response->flush();
        return;
        }
 
    StaticFileController(connection()).service(request, response);
}

serviceShtmlFile()

void RequestMapper::serviceShtmlFile ( HobrasoftHttpd::HttpRequest * request, HobrasoftHttpd::HttpResponse * response )

private

Definice je uvedena na řádku 176 v souboru requestmapper.cpp.

                                                                                 {
    Q_UNUSED(request);
    QByteArray data;
    try {
        data = readFile(m_path, response);
        }
    catch (...) {
        return;
        }
    response->setHeader("Content-Type", "text/html; charset=" + connection()->settings()->encoding());
    response->write(data);
    response->flush();
}

Dokumentace datových členů

m_authorizer

RequestAuthorizer* Httpd::RequestMapper::m_authorizer

private

Definice je uvedena na řádku 53 v souboru requestmapper.h.

m_path

QString Httpd::RequestMapper::m_path

private

Obsluhovaná cesta (URL adresa).

Definice je uvedena na řádku 51 v souboru requestmapper.h.

---

Dokumentace pro tuto třídu byla vygenerována z následujících souborů:

• httpd/requestmapper.h
• httpd/requestmapper.cpp