define([
    'dojo/_base/lang',
    'dojo/_base/array',
    'dojo/_base/html',
    'dojo/_base/sniff',
    'dojo/_base/config',
    'dojo/io-query',
    'dojo/query',
    'dojo/NodeList-traverse',
    'dojo/Deferred',
    'dojo/promise/all',
    'dojo/on',
    'dojo/json',
    'dojo/cookie',
    'dojo/number',
    'dojo/date/locale',
    'dojo/i18n!dojo/cldr/nls/number',
    'dojox/encoding/base64',
    './shared/utils'
  ],

function(lang, array, html, has, config, ioQuery, query, nlt, Deferred, all, on, json, cookie,
  dojoNumber, dateLocale, nlsBundle, base64,
  sharedUtils
) {
  /* global esriConfig, dojoConfig, ActiveXObject, testLoad */
  var mo = {};

  nlt = null;

  lang.mixin(mo, sharedUtils);

  if (!window.atob) {
    window.atob = function(b64) {
      var bytes = base64.decode(b64);
      var str = "";
      for (var i = 0, len = bytes.length; i < len; i++) {
        str += String.fromCharCode(bytes[i]);
      }
      return str;
    };
  }
  if (!window.btob) {
    window.btob = function(str) {
      var bytes = [];
      for (var i = 0, len = str.length; i < len; i++) {
        bytes.push(String.charCodeAt(str[i]));
      }

      return base64.encode(bytes);
    };
  }

  var fileAPIJsStatus = 'unload'; // unload, loading, loaded
  function _loadFileAPIJs(prePath, cb) {
    prePath = prePath || "";
    var loaded = 0,
      completeCb = function() {
        loaded++;
        if (loaded === tests.length) {
          cb();
        }
      },
      tests = [{
        test: window.File && window.FileReader && window.FileList && window.Blob ||
          !mo.file.isEnabledFlash(),
        failure: [
          prePath + "libs/polyfills/fileAPI/FileAPI.js"
        ],
        callback: function() {
          completeCb();
        }
      }];

    for (var i = 0; i < tests.length; i++) {
      testLoad(tests[i]);
    }
  }

  //if no beforeId, append to head tag, or insert before the id
  function loadStyleLink(id, href, beforeId) {
    var def = new Deferred(), styleNode, styleLinkNode;

    var hrefPath = require(mo.getRequireConfig()).toUrl(href);
    //the cache will use the baseUrl + module as the key
    if(require.cache['url:' + hrefPath]){
      //when load css file into index.html as <style>, we need to fix the
      //relative path used in css file
      var cssStr = require.cache['url:' + hrefPath];
      var fileName = hrefPath.split('/').pop();
      var rpath = hrefPath.substr(0, hrefPath.length - fileName.length);
      cssStr = addRelativePathInCss(cssStr, rpath);
      if (beforeId) {
        styleNode = html.create('style', {
          id: id,
          type: "text/css"
        }, html.byId(beforeId), 'before');
      } else {
        styleNode = html.create('style', {
          id: id,
          type: "text/css"
        }, document.getElementsByTagName('head')[0]);
      }

      if(styleNode.styleSheet && !styleNode.sheet){
        //for IE
        styleNode.styleSheet.cssText = cssStr;
      }else{
        styleNode.appendChild(html.toDom(cssStr));
      }
      def.resolve('load');
      return def;
    }

    if (beforeId) {
      styleLinkNode = html.create('link', {
        id: id,
        rel: "stylesheet",
        type: "text/css",
        href: hrefPath + '?wab_dv=' + window.deployVersion
      }, html.byId(beforeId), 'before');
    } else {
      styleLinkNode = html.create('link', {
        id: id,
        rel: "stylesheet",
        type: "text/css",
        href: hrefPath + '?wab_dv=' + window.deployVersion
      }, document.getElementsByTagName('head')[0]);
    }

    on(styleLinkNode, 'load', function() {
      def.resolve('load');
    });

    var ti = setInterval(function() {
      var loadedSheet;
      if (array.some(document.styleSheets, function(styleSheet) {
        if (styleSheet.href && styleSheet.href.substr(styleSheet.href.indexOf(href),
          styleSheet.href.length) === href) {
          loadedSheet = styleSheet;
          return true;
        }
      })) {
        try{
          if (!def.isFulfilled() && (loadedSheet.cssRules && loadedSheet.cssRules.length ||
            loadedSheet.rules && loadedSheet.rules.length)) {
            def.resolve('load');
          }
          clearInterval(ti);
        }catch(err){
        }
      }
    }, 50);
    return def;
  }


  function addRelativePathInCss(css, rpath){
    var m = css.match(/url\([^)]+\)/gi), i, m2;

    if (m === null || rpath === '') {
      return css;
    }
    for (i = 0; i < m.length; i++) {
      m2 = m[i].match(/(url\(["|']?)(.*)((?:['|"]?)\))/i);
      if(m2.length >= 4){
        var path = m2[2];
        if(/^data:image\/.*;/.test(path)){
          continue;
        }
        if(!rpath.endWith('/')){
          rpath = rpath + '/';
        }
        css = css.replace(m2[1] + path + m2[3], m2[1] + rpath + path + m2[3]);
      }
    }
    return css;
  }

  var errorCheckLists = [];
  require.on("error", function(err) {
    array.forEach(errorCheckLists, function(o) {
      if (err.info[0] && err.info[0].indexOf(o.resKey) > -1) {
        o.def.reject(err);
      }
      for (var p in err.info) {
        if (p.indexOf(o.resKey) > -1) {
          o.def.reject(err);
        }
      }
    });
  });

  mo.checkError = function(resKey, def) {
    //when resKey match a error, def will be reject
    errorCheckLists.push({
      resKey: resKey,
      def: def
    });
  };

  mo.replacePlaceHolder = function(obj, props) {
    var str = json.stringify(obj),
      m = str.match(/\$\{(\w)+\}/g),
      i;

    if (m === null) {
      return obj;
    }
    for (i = 0; i < m.length; i++) {
      var p = m[i].match(/(\w)+/g)[0];
      if (props[p]) {
        str = str.replace(m[i], props[p]);
      }
    }
    return json.parse(str);
  };

  mo.changeUnit = function(val) {
    var abs = Math.abs(val),
      text, d, m, s;
    d = Math.floor(abs);
    m = Math.floor((abs - d) * 60);
    s = (((abs - d) * 60 - m) * 60).toFixed(2);
    //00B0 id degree character
    text = d + '\u00B0' + ((m < 10) ? ('0' + m) : m) + '\'' + ((s < 10) ? ('0' + s) : s) + '"';
    return text;
  };

  mo.formatTime = function(time) {
    var s = time / 1000,
      m = Math.floor(s / 60),
      s2 = Number(s - m * 60).toFixed(1),
      text = ((m < 10) ? '0' + m : m) + ':' + ((s2 < 10) ? '0' + s2 : s2);
    return text;
  };

  mo.parseTime = function(text) {
    var p = /(\d{2,})\:(\d{2})\.(\d{1})/,
      m, t;
    if (!p.test(text)) {
      console.log('wrong time format.');
      return -1;
    }
    m = text.match(p);
    t = (parseInt(m[1], 10) * 60 + parseInt(m[2], 10) + parseInt(m[3], 10) / 10) * 1000;
    return t;
  };

  mo.preloadImg = function(imgs, rpath) {
    var imgArray = [];
    if (typeof imgs === 'string') {
      imgArray = [imgs];
    } else {
      imgArray = imgs;
    }
    array.forEach(imgArray, function(imgUrl) {
      var img = new Image();
      if (rpath) {
        img.src = rpath + imgUrl;
      } else {
        img.src = imgUrl;
      }
    });
  };

  var testImageDom = null;
  mo.getImagesSize = function(imageUrl){
    var def = new Deferred();

    if (!imageUrl || imageUrl.indexOf("http") !== 0) {
      def.reject();
      return def;
    }

    if(testImageDom === null){
      testImageDom = html.create('img', {
        id: '__test-image-size',
        style: {
          position: 'absolute',
          left: '-9999px',
          top: '-9999px'
        }
      }, document.body);
    }
    var testImageHandler = on(testImageDom, "load", function(){
      clearTimeout(timeoutHandler);
      timeoutHandler = null;
      testImageHandler.remove();

      var box = html.getContentBox(testImageDom);

      if ((box.w === 1 && box.h === 1) || box.w === 0 || box.h === 0) {
        def.reject();
        return;
      }

      def.resolve([box.w, box.h]);
    }, {});

    var timeoutHandler = setTimeout(function(){
      clearTimeout(timeoutHandler);
      timeoutHandler = null;
      // image URL is invalid or takes too long; don't update it
      def.reject();
    }, 5000);

    html.setAttr(testImageDom, 'src', imageUrl);

    return def;
  };

  mo.getPositionStyle = function(_position) {
    var style = {};
    if(!_position){
      return style;
    }
    var position = lang.clone(_position);
    if(window.isRTL){
      var temp;
      if(typeof position.left !== 'undefined' && typeof position.right !== 'undefined'){
        temp = position.left;
        position.left = position.right;
        position.right = temp;
      }else if(typeof position.left !== 'undefined'){
        position.right = position.left;
        delete position.left;
      }else if(typeof position.right !== 'undefined'){
        position.left = position.right;
        delete position.right;
      }

      if(typeof position.paddingLeft !== 'undefined' &&
        typeof position.paddingRight !== 'undefined'){
        temp = position.paddingLeft;
        position.paddingLeft = position.paddingRight;
        position.paddingRight = temp;
      }else if(typeof position.paddingLeft !== 'undefined'){
        position.paddingRight = position.paddingLeft;
        delete position.paddingLeft;
      }else if(typeof position.paddingRight !== 'undefined'){
        position.paddingLeft = position.paddingRight;
        delete position.paddingRight;
      }
    }

    var ps = ['left', 'top', 'right', 'bottom', 'width', 'height',
      'padding', 'paddingLeft', 'paddingRight', 'paddingTop', 'paddingBottom'];
    for (var i = 0; i < ps.length; i++) {
      var p = ps[i];
      if (typeof position[p] === 'number') {
        style[p] = position[p] + 'px';
      } else if (typeof position[p] !== 'undefined') {
        style[p] = position[p];
      }else{
        if(p.substr(0, 7) === 'padding'){
          style[p] = 0;
        }else{
          style[p] = 'auto';
        }
      }
    }

    if(typeof position.zIndex === 'undefined'){
      //set zindex=auto instead of 0, because inner dom of widget may need to overlay other widget
      //that has the same zindex.
      style.zIndex = 'auto';
    }else{
      style.zIndex = position.zIndex;
    }
    return style;
  };

  /**
   * compare two object/array recursively
   * Note: null === null, undefined === undefined
   */
  function isEqual(o1, o2) {
    var leftChain, rightChain;

    function compare2Objects(x, y) {
      var p;
      if(x === null && y === null || typeof x === 'undefined' && typeof y === 'undefined'){
        return true;
      }

      if(x === null && y !== null || y === null && x !== null ||
        typeof x === 'undefined' && typeof y !== 'undefined' ||
        typeof y === 'undefined' && typeof x !== 'undefined'){
        return false;
      }

      // remember that NaN === NaN returns false
      // and isNaN(undefined) returns true
      if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
        return true;
      }
      // Compare primitives and functions.
      // Check if both arguments link to the same object.
      // Especially useful on step when comparing prototypes
      if (x === y) {
        return true;
      }
      // Works in case when functions are created in constructor.
      // Comparing dates is a common scenario. Another built-ins?
      // We can even handle functions passed across iframes
      if ((typeof x === 'function' && typeof y === 'function') ||
        (x instanceof Date && y instanceof Date) ||
        (x instanceof RegExp && y instanceof RegExp) ||
        (x instanceof String && y instanceof String) ||
        (x instanceof Number && y instanceof Number)) {
        return x.toString() === y.toString();
      }
      // check for infinitive linking loops
      if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
        return false;
      }
      // Quick checking of one object beeing a subset of another.
      // todo: cache the structure of arguments[0] for performance
      if (y !== null) {
        for (p in y) {
          if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
            return false;
          } else if (typeof y[p] !== typeof x[p]) {
            return false;
          }
        }
        for (p in x) {
          if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
            return false;
          } else if (typeof y[p] !== typeof x[p]) {
            return false;
          }
          switch (typeof(x[p])) {
            case 'object':
            case 'function':
              leftChain.push(x);
              rightChain.push(y);
              if (!compare2Objects(x[p], y[p])) {
                return false;
              }
              leftChain.pop();
              rightChain.pop();
              break;
            default:
              // remember that NaN === NaN returns false
              if (isNaN(x[p]) && isNaN(y[p]) && typeof x[p] === 'number' && typeof y[p] === 'number') {
                continue;
              }
              if (x[p] !== y[p]) {
                return false;
              }
              break;
          }
        }
      }

      return true;
    }

    leftChain = []; //todo: this can be cached
    rightChain = [];
    if (!compare2Objects(o1, o2)) {
      return false;
    }
    return true;
  }

  mo.isEqual = isEqual;

  //merge the target and src object/array, return the merged object/array.
  function merge(target, src) {
    var array = Array.isArray(src);
    var dst = array && [] || {};

    if (array) {
      target = target || [];
      dst = dst.concat(target);
      src.forEach(function(e, i) {
        if (typeof target[i] === 'undefined') {
          dst[i] = e;
        } else if (typeof e === 'object') {
          dst[i] = merge(target[i], e);
        } else {
          if (target.indexOf(e) === -1) {
            dst.push(e);
          }
        }
      });
    } else {
      if (target && typeof target === 'object') {
        Object.keys(target).forEach(function(key) {
          dst[key] = target[key];
        });
      }
      Object.keys(src).forEach(function(key) {
        if (typeof src[key] !== 'object' || !src[key]) {
          dst[key] = src[key];
        } else {
          if (!target[key]) {
            dst[key] = src[key];
          } else {
            dst[key] = merge(target[key], src[key]);
          }
        }
      });
    }

    return dst;
  }

  function setVerticalCenter(contextNode) {
    function doSet() {
      var nodes = query('.jimu-vcenter-text', contextNode),
        h, ph;
      array.forEach(nodes, function(node) {
        h = html.getContentBox(node).h;
        html.setStyle(node, {
          lineHeight: h + 'px'
        });
      }, this);

      nodes = query('.jimu-vcenter', contextNode);
      array.forEach(nodes, function(node) {
        h = html.getContentBox(node).h;
        ph = html.getContentBox(query(node).parent()[0]).h;
        html.setStyle(node, {
          marginTop: (ph - h) / 2 + 'px'
        });
      }, this);
    }

    //delay sometime to let browser update dom
    setTimeout(doSet, 10);
  }

  mo.file = {
    loadFileAPI: function() {
      var def = new Deferred();
      if (fileAPIJsStatus === 'unload') {
        var prePath = !!window.isBuilder ? 'stemapp/' : "";
        window.FileAPI = {
          debug: false,
          flash: true,
          staticPath: prePath + 'libs/polyfills/fileAPI/',
          flashUrl: prePath + 'libs/polyfills/fileAPI/FileAPI.flash.swf',
          flashImageUrl: prePath + 'libs/polyfills/fileAPI/FileAPI.flash.image.swf'
        };

        _loadFileAPIJs(prePath, lang.hitch(this, function() {
          fileAPIJsStatus = 'loaded';
          def.resolve();
        }));
        fileAPIJsStatus = 'loading';
      } else if (fileAPIJsStatus === 'loaded'){
        def.resolve();
      }

      return def;
    },
    supportHTML5: function() {
      if (window.File && window.FileReader && window.FileList && window.Blob) {
        return true;
      } else {
        return false;
      }
    },
    supportFileAPI: function() {
      if (has('safari') && has('safari') < 6) {
        return false;
      }
      if (window.FileAPI && window.FileAPI.readAsDataURL) {
        return true;
      }
      return false;
    },
    isEnabledFlash: function(){
      var swf = null;
      if (document.all) {
        try{
          swf = new ActiveXObject('ShockwaveFlash.ShockwaveFlash');
        }catch(e) {
          swf = null;
        }
      } else {
        if (navigator.plugins && navigator.plugins.length > 0) {
          swf = navigator.plugins["Shockwave Flash"];
        }
      }
      return !!swf;
    },
    containSeparator: function(path) {
      if (path.indexOf("/") >= 0) {
        return true;
      } else {
        if (path.indexOf("\\") >= 0) {
          return true;
        } else {
          return false;
        }
      }
    },
    getNameFromPath: function(path) {
      var separator = "";
      if (path.indexOf("/") >= 0) {
        separator = "/";
      } else {
        separator = "\\";
      }
      var segment = path.split(separator);
      if (segment.length > 0) {
        return segment[segment.length - 1];
      } else {
        return null;
      }

    },
    getFolderFromPath: function(path) {
      return path.substr(0, path.length - mo.file.getNameFromPath(path).length);
    },
    /********
     * read file by HTML5 API.
     *
     * parameters:
     * file: the file will be read.
     * filter: file type filter, files which don't match the filter will not be read and
       return false.
     * maxSize: file size which exceeds the size will return false;
     * cb: the callback function when file is read completed, signature: (err, fileName, fileData)
     */
    readFile: function(fileEvt, filter, maxSize, cb) {
      if (this.supportHTML5()) {
        var file = fileEvt.target.files[0];
        if (!file) {
          return;
        }
        // Only process image files.
        if (!file.type.match(filter)) {
          // cb("Invalid file type.");
          cb({
            errCode: "invalidType"
          });
          return;
        }

        if (file.size >= maxSize) {
          // cb("File size cannot exceed  " + Math.floor(maxSize / 1024) + "KB.");
          cb({
            errCode: "exceed"
          });
          return;
        }

        var reader = new FileReader();
        // Closure to capture the file information.
        reader.onload = function(e) {
          cb(null, file.name, e.target.result);
        };
        // Read in the image file as a data URL.
        reader.readAsDataURL(file);
      } else if (this.supportFileAPI()) {
        var files = window.FileAPI.getFiles(fileEvt);

        // Only process image files.
        if (!files[0].type.match(filter)) {
          // cb("Invalid file type.");
          cb({
            errCode: "invalidType"
          });
          return;
        }

        if (files[0].size >= maxSize) {
          // cb("File size cannot exceed  " + Math.floor(maxSize / 1048576) + "M.");
          cb({
            errCode: "exceed"
          });
          return;
        }

        window.FileAPI.readAsDataURL(files[0], function(evt) {
          if (evt && evt.result) {
            cb(null, files[0].name, evt.result);
          } else {
            cb({
              errCode: "readError"
            });
          }
        });
      }
    }
  };

  ///////////////////widget json(in app config json) processing

  mo.getUriInfo = function getUriInfo(uri) {
    var pos, firstSeg, info = {},
      amdFolder;

    pos = uri.indexOf('/');
    firstSeg = uri.substring(0, pos);

    //config using package
    amdFolder = uri.substring(0, uri.lastIndexOf('/') + 1);
    info.folderUrl = require(mo.getRequireConfig()).toUrl(amdFolder);
    info.amdFolder = amdFolder;

    info.url = info.folderUrl;//for backward compatibility

    if(/^http(s)?:\/\//.test(uri) || /^\/\//.test(uri)){
      info.isRemote = true;
    }

    return info;
  };

  mo.widgetJson = (function(){
    var ret = {};

    ret.addManifest2WidgetJson = function(widgetJson, manifest){
      lang.mixin(widgetJson, manifest.properties);
      widgetJson.name = manifest.name;
      if(!widgetJson.label){
        widgetJson.label = manifest.label;
      }
      widgetJson.manifest = manifest;
      widgetJson.isRemote = manifest.isRemote;
      if(widgetJson.isRemote){
        widgetJson.itemId = manifest.itemId;
      }
      if(manifest.featureActions){
        widgetJson.featureActions = manifest.featureActions;
      }

      if (!widgetJson.icon) {
        widgetJson.icon = manifest.icon;
      }

      if (!widgetJson.thumbnail) {
        widgetJson.thumbnail = manifest.thumbnail;
      }

      widgetJson.folderUrl = manifest.folderUrl;
      widgetJson.amdFolder = manifest.amdFolder;
    };

    ret.removeManifestFromWidgetJson = function(widgetJson){
      //we set property to undefined, instead of delete them.
      //The reason is: configmanager can't hanle delete properties for now
      if(!widgetJson.manifest){
        return;
      }
      for(var p in widgetJson.manifest.properties){
        widgetJson[p] = undefined;
      }
      widgetJson.name = undefined;
      widgetJson.label = undefined;
      widgetJson.featureActions = undefined;
      widgetJson.manifest = undefined;
    };

    ret.getUriFromItem = function(item){
      if(!item.url){
        return null;
      }

      return ret.getFolderUrlFromItem(item) + 'Widget';
    };

    ret.getFolderUrlFromItem = function(item){
      if(!item.url){
        return null;
      }

      var url;
      if(/manifest\.json$/.test(item.url)){
        url = item.url.substring(0, item.url.length - 'manifest.json'.length);
      }else if(/\/$/.test(item.url)){
        url = item.url;
      }else{
        url = item.url + '/';
      }

      if(window.location.protocol === "https:"){
        url = url.replace(/^http:\/\//, 'https://');
      }
      return url;
    };

    return ret;
  })();


  mo.getRequireConfig = function() {
    /* global jimuConfig */
    if (jimuConfig) {
      var packages = [];
      if (jimuConfig.widgetsPackage) {
        packages = packages.concat(jimuConfig.widgetsPackage);
      }
      if (jimuConfig.themesPackage) {
        packages = packages.concat(jimuConfig.themesPackage);
      }
      if (jimuConfig.configsPackage) {
        packages = packages.concat(jimuConfig.configsPackage);
      }
      return {
        packages: packages
      };
    } else {
      return {};
    }
  };

  mo.getServices = function() {
    return servicesObj;
  };

  mo.getAncestorWindow = function() {
    var w = window;
    while (w && w.parent && w !== w.parent) {
      w = w.parent;
    }
    return w;
  };

  mo.getAncestorDom = function(child, verifyFunc,
    /*HTMLElement|Number optional */ maxLoopSizeOrDom) {
    if (child && child.nodeType === 1) {
      if (verifyFunc && typeof verifyFunc === 'function') {
        var maxLoopSize = 100;
        var maxLoopDom = document.body;

        if (maxLoopSizeOrDom) {
          if (typeof maxLoopSizeOrDom === 'number') {
            //Number
            maxLoopSizeOrDom = parseInt(maxLoopSizeOrDom, 10);
            if (maxLoopSizeOrDom > 0) {
              maxLoopSize = maxLoopSizeOrDom;
            }
          } else if (maxLoopSizeOrDom.nodeType === 1) {
            //HTMLElement
            maxLoopDom = maxLoopSizeOrDom;
          }
        }

        var loop = 0;
        while (child.parentNode && loop < maxLoopSize &&
          html.isDescendant(child.parentNode, maxLoopDom)) {
          if (verifyFunc(child.parentNode)) {
            return child.parentNode;
          }
          child = child.parentNode;
          loop++;
        }
      }
    }
    return null;
  };

  mo.bindClickAndDblclickEvents = function(dom, clickCallback, dblclickCallback,
    /* optional */ _timeout) {
    var handle = null;
    var isValidDom = dom && dom.nodeType === 1;
    var isValidClick = clickCallback && typeof clickCallback === 'function';
    var isValidDblclick = dblclickCallback && typeof dblclickCallback === 'function';
    var isValid = isValidDom && isValidClick && isValidDblclick;
    if (isValid) {
      var timeout = 200;
      if (_timeout && typeof _timeout === 'number') {
        var t = parseInt(_timeout, 10);
        if (t > 0) {
          timeout = t;
        }
      }

      var clickCount = 0;
      handle = on(dom, 'click', function(evt) {
        clickCount++;
        if (clickCount === 1) {
          setTimeout(function() {
            if (clickCount === 1) {
              clickCount = 0;
              clickCallback(evt);
            }
          }, timeout);
        } else if (clickCount === 2) {
          clickCount = 0;
          dblclickCallback(evt);
        }
      });
    }
    return handle;
  };

  mo.isScrollToBottom = function(dom) {
    var box = html.getContentBox(dom);
    var a = dom.scrollTop + box.h;
    var b = dom.scrollHeight - a;
    return b < 1;
  };

  mo.getAllItemTypes = function() {
    var allTypes = [];
    //Web Content
    var maps1 = ['Web Map', 'Web Scene', 'CityEngine Web Scene'];
    var layers1 = ['Feature Service', 'Map Service', 'Image Service', 'KML', 'WMS',
    'Feature Collection', 'Feature Collection Template', 'Geodata Service', 'Globe Service'];
    var tools1 = ['Geometry Service', 'Geocoding Service', 'Network Analysis Service',
    'Geoprocessing Service'];
    var applications1 = ['Web Mapping Application', 'Mobile Application', 'Code Attachment',
    'Operations Dashboard Add In', 'Operation View'];
    var datafiles1 = ['Symbol Set', 'Color Set', 'Shapefile', 'CSV', 'Service Definition',
    'Document Link', 'Microsoft Word', 'Microsoft PowerPoint', 'Microsoft Excel', 'PDF',
    'Image', 'Visio Document'];
    //Desktop Content
    var maps2 = ['Map Document', 'Map Package', 'Tile Package', 'ArcPad Package',
    'Explorer Map', 'Globe Document', 'Scene Document', 'Published Map', 'Map Template',
    'Windows Mobile Package'];
    var layers2 = ['Layer', 'Layer Package', 'Explorer Layer'];
    var tools2 = ['Geoprocessing Package', 'Geoprocessing Sample', 'Locator Package',
    'Rule Package'];
    var applications2 = ['Workflow Manager Package', 'Desktop Application',
    'Desktop Application Template', 'Code Sample', 'Desktop Add In', 'Explorer Add In'];

    allTypes = allTypes.concat(maps1).concat(layers1).concat(tools1)
    .concat(applications1).concat(datafiles1);
    allTypes = allTypes.concat(maps2).concat(layers2).concat(tools2).concat(applications2);
    return allTypes;
  };

  mo.getItemQueryStringByTypes = function(itemTypes) {
    var queryStr = '';
    var allTypes = mo.getAllItemTypes();
    if (itemTypes && itemTypes.length > 0) {
      if (itemTypes.length > 0) {
        var validStr = '';
        array.forEach(itemTypes, function(type, index) {
          var s = ' type:"' + type + '" ';
          validStr += s;
          if (index !== itemTypes.length - 1) {
            validStr += ' OR ';
          }
        });
        queryStr = ' ( ' + validStr + ' ) ';
        var sumAllTypes = itemTypes.concat(allTypes);
        var removedTypes = array.filter(sumAllTypes, function(removedType){
          return array.every(itemTypes, function(itemType){
            return itemType.toLowerCase().indexOf(removedType.toLowerCase()) < 0;
          });
        });

        array.forEach(removedTypes, function(type) {
          var s = ' -type:"' + type + '" ';
          queryStr += s;
        });
      }
    }
    return queryStr;
  };

  mo.getItemQueryStringByTypeKeywords = function(typeKeywords){
    var queryStr = '';
    //must use double quotation marks around typeKeywords
    //typekeywords:"Web AppBuilder" or typekeywords:"Web AppBuilder,Web Map"
    if(typeKeywords && typeKeywords.length > 0){
      queryStr = ' typekeywords:"' + typeKeywords.join(',') + '" ';
    }
    return queryStr;
  };

  mo.isNotEmptyString = function(str, /* optional */ trim) {
    var b = str && typeof str === 'string';
    if (b) {
      if (trim) {
        return b && lang.trim(str);
      } else {
        return true;
      }
    } else {
      return false;
    }
  };

  mo.isNotEmptyStringArray = function(strArray, /* optional */ trim){
    for(var key = 0; key < strArray.length; key++){
      var str = strArray[key];
      var strVal = str.value ? str.value : str;
      var isNotEmpty = mo.isNotEmptyString(strVal, trim);
      if(!isNotEmpty){
        return false;
      }
    }
    return true;
  };

  mo.isValidNumber = function(num){
    return typeof num === 'number' && !isNaN(num);
  };

  mo.isValidNumberArray = function(numArray){
    for(var key = 0; key < numArray.length; key++){
      var num = numArray[key];
      num = (num.value || num.value === 0) ? num.value : num;
      var isValid = mo.isValidNumber(num);
      if(!isValid){
        return false;
      }
    }
    return true;
  };

  mo.isValidDate = function(date){
    if(date){ //null, '', undefined
      try {
        var d = new Date(date);
        return !isNaN(d.getTime()); // d.toString() === 'Invalid Date'
      }catch (err) {
        console.error(err);
        return false;
      }
    }else{
      return false;
    }
  };

  mo.isObject = function(o) {
    return o && typeof o === 'object';
  };


  mo.getRandomString = function() {
    var str = Math.random().toString();
    str = str.slice(2, str.length);
    return str;
  };

  mo._getDomainsByServerName = function(serverName){
    var splits = serverName.split('.');
    var length = splits.length;
    var domains = array.map(splits, lang.hitch(this, function(v, index){
      // jshint unused:false
      var arr = splits.slice(index, length);
      var str = "";
      var lastIndex = arr.length - 1;
      array.forEach(arr, lang.hitch(this, function(s, idx){
        str += s;
        if(idx !== lastIndex){
          str += '.';
        }
      }));
      return str;
    }));
    return domains;
  };

  mo.removeCookie = function(cookieName, path){
    var domains = this._getDomainsByServerName(window.location.hostname);

    array.forEach(domains, lang.hitch(this, function(domainName){
      cookie(cookieName, null, {
        expires: -1,
        path: path
      });

      cookie(cookieName, null, {
        expires: -1,
        path: path,
        domain: domainName
      });

      cookie(cookieName, null, {
        expires: -1,
        path: path,
        domain: '.' + domainName
      });
    }));
  };

  mo.isLocaleChanged = function(oldLocale, newLocale){
    return !oldLocale.startWith(newLocale);
  };

  mo.hashToObject = function(hashStr){
    hashStr = hashStr.replace('#', '');
    var hashObj = ioQuery.queryToObject(hashStr);
    for (var p in hashObj) {
      if (hashObj.hasOwnProperty(p)) {
        try {
          hashObj[p] = json.parse(hashObj[p]);
        } catch (err) {
          continue;
        }
      }
    }
    return hashObj;
  };

  mo.reCreateObject = function(obj) {
    //summary:
    //  because of dojo's lang.isArray issue, we need re-create the array properties
    var ret;

    function copyArray(_array) {
      var retArray = [];
      _array.forEach(function(a) {
        if (Array.isArray(a)) {
          retArray.push(copyArray(a));
        } else if (typeof a === 'object') {
          retArray.push(copyObject(a));
        } else {
          retArray.push(a);
        }
      });
      return retArray;
    }

    function copyObject(_obj) {
      var ret = {};
      for (var p in _obj) {
        if (!_obj.hasOwnProperty(p)) {
          continue;
        }
        if(_obj[p] === null){
          ret[p] = null;
        }else if (Array.isArray(_obj[p])) {
          ret[p] = copyArray(_obj[p]);
        } else if (typeof _obj[p] === 'object') {
          ret[p] = copyObject(_obj[p]);
        } else {
          ret[p] = _obj[p];
        }
      }
      return ret;
    }

    if (Array.isArray(obj)) {
      ret = copyArray(obj);
    } else {
      ret = copyObject(obj);
    }
    return ret;
  };

  mo.setVerticalCenter = setVerticalCenter;
  mo.merge = merge;
  mo.loadStyleLink = loadStyleLink;

  mo.changeLocation = function(newUrl){
    // debugger;
    if (window.history.pushState) {
      window.history.pushState({path:newUrl}, '', encodeURI(newUrl));
    }/*else{
      window.location.href = newUrl;
    }*/
  };

  /////////////widget and theme manifest processing/////////
  mo.manifest = (function(){
    var ret = {};

    function addThemeManifestProperies(manifest) {
      manifest.panels.forEach(function(panel) {
        panel.uri = 'panels/' + panel.name + '/Panel.js';
      });

      manifest.styles.forEach(function(style) {
        style.uri = 'styles/' + style.name + '/style.css';
      });

      manifest.layouts.forEach(function(layout) {
        layout.uri = 'layouts/' + layout.name + '/config.json';
        layout.icon = 'layouts/' + layout.name + '/icon.png';
        layout.RTLIcon = 'layouts/' + layout.name + '/icon_rtl.png';
      });
    }

    function addWidgetManifestProperties(manifest) {
      //because tingo db engine doesn't support 2D, 3D property, so, change here
      if (typeof manifest['2D'] !== 'undefined') {
        manifest.support2D = manifest['2D'];
      }
      if (typeof manifest['3D'] !== 'undefined') {
        manifest.support3D = manifest['3D'];
      }

      if (typeof manifest['2D'] === 'undefined' && typeof manifest['3D'] === 'undefined') {
        manifest.support2D = true;
      }

      delete manifest['2D'];
      delete manifest['3D'];

      if (typeof manifest.properties === 'undefined') {
        manifest.properties = {};
      }

      sharedUtils.processWidgetProperties(manifest);
    }

    ret.addManifestProperies = function(manifest) {
      if(!manifest.icon){
        manifest.icon = manifest.folderUrl + 'images/icon.png?wab_dv=' + window.deployVersion;
      }

      if (!manifest.thumbnail) {
        manifest.thumbnail = manifest.folderUrl + 'images/thumbnail.png';
      }

      if(manifest.category === "theme") {
        addThemeManifestProperies(manifest);
      } else {
        addWidgetManifestProperties(manifest);
      }
    };

    ret.processManifestLabel = function(manifest, locale){
      var langCode = locale.split('-')[0];
      manifest.label = manifest.i18nLabels && (manifest.i18nLabels[locale] || manifest.i18nLabels[langCode] ||
        manifest.i18nLabels.defaultLabel) ||
        manifest.label ||
        manifest.name;
      if(manifest.layouts){
        array.forEach(manifest.layouts, function(layout){
          var key = 'i18nLabels_layout_' + layout.name;
          layout.label = manifest[key] && (manifest[key][locale] ||
            manifest[key].defaultLabel) ||
            layout.label ||
            layout.name;
        });
      }
      if(manifest.styles){
        array.forEach(manifest.styles, function(_style){
          var key = 'i18nLabels_style_' + _style.name;
          _style.label = manifest[key] && (manifest[key][locale] ||
            manifest[key].defaultLabel) ||
            _style.label ||
            _style.name;
        });
      }
    };

    ret.addI18NLabel = function(manifest){
      var def = new Deferred();
      if(manifest.i18nLabels){
        def.resolve(manifest);
        return def;
      }
      manifest.i18nLabels = {};

      if(manifest.properties && manifest.properties.hasLocale === false){
        def.resolve(manifest);
        return def;
      }

      //theme or widget label
      var nlsFile;
      if(manifest.isRemote){
        nlsFile = manifest.amdFolder + 'nls/strings.js';
      }else{
        nlsFile = manifest.amdFolder + 'nls/strings';
      }
      require(mo.getRequireConfig(), ['dojo/i18n!' + nlsFile],
      function(localeStrings){
        var localesStrings = {};
        localesStrings[dojoConfig.locale] = localeStrings;
        sharedUtils.addI18NLabelToManifest(manifest, null, localesStrings);
        def.resolve(manifest);
      });

      return def;
    };
    return ret;
  })();

  mo.isNumberField = function(fieldType){
    var numberFieldTypes = [
      'esriFieldTypeOID',
      'esriFieldTypeSmallInteger',
      'esriFieldTypeInteger',
      'esriFieldTypeSingle',
      'esriFieldTypeDouble'
    ];
    return numberFieldTypes.indexOf(fieldType) >= 0;
  };

  mo.getTime = function (date) {
    var _off = date.getTimezoneOffset();
    var _offTimes = _off < 0 ? "+" + (Math.abs(_off) / 60) : "-" + (_off / 60);
    return date.getTime() + _offTimes * 60 * 60 * 1000;
  };


  mo._getValues = function(layerDefinition, fieldPopupInfo, fieldName, values){
    var valueLabels = [];
    var fieldInfo = mo.getFieldInfoByFieldName(layerDefinition.fields, fieldName);
    var codedValueObj = null;//{value:label}
    var isNumberField = mo.isNumberField(fieldInfo.type);
    var isDateField = fieldInfo.type === 'esriFieldTypeDate' ? true : false;
    if(fieldInfo){
      if(isNumberField){
        values = array.map(values, function(v){
          var r = parseFloat(v);
          if(isNaN(r)){
            r = null;
          }
          return r;
        });
      }else if(isDateField){
        values = array.map(values, lang.hitch(this, function(v) {
          if(mo.isValidDate(v)){
            //convert it to num when server returns a purely numeric string
            // var numExp = new RegExp("^[0-9]*$");
            // if(typeof v === 'string' && numExp.test(v)){
            //   v = parseInt(v, 10);
            // }
            // var r = mo.localizeDateByFieldInfo(v, fieldPopupInfo);
            //display locate time to user
            var dFormat = fieldPopupInfo ? fieldPopupInfo.format.dateFormat : '';
            var newV = dFormat.indexOf('Time') < 0? v: mo.getTime(new Date(v));
            var r = mo.localizeDateByFieldInfo(new Date(newV), fieldPopupInfo);
            return r;
            // return v;
          }else{
            return v;
            // return null;
          }
        }));
      }
      //coded values
      var domainValLabels = mo.getCodedValueListForCodedValueOrSubTypes(layerDefinition, fieldName);//[{value,label}]
      if(domainValLabels !== null){
        codedValueObj = {};
        for(var key = 0; key < domainValLabels.length; key ++){
          codedValueObj[domainValLabels[key].value] = domainValLabels[key].label;
        }
      }
    }
    valueLabels = array.map(values, function(value){
      var label = null;
      if(value === null || value === undefined){
        label = '<Null>';
      }else{
        if(codedValueObj && codedValueObj.hasOwnProperty(value)){
          label = codedValueObj[value];
        }else{
          if(isNumberField){
            if(fieldPopupInfo){
              label = mo.localizeNumberByFieldInfo(value, fieldPopupInfo);
            }else{
              label = mo.localizeNumber(value);
            }
            // }else if(isDateField){
            //   var dFormat = fieldPopupInfo ? fieldPopupInfo.format.dateFormat : '';
            //   var newV = dFormat.indexOf('Time') < 0? value: mo.getTime(new Date(value));
            //   label = mo.localizeDateByFieldInfo(new Date(newV), fieldPopupInfo);
          }else{
            label = value;
          }
        }
      }
      return {
        value: value,
        label: label
      };
    });
    return valueLabels;
  };



  //get codedValue or types count, return number
  mo.getCodedValuesOrTypesCount = function(fieldInfo, layerDefinition){
    if(fieldInfo){
      if(layerDefinition.typeIdField && layerDefinition.typeIdField.toUpperCase() === fieldInfo.name.toUpperCase() &&
        layerDefinition.types){
        return layerDefinition.types.length;
      }else{
        var codedValues = mo._getAllCodedValue(layerDefinition, fieldInfo);
        return codedValues ? codedValues.length : 0;
      }
    }
    return 0;
  };

  mo.isCodedValuesSupportFilter = function(layerDefinition, codedValueLength){
    var version = parseFloat(layerDefinition.currentVersion);
    return codedValueLength <= parseFloat(layerDefinition.maxRecordCount) && version > 10.1;
  };

  mo.combineRadioCheckBoxWithLabel = function(inputDom, labelDom){
    var isValidInput = false;
    if(inputDom && inputDom.nodeType === 1 && inputDom.tagName.toLowerCase() === 'input'){
      var inputType = inputDom.getAttribute('type') || '';
      inputType = inputType.toLowerCase();
      if(inputType === 'radio' || inputType === 'checkbox'){
        isValidInput = true;
      }
    }
    var isValidLabel = false;
    if(labelDom && labelDom.nodeType === 1 && labelDom.tagName.toLowerCase() === 'label'){
      isValidLabel = true;
    }
    if(isValidInput && isValidLabel){
      var inputId = inputDom.getAttribute('id');
      if(!inputId){
        inputId = "input_" + mo.getRandomString();
        inputDom.setAttribute('id', inputId);
      }
      labelDom.setAttribute('for', inputId);
      html.setStyle(labelDom, 'cursor', 'pointer');
    }
  };

  //return handle array, the handles can be owned by widget
  mo.groupRadios = function(radios, /*optional*/ listener){
    var handles = [];
    var name = "radiogroup_" + mo.getRandomString();
    array.forEach(radios, function(radio){
      radio.name = name;
      if(listener){
        var handle = on(radio, 'change', listener);
        handles.push(handle);
      }
    });
    return handles;
  };

  mo.combineGeometriesByGraphics = function(graphics){
    var geometry = null;
    if(graphics && graphics.length > 0){
      var geometries = array.map(graphics, function(graphic){
        return graphic.geometry;
      });
      geometry = mo.combineGeometries(geometries);
    }
    return geometry;
  };

  mo.isFeaturelayerUrlSupportQuery = function(featureLayerUrl, capabilities){
    var isSupportQuery = false;
    var isFeatureService = (/\/featureserver\//gi).test(featureLayerUrl);
    var isMapService = (/\/mapserver\//gi).test(featureLayerUrl);
    capabilities = capabilities || '';
    capabilities = capabilities.toLowerCase();
    if (isFeatureService) {
      isSupportQuery = capabilities.indexOf('query') >= 0;
    } else if (isMapService) {
      isSupportQuery = capabilities.indexOf('data') >= 0;
    }
    return isSupportQuery;
  };

  mo.isImageServiceSupportQuery = function(capabilities){
    capabilities = capabilities || '';
    return capabilities.toLowerCase().indexOf('catalog') >= 0;
  };

  mo.isStringEndWith = function(s, endS){
    return (s.lastIndexOf(endS) + endS.length === s.length);
  };

  /*
  *Optional
  *An object with the following properties:
  *pattern (String, optional):
  *override formatting pattern with this string. Default value is based on locale.
   Overriding this property will defeat localization. Literal characters in patterns
   are not supported.
  *type (String, optional):
  *choose a format type based on the locale from the following: decimal, scientific
   (not yet supported), percent, currency. decimal by default.
  *places (Number, optional):
  *fixed number of decimal places to show. This overrides any information in the provided pattern.
  *round (Number, optional):
  *5 rounds to nearest .5; 0 rounds to nearest whole (default). -1 means do not round.
  *locale (String, optional):
  *override the locale used to determine formatting rules
  *fractional (Boolean, optional):
  *If false, show no decimal places, overriding places and pattern settings.
  */
  mo.localizeNumber = function(num, options){
    var decimalStr = num.toString().split('.')[1] || "",
          decimalLen = decimalStr.length;
    var _pattern = "";
    var places = options && isFinite(options.places) && options.places;
    if (places > 0 || decimalLen > 0) {
      var patchStr = Array.prototype.join.call({
        length: places > 0 ? (places + 1) : decimalLen
      }, '0');
      _pattern = "#,###,###,##0.0" + patchStr;
    }else {
      _pattern = "#,###,###,##0";
    }

    var _options = {
      locale: config.locale,
      pattern: _pattern
    };
    lang.mixin(_options, options || {});

    try {
      var fn = dojoNumber.format(num, _options);
      return fn;
    } catch (err) {
      console.error(err);
      return num.toLocaleString();
    }
  };

  /*
  *Optional
  *An object with the following properties:
  *pattern (String, optional):
  *override formatting pattern with this string. Default value is based on locale.
   Overriding this property will defeat localization. Literal characters in patterns
   are not supported.
  *type (String, optional):
  *choose a format type based on the locale from the following: decimal,
   scientific (not yet supported), percent, currency. decimal by default.
  *locale (String, optional):
  *override the locale used to determine formatting rules
  *strict (Boolean, optional):
  *strict parsing, false by default. Strict parsing requires input as produced by the
   format() method. Non-strict is more permissive, e.g. flexible on white space, omitting
   thousands separators
  *fractional (Boolean|Array, optional):
  *Whether to include the fractional portion, where the number of decimal places are
   implied by pattern or explicit 'places' parameter. The value [true,false] makes the
   fractional portion optional.
  */
  mo.parseNumber = function(numStr, options){
    var _options = {
      locale: config.locale
    };
    lang.mixin(_options, options || {});
    try {
      var dn = dojoNumber.parse(numStr, _options);
      return dn;
    } catch(err) {
      console.error(err);
      return numStr;
    }
  };

  /*
  *Optional
  *An object with the following properties:
  *selector (String):
  *choice of 'time','date' (default: date and time)
  *formatLength (String):
  *choice of long, short, medium or full (plus any custom additions). Defaults to 'short'
  *datePattern (String):
  *override pattern with this string
  *timePattern (String):
  *override pattern with this string
  *am (String):
  *override strings for am in times
  *pm (String):
  *override strings for pm in times
  *locale (String):
  *override the locale used to determine formatting rules
  *fullYear (Boolean):
  *(format only) use 4 digit years whenever 2 digit years are called for
  *strict (Boolean):
  *(parse only) strict parsing, off by default
  */
  mo.localizeDate = function(d, options){
    var _options = {
      locale: config.locale,
      fullYear: true
    };
    lang.mixin(_options, options || {});

    if(config.locale === 'ar' && _options.formatLength !== 'long' && _options.formatLength !== 'full') {
      _options.formatLength = 'long';
    }

    try {
      var ld = dateLocale.format(d, _options);
      return ld;
    } catch(err) {
      console.error(err);
      if (_options.selector === 'date') {
        return d.toLocaleDateString();
      } else if (_options.selector === 'time') {
        return d.toLocaleTimeString();
      } else {
        return d.toLocaleString();
      }
    }
  };

  /*
  *n: Number
  *fieldInfo: https://developers.arcgis.com/javascript/jshelp/intro_popuptemplate.html
  */
  mo.localizeNumberByFieldInfo = function(n, fieldInfo) {
    var fn = null;
    var p = lang.exists('format.places', fieldInfo) && fieldInfo.format.places;
    fn = mo.localizeNumber(n, {
      places: p
    });

    if (lang.exists('format.digitSeparator', fieldInfo) && !fieldInfo.format.digitSeparator) {
      return fn.toString().replace(new RegExp('\\' + nlsBundle.group, "g"), "");
    } else {
      return fn;
    }
  };

  mo.fieldFormatter = {
    getFormattedUrl: function(str) {
      if (str && typeof str === "string") {
        var s = str.indexOf('http:');
        if (s === -1) {
          s = str.indexOf('https:');
        }
        if (s > -1) {
          if (str.indexOf('href=') === -1) {
            var e = str.indexOf(' ', s);
            if (e === -1) {
              e = str.length;
            }
            var nl = str.indexOf('\r\n', s) > -1 ? str.indexOf('\r\n', s) :
              str.indexOf('\n', s) > -1 ? str.indexOf('\n', s) : e;
            e = nl < e ? nl : e;
            var link = str.substring(s, e);
            str = str.substring(0, s) +
              '<A href="' + link + '" target="_blank">' + link + '</A>' +
              str.substring(e, str.length);
          }
        }
      }

      if(typeof str === undefined || str === null){
        return '';
      }

      return str;
    },

    getFormattedNumber: function(num, format) {
      if (typeof num === 'number') {
        var decimalStr = num.toString().split('.')[1] || "",
          decimalLen = decimalStr.length;
        num = mo.localizeNumberByFieldInfo(num, {
          format: {
            places: (format && typeof format.places === 'number') ?
              parseInt(format.places, 10) : decimalLen,
            digitSeparator: format && format.digitSeparator
          }
        });
        return '<span class="jimu-numeric-value">' + (num || "") + '</span>';
      }
      return num;
    },

    getFormattedDate: function(timeNumber, format) {
      if (typeof timeNumber === 'number' || timeNumber instanceof Date) {
        timeNumber = mo.localizeDateByFieldInfo(timeNumber, {
          'format': format
        });
      }
      return timeNumber || "";
    },


    getTypeName: function(value, types) {
      var len = types.length;
      for (var i = 0; i < len; i++) {
        if (value === types[i].id) {
          return types[i].name;
        }
      }
      return value;
    }
  };

  mo.addRelativePathInCss = addRelativePathInCss;



  mo.processUrlInWidgetConfig = function(url, widgetFolderUrl){
    if(!url){
      return;
    }
    if(url.startWith('data:') || url.startWith('http') || url.startWith('/')){
      return url;
    }else if(url.startWith('${appPath}')){
      return url.replace('${appPath}', window.appInfo.appPath);
    }else{
      return widgetFolderUrl + url;
    }
  };

  mo.processUrlInAppConfig = function(url){
    if(!url){
      return;
    }
    if(url.startWith('data:') || url.startWith('http') || url.startWith('/')){
      return url;
    }else{
      return window.appInfo.appPath + url;
    }
  };

  mo.getDefaultWebMapThumbnail = function(){
    return require.toUrl('jimu/images/webmap.png');
  };

  mo.invertColor = function(hexTripletColor) {
    var color = hexTripletColor;
    color = color.substring(1);           // remove #
    if (color.length === 3) {
      color = color.slice(0, 1) +
              color.slice(0, 1) +
              color.slice(1, 1) +
              color.slice(1, 1) +
              color.slice(2, 1) +
              color.slice(2, 1);
    }
    color = parseInt(color, 16);          // convert to integer
    if(color > 7829367) {
      return "#000000";
    } else {
      return "#ffffff";
    }
  };

  mo.isLightColor = function(colorHex){
    var color = colorHex;
    color = color.substring(1);           // remove #
    if (color.length === 3) {
      color = color.slice(0, 1) +
              color.slice(0, 1) +
              color.slice(1, 1) +
              color.slice(1, 1) +
              color.slice(2, 1) +
              color.slice(2, 1);
    }
    color = parseInt(color, 16);          // convert to integer
    if(color > 7829367) {
      return true;
    } else {
      return false;
    }
  };

  /*
  Mixin config2 to config1, return the mixed object, but do not modify config1.
  What to mixin:
    replace widget's position, group's panel position, map's position.
  */
  mo.mixinAppConfigPosition = function(config1, config2){
    var mixinConfig = lang.clone(config1);
    if(!config2){
      return mixinConfig;
    }
    config2 = lang.clone(config2);
    var os1 = mixinConfig.widgetOnScreen;
    var os2 = config2.widgetOnScreen;
    if(os2 && os2.widgets){
      if(Object.prototype.toString.call(os2.widgets) ===
        '[object Object]'){

        array.forEach(os1.widgets, function(widget1, i){
          var k;
          if(widget1.uri){
            k = widget1.uri;
          }else{
            k = 'ph_' + i;
          }

          if(os2.widgets[k] && os2.widgets[k].position){
            if(!os2.widgets[k].position.relativeTo){
              os2.widgets[k].position.relativeTo = 'map';
            }
            widget1.position = os2.widgets[k].position;
          }
        }, this);
      }else{
        array.forEach(os2.widgets, function(widget2, i){
          if(widget2.position && !widget2.position.relativeTo){
            widget2.position.relativeTo = 'map';
          }
          if(os1.widgets[i] && widget2.position){
            os1.widgets[i].position = widget2.position;
          }
        });
      }
    }

    if(os2 && os2.groups){
      if(Object.prototype.toString.call(os2.groups) ===
        '[object Object]'){

        array.forEach(os1.groups, function(group1, i){
          var k;
          if(group1.label){
            k = group1.label;
          }else{
            k = 'g_' + i;
          }

          if(os2.groups[k] && os2.groups[k].panel && os2.groups[k].panel.position){
            if(!os2.groups[k].panel.position.relativeTo){
              os2.groups[k].panel.position.relativeTo = 'map';
            }
            group1.panel.position = os2.groups[k].panel.position;
          }
        }, this);
      }else{
        var managerName;
        if(config1.layoutDefinition){
          managerName = config1.layoutDefinition.manager;
        }else{
          managerName = 'jimu/layoutManagers/AbsolutePositionLayoutManager';
        }

        if(managerName === 'jimu/layoutManagers/AbsolutePositionLayoutManager'){
          array.forEach(os2.groups, function(group2, i){
            if(group2.panel && group2.panel.position &&
              !group2.panel.position.relativeTo){
              group2.panel.position.relativeTo = 'map';
            }
            if(os1.groups[i] && group2.panel && group2.panel.position){
              os1.groups[i].panel.position = group2.panel.position;
            }
          });
        }else if(managerName === 'jimu/layoutManagers/GridLayoutManager'){
          os1.groups = handleGridLayoutOnScreenGroupChange(os1.groups, os2.groups.map(function(g){
            return g.id;
          }));
        }
      }
    }

    if(config2.map && config2.map.position){
      if(mixinConfig.map){
        mixinConfig.map.position = config2.map.position;
      }else{
        mixinConfig.map = {position: config2.map.position};
      }
    }

    if(config2.widgetPool && config2.widgetPool.panel){
      if(config2.widgetPool.panel.position && !config2.widgetPool.panel.position.relativeTo){
        config2.widgetPool.panel.position.relativeTo = 'map';
      }
      mixinConfig.widgetPool.panel.position = config2.widgetPool.panel.position;
    }

    //mobileLayout is used to override it's main config, so replace totally
    if(config2.mobileLayout){
      mixinConfig.mobileLayout = config2.mobileLayout;
    }
    return mixinConfig;
  };

  function handleGridLayoutOnScreenGroupChange(oldGroups, newGroupIds){
    var oldGroupIds = oldGroups.map(function(g){
      return g.id;
    });

    array.forEach(newGroupIds, function(gId){
      if(oldGroupIds.indexOf(gId) < 0){// new add group
        oldGroups.push({
          id: gId,
          widgets: []
        });
      }
    }, this);

    var removedGroups = [];
    oldGroups = array.filter(oldGroups, function(g){
      if(newGroupIds.indexOf(g.id) < 0){// group is removed
        removedGroups.push(g);
        return false;
      }else{
        return true;
      }
    }, this);

    if(oldGroups.length === 0){
      return [];
    }
    //put widgets in removed groups into the last group
    var toAddGroup = oldGroups[oldGroups.length - 1];
    array.forEach(removedGroups, function(removedGroup){
      toAddGroup.widgets = toAddGroup.widgets.concat(removedGroup.widgets);
    }, this);

    oldGroups = oldGroups.sort(function(g1, g2){
      return newGroupIds.indexOf(g1.id) - newGroupIds.indexOf(g2.id);
    });

    return oldGroups;
  }

  mo.handleGridLayoutOnScreenGroupChange = handleGridLayoutOnScreenGroupChange;

  /**********************************
   * About template
   **********************************/

  // reset some field of config by template config.
  function getOrSetConfigByTemplate(config, key, value) {
    //config: Object
    //  the destination config object
    //key: String
    //  the key value relative to the config object, like this: app_p1_p2[0], app_p1_p2[1]--
    //value: String
    // value is undefined: get the value correspond to the key and save to 'value' param.
    // value is not undefined: set the value of key.
    var keyArray = convertToKeyArray(key);

    var obj = config;
    for (var i = 1; i < keyArray.length - 1; i++) {
      obj = getSubObj(obj, keyArray[i]);
      if (!obj) {
        return;
      }
    }

    if (keyArray[keyArray.length - 1].deleteFlag) {
      if (value === true) {
        if (lang.isArray(obj[keyArray[keyArray.length - 1].key])) {
          delete obj[keyArray[keyArray.length - 1].key][keyArray[keyArray.length - 1].index];
        } else {
          delete obj[keyArray[keyArray.length - 1].key];
        }
      }
    } else {
      if (lang.isArray(obj[keyArray[keyArray.length - 1].key])) {
        if(value === undefined) {
          // get value to valueParam
          return obj[keyArray[keyArray.length - 1].key][keyArray[keyArray.length - 1].index];
        } else {
          // set value to config
          obj[keyArray[keyArray.length - 1].key][keyArray[keyArray.length - 1].index] = value;
        }
      } else {
        if(value === undefined) {
          return obj[keyArray[keyArray.length - 1].key];
        } else {
          obj[keyArray[keyArray.length - 1].key] = value;
        }
      }
    }

    function getSubObj(obj, keyInfo) {
      if (lang.isArray(obj[keyInfo.key])) {
        return obj[keyInfo.key][keyInfo.index];
      } else {
        return obj[keyInfo.key];
      }
    }

    function convertToKeyArray(str) {
      var arrayKey = [];
      str.split('_').forEach(function(str) {
        var deleteFlag = false;
        var pos;
        if (str.slice(str.length - 2) === "--") {//Builder will not export this kind of key.
          deleteFlag = true;
          str = str.slice(0, str.length - 2);
        }
        pos = str.search(/\[[0-9]+\]/);
        if (pos === -1) {
          (pos = str.length);
        }
        arrayKey.push({
          "key": str.slice(0, pos),
          "index": Number(str.slice(pos + 1, -1)),
          "deleteFlag": deleteFlag
        });
      });
      return arrayKey;
    }
  }



  // reset some field of config by template config.
  function getOrSetConfigByTemplateWithId(config, key, value) {
    //config: Object
    //  the destination config object
    //key: String
    //  the key value relative to the config object, like this: app_p1_p2[0], app_p1_p2[1]--;
    //  howover, if the key is a wiget element, the key like this: app_p1_p2[widgetId];
    //  does not set anything if the key is not valid.
    //value: String
    // value is undefined: get the value correspond to the key and return value.
    // value is not undefined: set the value of key.



    // section means widget or group
    var groupSearchStr  = "groups\\[.+\\]";
    var widgetSearchStr = "widgets\\[.+\\]";
    var sectionConfig = config;

    key = key.replace(/\//g, '_');
    var sectionKey    = key;

    // Do not merge fields that in the widget config,
    // beacuse widgetConfig has not been loaded before open
    // widget if the widget has not been edited yet.
    // Merge it when first open widget(In Widgetmanager.js).
    //
    // if(key.search("widgets\\[.+\\]_config") >= 0) {
    //   return;
    // }
    // does not neet to "return null", regarde widget_config_key as invalid key.

    // handle groups
    var groupInfo = getSectionObject(groupSearchStr);
    if (groupInfo.state === "deleted") {
      return;
    } else if (groupInfo.state === "isSection") {
      sectionConfig = groupInfo.object;
      sectionKey = groupInfo.key;
    }

    // handle widgets
    var widgetInfo = getSectionObject(widgetSearchStr);
    if (widgetInfo.state === "delete") {
      return;
    } else if (widgetInfo.state === "isSection") {
      sectionConfig = widgetInfo.object;
      sectionKey = widgetInfo.key;
    }

    return getOrSetConfigByTemplate(sectionConfig, sectionKey, value);

    function getSectionObject(sectionSearchStr) {
      var sectionRange = mo.template.getSearchRange(key, sectionSearchStr, "]");
      var sectionStr   = key.slice(sectionRange.firstPos, sectionRange.lastPos);// section[abcd]
      // It's section node.
      if (sectionRange.firstPos !== -1) {
        var sectionId = key.slice(sectionRange.firstPos + sectionStr.indexOf('[') + 1,
          sectionRange.lastPos - 1);
        var subKey   = key.slice(sectionRange.lastPos + 1);
        var sectionObject = mo.getConfigElementById(config, sectionId);
        if (sectionObject) {
          return {
            object: sectionObject,
            key:  "section_" + subKey,
            state: "isSection"
          };
        } else {
          // means the section had been deleted.
          return {
            state: "deleted"
          };
        }
      } else {
        //It is not a section node.
        return {
          state: "isNotSection"
        };
      }
    }
  }


  mo.template = {
    groupIdentification: "groups\\[.+\\]",

    widgetIdentification: "widgets\\[.+\\]",

    getSearchRange: function(srcStr, searchStr, lastString) {
      // return value:{
      //   firstPos:
      //   lastPos:
      //}
      // if firstPos === -1: does not find searchStr from srcStr
      var posResult = -1, regExp, pos1, pos2, tempStr;
      regExp = new RegExp(searchStr);
      pos1 = srcStr.search(regExp);
      if (pos1 >= 0 ) {
        tempStr = srcStr.slice(pos1, srcStr.length);
        pos2 = tempStr.indexOf(lastString);
        posResult = pos1 + pos2 + lastString.length;
      }
      return {
        firstPos: pos1,
        lastPos: posResult
      };
    },

    setConfigValue: function(config, key, value) {
      //config: Object
      //  the destination config object
      //key: String
      //  the key value relative to the config object, like this: app_p1_p2[0], app_p1_p2[1]--
      getOrSetConfigByTemplate(config, key, value);
    },

    getConfigValue: function(config, key) {
      //config: Object
      //  the destination config object
      //key: String
      //  the key value relative to the config object, like this: app_p1_p2[0], app_p1_p2[1]--
      // return value:
      //  return value of key of config.
      //  return 'undefined' if the key is invalid.
      return getOrSetConfigByTemplate(config, key);
    },

    setConfigValueWithId: function(config, key, value) {
      //config: Object
      //  the destination config object
      //key: String
      //  the key value relative to the config object, like this: app_p1_p2[0], app_p1_p2[1]--
      //  howover, if the key is a wiget element, the key like this: app_p1_p2[widgetId]
      getOrSetConfigByTemplateWithId(config, key, value);
    },

    getConfigValueWithId: function(config, key) {
      //config: Object
      //  the destination config object
      //key: String
      //  the key value relative to the config object, like this: app_p1_p2[0], app_p1_p2[1]--
      //  howover, if the key is a wiget element, the key like this: app_p1_p2[widgetId]
      // return value:
      //  return value of key of config.
      //  return 'undefined' if the key is invalid.
      return getOrSetConfigByTemplateWithId(config, key);
    },

    getKeyInfo: function(key){
      var widgetId = this.getWidgetIdByKey(key);
      if(widgetId !== null){
        return {
          type: 'widget',
          id: widgetId
        };
      }else{
        var groupId = this.getGroupIdByKey(key);
        if(groupId !== null){
          return {
            type: 'group',
            id: groupId
          };
        }else{
          return {
            type: 'unknow', //TODO
            id: null
          };
        }
      }
    },

    getWidgetIdByKey: function(key) {
      //key: String
      //  the key value relative to the config object, like this: app_p1_p2[0], app_p1_p2[1]--
      // id: if its a widget.
      // null: it is not a widget
      var widgetId;
      var widgetRange = mo.template.getSearchRange(key,
                                                   mo.template.widgetIdentification, "]");
      if(widgetRange.firstPos === -1) {
        widgetId = null;
      } else {
        // widget[widget_id]
        var widgetStr  = key.slice(widgetRange.firstPos, widgetRange.lastPos);
        widgetId = key.slice(widgetRange.firstPos + widgetStr.indexOf('[') + 1,
                                       widgetRange.lastPos - 1);
      }
      return widgetId;

    },

    getGroupIdByKey: function(key) {
      //key: String
      //  the key value relative to the config object, like this: app_p1_p2[0], app_p1_p2[1]--
      //return value:
      // id: if its a group.
      // null: it is not a group

      //TODO widget in group should be widget
      var groupId;
      var groupRange = mo.template.getSearchRange(key,
                                                   mo.template.groupIdentification, "]");
      if(groupRange.firstPos === -1) {
        groupId = null;
      } else {
        // group[group_id]
        var groupStr  = key.slice(groupRange.firstPos, groupRange.lastPos);
        groupId = key.slice(groupRange.firstPos + groupStr.indexOf('[') + 1,
                                       groupRange.lastPos - 1);
      }
      return groupId;
    },


    getConfigedWidgetsByTemplateConfig: function(templateConfig) {
      var widgetIds = [];
      var widgetConfigIdentification = mo.template.widgetIdentification + "_config";
      var widgetConfigRange;

      array.forEach(templateConfig.configurationSettings, function(category) {
        array.forEach(category.fields, function(field) {
          if(field.fieldName) {
            widgetConfigRange = mo.template.getSearchRange(field.fieldName,
                                            widgetConfigIdentification, "]");
            if(widgetConfigRange.firstPos >= 0) {
              // the widget has config property.
              pushWithoutRepeat(widgetIds, mo.template.getWidgetIdByKey(field.fieldName));
            }
          }
        }, this);
      }, this);

      return widgetIds;

      function pushWithoutRepeat(desArray, value) {
        if(desArray.indexOf(value) === -1) {
          desArray.push(value);
        }
      }
    },

    // getConfigedWidgetsByTemplateAppConfig: function(templateAppConfig) {
    //   // return value.
    //   //   widget IDs arrary that contain all widgets which have been configed.

    //   var widgetIds = [];
    //   var widgetConfigIdentification = mo.template.widgetIdentification + "_config";
    //   var widgetConfigRange;

    //   for (var key in templateAppConfig.values) {
    //     if(templateAppConfig.values.hasOwnProperty(key) &&
    //        (typeof templateAppConfig.values[key] !== 'function')) {
    //       widgetConfigRange = mo.template.getSearchRange(key,
    //                                       widgetConfigIdentification, "]");
    //       if(widgetConfigRange.firstPos >= 0) {
    //         // the widget has config property.
    //         pushWithoutRepeat(widgetIds, mo.template.getWidgetIdByKey(key));
    //       }
    //     }
    //   }

    //   return widgetIds;

    //   function pushWithoutRepeat(desArray, value) {
    //     if(desArray.indexOf(value) === -1) {
    //       desArray.push(value);
    //     }
    //   }
    // },

    mergeTemplateAppConfigToAppConfig: function(appConfig, templateAppConfig, webmapInfo){
      //webmapInfo != undefined means templateAppConfig is from AGOL,
      //use this webmap info in appConfig
      var i;
      var screenSectionConfig = appConfig.widgetOnScreen;
      var portalUrl = appConfig.portalUrl;

      //Both WAB template app and AGOL template app have webmap value
      if(templateAppConfig.values.webmap){
        //app created from mycontent has no webmap
        appConfig.map.itemId = templateAppConfig.values.webmap;
      }

      if(webmapInfo){
        // use default mapOptions of current webmap.
        if(appConfig.map.mapOptions){
          mo.deleteMapOptions(appConfig.map.mapOptions);
        }
        appConfig.map.portalUrl = portalUrl;

        if (!templateAppConfig.values.app_title) {
          templateAppConfig.values.app_title = webmapInfo.title;
        }
        if (!templateAppConfig.values.app_subtitle) {
          templateAppConfig.values.app_subtitle = webmapInfo.snippet;
        }
      }

      //merge values
      for (var key in templateAppConfig.values) {
        if (key !== "webmap") {
          mo.template.setConfigValueWithId(appConfig, key, templateAppConfig.values[key]);
        }
      }

      reorder();

      function reorder() {
        //reorderWidgets
        appConfig.widgetPool.widgets = reorderWidgets(appConfig.widgetPool.widgets);
        screenSectionConfig.widgets = reorderWidgets(screenSectionConfig.widgets);
        if (appConfig.widgetPool.groups) {
          for (i = 0; i < appConfig.widgetPool.groups.length; i++) {
            appConfig.widgetPool.groups[i].widgets =
            reorderWidgets(appConfig.widgetPool.groups[i].widgets);
          }
        }
        if (screenSectionConfig.groups) {
          for (i = 0; i < screenSectionConfig.groups.length; i++) {
            screenSectionConfig.groups[i].widgets =
            reorderWidgets(screenSectionConfig.groups[i].widgets);
          }
        }
      }

      function reorderWidgets(widgetArray) {
        var tempWidgets = [];
        array.forEach(widgetArray, function(widget) {
          if (widget) {
            tempWidgets.push(widget);
          }
        }, this);
        return tempWidgets;
      }

      return appConfig;
    }
  };

  mo.sanitizeHTML = function(snippet){
    /* global html_sanitize */

    //https://code.google.com/p/google-caja/wiki/JsHtmlSanitizer
    return html_sanitize(snippet, function(url){
      return url;
    }, function(v){
      return v;
    });
  };

  mo.stripHTML = function (str){
    if (!str) {
      return str;
    }
    if (str.indexOf("<") > -1 && str.indexOf(">") > -1) {
      // this gets pretty slow if the string is long and has a < and no >
      var matchTag = /<(?:.|\s)*?>/g;
      return str.replace(matchTag, "");
    } else {
      return str;
    }
  };

  mo.encodeHTML = function (source) {
    return String(source)
      .replace(/&/g, '&amp;')
      .replace(/</g, '&lt;')
      .replace(/>/g, '&gt;')
      .replace(/"/g, '&quot;')
      .replace(/'/g, '&#39;');
  };

  mo.removeSuffixSlashes = function(url){
    return url.replace(/\/*$/g, '');
  };

  mo.getBestDisplayAttributes = function(attributes, fieldInfos) {
    var displayAttributes = {};
    var displayValue = null;
    for (var fieldName in attributes) {
      displayValue = mo.getBestDisplayValue(fieldName, attributes, fieldInfos);
      displayAttributes[fieldName] = displayValue;
    }
    return displayAttributes;
  };

  mo.getBestDisplayValue = function(fieldName, attributes, fieldInfoOrFieldInfos) {
    var displayValue = "";
    var fieldInfo = null;
    if (lang.isArrayLike(fieldInfoOrFieldInfos)) {
      var fieldInfos = fieldInfoOrFieldInfos;
      fieldInfo = mo.getFieldInfoByFieldName(fieldInfos, fieldName);
    } else if (typeof fieldInfoOrFieldInfos === 'object') {
      if(fieldInfoOrFieldInfos.name === fieldName){
        fieldInfo = fieldInfoOrFieldInfos;
      }
    }

    if (fieldInfo) {
      displayValue = attributes[fieldName];
      if (fieldInfo.type === 'esriFieldTypeDate') {
        if (displayValue) {
          var date = new Date(parseInt(displayValue, 10));
          displayValue = mo._tryLocaleDate(date);
        }
      } else {
        if (typeof displayValue === 'number') {
          if (fieldInfo.domain && fieldInfo.domain.type === 'codedValue') {
            array.some(fieldInfo.domain.codedValues, function(codedValue) {
              if (codedValue.code === displayValue) {
                displayValue = codedValue.name;
                return true;
              }
            });
          } else {
            displayValue = mo._tryLocaleNumber(displayValue);
          }
        }
      }
    }

    if (displayValue === null || displayValue === undefined) {
      displayValue = "";
    }

    return displayValue;
  };

  //only get codedValues in field domain
  //return [{value,label}], return null means not coded value field
  mo._getCodedValues = function(fieldInfo) {
    var codedValues = null;
    var domain = fieldInfo.domain;
    if (domain && domain.type === 'codedValue') {
      if (domain.codedValues && domain.codedValues.length > 0) {
        codedValues = domain.codedValues;
        //{code,name}=>{value,label}
        //code is value and name is description
        codedValues = array.map(codedValues, lang.hitch(this, function(item) {
          return {
            value: item.code,
            label: item.name
          };
        }));
      }
    }
    return codedValues;
  };

  //get subtypes list in subtypes property
  //return [{value,label}], return null means no subtypes
  mo._getSubTypes = function(layerDefinition) {
    var subTypes = null;
    if (layerDefinition.subtypeField && layerDefinition.subtypes && layerDefinition.subtypes.length > 0) {
      //{id,name}=>{value,label}
      subTypes = array.map(layerDefinition.subtypes, lang.hitch(this, function(item) {
        return {
          value: item.id,
          label: item.name
        };
      }));
    }
    return subTypes;
  };

  //get renders list in types property
  //return [{value,label}], return null means no render types
  mo._getRenderTypes = function(layerDefinition) {
    var subTypes = null;
    if (layerDefinition.typeIdField && layerDefinition.types && layerDefinition.types.length > 0) {
      //{id,name}=>{value,label}
      subTypes = array.map(layerDefinition.types, lang.hitch(this, function(item) {
        return {
          value: item.id,
          label: item.name
        };
      }));
      //update labels by render
      // subTypes = mo._updateCodedValueListFromRender(layerDefinition, subTypes);
    }
    return subTypes;
  };

  //return [{value,label}], maybe return null
  mo._getCodedValueOrSubtypes = function(layerDefinition, fieldName, /*optional*/ typeIdFieldValue){
    //http://servicesdev1.arcgis.com/5uh3wwYLNzBuU0Eu/arcgis/rest/services/CarsandLivingThings/FeatureServer/0?f=pjson
    var fieldInfo = mo.getFieldInfoByFieldName(layerDefinition.fields, fieldName);
    var codedValues;
    //query codedvalue from types-domain
    if(typeIdFieldValue !== undefined && typeIdFieldValue !== null){ //it can be 0(number)
      codedValues = mo._getCodedValueBySubTypeId(layerDefinition, fieldName, typeIdFieldValue, /*optional*/fieldInfo);
    }else{
      codedValues = mo._getAllCodedValue(layerDefinition, fieldInfo);
    }
    return codedValues;

    /*
    //http://servicesdev1.arcgis.com/5uh3wwYLNzBuU0Eu/arcgis/rest/services/CarsandLivingThings/FeatureServer/0?f=pjson
    var fieldInfo = mo.getFieldInfoByFieldName(layerDefinition.fields, fieldName);
    //check normal coded values
    var codedValues = mo._getCodedValues(fieldInfo);//[{value,label}]

    if(!codedValues || codedValues.length === 0){
      if (layerDefinition.typeIdField) {
        var subTypes = mo._getRenderTypes(layerDefinition);//[{value,label}]

        //typeIdField maybe doesn't match the real subtype field exactly
        if (layerDefinition.typeIdField.toUpperCase() === fieldName.toUpperCase()) {
          //check subtypes
          codedValues = subTypes;
        }else{
          //check codedvalues related to subtype
          if(typeIdFieldValue !== undefined && typeIdFieldValue !== null){
            if(layerDefinition.types && layerDefinition.types.length > 0){
              array.some(layerDefinition.types, lang.hitch(this, function(item){
                if(item.name === typeIdFieldValue){
                  if(item.type === 'codedValue'){
                    codedValues = item.codedValues;
                  }
                  return true;
                }else{
                  return false;
                }
              }));
            }
          }
        }
      }
    }
    return codedValues;
    */
  };

  //return {isCodedValueOrSubtype,displayValue}
  mo._getDisplayValueForCodedValueOrSubtype = function(layerDefinition, fieldName, fieldValue,
    /*optional*/ typeIdFieldValue){
    var result = {
      isCodedValueOrSubtype: false,
      displayValue: fieldValue + ''//convert it to a string if it's a numberical value.
    };

    //[{value,label}]
    var codedValues = mo._getCodedValueOrSubtypes(layerDefinition, fieldName, typeIdFieldValue);

    if(codedValues && codedValues.length > 0){
      array.some(codedValues, lang.hitch(this, function(item){
        if(item.value === fieldValue){
          result = {
            isCodedValueOrSubtype: true,
            displayValue: item.label
          };
          return true;
        }else{
          return false;
        }
      }));
    }
    return result;
  };


  // Delete subtype related properties for 6.3 ---temp function
  // subtypeField(string fieldName), subtypes(array)
  // These two properties are used to verify if a layer has subtype field,
  // we can get subtype field name by subtypeField property, get subtype configuration by subtypes property.
  // But right now, this is not yet supported with online or enterprise hosted feature services.
  //                Only enterprise gdb based feature survices have it(10.5 added).
  // It's hard to prepare this condition to test it now, so leave it to next release.
  mo._deleteSubtypePropertiesTemp = function(layerDefinition){
    delete layerDefinition.subtypeField;
    delete layerDefinition.subtypes;
  };

  //get display label by code from a feature attributes
  //attributes is feature's attributes
  //return {isCodedValueOrSubtype,displayValue}
  mo.getDisplayValueForCodedValueOrSubtype = function(layerDefinition, fieldName, attributes){
    mo._deleteSubtypePropertiesTemp(layerDefinition);
    var fieldValue = attributes[fieldName];
    var typeIdFieldValue;
    var typeIdField = layerDefinition.typeIdField;
    if(attributes.hasOwnProperty(typeIdField)){
      typeIdFieldValue = attributes[typeIdField];
    }

    var subtypeField = layerDefinition.subtypeField;
    if(subtypeField && layerDefinition.subtypes && layerDefinition.subtypes.length > 0){
      if(attributes.hasOwnProperty(subtypeField)){
        typeIdFieldValue = attributes[subtypeField];
      }
    }

    var result = mo._getDisplayValueForCodedValueOrSubtype(layerDefinition, fieldName, fieldValue, typeIdFieldValue);
    if(layerDefinition.typeIdField === fieldName){
      var codedvalue = [{value: attributes[fieldName], label: result.displayValue}];
      result.displayValue = mo._updateCodedValueListFromRender(layerDefinition, codedvalue)[0].label;
    }
    return result;

  };

  //get fieldValue's displayValue from a codedValues array
  //return {isCodedValueOrSubtype,displayValue}
  mo._getDisplayValueFromCodedValues = function(fieldValue, codedValues){
    var result = {
      isCodedValueOrSubtype: false,
      displayValue: fieldValue + '' //convert it to a string if it's a numberical value.
    };
    if(codedValues && codedValues.length > 0){
      array.some(codedValues, lang.hitch(this, function(item){
        if(item.value === fieldValue){
          result = {
            isCodedValueOrSubtype: true,
            displayValue: item.label
          };
          return true;
        }else{
          return false;
        }
      }));
    }
    result.value = fieldValue;
    return result;
  };

  //get display label list by code from a feature attributes
  //attributesList is a array of feature's attributes
  //return [{isCodedValueOrSubtype,value,label}]
  mo.getDisplayValueForCodedValueOrSubtypeBatch = function(layerDefinition, fieldName, attributesList){
    mo._deleteSubtypePropertiesTemp(layerDefinition);
    var codedValueHash = {};
    var typeIdField = layerDefinition.typeIdField;
    var subtypeField = layerDefinition.subtypeField;
    var fieldInfo = mo.getFieldInfoByFieldName(layerDefinition.fields, fieldName);
    if(subtypeField && layerDefinition.subtypes && layerDefinition.subtypes.length > 0){
      codedValueHash.subType = mo._getSubTypes(layerDefinition);//subtype list
      typeIdField = subtypeField;
      codedValueHash.all = mo._getAllCodedValueNew(layerDefinition, fieldInfo); //all codedvalue list
    }else{
      codedValueHash.all = mo._getAllCodedValue(layerDefinition, fieldInfo); //all codedvalue list
      codedValueHash.subType = mo._getRenderTypes(layerDefinition);//subtype list
    }
    if(codedValueHash.subType && codedValueHash.subType.length > 0){
      var subTypeValues = codedValueHash.subType;
      for(var index in subTypeValues){
        var stValue = subTypeValues[index].value;
        //codedvalue list by subtypeid
        // codedValueHash[stValue] = mo._getCodedValueBySubTypeId(layerDefinition, fieldName, stValue, fieldInfo);
        var list = mo._getCodedValueBySubTypeId(layerDefinition, fieldName, stValue, fieldInfo);
        codedValueHash[stValue] = layerDefinition.typeIdField === fieldName ?
          mo._updateCodedValueListFromRender(layerDefinition, list): list;
      }
    }

    //get labels by render
    if(layerDefinition.typeIdField === fieldName){
      codedValueHash.subType = mo._updateCodedValueListFromRender(layerDefinition, codedValueHash.subType);
      codedValueHash.all = mo._updateCodedValueListFromRender(layerDefinition, codedValueHash.all);
    }

    var codedValueList = [];
    var resultList = [];
    for(var key in attributesList){
      var attrs = attributesList[key];
      var fieldValue = attrs[fieldName];
      var typeIdFieldValue;
      if(typeIdField === fieldName){
        codedValueList = codedValueHash.subType;
      }else{
        if(attrs.hasOwnProperty(typeIdField)){
          typeIdFieldValue = attrs[typeIdField];
          codedValueList = codedValueHash[typeIdFieldValue];
          if(!codedValueList){//pass a error subtype, could get null from hash.
            codedValueList = mo._getCodedValues(fieldInfo); //return field domain
            if(layerDefinition.typeIdField === fieldName){
              codedValueList = mo._updateCodedValueListFromRender(layerDefinition, codedValueList);
            }
          }
        }else{
          codedValueList = codedValueHash.all;
        }
      }

      var result = mo._getDisplayValueFromCodedValues(fieldValue, codedValueList);
      resultList.push(result);
    }
    return resultList;

    /*
    var codedValueHash = {};
    var typeIdField = layerDefinition.typeIdField;
    codedValueHash.subType = mo._getRenderTypes(layerDefinition);//subtype list
    var fieldInfo = mo.getFieldInfoByFieldName(layerDefinition.fields, fieldName);
    if(codedValueHash.subType && codedValueHash.subType.length > 0){
      var subTypeValues = codedValueHash.subType;
      for(var index in subTypeValues){
        var stValue = subTypeValues[index].value;
        //codedvalue list by subtypeid
        codedValueHash[stValue] = mo._getCodedValueBySubTypeId(layerDefinition, fieldName, stValue, fieldInfo);
      }
    }
    codedValueHash.all = mo._getAllCodedValue(layerDefinition, fieldInfo); //all codedvalue list

    var codedValueList = [];
    var resultList = [];
    for(var key in attributesList){
      var attrs = attributesList[key];
      var fieldValue = attrs[fieldName];
      var typeIdFieldValue;
      if(typeIdField === fieldName){
        codedValueList = codedValueHash.subType;
      }else{
        if(attrs.hasOwnProperty(typeIdField)){
          typeIdFieldValue = attrs[typeIdField];
          codedValueList = codedValueHash[typeIdFieldValue];
        }else{
          codedValueList = codedValueHash.all;
        }
      }

      var result = mo._getDisplayValueFromCodedValues(fieldValue, codedValueList);
      resultList.push(result);
    }
    return resultList;
    */
  };

  //three states: code is not in hash, same code and diff label, same sode and label
  mo._getUniquCodedValue = function(hash, key, value){
    if(hash[key]){
      if(value === hash[key]){
      }else{
        hash[key] = hash[key] + ', ' + value;
      }
    }else{
      hash[key] = value;
    }
    return hash;
  };

  //get all codedValues by types&field.domains
  mo._getAllCodedValue = function(layerDefinition, fieldInfo){
    // var domain = fieldInfo.domain;
    var fieldName = fieldInfo.name;
    var codedValsHash = {}; //for Removing the duplicate value by code
    var codedValues = null;
    var ifFirstInherited = true;
    //a field could has codedvalue in types even its domain in fields is null
    // if(domain && domain.type === 'codedValue'){
    //get codeValues in types
    if(layerDefinition.typeIdField && layerDefinition.types && layerDefinition.types.length > 0){
      array.map(layerDefinition.types, lang.hitch(this, function(item){
        if(item.domains && item.domains[fieldName]){
          var fieldDomainInfo = item.domains[fieldName];
          if(fieldDomainInfo.type === 'inherited'){
            if(ifFirstInherited){
              ifFirstInherited = false;
              var valsArray = mo._getCodedValues(fieldInfo);
              array.map(valsArray, lang.hitch(this, function(_item){
                // codedValsHash[_item.value] = _item.label;
                codedValsHash = mo._getUniquCodedValue(codedValsHash, _item.value, _item.label);
              }));
            }
          }else{
            if(fieldDomainInfo.codedValues && fieldDomainInfo.codedValues.length > 0){
              array.map(fieldDomainInfo.codedValues, lang.hitch(this, function(_item){
                // codedValsHash[_item.code] = _item.name;
                codedValsHash = mo._getUniquCodedValue(codedValsHash, _item.code, _item.name);
              }));
            }
          }
        }
      }));
      if(!codedValues){//types array does not has this key.(maybe it's not the subtype field)
        codedValues = mo._getCodedValues(fieldInfo);
      }
    }else{ //get codeValues in fields domain
      return this._getCodedValues(fieldInfo);
    }
    var codedValuesArray = [];
    var isNumberField = mo.isNumberField(fieldInfo.type);
    for(var key in codedValsHash){
      var newKey = isNumberField ? parseInt(key, 10) : key;
      codedValuesArray.push({
        value: newKey,
        label: codedValsHash[key]
      });
    }
    // }
    if(codedValuesArray.length > 0){
      codedValues = codedValuesArray;
    }
    return codedValues;
  };

  //get all codedValues by types&field.domains
  mo._getAllCodedValueNew = function(layerDefinition, fieldInfo){
    // var domain = fieldInfo.domain;
    var fieldName = fieldInfo.name;
    var codedValsHash = {}; //for Removing the duplicate value by code
    var codedValues = null;
    var ifFirstInherited = true;
    //a field could has codedvalue in types even its domain in fields is null
    // if(domain && domain.type === 'codedValue'){
    //get codeValues in types
    if(layerDefinition.subtypeField && layerDefinition.subtypes && layerDefinition.subtypes.length > 0){
      array.map(layerDefinition.subtypes, lang.hitch(this, function(item){
        if(item.domains && item.domains[fieldName]){
          var fieldDomainInfo = item.domains[fieldName];
          if(fieldDomainInfo.type === 'inherited'){
            if(ifFirstInherited){
              ifFirstInherited = false;
              var valsArray = mo._getCodedValues(fieldInfo);
              array.map(valsArray, lang.hitch(this, function(_item){
                // codedValsHash[_item.value] = _item.label;
                codedValsHash = mo._getUniquCodedValue(codedValsHash, _item.value, _item.label);
              }));
            }
          }else{
            if(fieldDomainInfo.codedValues && fieldDomainInfo.codedValues.length > 0){
              array.map(fieldDomainInfo.codedValues, lang.hitch(this, function(_item){
                // codedValsHash[_item.code] = _item.name;
                codedValsHash = mo._getUniquCodedValue(codedValsHash, _item.code, _item.name);
              }));
            }
          }
        }
      }));
      if(!codedValues){//types array does not has this key.(maybe it's not the subtype field)
        codedValues = mo._getCodedValues(fieldInfo);
      }
    }else{ //get codeValues in fields domain
      return this._getCodedValues(fieldInfo);
    }
    var codedValuesArray = [];
    var isNumberField = mo.isNumberField(fieldInfo.type);
    for(var key in codedValsHash){
      var newKey = isNumberField ? parseInt(key, 10) : key;
      codedValuesArray.push({
        value: newKey,
        label: codedValsHash[key]
      });
    }
    // }
    if(codedValuesArray.length > 0){
      codedValues = codedValuesArray;
    }
    return codedValues;
  };

  //get codedvalue list by sutType Id
  //return [{value,label}]
  mo._getCodedValueBySubTypeId = function(layerDefinition, fieldName, typeIdFieldValue, /*optional*/fieldInfo){
    var type = 'typeIdField', arrayType = 'types';
    if(layerDefinition.subtypeField && layerDefinition.subtypes && layerDefinition.subtypes.length > 0){
      type = 'subtypeField';
      arrayType = 'subtypes';
    }

    var codedValues = null ;
    fieldInfo = fieldInfo ? fieldInfo : mo.getFieldInfoByFieldName(layerDefinition.fields, fieldName);
    if(layerDefinition[type] && layerDefinition[arrayType] && layerDefinition[arrayType].length > 0){
      array.map(layerDefinition[arrayType], lang.hitch(this, function(item){
        if(item.id === typeIdFieldValue){
          if(fieldName === layerDefinition[type]){//subtype field---in fact: render field
            codedValues = [{
              value: item.id,
              label: item.name
            }];
            return true;
          }
          else if(item.domains && item.domains[fieldName]){//other fields
            var fieldDomainInfo = item.domains[fieldName];
            if(fieldDomainInfo.type === 'inherited'){
              codedValues = mo._getCodedValues(fieldInfo);
            }else{
              if(fieldDomainInfo.codedValues && fieldDomainInfo.codedValues.length > 0){
                codedValues = array.map(fieldDomainInfo.codedValues, lang.hitch(this, function(_item){
                  return {
                    value: _item.code,
                    label: _item.name
                  };
                }));
              }
            }
          }
          //undefined in domains, when field is subtype field or some error data like#13631.
          else if(item.domains){
            codedValues = mo._getCodedValues(fieldInfo);
          }
        }
      }));
      if(!codedValues){//types array does not has this key.(maybe it's not the subtype field)
        codedValues = mo._getCodedValues(fieldInfo);
      }
    }else{
      codedValues = mo._getCodedValues(fieldInfo); //if the field isn't in types array but has its own domain codedvalue
    }
    return codedValues;
  };

  //get codedvalue list, return all or some by subtypeId from a feature attributes
  //attributes:feature's attributes or a obj of same format(it may has a subtype field or not).
  //return [{value,label}], return null means no subtypes or no coded value field
  mo.getCodedValueListForCodedValueOrSubTypes = function(layerDefinition, fieldName, attributes){
    mo._deleteSubtypePropertiesTemp(layerDefinition);
    var codedValues = null ;
    var fieldInfo = mo.getFieldInfoByFieldName(layerDefinition.fields, fieldName);

    var typeIdFieldValue, subtypeFieldValue;
    if(attributes){
      typeIdFieldValue = attributes[layerDefinition.typeIdField]; //it can be 0(number)
      subtypeFieldValue = attributes[layerDefinition.subtypeField]; //it can be 0(number)
    }

    if(layerDefinition.subtypeField && layerDefinition.subtypes && layerDefinition.subtypes.length > 0){
      //current field is subtype field
      if(fieldName === layerDefinition.subtypeField){
        codedValues = mo._getSubTypes(layerDefinition); //get subtyps list
        if(subtypeFieldValue !== undefined){
          var _valueInfo = mo._getDisplayValueFromCodedValues(subtypeFieldValue, codedValues);
          codedValues = [{
            value:_valueInfo.value,
            label:_valueInfo.displayValue
          }];
        }
      }else{
        if(subtypeFieldValue === undefined){//return all domains from subtype list
          codedValues = mo._getAllCodedValueNew(layerDefinition, fieldInfo);
        }else{//return one domain from current subtype value
          //get codedvalues list, from layerDefinition.subtypes..domain.
          codedValues = mo._getCodedValueBySubTypeId(layerDefinition, fieldName, subtypeFieldValue, fieldInfo);
        }
      }
      //update labels from render(if render current field)
      if(fieldName === layerDefinition.typeIdField){ //update labels from render
        codedValues = mo._updateCodedValueListFromRender(layerDefinition, codedValues);
      }
      return codedValues;
    }else{ //no subtype field
      // if(layerDefinition.subtypeField === ''){ //no subtype field
      layerDefinition.subtypeField = '';
      layerDefinition.subtypes = [];
      //continue old logic.
    }

    //current fieldName is typeIdField
    if(layerDefinition.typeIdField && layerDefinition.typeIdField.toUpperCase() === fieldName.toUpperCase()){
      codedValues = mo._getRenderTypes(layerDefinition);
      if(attributes && typeIdFieldValue !== undefined && typeIdFieldValue !== null){ //attributes has subtype field, return one data
        var valueInfo = mo._getDisplayValueFromCodedValues(typeIdFieldValue, codedValues);
        codedValues = [{
          value:valueInfo.value,
          label:valueInfo.displayValue
        }];
      }
    }else{ //other fields
      if(attributes && typeIdFieldValue !== undefined && typeIdFieldValue !== null){ //attributes has subtype field, so filter it
        codedValues = mo._getCodedValueBySubTypeId(layerDefinition, fieldName, typeIdFieldValue, fieldInfo);
      }else{
        codedValues = mo._getAllCodedValue(layerDefinition, fieldInfo);
      }
    }
    if(fieldName === layerDefinition.typeIdField){ //update labels from render
      codedValues = mo._updateCodedValueListFromRender(layerDefinition, codedValues);
    }
    return codedValues;
  };

  //check if current field is subtype field, and which field is subtype field from layerDefiniton
  mo._verifyIfFieldIsSubtypeField = function(layerDefinition, fieldInfo){
    var info = {
      isSubtypeField: false, // if current field is subtype field.
      subtypeField: '' //the name of the subtype field.
    };
    //version:10.5+, it's subtype 's fieldName if layer has a subtype field, not undefined or ''
    //subtypeField is a layer property that is set to the name of the subtype field.
    //If the layer does not have subtypes, it is set to empty string ("subtypeField": "").
    if(layerDefinition.subtypeField){
      info = {
        isSubtypeField: layerDefinition.subtypeField === fieldInfo.name,
        subtypeField: layerDefinition.subtypeField
      };
      return info;
    }

    //old versions need fieldInfo to verify
    var isRenderBySubtype = false;
    var subtypeFieldTypes = [
      'esriFieldTypeSmallInteger',
      'esriFieldTypeInteger'
    ];
    //1. render by current field, it maybe the subtype field.
    //2. checkout types.domain to verify
    if(subtypeFieldTypes.indexOf(fieldInfo.type) && layerDefinition.typeIdField === fieldInfo.name &&
      (layerDefinition.types && layerDefinition.types.length > 0)){
      var domains = layerDefinition.types[0].domains;
      //when layer has error data like: domain={}, then can't tell if it's subtype field.
      if(domains[fieldInfo.name] === undefined){
        info = {
          isSubtypeField: true,
          subtypeField: fieldInfo.name
        };
      }else{ // current field is existed in domains, so it can't be subtype field
        info.isSubtypeField = false;
      }
    }
    return isRenderBySubtype;
  };

  //no render https://sampleserver6.arcgisonline.com/arcgis/rest/services/911CallsHotspot/MapServer/2?f=json
  mo._getRenderValueLabelsForUnique = function(layerDefinition){
    var valueLabels = null;
    if(layerDefinition.drawingInfo && layerDefinition.drawingInfo.renderer &&
      layerDefinition.drawingInfo.renderer.type === 'uniqueValue'){
      valueLabels = {};
      var uniqueValueInfos = layerDefinition.drawingInfo.renderer.uniqueValueInfos;
      for(var key = 0; key < uniqueValueInfos.length; key ++){
        var info = uniqueValueInfos[key];
        valueLabels[info.value] = info.label;
      }
    }
    return valueLabels;
  };

  //update codedValues from render labels(call this function when fieldnName = typeIdField)
  mo._updateCodedValueListFromRender = function(layerDefinition, codedValues){ //[{value,label}]
    var renderCodedValues = mo._getRenderValueLabelsForUnique(layerDefinition);
    if(renderCodedValues && codedValues){
      for(var key = 0; key < codedValues.length; key ++){
        var codeValue = codedValues[key];
        if(renderCodedValues[codeValue.value]){
          codeValue.label = renderCodedValues[codeValue.value];
        }
      }
    }
    return codedValues;
  };

  //return {fieldName,label,tooltip,visible,format,stringFieldOption}
  mo.getDefaultPortalFieldInfo = function(serviceFieldInfo){
    //serviceFieldInfo: {name,alias,type,...}
    var fieldName = serviceFieldInfo.name;
    var item = {
      fieldName: fieldName,
      label: serviceFieldInfo.alias || fieldName,
      tooltip: '',
      visible: false,
      format: null,
      stringFieldOption: 'textbox'
    };

    //https://developers.arcgis.com/javascript/jsapi/field-amd.html#type
    var type = serviceFieldInfo.type;
    switch (type) {
      case 'esriFieldTypeSmallInteger':
      case 'esriFieldTypeInteger':
        item.format = {
          places: 0,
          digitSeparator: true
        };
        break;
      case 'esriFieldTypeSingle':
      case 'esriFieldTypeDouble':
        item.format = {
          places: 2,
          digitSeparator: true
        };
        break;
      case 'esriFieldTypeDate':
        item.format = {
          dateFormat: "longMonthDayYear"
        };
        break;
    }
    return item;
  };

  mo.getDefaultPopupInfo = function(object, title, fieldNames) {
    // return popupInfo with all fieldInfos if the fieldName is null;
    var popupInfo = null;
    if(object && object.fields) {
      popupInfo = {
        title: title,
        fieldInfos:[],
        description: null,
        showAttachments: true,
        mediaInfos: []
      };
      array.forEach(object.fields, function(field){
        var isValidField = false;
        if(fieldNames) {
          var isValidFieldName = array.some(fieldNames, lang.hitch(this, function(fieldName) {
            return fieldName && (field.name.toLowerCase() === fieldName.toLowerCase());
          }));
          if(isValidFieldName) {
            isValidField = true;
          }
        } else {
          isValidField = true;
        }
        if(isValidField) {
          var fieldInfo = this.getDefaultPortalFieldInfo(field);
          fieldInfo.visible = true;
          fieldInfo.isEditable = field.editable;
          popupInfo.fieldInfos.push(fieldInfo);
        }
      }, this);
    }
    return popupInfo;
  };

  mo._tryLocaleNumber = function(value) {
    var result = mo.localizeNumber(value);
    if (result === null || result === undefined) {
      result = value;
    }
    return result;
  };

  mo._tryLocaleDate = function(date) {
    var result = mo.localizeDate(date);
    if (!result) {
      result = date.toLocaleDateString();
    }
    return result;
  };

  //fieldInfos: layerDefinition.fields
  mo.getFieldInfoByFieldName = function(fieldInfos, fieldName) {
    var fieldInfo = null;
    if (fieldInfos && fieldInfos.length > 0) {
      array.some(fieldInfos, lang.hitch(this, function(item) {
        if (item.name === fieldName) {
          fieldInfo = item;
          return true;
        } else {
          return false;
        }
      }));
    }
    return fieldInfo;
  };

  //fieldInfos: popupFieldsInfo
  mo.getDateFieldFormatByFieldName = function(fieldInfos, fieldName) {
    if (fieldInfos && fieldInfos.length > 0) {
      for(var key = 0; key < fieldInfos.length; key++){
        var item = fieldInfos[key];
        if (item.fieldName === fieldName) {
          if(item.format && item.format.dateFormat){
            return item.format.dateFormat;
          }else{
            return '';
          }
        }
      }
      return '';
    }
    return '';
  };

  //layerField: https://developers.arcgis.com/web-map-specification/objects/field/
  //popupField: https://developers.arcgis.com/web-map-specification/objects/fieldInfo/
  mo.completePopupFieldFromLayerField = function(layerFields, popupFields){
    for(var layerKey in layerFields){
      var layerFieldName = layerFields[layerKey].name;
      var isExist = false;
      for(var popupKey in popupFields){
        if(popupFields[popupKey].fieldName === layerFieldName){
          isExist = true;
          break;
        }
      }
      if(!isExist){
        var _fieldInfo = mo.getPopupFieldFromLayerField(layerFields[layerKey]);
        popupFields.push(_fieldInfo);
      }
    }
    return popupFields;
  };

  mo.getPopupFieldFromLayerField = function(layerField){
    var _fieldInfo = {
      //pro publish (no edit by map viewer in some old versions)
      'fieldName': layerField.name,
      'isEditable': layerField.editable,
      'label': layerField.alias,
      'visible': layerField.visible ? layerField.visible : false,

      //other ways(include attrs above)
      //stringFieldOption is only for string field: textbox, textarea, richtext
      'stringFieldOption': layerField.type === 'esriFieldTypeString' ? 'textbox': null,
      'tooltips': '',
      'domain': layerField.domain ? layerField.domain : null
    };
    return _fieldInfo;
  };

  mo.containsNonLatinCharacter = function(string) {
    /*
    console.log(string);
    for (var k = 0; k < string.length; k++) {
      console.log(string.charCodeAt(k));
    }
    */
    for (var i = 0; i < string.length; i++) {
      if (string.charCodeAt(i) > 255) {
        return true;
      }
    }
    return false;
  };

  mo.has = function(browserName) {
    function _isIE11() {
      var iev = 0;
      var ieold = (/MSIE (\d+\.\d+);/.test(navigator.userAgent));
      var trident = !!navigator.userAgent.match(/Trident\/7.0/);
      var rv = navigator.userAgent.indexOf("rv:11.0");

      if (ieold) {
        iev = Number(RegExp.$1);
      }
      if (navigator.appVersion.indexOf("MSIE 10") !== -1) {
        iev = 10;
      }
      if (trident && rv !== -1) {
        iev = 11;
      }

      return iev === 11;
    }
    function _isEdge() {
      return navigator.userAgent.split('Edge/')[1];
    }
    var v = has(browserName);
    if (!v) {
      if (browserName.toLowerCase() === 'ie') {
        return (_isIE11() && 11) || v;
      } else if (browserName.toLowerCase() === 'edge') {
        return _isEdge() || v;
      }
    } else {
      return v;
    }
  };

  mo.detectUserAgent = function() {
    var os = {}, browser = {},
      ua = navigator.userAgent, platform = navigator.platform,
      webkit = ua.match(/Web[kK]it[\/]{0,1}([\d.]+)/),
      android = ua.match(/(Android);?[\s\/]+([\d.]+)?/),
      osx = !!ua.match(/\(Macintosh\; Intel /),
      ipad = ua.match(/(iPad).*OS\s([\d_]+)/),
      ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/),
      iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/),
      webos = ua.match(/(webOS|hpwOS)[\s\/]([\d.]+)/),
      win = /Win\d{2}|Windows/.test(platform),
      wp = ua.match(/Windows Phone ([\d.]+)/),
      touchpad = webos && ua.match(/TouchPad/),
      kindle = ua.match(/Kindle\/([\d.]+)/),
      silk = ua.match(/Silk\/([\d._]+)/),
      blackberry = ua.match(/(BlackBerry).*Version\/([\d.]+)/),
      bb10 = ua.match(/(BB10).*Version\/([\d.]+)/),
      rimtabletos = ua.match(/(RIM\sTablet\sOS)\s([\d.]+)/),
      playbook = ua.match(/PlayBook/),
      chrome = ua.match(/Chrome\/([\d.]+)/) || ua.match(/CriOS\/([\d.]+)/),
      firefox = ua.match(/Firefox\/([\d.]+)/),
      firefoxos = ua.match(/\((?:Mobile|Tablet); rv:([\d.]+)\).*Firefox\/[\d.]+/),
      ie = ua.match(/MSIE\s([\d.]+)/) || ua.match(/Trident\/[\d](?=[^\?]+).*rv:([0-9.].)/),
      webview = !chrome && ua.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/),
      safari = webview || ua.match(/Version\/([\d.]+)([^S](Safari)|[^M]*(Mobile)[^S]*(Safari))/);

    browser.webkit = !!webkit;
    if (browser.webkit) {
      browser.version = webkit[1];
    }

    if (android) {
      os.android = true;
      os.version = android[2];
    }
    if (iphone && !ipod) {
      os.ios = os.iphone = true;
      os.version = iphone[2].replace(/_/g, '.');
    }
    if (ipad) {
      os.ios = os.ipad = true;
      os.version = ipad[2].replace(/_/g, '.');
    }
    if (ipod) {
      os.ios = os.ipod = true;
      os.version = ipod[3] ? ipod[3].replace(/_/g, '.') : null;
    }
    if (wp) {
      os.wp = true;
      os.version = wp[1];
    }
    if (webos) {
      os.webos = true;
      os.version = webos[2];
    }
    if (touchpad) {
      os.touchpad = true;
    }
    if (blackberry) {
      os.blackberry = true;
      os.version = blackberry[2];
    }
    if (bb10) {
      os.bb10 = true;
      os.version = bb10[2];
    }
    if (rimtabletos) {
      os.rimtabletos = true;
      os.version = rimtabletos[2];
    }
    if (playbook) {
      browser.playbook = true;
    }
    if (kindle) {
      os.kindle = true;
      os.version = kindle[1];
    }
    if (silk) {
      browser.silk = true;
      browser.version = silk[1];
    }
    if (!silk && os.android && ua.match(/Kindle Fire/)) {
      browser.silk = true;
    }
    if (chrome) {
      browser.chrome = true;
      browser.version = chrome[1];
    }
    if (firefox) {
      browser.firefox = true;
      browser.version = firefox[1];
    }
    if (firefoxos) {
      os.firefoxos = true;
      os.version = firefoxos[1];
    }
    if (ie) {
      browser.ie = true;
      browser.version = ie[1];
    }
    if (safari && (osx || os.ios || win)) {
      browser.safari = true;
      if (!os.ios) {
        browser.version = safari[1];
      }
    }
    if (webview) {
      browser.webview = true;
    }

    os.tablet = !!(ipad || playbook || (android && !ua.match(/Mobile/)) ||
    (firefox && ua.match(/Tablet/)) || (ie && !ua.match(/Phone/) && ua.match(/Touch/)));
    os.phone = !!(!os.tablet && !os.ipod && (android || iphone || webos || blackberry || bb10 ||
    (chrome && ua.match(/Android/)) || (chrome && ua.match(/CriOS\/([\d.]+)/)) ||
    (firefox && ua.match(/Mobile/)) || (ie && ua.match(/Touch/))));

    return {
      os: os,
      browser: browser
    };
  };
  mo.isMobileUa = function() {
    var uaInfo = mo.detectUserAgent();
    if (true === uaInfo.os.phone || true === uaInfo.os.tablet) {
      return true;
    } else {
      return false;
    }
  };

  mo.inMobileSize = function(){
    var layoutBox = html.getMarginBox(document.body);
    if (layoutBox.w <= window.jimuConfig.breakPoints[0] ||
      layoutBox.h <= window.jimuConfig.breakPoints[0]) {
      html.addClass(window.jimuConfig.layoutId, 'jimu-ismobile');
      return true;
    } else {
      html.removeClass(window.jimuConfig.layoutId, 'jimu-ismobile');
      return false;
    }
  };

  mo.getObjectIdField = function(layerDefinition){
    if(layerDefinition.objectIdField){
      return layerDefinition.objectIdField;
    }else{
      var fieldInfos = layerDefinition.fields;
      for(var i = 0; i < fieldInfos.length; i++){
        var fieldInfo = fieldInfos[i];
        if(fieldInfo.type === 'esriFieldTypeOID'){
          return fieldInfo.name;
        }
      }
    }
    return null;
  };

  //if browser(such as Chrome50) have window.isSecureContext, and not in https origin, return true
  //for example: if true===isNendHttpsButNot(), MyLocateButton should be disabled
  mo.isNeedHttpsButNot = function() {
    //copy from: https://devtopia.esri.com/WebGIS/arcgis-js-api/issues/6614
    var hasGeolocation = navigator.geolocation;
    var hasSecureContext = window.hasOwnProperty("isSecureContext");
    var isSecureContext = (hasSecureContext && window.isSecureContext) ||
      (!hasSecureContext && window.location.protocol === "https:");
    if (!isSecureContext || !hasGeolocation) {
      return true;
    } else {
      return false;
    }
  };


  mo.showValidationErrorTipForFormDijit = function(_dijit){
    try{
      if (!_dijit.validate() && _dijit.domNode) {
        if (_dijit.focusNode) {
          _dijit.focusNode.focus();
          setTimeout(lang.hitch(this, function() {
            _dijit.focusNode.blur();
          }), 100);
        }
      }
    }catch(e){
      console.error(e);
    }
  };

  mo.getFeatureLayerDefinition = function(featureLayer){
    var layerDefinition = null;
    var features = featureLayer.graphics;
    featureLayer.graphics = [];
    var json = featureLayer.toJson();
    featureLayer.graphics = features;
    if(json){
      layerDefinition = json.layerDefinition;
    }
    return layerDefinition;
  };

  mo.simulateClickEvent = function(dom){
    if(has('safari')){
      //create an event
      var mouseEvent = document.createEvent("MouseEvents");
      //initialize the event
      mouseEvent.initEvent("click",/* bubble */ true, /* cancelable */ true);
      //trigger the evevnt
      dom.dispatchEvent(mouseEvent);
    }else{
      dom.click();
    }
  };



  mo.isInConfigOrPreviewWindow = function(){
    var b = false;
    try{
      b = !window.isBuilder && window.parent && window.parent !== window &&
        window.parent.isBuilder;
    }catch(e){
      // console.log(e);
      b = false;
    }
    return !!b;
  };

  //for cross-origin frame
  mo.getAppHref = function(){
    var href = "";
    if (mo.isInConfigOrPreviewWindow()) {
      href = window.parent.location.href;
    } else {
      href = window.location.href;
    }
    return href;
  };

  mo.getAppIdFromUrl = function() {
    var isDeployedApp = true,
      href = mo.getAppHref();// window.top.location.href;
    if (href.indexOf("id=") !== -1 || href.indexOf("appid=") !== -1 ||
      href.indexOf("apps") !== -1) {
      isDeployedApp = false;
    }

    if (isDeployedApp === true) {
      // deployed app use pathname as key
      return href;
    } else {
      // xt or integration use id of app as key
      var urlParams = this.urlToObject(window.location.href);
      if (urlParams.query) {
        if (urlParams.query.id || urlParams.query.appid) {
          return urlParams.query.id || urlParams.query.appid;
        }
      }

      // if there is no id/appid in url
      if (window.appInfo) {
        if (window.appInfo.id) {
          //id in appInfo
          return window.appInfo.id;
        } else if (window.appInfo.appPath) {
          //parse id from appPath
          var list = window.appInfo.appPath.split("/");
          if (list.length && list.length > 2) {
            return list[list.length - 2];
          }
        } else {
          console.error("CAN NOT getAppIdFromUrl");
        }
      }
    }
  };

  mo.getEditorContentHeight = function(content, dom, domParam) {
    var def = new Deferred();
    this._content = content;
    this._dom = dom;
    this._domParam = domParam;
    var timeoutHandler = setTimeout(lang.hitch(this, function() {
      clearTimeout(timeoutHandler);
      timeoutHandler = null;

      var h = 0;
      var scrollerWidth = 20;
      var polyfill = 8;
      var contentWidth = this._domParam.contentWidth;//defaultWidth - marginLeftRight;
      try {
        var fakeContent = document.createElement('div');
        fakeContent.setAttribute('id', 'fakeContent');
        html.setStyle(fakeContent, "background-size", "contain");
        fakeContent.innerHTML = this._content;
        this._dom.appendChild(fakeContent);
        if (fakeContent) {
          //to adjust images
          var contentImgs = query('img', fakeContent);
          if (contentImgs && contentImgs.length) {
            contentImgs.style({
              maxWidth: (contentWidth - scrollerWidth) + 'px'
            });
          }

          html.setStyle(fakeContent, "position", "absolute");
          html.setStyle(fakeContent, "width", contentWidth + "px");
          html.setStyle(fakeContent, "left", "-99999px");
          html.setStyle(fakeContent, "top", "-99999px");
          html.setStyle(fakeContent, "visibility", "hidden");

          var box = html.getContentBox(fakeContent);
          if (box.h) {
            //content height
            h = box.h;
            //+ content margin top + content margin bottom + polyfill
            h += (this._domParam.contentMarginTop + this._domParam.footerHeight + polyfill);
          }
          //TODO delete
          // if (h) {
          //   this._dom.removeChild(fakeContent);
          // }
        }
      } catch (err) {
        console.error("can't getEditorContentHeight" + err);
        h = 200;
      }

      def.resolve(h);
    }), 1500);
    return def;
  };

  mo.getEditorTextColor = function(colorRecordID, forceAttr) {
    return {
      name: "dijit.editor.plugins.EditorTextColor",
      custom: {
        recordUID: mo.getColorRecordName(colorRecordID),
        forceAttr: forceAttr
      }
    };
  };
  mo.getEditorBackgroundColor = function(colorRecordID) {
    return {
      name: "dijit.editor.plugins.EditorBackgroundColor",
      custom: {
        recordUID: mo.getColorRecordName(colorRecordID)
      }
    };
  };
  mo.getColorRecordName = function(id){
    return "wab_cr_" + (id || "");
  };
  mo.b64toBlob = function(b64Data, contentType, sliceSize) {
    contentType = contentType || '';
    sliceSize = sliceSize || 512;
    var byteCharacters = window.atob(b64Data.replace(/^data:image\/(png|jpg|jpeg|gif);base64,/, ''));
    var byteArrays = [];
    for (var offset = 0; offset < byteCharacters.length; offset += sliceSize) {
      var slice = byteCharacters.slice(offset, offset + sliceSize);
      var byteNumbers = new Array(slice.length);
      for (var i = 0; i < slice.length; i++) {
        byteNumbers[i] = slice.charCodeAt(i);
      }
      var byteArray = new Uint8Array(byteNumbers);
      byteArrays.push(byteArray);
    }
    var blob = new Blob(byteArrays, {
      type: contentType
    });
    return blob;
  };
  mo.subtractionArray = function(arr1, arr2) {
    //return arr1 = arr1 - arr2
    for (var i = arr1.length - 1; i >= 0; i--) {
      var a = arr1[i];
      for (var j = arr2.length - 1; j >= 0; j--) {
        var b = arr2[j];
        if (a === b) {
          arr1.splice(i, 1);
          arr2.splice(j, 1);
          break;
        }
      }
    }
    return arr1;
  };

  mo.processItemResourceOfAppConfig = function(appConfig, cb){
    //Traverse appConfig and get all the data that matches the cb.test,
    //along with its direct parent object, passed to the callback function(cb.func)

    //cb:{test,func}
    //args:all parameters that need to be passed to the callback function(cb.func)
    //
    //Return: if cb.func return a promise(defs.length > 0),this function will return a deferred
    //        else return {appConfig,normalReturnValues}
    var normalReturnValues = [];
    var defs = [];
    var callbackReturn;

    function _formatPendingObj(pendingObj){
      var obj = pendingObj.obj;
      var key = pendingObj.key;
      var formatObj = {
        obj:obj,
        key:key
      };
      if(typeof pendingObj.i === 'number'){
        formatObj.i = pendingObj.i;
        formatObj.value = obj[key][pendingObj.i];
      }else{
        formatObj.value = obj[key];
      }
      return formatObj;
    }

    function processObject(obj) {
      for (var key in obj) {
        if (typeof obj[key] === 'object') {
          if (Array.isArray(obj[key])) {
            processArray(obj, key);
          } else {
            processObject(obj[key]);
          }
        } else if (typeof obj[key] === 'string') {
          processString(obj, key);
        }
      }
    }

    function processString(obj, key, i){
      if(typeof i === 'number'){
        if (cb.test(obj[key][i])) {
          callbackReturn = cb.func(_formatPendingObj({
            obj: obj,
            key: key,
            i:i
          }));
          if(typeof callbackReturn.then === 'function'){
            defs.push(callbackReturn);
          }else{
            normalReturnValues.push(callbackReturn);
          }
        }
      }else{
        if (cb.test(obj[key])) {
          callbackReturn = cb.func(_formatPendingObj({
            obj: obj,
            key: key
          }));
          if(typeof callbackReturn.then === 'function'){
            defs.push(callbackReturn);
          }else{
            normalReturnValues.push(callbackReturn);
          }
        }
      }
    }

    function processArray(obj, key){
      for (var i = 0; i < obj[key].length; i++) {
        if (typeof obj[key][i] === 'string') {
          processString(obj, key, i);
        }else if (typeof obj[key][i] === 'object') {
          processObject(obj[key][i]);
        }
      }
    }

    processObject(appConfig);

    if(defs.length > 0){
      return all(defs).then(function(result){
        if(normalReturnValues.length > 0){
          result = result.concat(normalReturnValues);
        }
        return {
          appConfig: appConfig,
          result: result
        };
      });
    }else{
      return {
        appConfig: appConfig,
        result: normalReturnValues
      };
    }
  };
  mo.isEsriDomain = function(url){
    return /^https?:\/\/(?:[\w\-\_]+\.)+(?:esri|arcgis)\.com/.test(url);
  };
  mo.uniqueArray = function(array) {
    var n = [];
    for (var i = 0; i < array.length; i++) {
      if (n.indexOf(array[i]) === -1) {
        n.push(array[i]);
      }
    }
    return n;
  };

  mo.isNotEmptyObject = function(obj, includeArray) {
    if(!!includeArray){
      return mo.isObject(obj) && Object.keys(obj).length > 0 && Array.isArray(obj);
    }else{
      return mo.isObject(obj) && Object.keys(obj).length > 0;
    }
  };
  mo.getMinOfArray = function(array) {
    return Number(Math.min.apply(Math, array));
  };
  mo.getDataSchemaFromLayerDefinition = function(layerDefinition){
    var oIdField = layerDefinition.fields.filter(function(f){
      return f.type === 'esriFieldTypeOID';
    });
    if(oIdField.length > 0){
      oIdField = oIdField[0];
    }else{
      oIdField = null;
    }

    return {
      geometryType: layerDefinition.geometryType,
      fields: layerDefinition.fields,
      displayField: layerDefinition.displayField,
      objectIdField: oIdField,
      typeIdField: layerDefinition.typeIdField
    };
  };

  mo.isValidPointGeometry = function(geometry) {
    return geometry && geometry.type === 'point' && mo.isTrueOrZero(geometry.x) &&
      mo.isTrueOrZero(geometry.y);
  };

  // Incorrect function name, keep it here for back compatibility.
  mo.isVaildPointGeometry = mo.isValidPointGeometry;

  mo.isNumberOrNumberString = function(value) {
    return /^-?[1-9]\d*$/.test(value) ||
      /^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$/.test(value);
  };

  //0.1234 --> 12.34% or %12.34(locale=ar or tr)
  mo.convertNumberToPercentage = function(number, /*optional*/ decimalDigits) {
    if (!mo.isNumberOrNumberString(number)) {
      return number;
    }
    if (typeof decimalDigits === 'undefined') {
      decimalDigits = 2;
    }
    var locale = config.locale;
    var shouldPercentSignLeft = locale === 'ar' || locale === 'tr';
    number = Number(number);
    var isNegative = false;
    if (number < 0) {
      isNegative = true;
      number = Math.abs(number);
    }
    number = number * 100;
    number = number.toFixed(decimalDigits);
    number = mo.localizeNumber(number);

    if (!shouldPercentSignLeft) {
      number += '%';
    } else {
      number = '%' + number;
    }

    if (isNegative) {
      number = '-' + number;
    }

    return number;
  };




  mo.upperCaseString = function(temp) {
    if (temp && typeof temp === 'string') {
      return temp.toUpperCase();
    }
    return temp;
  };

  mo.lowerCaseString = function(temp) {
    if (temp && typeof temp === 'string') {
      return temp.toLowerCase();
    }
    return temp;
  };

  return mo;
});