示例#1
0
void Impl::ParseResponse( Response * response )
{
    // This function uses return defines for readability and maintainability.
#   define return_error(error_type, error_message)                             \
    {                                                                          \
        SetError(response, error_type, error_message);                         \
        return;                                                                \
    }
    response->one_time_download_request_count = 0;
    response->direct_download_free_bandwidth = 0;

    // create_content_struct_parse TArray
    try {
        const boost::property_tree::wptree & branch =
            response->pt.get_child(L"response.links");
        response->links.reserve( response->pt.size() );

        for ( auto & it : branch )
        {
            Response::Links optarg;
            if ( LinksFromPropertyBranch(
                    response, &optarg, it.second) )
                response->links.push_back(std::move(optarg));
            else
                return;  // error set already
        }
    }
    catch(boost::property_tree::ptree_bad_path & err)
    {
        // JSON response still has element if no files were returned.
        // This is really an error.
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.links\"");
    }

    // create_content_parse_single optional with default
    GetIfExists(
            response->pt,
            "response.one_time_download_request_count",
            &response->one_time_download_request_count);

    // create_content_parse_single optional with default
    GetIfExists(
            response->pt,
            "response.direct_download_free_bandwidth",
            &response->direct_download_free_bandwidth);

#   undef return_error
}
示例#2
0
void Impl::ParseResponse( Response * response )
{
    // This function uses return defines for readability and maintainability.
#   define return_error(error_type, error_message)                             \
    {                                                                          \
        SetError(response, error_type, error_message);                         \
        return;                                                                \
    }

    ResponseData response_data;

    // For uniformity for code generation with the other content parsers.
    ResponseData * response_data_ptr = &response_data;
    response_data_ptr->description = "";
    response_data_ptr->mimetype = "";

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.created",
            &response_data_ptr->created_datetime ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.created\"");

    // create_content_parse_single optional with default
    GetIfExists(
            response->pt,
            "response.fileinfo.description",
            &response_data_ptr->description);

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.device_revision",
            &response_data_ptr->device_revision ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.device_revision\"");

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.downloads",
            &response_data_ptr->downloads ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.downloads\"");

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.hash",
            &response_data_ptr->filehash ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.hash\"");

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.filename",
            &response_data_ptr->filename ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.filename\"");

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.size",
            &response_data_ptr->filesize ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.size\"");

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.filetype",
            &response_data_ptr->filetype ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.filetype\"");

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.revision",
            &response_data_ptr->file_revision ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.revision\"");

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.flag",
            &response_data_ptr->flag ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.flag\"");

    // create_content_struct_parse TSingle
    try {
        const boost::property_tree::wptree & branch =
            response->pt.get_child(L"response.fileinfo.links");

        ResponseData::Links optarg;
        if ( LinksFromPropertyBranch(
                response, &optarg, branch) )
        {
            response_data_ptr->links = std::move(optarg);
        }
        else
        {
            // JSON response still has element if expected.
            // This is really an error.
            return_error(
                mf::api::api_code::ContentInvalidData,
                "missing \"response.fileinfo.links\"");
        }
    }
    catch(boost::property_tree::ptree_bad_path & err)
    {
        // JSON response still has element if no files were returned.
        // This is really an error.
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.links\"");
    }

    // create_content_parse_single optional with default
    GetIfExists(
            response->pt,
            "response.fileinfo.mimetype",
            &response_data_ptr->mimetype);

    {
        std::string optval;
        // create_content_enum_parse TSingle
        if ( GetIfExists(
                response->pt,
                "response.fileinfo.password_protected",
                &optval) )
        {
            if ( optval == "no" )
                response_data_ptr->password_protected = PasswordProtected::Unprotected;
            else if ( optval == "yes" )
                response_data_ptr->password_protected = PasswordProtected::Protected;
            else
                return_error(
                    mf::api::api_code::ContentInvalidData,
                    "invalid value in response.fileinfo.password_protected");
        }
        else
            return_error(
                mf::api::api_code::ContentInvalidData,
                "no value in response.fileinfo.password_protected");
    }

    {
        std::string optval;
        // create_content_enum_parse TSingle
        if ( GetIfExists(
                response->pt,
                "response.fileinfo.privacy",
                &optval) )
        {
            if ( optval == "public" )
                response_data_ptr->privacy = Privacy::Public;
            else if ( optval == "private" )
                response_data_ptr->privacy = Privacy::Private;
            else
                return_error(
                    mf::api::api_code::ContentInvalidData,
                    "invalid value in response.fileinfo.privacy");
        }
        else
            return_error(
                mf::api::api_code::ContentInvalidData,
                "no value in response.fileinfo.privacy");
    }

    // create_content_parse_single required
    if ( ! GetIfExists(
            response->pt,
            "response.fileinfo.quickkey",
            &response_data_ptr->quickkey ) )
        return_error(
            mf::api::api_code::ContentInvalidData,
            "missing \"response.fileinfo.quickkey\"");

    // Only on success, return parsed data structure with response
    response->response_data = std::move(response_data);

#   undef return_error
}