/**
* 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()));
}
/** 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()));
}
/**
* 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()));
}
/**
* 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()));
}
/**
* 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()));
}
/**
* 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()));
}
/**
* @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()));
}
/**
* 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()));
}
/**
* 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()));
}
/**
* 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 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 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()));
}
/**
* 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()));
}
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()));
}
/**
* 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()));
}
/**
* 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()));
}
/**
* 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()));
}
/**
* 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()));
}
/**
* 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()));
}
/**
* @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()));
}
/**
* Starts creating favorited statues
* @param statusid ID of the desired status to be favorited.
* @param includeEntities When set to true, each tweet will include a node called "entities,".
*/
void QTweetFavoritesCreate::create(qint64 statusid, bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/favorites/create/%1.json").arg(statusid));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, QByteArray());
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Retweets the tweet
* @param id tweet ID to retweet
* @param trimUser trims user info in response
* @param includeEntities true to include node entities in response
*/
void QTweetStatusRetweet::retweet(qint64 id,
bool trimUser,
bool includeEntities)
{
QUrl url(QString("http://api.twitter.com/1/statuses/retweet/%1.json").arg(id));
if (trimUser)
url.addQueryItem("trim_user", "true");
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
if (isAuthenticationEnabled()) { //Oh, Twitter API docs wrong?
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()));
}
/**
* Starts fetching direct messages
* @param sinceid returns results with an ID greater than (that is, more recent than) the specified ID.
* @param maxid returns results with an ID less than (that is, older than) or equal to the specified ID.
* @param count specifies the number of records to retrieve. Must be less than or equal to 200.
* @param page specifies the page of results to retrieve.
* @param includeEntities When set to true, each tweet will include a node called "entities,".
* @remarks Setting parameters to default value will not be put in the query
*/
void QTweetDirectMessagesSent::fetch(qint64 sinceid,
qint64 maxid,
int count,
int page,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("https://api.twitter.com/1.1/direct_messages/sent.json");
QUrlQuery urlQuery;
if (sinceid)
urlQuery.addQueryItem("since_id", QString::number(sinceid));
if (maxid)
urlQuery.addQueryItem("max_id", QString::number(maxid));
if (count)
urlQuery.addQueryItem("count", QString::number(count));
if (page)
urlQuery.addQueryItem("page", QString::number(page));
if (includeEntities)
urlQuery.addQueryItem("include_entities", "true");
url.setQuery(urlQuery);
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()));
}
