View difference between Paste ID: anvJEn54 and CMuUhESw

 import ClientAppService from "./system/ClientAppService";
 
 // Data Models
 import XError from "./core/model/XError";
 import XRequest from "./core/model/net/XRequest";
 import XResponse from "./core/model/net/XResponse";
 import XObject from "./core/model/XObject";
 import XMObject from "./core/model/XMObject";
 import XResultList from "./core/model/util/XResultList";
 import XResultMap from "./core/model/util/XResultMap";
 import XBinaryData from "./core/model/XBinaryData";
 import {
   ModelType,
   MessageProps,
   UserProps,
   LanguageCodes,
   SocialProps,
   PREFIX_COMMENT_ID,
   TOPIC_CATEGORIES,
   FEATURE_LIKE,
   FEATURE_FOLLOW_USER,
   FEATURE_REPLY_POST,
   FEATURE_REPLY_COMMENT,
   FEATURE_REPOST,
   FEATURE_SUBMIT_POST,
 } from "./core/model/ModelConsts";
 import {XMFollows, XMFollowers} from "./core/model/social/XMFollow";
 import Util from "./core/Util";
 import axios from "axios";
 
 import XMWatchesPost from "./core/model/post/XMWatchesPost";
 import XMWatchedPost from "./core/model/post/XMWatchedPost";
 import XPostFeed from "./core/model/activity/XPostFeed";
 import XMPost from "./core/model/post/XMPost";
 import {AppMessages, SupportedLanguageList} from "./app/AppMessages";
 import XUserInfo from "./core/model/user/XUserInfo";
 import XCommentFeed from "./core/model/post/XCommentFeed";
 import XMComment from "./core/model/social/XMComment";
 import API from "./core/API";
 import ErrorCodes from "./core/ErrorCodes";
 import {fileToMd5} from "src/util/file";
 
 // These are classes that we have instances but not direct type
 // reference. They are good for IDE/JSDoc and these are used to eliminate
 // the complaints
 XError.CheckIn();
 XResponse.CheckIn();
 XRequest.CheckIn();
 XBinaryData.CheckIn();
 XResultList.CheckIn();
 XResultMap.CheckIn();
 
 XPostFeed.CheckIn();
 XMPost.CheckIn();
 
 // import numeral from 'numeral';
 
 const _CLSNAME = "GetterService";
 
 /**
  * Application context / helper (controller, api requestor)
  * for the web app.
  *
  * There should be one instance per app type per user. With
  * SSR configuration, there will be one instance in the browser code,
  * and one on the server side.
  */
 export class GetterService extends ClientAppService {
   /**
    *
    * @constructor
    * @param {object} props outside (configuration) properties to use
    */
   constructor(props) {
     super(_CLSNAME, props);
 
     this.applyConfig(this.props);
   }
 
   applyConfig(props) {
     // const _m = "applyConfig";
     super.applyConfig(props);
 
     // let isBrowser = Global.IsBrowser();
     // this.log("applyConfig", "parameters: ", props);
 
     this.urlPrefix = props.urlPrefix ? props.urlPrefix : "/";
     this.appUrl = props.appUrl ? props.appUrl : null;
     this.appPrefix = this.appUrl ? this.appUrl + "/" : null;
 
     // this.trace(_m, `**** APP URL: ${this.appUrl} Is Browser: ${isBrowser} ****`);
 
     this.urlHost = props.apiHost ? props.apiHost : "http://255.255.255.255:999";
 
     this.title = props.title ? props.title : "Untitled App";
 
     this.urlTagInfo = this.getURL(this.urlHost, "/s/taginfo");
     this.urlActivityLog = this.getURL(this.urlHost, "/log/activity/");
     this.urlLogMessage = this.getURL(this.urlHost, "/log/msg");
   }
 
   /**
    * Initializer user info. This is called by Portal upon login.
    */
   initUser(userInfo) {
     // re-intialize analytics tracking
     this._trackingUser();
   }
 
   assertXMObject(value) {
     return this.assertType(value, XMObject);
   }
 
   /**
    * Reset user information. This is called by Portal upon logout.
    */
   resetUser() {
     // clear session?
   }
 
   /**
    * Return the application's official URL, as set in the environment
    * variable *_APP_URL. This is optional and only used for user click
    * backs.
    *
    * @param {*} defaultVal
    * @return {string=} application's url with protocol and port
    */
   getAppUrl(defaultVal = null) {
     return this.appUrl ? this.appUrl : defaultVal;
   }
 
   /**
    * Return the SPA's url prefix.
    */
   getUrlPrefix() {
     return this.urlPrefix;
   }
 
   /**
    * Prefix of this web application's URL, or a
    * complete URL if given path
    *
    * @param {string} path path to add to prefix
    * @return {string} either prefix, or complete URL if given path
    */
   getAppPrefix(path) {
     return path ? this.urlPrefix + path : this.urlPrefix;
   }
 
   /**
    * Prefix of this app's service URL to make API calls.
    *
    * @param {string} path path to add to prefix
    * @return {string} either prefix, or complete URL if given path
    */
   getServicePrefix(path) {
     return path ? new URL(path, this.urlHost).toString() : this.urlHost;
   }
 
   /**
    *
    * @param {string} phrase search phrase
    */
   getUrlSearchResults(phrase) {
     let url = this.getAppPrefix("search");
     if (!Util.StringIsEmpty(url)) url += `?q=` + encodeURIComponent(phrase);
     return url;
   }
 
   getUrlHashtagPage(hashtag) {
     if (hashtag[0] !== "#") {
       hashtag = "/hashtag/" + encodeURIComponent("#" + hashtag);
     } else {
       hashtag = "/hashtag/" + encodeURIComponent(hashtag);
     }
     return hashtag;
   }
 
   getUrlUsertagPage(userId) {
     if (userId[0] === "@") userId = userId.substring(1);
     return `/user/${userId}`;
   }
 
   getUrlPostPage(postId) {
     return this.getAppPrefix(`post/${postId}`);
   }
 
   getUrlCommentPage(commentId) {
     return this.getAppPrefix(`comment/${commentId}`);
   }
 
   getUrlUserProfilePage(username) {
     return this.getAppPrefix(`user/${username}`);
   }
 
   getUrlNotificationsAll() {
     return this.getAppPrefix(`notifications`);
   }
 
   getUrlNotificationsMentions() {
     return this.getAppPrefix(`notifications/mentions`);
   }
 
   /**
    * Explore URL: /explore or /explore/topic/:topic
    *
    * @param {string} topic topic to get results from server
    */
   getUrlExplore(topic) {
     let url = Util.StringIsEmpty(topic) ? "explore" : "explore/topic/" + topic;
     return this.getAppPrefix(url);
   }
 
   getUrlHome() {
     return this.getAppPrefix("");
   }
 
   getUrlLogin() {
     return this.getAppPrefix("login");
   }
 
   getUrlLogout() {
     return this.getAppPrefix("logout");
   }
 
   getUrlSignup() {
     return this.getAppPrefix("signup");
   }
 
   getUrlDashboard() {
     return this.getAppPrefix("");
   }
 
   getUrlWelcome() {
     return this.getAppPrefix("welcome");
   }
 
   getUrlNotFound() {
     return this.getAppPrefix("notfound");
   }
 
   // ----------------------- API URL Constructions ------------------------------
 
   /**
    * Construct API endpoint url for retrieving stats on an object
    *
    * @param {string} type object type. This may not match ModelType constants,
    * so best to look up the endpoint. For example, ModelType.COMMENT is "cm"
    * while the endpoint uses "comment" as in /u/comment/:commentId/...
    * @param {string[]} objectId
    * @param {boolean} inclObj true to also fetch and return the XObject instance
    * @return {string} derived URL
    */
   apiGetObjectStats(type, objectId, inclObj = false) {
     if (!objectId) {
       this.error("apiGetObjectStats", "no tagnames given");
       return;
     }
 
     let query = this.getURL(this.urlHost, `/s/${type}/${objectId}/stats/`);
     if (inclObj === true) query += `?${API.INCL_OBJ}=true`;
 
     return query;
   }
 
   /**
    * Construct API URL for GetUserSettings
    *
    * @param {string[]} userId in array or delimited by comma
    * @param {string[]} props field names in array or delimited by comma
    */
   apiGetUserSettings(userId, section, props = null) {
     if (!userId || !section) {
       console.error("apiGUS: ?null");
       return;
     }
 
     if (props != null) props = Array.isArray(props) ? props.join(",") : props;
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/settings/${section}`,
     );
     if (props) query += "?props=" + JSON.stringify(props);
 
     return query;
   }
 
   // ------------------------- LANGUAGE SUPPORT --------------------------
 
   getSupportedLanguageCodes() {
     return [LanguageCodes.ENGLISH, LanguageCodes.CHINESE_SIMPLIFIED];
   }
 
   /**
    * Return entire language list of supported languages, or just the
    * record of the desired language code
    *
    * @param {string} langCode
    * @param {string=} defaultVal optional backup language. Default will be English
    * @return {object[]} either full language map keyed off code, or the record
    * for the given code
    */
   getSupportedLanguageList(langCode = null, defaultVal = null) {
     let langList = SupportedLanguageList;
     let result;
     if (langCode) {
       result = Util.GetObjectFromArrayByValue(langList, "code", langCode);
       if (result == null) {
         if (defaultVal == null) defaultVal = LanguageCodes.ENGLISH;
         result = Util.GetObjectFromArrayByValue(langList, "code", defaultVal);
       }
     } else result = langList;
     return result;
   }
 
   /**
    * Return current locale (language + country)
    *
    * @param {*} defaultVal
    * @return {string} "en" for now
    */
   getLanguagePref(defaultVal = "en") {
     let lang = this.getSessionVar(UserProps.LANGUAGE, null);
     if (lang == null) {
       let xUserInfo = this.getXUserInfo();
       lang = xUserInfo ? xUserInfo.getLanguagePref(defaultVal) : defaultVal;
     }
     return lang;
   }
 
   /**
    *
    * @param {string} langCode language code
    * @return {boolean} true if set, false if something happened
    */
   setLanguagePref(langCode, sessionOnly = true) {
     if (langCode == null) return false;
     let prevCode = this.setSessionVar(UserProps.LANGUAGE, langCode);
     if (prevCode !== langCode) {
       let xUserInfo = new XUserInfo();
       xUserInfo.setLanguagePref(langCode);
       this.updateUserInfo(xUserInfo);
     }
     return true;
   }
 
   // ------------------------- NOTIFICATION -----------------------------
 
   /**
    * Construct API URL for user alert count (/u/user/:userId/count/alerts/:targetId)
    *
    * @param {string} userId user of the alerts (logged in currently)
    * @param {string} field field to retrieve (default is unread)
    * @return {string} fully qualified URL
    */
   apiUserAlertCount(userId, field = "unread", props = null) {
     if (!userId) {
       this.error("apiUserAlertCount", "no userId or targetId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/count/alerts/${field}`,
     );
     if (props) query += "&props=" + JSON.stringify(props);
 
     return query;
   } // apiUserAlertCount
 
   /**
    * Construct API URL for user alerts (/uuser/:userId/alerts
    *
    * @param {string} userId user for alerts (logged in currently)
    * @param {string} field field to retrieve (default is unread)
    * @param {number} max maximum number of alerts to retrieve
    * @return {string} fully qualified URL
    */
   apiUserAlerts(userId, field = "", max = 20, props = null) {
     if (!userId) {
       this.error("apiUserAlert", "no userId or targetId given");
       return false;
     }
 
     if (props == null) props = {};
     props[API.BATCH_SIZE] = max;
 
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/user/${userId}/alerts/${field}`);
     if (props) query += "?props=" + JSON.stringify(props);
 
     return query;
   } // apiUserAlerts
 
   /**
    * Construct API URL for user alerts status (/u/user/:userId/alerts/status/)
    *
    * @param {string} userId alerts for user (logged in currently)
    * @param {string[]} alertIds array if Ids to check/get. Note this
    * is mostly likely in the body using POST
    * @return {string} fully qualified URL
    */
   apiUserAlertsStatus(userId, alertIds = null) {
     if (!userId) {
       return false;
     }
     let idString = alertIds ? alertIds.join(",") : null;
 
     let query = this.getURL(this.urlHost, `/u/user/${userId}/alerts/status/`);
     if (idString) query += "?ids=" + idString;
 
     return query;
   } // apiUserAlertsStats
 
   /**
    * Construct API URL for confirmation by Id
    *
    * @param {string} confirmId alerts for user (logged in currently)
    * @param {string} sourceId array if Ids to check/get. Note this
    * is mostly likely in the body using POST
    * @return {string} fully qualified URL
    */
   apiConfirmById(confirmId, sourceId) {
     if (!confirmId) {
       this.error("apiCBI");
       return false;
     }
     let query = this.getURL(this.urlHost, `/s/confirm/${confirmId}`);
     if (sourceId) query = `${query}/src/${sourceId}`;
 
     return query;
   } // apiConfirmById
 
   // ---------------------------- FEED -----------------------------------
 
   /**
    * Add parameters to given URL related to batch fetching.
    *
    * @param {string} url
    * @param {number} offset if null then set to zero
    * @param {number} max maximum to return in this batch size
    * @param {number} startTime point in time as starting point for fetch in either direction
    * @param {string} direction fetch direction. Either API.DIRECTION_FORWARD or API.DIRECTION_BACKWARD
    * @param {string=} starter default to '?' and assume no other params already (dumb, I know)
    */
   appendFetchParams(
     url,
     offset,
     max,
     startTime,
     direction,
     starter,
     isComment = false,
   ) {
     if (offset == null) offset = 0;
 
     if (starter == null) starter = "?";
     url += `?${API.OFFSET}=${offset}`;
     if (max) url += `&${API.BATCH_SIZE}=${max}`;
     if (startTime) url += `&${API.START_TS}=${startTime}`;
     if (direction) url += `&${API.DIRECTION}=${direction}`;
     url += `&incl=posts|stats|userinfo|shared|liked`;
     return url;
   }
 
   // ------------------------ FOLLOW API URL -----------------------------
 
   /**
    * Construct API URL for user follows (/u/:userId/follows/:targetId)
    *
    * @param {string} userId ID of following user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiAddFollows(userId, targetId, props = null) {
     if (!targetId) {
       this.error("apiAddFollows", "no userId or targetId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/follows/${targetId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // addFollows
 
   /**
    * Construct API URL for user follows (/u/:userId/follows/:targetId)
    *
    * @param {string} userId ID of following user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiUserFollowStatus(userId, targetId, props = null) {
     if (!targetId || !userId) {
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/follows/${targetId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetUserFollowStatus
 
   /**
    * Construct API URL for user followers (/u/:userId/follows/:targetId)
    *
    * @param {string} userId ID of following user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiUserFollowerStatus(userId, followerId, props = null) {
     if (!userId && !followerId) {
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${followerId}/follows/${userId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetUserFollowStatus
 
   /**
    * Construct API URL for retrieving follows (/u/:userId/follows/)
    *
    * @param {string} userId ID of users follows currently logged in
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiGetFollows(userId, props = null) {
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/user/${userId}/followings/`);
     if (props) query += "&props=" + props;
 
     return query;
   } // getFollows
 
   /**
    * Construct API URL for retrieving follows (/u/:userId/followers/)
    *
    * @param {string} userId ID to retrieve followers for
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiGetFollowers(userId, props = null) {
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/user/${userId}/followers/`);
     if (props) query += "&props=" + props;
 
     return query;
   } // getFollows
 
   /**
    * Construct API URL for user follows (/u/:userId/follows/:targetId)
    *
    * @param {string} userId ID of following user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    *
    * @see #apiAddFollows
    * @see #apiGetFollows
    * @see #apiRemoveFollows
    */
   apiRemoveFollows(userId, targetId, props = null) {
     if (!targetId) {
       this.error("apiRemoveFollows", "no userId or targetId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/unfollows/${targetId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiRemoveFollows
 
   /**
    * Construct API URL for user follows (/u/:userId/blocks/:targetId)
    *
    * @param {string} userId ID to block follower user (logged in currently)
    * @param {string} followerId follower to block
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiBlockFollower(userId, followerId, props = null) {
     if (!followerId) {
       this.error("apiBlockFollower", "no userId or followerId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/blocks/${followerId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiBlockFollower
 
   /**
    * Construct API URL for user follows (/u/:userId/unblocks/:targetId)
    *
    * @param {string} userId ID to block follower user (logged in currently)
    * @param {string} followerId follower to block
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiUnblockFollower(userId, followerId, props = null) {
     if (!followerId) {
       this.error("apiUnblockFollower", "no userId or followerId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/unblocks/${followerId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiUnblockFollower
 
   /**
    * Construct API URL to mute (/u/:userId/mutes/:targetId)
    *
    * @param {string} userId ID to mute user (logged in currently)
    * @param {string} followerId user to mute
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiMuteFollower(userId, followerId, props = null) {
     if (!followerId) {
       this.error("apiMuteFollower", "no userId or followerId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/mutes/${followerId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiMuteFollower
 
   /**
    * Construct API URL to unmute (/u/:userId/unmutes/:targetId)
    *
    * @param {string} userId ID to unmute user (logged in currently)
    * @param {string} followerId user to unmute
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiUnmuteFollower(userId, followerId, props = null) {
     if (!followerId) {
       this.error("apiUnmuteFollower", "no userId or followerId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/unmutes/${followerId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiUnmuteFollower
 
   // ------------------------ LIKE OBJECT API URL -----------------------------
 
   /**
    * Construct API URL for user like (/u/user/:userId/likes/{type}/:objectId)
    *
    *
    * @param {string} userId
    * @param {string} type object type (see ModelType)
    * @param {string} objectId
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiAddLikeObject(userId, type, objectId, props = null) {
     if (!objectId) {
       this.error("apiAddLikeObj", "no userId or objectId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/likes/${type}/${objectId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiAddLikeObject
 
   /**
    * Construct API URL for user likes (/u/user/:userId/likes/{type}/:objectId)
    *e
    * @param {string} userId ID of liking user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiUserLikeObjectStatus(userId, type, objectId, props = null) {
     if (!objectId || !userId) {
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/likes/${type}/${objectId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetUserLikeObjectStatus
 
   /**
    * Construct API URL for retrieving follows (/u/:userId/likes/rl)
    *
    * @param {string} userId ID of users follows currently logged in
    * @param {string} type object type (see ModelType)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiGetLikesObject(userId, type, props = null) {
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/user/${userId}/likes/${type}/`);
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetLikesObject
 
   /**
    * Construct API URL for retrieving follows (/u/:type/:objectId/liked/)
    *
    * @param {string} type object type (see ModelType)
    * @param {string} objectId ID to retrieve likes for
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiGetLikedObject(type, objectId, props = null) {
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/${type}/${objectId}/liked/`);
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetLikedPost
 
   /**
    * Construct API URL for user follows (/u/:userId/unlike/:type/:objectId)
    *
    * @param {string} userId ID of following user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    *
    * @see #apiAddLikesRL
    * @see #apiGetLikesRL
    */
   apiRemoveLikeObject(userId, type, objectId, props = null) {
     if (!objectId) {
       this.error("apiRmLikeObject", "no userId or objectId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/unlike/${type}/${objectId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiRemoveLikeObject
 
   // ------------------------ LIKE POST API URL -----------------------------
 
   /**
    * Construct API URL for user follows (/u/user/:userId/likes/rl/:postId)
    *
    * @param {string} userId ID of following user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiAddLikePost(userId, postId, props = null) {
     return this.apiAddLikeObject(userId, ModelType.POST, postId, props);
     // if (!postId) {
     //   this.error("apiAddLikePost", "no userId or postId given");
     //   return false;
     // }
     // props = Array.isArray(props) ? props.join(",") : props;
 
     // let query = this.getURL( this.urlHost, `/u/user/${userId}/likes/post/${postId}`);
     // if (props) query += "&props=" + props;
 
     // return query;
   } // apiAddLikePost
 
   /**
    * Construct API URL for user likes (/u/user/:userId/likes/post/:postId)
    *
    * @param {string} userId ID of liking user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiUserLikePostStatus(userId, postId, props = null) {
     if (!postId || !userId) {
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/likes/post/${postId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetUserLikePostStatus
 
   /**
    * Construct API URL for retrieving follows (/u/:userId/likes/post)
    *
    * @param {string} userId ID of users follows currently logged in
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiGetLikesPost(userId, props = null) {
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/user/${userId}/likes/post/`);
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetLikesPost
 
   /**
    * Construct API URL for retrieving follows (/u/:userId/followers/)
    *
    * @param {string} postId ID to retrieve post
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiGetLikedPost(postId, props = null) {
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/post/${postId}/liked/`);
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetLikedRL
 
   /**
    * Construct API URL for user follows (/u/:userId/unlike/rl/:postId)
    *
    * @param {string} userId ID doing the like removal
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    *
    * @see #apiAddLikesPost
    * @see #apiGetLikesPost
    */
   apiRemoveLikePost(userId, postId, props = null) {
     if (!postId) {
       this.error("apiRemoveLikePost", "no userId or post given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/unlike/post/${postId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiRemoveLikePost
 
   // ------------------------- SHARE API -------------------------------
 
   /**
    * Construct API URL for user shares (/u/user/:userId/likes/:type/:objectId)
    *
    * @param {string} userId ID of sharing user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiUserShareObjectStatus(userId, type, objectId, props = null) {
     if (!objectId || !userId) {
       return false;
     }
     if (type == null) {
       this.error("apiGetUserShareStatus", "null type");
       this.trace();
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/shares/${type}/${objectId}`, // deprecated - remove in 2021
       // `/u/user/${userId}/shares/${type}/${objectId}`,  // use this in 2021
     );
     if (props) query += "&props=" + props;
 
     return query;
   } // apiGetUserShareObjectStatus
 
   /**
    *
    * @param {XMObject} xmObject
    *
    * @return {boolean}
    */
   userCanShare(xmObject) {
     // let userId = this.getUserId();
 
     if (xmObject.hasACL() === false) return true;
 
     return true;
   }
 
   // ------------------------- USER SHARE SERVICES ------------------------------
 
   /**
    * Submit sharing of a post. "Sharing" in this csae is basically
    * a "repost" without any added content. This mean it is
    * literally a share. Standard POST is used.
    *
    * For reposting with user's own content, use userRepost()
    *
    * @param {string} postId post to share by logged in user
    * @param {string} text additional text from reposter
    *
    * @return {string} updated share status "y" or "n"
    *
    * @see ~SubmitRepost
    */
   async userSharesPost(postId, text, callback) {
     const _m = "userSharesPost";
 
     let loggedInUserId = this.getUserId();
     let shareStatus;
     let error = null;
     try {
       let getUrl = this.getURL(
         this.urlHost,
         `/u/user/${loggedInUserId}/shares/post/${postId}`,
       );
       let content = {
         text: text,
       };
       shareStatus = await this.requestPOST(getUrl, content);
     } catch (e) {
       this.error(_m, e);
       error = e;
       shareStatus = null;
     }
 
     return callback ? callback(error, shareStatus) : shareStatus;
   } // userSharesPost
 
   /**
    * remove shares.
    *
    *
    * @param {string} postId  postItem id
    *
    * @return {string} updated share status "y" or "n"
    *
    * @see ~SubmitRepost
    */
   async userUnshares(postId, action, callback) {
     const _m = "userUnsharesPost";
 
     let loggedInUserId = this.getUserId();
     let unshareStatus;
     let error = null;
     try {
       let getUrl = this.getURL(
         this.urlHost,
         `/u/user/${loggedInUserId}/shares/${
           action === "p" ? "post" : "comment"
         }/${postId}`,
       );
       unshareStatus = await this.requestDELETE(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       unshareStatus = null;
     }
 
     return callback ? callback(error, unshareStatus) : unshareStatus;
   } // userUnshares
 
   /**
    * Submit sharing of a comment. "Sharing" in this csae is basically
    * a "repost" without any added content. This mean it is
    * literally a share. Standard POST is used.
    *
    * For reposting with user's own content, use submitRepost()
    *
    * @param {string} commentId post to share by logged in user
    * @param {string} text additional text from reposter
    *
    * @return {string} updated share status "y" or "n"
    *
    * @see ~SubmitRepost
    */
   async userSharesComment(commentId, callback) {
     const _m = "userSharesComment";
 
     let loggedInUserId = this.getUserId();
     let shareStatus;
     let error = null;
     try {
       let getUrl = this.getURL(
         this.urlHost,
         `/u/user/${loggedInUserId}/shares/comment/${commentId}`,
       );
       let content = null;
       shareStatus = await this.requestPOST(getUrl, content);
     } catch (e) {
       this.error(_m, e);
       error = e;
       shareStatus = null;
     }
 
     return callback ? callback(error, shareStatus) : shareStatus;
   } // userSharesComment
 
   /**
    * Retrieve answer to whether the logged in user is sharing post
    *
    * @param {string[]} postId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return {string} "y" or "no"
    */
   async userSharePostStatus(postId, props = null, callback) {
     const _m = "userSharePostStatus";
 
     let statusValue = null;
     let error = null;
     let userId = this.getUserId();
     if (!postId || !userId) {
       return "no";
     }
     try {
       let url = this.apiUserShareObjectStatus(userId, "post", postId, props);
       statusValue = await this.requestGET(url, null);
     } catch (e) {
       this.error(_m, "server returned error:", e);
       error = e;
       statusValue = null;
     }
     return callback ? callback(error, statusValue) : statusValue;
   } // userSharePostStatus
 
   /**
    * Retrieve answer to whether the logged in user is sharing post
    *
    * @param {string[]} commentId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return {string} "y" or "no"
    */
   async userShareCommentStatus(commentId, props = null, callback) {
     const _m = "userShareCommentStatus";
 
     let statusValue = null;
     let error = null;
     let userId = this.getUserId();
     if (!commentId || !userId) {
       return "no";
     }
     try {
       let url = this.apiUserShareObjectStatus(
         userId,
         "comment",
         commentId,
         props,
       );
       statusValue = await this.requestGET(url, null);
     } catch (e) {
       this.error(_m, "server returned error:", e);
       error = e;
       statusValue = null;
     }
     return callback ? callback(error, statusValue) : statusValue;
   } // userShareCommentStatus
 
   // ------------------------ WATCH OBJECT API URLs -----------------------------
 
   /**
    * Construct API URL for user watching an object. The URL for this
    * API should be (POST): /u/user/:userId/watch/{type}/:objId
    *
    * @param {string} type object's type name (tag, rl, etc)
    * @param {string} userId ID of following user (logged in currently)
    * @param {string} objectId ID of object to watch
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiAddWatchObject(type, userId, objectId, props = null) {
     if (!objectId && !objectId) {
       this.error("apiAddWatchObj", "no userId or objId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/watch/${type}/${objectId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   }
 
   /**
    * Construct API URL for status of the object the user may be watching. The
    * URL for this API should be (GET): /u/user/:userId/watch/{type}/:objId
    *
    * @param {string} type object's type name (tag, rl, etc)
    * @param {string} userId ID of the user
    * @param {string} objectId ID of the object watched
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiUserWatchObjectStatus(type, userId, objectId, props = null) {
     if (!objectId || !type || !userId) {
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/watch/${type}/${objectId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   }
 
   /**
    * Construct API URL for retrieving follows (/u/:userId/watch/rl)
    *
    * @param {string} userId ID of users follows currently logged in
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiGetWatchesObject(type, userId, props = null) {
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/user/${userId}/watch/${type}/`);
     if (props) query += "&props=" + props;
 
     return query;
   }
 
   /**
    * Construct API URL for retrieving watchers (/u/:type/:objectId/watched/)
    *
    * @param {string} type object's type name (tag, rl, etc)
    * @param {string} objectId ID to retrieve followers for
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    */
   apiGetObjectWatchers(type, objectId, props = null) {
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(this.urlHost, `/u/${type}/${objectId}/watched/`);
     if (props) query += "&props=" + props;
 
     return query;
   }
 
   /**
    * Construct API URL for user follows (/u/:userId/unlike/:type/:objectId)
    *
    * @param {string} type object's type name (tag, rl, etc)
    * @param {string} userId ID of following user (logged in currently)
    * @param {string[]} props field names in array or delimited by comma
    * @return {string} fully qualified URL
    *
    */
   apiRemoveWatchObject(type, userId, objectId, props = null) {
     if (!objectId) {
       this.error("apiRmWatchObject", "no userId or objectId given");
       return false;
     }
     props = Array.isArray(props) ? props.join(",") : props;
 
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/unwatch/${type}/${objectId}`,
     );
     if (props) query += "&props=" + props;
 
     return query;
   }
 
   // -------------------------- Privilege Check ---------------------------
 
   userIsGod() {
     return this.portal.userIsGod();
   }
 
   /**
    * @return {boolean}
    */
   userHasAdminRole() {
     return this.portal.userHasAdminRole();
   }
 
   /**
    * @return {boolean}
    */
   userHasSysAdminRole() {
     return this.portal.userHasSysAdminRole();
   }
 
   userHasModeratorRole() {
     return this.portal.userHasModeratorRole();
   }
 
   /**
    * Not Used
    *
    * @return {boolean}
    */
   userHasPreviewFeatures() {
     return this.portal.userHasPreviewFeatures();
   }
 
   /**
    * @deprecated
    *
    * @return {boolean}
    */
   userHasSocialFeatures() {
     return true;
   }
 
   /**
    * @return {boolean}
    */
   userHasFeature(featureId) {
     return this.getSession().userHasFeature(featureId);
   }
 
   /**
    * @return {boolean}
    */
   userHasFeatureDisabled(featureId) {
     return this.getSession().userHasFeatureDisabled(featureId);
   }
 
   /**
    * @return {boolean}
    */
   userCanFollow() {
     return this.userHasFeature(FEATURE_FOLLOW_USER);
   }
 
   /**
    * @return {boolean}
    */
   userCanPost() {
     return this.userHasFeature(FEATURE_SUBMIT_POST);
   }
 
   /**
    * @return {boolean}
    */
   userCanRepost() {
     return this.userHasFeature(FEATURE_REPOST);
   }
 
   /**
    * @return {boolean}
    */
   userCanReplyPost() {
     return this.userHasFeature(FEATURE_REPLY_POST);
   }
 
   /**
    * @return {boolean}
    */
   userCanReplyComment() {
     return this.userHasFeature(FEATURE_REPLY_COMMENT);
   }
 
   /**
    * @return {boolean}
    */
   userCanLike() {
     return this.userHasFeature(FEATURE_LIKE);
   }
 
   /**
    * Determine if the given resource can be edited
    * by current logged in user.
    *
    * @param {XMObject} instance of XMObject subclass
    *
    * @return {boolean}
    */
   canEditResource(xmObject) {
     let isOwner = this.userIsOwner(xmObject);
     if (isOwner) return true;
 
     if (this.userHasModeratorRole()) return true;
 
     // ACL check - Future/TBD
 
     return false;
   } // canEditResource
 
   canShareResource(xmObject) {
     return true;
   }
 
   canDeleteResource(xmObject) {
     return this.canEditResource(xmObject);
   }
 
   canSubmitPost() {
     return this.userHasFeature(FEATURE_SUBMIT_POST);
   }
 
   // --------------------------------------------------------------------------
 
   /**
    * Determine if the given object's owner is the
    * logged in user.
    *
    * @param {XMObject} xmObject
    *
    * @return {booleaan}
    */
   userIsOwner(xmObject) {
     let loggedInUserId = this.getUserId();
     if (loggedInUserId == null) return false;
 
     let objectOwnerId = xmObject.getOwnerId();
 
     // simple check for now
     return loggedInUserId === objectOwnerId;
   } // userIsOwner
 
   trackContainer(container) {
     this.appContainer = container;
   }
 
   async refreshContainer() {
     if (this.appContainer) this.appContainer.refreshView(true);
   }
 
   /**
    * Retrieve stats on an object
    *
    * @param {string} type object type
    * @param {string[]} objectId
    * @param {boolean} inclObj also return the XObject for which the stats are for
    *
    * @return {XObjectStat, [XObject, XObjectStat]}
    */
   async fetchObjectStats(type, objectId, inclObj = false, callback) {
     const _m = "fetchObjectStatus";
 
     let result;
     let error = null;
     try {
       let apiUrl = this.apiGetObjectStats(type, objectId, inclObj);
       result = await this.requestGET(apiUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
     return callback ? callback(error, result) : result;
   } // fetchObjectStats
 
   // ----------------------- USER NEWS FEED --------------------------------
 
   /**
    * Fetch user timline using /u/user/:userId/timeline. Timeline includes
    * all user followings posts.
    *
    * @param {string} userId which user to retrieve posts for?
    * @param {number} offset offset into start position of the expected query
    * @param {number} size batch size
    * @param {number} startTS timestamp where the posts streaming should start
    * @callback (err, PostList)
    * @return {PostList}
    */
   async fetchUserTimeline(
     userId,
     offset = null,
     size = null,
     startTS,
     direction,
     callback,
   ) {
     let _m = `getUserTimeline(${userId})`;
     this.log(_m, `Fetching: offset=${offset}, max=${size}`);
     let err = null;
     let feedList;
     try {
       let url = this.getURL(this.urlHost, `/u/user/${userId}/timeline`);
       url = this.appendFetchParams(url, offset, size, startTS, direction);
       let result = await this.requestGET(url, null);
       feedList = XPostFeed.Wrap(result);
     } catch (e) {
       this.log(_m, e);
       if (callback == null) throw e;
     }
 
     return callback ? callback(err, feedList) : feedList;
   } // fetchUserTimeline
 
   async fetchUserPostsFeed(userId, offset, size, startTS, direction, callback) {
     return this.fetchUserTimeline(
       userId,
       offset,
       size,
       startTS,
       direction,
       callback,
     );
   }
 
   /**
    * Fetch user posts /u/user/:userId/posts. This
    * must be called on behalf of the user request (therefore /u).
    *
    * @param {string} userId which user to retrieve posts for?
    * @param {number} offset offset into start position of the expected query
    * @param {number} size batch size
    * @param {number} startTS timestamp where the posts streaming should start
    * @callback (err, PostList)
    * @return {PostList}
    */
   async fetchUserPosts(
     userId,
     offset = null,
     size = null,
     startTS,
     direction,
     callback,
     options = null,
     medias = null,
   ) {
     let _m = `getUserPosts(${userId})`;
     this.log(_m, `Fetching: offset=${offset}, max=${size}`);
     let err = null;
     let feedList;
     try {
       let url = this.getURL(this.urlHost, `/u/user/${userId}/posts`);
       url = this.appendFetchParams(
         url,
         offset,
         size,
         startTS,
         direction,
         null,
         options === "c" || options === "l" ? true : false,
       );
       let result = await this.requestGET(
         url +
           (medias ? "&fp=f_um" : "&fp=f_u") +
           (options ? options : medias ? "" : "o"),
         null,
       );
       feedList = XPostFeed.Wrap(result);
     } catch (e) {
       this.log(_m, e);
       if (callback == null) throw e;
     }
 
     return callback ? callback(err, feedList) : feedList;
   } // fetchUserPostFeed
 
   async getSearchByPhrase(phrase, offset, max, callback) {
     let _m = `getSearchByPhrase(${phrase})`;
     let err = null;
     let feedList;
 
     try {
       let encodedPhrase = "#" + phrase.slice(3);
       let url = this.getURL(this.urlHost, `/u/posts/srch/phrase`);
       let result = await this.requestPOST(url, {
         q: encodedPhrase,
         offset,
         max,
       });
       feedList = XPostFeed.Wrap(result);
     } catch (e) {
       this.log(_m, e);
       if (callback === null) throw e;
     }
     return callback ? callback(err, feedList) : feedList;
   }
 
   async getTopSearchResult(phrase, offset, max, callback) {
     let _m = `getSearchByPhrase(${phrase})`;
 
     let feedList;
     let err;
 
     try {
       let url = this.getURL(this.urlHost, `/u/posts/srch/phrase`);
       let result = await this.requestPOST(url, {
         q: phrase,
         offset,
         max,
       });
 
       feedList = XPostFeed.Wrap(result);
     } catch (e) {
       err = e;
       this.log(_m, e);
       if (callback === null) throw e;
     }
     return callback ? callback(feedList || err) : feedList || err;
   }
 
   /**
    * Execute search of posts by phrase and return a batch of posts using the
    * feed format.
    *
    * @param {string} phrase a string that user typed
    * @param {number} offset offset into start position of the expected query
    * @param {number} size batch size
    * @param {number} startTS timestamp where the posts streaming should start
    * @param {function} callback
    * @return {XPostFeed} collection of XPostItems, which wrap
    */
   async getSearchPostsFeed(
     phrase,
     offset = null,
     size = null,
     startTS,
     direction,
     callback,
   ) {
     let _m = "";
     // this.log(_m, `Fetching for userId: ${userId}`);
     let err = null;
     let url = this.getURL(this.urlHost, `/u/posts/srch/phrase`); // @depcrecated
     // let url = this.getURL(this.urlHost, `/u/posts/srch/phrase`); // to use with 12/3/2020 checkin but need to be pushed to cloud
 
     url = this.appendFetchParams(url, offset, size, startTS, direction);
     let params = {
       q: phrase,
     };
     let feedList;
     try {
       let result = await this.requestPOST(url, params);
       feedList = XPostFeed.Wrap(result);
     } catch (e) {
       this.log(_m, e);
       throw e;
     }
 
     return callback ? callback(err, feedList) : feedList;
   } // getSearchPostsFeed
 
   /**
    * Return a feed of posts that system identify as trendy / news. This
    * is more suitable as a home page.
    *
    * @param {string} topics
    * @param {number} offset
    * @param {number} size
    * @callback
    * @return {XPostFeed}
    */
   async getTrendsPostsFeed(
     topics,
     offset = null,
     size = null,
     startTs,
     lang,
     callback = null,
   ) {
     if (!lang) lang = "en";
     const _m = "gTPF";
     let err;
     let url = this.getURL(this.urlHost, `/u/posts/trends`);
     url = this.appendFetchParams(url, offset, size, startTs);
     if (lang) url += `&${API.FILTER_LANGUAGE_PREF}=${lang}`;
     let params = topics
       ? {
           [API.FILTER_LANGUAGE_PREF]: topics,
           [API.FILTER_TOPICS]: lang,
         }
       : null;
     let feedList;
     try {
       let result = await this.requestGET(url, params);
       feedList = XPostFeed.Wrap(result);
     } catch (e) {
       this.log(_m, e);
       err = e;
       if (!callback) throw e;
     }
     return callback ? callback(err, feedList) : feedList;
   }
 
   /**
    * Fetch post with post stats and userinfo as piggybacked data
    * in aux fields.
    *
    * @param {string} commentId
    * @callback
    * @return {XMPost} comment object with aux data
    * keyed by ModelType.COMMENT_STATS and ModelType.USERINFO
    */
   fetchPostWithStats_UserInfo(commentId, callback) {
     let inclOptions = API.INCL_POSTSTATS + "|" + API.INCL_USERINFO;
     return this.fetchPost(commentId, inclOptions, false, callback);
   }
 
   /**
    * Fetch a post object
    *
    * @param {string} postId ID for post
    * @param {string} inclOptions API.INCL_POSTSTATS|API.INCL_USERINFO
    * @param {boolean} cache true to ask ObjectManager to track it
    * @return {XMPost}
    * @callback {XError, XMPost}
    *
    * @see ~fetchPostWithStatsAndUser
    */
   fetchPost(postId, inclOptions = null, cache = false, callback) {
     let _m = `fetchPost(${postId})`;
     let p = new Promise((resolve, reject) => {
       let processResults = (err, postObj) => {
         if (err) {
           this.error(_m, `Error post ${postId}`);
           console.error(err);
           return callback ? callback(err, null) : reject(err);
         }
         if (callback) callback(null, postObj);
         resolve(postObj);
       };
       let params = inclOptions ? {[API.PARAM_INCL]: inclOptions} : null;
       this.user_getResource(
         postId,
         ModelType.POST,
         params,
         cache,
         processResults,
       );
     });
 
     return p;
   }
 
   /**
    * Retrieve stats for a post
    *
    * @param {string[]} postId
    * @param {boolean} inclObj include XMPost object in the return result
    *
    * @return {XPostStat | [XMPost,XPostStat]} either single object, or two objects
    */
   async fetchPostStats(postId, inclObj = false, callback) {
     const _m = "fetchPostStats";
 
     let result;
     let error = null;
 
     try {
       let apiUrl = this.apiGetObjectStats(ModelType.POST, postId, inclObj);
       result = await this.requestGET(apiUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
     return callback ? callback(error, result) : result;
   }
 
   // ----------------------------- COMMENTS ------------------------------
 
   /**
    * Fetch comments of a post, or as replies of a comment.  Currently
    * we determine which by the prefix of the Id
    *
    * @param {string} parentId either postId or a commentId.
    * @param {number} offset offset into start position of the expected query
    * @param {number} size batch size
    * @param {number} startTS timestamp where the posts streaming should start
    * @callback (err, XCommentFeed)
    * @return {XCommentFeed}
    */
   async fetchComments(
     parentId,
     offset = null,
     size = null,
     startTS,
     direction,
     callback,
   ) {
     let isComment = parentId.startsWith(PREFIX_COMMENT_ID) ? true : false;
     let _m = `fetchComments(${isComment ? "comment" : "post"}:${parentId})`;
     this.log(_m, `Fetching: offset=${offset}, max=${size}`);
     let err = null;
 
     let endpoint = isComment
       ? `/u/comment/${parentId}/comments`
       : `/u/post/${parentId}/comments`;
 
     let feedList;
     try {
       let url = this.getURL(this.urlHost, endpoint);
       url = this.appendFetchParams(
         url,
         offset,
         size,
         startTS,
         direction,
         null,
         true,
       );
       let result = await this.requestGET(url, null);
       feedList = XCommentFeed.Wrap(result); // should already been wrapped...
     } catch (e) {
       this.log(_m, e);
       if (callback == null) throw e;
     }
 
     return callback ? callback(err, feedList) : feedList;
   } // fetchComments
 
   /**
    * Fetch a comment object with piggybacked comment stats,
    * user info, associated post object, and its post stats
    *
    * @param {string} commentId
    * @callback
    *
    * @return {XMComment} comment object with aux object
    * keyed by ModelType.COMMENT_STATS and ModelType.USERINFO,
    * ModelType.POST, and ModelType.POST_STATS
    */
   fetchCommentWithStats_UserInfo_Post(commentId, callback) {
     // API.STATS will be honored by all objects, but in this case we don't
     // want UserInfo to come back with UserStats
     let inclOptions = `${API.INCL_COMMENTSTATS}|${API.INCL_USERINFO}|${API.INCL_POSTS}|${API.INCL_POSTSTATS}`;
     return this.fetchComment(commentId, inclOptions, false, callback);
   }
 
   /**
    * Fetch a comment object with piggybacked comment stats and userinfo
    *
    * @param {string} commentId
    * @callback
    *
    * @return {XMComment} comment object with aux object
    * keyed by ModelType.COMMENT_STATS and ModelType.USERINFO
    */
   fetchCommentWithStats_UserInfo(commentId, callback) {
     let inclOptions = API.INCL_COMMENTSTATS + "|" + API.INCL_USERINFO;
     return this.fetchComment(commentId, inclOptions, false, callback);
   }
 
   /**
    * Fetch a comment object from server
    *
    * @param {string} commentId ID for post
    * @param {string} inclOptions INCL_COMMENTSTATS|INCL_USERINFO
    * @param {boolean} cache true to ask ObjectManager to track it
    * @return {XMComment}
    * @callback {XError, XMComment}
    *
    * @see ~fetchComment
    */
   fetchComment(commentId, inclOptions, cache = false, callback) {
     let _m = `fetchComment(${commentId})`;
     let p = new Promise((resolve, reject) => {
       let processResults = (err, commentObj) => {
         if (err) {
           this.error(_m, `Error comment ${commentId}`);
           console.error(err);
           return callback ? callback(err, null) : reject(err);
         }
         if (callback) callback(null, commentObj);
         resolve(commentObj);
       };
       let params = inclOptions ? {[API.PARAM_INCL]: inclOptions} : null;
       this.user_getResource(
         commentId,
         "comment",
         params,
         cache,
         processResults,
       );
     });
 
     return p;
   }
 
   /**
    * Retrieve comment stats object from server
    *
    * @param {string[]} commentId
    * @param {boolean} inclObj include XMPost object in the return result
    *
    * @return {XMCommentStat | [XMComment,XMCommentStats]} either single object, or two objects
    */
   async fetchCommentStats(commentId, inclObj = false, callback) {
     const _m = "fetchCommentStats";
 
     let result;
     let error = null;
 
     try {
       let apiUrl = this.apiGetObjectStats("comment", commentId, inclObj);
       result = await this.requestGET(apiUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
     return callback ? callback(error, result) : result;
   }
 
   // --------------------------- USER SERVICES -----------------------------
 
   /**
    * Check whether a user exists.
    *
    * NOTE: currently, it does not return user status, which includes suspended/inactive.
    * So it's mainly used for use during sign-up
    *
    * @param {string[]} userId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return {object} map with tagname is key, and requested props: {title: <text>} as default
    */
   async checkUserExists(userId, callback) {
     const _m = "chkUID";
     let verdict = null;
     let error = null;
     try {
       let checkUserUrl = this.getURL(this.urlHost, `/u/user/${userId}/exists`);
       verdict = await this.requestGET(checkUserUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
     }
     return callback ? callback(error, verdict) : verdict;
   } // checkUserExists
 
   /**
    * Check whether an email exists.
    *
 
    * @param {string[]} email
    *
    * @return {object} map with tagname is key, and requested props: {title: <text>} as default
    */
   async checkEmailExists(email, callback) {
     const _m = "chkEm";
     let verdict = false;
     let error = null;
     if (Util.EmailIsValid(email)) {
       try {
         const encoded = encodeURIComponent(email);
         let checkUserUrl = this.getURL(
           this.urlHost,
           `/s/email/exists?email=${email}`,
         );
         verdict = await this.requestGET(checkUserUrl, null);
       } catch (e) {
         this.error(_m, e);
         error = e;
       }
     } else {
       error = new XError.New(ErrorCodes.USER_BAD_INPUT, "Invalid Email");
     }
 
     return callback ? callback(error, verdict) : verdict;
   } // checkEmailExists
 
   /**
    * Get user's status with the system
    *
    * @param {string[]} userId
    *
    * @return {string} user status (see UserProps.STATUS)
    */
   async getUserStatus(userId, callback) {
     const _m = "getUserStatus";
     let verdict = null;
     let error = null;
     try {
       let checkUserUrl = this.getURL(this.urlHost, `/s/user/${userId}/status`);
       // debugger;
       verdict = await this.requestGET(checkUserUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
     }
     return callback ? callback(error, verdict) : verdict;
   } // checkUserStatus
 
   /**
    * Retrieve nickname from userID. This convenient
    * method assumes user object is already in cache.
    *
    * @param {string} userId user ID to lookup
    */
   getUserNickname(userId, defaultVal = null) {
     let om = this.getObjectManager();
     let usrObj = om.getFromCache(userId, null, null);
 
     return usrObj ? usrObj.getNickname() : defaultVal;
   }
 
   async updateUserProfile(objId, data, userId) {
     let _m = "updateUserProfile";
     let token = this.portal.getUserToken();
     let error = null;
     let result = null;
     try {
       let formData = new FormData();
 
       for (let key in data) {
         if (key === "username") {
           formData.append("nickname", data.username);
         } else if (key === "bio") {
           formData.append("dsc", data.bio);
         } else if (data[key] === "ico") {
           formData.append(key, data[key]);
         } else if (data[key] === "bgimg") {
           formData.append(key, data[key]);
         } else {
           formData.append(key, data[key]);
         }
       }
       let postUrl = this.getURL(this.urlHost, `/u/user/${userId}/profile`);
 
       let xAuth =
         userId === null
           ? `{"user": null, "token": null}`
           : `{"user": "${userId}", "token": "${token}"}`;
       let config = {
         headers: {
           "Content-Type": "multipart/form-data",
           "x-app-auth": xAuth,
         },
       };
       result = await axios({
         url: postUrl,
         method: "post",
         data: formData,
         ...config,
       });
     } catch (e) {
       this.error(_m, e);
       error = e;
     }
     return result;
   }
 
   /**
    * Fetch a user info record from server
    *
    * @param {string} userId use user ID
    * @param params any arguments or filters
    * @callback
    * @return {XUserInfo}
    */
   async fetchUserInfo(userId, params, callback) {
     let _m = "fetchUserInfo";
     let p = new Promise((resolve, reject) => {
       let processResults = (err, userInfo) => {
         // this.log(_m, "user info retrieved:", userInfo);
         if (err) {
           this.error(_m, err);
           if (callback) callback(err, null);
           reject(err);
         } else {
           if (callback) callback(null, userInfo);
           resolve(userInfo);
         }
       }; // processResults
       this.getResource(
         userId,
         ModelType.USER_INFO,
         null,
         false,
         processResults,
       );
     });
 
     return p;
   } // fetchuserInfo
 
   /**
    * Force refresh of user info by reading from server and
    * then update session/cookie
    *
    * @param {function} callback in case not using promise
    */
   async refreshUserInfo(callback) {
     let userInfo;
     let errObj;
     try {
       let userId = this.getUserId();
       userInfo = await this.fetchUserInfo(userId);
       if (userInfo) {
         // this.log("refreshUserInfo", "info", userInfo);
         this.updateUserInfo(userInfo);
       }
     } catch (err) {
       if (callback == null) throw err;
     }
     return callback ? callback(errObj, userInfo) : userInfo;
   } // refreshUserInfo
 
   /**
    * Invalidate a settings group and force re-retrieve.
    *
    * @param {string} section one of UserProps.SETTINGS_*
    * @param {{}} params pass to server
    * @param {function} callback in case not using promise
    */
   async invalidateSettings(section, params, callback) {
     // for now, we only allow refreshing the profile section
     if (UserProps.SETTINGS_PROFILE !== section) return;
 
     return this.refreshUserInfo(callback);
   } // invalidateSettings
 
   /**
    * Fetch a user settings record from server
    *
    * @param {string} userId use user ID
    * @param {string} section one of UserProps.SETTINGS_*
    * @param {{}} params any arguments or filters
    * @return {XUserInfo} subclass of it which is basically specific
    * settings like XAccountSettings, XProfileSettings, etc.
    */
   async fetchUserSettings(userId, section, params, callback) {
     const _m = "fetchUserSettings";
     let settingsObj;
     let error = null;
     try {
       let getSettingsUrl = this.apiGetUserSettings(userId, section, params);
       settingsObj = await this.requestGET(getSettingsUrl, null);
       settingsObj = XMObject.Wrap(settingsObj);
     } catch (e) {
       this.error(_m, "server returned error:", e);
       error = e;
       settingsObj = null;
     }
     return callback ? callback(error, settingsObj) : settingsObj;
   } // fetchUserSettings
 
   /**Update a user settings (delta) record to server
    *
    * @param {string} userId use user ID
    * @param {string} section settings type defined in UserProps.SETTINGS_*
    * @param {XDeepDiff} settingsChanges changes to update
    * @param {{}} params any arguments or filters
    * @return {XUserInfo} updated settings object of types like
    * XAccountSettings, XProfileSettings, etc.
    */
   async updateUserSettings(userId, section, settingsChanges, params, callback) {
     const _m = "uUrSt";
     let settingsObj;
     let settingsData = XMObject.Unwrap(settingsChanges);
     let encryptedData = Util.EncryptJSON(settingsData);
     let error = null;
     try {
       let updateSettingsUrl = this.apiGetUserSettings(userId, section, params);
       settingsObj = await this.requestPOST(updateSettingsUrl, encryptedData);
       settingsObj = XMObject.Wrap(settingsObj);
     } catch (e) {
       this.error(_m, e);
       error = e;
       settingsObj = null;
     }
 
     // If settings is profile, then we need to update user info
     if (this.isLoggedInUser(userId)) this.invalidateSettings(section);
 
     return callback ? callback(error, settingsObj) : settingsObj;
   } // updateUserSettings
 
   /**
    * Initiate an user stat update from server, which will
    * update in session variables.
    *
    * @param {{}} props control what stats to update
    *
    * @callback
    */
   async updateUserStats(props, callback) {
     let userId = this.getUserId();
     let statsObj = await this.fetchUserStats(userId, props);
     // Update session
     if (statsObj) {
       this.getSession().updateUserStats(statsObj);
     }
   }
 
   /**
    * Retrieve latest in stats of (current) user and update
    * the profile
    *
    * @param {string[]} userId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return {object} map with tagname is key, and requested props: {title: <text>} as default
    */
   async fetchUserStats(userId, props = null, callback) {
     const _m = "fetchUserStats";
     let statsObj;
     let error = null;
     try {
       let url = this.getURL(this.urlHost, `/s/user/${userId}/stats/`);
       if (props) {
         // props = Array.isArray(props) ? props.join(",") : props;
         url += "?props=" + JSON.stringify(props);
       }
       statsObj = await this.requestGET(url, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       statsObj = null;
     }
     return callback ? callback(error, statsObj) : statsObj;
   } // fetchUserStats
 
   /**
    * Retrieve tag stats
    *
    * @param {string[]} tagId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return {object} map with tagname is key, and requested props: {title: <text>} as default
    */
   async fetchTagStats(tagId, props = null, callback) {
     const _m = "fetchTagStats";
 
     let statsObj;
     let error = null;
     try {
       let apiUrl = this.apiGetCategoryStats(tagId, props);
       statsObj = await this.requestGET(apiUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       statsObj = null;
     }
     return callback ? callback(error, statsObj) : statsObj;
   } // fetchTagStats
 
   // ----------------------- TOPIC CATEGORIES -----------------------------
 
   /**
    * Submit update of interested topic categories for a user
    *
    * @param {string[]} topicIds array of topic category identifiers as
    * specified in ModelConst.CATEGORY_*. If one, still submit as a string
    *
    *
    * @return {string[]} all user interested topics
    */
   async submitTopics(topicIds, callback) {
     const _m = "setTopics";
     let error = null;
     let userTopics = null;
     try {
       const userId = this.getUserId();
       let submitTopicsUrl = this.getURL(
         this.urlHost,
         `/s/user/${userId}/topics`,
       );
       let data = {
         [API.PARAM_CATEGORIES]: API.CreateOptions(topicIds),
       };
       userTopics = await this.requestPOST(submitTopicsUrl, data);
     } catch (e) {
       this.error(_m, e);
       error = e;
     }
     return callback ? callback(error, userTopics) : userTopics;
   } // submitTopics
 
   /**
    * Return all available topic (IDs). The Ids should be mappable
    * to translations.
    *
    * @return {string[]} topicIds array of topic category identifiers as
    * specified in ModelConst.CATEGORY_*. If one, still submit as a string
    *
    * @return {string[]} all user interested topics
    */
   async fetchAvailableTopics(callback) {
     const _m = "gTopics";
     let error = null;
 
     // We have these topic Ids in constants, so no need to
     // make a call to server for now.
     let topicIds = TOPIC_CATEGORIES;
     // try {
     //   const userId = this.getUserId();
     //   let getTopicsUrl = this.getURL(this.urlHost, `/s/topics`);
     //   topicIds = await this.requestGET(getTopicsUrl);
     // } catch (e) {
     //   this.error(_m, e);
     //   error = e;
     // }
     return callback ? callback(error, topicIds) : topicIds;
   } // fetchAvailableTopics
 
   // --------------------- ALERT SERVICE ----------------------
 
   /**
    * Get alert count
    *
    * @param {string} userId user to get count, or null for logged in user
    * @param {{}} props future
    * @param {*} defaultVal if no value is retrieved.
    *
    * @return {number} count
    */
   async fetchAlertCount(
     userId = null,
     props = null,
     defaultVal = -1,
     callback,
   ) {
     const _m = "fetchAlertCount";
 
     let loggedInUserId = userId ? userId : this.getUserId();
     let alertCount;
     let field = "unread";
     let error = null;
     try {
       let getUrl = this.apiUserAlertCount(loggedInUserId, field, props);
       let result = await this.requestGET(getUrl);
       if (result) alertCount = result[field];
     } catch (e) {
       this.error(_m, e);
       error = e;
       alertCount = defaultVal;
     }
 
     return callback ? callback(error, alertCount) : alertCount;
   } // fetchAlertCount
 
   /**
    * Fetch User alerts
    * @param {string} userId
    * @param {*} props
    * @param {*} defaultVal
    * @callback
    * @return {XMUserAlerts} wrapper to XUserAlert instances and XVarData
    */
   async fetchAlerts(userId = null, props = null, defaultVal = null, callback) {
     const _m = "fetchAlerts";
 
     let loggedInUserId = userId ? userId : this.getUserId();
 
     /** @type {XMUserAlert} */
     let retval;
     let field = "";
     let max = 20;
     let error = null;
     try {
       let getUrl = this.apiUserAlerts(loggedInUserId, field, max, props);
       retval = await this.requestGET(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       retval = defaultVal;
     }
 
     return callback ? callback(error, retval) : retval;
   } // fetchAlerts
 
   /**
    * Get alert count
    *
    * @param {string} userId user to get count, or null for logged in user
    * @param {{}} props future
    * @param {*} defaultVal if no value is retrieved.
    *
    * @return {number} count
    */
   async markAlertsRead(alertIds, props = null, callback) {
     const _m = "markAlertsRead";
 
     let loggedInUserId = this.getUserId();
     let returnVal;
     if (props == null) props = {};
 
     // for now...
     props[API.ALERT_IDS] = alertIds;
     props[API.READ_TS] = Date.now();
     props[API.READ_MEDIUM] = MessageProps.MEDIUM_APP;
     let error = null;
     try {
       let getUrl = this.apiUserAlertsStatus(loggedInUserId, null, null);
       returnVal = await this.requestPOST(getUrl, props);
     } catch (e) {
       this.error(_m, e);
       error = e;
       returnVal = null;
     }
 
     return callback ? callback(error, returnVal) : returnVal;
   } // fetchAlertCount
 
   // --------------------- FOLLOWS SERVICE ----------------------
 
   /**
    * Add a "userId follows :anotherUserId"
    *
    * @param {string} targetUserId user to follow
    *
    * @return {XUserInfo} upated user info with new follow
    */
   async userFollows(targetUserId, props = null, callback) {
     const _m = "userFollows";
 
     let loggedInUserId = this.getUserId();
     let followStatus;
     let error = null;
     try {
       let getUrl = this.apiAddFollows(loggedInUserId, targetUserId, props);
       followStatus = await this.requestPOST(getUrl);
     } catch (e) {
       // response object in here is not an xResObj
       this.error(_m, e);
       error = e;
       followStatus = null;
     }
     return callback ? callback(error, followStatus) : followStatus;
   } // userFollows
 
   /**
    * Retrieve answer to whether the logged in user is following
    * a given user.
    *
    * @param {string[]} userId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return {object} map with tagname is key, and requested props: {title: <text>} as default
    */
   async userFollowStatus(targetUserId, props = null, callback) {
     const _m = "userFollowStatus";
 
     let statusValue = null;
     let error = null;
     let userId = this.getUserId();
     if (!targetUserId || !userId) {
       return false;
     }
     try {
       let getUserStatsUrl = this.apiUserFollowStatus(
         userId,
         targetUserId,
         props,
       );
       statusValue = await this.requestGET(getUserStatsUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       statusValue = SocialProps.STATUS_UNKNOWN;
     }
     return callback ? callback(error, statusValue) : statusValue;
   } // userFollowStatus
 
   /**
    * Retrieve answer to whether the logged in user is following
    * a given user (or pending or blocked).
    *
    * @param {string[]} followerId userId for the follower of logged in user
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return {string} status PROP_ACCEPTED, PROP_PENDING, PROP_BLOCKED or null
    */
   async userFollowerStatus(followerId, props = null, callback) {
     const _m = "userFollowerStatus";
 
     let statusValue = null;
     let error = null;
     let userId = this.getUserId();
     if (!followerId || !userId) {
       return null;
     }
     try {
       let getUserStatsUrl = this.apiUserFollowerStatus(
         userId,
         followerId,
         props,
       );
       statusValue = await this.requestGET(getUserStatsUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       statusValue = null;
     }
     return callback ? callback(error, statusValue) : statusValue;
   } // userFollowStatus
 
   /**
    * Add a "userId unfollows :anotherUserId"
    *
    * @param {string} targetUserId user to unfollow
    *
    * @return {XUserInfo} updated user info with follow removed
    */
   async userUnfollows(targetUserId, props = null, callback) {
     const _m = "userUnfollows";
 
     let loggedInUserId = this.getUserId();
     let followStatus;
     let error = null;
     try {
       let getUrl = this.apiRemoveFollows(loggedInUserId, targetUserId, props);
       followStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       followStatus = null;
     }
 
     return callback ? callback(error, followStatus) : followStatus;
   } // userUnfollows
 
   /**
    * Request blocking of a user from logged in user
    *
    * @param {string} targetUserId user to block
    *
    * @return {XUserInfo} updted user info with follow removed
    */
   async userBlocksFollower(targetUserId, props = null, callback) {
     const _m = "userBlocksFollower";
 
     let loggedInUserId = this.getUserId();
     let followStatus;
     let error = null;
     try {
       let getUrl = this.apiBlockFollower(loggedInUserId, targetUserId, props);
       followStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       followStatus = null;
     }
 
     return callback ? callback(error, followStatus) : followStatus;
   } // userBlocksUser
 
   /**
    * Request unblocking of a user from logged in user
    *
    * @param {string} targetUserId user to block
    *
    * @return {XUserInfo} updted user info with follow removed
    */
   async userUnblocksFollower(targetUserId, props = null, callback) {
     const _m = "userUnblocksFollower";
 
     let loggedInUserId = this.getUserId();
     let followStatus;
     let error = null;
     try {
       let getUrl = this.apiUnblockFollower(loggedInUserId, targetUserId, props);
       followStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       followStatus = null;
     }
 
     return callback ? callback(error, followStatus) : followStatus;
   } // userBlocksUser
 
   /**
    * Request mute a user for logged in user
    *
    * @param {string} targetUserId user to mute
    *
    * @return {XUserInfo} updted user info with follow removed
    */
   async userMutesFollower(targetUserId, props = null, callback) {
     const _m = "userMutesFollower";
 
     let loggedInUserId = this.getUserId();
     let followStatus;
     let error = null;
     try {
       let getUrl = this.apiMuteFollower(loggedInUserId, targetUserId, props);
       followStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       followStatus = null;
     }
 
     return callback ? callback(error, followStatus) : followStatus;
   } // userMutesUser
 
   /**
    * Request unmute a user for logged in user
    *
    * @param {string} targetUserId user to mute
    *
    * @return {XUserInfo} updted user info with follow removed
    */
   async userUnmutesFollower(targetUserId, props = null, callback) {
     const _m = "userUnmutesFollower";
 
     let loggedInUserId = this.getUserId();
     let followStatus;
     let error = null;
     try {
       let getUrl = this.apiUnmuteFollower(loggedInUserId, targetUserId, props);
       followStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       followStatus = null;
     }
 
     return callback ? callback(error, followStatus) : followStatus;
   } // userUnmutesUser
 
   /**
    * Fetch a user follows instance, which contains user IDs
    * that this user is following.
    *
    * @param {string} userId poll configuration ID
    * @param {{}} params API.INCL_REFOBJS, API.INCL_STATS
    * @callback
    *
    * @see ~fetchUserFollowsInclRefs
    */
   async fetchUserFollows(userId, params, callback) {
     let _m = `fetchUserFollows(${userId})`;
     let loggedInUserId = userId ? userId : this.getUserId();
     let followObj;
     let error = null;
     try {
       let getUrl = this.apiGetFollows(loggedInUserId, params);
       followObj = await this.requestGET(getUrl);
       followObj = XMFollows.Wrap(followObj);
     } catch (e) {
       this.error(_m, e);
       error = e;
       followObj = null;
     }
 
     return callback ? callback(error, followObj) : followObj;
   } // fetchUserFollows
 
   /**
    *
    * @param {string} userId
    * @param {{}} params
    * @param {boolean} cache true to ask ObjectManager to track it
    * @callback
    */
   fetchUserFollowsInclRefs(userId, params, cache = false, callback) {
     if (params == null) params = {};
 
     // The content is not evaluated at the server; only that
     // this parameter is passed (as of 3/2019)
     params[API.INCL_REFOBJS] = {
       [XObject.PROP_TAGS]: {
         [XObject.PROP_TITLE]: "en_us",
       },
     };
 
     return this.fetchUserFollows(userId, params, cache, callback);
   }
 
   /**
    * Fetch a user follows instance, which contains user IDs
    * that this user is following.
    *
    * @param {string} userId poll configuration ID
    * @param {{}} params API.INCL_REFOBJS, API.INCL_STATS
    * @callback
    */
   async fetchUserFollowers(userId, params, callback) {
     let _m = `fUF(${userId})`;
     let loggedInUserId = userId ? userId : this.getUserId();
     let followerObj;
     let error = null;
     try {
       let getUrl = this.apiGetFollowers(loggedInUserId, params);
       followerObj = await this.requestGET(getUrl);
       followerObj = XMFollowers.Wrap(followerObj);
     } catch (e) {
       this.error(_m, "server returned error:", e);
       error = e;
       followerObj = null;
     }
 
     return callback ? callback(error, followerObj) : followerObj;
   } // fetchUserFollowers
 
   /**
    *
    * @param {string} userId
    * @param {{}} params
    * @param {boolean} cache true to ask ObjectManager to track it
    * @callback
    */
   fetchUserFollowersInclRefs(userId, params, cache = false, callback) {
     if (params == null) params = {};
 
     // The content is not evaluated at the server; only that
     // this parameter is passed (as of 3/2019)
     params[API.INCL_REFOBJS] = {
       [XObject.PROP_TAGS]: {
         [XObject.PROP_TITLE]: "en_us",
       },
     };
 
     return this.fetchUserFollowers(userId, params, cache, callback);
   }
 
   // ------------------- WATCHES/WATCHED POSTS -----------------
 
   /**
    * Fetch all tags that a user is watching
    *
    * @param {string} userId
    * @param {{}} params API.INCL_REFOBJS, API.INCL_STATS
    * @callback
    * @return {XMWatchesPost}
    */
   async fetchWatchesPost(userId, params, callback) {
     let _m = `fetchWatchesPost(${userId})`;
     let loggedInUserId = userId ? userId : this.getUserId();
     let xWatches;
     let error = null;
     try {
       let getUrl = this.apiGetWatchesObject(
         ModelType.POST,
         loggedInUserId,
         params,
       );
       xWatches = await this.requestGET(getUrl);
       xWatches = XMWatchesPost.Wrap(xWatches);
     } catch (e) {
       this.error(_m, e);
       error = e;
       xWatches = null;
     }
     return callback ? callback(error, xWatches) : xWatches;
   }
 
   /**
    * Fetch a user follows instance, which contains user IDs
    * that this user is following.
    *
    * @param {string} postId poll configuration ID
    * @param {{}} params API.INCL_REFOBJS, API.INCL_STATS
    * @callback
    */
   async fetchPostWatchers(postId, params, callback) {
     let _m = `fetchPostWatchers(${postId})`;
     let loggedInUserId = postId ? postId : this.getUserId();
     let xWatchers;
     let error = null;
     try {
       let getUrl = this.apiGetObjectWatchers(
         ModelType.POST,
         loggedInUserId,
         params,
       );
       xWatchers = await this.requestGET(getUrl);
 
       xWatchers = XMWatchedPost.Wrap(xWatchers);
     } catch (e) {
       this.error(_m, e);
       error = e;
       xWatchers = null;
     }
     return callback ? callback(error, xWatchers) : xWatchers;
   }
 
   // --------------------- LIKES POST SERVICE ----------------------
 
   /**
    * Add a "userId likes :postId"
    *
    * @param {string} postId user to follow
    *
    * @return {string} updated like status "y" or "n"
    */
   async userLikesPost(postId, props = null, callback) {
     const _m = "userLikesPost";
 
     let loggedInUserId = this.getUserId();
     let likeStatus;
     let error = null;
     try {
       let getUrl = this.apiAddLikeObject(
         loggedInUserId,
         ModelType.POST,
         postId,
         props,
       );
       likeStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       likeStatus = null;
     }
 
     return callback ? callback(error, likeStatus) : likeStatus;
   } // userLikesPost
 
   /**
    * Request to unlike a post
    *
    * @param {string} postId user to unfollow
    *
    * @return {XUserInfo} upated user info with follow removed
    */
   async userUnlikesPost(postId, props = null, callback) {
     const _m = "userUnlikesPost";
 
     let loggedInUserId = this.getUserId();
     let likeStatus;
     let error = null;
     try {
       let getUrl = this.apiRemoveLikeObject(
         loggedInUserId,
         ModelType.POST,
         postId,
         props,
       );
       likeStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       likeStatus = null;
     }
 
     return callback ? callback(error, likeStatus) : likeStatus;
   } // userUnlikesPost
 
   /**
    * Retrieve answer to whether the logged in user has liked
    * the given post.
    *
    * @param {string[]} postId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return "y" or "no"
    */
   async userLikePostStatus(postId, props = null, callback) {
     const _m = "fULPS";
 
     let statusValue = null;
     let error = null;
     let userId = this.getUserId();
     if (!postId || !userId) {
       return "no";
     }
     try {
       let url = this.apiUserLikeObjectStatus(
         userId,
         ModelType.POST,
         postId,
         props,
       );
       statusValue = await this.requestGET(url, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       statusValue = null;
     }
     return callback ? callback(error, statusValue) : statusValue;
   } // userLikePostStatus
 
   // --------------------- LIKES COMMENT SERVICE ----------------------
 
   /**
    * Add a "userId likes :commentId"
    *
    * @param {string} commentId user to follow
    *
    * @return {string} updated like status "y" or "n"
    */
   async userLikesComment(commentId, props = null, callback) {
     const _m = "userLikesPost";
 
     let loggedInUserId = this.getUserId();
     let likeStatus;
     let error = null;
     try {
       let getUrl = this.apiAddLikeObject(
         loggedInUserId,
         "comment",
         commentId,
         props,
       );
       likeStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       likeStatus = null;
     }
 
     return callback ? callback(error, likeStatus) : likeStatus;
   } // userLikesPost
 
   /**
    * Request to unlike a post
    *
    * @param {string} commentId user to unfollow
    *
    * @return {XUserInfo} upated user info with follow removed
    */
   async userUnlikesComment(commentId, props = null, callback) {
     const _m = "fUUCS";
 
     let loggedInUserId = this.getUserId();
     let likeStatus;
     let error = null;
     try {
       let getUrl = this.apiRemoveLikeObject(
         loggedInUserId,
         "comment",
         commentId,
         props,
       );
       likeStatus = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       likeStatus = null;
     }
 
     return callback ? callback(error, likeStatus) : likeStatus;
   } // userUnlikesComment
 
   /**
    * Retrieve answer to whether the logged in user has liked
    * the given post.
    *
    * @param {string[]} commentId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return "y" or "no"
    */
   async userLikeCommentStatus(commentId, props = null, callback) {
     const _m = "fULCS";
 
     let statusValue = null;
     let error = null;
     let userId = this.getUserId();
     if (!commentId || !userId) {
       return "no";
     }
     try {
       let url = this.apiUserLikeObjectStatus(
         userId,
         "comment",
         commentId,
         props,
       );
       statusValue = await this.requestGET(url, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
       statusValue = null;
     }
     return callback ? callback(error, statusValue) : statusValue;
   } // userLikeCommentStatus
 
   // --------------------- WATCH OBJECT SERVICE ----------------------
 
   /**
    * Add a "userId watches :objectId"
    *
    * @param {string} objectId object to watch
    *
    * @return {string} updated like status "y" or "n"
    */
   async userWatchesObject(type, objectId, props = null, callback) {
     const _m = "userWatchesObject";
 
     let loggedInUserId = this.getUserId();
     let watchStatus;
     let error = null;
     try {
       let url = this.apiAddWatchObject(type, loggedInUserId, objectId, props);
       watchStatus = await this.requestPOST(url);
     } catch (e) {
       this.error(_m, e);
       error = e;
       watchStatus = null;
     }
 
     return callback ? callback(error, watchStatus) : watchStatus;
   }
 
   /**
    * Request to unwatch an object
    *
    * @param {string} objectId object to unwatch
    *
    * @return {XUserInfo} upated user info with follow removed
    */
   async userUnwatchesObject(type, objectId, props = null, callback) {
     const _m = "userUnwatchesObject";
 
     let loggedInUserId = this.getUserId();
     let watchStatus;
     let error = null;
     try {
       let url = this.apiRemoveWatchObject(
         type,
         loggedInUserId,
         objectId,
         props,
       );
       watchStatus = await this.requestPOST(url);
     } catch (e) {
       this.error(_m, "server returned error:", e);
       error = e;
       watchStatus = null;
     }
 
     return callback ? callback(error, watchStatus) : watchStatus;
   }
 
   /**
    * Get watch status on the specified object type/id
    *
    * @param {string[]} objectId
    * @param {string[]} props properties to include (array or comma delimited string)
    * Null to include defaults which is title only.
    *
    * @return "y" or "no"
    */
   async userWatchObjectStatus(type, objectId, props = null, callback) {
     const _m = "userWatchObjectStatus";
 
     let statusValue = null;
     let error = null;
     let userId = this.getUserId();
     if (!objectId || !userId) {
       return "no";
     }
     try {
       let url = this.apiUserWatchObjectStatus(type, userId, objectId, props);
       statusValue = await this.requestGET(url, null);
     } catch (e) {
       this.error(_m, "server returned error:", e);
       error = e;
       statusValue = null;
     }
     return callback ? callback(error, statusValue) : statusValue;
   }
 
   // --------------------- (PASSWORD) CHANGE REQUEST -------------------------
 
   /**
    * Fetch existing XMUserRequest instance.
    *
    * @param {string} requestId
    * @callback
    */
   fetchUserRequest(requestId, cache = false, callback) {
     // let _m = `fetchUserRequest(${templateId})`;
 
     let processResults = (err, rlObj) => {
       if (err) {
         console.log(err);
         return callback ? callback(err, null) : null;
       }
 
       if (callback) callback(null, rlObj);
       else return rlObj;
     };
 
     this.getResource(
       requestId,
       ModelType.USER_REQUEST,
       null,
       cache,
       processResults,
     );
   } // fetchUserRequest
 
   /**
    * Send password change request to verified contact path (e.g., email)
    *
    * @param {XUserInfo} userInfo
    * @param {XAuthInfo} authInfo
    * @param {string} requestType either REQUEST_EMAIL or REQUEST_SMS as wish
    *
    * @return {XMUserConfirm} confirmation object
    */
   async initiatePasswordChange(userInfo, authInfo, requestType, callback) {
     const _m = "initPwdChange";
 
     let content = {};
     if (userInfo) content["userinfo"] = XObject.Unwrap(userInfo);
     if (authInfo) content["authinfo"] = XObject.Unwrap(authInfo);
 
     let encrypted = Util.EncryptJSON(content);
 
     let confirmObj;
     let error = null;
 
     // type may become an option to allow user to choose how to send request (by email or sms)
     // let type = (confirmType === UserProps.CONFIRM_SMS) ? UserProps.SMS : UserProps.EMAIL;
     try {
       let apiUrl = this.getURL(this.urlHost, `/s/request/pwdchg`);
       confirmObj = await this.requestPOST(apiUrl, encrypted);
     } catch (e) {
       this.error(_m, "server error:", e);
       error = e;
       confirmObj = null;
     }
     return callback ? callback(error, confirmObj) : confirmObj;
   }
 
   /**
    * Resend new confirmation based on the given (expired) confirmation.
    *
    * @param {string} requestId
    * @param {string} confirmType either CONFIRM_EMAIL or CONFIRM_SMS
    *
    * @return {XMUserConfirm} new confirmation object with different ID
    */
   async resendPasswordChangeRequest(requestId, callback) {
     const _m = "resentPwdChangeReq";
 
     let xRequest;
     let error = null;
     try {
       let apiUrl = this.getURL(this.urlHost, `/s/request/${requestId}/resend`);
       xRequest = await this.requestGET(apiUrl, null);
     } catch (e) {
       this.error(_m, "server error:", e);
       error = e;
       xRequest = null;
     }
     return callback ? callback(error, xRequest) : xRequest;
   }
 
   /**
    * Submit a password change request to server.
    * This is a pass-thru from
    * the web app URL: /chgpwd/:requestId when responding to
    * an email request to change password
    *
    * @param {string} curPassword current pasword (clear)
    * @param {string} newPassword new password (clear)
    *
    * @return {string} status PROP_ACCEPTED, PROP_PENDING, PROP_BLOCKED or null
    *
    * @see PasswordChangeRoute.submitRequest (route-changepwd.js)
    */
   async submitPasswordChange(curPassword, newPassword, callback) {
     const _m = "submitPwdChange";
 
     let result;
     let error = null;
     try {
       let userId = this.getUserId();
       let data = {
         [API.CURRENT_PASSWORD]: curPassword,
         [API.NEW_PASSWORD]: newPassword,
       };
 
       let query = this.getURL(
         this.urlHost,
         `/u/user/${userId}/pwdchg?clear=true`,
       );
       // if (sourceId) query = `${query}/src/${sourceId}`;
 
       result = await this.requestPOST(query, data);
     } catch (e) {
       this.error(_m, "server:", e);
       error = e;
       result = null;
     }
     return callback ? callback(error, result) : result;
   } // submitPasswordChange
 
   /**
    * Change password
    *
    * @param {string} curPassword current pasword (clear)
    * @param {string} newPassword new password (clear)
    *
    * @return {boolean} true to indicate success, or E_AUTH error
    *
    */
   async changePassword(curPassword, newPassword, callback) {
     const _m = "chgPwd";
 
     let result;
     let error = null;
     let username = this.getUsername();
     try {
       let query = this.getURL(this.urlHost, `/u/${username}/pwdchg`);
 
       let curpwd = Util.EncryptPwd(curPassword);
       let newpwd = Util.EncryptPwd(newPassword);
 
       let data = {
         [API.CURRENT_PASSWORD]: curpwd,
         [API.NEW_PASSWORD]: newpwd,
       };
 
       result = await this.requestPOST(query, data);
     } catch (e) {
       this.error(_m, "server:", e);
       error = e;
       result = null;
     }
     return callback ? callback(error, result) : result;
   } // changePassword
 
   // --------------------- CONFIRMATION / VERIFICATION STATUS -------------------------
 
   /**
    * Send verification email/text to user to confirm account (contact method)
    *
    * @param {string} userId
    * @param {string} confirmType either CONFIRM_EMAIL or CONFIRM_SMS
    *
    * @return {XMUserConfirm} confirmation object
    */
   async verifyContact(userId, confirmType, callback) {
     const _m = "verifyContact";
 
     let confirmObj;
     let error = null;
     let type =
       confirmType === UserProps.CONFIRM_SMS ? UserProps.SMS : UserProps.EMAIL;
     try {
       let apiUrl = this.getURL(
         this.urlHost,
         `/s/user/${userId}/verify/${type}`,
       );
       confirmObj = await this.requestGET(apiUrl, null);
     } catch (e) {
       this.error(_m, "server error:", e);
       error = e;
       confirmObj = null;
     }
     return callback ? callback(error, confirmObj) : confirmObj;
   }
 
   /**
    * Resend new confirmation based on the given (expired) confirmation.
    *
    * @param {string} userId
    * @param {string} confirmType either CONFIRM_EMAIL or CONFIRM_SMS
    *
    * @return {XMUserConfirm} new confirmation object with different ID
    */
   async resendConfirmation(confirmId, callback) {
     const _m = "resendConfirm";
 
     let xConfirm;
     let error = null;
     try {
       let apiUrl = this.getURL(this.urlHost, `/s/confirm/${confirmId}/resend`);
       xConfirm = await this.requestGET(apiUrl, null);
     } catch (e) {
       this.error(_m, "server error:", e);
       error = e;
       xConfirm = null;
     }
     return callback ? callback(error, xConfirm) : xConfirm;
   }
 
   /**
    * Send confirmation by an Id to server and get results back.
    *
    * @param {string} confirmId confirmation identifier
    * @param {string} sourceId identifier of source. If null, we'll look up IP
    *
    * @return {string} status PROP_ACCEPTED, PROP_PENDING, PROP_BLOCKED or null
    */
   async confirmById(confirmId, sourceId, callback) {
     const _m = "confirmById";
 
     let confirmObj;
     let error = null;
     try {
       let apiUrl = this.apiConfirmById(confirmId, sourceId);
       confirmObj = await this.requestGET(apiUrl, null);
       if (confirmObj && confirmObj.isConfirmed(false))
         this.refreshUserInfo(null);
     } catch (e) {
       this.error(_m, "server:", e);
       error = e;
       confirmObj = null;
     }
     return callback ? callback(error, confirmObj) : confirmObj;
   } // confirmById
 
   /**
    * Submit a User Feedback
    *
    * @param {string} requestId confirmation identifier
    * @param {string} sourceId identifier of source. If null, we'll look up IP
    *
    * @return {string} status PROP_ACCEPTED, PROP_PENDING, PROP_BLOCKED or null
    */
   async submitFeedback(xUserFeedback, callback) {
     const _m = "submitFeedback";
 
     let result;
     let error = null;
     try {
       let query = this.getURL(this.urlHost, `/s/submit/feedback`);
 
       result = await this.requestPOST(query, xUserFeedback);
     } catch (e) {
       this.error(_m, "server:", e);
       error = e;
       result = null;
     }
     return callback ? callback(error, result) : result;
   } // submitPasswordChange
 
   // -------------------------------
 
   /**
    * Check if given instance of XMObject can
    * be updated by the currently logged in user.
    *
    * @param {XMObject} xmobject
    */
   validateWrite(xmobject) {
     let loggedInUserId = this.getUserId();
     let ownerId = xmobject ? xmobject.getOwnerId() : null;
     if (ownerId == null || loggedInUserId == null) return false;
 
     if (ownerId !== loggedInUserId) return false;
 
     return true;
   } // validateWrite
 
   // ------------------- HASHTAG / USERTAG RELATED SERVICES ---------------------
 
   /**
    *
    * @param {number} max
    * @return {XResultList}
    * @callback
    */
   async fetchSuggestedHashtags(offset = null, max = null, callback) {
     if (!max) max = 20;
 
     let url = this.getURL(this.urlHost, "/s/hashtag/suggest");
     url += "?max=" + max;
     if (offset) url += "&offset=" + offset;
     return this.requestGET(url, null, callback);
   }
 
   /**
    *
    * @param {number} max maximum number of userIds to retrieve
    * @param {number} offset starting position, if different from zero
    * @return {XResultList}
    * @callback
    */
   async fetchSuggestedUsertags(offset = null, max = null, callback) {
     if (!max) max = 20;
     let url = this.getURL(this.urlHost, "/s/usertag/suggest");
     url += "?max=" + max;
     if (offset) url += "&offset=" + offset;
     url += "&incl=userinfo|followings";
 
     let resultList = await this.requestGET(url, null);
 
     if (callback) return callback(resultList);
     else return resultList;
   }
 
   // --------------- POST-RELATED SEARCHES / FETCHES ----------------------------
 
   /**
    * Fetch matching keywords delmited by spaces. hashtags and mentions will give
    * priority in results, follow by generaal results (eventually).
    *
    * @param {string} keywords delimited by space
    * @param {boolean} inclSelf include own posts?
    * @param {array} field names to include in the result (catObj for whole object)
    * @param {number} max
    * @param {number} min
    * @return {XResultMap}
    */
   async fetchSearchChoices(keywords, max = null, min = null, callback) {
     // const postProcess = function (err, resultMap) {
     //   if (err) return callback(err, null);
     //   // no filter processing
     //   callback(null, resultMap);
     // }; // postProcess
 
     let urlKwdTags = this.getURL(this.urlHost, "/u/posts/srch/choices");
     let result = await this.searchPostPhrase(
       urlKwdTags,
       keywords,
       false,
       false,
       max,
       min,
       //postProcess,
     );
 
     return result;
   } // fetchKwd2Tags
 
   async fetchSearchResultChoices(
     type,
     phrase,
     offset = 10,
     max = null,
     callback,
   ) {
     let url = this.getURL(this.urlHost, "/u/posts/srch/choices");
 
     let apiUrl = url + `?phrase=${encodeURIComponent(type)}${phrase}`;
     if (offset) apiUrl += `&offset=${offset}`;
     if (max) apiUrl += `&max=${max}`;
     if (type !== "#") apiUrl += "&incl=userinfo|followings";
 
     let resultList = await this.requestGET(apiUrl, null);
 
     if (callback) return callback(resultList);
     else return resultList;
   }
 
   async searchUserResult(phrase, offset, max, callback) {
     let resultList;
     try {
       let url = this.getURL(this.urlHost, `/u/users/srch/phrase`);
       resultList = await this.requestPOST(url, {
         incl: "userinfo|followings|followers",
         q: phrase,
         offset,
         max,
       });
     } catch (e) {
       console.error(e);
     }
 
     if (callback) {
       return callback(resultList);
     } else {
       return resultList;
     }
   }
 
   /**
    * Fetch matching hashtags and suggestions.
    *
    * @param {string} keywords delimited by space
    * @param {boolean} inclSelf include own posts?
    * @param {array} field names to include in the result (catObj for whole object)
    * @param {number} max
    * @param {number} min
    * @return {XResultMap}
    */
   async fetchHashtagChoices(keywords, max = null, min = null, callback) {
     const postProcess = function (err, resultMap) {
       if (err) return callback(err, null);
       // no filter processing
       callback(null, resultMap);
     }; // postProcess
 
     let urlKwdTags = this.getURL(this.urlHost, "/u/posts/srch/choices");
     let result = this.searchPostPhrase(
       urlKwdTags,
       "#" + keywords,
       false,
       false,
       max,
       min,
       postProcess,
     );
 
     return result;
   } // fetchHashtags
 
   /**
    * Fetch matching mentions and suggestions.
    *
    * @param {string} keywords delimited by space
    * @param {boolean} inclSelf include own posts?
    * @param {array} field names to include in the result (catObj for whole object)
    * @param {number} max
    * @param {number} min
    * @return {XResultMap}
    */
   async fetchMentionChoices(keywords, max = null, min = null, callback) {
     const postProcess = function (err, resultMap) {
       if (err) return callback(err, null);
       // no filter processing
       callback(null, resultMap);
     }; // postProcess
 
     let urlKwdTags = this.getURL(this.urlHost, "/u/posts/srch/choices");
     let result = this.searchPostPhrase(
       urlKwdTags,
       "@" + keywords,
       false,
       false,
       max,
       min,
       postProcess,
     );
 
     return result;
   } // fetchMentions
 
   /**
    * Fetch a list of categories by their IDs and cache them
    *
    * @param {string} url searc h API's URL to use
    * @param {string} phrase delimited by
    * @param {string} inclFields INCL_TAGINFO for now
    * @param {string} expanded true to include expanded tags
    * @param {string} max max entries
    * @param {string} min entries, which means proceed with partial search if initial
    * result is below this number
    * @param params any arguments or filters
    * @return {XResultList}
    */
   async searchPostPhrase(
     url,
     phrase,
     inclFields = null,
     expanded = null,
     max = null,
     min = null,
     callback,
   ) {
     const _m = "shP";
 
     let apiUrl = url + "?phrase=" + encodeURIComponent(phrase);
     if (inclFields) apiUrl += `&fields=${inclFields}`;
     if (expanded) apiUrl += `&expanded=${String(expanded)}`;
     if (max) apiUrl += `&max=${max}`;
     if (min) apiUrl += `&min=${min}`;
     apiUrl += "&incl=userinfo";
     //let response = null;
     let error = null;
     let resultList;
     // debugger;
     try {
       resultList = await this.requestGET(apiUrl, null);
     } catch (e) {
       this.error(_m, e);
       error = e;
     }
     if (callback) return callback(error, resultList);
     else return resultList;
   } // searchPostPhrase
 
   // ------------------------------- POST SERVICES -----------------------------------
 
   /**
    * Submit new post (create) to server, with specs
    * for pictures
    *
    * THIS IS WORK IN PROGRESS
    *
    * @param {XMPost} newPost
    * @param {File[]} files array of local files needed
    * to trigger upload
    * @param {{}} params TBD
    * @callback callback
    */
   async submitPost(newPost, files, params, callback) {
     const _m = "subPost";
 
     // let listId = newPost.getId();
     // this.log(_m, "list to create/save ", newList);
     if (newPost.getOwnerId() == null) newPost.setOwnerId(this.getUserId());
     if (!this.validateWrite(newPost)) {
       if (callback != null) callback("Unable to Submit Post, null");
       // to-do: dee proper error object
       else return false;
     }
 
     let formData = new FormData();
     if (!newPost.hasOwner()) newPost.setOwnerId(this.getUserId());
     // formData.append("post", newPost.toJSONString()); // moved to content
     if (files && files[0]?.m3u8) {
       newPost.setVideoUrl(files[0].m3u8);
       files[0].ori && newPost.setOriginalVideoUrl(files[0].ori);
       files[0].screen && newPost.setMainImageURL(files[0].screen);
       files[0].duration &&
         newPost.setVideoDuration(parseInt(files[0].duration));
       files[0].width && newPost.setVideoWidth(parseInt(files[0].width));
       files[0].height && newPost.setVideoHeight(parseInt(files[0].height));
     } else if (files) {
       const imageFiles = [];
       const imageMeta = [];
       for (const file of files) {
         imageFiles.push(file.ori);
         const {heads, width: wid, height: hgt} = file;
         if (heads && wid && hgt) {
           imageMeta.push({wid, hgt, meta: {heads}});
         }
       }
       if (imageMeta.length) {
         newPost.setImageMeta(imageMeta);
       }
       newPost.setImageURLs(imageFiles);
     }
 
     let savedPost;
     let apiError;
     try {
       let url = this.getURL(this.urlHost, "/u/post");
       savedPost = await this.requestPOST_FormData(url, newPost, formData);
     } catch (e) {
       this.error(_m, e);
       apiError = e;
     }
     if (callback) callback(apiError, savedPost);
     else return savedPost;
   } // submitPost
 
   /**
    * Submit a repost (create) to server, with specs
    * for pictures. Repost differs from sharing a post,
    * in that it is a real post that references another
    * post.
    *
    * THIS IS WORK IN PROGRESS
    *
    * @param {XMPost} newPost
    * @param {string} refPostId referenced post
    * @param {File[]} imageFiles array of local files needed
    * to trigger upload
    * @param {{}} params TBD
    * @callback callback
    *
    * @see ~SharesXXX
    */
   async submitRepost(newPost, files, params, callback) {
     const _m = "subRepost";
 
     if (newPost.getOwnerId() == null) newPost.setOwnerId(this.getUserId());
     if (!this.validateWrite(newPost)) {
       if (callback != null) callback("Unable to Submit Repost, null");
       // to-do: dee proper error object
       else return false;
     }
 
     let formData = new FormData();
     if (!newPost.hasOwner()) newPost.setOwnerId(this.getUserId());
     // formData.append("post", newPost.toJSONString()); // moved to content
     if (files && files[0]?.m3u8) {
       newPost.setOriginalVideoUrl(files[0]);
     } else if (files) {
       const imageFiles = [];
       for (let i in files) {
         imageFiles.push(files[i].ori);
       }
       newPost.setImageURLs(imageFiles);
     }
 
     let savedPost;
     let apiError;
     try {
       let url = this.getURL(this.urlHost, "/u/repost");
       savedPost = await this.requestPOST_FormData(url, newPost, formData);
     } catch (e) {
       this.error(_m, e);
       apiError = e;
     }
     if (callback) callback(apiError, savedPost);
     else return savedPost;
   } // submitRepost
 
   /**
    * Delete a post by the owner
    *
    * @param {string} userId use user ID
    * @param {string} section one of UserProps.SETTINGS_*
    * @param {{}} params any arguments or filters
    * @return {XUserInfo} subclass of it which is basically specific
    * settings like XAccountSettings, XProfileSettings, etc.
    */
   async deletePost(postId, callback) {
     const _m = "delPost";
     let error = null;
     let result = null;
     try {
       let url = this.getURL(this.urlHost, `/u/post/${postId}`);
       result = await this.requestDELETE(url, null);
       return callback ? callback(null, result) : result;
     } catch (e) {
       this.error(_m, e);
       if (callback) callback(error, null);
       else throw e;
     }
   } // deletePost
 
   // ------------------------------- POST COMMMENTS -----------------------------------
 
   /**
    * Submit new comment to the server. If the comment object has
    * a parent comment Id, then this comment is a reply to that
    * parent comment. if parent comment Id is null, then this
    * comment is a reply to the post.
    *
    *
    * @param {string} postId post the comment is associated with, but
    * does not have to be immediate reply! can be nested.
    * @param {XMComment} newComment
    * @param {File[]} files array of local files needed
    * to trigger upload
    * @param {{}} params TBD
    * @callback callback
    */
   async submitComment(postId, newComment, files, params, callback) {
     const _m = "subPost";
 
     // let listId = newPost.getId();
     // this.log(_m, "list to create/save ", newList);
     if (postId == null) postId = newComment.getPostId();
     let parentCommentId = newComment.getParentCommentId();
     let forPost = parentCommentId == null;
     if (newComment.getOwnerId() == null)
       newComment.setOwnerId(this.getUserId());
     if (!this.validateWrite(newComment)) {
       if (callback != null) callback("Unable to Submit Comment");
       // to-do: dee proper error object
       else return false;
     }
 
     let formData = new FormData();
     if (!newComment.hasOwner()) newComment.setOwnerId(this.getUserId());
     // formData.append("post", newPost.toJSONString()); // moved to content
     if (files && files[0]?.m3u8) {
       newComment.setVideoUrl(files[0].m3u8);
       files[0].ori && newComment.setOriginalVideoUrl(files[0].ori);
       files[0].screen && newComment.setMainImageURL(files[0].screen);
       files[0].duration &&
         newComment.setVideoDuration(parseInt(files[0].duration));
       files[0].width && newComment.setVideoWidth(parseInt(files[0].width));
       files[0].height && newComment.setVideoHeight(parseInt(files[0].height));
     } else if (files) {
       const imageFiles = [];
       for (let i in files) {
         imageFiles.push(files[i].ori);
       }
       newComment.setImageURLs(imageFiles);
     }
     // formData.append("images", files);
     let savedComment;
     let apiError;
     try {
       let endpoint = forPost
         ? `/u/post/${postId}/comment`
         : `/u/comment/${parentCommentId}/comment`;
       let url = this.getURL(this.urlHost, endpoint);
       savedComment = await this.requestPOST_FormData(url, newComment, formData);
     } catch (e) {
       this.error(_m, e);
       apiError = e;
     }
     if (callback) callback(apiError, savedComment);
     else return savedComment;
   } // submitPost
 
   /**
    * Delete a post comment by the comment owner
    *
    * @param {string} postId
    * @param {string} commentId
    * @param {{}} params any arguments or filters
    * @return {XUserInfo} subclass of it which is basically specific
    * settings like XAccountSettings, XProfileSettings, etc.
    */
   async deletePostComment(commentId, callback) {
     const _m = "delPost";
     let error = null;
     let result = null;
     try {
       let url = this.getURL(this.urlHost, `/u/comment/${commentId}`);
       result = await this.requestDELETE(url, null);
       return callback ? callback(null, result) : result;
     } catch (e) {
       this.error(_m, e);
       if (callback) callback(e, null);
       else throw e;
     }
   } // deletePostComment
 
   // -------------------------- LOG SERVICES ----------------------------
 
   /**
    * Send a log record to server
    *
    * @param {XMActivityLog} activityLog constructed log
    *
    * @return {boolean} should be true if no issue. Sending is async
    */
   async transmitLog(activityLog, props = null) {
     const _m = "tlog";
     try {
       let logId = activityLog.getDerivedID();
       let url = this.urlActivityLog + logId;
       await this.requestPOST(url, activityLog);
     } catch (e) {
       // probably should keep silent in the web browser
       this.warn(_m, e);
     }
     return true;
   } // transmitLog
 
   /**
    * Log a message on the server side. This is useful for mobile
    * debugging..for now
    *
    * @param {string=} m method name (optional)
    * @param {string} msg
    */
   async logMessageServer(m, msg) {
     const _m = "logms";
     try {
       msg = m ? m + ": " + msg : msg;
       console.log(`${_m}: ${msg}`);
       await this.requestPOST(this.urlLogMessage, {msg: msg});
     } catch (e) {
       // probably should keep silent in the web browser
       this.warn(_m, e);
     }
     return true;
   }
 
   // ----------------------- USER SIGN-UP / AUTH ------------------------
 
   /**
    * User signup
    *
    * @param {string} userInfo user to follow
    *
    * @return {XUserInfo} upated user info with new follow
    */
   async signupUser(userInfo, authInfo, callback) {
     const _m = "userFollows";
     let newUser;
     let error = null;
     try {
       let content = {
         userinfo: userInfo.getData(),
         authinfo: authInfo.getData(),
       };
 
       let encrypted = Util.EncryptJSON(content);
 
       let url = this.getURL(this.urlHost, `/s/signup`);
       newUser = await this.requestPOST(url, encrypted);
     } catch (e) {
       error = XError.FromRequestError(e);
       this.error(_m, e);
 
       newUser = null;
     }
 
     return callback ? callback(error, newUser) : newUser;
   } // signupUser
 
   // ----------------------- LOAD SPECIAL RESOURCES ---------------------
 
   /**
    * Fetch help file in MD format.
    *
    * @param {string=} helpId null to retreive latest template. Give a
    * user ID will retrieve user's confirmed version.
    * @param {string} locale language requirement. default is "en"
    * @param {*} callback
    */
   async fetchHelpFile(helpId, locale, callback) {
     if (Util.StringIsEmpty(helpId)) return "No Help??";
 
     if (locale == null) locale = this.getLanguagePref();
     let url = `/doc/md/help/${locale}/${helpId}`;
     return this.fetchBinaryData(url, callback);
   }
 
   /**
    * Fetch the About Us markdown text that is suitable to display publicly.
    * @param {string} locale language. default is "en"
    * @callback
    * @return {XBinaryData} wrapper containing marked down TOS text.
    */
   async fetchAboutUs(locale, callback) {
     if (locale == null) locale = "en";
     return this.fetchBinaryData(`/doc/md/legal/${locale}/aboutus`, callback);
   }
 
   /**
    * Fetch TOS for user to confirm, or what user has already confirmed.
    *
    * @param {string=} userId null to retreive latest template. Give a
    * user ID will retrieve user's confirmed version.
    * @param {*} locale
    * @param {*} callback
    */
   async fetchUserTOS(userId, locale, callback) {
     if (locale == null) locale = "en";
     let url = userId
       ? `/doc/md/legal/${locale}/tos/user/${userId}`
       : `/doc/md/legal/${locale}/tos/user`;
     return this.fetchBinaryData(url, callback);
   }
 
   /**
    * Fetch the TOS markdown text that is suitable to display publicly.
    * @param {string} locale language. default is "en"
    * @callback
    * @return {XBinaryData} wrapper containing marked down TOS text.
    */
   async fetchPublicTOS(locale, callback) {
     if (locale == null) locale = "en";
     return this.fetchBinaryData(`/doc/md/legal/${locale}/tos/public`, callback);
   }
 
   /**
    * Fetch the DMCA notice markdown text that is suitable to display publicly.
    *
    * @param {string} locale language. default is "en"
    * @callback
    * @return {XBinaryData} wrapper containing marked down TOS text.
    */
   async fetchDMCA(locale, callback) {
     if (locale == null) locale = "en";
     return this.fetchBinaryData(`/doc/md/legal/${locale}/dmca`, callback);
   }
 
   /**
    * Fetch the user guidelines markdown text that is suitable to display publicly.
    *
    * @param {string} locale language. default is "en"
    * @callback
    * @return {XBinaryData} wrapper containing marked down TOS text.
    */
   async fetchUserGuidelines(locale, callback) {
     if (locale == null) locale = "en";
     return this.fetchBinaryData(
       `/doc/md/legal/${locale}/user_guidelines`,
       callback,
     );
   }
 
   /**
    * Fetch the legal guidelines markdown text that is suitable to display publicly.
    *
    * @param {string} locale language. default is "en"
    * @callback
    * @return {XBinaryData} wrapper containing marked down TOS text.
    */
   async fetchLegalGuidelines(locale, callback) {
     if (locale == null) locale = "en";
     return this.fetchBinaryData(
       `/doc/md/legal/${locale}/legal_guidelines`,
       callback,
     );
   }
 
   disableTranslation(flag) {
     if (flag === true) {
       this["xlate"] = false;
       console.warn("Translation Disabled");
     }
   }
 
   translationDisabled() {
     return this["xlate"] === false;
   }
 
   async translateText(fromLang, toLang, text, callback) {
     if (this.translationDisbled()) return callback(null);
 
     const API_KEY = this.getPortal().getGoogleAPIKey();
 
     let url = `https://translation.googleapis.com/language/translate/v2?key=${API_KEY}`;
     url += "&q=" + encodeURI(text);
     url += `&source=${fromLang}`;
     url += `&target=${toLang}`;
 
     fetch(url, {
       method: "GET",
       headers: {
         "Content-Type": "application/json",
         Accept: "application/json",
       },
     })
       .then((res) => res.json())
       .then(callback)
       .catch((error) => {
         console.log("There was an error with the translation request: ", error);
       });
   }
 
   /**
    *
    * @param {string} fromLang
    * @param {string} toLang
    * @param {string} text
    * @param {function(XError, *)} callback error and result
    */
   async translateText_notworking(fromLang, toLang, text, callback) {
     if (this.translationDisbled()) return callback(null);
 
     const API_KEY = this.getPortal().getGoogleAPIKey();
 
     let url = `https://translation.googleapis.com/language/translate/v2?key=${API_KEY}`;
     url += "&q=" + encodeURI(text);
     url += `&source=${fromLang}`;
     url += `&target=${toLang}`;
     return this.requestExternalGET(url, null, callback);
   }
 
   async detectLanguage(text, callback) {
     const API_KEY = this.getPortal().getGoogleAPIKey();
 
     let url = `https://translation.googleapis.com/language/translate/v2/detect?key=${API_KEY}`;
     url += "&q=" + encodeURI(text);
 
     fetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Accept: "application/json",
       },
       body: JSON.stringify({q: text}),
     })
       .then((res) => res.json())
       .then(callback)
       .catch((error) => {
         console.log("There was an error with the translation request: ", error);
       });
   }
 
   /**
    *
    * @param {string} text
    * @param {function(XError, *)} callback  error and result
    */
   async detectLanguage_notworking(text, callback) {
     // let _m = "detectLang";
     let apiKey = this.getPortal().getGoogleAPIKey();
     let url = `https://translation.googleapis.com/language/translate/v2/detect?key=${apiKey}`;
     url += "&q=" + encodeURI(text);
 
     let p = this.requestExternalPOST(url, null, (err, result) => {
       this._processResult(err, result, callback);
     });
     return p;
   }
 
   // ------------------- VERIFICATION CODE DELIVERY ---------------------
 
   /**
    * Request server to delivery a verification code to an email address
    *
    * @param {string} code clear text to show in an email
    * @param {string} email
    * @return {boolean} true if no errors, false if not delivered for any reason
    */
   async sendVerificationCode(code, email, callback) {
     const _m = "pre";
 
     let url = this.getURL(this.urlHost, "/s/pre");
     let error = null;
     let result = false;
     try {
       let content = {
         code: code,
         email: email,
       };
       result = await this.requestPOST(url, content);
     } catch (e) {
       this.error(_m, e);
       error = e;
     }
 
     return callback ? callback(error, result) : result;
   }
 
   /**
    * remove exif from image
    * @param {File} file
    */
   _removeExif(file) {
     return new Promise((resolve, reject) => {
       if (file.type !== "image/jpeg" && file.type !== "image/png") {
         return reject("Wrong file type");
       }
       const fileURL = URL.createObjectURL(file);
       const canvas = document.createElement("canvas");
       const canvasContext = canvas.getContext("2d");
       const image = new Image();
       image.src = fileURL;
       image.onload = (e) => {
         canvas.width = image.naturalWidth;
         canvas.height = image.naturalHeight;
         canvasContext.drawImage(
           e.target,
           0,
           0,
           image.naturalWidth,
           image.naturalHeight,
         );
         canvas.toBlob((blob) => {
           URL.revokeObjectURL(fileURL);
           blob.lastModifiedDate = new Date();
           blob.name = file.name;
           return resolve(blob);
         }, file.type);
       };
       image.onerror = () => {
         return reject("Failed to remove exif");
       };
     });
   }
 
   /**
    * upload file
    * @param {File} file
    * @param {Function} callback
    */
   async uploadFile(file, hasExif, callback, path = "/media/upload") {
     const fileSize = file.size;
     let md5 = null;
 
     if (fileSize <= 300000000) {
       // 300 MB
       try {
         md5 = await fileToMd5(file);
       } catch (error) {}
     }
 
     const _m = "uploadFile";
     const url = this.getURL(process.env.REACT_APP_MEDIA_UPLOAD, path);
     const formData = new FormData();
     const userInfo = this.getXUserInfo();
     const lv = userInfo.getInfluencerLevel();
     // const lv = 5;
     let result;
     let error;
     if (hasExif) {
       try {
         const blob = await this._removeExif(file);
         if (blob) {
           file = blob;
         }
       } catch (err) {
         console.log(err);
       }
     }
 
     formData.append("file", file, file.name);
     formData.append("user_id", userInfo.data._id);
     // formData.append("auth_token", this.portal.getUserToken());
     // try {
     //   this.requestPOST_FormData(url, null, formData, callback);
     // } catch (e) {
     //   this.error(_m, e);
     //   error = e;
     // }
     // return callback ? callback(error, result) : result;
     // const auth =
     //   "Basic " + Buffer.from("getterupload:getterupload").toString("base64");
     let config = {
       // withCredentials: true,
       headers: {
         // "Access-Control-Allow-Origin": "*",
         "Content-Type": "multipart/form-data",
         authorization: this.portal.getUserToken(),
         userid: this.portal.getUserId(),
         filename: file.name,
         // lossless: hasExif ? 0 : 1,
         lossless: 1,
         lv,
         env: process.env.REACT_APP_GETTER_ENV,
       },
     };
 
     if (md5) {
       config.headers.md5 = md5;
     }
     const cancelTokenSource = axios.CancelToken.source();
     const cancelUpload = cancelTokenSource.cancel;
     let complete = false;
     let timeout = false;
     let timeoutInterval = setInterval(() => {
       if (!timeout) {
         timeout = true;
       } else if (!complete) {
         cancelUpload();
       }
     }, 20000);
     axios({
       url,
       method: "post",
       data: formData,
       ...config,
       onUploadProgress: (p) => {
         timeout = false;
         if (p.loaded == p.total) {
           complete = true;
         }
         callback(null, null, 100 * (p.loaded / p.total));
       },
       cancelToken: cancelTokenSource.token,
     })
       .then((response) => {
         result = response.data;
         if (result.ori) {
           callback(null, result);
         } else {
           error = result.error;
           callback(error);
         }
       })
       .catch((e) => {
         error = e;
         callback(error);
       })
       .finally(() => {
         clearInterval(timeoutInterval);
       });
   }
 
   /**
    * Construct API URL to report content(post) (/u/user/:userId/report/post/:postId/:reasonId)
    *
    * @param {string} userId
    * @param {string} postId
    * @param {string} reasonId
    * @return {string} fully qualified URL
    */
   apiReportPost(userId, postId, reasonId) {
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/report/post/${postId}/${reasonId}`,
     );
 
     return query;
   } // apiReportPost
 
   /**
    * Construct API URL to report user (/u/user/:userId/report/user/:targetId/:reasonId)
    *
    * @param {string} userId
    * @param {string} targetId
    * @param {string} reasonId
    * @return {string} fully qualified URL
    */
   apiReportUser(userId, targetId, reasonId) {
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/report/user/${targetId}/${reasonId}`,
     );
 
     return query;
   } // apiReportUser
 
   /**
    * Report content(post) by postId and reasonId
    *
    * @param {string} postId
    * @param {number} reasonId
    */
   async reportPost(postId, reasonId, callback) {
     const _m = "reportPost";
     const loggedInUserId = this.getUserId();
     const reasonIdPrefix = "rsn";
     let result;
     let error = null;
     try {
       let getUrl = this.apiReportPost(
         loggedInUserId,
         postId,
         reasonIdPrefix + reasonId,
       );
       result = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // reportPost
 
   /**
    * Report user by target userId and reasonId
    *
    * @param {string} targetId target userId
    * @param {number} reasonId
    */
   async reportUser(targetId, reasonId, callback) {
     const _m = "reportUser";
     const loggedInUserId = this.getUserId();
     const reasonIdPrefix = "rsn";
     let result;
     let error = null;
     try {
       let getUrl = this.apiReportUser(
         loggedInUserId,
         targetId,
         reasonIdPrefix + reasonId,
       );
       result = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // reportUser
 
   /**
    * Construct API URL to get muted users (/u/user/:userId/mutes/?offset=0&max=5&incl=userstats|userinfo)
    *
    * @param {string} userId
    * @param {number} max
    * @return {string} fully qualified URL
    */
   apiGetMutedUsers(userId, max) {
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/mutes/?offset=0&max=${max}&incl=userstats|userinfo`,
     );
 
     return query;
   } // apiGetMutedUsers
 
   /**
    * Get muted users
    *
    * @param {number} max
    * @param {(error, result) => void} callback
    */
   async getMutedUsers(max = 5, callback) {
     const _m = "getMutedUsers";
     const loggedInUserId = this.getUserId();
     let result;
     let error = null;
     try {
       let getUrl = this.apiGetMutedUsers(loggedInUserId, max);
       result = await this.requestGET(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // getMutedUsers
 
   /**
    * Construct API URL to get users who I follow (/u/user/:userId/followings/?offset=0&max=5&incl=userstats|userinfo)
    *
    * @param {string} userId
    * @param {number} max
    * @return {string} fully qualified URL
    */
   apiGetFollowingUsers(userId, max) {
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/followings/?offset=0&max=${max}&incl=userstats|userinfo`,
     );
 
     return query;
   } // apiGetFollowingUsers
 
   /**
    * Get following users
    *
    * @param {string} userId
    * @param {number} max
    * @param {(error, result) => void} callback
    */
   async getFollowingUsers(userId, max = 5, callback) {
     const _m = "getFollowingUsers";
     let result;
     let error = null;
     try {
       let getUrl = this.apiGetFollowingUsers(userId, max);
       result = await this.requestGET(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // getFollowingUsers
 
   /**
    * Construct API URL to get blocked users (/u/user/:userId/blockers/?offset=0&max=5&incl=userstats|userinfo)
    *
    * @param {string} userId
    * @param {number} max
    * @return {string} fully qualified URL
    */
   apiGetBlockedUsers(userId, max) {
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/blockers/?offset=0&max=${max}&incl=userstats|userinfo`,
     );
 
     return query;
   } // apiGetBlockedUsers
 
   /**
    * Get blocked users
    *
    * @param {string} userId
    * @param {number} max
    * @param {(error, result) => void} callback
    */
   async getBlockedUsers(userId, max = 5, callback) {
     const _m = "getBlockedUsers";
     let result;
     let error = null;
     try {
       let getUrl = this.apiGetBlockedUsers(userId, max);
       result = await this.requestGET(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // getFollowing
 
   /**
    * Construct API URL to mute user (/u/user/:userId/mutes/:targetId)
    *
    * @param {string} userId
    * @param {string} targetUserId
    * @return {string} fully qualified URL
    */
   apiMuteUser(userId, targetUserId) {
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/mutes/${targetUserId}`,
     );
 
     return query;
   } // apiMuteUser
 
   /**
    * Mute user
    *
    * @param {string} targetUserId
    * @param {(error, result) => void} callback
    */
   async muteUser(targetUserId, callback) {
     const _m = "muteUser";
     const loggedInUserId = this.getUserId();
     let result;
     let error = null;
     try {
       let getUrl = this.apiMuteUser(loggedInUserId, targetUserId);
       result = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // muteUser
 
   /**
    * Unmute user
    *
    * @param {string} targetUserId
    * @param {(error, result) => void} callback
    */
   async unmuteUser(targetUserId, callback) {
     const _m = "unmuteUser";
     const loggedInUserId = this.getUserId();
     let result;
     let error = null;
     try {
       let getUrl = this.apiMuteUser(loggedInUserId, targetUserId);
       result = await this.requestDELETE(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // unmuteUser
 
   /**
    * Construct API URL to follow user (/u/user/:userId/follows/:targetId)
    *
    * @param {string} userId
    * @param {string} targetUserId
    * @return {string} fully qualified URL
    */
   apiFollowUser(userId, targetUserId) {
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/follows/${targetUserId}`,
     );
 
     return query;
   } // apiFollowUser
 
   /**
    * Follow user
    *
    * @param {string} targetUserId
    * @param {(error, result) => void} callback
    */
   async followUser(targetUserId, callback) {
     const _m = "followUser";
     const loggedInUserId = this.getUserId();
     let result;
     let error = null;
     try {
       let getUrl = this.apiFollowUser(loggedInUserId, targetUserId);
       result = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // followUser
 
   /**
    * Unfollow user
    *
    * @param {string} targetUserId
    * @param {(error, result) => void} callback
    */
   async unfollowUser(targetUserId, callback) {
     const _m = "unfollowUser";
     const loggedInUserId = this.getUserId();
     let result;
     let error = null;
     try {
       let getUrl = this.apiFollowUser(loggedInUserId, targetUserId);
       result = await this.requestDELETE(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // unfollowUser
 
   /**
    * Construct API URL to block user (/u/user/:userId/blocks/:targetId)
    *
    * @param {string} userId
    * @param {string} targetUserId
    * @return {string} fully qualified URL
    */
   apiBlockUser(userId, targetUserId) {
     let query = this.getURL(
       this.urlHost,
       `/u/user/${userId}/blocks/${targetUserId}`,
     );
 
     return query;
   } // apiBlockUser
 
   /**
    * Block user
    *
    * @param {string} targetUserId
    * @param {(error, result) => void} callback
    */
   async blockUser(targetUserId, callback) {
     const _m = "blockUser";
     const loggedInUserId = this.getUserId();
     let result;
     let error = null;
     try {
       let getUrl = this.apiBlockUser(loggedInUserId, targetUserId);
       result = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // blockUser
 
   /**
    * Unblock user
    *
    * @param {string} targetUserId
    * @param {(error, result) => void} callback
    */
   async unblockUser(targetUserId, callback) {
     const _m = "unblockUser";
     const loggedInUserId = this.getUserId();
     let result;
     let error = null;
     try {
       let getUrl = this.apiBlockUser(loggedInUserId, targetUserId);
       result = await this.requestDELETE(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // unblockUser
 
   /**
    * Construct API URL to block user (/u/user/:userId/blocks/:targetId)
    *
    * @param {string} userId
    * @param {string} targetUserId
    * @return {string} fully qualified URL
    */
   apiSuspendUser(targetUserId) {
     let query = this.getURL(
       this.urlHost,
       `/admin/user/${targetUserId}/suspend`,
     );
 
     return query;
   } // apiSuspendUser
 
   /**
    * Block user
    *
    * @param {string} targetUserId
    * @param {(error, result) => void} callback
    */
   async suspendUser(targetUserId, callback) {
     const _m = "suspendUser";
     let result;
     let error = null;
     try {
       let getUrl = this.apiSuspendUser(targetUserId);
       result = await this.requestPOST(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // suspendUser
 
   /**
    * Unblock user
    *
    * @param {string} targetUserId
    * @param {(error, result) => void} callback
    */
   async unSuspendUser(targetUserId, callback) {
     const _m = "unSuspendUser";
     let result;
     let error = null;
     try {
       let getUrl = this.apiUnSuspendUser(targetUserId);
       result = await this.requestDELETE(getUrl);
     } catch (e) {
       this.error(_m, e);
       error = e;
       result = null;
     }
 
     return callback ? callback(error, result) : result;
   } // unSuspendUser
 } // class
 
 export default GetterService;