/**
* Starts fetching user followers list
* @param screenName the screen name of the user for whom to return results for.
* Set to empty string if you want to fetch followers for authenticaded user
* @param cursor breaks the results into pages. Provide a value of "-1" to begin paging.
* @param includeEntities when set to true, each tweet will include a node called "entities,".
*/
void QTweetUserStatusesFollowers::fetch(const QString &screenName,
const QString &cursor,
bool includeEntities)
{
QUrl url("http://api.twitter.com/1/statuses/followers.json");
if (!screenName.isEmpty())
url.addQueryItem("screen_name", screenName);
if (!cursor.isEmpty()) {
m_usesCursoring = true;
url.addQueryItem("cursor", cursor);
}
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/*!
Starts fetching
\param id Tweet ID
\param respType Response type
\remarks Async
*/
void QTweetStatusShow::fetch(qint64 id, ResponseType respType, bool trimUser, bool includeEntities)
{
Q_ASSERT(oauthTwitter() != 0);
QUrl url;
if (respType == QTweetNetBase::JSON)
url.setUrl("http://api.twitter.com/1/statuses/show.json");
else
url.setUrl("http://api.twitter.com/1/statuses/show.xml");
url.addQueryItem("id", QString::number(id));
if (trimUser)
url.addQueryItem("trim_user", "true");
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error()));
}
/** Creates list
* @param user user id
* @param name the name of the list
* @param mode true for public list, false for private list
* @param description the description to give the list.
*/
void QTweetListCreate::create(qint64 user,
const QString &name,
bool mode,
const QString &description)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/%1/lists.json").arg(user));
QUrl urlQuery(url);
urlQuery.addEncodedQueryItem("name", QUrl::toPercentEncoding(name));
if (!mode)
urlQuery.addQueryItem("mode", "private");
if (!description.isEmpty())
urlQuery.addEncodedQueryItem("description", QUrl::toPercentEncoding(description));
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QByteArray postBody = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
postBody.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, postBody);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* @param user user id
* @param list list id
* @param cursor breaks the results in pages. Set to "-1" to begin paging.
* Use prevCursor and nextCursor to page back and forth
* @param includeEntities when set to true each tweet will include a node called "entities,"
*/
void QTweetListSubscribers::fetch(qint64 user,
qint64 list,
const QString &cursor,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/%1/%2/subscribers.json").arg(user).arg(list));
if (!cursor.isEmpty())
url.addQueryItem("cursor", cursor);
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Starts fetching
* @param id tweet ID
* @param trimUser set to true to trim user info in response
* @param includeEntities set to true to include node entities in response
*/
void QTweetStatusShow::fetch(qint64 id, bool trimUser, bool includeEntities, bool includeMyRetweet)
{
QUrl url("http://api.twitter.com/1/statuses/show.json");
url.addQueryItem("id", QString::number(id));
if (trimUser)
url.addQueryItem("trim_user", "true");
if (includeEntities)
url.addQueryItem("include_entities", "true");
if (includeMyRetweet)
url.addQueryItem("include_my_retweet ", "true");
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* save a search query
*/
void QTweetSaveSearchQuery::save(const QString& query)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("https://api.twitter.com/1.1/saved_searches/create.json");
QUrl urlQuery(url);
urlQuery.addQueryItem("query", query);
QNetworkRequest req(url);
req.setRawHeader("User-Agent", userAgent());
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QByteArray postBody = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
postBody.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, postBody);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Sends direct message
* @param user The ID of the user who should receive the direct message.
* @param text The text of direct message
* @param includeEntities When set to true each tweet will include a node called "entities,"
*/
void QTweetDirectMessageNew::post(qint64 user,
const QString &text,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("https://api.twitter.com/1/direct_messages/new.json");
QUrl urlQuery(url);
urlQuery.addQueryItem("user_id", QString::number(user));
urlQuery.addEncodedQueryItem("text", QUrl::toPercentEncoding(text));
if (includeEntities)
urlQuery.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QByteArray postBody = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
postBody.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, postBody);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Blocks user
* @param screenName screen name of the user to be blocked
* @param includeEntities When set to true, each tweet will include a node called "entities"
*/
void QTweetBlocksCreate::create(const QString& screenName, bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("https://api.twitter.com/1/blocks/create.json");
QUrl urlQuery(url);
urlQuery.addQueryItem("screen_name", screenName);
if (includeEntities)
urlQuery.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QByteArray postBody = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
postBody.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, postBody);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Destroys tweet with id
* @param id tweet ID
* @param trimUser trims users info
* @param includeEntities true to include node entities in response
*/
void QTweetStatusDestroy::destroy(qint64 id,
bool trimUser)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("https://api.twitter.com/1.1/statuses/destroy.json");
QUrl urlQuery(url);
urlQuery.addQueryItem("id", QString::number(id));
if (trimUser)
urlQuery.addQueryItem("trim_user", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QByteArray postBody = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
postBody.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, postBody);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Starts a search
* @param query the search query to run against people search
* @param perPage the number of people per page to retrieve. Maxiumum of 20 allowed per page.
* @param page specifies the page of results to retrieve
* @param includeEntities when set to true each tweet will include a node called "entities".
*/
void QTweetUserSearch::search(const QString &query,
int perPage,
int page,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("https://api.twitter.com/1.1/users/search.json");
url.addQueryItem("q", query);
if (perPage)
url.addQueryItem("per_page", QString::number(perPage));
if (page)
url.addQueryItem("page", QString::number(page));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
req.setRawHeader("User-Agent", userAgent());
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Creates place
* @param name the name a place is known as
* @param containedWithin placeid within which the new place can be found. Be close as possible with
contained place
* @param token token found in the response from QTweetGeoSimilarPlaces
* @param latLong latitude and longitude
*/
void QTweetGeoPlaceCreate::create(const QString &name,
const QString &containedWithin,
const QString &token,
const QTweetGeoCoord &latLong)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/geo/place.json");
QUrl urlQuery(url);
urlQuery.addEncodedQueryItem("name", QUrl::toPercentEncoding(name));
urlQuery.addQueryItem("contained_within", containedWithin);
urlQuery.addQueryItem("token", token);
urlQuery.addQueryItem("lat", QString::number(latLong.latitude()));
urlQuery.addQueryItem("long", QString::number(latLong.longitude()));
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
QNetworkRequest req(url);
req.setRawHeader(AUTH_HEADER, oauthHeader);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QByteArray statusPost = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
statusPost.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, statusPost);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Starts fetching
* @param userid user ID
* @param screenName user screen name
* @param sinceid fetches tweets with ID greater (more recent) then sinceid
* @param maxid fetches tweets with ID less (older) then maxid
* @param count number of tweets to fetch (up to 200)
* @param page page number
* @param skipUser true to include only status authors numerical ID
* @param includeRts timeline contains native retweets if true
* @param includeEntities each tweet include node "entities"
* @param excludeReplies true to prevent replies from appearing in the returned timeline
* @param contributorDetails true to enhance the contributors element of the status response
*/
void QTweetUserTimeline::fetch(qint64 userid,
const QString &screenName,
qint64 sinceid,
qint64 maxid,
int count,
int page,
bool trimUser,
bool includeRts,
bool includeEntities,
bool excludeReplies,
bool contributorDetails)
{
QUrl url("http://api.twitter.com/1/statuses/user_timeline.json");
if (userid != 0)
url.addQueryItem("user_id", QString::number(userid));
if (!screenName.isEmpty())
url.addQueryItem("screen_name", screenName);
if (sinceid != 0)
url.addQueryItem("since_id", QString::number(sinceid));
if (maxid != 0)
url.addQueryItem("max_id", QString::number(maxid));
if (count != 0)
url.addQueryItem("count", QString::number(count));
if (page != 0)
url.addQueryItem("page", QString::number(page));
if (trimUser)
url.addQueryItem("trim_user", "true");
if (includeRts)
url.addQueryItem("include_rts", "true");
if (includeEntities)
url.addQueryItem("include_entities", "true");
if (excludeReplies)
url.addQueryItem("exclude_replies", "true");
if (contributorDetails)
url.addQueryItem("contributor_details", "true");
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Posts a tweet
* @param status text of the status update
* @param inReplyToStatus ID of a existing tweet is in reply to
* @param latLong latitude and longitude
* @param placeid a place in the world (use reverse geocoding)
* @param displayCoordinates whether or not to put a exact coordinates a tweet has been sent from
*/
void QTweetStatusUpdate::post(const QString &status,
qint64 inReplyToStatus,
const QTweetGeoCoord& latLong,
const QString &placeid,
bool displayCoordinates,
bool trimUser,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/statuses/update.json");
QUrl urlQuery("http://api.twitter.com/1/statuses/update.json");
urlQuery.addEncodedQueryItem("status", QUrl::toPercentEncoding(status));
if (inReplyToStatus != 0)
urlQuery.addQueryItem("in_reply_to_status_id", QString::number(inReplyToStatus));
if (latLong.isValid()) {
urlQuery.addQueryItem("lat", QString::number(latLong.latitude()));
urlQuery.addQueryItem("long", QString::number(latLong.longitude()));
}
if (!placeid.isEmpty())
urlQuery.addQueryItem("place_id", placeid);
if (displayCoordinates)
urlQuery.addQueryItem("display_coordinates", "true");
if (trimUser)
urlQuery.addQueryItem("trim_user", "true");
if (includeEntities)
urlQuery.addQueryItem("include_entities", "true");
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
QNetworkRequest req(url);
req.setRawHeader(AUTH_HEADER, oauthHeader);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
//build status post array
QByteArray statusPost = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
//remove '?'
statusPost.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, statusPost);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Starts fetching information about place
* @param placeid a place in the world. These ID's can be retrieved from QTweetGeoReverseGeoCode
*/
void QTweetGeoPlaceID::get(const QString &placeid)
{
QUrl url(QString("https://api.twitter.com/1/geo/id/%1.json").arg(placeid));
QNetworkRequest req(url);
req.setRawHeader("User-Agent", userAgent());
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Starts checking rate limit status
* @remarks Should be emiting rateLimitInfo signal after finishing
*/
void QTweetAccountRateLimitStatus::check()
{
QUrl url("http://api.twitter.com/1/account/rate_limit_status.json");
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetConfiguration::get()
{
QUrl url("http://api.twitter.com/1.1/help/configuration.json");
QNetworkRequest req(url);
if (isAuthenticationEnabled())
{
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetSearch::startWithCustomQuery(const QByteArray &encodedQuery)
{
QUrl url("https://search.twitter.com/search.json");
//remove ?
QByteArray query(encodedQuery);
url.setEncodedQuery(query.remove(0, 1));
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Start fetcing one page of id's
* @param user the ID of the user for whom to return results for.
* @param cursor use from response nextCursor and prevCursor to allow paging back and forth
*/
void QTweetFriendsID::fetch(qint64 user, const QString &cursor)
{
QUrl url("http://api.twitter.com/1/friends/ids.json");
url.addQueryItem("user_id", QString::number(user));
url.addQueryItem("cursor", cursor);
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Gets the user ids which user is blocking
*/
void QTweetBlocksBlockingIDs::getIDs()
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/blocks/blocking/ids.json");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Starts fetching one page of id's
* @param screenName the screen name of the user for whom to return results for.
* @param cursor use from signal response nextCursor and prevCursor to allow paging back and forth
*/
void QTweetFollowersID::fetch(const QString &screenName, const QString &cursor)
{
QUrl url("https://api.twitter.com/1/followers/ids.json");
url.addQueryItem("screen_name", screenName);
url.addQueryItem("cursor", cursor);
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Start geo reversing
* @param latLong latitutde and longitude
* @param accuracy a hint on the "region" in which to search in meters
* @param granularity minimal granularity of place types to return
* @param maxResults hint as to the number of results to return
*/
void QTweetGeoReverseGeoCode::getPlaces(const QTweetGeoCoord& latLong,
int accuracy,
QTweetPlace::Type granularity,
int maxResults)
{
QUrl url("https://api.twitter.com/1/geo/reverse_geocode.json");
url.addQueryItem("lat", QString::number(latLong.latitude()));
url.addQueryItem("long", QString::number(latLong.longitude()));
if (accuracy != 0)
url.addQueryItem("accuracy", QString::number(accuracy));
switch (granularity) {
case QTweetPlace::Poi:
url.addQueryItem("granularity", "poi");
break;
case QTweetPlace::Neighborhood:
url.addQueryItem("granularity", "neighborhood");
break;
case QTweetPlace::City:
url.addQueryItem("granularity", "city");
break;
case QTweetPlace::Admin:
url.addQueryItem("granularity", "admin");
break;
case QTweetPlace::Country:
url.addQueryItem("granularity", "country");
break;
default:
;
}
if (maxResults != 0)
url.addQueryItem("max_results", QString::number(maxResults));
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* @param user user id owner of the list
* @param list list id
*/
void QTweetListSubscribe::follow(qint64 user, qint64 list)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/%1/%2/subscribers.json").arg(user).arg(list));
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, QByteArray());
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void RESTFriendshipExists::fetch(const qint64& userid1, const qint64& userid2)
{
QUrl url("https://api.twitter.com/1/friendships/exists.json?");
url.addQueryItem("user_id_a", QString::number(userid1));
url.addQueryItem("user_id_b", QString::number(userid2));
//fprintf(stderr, "fetchForUrl %s \n", url.toString().toStdString().c_str());
QNetworkRequest req(url);
req.setRawHeader("User-Agent", userAgent());
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Starts fetching friends timeline
* @param sinceid fetch tweets newer then sinceid
* @param maxid fetch tweets older then maxid
* @param count number of tweet to fetch (up to 200)
* @param page page Number (starts from 1)
* @param skipUser don't show user info in timeline (only id)
* @param includeRts timeline contains native retweets if true
* @param includeEntities each tweet will include node "entities"
* @remarks Setting parameter to default value will not be put in query
*/
void QTweetFriendsTimeline::fetch(qint64 sinceid,
qint64 maxid,
int count,
int page,
bool trimUser,
bool includeRts,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled.");
return;
}
QUrl url("http://api.twitter.com/1/statuses/friends_timeline.json");
if (sinceid != 0)
url.addQueryItem("since_id", QString::number(sinceid));
if (maxid != 0)
url.addQueryItem("max_id", QString::number(maxid));
if (count != 0)
url.addQueryItem("count", QString::number(count));
if (page != 0)
url.addQueryItem("page", QString::number(page));
if (trimUser)
url.addQueryItem("trim_user", "true");
if (includeRts)
url.addQueryItem("include_rts", "true");
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/*!
Start fetching
\param respType Response type
\param sinceid Fetches tweets with ID greater (more recent) then sinceid
\param maxid Fetches tweets with ID less (older) then maxid
\param count Number of tweets to fetch (up to 200)
\param page Page number
\remarks Async
*/
void QTweetRetweetByMe::fetch(ResponseType respType,
qint64 sinceid,
qint64 maxid,
int count,
int page,
bool trimUser,
bool includeEntities)
{
Q_ASSERT(oauthTwitter() != 0);
QUrl url;
if (respType == QTweetNetBase::JSON)
url.setUrl("http://api.twitter.com/1/statuses/retweeted_by_me.json");
else
url.setUrl("http://api.twitter.com/1/statuses/retweeted_by_me.xml");
if (sinceid != 0)
url.addQueryItem("since_id", QString::number(sinceid));
if (maxid != 0)
url.addQueryItem("max_id", QString::number(maxid));
if (count != 0)
url.addQueryItem("count", QString::number(count));
if (page != 0)
url.addQueryItem("page", QString::number(page));
if (trimUser)
url.addQueryItem("trim_user", "true");
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error()));
}
/**
* Starts fetching
* @param userid user ID
* @param includeEntities when set to true, each tweet will include a node called "entities"
*/
void QTweetUserShow::fetch(const QString &screenName, bool includeEntities)
{
QUrl url("https://api.twitter.com/1.1/users/show.json");
url.addQueryItem("screen_name", screenName);
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
req.setRawHeader("User-Agent", userAgent());
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Shows (gets) specified list
* @param id user id
* @param list list id
*/
void QTweetListShowList::show(qint64 id, qint64 list)
{
// slug parameter?
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/%1/lists/%2.json").arg(id).arg(list));
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* @param user user id (owner of the list
* @param list list id
* @param member user id of the list member to remove
*/
void QTweetListDeleteMember::remove(qint64 user, qint64 list, qint64 member)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/%1/%2/members.json").arg(user).arg(list));
url.addQueryItem("id", QString::number(member));
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::DELETE);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->deleteResource(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* @param id the ID of the direct message to delete.
* @param includeEntities When set to true, each tweet will include a node called "entities,"
*/
void QTweetDirectMessageDestroy::destroyMessage(qint64 id, bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("https://api.twitter.com/1/direct_messages/destroy/%1.json").arg(id));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
req.setRawHeader("User-Agent", userAgent());
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::DELETE);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->deleteResource(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Verifies credentials
* @param includeEntities when set to either true, t or 1, each tweet will include a node called "entities,".
*/
void QTweetAccountVerifyCredentials::verify(bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/account/verify_credentials.json");
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}