package org.xmlrpc.android;
import android.content.Context;
import android.net.Uri;
import android.os.AsyncTask;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.webkit.URLUtil;
import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.RedirectError;
import com.android.volley.TimeoutError;
import com.android.volley.toolbox.RequestFuture;
import com.android.volley.toolbox.StringRequest;
import com.google.gson.Gson;
import org.wordpress.android.R;
import org.wordpress.android.WordPress;
import org.wordpress.android.analytics.AnalyticsTracker;
import org.wordpress.android.datasets.CommentTable;
import org.wordpress.android.models.Blog;
import org.wordpress.android.models.BlogIdentifier;
import org.wordpress.android.models.Comment;
import org.wordpress.android.models.CommentList;
import org.wordpress.android.models.CommentStatus;
import org.wordpress.android.models.FeatureSet;
import org.wordpress.android.ui.media.MediaGridFragment.Filter;
import org.wordpress.android.ui.stats.StatsUtils;
import org.wordpress.android.ui.stats.StatsWidgetProvider;
import org.wordpress.android.util.AnalyticsUtils;
import org.wordpress.android.util.AppLog;
import org.wordpress.android.util.AppLog.T;
import org.wordpress.android.util.CoreEvents;
import org.wordpress.android.util.DateTimeUtils;
import org.wordpress.android.util.MapUtils;
import org.wordpress.android.util.helpers.MediaFile;
import org.xmlpull.v1.XmlPullParserException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.net.ssl.SSLHandshakeException;
import de.greenrobot.event.EventBus;
public class ApiHelper {
public static final class Method {
public static final String GET_MEDIA_LIBRARY = "wp.getMediaLibrary";
public static final String GET_POST_FORMATS = "wp.getPostFormats";
public static final String GET_CATEGORIES = "wp.getCategories";
public static final String GET_MEDIA_ITEM = "wp.getMediaItem";
public static final String GET_COMMENT = "wp.getComment";
public static final String GET_COMMENTS = "wp.getComments";
public static final String GET_BLOGS = "wp.getUsersBlogs";
public static final String GET_OPTIONS = "wp.getOptions";
public static final String GET_PROFILE = "wp.getProfile";
public static final String GET_PAGES = "wp.getPages";
public static final String GET_TERM = "wp.getTerm";
public static final String GET_PAGE = "wp.getPage";
public static final String DELETE_COMMENT = "wp.deleteComment";
public static final String DELETE_PAGE = "wp.deletePage";
public static final String DELETE_POST = "wp.deletePost";
public static final String NEW_CATEGORY = "wp.newCategory";
public static final String NEW_COMMENT = "wp.newComment";
public static final String EDIT_POST = "wp.editPost";
public static final String EDIT_COMMENT = "wp.editComment";
public static final String SET_OPTIONS = "wp.setOptions";
public static final String UPLOAD_FILE = "wp.uploadFile";
public static final String WPCOM_GET_FEATURES = "wpcom.getFeatures";
public static final String LIST_METHODS = "system.listMethods";
}
public static final class Param {
public static final String SHOW_SUPPORTED_POST_FORMATS = "show-supported";
}
public enum ErrorType {
NO_ERROR, UNKNOWN_ERROR, INVALID_CURRENT_BLOG, NETWORK_XMLRPC, INVALID_CONTEXT,
INVALID_RESULT, NO_UPLOAD_FILES_CAP, CAST_EXCEPTION, TASK_CANCELLED, UNAUTHORIZED
}
public static final Map<String, String> blogOptionsXMLRPCParameters = new HashMap<String, String>();
static {
blogOptionsXMLRPCParameters.put("software_version", "software_version");
blogOptionsXMLRPCParameters.put("post_thumbnail", "post_thumbnail");
blogOptionsXMLRPCParameters.put("jetpack_client_id", "jetpack_client_id");
blogOptionsXMLRPCParameters.put("blog_public", "blog_public");
blogOptionsXMLRPCParameters.put("home_url", "home_url");
blogOptionsXMLRPCParameters.put("admin_url", "admin_url");
blogOptionsXMLRPCParameters.put("login_url", "login_url");
blogOptionsXMLRPCParameters.put("blog_title", "blog_title");
blogOptionsXMLRPCParameters.put("time_zone", "time_zone");
}
public static abstract class HelperAsyncTask<Params, Progress, Result> extends AsyncTask<Params, Progress, Result> {
protected String mErrorMessage;
protected ErrorType mErrorType = ErrorType.NO_ERROR;
protected Throwable mThrowable;
protected void setError(@NonNull ErrorType errorType, String errorMessage) {
mErrorMessage = errorMessage;
mErrorType = errorType;
AppLog.e(T.API, mErrorType.name() + " - " + mErrorMessage);
}
protected void setError(@NonNull ErrorType errorType, String errorMessage, Throwable throwable) {
mErrorMessage = errorMessage;
mErrorType = errorType;
mThrowable = throwable;
AppLog.e(T.API, mErrorType.name() + " - " + mErrorMessage, throwable);
}
}
public interface GenericErrorCallback {
public void onFailure(ErrorType errorType, String errorMessage, Throwable throwable);
}
public interface GenericCallback extends GenericErrorCallback {
public void onSuccess();
}
public interface DatabasePersistCallback {
void onDataReadyToSave(List list);
}
public static class GetPostFormatsTask extends HelperAsyncTask<Blog, Void, Object> {
private Blog mBlog;
@Override
protected Object doInBackground(Blog... blog) {
mBlog = blog[0];
XMLRPCClientInterface client = XMLRPCFactory.instantiate(mBlog.getUri(), mBlog.getHttpuser(),
mBlog.getHttppassword());
Object result = null;
Object[] params = { mBlog.getRemoteBlogId(), mBlog.getUsername(),
mBlog.getPassword(), Param.SHOW_SUPPORTED_POST_FORMATS };
try {
result = client.call(Method.GET_POST_FORMATS, params);
} catch (ClassCastException cce) {
setError(ErrorType.INVALID_RESULT, cce.getMessage(), cce);
} catch (XMLRPCException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (IOException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (XmlPullParserException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
}
return result;
}
protected void onPostExecute(Object result) {
if (result != null && result instanceof HashMap) {
Map<?, ?> postFormats = (HashMap<?, ?>) result;
if (postFormats.size() > 0) {
Gson gson = new Gson();
String postFormatsJson = gson.toJson(postFormats);
if (postFormatsJson != null) {
if (mBlog.bsetPostFormats(postFormatsJson)) {
WordPress.wpDB.saveBlog(mBlog);
}
}
}
}
}
}
public static synchronized void updateBlogOptions(Blog currentBlog, Map<?, ?> blogOptions) {
boolean isModified = false;
Gson gson = new Gson();
String blogOptionsJson = gson.toJson(blogOptions);
if (blogOptionsJson != null) {
isModified |= currentBlog.bsetBlogOptions(blogOptionsJson);
}
// Software version
if (!currentBlog.isDotcomFlag()) {
Map<?, ?> sv = (Map<?, ?>) blogOptions.get("software_version");
String wpVersion = MapUtils.getMapStr(sv, "value");
if (wpVersion.length() > 0) {
isModified |= currentBlog.bsetWpVersion(wpVersion);
}
}
// Featured image support
Map<?, ?> featuredImageHash = (Map<?, ?>) blogOptions.get("post_thumbnail");
if (featuredImageHash != null) {
boolean featuredImageCapable = MapUtils.getMapBool(featuredImageHash, "value");
isModified |= currentBlog.bsetFeaturedImageCapable(featuredImageCapable);
} else {
isModified |= currentBlog.bsetFeaturedImageCapable(false);
}
// Blog name
Map<?, ?> blogNameHash = (Map<?, ?>) blogOptions.get("blog_title");
if (blogNameHash != null) {
String blogName = MapUtils.getMapStr(blogNameHash, "value");
if (blogName != null && !blogName.equals(currentBlog.getBlogName())) {
currentBlog.setBlogName(blogName);
isModified = true;
}
}
if (isModified) {
WordPress.wpDB.saveBlog(currentBlog);
}
}
/**
* Task to refresh blog level information (WP version number) and stuff
* related to the active theme (available post types, recent comments, etc).
*/
public static class RefreshBlogContentTask extends HelperAsyncTask<Boolean, Void, Boolean> {
private static HashSet<BlogIdentifier> refreshedBlogs = new HashSet<BlogIdentifier>();
private Blog mBlog;
private BlogIdentifier mBlogIdentifier;
private GenericCallback mCallback;
public RefreshBlogContentTask(Blog blog, GenericCallback callback) {
if (blog == null) {
cancel(true);
return;
}
mBlogIdentifier = new BlogIdentifier(blog.getUrl(), blog.getRemoteBlogId());
if (refreshedBlogs.contains(mBlogIdentifier)) {
cancel(true);
} else {
refreshedBlogs.add(mBlogIdentifier);
}
mBlog = blog;
mCallback = callback;
}
private void updateBlogAdmin(Map<String, Object> userInfos) {
if (userInfos.containsKey("roles") && ( userInfos.get("roles") instanceof Object[])) {
boolean isAdmin = false;
Object[] userRoles = (Object[])userInfos.get("roles");
for (int i = 0; i < userRoles.length; i++) {
if (userRoles[i].toString().equals("administrator")) {
isAdmin = true;
break;
}
}
if (mBlog.bsetAdmin(isAdmin)) {
WordPress.wpDB.saveBlog(mBlog);
EventBus.getDefault().post(new CoreEvents.BlogListChanged());
}
}
}
@Override
protected Boolean doInBackground(Boolean... params) {
boolean commentsOnly = params[0];
XMLRPCClientInterface client = XMLRPCFactory.instantiate(mBlog.getUri(), mBlog.getHttpuser(),
mBlog.getHttppassword());
boolean alreadyTrackedAsJetpackBlog = mBlog.isJetpackPowered();
if (!commentsOnly) {
// check the WP number if self-hosted
Map<String, String> hPost = ApiHelper.blogOptionsXMLRPCParameters;
Object[] vParams = {mBlog.getRemoteBlogId(),
mBlog.getUsername(),
mBlog.getPassword(),
hPost};
Object versionResult = null;
try {
versionResult = client.call(Method.GET_OPTIONS, vParams);
} catch (ClassCastException cce) {
setError(ErrorType.INVALID_RESULT, cce.getMessage(), cce);
return false;
} catch (Exception e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
return false;
}
if (versionResult != null) {
Map<?, ?> blogOptions = (HashMap<?, ?>) versionResult;
ApiHelper.updateBlogOptions(mBlog, blogOptions);
}
if (mBlog.isJetpackPowered() && !alreadyTrackedAsJetpackBlog) {
// blog just added to the app, or the value of jetpack_client_id has just changed
AnalyticsUtils.trackWithBlogDetails(AnalyticsTracker.Stat.SIGNED_INTO_JETPACK, mBlog);
}
// get theme post formats
new GetPostFormatsTask().execute(mBlog);
//Update Stats widgets if necessary
String currentBlogID = String.valueOf(mBlog.getRemoteBlogId());
if (StatsWidgetProvider.isBlogDisplayedInWidget(mBlog.getRemoteBlogId())) {
AppLog.d(AppLog.T.STATS, "The blog with remoteID " + currentBlogID + " is NOT displayed in a widget. Blog Refresh Task doesn't call an update of the widget.");
String currentDate = StatsUtils.getCurrentDateTZ(mBlog.getLocalTableBlogId());
StatsWidgetProvider.enqueueStatsRequestForBlog(WordPress.getContext(), currentBlogID, currentDate);
}
}
// Check if user is an admin
Object[] userParams = {mBlog.getRemoteBlogId(), mBlog.getUsername(), mBlog.getPassword()};
try {
Map<String, Object> userInfos = (HashMap<String, Object>) client.call(Method.GET_PROFILE, userParams);
updateBlogAdmin(userInfos);
} catch (ClassCastException cce) {
setError(ErrorType.INVALID_RESULT, cce.getMessage(), cce);
return false;
} catch (XMLRPCException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (IOException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (XmlPullParserException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
}
// refresh the comments
Map<String, Object> hPost = new HashMap<String, Object>();
hPost.put("number", 30);
Object[] commentParams = {mBlog.getRemoteBlogId(), mBlog.getUsername(),
mBlog.getPassword(), hPost};
try {
ApiHelper.refreshComments(mBlog, commentParams, new DatabasePersistCallback() {
@Override
public void onDataReadyToSave(List list) {
int localBlogId = mBlog.getLocalTableBlogId();
CommentTable.deleteCommentsForBlog(localBlogId);
CommentTable.saveComments(localBlogId, (CommentList)list);
}
});
} catch (Exception e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
return false;
}
return true;
}
@Override
protected void onPostExecute(Boolean success) {
if (mCallback != null) {
if (success) {
mCallback.onSuccess();
} else {
mCallback.onFailure(mErrorType, mErrorMessage, mThrowable);
}
}
refreshedBlogs.remove(mBlogIdentifier);
}
}
/**
* request deleted comments for passed blog and remove them from local db
* @param blog blog to check
* @return count of comments that were removed from db
*/
public static int removeDeletedComments(Blog blog) {
if (blog == null) {
return 0;
}
XMLRPCClientInterface client = XMLRPCFactory.instantiate(
blog.getUri(),
blog.getHttpuser(),
blog.getHttppassword());
Map<String, Object> hPost = new HashMap<String, Object>();
hPost.put("status", "trash");
Object[] params = { blog.getRemoteBlogId(),
blog.getUsername(),
blog.getPassword(),
hPost };
int numDeleted = 0;
try {
Object[] result = (Object[]) client.call(Method.GET_COMMENTS, params);
if (result == null || result.length == 0) {
return 0;
}
Map<?, ?> contentHash;
for (Object aComment : result) {
contentHash = (Map<?, ?>) aComment;
long commentId = Long.parseLong(contentHash.get("comment_id").toString());
if (CommentTable.deleteComment(blog.getLocalTableBlogId(), commentId))
numDeleted++;
}
if (numDeleted > 0) {
AppLog.d(T.COMMENTS, String.format("removed %d deleted comments", numDeleted));
}
} catch (XMLRPCException e) {
AppLog.e(T.COMMENTS, e);
} catch (IOException e) {
AppLog.e(T.COMMENTS, e);
} catch (XmlPullParserException e) {
AppLog.e(T.COMMENTS, e);
}
return numDeleted;
}
public static CommentList refreshComments(Blog blog, Object[] commentParams, DatabasePersistCallback dbCallback)
throws XMLRPCException, IOException, XmlPullParserException {
if (blog == null) {
return null;
}
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Object[] result;
result = (Object[]) client.call(Method.GET_COMMENTS, commentParams);
if (result.length == 0) {
return null;
}
Map<?, ?> contentHash;
long commentID, postID;
String authorName, content, status, authorEmail, authorURL, postTitle, pubDate;
java.util.Date date;
CommentList comments = new CommentList();
for (int ctr = 0; ctr < result.length; ctr++) {
contentHash = (Map<?, ?>) result[ctr];
content = contentHash.get("content").toString();
status = contentHash.get("status").toString();
postID = Long.parseLong(contentHash.get("post_id").toString());
commentID = Long.parseLong(contentHash.get("comment_id").toString());
authorName = contentHash.get("author").toString();
authorURL = contentHash.get("author_url").toString();
authorEmail = contentHash.get("author_email").toString();
postTitle = contentHash.get("post_title").toString();
date = (java.util.Date) contentHash.get("date_created_gmt");
pubDate = DateTimeUtils.iso8601FromDate(date);
Comment comment = new Comment(
postID,
commentID,
authorName,
pubDate,
content,
status,
postTitle,
authorURL,
authorEmail,
null);
comments.add(comment);
}
if (dbCallback != null){
dbCallback.onDataReadyToSave(comments);
}
return comments;
}
/**
* Delete a single post or page via XML-RPC API parameters follow those of FetchSinglePostTask
*/
public static class DeleteSinglePostTask extends HelperAsyncTask<Object, Boolean, Boolean> {
@Override
protected Boolean doInBackground(Object... arguments) {
Blog blog = (Blog) arguments[0];
if (blog == null) {
return false;
}
String postId = (String) arguments[1];
boolean isPage = (Boolean) arguments[2];
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Object[] params = {blog.getRemoteBlogId(), blog.getUsername(), blog.getPassword(), postId};
try {
client.call(isPage ? Method.DELETE_PAGE : Method.DELETE_POST, params);
return true;
} catch (XMLRPCException | IOException | XmlPullParserException e) {
mErrorMessage = e.getMessage();
return false;
}
}
}
public static class SyncMediaLibraryTask extends HelperAsyncTask<java.util.List<?>, Void, Integer> {
public interface Callback extends GenericErrorCallback {
public void onSuccess(int results);
}
private Callback mCallback;
private int mOffset;
private Filter mFilter;
public SyncMediaLibraryTask(int offset, Filter filter, Callback callback) {
mOffset = offset;
mCallback = callback;
mFilter = filter;
}
@Override
protected Integer doInBackground(List<?>... params) {
List<?> arguments = params[0];
WordPress.currentBlog = (Blog) arguments.get(0);
Blog blog = WordPress.currentBlog;
if (blog == null) {
setError(ErrorType.INVALID_CURRENT_BLOG, "ApiHelper - current blog is null");
return 0;
}
String blogId = String.valueOf(blog.getLocalTableBlogId());
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Map<String, Object> filter = new HashMap<String, Object>();
filter.put("number", 50);
filter.put("offset", mOffset);
if (mFilter == Filter.IMAGES) {
filter.put("mime_type","image/*");
} else if(mFilter == Filter.UNATTACHED) {
filter.put("parent_id", 0);
}
Object[] apiParams = {blog.getRemoteBlogId(), blog.getUsername(), blog.getPassword(),
filter};
Object[] results = null;
try {
results = (Object[]) client.call(Method.GET_MEDIA_LIBRARY, apiParams);
} catch (ClassCastException cce) {
setError(ErrorType.INVALID_RESULT, cce.getMessage(), cce);
return 0;
} catch (XMLRPCException e) {
prepareErrorMessage(e);
return 0;
} catch (IOException e) {
prepareErrorMessage(e);
return 0;
} catch (XmlPullParserException e) {
prepareErrorMessage(e);
return 0;
}
if (blogId == null) {
setError(ErrorType.INVALID_CURRENT_BLOG, "Invalid blogId");
return 0;
}
if (results == null) {
setError(ErrorType.INVALID_RESULT, "Invalid blogId");
return 0;
}
Map<?, ?> resultMap;
// results returned, so mark everything existing to deleted
// since offset is 0, we are doing a full refresh
if (mOffset == 0) {
WordPress.wpDB.setMediaFilesMarkedForDeleted(blogId);
}
for (Object result : results) {
resultMap = (Map<?, ?>) result;
boolean isDotCom = (WordPress.getCurrentBlog() != null && WordPress.getCurrentBlog().isDotcomFlag());
MediaFile mediaFile = new MediaFile(blogId, resultMap, isDotCom);
WordPress.wpDB.saveMediaFile(mediaFile);
}
WordPress.wpDB.deleteFilesMarkedForDeleted(blogId);
return results.length;
}
private void prepareErrorMessage(Exception e) {
// user does not have permission to view media gallery
if (e.getMessage() != null && e.getMessage().contains("401")) {
setError(ErrorType.NO_UPLOAD_FILES_CAP, e.getMessage(), e);
} else {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
}
}
@Override
protected void onPostExecute(Integer result) {
if (mCallback != null) {
if (mErrorType == ErrorType.NO_ERROR) {
mCallback.onSuccess(result);
} else {
mCallback.onFailure(mErrorType, mErrorMessage, mThrowable);
}
}
}
}
public static class EditMediaItemTask extends HelperAsyncTask<List<?>, Void, Boolean> {
private GenericCallback mCallback;
private String mMediaId;
private String mTitle;
private String mDescription;
private String mCaption;
public EditMediaItemTask(String mediaId, String title, String description, String caption,
GenericCallback callback) {
mMediaId = mediaId;
mCallback = callback;
mTitle = title;
mCaption = caption;
mDescription = description;
}
@Override
protected Boolean doInBackground(List<?>... params) {
List<?> arguments = params[0];
WordPress.currentBlog = (Blog) arguments.get(0);
Blog blog = WordPress.currentBlog;
if (blog == null) {
setError(ErrorType.INVALID_CURRENT_BLOG, "ApiHelper - current blog is null");
return null;
}
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Map<String, Object> contentStruct = new HashMap<String, Object>();
contentStruct.put("post_title", mTitle);
contentStruct.put("post_content", mDescription);
contentStruct.put("post_excerpt", mCaption);
Object[] apiParams = {
blog.getRemoteBlogId(),
blog.getUsername(),
blog.getPassword(),
mMediaId,
contentStruct
};
Boolean result = null;
try {
result = (Boolean) client.call(Method.EDIT_POST, apiParams);
} catch (ClassCastException cce) {
setError(ErrorType.INVALID_RESULT, cce.getMessage(), cce);
} catch (XMLRPCException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (IOException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (XmlPullParserException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
}
return result;
}
@Override
protected void onPostExecute(Boolean result) {
if (mCallback != null) {
if (mErrorType == ErrorType.NO_ERROR) {
mCallback.onSuccess();
} else {
mCallback.onFailure(mErrorType, mErrorMessage, mThrowable);
}
}
}
}
public static class GetMediaItemTask extends HelperAsyncTask<List<?>, Void, MediaFile> {
public interface Callback extends GenericErrorCallback {
public void onSuccess(MediaFile results);
}
private Callback mCallback;
private int mMediaId;
public GetMediaItemTask(int mediaId, Callback callback) {
mMediaId = mediaId;
mCallback = callback;
}
@Override
protected MediaFile doInBackground(List<?>... params) {
List<?> arguments = params[0];
WordPress.currentBlog = (Blog) arguments.get(0);
Blog blog = WordPress.currentBlog;
if (blog == null) {
setError(ErrorType.INVALID_CURRENT_BLOG, "ApiHelper - current blog is null");
return null;
}
String blogId = String.valueOf(blog.getLocalTableBlogId());
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Object[] apiParams = {
blog.getRemoteBlogId(),
blog.getUsername(),
blog.getPassword(),
mMediaId
};
Map<?, ?> results = null;
try {
results = (Map<?, ?>) client.call(Method.GET_MEDIA_ITEM, apiParams);
} catch (ClassCastException cce) {
setError(ErrorType.INVALID_RESULT, cce.getMessage(), cce);
} catch (XMLRPCException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (IOException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (XmlPullParserException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
}
if (results != null && blogId != null) {
boolean isDotCom = (WordPress.getCurrentBlog() != null && WordPress.getCurrentBlog().isDotcomFlag());
MediaFile mediaFile = new MediaFile(blogId, results, isDotCom);
WordPress.wpDB.saveMediaFile(mediaFile);
return mediaFile;
} else {
return null;
}
}
@Override
protected void onPostExecute(MediaFile result) {
if (mCallback != null) {
if (result != null) {
mCallback.onSuccess(result);
} else {
mCallback.onFailure(mErrorType, mErrorMessage, mThrowable);
}
}
}
}
public static class UploadMediaTask extends HelperAsyncTask<List<?>, Void, Map<?, ?>> {
public interface Callback extends GenericErrorCallback {
void onSuccess(String remoteId, String remoteUrl, String secondaryId);
void onProgressUpdate(float progress);
}
private Callback mCallback;
private Context mContext;
private MediaFile mMediaFile;
public UploadMediaTask(Context applicationContext, MediaFile mediaFile,
Callback callback) {
mContext = applicationContext;
mMediaFile = mediaFile;
mCallback = callback;
}
@Override
protected Map<?, ?> doInBackground(List<?>... params) {
List<?> arguments = params[0];
WordPress.currentBlog = (Blog) arguments.get(0);
Blog blog = WordPress.currentBlog;
if (blog == null) {
setError(ErrorType.INVALID_CURRENT_BLOG, "current blog is null");
return null;
}
final XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Map<String, Object> data = new HashMap<String, Object>();
data.put("name", mMediaFile.getFileName());
data.put("type", mMediaFile.getMimeType());
data.put("bits", mMediaFile);
data.put("overwrite", true);
Object[] apiParams = {
blog.getRemoteBlogId(),
blog.getUsername(),
blog.getPassword(),
data
};
final File tempFile = getTempFile(mContext);
if (client instanceof XMLRPCClient) {
((XMLRPCClient) client).setOnBytesUploadedListener(new XMLRPCClient.OnBytesUploadedListener() {
@Override
public void onBytesUploaded(long uploadedBytes) {
if (isCancelled()) {
// Stop the upload if the task has been cancelled
((XMLRPCClient) client).cancel();
}
if (tempFile == null || tempFile.length() == 0) {
return;
}
float fractionUploaded = uploadedBytes / (float) tempFile.length();
mCallback.onProgressUpdate(fractionUploaded);
}
});
}
if (mContext == null) {
return null;
}
Map<?, ?> resultMap;
try {
resultMap = (HashMap<?, ?>) client.call(Method.UPLOAD_FILE, apiParams, tempFile);
} catch (ClassCastException cce) {
setError(ErrorType.INVALID_RESULT, null, cce);
return null;
} catch (XMLRPCFault e) {
if (e.getFaultCode() == 401) {
setError(ErrorType.NETWORK_XMLRPC,
mContext.getString(R.string.media_error_no_permission_upload), e);
} else {
// getFaultString() returns the error message from the server without the "[Code 403]" part.
setError(ErrorType.NETWORK_XMLRPC, e.getFaultString(), e);
}
return null;
} catch (XMLRPCException e) {
setError(ErrorType.NETWORK_XMLRPC, null, e);
return null;
} catch (IOException e) {
setError(ErrorType.NETWORK_XMLRPC, null, e);
return null;
} catch (XmlPullParserException e) {
setError(ErrorType.NETWORK_XMLRPC, null, e);
return null;
}
if (resultMap != null && resultMap.containsKey("id")) {
return resultMap;
} else {
setError(ErrorType.INVALID_RESULT, null);
}
return null;
}
// Create a temp file for media upload
private File getTempFile(Context context) {
String tempFileName = "wp-" + System.currentTimeMillis();
try {
context.openFileOutput(tempFileName, Context.MODE_PRIVATE);
} catch (FileNotFoundException e) {
return null;
}
return context.getFileStreamPath(tempFileName);
}
@Override
protected void onPostExecute(Map<?, ?> result) {
if (mCallback != null) {
if (result != null) {
String remoteId = (String) result.get("id");
String remoteUrl = (String) result.get("url");
String videoPressId = (String) result.get("videopress_shortcode");
mCallback.onSuccess(remoteId, remoteUrl, videoPressId);
} else {
mCallback.onFailure(mErrorType, mErrorMessage, mThrowable);
}
}
}
}
public static class DeleteMediaTask extends HelperAsyncTask<List<?>, Void, Void> {
private GenericCallback mCallback;
private String mMediaId;
public DeleteMediaTask(String mediaId, GenericCallback callback) {
mMediaId = mediaId;
mCallback = callback;
}
@Override
protected Void doInBackground(List<?>... params) {
List<?> arguments = params[0];
Blog blog = (Blog) arguments.get(0);
if (blog == null) {
setError(ErrorType.INVALID_CONTEXT, "ApiHelper - invalid blog");
return null;
}
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Object[] apiParams = new Object[]{blog.getRemoteBlogId(), blog.getUsername(),
blog.getPassword(), mMediaId};
try {
if (client != null) {
Boolean result = (Boolean) client.call(Method.DELETE_POST, apiParams);
if (!result) {
setError(ErrorType.INVALID_RESULT, "wp.deletePost returned false");
}
}
} catch (ClassCastException cce) {
setError(ErrorType.INVALID_RESULT, cce.getMessage(), cce);
} catch (XMLRPCException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (IOException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
} catch (XmlPullParserException e) {
setError(ErrorType.NETWORK_XMLRPC, e.getMessage(), e);
}
return null;
}
@Override
protected void onPostExecute(Void v) {
if (mCallback != null) {
if (mErrorType == ErrorType.NO_ERROR) {
mCallback.onSuccess();
} else {
mCallback.onFailure(mErrorType, mErrorMessage, mThrowable);
}
}
}
}
public static class GetFeatures extends AsyncTask<List<?>, Void, FeatureSet> {
public interface Callback {
void onResult(FeatureSet featureSet);
}
private Callback mCallback;
public GetFeatures() {
}
public GetFeatures(Callback callback) {
mCallback = callback;
}
public FeatureSet doSynchronously(List<?>... params) {
return doInBackground(params);
}
@Override
protected FeatureSet doInBackground(List<?>... params) {
List<?> arguments = params[0];
Blog blog = (Blog) arguments.get(0);
if (blog == null)
return null;
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Object[] apiParams = new Object[] {
blog.getRemoteBlogId(),
blog.getUsername(),
blog.getPassword(),
};
Map<?, ?> resultMap = null;
try {
resultMap = (HashMap<?, ?>) client.call(Method.WPCOM_GET_FEATURES, apiParams);
} catch (ClassCastException cce) {
AppLog.e(T.API, "wpcom.getFeatures error", cce);
} catch (XMLRPCException e) {
AppLog.e(T.API, "wpcom.getFeatures error", e);
} catch (IOException e) {
AppLog.e(T.API, "wpcom.getFeatures error", e);
} catch (XmlPullParserException e) {
AppLog.e(T.API, "wpcom.getFeatures error", e);
}
if (resultMap != null) {
return new FeatureSet(blog.getRemoteBlogId(), resultMap);
}
return null;
}
@Override
protected void onPostExecute(FeatureSet result) {
if (mCallback != null)
mCallback.onResult(result);
}
}
/**
* Synchronous method to fetch the String content at the specified HTTP URL.
*
* @param stringUrl URL to fetch contents for.
* @return content of the resource, or null if URL was invalid or resource could not be retrieved.
*/
public static String getResponse(final String stringUrl) throws SSLHandshakeException, TimeoutError, TimeoutException {
return getResponse(stringUrl, 0);
}
private static String getRedirectURL(String oldURL, NetworkResponse networkResponse) {
if (networkResponse.headers != null && networkResponse.headers.containsKey("Location")) {
String newURL = networkResponse.headers.get("Location");
// Relative URL
if (newURL != null && newURL.startsWith("/")) {
Uri oldUri = Uri.parse(oldURL);
if (oldUri.getScheme() == null || oldUri.getAuthority() == null) {
return null;
}
return oldUri.getScheme() + "://" + oldUri.getAuthority() + newURL;
}
// Absolute URL
return newURL;
}
return null;
}
public static String getResponse(final String stringUrl, int numberOfRedirects) throws SSLHandshakeException, TimeoutError, TimeoutException {
RequestFuture<String> future = RequestFuture.newFuture();
StringRequest request = new StringRequest(stringUrl, future, future);
request.setRetryPolicy(new DefaultRetryPolicy(XMLRPCClient.DEFAULT_SOCKET_TIMEOUT_MS, 0, 1));
WordPress.requestQueue.add(request);
try {
return future.get(XMLRPCClient.DEFAULT_SOCKET_TIMEOUT_MS, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
AppLog.e(T.API, e);
} catch (ExecutionException e) {
if (e.getCause() != null && e.getCause() instanceof RedirectError) {
// Maximum 5 redirects or die
if (numberOfRedirects > 5) {
AppLog.e(T.API, "Maximum of 5 redirects reached, aborting.", e);
return null;
}
// Follow redirect
RedirectError re = (RedirectError) e.getCause();
if (re.networkResponse != null) {
String newURL = getRedirectURL(stringUrl, re.networkResponse);
if (newURL == null) {
AppLog.e(T.API, "Invalid server response", e);
return null;
}
// Abort redirect if old URL was HTTPS and not the new one
if (URLUtil.isHttpsUrl(stringUrl) && !URLUtil.isHttpsUrl(newURL)) {
AppLog.e(T.API, "Redirect from HTTPS to HTTP not allowed.", e);
return null;
}
// Retry getResponse
AppLog.i(T.API, "Follow redirect from " + stringUrl + " to " + newURL);
return getResponse(newURL, numberOfRedirects + 1);
}
} else if (e.getCause() != null && e.getCause() instanceof com.android.volley.TimeoutError) {
AppLog.e(T.API, e);
throw (com.android.volley.TimeoutError) e.getCause();
} else {
AppLog.e(T.API, e);
}
}
return null;
}
/*
* fetches a single post saves it to the db - note that this should NOT be called from main thread
*/
public static boolean updateSinglePost(int localBlogId, String remotePostId, boolean isPage) {
Blog blog = WordPress.getBlog(localBlogId);
if (blog == null || TextUtils.isEmpty(remotePostId)) {
return false;
}
XMLRPCClientInterface client = XMLRPCFactory.instantiate(
blog.getUri(),
blog.getHttpuser(),
blog.getHttppassword());
Object[] apiParams;
if (isPage) {
apiParams = new Object[]{
blog.getRemoteBlogId(),
remotePostId,
blog.getUsername(),
blog.getPassword()
};
} else {
apiParams = new Object[]{
remotePostId,
blog.getUsername(),
blog.getPassword()
};
}
try {
Object result = client.call(isPage ? Method.GET_PAGE : "metaWeblog.getPost", apiParams);
if (result != null && result instanceof Map) {
Map postMap = (HashMap) result;
List<Map<?, ?>> postsList = new ArrayList<>();
postsList.add(postMap);
WordPress.wpDB.savePosts(postsList, localBlogId, isPage, true);
return true;
} else {
return false;
}
} catch (XMLRPCException | IOException | XmlPullParserException e) {
AppLog.e(AppLog.T.POSTS, e);
return false;
}
}
public static boolean editComment(Blog blog, Comment comment, CommentStatus newStatus) {
if (blog == null) {
return false;
}
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Map<String, String> postHash = new HashMap<>();
postHash.put("status", CommentStatus.toString(newStatus));
postHash.put("content", comment.getCommentText());
postHash.put("author", comment.getAuthorName());
postHash.put("author_url", comment.getAuthorUrl());
postHash.put("author_email", comment.getAuthorEmail());
Object[] params = { blog.getRemoteBlogId(),
blog.getUsername(),
blog.getPassword(),
Long.toString(comment.commentID),
postHash};
try {
Object result = client.call(Method.EDIT_COMMENT, params);
return (result != null && Boolean.parseBoolean(result.toString()));
} catch (XMLRPCFault xmlrpcFault) {
if (xmlrpcFault.getFaultCode() == 500) {
// let's check whether the comment is already marked as _newStatus_
CommentStatus remoteStatus = getCommentStatus(blog, comment);
if (remoteStatus != null && remoteStatus.equals(newStatus)) {
// Happy days! Remote is already marked as the desired status
return true;
}
}
AppLog.e(T.COMMENTS, "Error while editing comment", xmlrpcFault);
} catch (XMLRPCException e) {
AppLog.e(T.COMMENTS, "Error while editing comment", e);
} catch (IOException e) {
AppLog.e(T.COMMENTS, "Error while editing comment", e);
} catch (XmlPullParserException e) {
AppLog.e(T.COMMENTS, "Error while editing comment", e);
}
return false;
}
/**
* Fetches the status of a comment
* @param blog the blog the comment is in
* @param comment the comment to fetch its status
* @return the status of the comment on the server, null if error
*/
public static @Nullable CommentStatus getCommentStatus(Blog blog, Comment comment) {
if (blog == null || comment == null) {
return null;
}
XMLRPCClientInterface client = XMLRPCFactory.instantiate(blog.getUri(), blog.getHttpuser(),
blog.getHttppassword());
Object[] params = { blog.getRemoteBlogId(),
blog.getUsername(),
blog.getPassword(),
Long.toString(comment.commentID)};
try {
Map<?, ?> contentHash = (Map<?, ?>) client.call(Method.GET_COMMENT, params);
final Object status = contentHash.get("status");
return status == null ? null : CommentStatus.fromString(status.toString());
} catch (XMLRPCException e) {
AppLog.e(T.COMMENTS, "Error while getting comment", e);
} catch (IOException e) {
AppLog.e(T.COMMENTS, "Error while getting comment", e);
} catch (XmlPullParserException e) {
AppLog.e(T.COMMENTS, "Error while getting comment", e);
}
return null;
}
}