///////////////////////////////////////////////////////////////////////////
|
// Copyright © 2014 - 2018 Esri. All Rights Reserved.
|
//
|
// Licensed under the Apache License Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
///////////////////////////////////////////////////////////////////////////
|
|
define([
|
'dojo/Deferred',
|
'esri/tasks/query',
|
'dojo/_base/array',
|
'dojo/_base/lang',
|
'dojo/_base/declare',
|
'jimu/Query',
|
'jimu/LayerStructure',
|
'dijit/_WidgetBase',
|
'dijit/_TemplatedMixin',
|
'dijit/_WidgetsInTemplateMixin',
|
'dojo/text!./pageControlForQuery.html',
|
'jimu/utils'
|
],
|
function(Deferred, EsriQuery, array,
|
lang, declare, JimuQuery, LayerStructure, _WidgetBase,
|
_TemplatedMixin, _WidgetsInTemplateMixin, template, jimuUtils){
|
|
return declare([_WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin], {
|
templateString: template,
|
|
layerUrl: null,
|
fieldInfo: null,
|
fieldPopupInfo: null,
|
spatialReference: null,
|
layerDefinition: null,
|
isNumberField: false,
|
showNullValues: false,
|
|
_isUniqueValueCacheFinish: false,
|
_uniqueValueCache: {},
|
_uniqueValueCacheForOtherTypes: {}, //cache for searchKey & types = 2 or 3
|
_codedvalueCache: [],
|
|
cascadeFilterExprs: '1=1',
|
|
numbericFieldLength: {
|
'esriFieldTypeOID': 32,
|
'esriFieldTypeSmallInteger': 16,
|
'esriFieldTypeInteger': 32,
|
'esriFieldTypeSingle': 128,
|
'esriFieldTypeDouble': 1024
|
},
|
pageIndex: 1, //current page
|
pageSize: 1000, //optional, feature count per page
|
postCreate: function(){
|
this.inherited(arguments);
|
this.spatialReference = LayerStructure.getInstance().map.spatialReference;
|
this.reset();
|
this.queryType = JimuQuery.getQueryType(this.layerDefinition);
|
if(this.isNumberField){
|
this.fieldLength = this.numbericFieldLength[this.fieldInfo.type];
|
}
|
},
|
|
reset:function(){
|
this.pageIndex = 1;
|
this._isUniqueValueCacheFinish = false;
|
this._uniqueValueCache = {};
|
this._uniqueValueCacheForOtherTypes = {};
|
this._codedvalueCache = [];
|
},
|
|
isKeyQueryLoader: false,
|
_searchKey: function(name){
|
var def = new Deferred();
|
var query = new EsriQuery();
|
//"%123%" works for string field and number field
|
var keyWhere = '';
|
if(this.isNumberField){ // CAST(objectid AS CHAR(32)) LIKE '%1%'
|
keyWhere = "CAST(" + this.fieldInfo.name + " AS CHAR(" + this.fieldLength + ")) LIKE '%" + name + "%'";
|
}else{
|
keyWhere = this.fieldInfo.name + " LIKE '%" + name + "%'";
|
}
|
query.where = '((' + this.cascadeFilterExprs + ') AND (' + keyWhere + '))';
|
|
query.geometry = null;
|
query.outSpatialReference = this.spatialReference;
|
query.outFields = [this.fieldInfo.name];
|
query.returnDistinctValues = true;
|
query.returnGeometry = false;
|
query.orderByFields = query.outFields;//for order
|
|
this.layerLoaderForKey = new JimuQuery({
|
url: this.layerUrl,
|
query: query,
|
pageSize: this.pageSize
|
});
|
|
this.isKeyQueryLoader = true;
|
this._uniqueValueCacheForOtherTypes = {};
|
this.queryByPage(true).then(lang.hitch(this, function(valueLabels){
|
def.resolve(valueLabels);
|
}), lang.hitch(this, function(err){
|
def.reject('reject:' + err);
|
}));
|
return def;
|
},
|
|
_searchKeyLocal: function(name){
|
name = name.toUpperCase();
|
this.isKeyQueryLoader = false;
|
var valueLabels = [];
|
var cacheData = this._codedvalueCache;
|
var item;
|
if(cacheData.length > 0){ //coded value
|
for (var key1 = 0; key1 < cacheData.length; key1++){
|
item = cacheData[key1];
|
if(item.label && item.label.toString().toUpperCase().indexOf(name) >= 0){
|
valueLabels.push(item);
|
}
|
}
|
}else{
|
cacheData = this._uniqueValueCache;
|
// var enName = this.isNumberField ? name.replace(',', '.') : name;
|
for (var key2 in cacheData){
|
var items = cacheData[key2];
|
for (var index = 0; index < items.length; index++){
|
item = items[index];
|
var mathStr = item.label;
|
if(mathStr && mathStr.toString().toUpperCase().indexOf(name) >= 0){
|
valueLabels.push(item);
|
}
|
//match value as well if it's a number.
|
// if(this.isNumberField){
|
// var mathStrNew = item.value.toString();
|
// if(mathStrNew && mathStrNew.toString().indexOf(enName) >= 0){
|
// valueLabels.push(item);
|
// }
|
// }
|
}
|
}
|
}
|
return valueLabels;
|
},
|
|
queryByPage: function(ifFristPage){
|
var def = new Deferred();
|
|
//jimuQuery will remember the totalcount after first query,
|
//so need new a query to get count for new exprs
|
if(this.layerLoader && (this.layerLoader.query.where !== this.cascadeFilterExprs)){
|
this.layerLoader = null;
|
this.isKeyQueryLoader = false;
|
this.reset();//need to test
|
}
|
|
if(!this.layerLoader){
|
var query = new EsriQuery();
|
query.where = this.cascadeFilterExprs;
|
query.geometry = null;
|
// query.outSpatialReference = this.map.spatialReference;
|
query.outSpatialReference = this.spatialReference;
|
//outFields&returnDistinctValues can work only when returnGeometry is false
|
query.outFields = [this.fieldInfo.name];
|
query.returnDistinctValues = true;
|
query.returnGeometry = false;
|
query.orderByFields = query.outFields;//for order
|
|
this.layerLoader = new JimuQuery({
|
url: this.layerUrl,
|
query: query,
|
pageSize: this.pageSize
|
});
|
}
|
|
if(ifFristPage){ //init pageindex
|
this.pageIndex = 1;
|
}
|
|
var cacheValueLabels = [], loader;
|
if(this.isKeyQueryLoader){
|
if(this._uniqueValueCacheForOtherTypes[this.pageIndex]){
|
cacheValueLabels = this._resolveValueLabelsFromCache(this._uniqueValueCacheForOtherTypes);
|
def.resolve(cacheValueLabels);
|
return def;
|
}else{
|
loader = this.layerLoaderForKey;
|
}
|
}else{
|
if(this._uniqueValueCache[this.pageIndex]){
|
cacheValueLabels = this._resolveValueLabelsFromCache(this._uniqueValueCache);
|
def.resolve(cacheValueLabels);
|
return def;
|
}else{
|
loader = this.layerLoader;
|
}
|
}
|
|
if(this.queryType === 1){
|
loader.queryByPage(this.pageIndex).then(lang.hitch(this, function(response){
|
if(response){
|
var features = response.features || [];
|
|
var featuresLength = features.length; //for calc cache
|
if(!this.showNullValues){ //remove null data
|
features = this._getNotNullValues(features);
|
}
|
|
var valueLabels = this._getValueLabelsFromFeatures(features);
|
|
if(!this.isKeyQueryLoader){ //only cache the data list which has no conditions
|
this._uniqueValueCache[this.pageIndex - 1] = valueLabels;
|
if(featuresLength < this.pageSize){
|
this._uniqueValueCache[this.pageIndex] = [];
|
this._isUniqueValueCacheFinish = true;
|
}
|
}else{
|
this._uniqueValueCacheForOtherTypes[this.pageIndex - 1] = valueLabels;
|
if(featuresLength < this.pageSize){
|
this._uniqueValueCacheForOtherTypes[this.pageIndex] = [];
|
}
|
}
|
if(valueLabels.length === 0){
|
this.pageIndex --;
|
}
|
def.resolve(valueLabels);
|
}else{
|
def.reject("Can't get features from current layer");
|
}
|
}), lang.hitch(this, function(err){
|
def.reject(err);
|
}));
|
} else{ //get all features
|
loader.getAllFeatures().then(lang.hitch(this, function(response){
|
if(response){
|
var features = response.features || [];
|
if(!this.showNullValues){
|
features = this._getNotNullValues(features);
|
}
|
var isReturnValueLabels = features.length > 0 ? true : false;
|
|
features = this._getDistinctValues(features);
|
var valueLabels = this._getValueLabelsFromFeatures(features);
|
if(this.isKeyQueryLoader){
|
valueLabels = this._getAndStoreValueLabelsForOtherTypes(valueLabels,
|
this._uniqueValueCacheForOtherTypes);
|
}else{ //only cache the data list which has no conditions
|
valueLabels = this._getAndStoreValueLabelsForOtherTypes(valueLabels,
|
this._uniqueValueCache);
|
}
|
this._isUniqueValueCacheFinish = true;
|
|
var reValueLabels = isReturnValueLabels ? valueLabels : [];
|
def.resolve(reValueLabels);
|
}else{
|
def.reject("Can't get features from current layer");
|
}
|
}), lang.hitch(this, function(err){
|
def.reject(err);
|
}));
|
}
|
this.pageIndex ++;
|
return def;
|
},
|
|
_resolveValueLabelsFromCache: function(cacheValueLabels){
|
var valueLabels = cacheValueLabels[this.pageIndex];
|
if(valueLabels.length !== 0){
|
this.pageIndex++;
|
}
|
return valueLabels;
|
},
|
|
_getAndStoreValueLabelsForOtherTypes: function(valueLabels, cacheValueLabels){
|
for (var key = 0; key < valueLabels.length; key = key + this.pageSize){
|
cacheValueLabels[parseInt(key / this.pageSize, 10) + 1] = valueLabels.slice(key, key + this.pageSize);
|
}
|
for (var k in cacheValueLabels){
|
var next = parseInt(k, 10) + 1;
|
if(!cacheValueLabels[next]){
|
cacheValueLabels[next] = [];
|
}
|
}
|
return cacheValueLabels[1];//return the data of first page
|
},
|
|
_getDistinctValues: function(features){
|
var hash = {};
|
var distinctFeatures = [];
|
for(var key in features){
|
var feature = features[key];
|
var featureVal = feature.attributes[this.fieldInfo.name];
|
if(!hash[featureVal]){
|
hash[featureVal] = true;//value = featureVal will cause bug, when value=0
|
distinctFeatures.push(feature);
|
}
|
}
|
return distinctFeatures;
|
},
|
|
//value could be undefined or null or '',now only delete null values
|
_getNotNullValues: function(features){
|
features = array.filter(features, lang.hitch(this, function(feature){
|
var featureVal = feature.attributes[this.fieldInfo.name];
|
return featureVal !== '<Null>' && featureVal !== null;
|
}));
|
return features;
|
},
|
|
//get dataList with valueLabel's format include codedvalue
|
//could partially solve decimal point.#13334
|
_getValueLabelsFromFeatures: function(featureList){
|
var fieldName = this.fieldInfo.name;
|
var values = array.map(featureList, function(feature){
|
return feature.attributes[fieldName];
|
});
|
var valueLabels = jimuUtils._getValues(this.layerDefinition, this.fieldPopupInfo, fieldName, values);
|
return valueLabels;
|
}
|
|
});
|
});
|
