| package org.wordpress.android.ui.prefs; |
| |
| import android.app.Activity; |
| import android.text.TextUtils; |
| |
| import org.wordpress.android.R; |
| import org.wordpress.android.analytics.AnalyticsTracker; |
| import org.wordpress.android.datasets.SiteSettingsTable; |
| import org.wordpress.android.models.Blog; |
| import org.wordpress.android.models.CategoryModel; |
| import org.wordpress.android.models.SiteSettingsModel; |
| import org.wordpress.android.util.LanguageUtils; |
| import org.wordpress.android.util.AnalyticsUtils; |
| import org.wordpress.android.util.AppLog; |
| import org.wordpress.android.util.MapUtils; |
| import org.xmlrpc.android.ApiHelper.Method; |
| import org.xmlrpc.android.XMLRPCCallback; |
| import org.xmlrpc.android.XMLRPCClientInterface; |
| import org.xmlrpc.android.XMLRPCException; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Set; |
| |
| class SelfHostedSiteSettings extends SiteSettingsInterface { |
| // XML-RPC wp.getOptions keys |
| public static final String PRIVACY_KEY = "blog_public"; |
| public static final String DEF_CATEGORY_KEY = "default_category"; |
| public static final String DEF_POST_FORMAT_KEY = "default_post_format"; |
| public static final String ALLOW_COMMENTS_KEY = "default_comment_status"; |
| public static final String SEND_PINGBACKS_KEY = "default_pingback_flag"; |
| public static final String RECEIVE_PINGBACKS_KEY = "default_ping_status"; |
| public static final String CLOSE_OLD_COMMENTS_KEY = "close_comments_for_old_posts"; |
| public static final String CLOSE_OLD_COMMENTS_DAYS_KEY = "close_comments_days_old"; |
| public static final String THREAD_COMMENTS_KEY = "thread_comments"; |
| public static final String THREAD_COMMENTS_DEPTH_KEY = "thread_comments_depth"; |
| public static final String PAGE_COMMENTS_KEY = "page_comments"; |
| public static final String PAGE_COMMENT_COUNT_KEY = "comments_per_page"; |
| public static final String COMMENT_SORT_ORDER_KEY = "comment_order"; |
| public static final String COMMENT_MODERATION_KEY = "comment_moderation"; |
| public static final String REQUIRE_IDENTITY_KEY = "require_name_email"; |
| public static final String REQUIRE_USER_ACCOUNT_KEY = "comment_registration"; |
| public static final String WHITELIST_KNOWN_USERS_KEY = "comment_whitelist"; |
| public static final String MAX_LINKS_KEY = "comment_max_links"; |
| public static final String MODERATION_KEYS_KEY = "moderation_keys"; |
| public static final String BLACKLIST_KEYS_KEY = "blacklist_keys"; |
| public static final String SOFTWARE_VERSION_KEY = "software_version"; |
| |
| private static final String BLOG_URL_KEY = "blog_url"; |
| private static final String BLOG_TITLE_KEY = "blog_title"; |
| private static final String BLOG_USERNAME_KEY = "username"; |
| private static final String BLOG_PASSWORD_KEY = "password"; |
| private static final String BLOG_TAGLINE_KEY = "blog_tagline"; |
| private static final String BLOG_CATEGORY_ID_KEY = "categoryId"; |
| private static final String BLOG_CATEGORY_PARENT_ID_KEY = "parentId"; |
| private static final String BLOG_CATEGORY_DESCRIPTION_KEY = "categoryDescription"; |
| private static final String BLOG_CATEGORY_NAME_KEY = "categoryName"; |
| |
| // Requires WordPress 4.5.x or higher |
| private static final int REQUIRED_MAJOR_VERSION = 4; |
| private static final int REQUIRED_MINOR_VERSION = 3; |
| |
| private static final String OPTION_ALLOWED = "open"; |
| private static final String OPTION_DISALLOWED = "closed"; |
| |
| SelfHostedSiteSettings(Activity host, Blog blog, SiteSettingsListener listener) { |
| super(host, blog, listener); |
| } |
| |
| @Override |
| public SiteSettingsInterface init(boolean fetch) { |
| super.init(fetch); |
| |
| if (mSettings.defaultCategory == 0) { |
| mSettings.defaultCategory = siteSettingsPreferences(mActivity).getInt(DEF_CATEGORY_PREF_KEY, 0); |
| } |
| if (TextUtils.isEmpty(mSettings.defaultPostFormat) || mSettings.defaultPostFormat.equals("0")) { |
| mSettings.defaultPostFormat = siteSettingsPreferences(mActivity).getString(DEF_FORMAT_PREF_KEY, "0"); |
| } |
| mSettings.language = siteSettingsPreferences(mActivity).getString(LANGUAGE_PREF_KEY, LanguageUtils.getPatchedCurrentDeviceLanguage(null)); |
| |
| return this; |
| } |
| |
| @Override |
| public void saveSettings() { |
| super.saveSettings(); |
| |
| final Map<String, String> params = serializeSelfHostedParams(); |
| if (params == null || params.isEmpty()) return; |
| |
| XMLRPCCallback callback = new XMLRPCCallback() { |
| @Override |
| public void onSuccess(long id, final Object result) { |
| notifySavedOnUiThread(null); |
| mRemoteSettings.copyFrom(mSettings); |
| |
| if (result != null) { |
| HashMap<String, Object> properties = new HashMap<>(); |
| if (result instanceof Map) { |
| Map<String, Object> resultMap = (Map) result; |
| Set<String> keys = resultMap.keySet(); |
| for (String key : keys) { |
| Object currentValue = resultMap.get(key); |
| if (currentValue != null) { |
| properties.put(SAVED_ITEM_PREFIX + key, currentValue); |
| } |
| } |
| } |
| AnalyticsUtils.trackWithCurrentBlogDetails( |
| AnalyticsTracker.Stat.SITE_SETTINGS_SAVED_REMOTELY, properties); |
| } |
| } |
| |
| @Override |
| public void onFailure(long id, final Exception error) { |
| notifySavedOnUiThread(error); |
| } |
| }; |
| final Object[] callParams = { |
| mBlog.getRemoteBlogId(), mSettings.username, mSettings.password, params |
| }; |
| |
| XMLRPCClientInterface xmlrpcInterface = instantiateInterface(); |
| if (xmlrpcInterface == null) return; |
| xmlrpcInterface.callAsync(callback, Method.SET_OPTIONS, callParams); |
| } |
| |
| /** |
| * Request remote site data via XML-RPC. |
| */ |
| @Override |
| protected void fetchRemoteData() { |
| new Thread() { |
| @Override |
| public void run() { |
| Object[] params = {mBlog.getRemoteBlogId(), mBlog.getUsername(), mBlog.getPassword()}; |
| |
| // Need two interfaces or the first call gets aborted |
| instantiateInterface().callAsync(mOptionsCallback, Method.GET_OPTIONS, params); |
| instantiateInterface().callAsync(mCategoriesCallback, Method.GET_CATEGORIES, params); |
| } |
| }.start(); |
| } |
| |
| /** |
| * Handles response to fetching self-hosted site categories via XML-RPC. |
| */ |
| private final XMLRPCCallback mCategoriesCallback = new XMLRPCCallback() { |
| @Override |
| public void onSuccess(long id, Object result) { |
| if (result instanceof Object[]) { |
| AppLog.d(AppLog.T.API, "Received Categories XML-RPC response."); |
| credentialsVerified(true); |
| |
| mRemoteSettings.localTableId = mBlog.getRemoteBlogId(); |
| deserializeCategoriesResponse(mRemoteSettings, (Object[]) result); |
| mSettings.categories = mRemoteSettings.categories; |
| SiteSettingsTable.saveCategories(mSettings.categories); |
| notifyUpdatedOnUiThread(null); |
| } else { |
| // Response is considered an error if we are unable to parse it |
| AppLog.w(AppLog.T.API, "Error parsing Categories XML-RPC response: " + result); |
| notifyUpdatedOnUiThread(new XMLRPCException("Unknown response object")); |
| } |
| } |
| |
| @Override |
| public void onFailure(long id, Exception error) { |
| AppLog.w(AppLog.T.API, "Error Categories XML-RPC response: " + error); |
| notifyUpdatedOnUiThread(error); |
| } |
| }; |
| |
| /** |
| * Handles response to fetching self-hosted site options via XML-RPC. |
| */ |
| private final XMLRPCCallback mOptionsCallback = new XMLRPCCallback() { |
| @Override |
| public void onSuccess(long id, final Object result) { |
| if (result instanceof Map) { |
| AppLog.d(AppLog.T.API, "Received Options XML-RPC response."); |
| |
| if (!versionSupported((Map) result) && mActivity != null) { |
| notifyUpdatedOnUiThread(new XMLRPCException(mActivity.getString(R.string.site_settings_unsupported_version_error))); |
| return; |
| } |
| |
| credentialsVerified(true); |
| |
| deserializeOptionsResponse(mRemoteSettings, (Map) result); |
| |
| // postFormats setting is not returned by this api call so copy it over |
| final Map<String, String> currentPostFormats = mSettings.postFormats; |
| |
| mSettings.copyFrom(mRemoteSettings); |
| |
| mSettings.postFormats = currentPostFormats; |
| |
| SiteSettingsTable.saveSettings(mSettings); |
| notifyUpdatedOnUiThread(null); |
| } else { |
| // Response is considered an error if we are unable to parse it |
| AppLog.w(AppLog.T.API, "Error parsing Options XML-RPC response: " + result); |
| notifyUpdatedOnUiThread(new XMLRPCException("Unknown response object")); |
| } |
| } |
| |
| @Override |
| public void onFailure(long id, final Exception error) { |
| AppLog.w(AppLog.T.API, "Error Options XML-RPC response: " + error); |
| notifyUpdatedOnUiThread(error); |
| } |
| }; |
| |
| private boolean versionSupported(Map map) { |
| String version = getNestedMapValue(map, SOFTWARE_VERSION_KEY); |
| if (TextUtils.isEmpty(version)) return false; |
| String[] split = version.split("\\."); |
| return split.length > 0 && |
| Integer.valueOf(split[0]) >= REQUIRED_MAJOR_VERSION && |
| Integer.valueOf(split[1]) >= REQUIRED_MINOR_VERSION; |
| } |
| |
| private Map<String, String> serializeSelfHostedParams() { |
| Map<String, String> params = new HashMap<>(); |
| |
| if (mSettings.title != null && !mSettings.title.equals(mRemoteSettings.title)) { |
| params.put(BLOG_TITLE_KEY, mSettings.title); |
| } |
| if (mSettings.tagline != null && !mSettings.tagline.equals(mRemoteSettings.tagline)) { |
| params.put(BLOG_TAGLINE_KEY, mSettings.tagline); |
| } |
| if (mSettings.privacy != mRemoteSettings.privacy) { |
| params.put(PRIVACY_KEY, String.valueOf(mSettings.privacy)); |
| } |
| if (mSettings.defaultCategory != mRemoteSettings.defaultCategory) { |
| params.put(DEF_CATEGORY_KEY, String.valueOf(mSettings.defaultCategory)); |
| } |
| if (mSettings.defaultPostFormat != null && !mSettings.defaultPostFormat.equals(mRemoteSettings.defaultPostFormat)) { |
| params.put(DEF_POST_FORMAT_KEY, mSettings.defaultPostFormat); |
| } |
| if (mSettings.allowComments != mRemoteSettings.allowComments) { |
| params.put(ALLOW_COMMENTS_KEY, String.valueOf(mSettings.allowComments)); |
| } |
| if (mSettings.sendPingbacks != mRemoteSettings.sendPingbacks) { |
| params.put(SEND_PINGBACKS_KEY, mSettings.sendPingbacks ? "1" : "0"); |
| } |
| if (mSettings.receivePingbacks != mRemoteSettings.receivePingbacks) { |
| params.put(RECEIVE_PINGBACKS_KEY, mSettings.receivePingbacks ? OPTION_ALLOWED : OPTION_DISALLOWED); |
| } |
| if (mSettings.commentApprovalRequired != mRemoteSettings.commentApprovalRequired) { |
| params.put(COMMENT_MODERATION_KEY, String.valueOf(mSettings.commentApprovalRequired)); |
| } |
| if (mSettings.closeCommentAfter != mRemoteSettings.closeCommentAfter) { |
| if (mSettings.closeCommentAfter <= 0) { |
| params.put(CLOSE_OLD_COMMENTS_KEY, String.valueOf(0)); |
| } else { |
| params.put(CLOSE_OLD_COMMENTS_KEY, String.valueOf(1)); |
| params.put(CLOSE_OLD_COMMENTS_DAYS_KEY, String.valueOf(mSettings.closeCommentAfter)); |
| } |
| } |
| if (mSettings.sortCommentsBy != mRemoteSettings.sortCommentsBy) { |
| if (mSettings.sortCommentsBy == ASCENDING_SORT) { |
| params.put(COMMENT_SORT_ORDER_KEY, "asc"); |
| } else if (mSettings.sortCommentsBy == DESCENDING_SORT) { |
| params.put(COMMENT_SORT_ORDER_KEY, "desc"); |
| } |
| } |
| if (mSettings.threadingLevels != mRemoteSettings.threadingLevels) { |
| if (mSettings.threadingLevels <= 1) { |
| params.put(THREAD_COMMENTS_KEY, String.valueOf(0)); |
| } else { |
| params.put(PAGE_COMMENTS_KEY, String.valueOf(1)); |
| params.put(THREAD_COMMENTS_DEPTH_KEY, String.valueOf(mSettings.threadingLevels)); |
| } |
| } |
| if (mSettings.commentsPerPage != mRemoteSettings.commentsPerPage) { |
| if (mSettings.commentsPerPage <= 0) { |
| params.put(PAGE_COMMENTS_KEY, String.valueOf(0)); |
| } else{ |
| params.put(PAGE_COMMENTS_KEY, String.valueOf(1)); |
| params.put(PAGE_COMMENT_COUNT_KEY, String.valueOf(mSettings.commentsPerPage)); |
| } |
| } |
| if (mSettings.commentsRequireIdentity != mRemoteSettings.commentsRequireIdentity) { |
| params.put(REQUIRE_IDENTITY_KEY, String.valueOf(mSettings.commentsRequireIdentity ? 1 : 0)); |
| } |
| if (mSettings.commentsRequireUserAccount != mRemoteSettings.commentsRequireUserAccount) { |
| params.put(REQUIRE_USER_ACCOUNT_KEY, String.valueOf(mSettings.commentsRequireUserAccount ? 1 : 0)); |
| } |
| if (mSettings.commentAutoApprovalKnownUsers != mRemoteSettings.commentAutoApprovalKnownUsers) { |
| params.put(WHITELIST_KNOWN_USERS_KEY, String.valueOf(mSettings.commentAutoApprovalKnownUsers)); |
| } |
| if (mSettings.maxLinks != mRemoteSettings.maxLinks) { |
| params.put(MAX_LINKS_KEY, String.valueOf(mSettings.maxLinks)); |
| } |
| if (mSettings.holdForModeration != null && !mSettings.holdForModeration.equals(mRemoteSettings.holdForModeration)) { |
| StringBuilder builder = new StringBuilder(); |
| for (String key : mSettings.holdForModeration) { |
| builder.append(key); |
| builder.append("\n"); |
| } |
| if (builder.length() > 1) { |
| params.put(MODERATION_KEYS_KEY, builder.substring(0, builder.length() - 1)); |
| } else { |
| params.put(MODERATION_KEYS_KEY, ""); |
| } |
| } |
| if (mSettings.blacklist != null && !mSettings.blacklist.equals(mRemoteSettings.blacklist)) { |
| StringBuilder builder = new StringBuilder(); |
| for (String key : mSettings.blacklist) { |
| builder.append(key); |
| builder.append("\n"); |
| } |
| if (builder.length() > 1) { |
| params.put(BLACKLIST_KEYS_KEY, builder.substring(0, builder.length() - 1)); |
| } else { |
| params.put(BLACKLIST_KEYS_KEY, ""); |
| } |
| } |
| |
| return params; |
| } |
| |
| /** |
| * Sets values from a self-hosted XML-RPC response object. |
| */ |
| private void deserializeOptionsResponse(SiteSettingsModel model, Map response) { |
| if (mBlog == null || response == null) return; |
| |
| model.username = mBlog.getUsername(); |
| model.password = mBlog.getPassword(); |
| model.address = getNestedMapValue(response, BLOG_URL_KEY); |
| model.title = getNestedMapValue(response, BLOG_TITLE_KEY); |
| model.tagline = getNestedMapValue(response, BLOG_TAGLINE_KEY); |
| model.privacy = Integer.valueOf(getNestedMapValue(response, PRIVACY_KEY)); |
| model.defaultCategory = Integer.valueOf(getNestedMapValue(response, DEF_CATEGORY_KEY)); |
| model.defaultPostFormat = getNestedMapValue(response, DEF_POST_FORMAT_KEY); |
| model.allowComments = OPTION_ALLOWED.equals(getNestedMapValue(response, ALLOW_COMMENTS_KEY)); |
| model.receivePingbacks = OPTION_ALLOWED.equals(getNestedMapValue(response, RECEIVE_PINGBACKS_KEY)); |
| String sendPingbacks = getNestedMapValue(response, SEND_PINGBACKS_KEY); |
| String approvalRequired = getNestedMapValue(response, COMMENT_MODERATION_KEY); |
| String identityRequired = getNestedMapValue(response, REQUIRE_IDENTITY_KEY); |
| String accountRequired = getNestedMapValue(response, REQUIRE_USER_ACCOUNT_KEY); |
| String knownUsers = getNestedMapValue(response, WHITELIST_KNOWN_USERS_KEY); |
| model.sendPingbacks = !TextUtils.isEmpty(sendPingbacks) && Integer.valueOf(sendPingbacks) > 0; |
| model.commentApprovalRequired = !TextUtils.isEmpty(approvalRequired) && Boolean.valueOf(approvalRequired); |
| model.commentsRequireIdentity = !TextUtils.isEmpty(identityRequired) && Integer.valueOf(identityRequired) > 0; |
| model.commentsRequireUserAccount = !TextUtils.isEmpty(accountRequired) && Integer.valueOf(identityRequired) > 0; |
| model.commentAutoApprovalKnownUsers = !TextUtils.isEmpty(knownUsers) && Boolean.valueOf(knownUsers); |
| model.maxLinks = Integer.valueOf(getNestedMapValue(response, MAX_LINKS_KEY)); |
| mRemoteSettings.holdForModeration = new ArrayList<>(); |
| mRemoteSettings.blacklist = new ArrayList<>(); |
| |
| String modKeys = getNestedMapValue(response, MODERATION_KEYS_KEY); |
| if (modKeys.length() > 0) { |
| Collections.addAll(mRemoteSettings.holdForModeration, modKeys.split("\n")); |
| } |
| String blacklistKeys = getNestedMapValue(response, BLACKLIST_KEYS_KEY); |
| if (blacklistKeys.length() > 0) { |
| Collections.addAll(mRemoteSettings.blacklist, blacklistKeys.split("\n")); |
| } |
| |
| String close = getNestedMapValue(response, CLOSE_OLD_COMMENTS_KEY); |
| if (!TextUtils.isEmpty(close) && Boolean.valueOf(close)) { |
| mRemoteSettings.closeCommentAfter = Integer.valueOf(getNestedMapValue(response, CLOSE_OLD_COMMENTS_DAYS_KEY)); |
| } else { |
| mRemoteSettings.closeCommentAfter = 0; |
| } |
| |
| String thread = getNestedMapValue(response, THREAD_COMMENTS_KEY); |
| if (!TextUtils.isEmpty(thread) && Integer.valueOf(thread) > 0) { |
| mRemoteSettings.threadingLevels = Integer.valueOf(getNestedMapValue(response, THREAD_COMMENTS_DEPTH_KEY)); |
| } else { |
| mRemoteSettings.threadingLevels = 0; |
| } |
| |
| String page = getNestedMapValue(response, PAGE_COMMENTS_KEY); |
| if (!TextUtils.isEmpty(page) && Boolean.valueOf(page)) { |
| mRemoteSettings.commentsPerPage = Integer.valueOf(getNestedMapValue(response, PAGE_COMMENT_COUNT_KEY)); |
| } else { |
| mRemoteSettings.commentsPerPage = 0; |
| } |
| |
| if (getNestedMapValue(response, COMMENT_SORT_ORDER_KEY).equals("asc")) { |
| mRemoteSettings.sortCommentsBy = ASCENDING_SORT; |
| } else { |
| mRemoteSettings.sortCommentsBy = DESCENDING_SORT; |
| } |
| } |
| |
| private void deserializeCategoriesResponse(SiteSettingsModel model, Object[] response) { |
| model.categories = new CategoryModel[response.length]; |
| |
| for (int i = 0; i < response.length; ++i) { |
| if (response[i] instanceof Map) { |
| Map category = (Map) response[i]; |
| CategoryModel categoryModel = new CategoryModel(); |
| categoryModel.id = MapUtils.getMapInt(category, BLOG_CATEGORY_ID_KEY); |
| categoryModel.parentId = MapUtils.getMapInt(category, BLOG_CATEGORY_PARENT_ID_KEY); |
| categoryModel.description = MapUtils.getMapStr(category, BLOG_CATEGORY_DESCRIPTION_KEY); |
| categoryModel.name = MapUtils.getMapStr(category, BLOG_CATEGORY_NAME_KEY); |
| model.categories[i] = categoryModel; |
| } |
| } |
| } |
| |
| /** |
| * Helper method to get a value from a nested Map. Used to parse self-hosted response objects. |
| */ |
| private String getNestedMapValue(Map map, String key) { |
| if (map != null && key != null) { |
| return MapUtils.getMapStr((Map) map.get(key), "value"); |
| } |
| |
| return ""; |
| } |
| } |
