HttpImportResource.h

Go to the documentation of this file.

 
#pragma once
 
#include "../Database.h"
#include <Network/Http/HttpResource.h>
 
namespace ConfigDB
{
class HttpImportResource : public HttpResource
{
public:
    using OnRequest = Delegate<std::unique_ptr<ImportStream>(HttpRequest& request, MimeType mimeType)>;
 
    using OnComplete = Delegate<void(HttpRequest& request, HttpResponse& response, ImportStream& stream)>;
 
    HttpImportResource(OnRequest onRequest, OnComplete onComplete) : onRequest(onRequest), onComplete(onComplete)
    {
        init();
    }
 
    HttpImportResource(Database& database, const Format& format)
    {
        init();
 
        onRequest = [&database, &format](HttpRequest&, MimeType mimeType) -> std::unique_ptr<ImportStream> {
            debug_i("POST REQ");
            if(mimeType != format.getMimeType()) {
                return nullptr;
            }
            return database.createImportStream(format);
        };
 
        onComplete = [](HttpRequest&, HttpResponse& response, ImportStream& stream) -> void {
            String msg;
            msg += F("Result: ");
            auto status = stream.getStatus();
            msg += toString(status);
            response.sendString(msg);
            debug_i("%s", msg.c_str());
            switch(status.error) {
            case Error::OK:
                break;
            case Error::FormatError:
                response.code = HTTP_STATUS_BAD_REQUEST;
                break;
            case Error::UpdateConflict:
                response.code = HTTP_STATUS_CONFLICT;
                break;
            case Error::FileError:
                response.code = HTTP_STATUS_INTERNAL_SERVER_ERROR;
                break;
            }
        };
    }
 
private:
    void init()
    {
        onHeadersComplete = [this](HttpServerConnection&, HttpRequest& request, HttpResponse& response) -> int {
            if(request.args) {
                response.code = HTTP_STATUS_INTERNAL_SERVER_ERROR;
                return 0;
            }
 
            if(request.method != HTTP_POST) {
                response.code = HTTP_STATUS_BAD_REQUEST;
                return 0;
            }
 
            String contentType = request.headers[HTTP_HEADER_CONTENT_TYPE];
            auto stream = this->onRequest(request, ContentType::fromString(contentType));
            if(!stream) {
                response.code = HTTP_STATUS_BAD_REQUEST;
                return 0;
            }
 
            request.args = stream.release();
            return 0;
        };
 
        onBody = [](HttpServerConnection&, HttpRequest& request, const char* at, int length) -> int {
            auto stream = static_cast<ImportStream*>(request.args);
            if(!stream) {
                return 0;
            }
            return stream->write(at, length) == size_t(length) ? 0 : 1;
        };
 
        onRequestComplete = [this](HttpServerConnection&, HttpRequest& request, HttpResponse& response) -> int {
            auto stream = static_cast<ImportStream*>(request.args);
            if(stream) {
                this->onComplete(request, response, *stream);
                delete stream;
                request.args = nullptr;
            }
            return 0;
        };
    }
 
    OnRequest onRequest;
    OnComplete onComplete;
};
 
} // namespace ConfigDB