C++ JsonArray::append方法代码示例

Status
loginServerKeyAdd(AuthJson authJson, JsonPtr keyBox, std::string syncKey)
{
    const auto url = ABC_SERVER_ROOT "/v2/login/keys";

    // Repos to create (optional):
    JsonArray newSyncKeys;
    if (syncKey.size())
        ABC_CHECK(newSyncKeys.append(json_string(syncKey.c_str())));

    // Key boxes to upload:
    JsonArray keyBoxes;
    ABC_CHECK(keyBoxes.append(keyBox));

    /// Assemble request:
    JsonObject requestJson;
    ABC_CHECK(requestJson.set("newSyncKeys", newSyncKeys));
    ABC_CHECK(requestJson.set("keyBoxes", keyBoxes));
    ABC_CHECK(authJson.set("data", requestJson));

    HttpReply reply;
    ABC_CHECK(AirbitzRequest().request(reply, url, "POST", authJson.encode()));
    ServerReplyJson replyJson;
    ABC_CHECK(replyJson.decode(reply));

    return Status();
}

Status
loginServerUploadLogs(Account *account)
{
    const auto url = ABC_SERVER_ROOT "/v1/account/debug";
    ServerRequestJson json;

    if (account)
    {
        json.setup(account->login); // Failure is fine

        JsonArray jsonArray;
        auto ids = account->wallets.list();
        for (const auto &id: ids)
        {
            std::shared_ptr<Wallet> wallet = cacheWalletSoft(id);
            if (wallet)
            {
                const auto name = wallet->name();
                logInfo("Wallet '" + name + "' " + id);

                const auto addresses = wallet->addresses.list();
                for (const auto &address: addresses)
                    logInfo(address);
            }

            DataChunk watchData;
            if (fileLoad(watchData, WalletPaths(id).cachePath()))
            {
                jsonArray.append(
                    json_string(base64Encode(watchData).c_str()));
            }
        }
        json.set("watchers", jsonArray); // Failure is fine

        AutoFree<tABC_AccountSettings, accountSettingsFree> settings;
        settings.get() = accountSettingsLoad(*account);
        std::string servers(settings->szOverrideBitcoinServerList);
        std::string strOverride = (settings->bOverrideBitcoinServers ? "true" :
                                   "false");

        logInfo("bOverrideBitcoinServers:" + strOverride);
        logInfo("szOverrideBitcoinServerList:" + servers);
    }

    DataChunk logData = debugLogLoad();
    json.set("log", base64Encode(logData)); // Failure is fine

    HttpReply reply;
    ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));

    return Status();
}

void
StratumConnection::getAddressHistory(
    const bc::client::obelisk_codec::error_handler &onError,
    const bc::client::obelisk_codec::fetch_history_handler &onReply,
    const bc::payment_address &address, size_t fromHeight)
{
    JsonArray params;
    params.append(json_string(address.encoded().c_str()));

    auto errorShim = [onError](Status status)
    {
        onError(std::make_error_code(std::errc::bad_message));
    };

    auto decoder = [onReply](JsonPtr payload) -> Status
    {
        JsonArray arrayJson(payload);

        bc::client::history_list history;
        size_t size = arrayJson.size();
        history.reserve(size);
        for (size_t i = 0; i < size; i++)
        {
            struct HistoryJson:
                public JsonObject
            {
                ABC_JSON_CONSTRUCTORS(HistoryJson, JsonObject)
                ABC_JSON_STRING(txid, "tx_hash", nullptr)
                ABC_JSON_INTEGER(height, "height", 0)
            };
            HistoryJson json(arrayJson[i]);

            bc::hash_digest hash;
            if (!json.txidOk() || !bc::decode_hash(hash, json.txid()))
                return ABC_ERROR(ABC_CC_Error, "Bad txid");

            bc::client::history_row row;
            row.output.hash = hash;
            row.output_height = json.height();
            row.spend.hash = bc::null_hash;
            history.push_back(row);
        }

        onReply(history);
        return Status();
    };

Status
loginServerMessages(JsonPtr &result, const std::list<std::string> &usernames)
{
    const auto url = ABC_SERVER_ROOT "/v2/messages";

    // Compute all userIds:
    JsonArray loginIds;
    std::map<std::string, std::string> loginIdMap;
    for (const auto &username: usernames)
    {
        std::shared_ptr<LoginStore> store;
        ABC_CHECK(LoginStore::create(store, username));
        const auto loginId = base64Encode(store->userId());
        loginIds.append(json_string(loginId.c_str()));
        loginIdMap[loginId] = username;
    }

    JsonObject request;
    ABC_CHECK(request.set("loginIds", loginIds));

    // Make the request:
    HttpReply reply;
    ABC_CHECK(AirbitzRequest().request(reply, url, "POST", request.encode()));
    ServerReplyJson replyJson;
    ABC_CHECK(replyJson.decode(reply));

    // Insert the original usernames into the results:
    JsonArray arrayJson(replyJson.results());
    size_t size = arrayJson.size();
    for (size_t i = 0; i < size; i++)
    {
        JsonObject objectJson(arrayJson[i]);
        const auto loginId = objectJson.getString("loginId", nullptr);
        if (!loginId) continue;
        const auto username = loginIdMap.find(loginId);
        if (username == loginIdMap.end()) continue;
        ABC_CHECK(objectJson.set("username", username->second));
    }

    result = arrayJson;
    return Status();
}

void
StratumConnection::getTx(
    const bc::client::obelisk_codec::error_handler &onError,
    const bc::client::obelisk_codec::fetch_transaction_handler &onReply,
    const bc::hash_digest &txid)
{
    JsonArray params;
    params.append(json_string(bc::encode_hash(txid).c_str()));

    auto errorShim = [onError](Status status)
    {
        onError(std::make_error_code(std::errc::bad_message));
    };

    auto decoder = [onReply](JsonPtr payload) -> Status
    {
        if (!json_is_string(payload.get()))
            return ABC_ERROR(ABC_CC_JSONError, "Bad reply format");

        bc::data_chunk rawTx;
        if (!base16Decode(rawTx, json_string_value(payload.get())))
            return ABC_ERROR(ABC_CC_ParseError, "Bad transaction format");

        // Convert rawTx to bc::transaction_type:
        bc::transaction_type tx;
        try
        {
            auto deserial = bc::make_deserializer(rawTx.begin(), rawTx.end());
            bc::satoshi_load(deserial.iterator(), deserial.end(), tx);
        }
        catch (bc::end_of_stream)
        {
            return ABC_ERROR(ABC_CC_ParseError, "Bad transaction format");
        }

        onReply(tx);
        return Status();
    };

    sendMessage("blockchain.transaction.get", params, errorShim, decoder);
}

Status
loginServerUploadLogs(const Account *account)
{
    const auto url = ABC_SERVER_ROOT "/account/debug";
    JsonPtr json;
    HttpReply reply;
    DataChunk logData = debugLogLoad();

    if (account)
    {
        JsonArray jsonArray;
        auto ids = account->wallets.list();
        for (const auto &id: ids)
        {
            std::shared_ptr<Wallet> wallet;
            if (cacheWallet(wallet, nullptr, id.c_str()))
            {
                DataChunk watchData;
                ABC_CHECK(fileLoad(watchData, watcherPath(*wallet)));
                jsonArray.append(
                    json_string(base64Encode(watchData).c_str()));
            }
        }

        json.reset(json_pack("{ss, ss, ss}",
                             ABC_SERVER_JSON_L1_FIELD, base64Encode(account->login.lobby.authId()).c_str(),
                             ABC_SERVER_JSON_LP1_FIELD, base64Encode(account->login.authKey()).c_str(),
                             "log", base64Encode(logData).c_str()));
        if (jsonArray)
            json_object_set(json.get(), "watchers", jsonArray.get());
    }
    else
    {
        json.reset(json_pack("{ss}", "log", base64Encode(logData).c_str()));
    }

    ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
    return Status();
}