C++ createRequest函数代码示例

void Session::Request::fetchAccountCharacters(const QString &accountName,
                                      QVariant data) {
    QUrlQuery query;
    query.addQueryItem("accountName", accountName);
    QUrl url = CharactersUrl();
    url.setQuery(query);

    QNetworkRequest request = createRequest(url);
    setAttribute(&request, UserData, data);
    QNetworkReply *r = _manager->get(request);

    connect(r, &QNetworkReply::finished, this, &Session::Request::Request::onAccountCharactersResult);
}

void XMLHttpRequest::sendBytesData(const void* data, size_t length, ExceptionCode& ec)
{
    if (!initSend(ec))
        return;

    if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
        m_requestEntityBody = FormData::create(data, length);
        if (m_upload)
            m_requestEntityBody->setAlwaysStream(true);
    }

    createRequest(ec);
}

void XMLHttpRequest::sendBytesData(const void* data, size_t length, ExceptionState& exceptionState)
{
    if (!initSend(exceptionState))
        return;

    if (areMethodAndURLValidForSend()) {
        m_requestEntityBody = FormData::create(data, length);
        if (m_upload)
            m_requestEntityBody->setAlwaysStream(true);
    }

    createRequest(exceptionState);
}

void SdtpCatalogDataProvider::search( QString query, XFolderList selectedFolders )
{
    QString idString;
    for ( XFolderList::const_iterator it = selectedFolders.constBegin();
          it != selectedFolders.constEnd(); ++it ) {
        idString += QString("%1,").arg((*it)->id());
    }
    idString.chop(1);

    QUrl url( QString(SDTP_URL_SEARCH).arg(query).arg(idString) );

    createRequest(url, Search, NULL);
}

void XMLHttpRequest::send(ArrayBuffer* body, ExceptionCode& ec)
{
    if (!initSend(ec))
        return;

    if (m_method != "GET" && m_method != "HEAD" && m_url.protocolInHTTPFamily()) {
        m_requestEntityBody = FormData::create(body->data(), body->byteLength());
        if (m_upload)
            m_requestEntityBody->setAlwaysStream(true);
    }

    createRequest(ec);
}

ExceptionOr<void> XMLHttpRequest::sendBytesData(const void* data, size_t length)
{
    if (auto result = prepareToSend())
        return WTFMove(result.value());

    if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
        m_requestEntityBody = FormData::create(data, length);
        if (m_upload)
            m_requestEntityBody->setAlwaysStream(true);
    }

    return createRequest();
}

void Session::Request::loginWithOAuth(const QString &authorizationCode) {
    QUrl url("https://webdev2.office.grindinggear.com/oauth/token");
    QUrlQuery query;
    query.addQueryItem("client_id", "test");
    query.addQueryItem("client_secret", "testpassword");
    query.addQueryItem("code", authorizationCode);
    query.addQueryItem("grant_type", "authorization_code");
    QNetworkRequest request = createRequest(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");

    QNetworkReply *r = _manager->post(request, query.toString().toUtf8());
    connect(r, &QNetworkReply::finished, this, &Session::Request::Request::onOAuthResultPath);
}

PublishOutput AmazonSNSClient::publish(PublishInput publishInput, ActionError& actionError) {
    actionError = NONE_ACTIONERROR;

    PublishOutput publishOutput;
	
    if (!publishInput.requiredAreSet()) {
        actionError = MISSING_REQUIRED_ARGS_ACTIONERROR;
	return publishOutput;
    }
	
    contentType = FORM_TYPE;
    MinimalString payload = publishInput.serialize();
	
    char* request = createRequest(payload);
    char* response = sendData(request);
    delete[] request;
    
    if (response == NULL) {
        actionError = CONNECTION_ACTIONERROR;
        return publishOutput;
    }

    int httpStatusCode = findHttpStatusCode(response);
	
    if (httpStatusCode == 200) {
        char* msgidIdx = strstr(response, "<MessageId>");
        int msgidPos = msgidIdx - response;

        char* msgid = new char[MESSAGEID_BUFFER_LENGTH]();
        strncpy(msgid, response + msgidPos + 11, MESSAGEID_BUFFER_LENGTH - 1);
        msgid[37] = '\0';
		
        publishOutput.setMessageId(msgid);
        return publishOutput;
    }
    
    if (httpStatusCode == 403) {
        char* ts = strstr(response, "earlier than ");
        int pos = ts - response;
    	
        char* newts = new char[EXTRACTED_TIMESTAMP_BUFFER_LENGTH]();
        strncpy(newts, response + pos + 31, EXTRACTED_TIMESTAMP_BUFFER_LENGTH - 1);
        newts[16] = '\0';
    	
        char* time = new char[FORMATTED_TIMESTAMP_BUFFER_LENGTH]();
        sprintf(time, "%.8s%.6s", newts, newts + 9);
        dateTimeProvider->sync(time);
    }
    
    return publishOutput;
}

void AssetResourceRequest::doSend() {
    // Make request to atp
    auto assetClient = DependencyManager::get<AssetClient>();
    auto parts = _url.path().split(".", QString::SkipEmptyParts);
    auto hash = parts[0];
    auto extension = parts.length() > 1 ? parts[1] : "";

    if (hash.length() != SHA256_HASH_HEX_LENGTH) {
        _result = InvalidURL;
        _state = Finished;

        emit finished();

        return;
    }

    auto request = assetClient->createRequest(hash, extension);

    if (!request) {
        _result = ServerUnavailable;
        _state = Finished;

        emit finished();

        return;
    }

    connect(request, &AssetRequest::progress, this, &AssetResourceRequest::progress);
    QObject::connect(request, &AssetRequest::finished, [this](AssetRequest* req) mutable {
        Q_ASSERT(_state == InProgress);
        Q_ASSERT(req->getState() == AssetRequest::FINISHED);
        
        switch (req->getError()) {
            case NoError:
                _data = req->getData();
                _result = Success;
                break;
            case AssetNotFound:
                _result = NotFound;
                break;
            default:
                _result = Error;
                break;
        }
        
        _state = Finished;
        emit finished();
    });

    request->start();
}

/*  
    function accept(): Request
 */
static EjsRequest *hs_accept(Ejs *ejs, EjsHttpServer *sp, int argc, EjsObj **argv)
{
    HttpConn    *conn;
    MprEvent    event;

    memset(&event, 0, sizeof(MprEvent));
    event.dispatcher = sp->endpoint->dispatcher;
    if ((conn = httpAcceptConn(sp->endpoint, &event)) == 0) {
        /* Just ignore */
        mprError("Cannot accept connection");
        return 0;
    }
    return createRequest(sp, conn);
}

void updateTagDBVersion(uint newDBVersion)
{
	if(cache == NULL && immatureCache == NULL)
		return;
	
	sqlite3_stmt * request = createRequest(cache != NULL ? cache : immatureCache, "INSERT OR REPLACE INTO "TABLE_TAG_VERSION" (`"VERSION_COLUMN_NAME"`) VALUES(?1);");

	if(request == NULL)
		return;
	
	sqlite3_bind_int(request, 1, (int32_t) newDBVersion);
	sqlite3_step(request);
	destroyRequest(request);
}

    int start() {
        // ALOGD("Start debug command");
        WifiRequest request(familyId(), ifaceId());
        int result = createRequest(request);
        if (result != WIFI_SUCCESS) {
            ALOGE("Failed to create debug request; result = %d", result);
            return result;
        }

        result = requestResponse(request);
        if (result != WIFI_SUCCESS) {
            ALOGE("Failed to register debug response; result = %d", result);
        }
        return result;
    }

int main(void)
{
    UnityBegin("DLService.Thingspeak.cpp");

	createRequest();

    RUN_TEST(test_BulkUploadRequestHasCorrectNumberOfLines);
    
 	for (s_testLine = 0; s_testLine < requestStrings.size(); ++s_testLine)
 	{

 		RUN_TEST(test_BulkUploadRequestLineIsCorrect);
 	}

    return 0;
}

void XMLHttpRequest::send(DOMFormData* body, ExceptionCode& ec)
{
    if (!initSend(ec))
        return;

    if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
        m_requestEntityBody = FormData::createMultiPart(*(static_cast<FormDataList*>(body)), body->encoding(), document());

        m_requestEntityBody->generateFiles(document());

        if (!m_requestHeaders.contains(HTTPHeaderName::ContentType))
            m_requestHeaders.set(HTTPHeaderName::ContentType, makeString("multipart/form-data; boundary=", m_requestEntityBody->boundary().data()));
    }

    createRequest(ec);
}

void Session::Request::fetchAccountStashTabs(const QString &accountName, const QString &league, int tabIndex,
                                     bool tabs, QVariant data) {
    QUrlQuery query;
    query.addQueryItem("accountName", accountName);
    query.addQueryItem("league", league);
    query.addQueryItem("tabIndex", QString::number(tabIndex));
    query.addQueryItem("tabs", tabs ? "1" : "0");
    QUrl url = StashUrl();
    url.setQuery(query);

    QNetworkRequest request = createRequest(url);
    setAttribute(&request, UserData, data);
    setAttribute(&request, League, league);
    QNetworkReply *r = _manager->get(request);

    connect(r, &QNetworkReply::finished, this, &Session::Request::Request::onAccountStashTabsResult);
}