mirror of
https://github.com/Esri/offline-editor-js.git
synced 2025-12-15 15:20:05 +00:00
2032 lines
75 KiB
JavaScript
2032 lines
75 KiB
JavaScript
/*! offline-editor-js - v2.5 - 2015-02-23
|
|
* Copyright (c) 2015 Environmental Systems Research Institute, Inc.
|
|
* Apache License*/
|
|
|
|
define([
|
|
"dojo/Evented",
|
|
"dojo/_base/Deferred",
|
|
"dojo/DeferredList",
|
|
"dojo/promise/all",
|
|
"dojo/_base/declare",
|
|
"dojo/_base/array",
|
|
"dojo/dom-attr",
|
|
"dojo/dom-style",
|
|
"dojo/query",
|
|
"esri/config",
|
|
"esri/layers/GraphicsLayer",
|
|
"esri/graphic",
|
|
"esri/symbols/SimpleMarkerSymbol",
|
|
"esri/symbols/SimpleLineSymbol",
|
|
"esri/symbols/SimpleFillSymbol",
|
|
"esri/urlUtils"],
|
|
function(
|
|
Evented,Deferred,DeferredList,all,declare,array,domAttr,domStyle,query,
|
|
esriConfig,GraphicsLayer,Graphic,SimpleMarkerSymbol,SimpleLineSymbol,SimpleFillSymbol,urlUtils)
|
|
{
|
|
"use strict";
|
|
return declare("O.esri.Edit.OfflineFeaturesManager",[Evented],
|
|
{
|
|
_onlineStatus: "online",
|
|
_featureLayers: {},
|
|
_editStore: new O.esri.Edit.EditStore(),
|
|
|
|
ONLINE: "online", // all edits will directly go to the server
|
|
OFFLINE: "offline", // edits will be enqueued
|
|
RECONNECTING: "reconnecting", // sending stored edits to the server
|
|
attachmentsStore: null, // indexedDB for storing attachments
|
|
proxyPath: null, // by default we use CORS and therefore proxyPath is null
|
|
|
|
// manager emits event when...
|
|
events: {
|
|
EDITS_SENT: "edits-sent", // ...whenever any edit is actually sent to the server
|
|
EDITS_ENQUEUED: "edits-enqueued", // ...when an edit is enqueued (and not sent to the server)
|
|
EDITS_SENT_ERROR: "edits-error", // ...there was a problem with one or more edits!
|
|
ALL_EDITS_SENT: "all-edits-sent", // ...after going online and there are no pending edits in the queue
|
|
ATTACHMENT_ENQUEUED: "attachment-enqueued",
|
|
ATTACHMENTS_SENT: "attachments-sent"
|
|
},
|
|
|
|
/**
|
|
* Need to call this method only if you want to support offline attachments
|
|
* it is optional
|
|
* @param callback(success)
|
|
* @returns void
|
|
*/
|
|
initAttachments: function(callback)
|
|
{
|
|
callback = callback || function(success) { console.log("attachments inited ", success? "ok" : "failed"); };
|
|
|
|
if( !this._checkFileAPIs())
|
|
{
|
|
return callback(false, "File APIs not supported");
|
|
}
|
|
|
|
try
|
|
{
|
|
this.attachmentsStore = new O.esri.Edit.AttachmentsStore();
|
|
|
|
if( /*false &&*/ this.attachmentsStore.isSupported() )
|
|
{
|
|
this.attachmentsStore.init(callback);
|
|
}
|
|
else
|
|
{
|
|
return callback(false, "indexedDB not supported");
|
|
}
|
|
}
|
|
catch(err)
|
|
{
|
|
console.log("problem! " + err.toString());
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Overrides a feature layer.
|
|
* @param layer
|
|
* @returns deferred
|
|
*/
|
|
extend: function(layer,callback)
|
|
{
|
|
var self = this;
|
|
|
|
// Attempt to initialize the database
|
|
self._editStore.init(function(result){
|
|
callback(result);
|
|
//return;
|
|
});
|
|
|
|
// we keep track of the FeatureLayer object
|
|
this._featureLayers[ layer.url ] = layer;
|
|
|
|
// replace the applyEdits() method
|
|
layer._applyEdits = layer.applyEdits;
|
|
|
|
|
|
// attachments
|
|
layer._addAttachment = layer.addAttachment;
|
|
layer._queryAttachmentInfos = layer.queryAttachmentInfos;
|
|
layer._deleteAttachments = layer.deleteAttachments;
|
|
|
|
/*
|
|
operations supported offline:
|
|
1. add a new attachment to an existing feature (DONE)
|
|
2. add a new attachment to a new feature (DONE)
|
|
3. remove an attachment that is already in the server... (NOT YET)
|
|
4. remove an attachment that is not in the server yet (DONE)
|
|
5. update an existing attachment to an existing feature (NOT YET)
|
|
6. update a new attachment (NOT YET)
|
|
|
|
concerns:
|
|
- manage the relationship between offline features and attachments: what if the user wants to add
|
|
an attachment to a feature that is still offline? we need to keep track of objectids so that when
|
|
the feature is sent to the server and receives a final objectid we replace the temporary negative id
|
|
by its final objectid (DONE)
|
|
- what if the user deletes an offline feature that had offline attachments? we need to discard the attachment (DONE)
|
|
|
|
pending tasks:
|
|
- delete attachment (DONE)
|
|
- send attachments to server when reconnecting (DONE)
|
|
- check for hasAttachments attribute in the FeatureLayer (NOT YET)
|
|
*/
|
|
|
|
//
|
|
// attachments
|
|
//
|
|
layer.queryAttachmentInfos = function(objectId,callback,errback)
|
|
{
|
|
if( self.getOnlineStatus() === self.ONLINE)
|
|
{
|
|
var def = this._queryAttachmentInfos(objectId,
|
|
function()
|
|
{
|
|
console.log(arguments);
|
|
self.emit(self.events.ATTACHMENTS_INFO,arguments);
|
|
callback && callback.apply(this,arguments);
|
|
},
|
|
errback);
|
|
return def;
|
|
}
|
|
|
|
if( !self.attachmentsStore )
|
|
{
|
|
console.log("in order to support attachments you need to call initAttachments() method of offlineFeaturesManager");
|
|
return;
|
|
}
|
|
|
|
// will only return LOCAL attachments
|
|
var deferred = new Deferred();
|
|
self.attachmentsStore.getAttachmentsByFeatureId(this.url, objectId, function(attachments)
|
|
{
|
|
callback && callback(attachments);
|
|
deferred.resolve(attachments);
|
|
});
|
|
return deferred;
|
|
};
|
|
|
|
layer.addAttachment = function(objectId,formNode,callback,errback)
|
|
{
|
|
if( self.getOnlineStatus() === self.ONLINE)
|
|
{
|
|
return this._addAttachment(objectId,formNode,
|
|
function()
|
|
{
|
|
console.log(arguments);
|
|
self.emit(self.events.ATTACHMENTS_SENT,arguments);
|
|
callback && callback.apply(this,arguments);
|
|
},
|
|
function(err)
|
|
{
|
|
console.log("addAttachment: " + err);
|
|
errback && errback.apply(this,arguments);
|
|
}
|
|
);
|
|
}
|
|
|
|
if( !self.attachmentsStore )
|
|
{
|
|
console.log("in order to support attachments you need to call initAttachments() method of offlineFeaturesManager");
|
|
return;
|
|
}
|
|
|
|
var files = this._getFilesFromForm(formNode);
|
|
var file = files[0]; // addAttachment can only add one file, so the rest -if any- are ignored
|
|
|
|
var deferred = new Deferred();
|
|
var attachmentId = this._getNextTempId();
|
|
self.attachmentsStore.store(this.url, attachmentId, objectId, file, function(success, newAttachment)
|
|
{
|
|
var returnValue = { attachmentId: attachmentId, objectId:objectId, success:success };
|
|
if( success )
|
|
{
|
|
self.emit(self.events.ATTACHMENT_ENQUEUED,returnValue);
|
|
callback && callback(returnValue);
|
|
deferred.resolve(returnValue);
|
|
|
|
// replace the default URL that is set by attachmentEditor with the local file URL
|
|
var attachmentUrl = this._url.path + "/" + objectId + "/attachments/" + attachmentId;
|
|
var attachmentElement = query("[href=" + attachmentUrl + "]");
|
|
attachmentElement.attr("href", newAttachment.url);
|
|
}
|
|
else
|
|
{
|
|
returnValue.error = "can't store attachment";
|
|
errback && errback(returnValue);
|
|
deferred.reject(returnValue);
|
|
}
|
|
}.bind(this));
|
|
|
|
return deferred;
|
|
};
|
|
|
|
layer.deleteAttachments = function(objectId,attachmentsIds,callback,errback)
|
|
{
|
|
if( self.getOnlineStatus() === self.ONLINE)
|
|
{
|
|
var def = this._deleteAttachments(objectId,attachmentsIds,
|
|
function()
|
|
{
|
|
callback && callback.apply(this,arguments);
|
|
},
|
|
function(err)
|
|
{
|
|
console.log("deleteAttachments: " + err);
|
|
errback && errback.apply(this,arguments);
|
|
});
|
|
return def;
|
|
}
|
|
|
|
if( !self.attachmentsStore )
|
|
{
|
|
console.log("in order to support attachments you need to call initAttachments() method of offlineFeaturesManager");
|
|
return;
|
|
}
|
|
|
|
// case 1.- it is a new attachment
|
|
// case 2.- it is an already existing attachment
|
|
// only case 1 is supported right now
|
|
|
|
// asynchronously delete each of the attachments
|
|
var promises = [];
|
|
attachmentsIds.forEach(function(attachmentId)
|
|
{
|
|
attachmentId = parseInt(attachmentId,10); // to number
|
|
console.assert( attachmentId<0 , "we only support deleting local attachments");
|
|
var deferred = new Deferred();
|
|
self.attachmentsStore.delete(attachmentId, function(success)
|
|
{
|
|
var result = { objectId: objectId, attachmentId: attachmentId, success: success };
|
|
deferred.resolve(result);
|
|
});
|
|
promises.push(deferred);
|
|
}, this);
|
|
|
|
// call callback once all deletes have finished
|
|
var allPromises = all(promises);
|
|
allPromises.then( function(results)
|
|
{
|
|
callback && callback(results);
|
|
});
|
|
|
|
return allPromises;
|
|
};
|
|
|
|
//
|
|
// other functions
|
|
//
|
|
|
|
/**
|
|
* Overrides the ArcGIS API for JavaSccript applyEdits() method.
|
|
* @param adds Creates a new edit entry.
|
|
* @param updates Updates an existing entry.
|
|
* @param deletes Deletes an existing entry.
|
|
* @param callback Called when the operation is complete.
|
|
* @param errback An error object is returned if an error occurs
|
|
* @returns {*} deferred
|
|
*/
|
|
layer.applyEdits = function(adds,updates,deletes,callback,errback)
|
|
{
|
|
// inside this method, 'this' will be the FeatureLayer
|
|
// and 'self' will be the offlineFeatureLayer object
|
|
|
|
var promises = [];
|
|
|
|
if( self.getOnlineStatus() === self.ONLINE)
|
|
{
|
|
var def = this._applyEdits(adds,updates,deletes,
|
|
function()
|
|
{
|
|
self.emit(self.events.EDITS_SENT,arguments);
|
|
callback && callback.apply(this,arguments);
|
|
},
|
|
errback);
|
|
return def;
|
|
}
|
|
|
|
var deferred = new Deferred();
|
|
var results = { addResults:[],updateResults:[], deleteResults:[] };
|
|
var updatesMap = {};
|
|
|
|
this.onBeforeApplyEdits(adds, updates, deletes);
|
|
|
|
adds = adds || [];
|
|
adds.forEach(function(addEdit)
|
|
{
|
|
var deferred = new Deferred();
|
|
|
|
var objectId = this._getNextTempId();
|
|
addEdit.attributes[ this.objectIdField ] = objectId;
|
|
|
|
self._editStore.pushEdit(self._editStore.ADD, this.url, addEdit,function(result,error){
|
|
result == true ? deferred.resolve(result) : deferred.reject(error);
|
|
});
|
|
results.addResults.push({ success:true, error: null, objectId: objectId});
|
|
|
|
var phantomAdd = new Graphic(
|
|
addEdit.geometry,
|
|
self._getPhantomSymbol(addEdit.geometry, self._editStore.ADD),
|
|
{
|
|
objectId: objectId
|
|
});
|
|
this._phantomLayer.add(phantomAdd);
|
|
domAttr.set(phantomAdd.getNode(),"stroke-dasharray","10,4");
|
|
domStyle.set(phantomAdd.getNode(), "pointer-events","none");
|
|
|
|
promises.push(deferred);
|
|
},this);
|
|
|
|
updates = updates || [];
|
|
updates.forEach(function(updateEdit)
|
|
{
|
|
var deferred = new Deferred();
|
|
|
|
var objectId = updateEdit.attributes[ this.objectIdField ];
|
|
updatesMap[ objectId ] = updateEdit;
|
|
|
|
self._editStore.pushEdit(self._editStore.UPDATE, this.url, updateEdit,function(result,error){
|
|
result == true ? deferred.resolve(result) : deferred.reject(error);
|
|
});
|
|
results.updateResults.push({success:true, error: null, objectId: objectId});
|
|
|
|
var phantomUpdate = new Graphic(
|
|
updateEdit.geometry,
|
|
self._getPhantomSymbol(updateEdit.geometry, self._editStore.UPDATE),
|
|
{
|
|
objectId: objectId
|
|
});
|
|
this._phantomLayer.add(phantomUpdate);
|
|
domAttr.set(phantomUpdate.getNode(),"stroke-dasharray","5,2");
|
|
domStyle.set(phantomUpdate.getNode(), "pointer-events","none");
|
|
|
|
promises.push(deferred);
|
|
},this);
|
|
|
|
deletes = deletes || [];
|
|
deletes.forEach(function(deleteEdit)
|
|
{
|
|
var deferred = new Deferred();
|
|
|
|
var objectId = deleteEdit.attributes[ this.objectIdField ];
|
|
self._editStore.pushEdit(self._editStore.DELETE, this.url, deleteEdit,function(result,error){
|
|
result == true ? deferred.resolve(result) : deferred.reject(error);
|
|
});
|
|
results.deleteResults.push({success:true, error: null, objectId: objectId});
|
|
|
|
var phantomDelete = new Graphic(
|
|
deleteEdit.geometry,
|
|
self._getPhantomSymbol(deleteEdit.geometry, self._editStore.DELETE),
|
|
{
|
|
objectId: objectId
|
|
});
|
|
this._phantomLayer.add(phantomDelete);
|
|
domAttr.set(phantomDelete.getNode(),"stroke-dasharray","4,4");
|
|
domStyle.set(phantomDelete.getNode(), "pointer-events","none");
|
|
|
|
if( self.attachmentsStore )
|
|
{
|
|
// delete local attachments of this feature, if any... we just launch the delete and don't wait for it to complete
|
|
self.attachmentsStore.deleteAttachmentsByFeatureId(this.url, objectId, function(deletedCount)
|
|
{
|
|
console.log("deleted",deletedCount,"attachments of feature",objectId);
|
|
});
|
|
}
|
|
|
|
promises.push(deferred);
|
|
},this);
|
|
|
|
all(promises).then( function(r)
|
|
{
|
|
//TO-DO - handle information related to any failed edits that didn't get stored
|
|
|
|
/* we already pushed the edits into the database, now we let the FeatureLayer to do the local updating of the layer graphics */
|
|
setTimeout(function()
|
|
{
|
|
this._editHandler(results, adds, updatesMap, callback, errback, deferred);
|
|
self.emit(self.events.EDITS_ENQUEUED, results);
|
|
}.bind(this),0);
|
|
return deferred;
|
|
}.bind(this));
|
|
|
|
}; // layer.applyEdits()
|
|
|
|
/**
|
|
* Converts an array of graphics/features into JSON
|
|
* @param features
|
|
* @param updateEndEvent
|
|
* @param callback
|
|
*/
|
|
layer.convertGraphicLayerToJSON = function(features,updateEndEvent,callback){
|
|
var layerDefinition = {};
|
|
layerDefinition.objectIdFieldName = updateEndEvent.target.objectIdField;
|
|
layerDefinition.globalIdFieldName = updateEndEvent.target.globalIdField;
|
|
layerDefinition.geometryType = updateEndEvent.target.geometryType;
|
|
layerDefinition.spatialReference = updateEndEvent.target.spatialReference;
|
|
layerDefinition.fields = updateEndEvent.target.fields;
|
|
|
|
var length = features.length;
|
|
var jsonArray = [];
|
|
for(var i=0; i < length; i++){
|
|
var jsonGraphic = features[i].toJson();
|
|
jsonArray.push(jsonGraphic);
|
|
if(i == (length - 1)) {
|
|
var featureJSON = JSON.stringify(jsonArray);
|
|
var layerDefJSON = JSON.stringify(layerDefinition);
|
|
callback(featureJSON,layerDefJSON);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Sets the phantom layer with a new features.
|
|
* @param graphicsArray an array of Graphics
|
|
*/
|
|
layer.setPhantomLayerGraphics = function(graphicsArray){
|
|
var length = graphicsArray.length;
|
|
|
|
if(length > 0){
|
|
for(var i=0; i < length; i++){
|
|
var graphic = new Graphic(graphicsArray[i]);
|
|
this._phantomLayer.add(graphic);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the array of graphics from the phantom graphics layer.
|
|
* This layer identifies features that have been modified
|
|
* while offline.
|
|
* @returns {array}
|
|
*/
|
|
layer.getPhantomLayerGraphics = function(callback){
|
|
//return layer._phantomLayer.graphics;
|
|
var graphics = layer._phantomLayer.graphics;
|
|
var length = layer._phantomLayer.graphics.length;
|
|
var jsonArray = [];
|
|
for(var i=0; i < length; i++){
|
|
var jsonGraphic = graphics[i].toJson();
|
|
jsonArray.push(jsonGraphic);
|
|
if(i == (length - 1)) {
|
|
var graphicsJSON = JSON.stringify(jsonArray);
|
|
callback(graphicsJSON);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create a featureDefinition
|
|
* @param featureLayer
|
|
* @param featuresArr
|
|
* @param geometryType
|
|
* @param callback
|
|
*/
|
|
layer.getFeatureDefinition = function(/* Object */ featureLayer,/* Array */ featuresArr,/* String */ geometryType,callback){
|
|
|
|
var featureDefinition = {
|
|
"layerDefinition":featureLayer,
|
|
"featureSet":{
|
|
"features": featuresArr,
|
|
"geometryType": geometryType
|
|
}
|
|
|
|
}
|
|
|
|
callback(featureDefinition);
|
|
}
|
|
|
|
/* internal methods */
|
|
|
|
layer._getFilesFromForm = function(formNode)
|
|
{
|
|
var files = [];
|
|
var inputNodes = array.filter(formNode.elements, function(node) { return node.type === "file"; });
|
|
inputNodes.forEach(function(inputNode)
|
|
{
|
|
files.push.apply(files,inputNode.files);
|
|
},this);
|
|
return files;
|
|
};
|
|
|
|
layer._replaceFeatureIds = function(tempObjectIds,newObjectIds,callback)
|
|
{
|
|
console.log("replacing ids of attachments",tempObjectIds, newObjectIds);
|
|
console.assert( tempObjectIds.length === newObjectIds.length, "arrays must be the same length");
|
|
|
|
if(!tempObjectIds.length)
|
|
{
|
|
console.log("no ids to replace!");
|
|
callback(0);
|
|
}
|
|
|
|
var i, n = tempObjectIds.length;
|
|
var count = n;
|
|
var successCount = 0;
|
|
for(i=0; i<n; i++)
|
|
{
|
|
self.attachmentsStore.replaceFeatureId(this.url, tempObjectIds[i], newObjectIds[i], function(success)
|
|
{
|
|
--count;
|
|
successCount += (success? 1:0);
|
|
if( count === 0)
|
|
{
|
|
callback(successCount);
|
|
}
|
|
}.bind(this));
|
|
}
|
|
};
|
|
|
|
// we need to identify ADDs before sending them to the server
|
|
// we assign temporary ids (using negative numbers to distinguish them from real ids)
|
|
layer._nextTempId = -1;
|
|
layer._getNextTempId = function()
|
|
{
|
|
return this._nextTempId--;
|
|
};
|
|
|
|
function _initPhantomLayer()
|
|
{
|
|
try
|
|
{
|
|
layer._phantomLayer = new GraphicsLayer({opacity:0.8});
|
|
layer._map.addLayer(layer._phantomLayer);
|
|
}
|
|
catch(err)
|
|
{
|
|
console.log("Unable to init PhantomLayer");
|
|
}
|
|
}
|
|
|
|
_initPhantomLayer();
|
|
|
|
}, // extend
|
|
|
|
/**
|
|
* Forces library into an offline state. Any edits applied during this condition will be stored locally
|
|
*/
|
|
goOffline: function()
|
|
{
|
|
console.log("offlineFeatureManager going offline");
|
|
this._onlineStatus = this.OFFLINE;
|
|
},
|
|
|
|
/**
|
|
* Forces library to return to an online state. If there are pending edits,
|
|
* an attempt will be made to sync them with the remote feature server
|
|
* @param callback callback( boolean, errors )
|
|
*/
|
|
goOnline: function(callback)
|
|
{
|
|
console.log("offlineFeaturesManager going online");
|
|
this._onlineStatus = this.RECONNECTING;
|
|
this._replayStoredEdits(function(success,responses)
|
|
{
|
|
var result = { features: { success:success, responses: responses} };
|
|
if( this.attachmentsStore != null )
|
|
{
|
|
console.log("sending attachments");
|
|
this._sendStoredAttachments(function(success, responses)
|
|
{
|
|
this._onlineStatus = this.ONLINE;
|
|
result.attachments = { success: success, responses:responses } ;
|
|
callback && callback(result);
|
|
}.bind(this));
|
|
}
|
|
else
|
|
{
|
|
this._onlineStatus = this.ONLINE;
|
|
callback && callback(result);
|
|
}
|
|
}.bind(this));
|
|
},
|
|
|
|
/**
|
|
* Determines if offline or online condition exists
|
|
* @returns {string} ONLINE or OFFLINE
|
|
*/
|
|
getOnlineStatus: function()
|
|
{
|
|
return this._onlineStatus;
|
|
},
|
|
|
|
/* internal methods */
|
|
|
|
/**
|
|
* internal method that checks if this browser supports everything that is needed to handle offline attachments
|
|
* it also extends XMLHttpRequest with sendAsBinary() method, needed in Chrome
|
|
*/
|
|
_checkFileAPIs: function()
|
|
{
|
|
if( window.File && window.FileReader && window.FileList && window.Blob )
|
|
{
|
|
console.log("All APIs supported!");
|
|
|
|
if(!XMLHttpRequest.prototype.sendAsBinary )
|
|
{
|
|
// https://code.google.com/p/chromium/issues/detail?id=35705#c40
|
|
XMLHttpRequest.prototype.sendAsBinary = function(datastr)
|
|
{
|
|
function byteValue(x) {
|
|
return x.charCodeAt(0) & 0xff;
|
|
}
|
|
var ords = Array.prototype.map.call(datastr, byteValue);
|
|
var ui8a = new Uint8Array(ords);
|
|
this.send(ui8a.buffer);
|
|
};
|
|
console.log("extending XMLHttpRequest");
|
|
}
|
|
return true;
|
|
}
|
|
console.log("The File APIs are not fully supported in this browser.");
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* internal method that extends an object with sendAsBinary() method
|
|
* sometimes extending XMLHttpRequest.prototype is not enough, as ArcGIS JS lib seems to mess with this object too
|
|
* @param oAjaxReq object to extend
|
|
*/
|
|
_extendAjaxReq: function(oAjaxReq)
|
|
{
|
|
oAjaxReq.sendAsBinary = XMLHttpRequest.prototype.sendAsBinary;
|
|
console.log("extending XMLHttpRequest");
|
|
},
|
|
|
|
//
|
|
// phantom symbols
|
|
//
|
|
|
|
_phantomSymbols: [],
|
|
|
|
_getPhantomSymbol: function(geometry, operation)
|
|
{
|
|
if( this._phantomSymbols.length === 0)
|
|
{
|
|
var color = [0,255,0,255];
|
|
var width = 1.5;
|
|
|
|
this._phantomSymbols['point'] = [];
|
|
this._phantomSymbols['point'][this._editStore.ADD] = new SimpleMarkerSymbol({
|
|
"type": "esriSMS", "style": "esriSMSCross",
|
|
"xoffset": 10, "yoffset": 10,
|
|
"color": [255,255,255,0], "size": 15,
|
|
"outline": { "color": color, "width": width, "type": "esriSLS", "style": "esriSLSSolid" }
|
|
});
|
|
this._phantomSymbols['point'][this._editStore.UPDATE] = new SimpleMarkerSymbol({
|
|
"type": "esriSMS", "style": "esriSMSCircle",
|
|
"xoffset": 0, "yoffset": 0,
|
|
"color": [255,255,255,0], "size": 15,
|
|
"outline": { "color": color, "width": width, "type": "esriSLS", "style": "esriSLSSolid" }
|
|
});
|
|
this._phantomSymbols['point'][this._editStore.DELETE] = new SimpleMarkerSymbol({
|
|
"type": "esriSMS", "style": "esriSMSX",
|
|
"xoffset": 0, "yoffset": 0,
|
|
"color": [255,255,255,0], "size": 15,
|
|
"outline": { "color": color, "width": width, "type": "esriSLS", "style": "esriSLSSolid" }
|
|
});
|
|
this._phantomSymbols['multipoint'] = null;
|
|
|
|
this._phantomSymbols['polyline'] = [];
|
|
this._phantomSymbols['polyline'][this._editStore.ADD] = new SimpleLineSymbol({
|
|
"type": "esriSLS", "style": "esriSLSSolid",
|
|
"color": color,"width": width
|
|
});
|
|
this._phantomSymbols['polyline'][this._editStore.UPDATE] = new SimpleLineSymbol({
|
|
"type": "esriSLS", "style": "esriSLSSolid",
|
|
"color": color,"width": width
|
|
});
|
|
this._phantomSymbols['polyline'][this._editStore.DELETE] = new SimpleLineSymbol({
|
|
"type": "esriSLS", "style": "esriSLSSolid",
|
|
"color": color,"width": width
|
|
});
|
|
|
|
this._phantomSymbols['polygon'] = [];
|
|
this._phantomSymbols['polygon'][this._editStore.ADD] = new SimpleFillSymbol({
|
|
"type": "esriSFS",
|
|
"style": "esriSFSSolid",
|
|
"color": [255,255,255,0],
|
|
"outline": { "type": "esriSLS", "style": "esriSLSSolid", "color": color, "width": width }
|
|
});
|
|
this._phantomSymbols['polygon'][this._editStore.UPDATE] = new SimpleFillSymbol({
|
|
"type": "esriSFS",
|
|
"style": "esriSFSSolid",
|
|
"color": [255,255,255,0],
|
|
"outline": { "type": "esriSLS", "style": "esriSLSDash", "color": color, "width": width }
|
|
});
|
|
this._phantomSymbols['polygon'][this._editStore.DELETE] = new SimpleFillSymbol({
|
|
"type": "esriSFS",
|
|
"style": "esriSFSSolid",
|
|
"color": [255,255,255,0],
|
|
"outline": { "type": "esriSLS", "style": "esriSLSDot", "color": color, "width": width }
|
|
});
|
|
}
|
|
|
|
return this._phantomSymbols[ geometry.type ][ operation ];
|
|
},
|
|
|
|
//
|
|
// methods to handle attachment uploads
|
|
//
|
|
|
|
_fieldSegment: function(name,value)
|
|
{
|
|
return "Content-Disposition: form-data; name=\"" + name + "\"\r\n\r\n" + value + "\r\n";
|
|
},
|
|
|
|
_fileSegment: function(fieldName,fileName,fileType,fileContent)
|
|
{
|
|
return "Content-Disposition: form-data; name=\"" + fieldName +
|
|
"\"; filename=\""+ fileName +
|
|
"\"\r\nContent-Type: " + fileType + "\r\n\r\n" +
|
|
fileContent + "\r\n";
|
|
},
|
|
|
|
_uploadAttachment: function(attachment)
|
|
{
|
|
var dfd = new Deferred();
|
|
|
|
var segments = [];
|
|
segments.push( this._fieldSegment("f","json") );
|
|
segments.push( this._fileSegment("attachment", attachment.name,attachment.contentType,attachment.content ));
|
|
|
|
var oAjaxReq = new XMLHttpRequest();
|
|
|
|
// surprisingly, sometimes the oAjaxReq object doesn't have the sendAsBinary() method, even if we added it to the XMLHttpRequest.prototype
|
|
if( ! oAjaxReq.sendAsBinary )
|
|
{
|
|
this._extendAjaxReq(oAjaxReq);
|
|
}
|
|
|
|
oAjaxReq.onload = function(result)
|
|
{
|
|
dfd.resolve(JSON.parse(result.target.response));
|
|
};
|
|
oAjaxReq.onerror = function(err)
|
|
{
|
|
dfd.reject(err);
|
|
};
|
|
|
|
// IMPORTANT!
|
|
// Proxy path can be set to null if feature service is CORS enabled
|
|
// Refer to "Using the Proxy Page" for more information: https://developers.arcgis.com/en/javascript/jshelp/ags_proxy.html
|
|
var proxy = this.proxyPath || esriConfig.defaults.io.proxyUrl || "";
|
|
if(proxy !== ""){
|
|
proxy += "?";
|
|
}
|
|
console.log("proxy:", proxy);
|
|
oAjaxReq.open("post", proxy + attachment.featureId + "/addAttachment", true);
|
|
var sBoundary = "---------------------------" + Date.now().toString(16);
|
|
oAjaxReq.setRequestHeader("Content-Type", "multipart\/form-data; boundary=" + sBoundary);
|
|
oAjaxReq.sendAsBinary("--" + sBoundary + "\r\n" + segments.join("--" + sBoundary + "\r\n") + "--" + sBoundary + "--\r\n");
|
|
|
|
return dfd;
|
|
},
|
|
|
|
_deleteAttachment: function(attachmentId, uploadResult)
|
|
{
|
|
var dfd = new Deferred();
|
|
|
|
console.log("upload complete", uploadResult, attachmentId);
|
|
this.attachmentsStore.delete(attachmentId, function(success)
|
|
{
|
|
console.assert(success===true, "can't delete attachment already uploaded");
|
|
console.log("delete complete", success);
|
|
dfd.resolve(uploadResult);
|
|
});
|
|
|
|
return dfd;
|
|
},
|
|
|
|
_sendStoredAttachments: function(callback)
|
|
{
|
|
this.attachmentsStore.getAllAttachments(function(attachments)
|
|
{
|
|
console.log("we have",attachments.length,"attachments to upload");
|
|
|
|
var promises = [];
|
|
attachments.forEach(function(attachment)
|
|
{
|
|
console.log("sending attachment", attachment.id, "to feature", attachment.featureId);
|
|
var deleteCompleted =
|
|
this._uploadAttachment(attachment)
|
|
.then(function(uploadResult)
|
|
{
|
|
if( uploadResult.addAttachmentResult && uploadResult.addAttachmentResult.success === true)
|
|
{
|
|
console.log("upload success", uploadResult.addAttachmentResult.success);
|
|
return this._deleteAttachment(attachment.id, uploadResult);
|
|
}
|
|
else
|
|
{
|
|
console.log("upload failed", uploadResult);
|
|
return null;
|
|
}
|
|
}.bind(this),
|
|
function(err)
|
|
{
|
|
console.log("failed uploading attachment", attachment);
|
|
}
|
|
);
|
|
promises.push( deleteCompleted );
|
|
},this);
|
|
console.log("promises", promises.length);
|
|
var allPromises = all(promises);
|
|
allPromises.then(function(results)
|
|
{
|
|
console.log(results);
|
|
callback && callback(true, results);
|
|
},
|
|
function(err)
|
|
{
|
|
console.log("error!",err);
|
|
callback && callback(false, err);
|
|
});
|
|
}.bind(this));
|
|
},
|
|
|
|
//
|
|
// methods to send features back to the server
|
|
//
|
|
|
|
/**
|
|
* Attempts to send any edits in the database. Monitor events for success or failure.
|
|
* @param callback
|
|
* @throws EDITS_SENT when some edits have been successfully sent
|
|
* @throws ALL_EDITS_SENT when all edits have been successfully sent
|
|
* @throws EDITS_SENT_ERROR some edits were not sent successfully
|
|
* @private
|
|
*/
|
|
_replayStoredEdits: function(callback)
|
|
{
|
|
var promises = {};
|
|
var that = this;
|
|
|
|
//
|
|
// send edits for each of the layers
|
|
//
|
|
var layer;
|
|
var adds = [], updates = [], deletes = [];
|
|
var tempObjectIds = [];
|
|
var tempArray = [];
|
|
var featureLayers = this._featureLayers;
|
|
var attachmentsStore = this.attachmentsStore;
|
|
var editStore = this._editStore;
|
|
|
|
this._editStore.getAllEditsArray(function(result,err){
|
|
if(result != null) {
|
|
tempArray = result;
|
|
|
|
var length = tempArray.length;
|
|
|
|
for(var n= 0;n < length;n++) {
|
|
layer = featureLayers[tempArray[n].layer];
|
|
|
|
// If the layer has attachments then check to see if the attachmentsStore has been initialized
|
|
if (attachmentsStore == null && layer.hasAttachments) {
|
|
console.log("ERROR: you need to run OfflineFeaturesManager.initAttachments(). Check the Attachments doc for more info.")
|
|
throw new Error("OfflineFeaturesManager: Attachments aren't initialized.");
|
|
}
|
|
|
|
// Assign the attachmentsStore to the layer as a private var so we can access it from
|
|
// the promises applyEdits() method.
|
|
layer._attachmentsStore = attachmentsStore;
|
|
|
|
layer.__onEditsComplete = layer.onEditsComplete;
|
|
layer.onEditsComplete = function () {
|
|
console.log("intercepting events onEditsComplete");
|
|
};
|
|
layer.__onBeforeApplyEdits = layer.onBeforeApplyEdits;
|
|
layer.onBeforeApplyEdits = function () {
|
|
console.log("intercepting events onBeforeApplyEdits");
|
|
};
|
|
|
|
adds = [], updates = [], deletes = [], tempObjectIds = [];
|
|
|
|
// IMPORTANT: reconstitute the graphic JSON into an actual esri.Graphic object
|
|
// NOTE: we are only sending on Graphic per loop!
|
|
var graphic = new Graphic(JSON.parse(tempArray[n].graphic));
|
|
|
|
switch (tempArray[n].operation) {
|
|
case editStore.ADD:
|
|
for (var i = 0; i < layer.graphics.length; i++) {
|
|
var g = layer.graphics[i];
|
|
if (g.attributes[layer.objectIdField] === graphic.attributes[layer.objectIdField]) {
|
|
layer.remove(g);
|
|
break;
|
|
}
|
|
}
|
|
tempObjectIds.push(graphic.attributes[layer.objectIdField]);
|
|
delete graphic.attributes[layer.objectIdField];
|
|
adds.push(graphic);
|
|
break;
|
|
case editStore.UPDATE:
|
|
updates.push(graphic);
|
|
break;
|
|
case editStore.DELETE:
|
|
deletes.push(graphic);
|
|
break;
|
|
}
|
|
|
|
promises[n] = that._internalApplyEdits(layer, tempArray[n].id, tempObjectIds, adds, updates, deletes);
|
|
}
|
|
|
|
}
|
|
|
|
// wait for all requests to finish
|
|
//
|
|
var allPromises = all(promises);
|
|
allPromises.then(
|
|
function(responses)
|
|
{
|
|
console.log("OfflineFeaturesManager - all responses are back");
|
|
this._cleanDatabase(responses,function(success,error){
|
|
if(success){
|
|
this.emit(this.events.EDITS_SENT);
|
|
this.emit(this.events.ALL_EDITS_SENT);
|
|
callback && callback(true,responses);
|
|
}
|
|
else{
|
|
this.emit(this.events.EDITS_SENT);
|
|
this.emit(this.events.EDITS_SENT_ERROR); // There was a problem, some edits were not successfully sent!
|
|
callback && callback(false,responses);
|
|
}
|
|
}.bind(that));
|
|
}.bind(that),
|
|
function(errors)
|
|
{
|
|
console.log("OfflineFeaturesManager - ERROR!!");
|
|
console.log(errors);
|
|
callback && callback(false,errors);
|
|
}.bind(that)
|
|
);
|
|
});
|
|
},
|
|
|
|
// Only delete items from database that were verified as successfully updated
|
|
// on the server.
|
|
_cleanDatabase: function(responses,callback){
|
|
if( Object.keys(responses).length !== 0 ){
|
|
|
|
var editsArray = [];
|
|
var fails = 0; // track any failures
|
|
|
|
for(var key in responses){
|
|
if (responses.hasOwnProperty(key)) {
|
|
|
|
var edit = responses[key];
|
|
|
|
if(edit.updateResults.length > 0){
|
|
var tempResult = {};
|
|
tempResult.layer = edit.layer;
|
|
tempResult.id = edit.updateResults[0].objectId;
|
|
editsArray.push(tempResult);
|
|
if(edit.updateResults[0].success == false){
|
|
fails++;
|
|
}
|
|
}
|
|
if(edit.deleteResults.length > 0){
|
|
var tempResult = {};
|
|
tempResult.layer = edit.layer;
|
|
tempResult.id = edit.deleteResults[0].objectId;
|
|
editsArray.push(tempResult);
|
|
if(edit.deleteResults[0].success == false){
|
|
fails++;
|
|
}
|
|
}
|
|
if(edit.addResults.length > 0){
|
|
var tempResult = {};
|
|
tempResult.layer = edit.layer;
|
|
tempResult.id = edit.tempId;
|
|
editsArray.push(tempResult);
|
|
if(tempResult.success == false){
|
|
fails++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var promises = {};
|
|
var length = editsArray.length;
|
|
for(var i = 0; i < length; i++){
|
|
promises[i] = this._updateDatabase(editsArray[i]);
|
|
}
|
|
console.log("EDIT LIST " + JSON.stringify(editsArray));
|
|
|
|
// wait for all requests to finish
|
|
//
|
|
var allPromises = all(promises);
|
|
allPromises.then(
|
|
function(responses)
|
|
{
|
|
fails > 0 ? callback(false,responses) : callback(true,responses);
|
|
},
|
|
function(errors)
|
|
{
|
|
callback(false,errors);
|
|
}
|
|
);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Deletes items from database
|
|
* @param edit
|
|
* @returns {l.Deferred.promise|*|c.promise|q.promise|promise}
|
|
* @private
|
|
*/
|
|
_updateDatabase: function(edit){
|
|
var dfd = new Deferred();
|
|
var fakeGraphic = {};
|
|
fakeGraphic.attributes = {}
|
|
fakeGraphic.attributes.objectid = edit.id;
|
|
|
|
this._editStore.delete(edit.layer,fakeGraphic,function(success,error){
|
|
if(success){
|
|
dfd.resolve({success: true, error:null});
|
|
}
|
|
else{
|
|
dfd.reject({success:false, error: error});
|
|
}
|
|
});
|
|
|
|
return dfd.promise;
|
|
|
|
},
|
|
|
|
/**
|
|
* Executes the _applyEdits() method
|
|
* @param layer
|
|
* @param id the unique id that identifies the Graphic in the database
|
|
* @param tempObjectIds
|
|
* @param adds
|
|
* @param updates
|
|
* @param deletes
|
|
* @returns {l.Deferred.promise|*|c.promise|q.promise|promise}
|
|
* @private
|
|
*/
|
|
_internalApplyEdits: function(layer,id,tempObjectIds,adds,updates,deletes)
|
|
{
|
|
var dfd = new Deferred();
|
|
|
|
layer._applyEdits(adds,updates,deletes,
|
|
function(addResults,updateResults,deleteResults)
|
|
{
|
|
layer._phantomLayer.clear();
|
|
|
|
layer.onBeforeApplyEdits = layer.__onBeforeApplyEdits;
|
|
delete layer.__onBeforeApplyEdits;
|
|
var newObjectIds = addResults.map(function (r) {
|
|
return r.objectId;
|
|
});
|
|
|
|
// We use a different pattern if the attachmentsStore is valid and the layer has attachments
|
|
if (layer._attachmentsStore != null && layer.hasAttachments && tempObjectIds.length > 0) {
|
|
layer._replaceFeatureIds(tempObjectIds, newObjectIds, function (success) {
|
|
dfd.resolve({
|
|
id: id,
|
|
layer: layer.url,
|
|
tempId: tempObjectIds, // let's us internally match an ADD to it's new ObjectId
|
|
addResults: addResults,
|
|
updateResults: updateResults,
|
|
deleteResults: deleteResults
|
|
}); // wrap three arguments in a single object
|
|
});
|
|
}
|
|
else {
|
|
dfd.resolve({
|
|
id: id,
|
|
layer: layer.url,
|
|
tempId: tempObjectIds, // let's us internally match an ADD to it's new ObjectId
|
|
addResults: addResults,
|
|
updateResults: updateResults,
|
|
deleteResults: deleteResults
|
|
}); // wrap three arguments in a single object
|
|
}
|
|
},
|
|
function(error)
|
|
{
|
|
layer.onEditsComplete = layer.__onEditsComplete; delete layer.__onEditsComplete;
|
|
layer.onBeforeApplyEdits = layer.__onBeforeApplyEdits; delete layer.__onBeforeApplyEdits;
|
|
dfd.reject(error);
|
|
}
|
|
);
|
|
return dfd.promise;
|
|
},
|
|
|
|
/**
|
|
* DEPRECATED @ v2.5
|
|
* @returns {{}}
|
|
* @private
|
|
*/
|
|
_optimizeEditsQueue: function()
|
|
{
|
|
var optimizedEdits = {},
|
|
editCount = this._editStore.pendingEditsCount(),
|
|
optimizedCount = 0;
|
|
|
|
var edit, layer;
|
|
var layerEdits, objectId;
|
|
|
|
while( this._editStore.hasPendingEdits() )
|
|
{
|
|
edit = this._editStore.popFirstEdit();
|
|
layer = this._featureLayers[ edit.layer ];
|
|
|
|
if( ! (edit.layer in optimizedEdits) )
|
|
{
|
|
optimizedEdits[edit.layer] = {};
|
|
}
|
|
|
|
layerEdits = optimizedEdits[edit.layer];
|
|
objectId = edit.graphic.attributes[ layer.objectIdField ];
|
|
|
|
if( !( objectId in layerEdits) )
|
|
{
|
|
// first edit we see of this feature, no optimization to apply
|
|
layerEdits[ objectId ] = edit;
|
|
optimizedCount += 1;
|
|
}
|
|
else
|
|
{
|
|
// we already have seen one edit for this same feature... we can merge the two edits in a single operation
|
|
switch( edit.operation )
|
|
{
|
|
case this._editStore.ADD:
|
|
/* impossible!! */
|
|
throw("can't add the same feature twice!");
|
|
case this._editStore.UPDATE:
|
|
layerEdits[ objectId ].graphic = edit.graphic;
|
|
break;
|
|
case this._editStore.DELETE:
|
|
if(objectId < 0)
|
|
{
|
|
delete layerEdits[ objectId ];
|
|
optimizedCount -= 1;
|
|
}
|
|
else
|
|
{
|
|
layerEdits[objectId].operation = this._editStore.DELETE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if( Object.keys(layerEdits).length === 0 )
|
|
{
|
|
delete optimizedEdits[edit.layer];
|
|
}
|
|
}
|
|
|
|
console.log("optimized", editCount, "edits into", optimizedCount,"edits of", Object.keys(optimizedEdits).length ,"layers");
|
|
return optimizedEdits;
|
|
},
|
|
|
|
/**
|
|
* DEPRECATED @ v2.5
|
|
* A string value representing human readable information on pending edits
|
|
* @param edit
|
|
* @returns {string}
|
|
*/
|
|
getReadableEdit: function(edit)
|
|
{
|
|
var layer = this._featureLayers[ edit.layer ];
|
|
var graphic = this._editStore._deserialize(edit.graphic);
|
|
var readableGraphic = graphic.geometry.type;
|
|
var layerId = edit.layer.substring(edit.layer.lastIndexOf("/")+1);
|
|
if(layer)
|
|
{
|
|
readableGraphic += " [id=" + graphic.attributes[layer.objectIdField] + "]";
|
|
}
|
|
return "o:" + edit.operation + ", l:" + layerId + ", g:" + readableGraphic;
|
|
}
|
|
|
|
}); // declare
|
|
}); // define
|
|
|
|
/**
|
|
* Creates a namespace for the non-AMD libraries in this directory
|
|
*/
|
|
|
|
|
|
if(typeof O != "undefined"){
|
|
O.esri.Edit = {}
|
|
}
|
|
else{
|
|
O = {};
|
|
O.esri = {
|
|
Edit: {}
|
|
}
|
|
}
|
|
|
|
"use strict";
|
|
|
|
/*global IDBKeyRange,indexedDB */
|
|
|
|
"use strict";
|
|
O.esri.Edit.EditStore = function()
|
|
{
|
|
this._db = null;
|
|
|
|
// Public properties
|
|
|
|
var dbName = "features_store";
|
|
var objectStoreName = "features";
|
|
var dbIndex = "featureId";
|
|
|
|
// ENUMs
|
|
|
|
this.ADD = "add";
|
|
this.UPDATE = "update";
|
|
this.DELETE = "delete";
|
|
|
|
this.isSupported = function()
|
|
{
|
|
if(!window.indexedDB){
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* Commit an edit to the database
|
|
* @param operation add, update or delete
|
|
* @param layer the URL of the feature layer
|
|
* @param graphic esri/graphic. The method will serialize to JSON
|
|
* @param callback {true, edit} or {false, error}
|
|
*/
|
|
this.pushEdit = function(operation,layer,graphic, callback)
|
|
{
|
|
|
|
var edit = {
|
|
id: layer + "/" + graphic.attributes.objectid,
|
|
operation: operation,
|
|
layer: layer,
|
|
graphic: this._serialize(graphic)
|
|
};
|
|
|
|
var transaction = this._db.transaction([objectStoreName],"readwrite");
|
|
|
|
transaction.oncomplete = function(event){
|
|
callback(true);
|
|
};
|
|
|
|
transaction.onerror = function(event){
|
|
callback(false,event.target.error.message);
|
|
};
|
|
|
|
var objectStore = transaction.objectStore(objectStoreName);
|
|
objectStore.put(edit);
|
|
};
|
|
|
|
/**
|
|
* Returns all the edits recursively via the callback
|
|
* @param callback {value, message}
|
|
*/
|
|
this.getAllEdits = function(callback){
|
|
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
if(this._db !== null){
|
|
var transaction = this._db.transaction([objectStoreName])
|
|
.objectStore(objectStoreName)
|
|
.openCursor();
|
|
|
|
transaction.onsuccess = function(event)
|
|
{
|
|
var cursor = event.target.result;
|
|
if(cursor){
|
|
callback(cursor.value,null);
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(null, "end");
|
|
}
|
|
}.bind(this);
|
|
transaction.onerror = function(err)
|
|
{
|
|
callback(null, err);
|
|
};
|
|
}
|
|
else
|
|
{
|
|
callback(null, "no db");
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns all the edits as a single Array via the callback
|
|
* @param callback {value, message}
|
|
*/
|
|
this.getAllEditsArray = function(callback){
|
|
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
var editsArray = [];
|
|
|
|
if(this._db !== null){
|
|
var transaction = this._db.transaction([objectStoreName])
|
|
.objectStore(objectStoreName)
|
|
.openCursor();
|
|
|
|
transaction.onsuccess = function(event)
|
|
{
|
|
var cursor = event.target.result;
|
|
if(cursor){
|
|
editsArray.push(cursor.value);
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(editsArray, "end");
|
|
}
|
|
}.bind(this);
|
|
transaction.onerror = function(err)
|
|
{
|
|
callback(null, err);
|
|
};
|
|
}
|
|
else
|
|
{
|
|
callback(null, "no db");
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Update an edit already exists in the database
|
|
* @param operation add, update or delete
|
|
* @param layer the URL of the feature layer
|
|
* @param graphic esri/graphic. The method will serialize to JSON
|
|
* @param callback {true, edit} or {false, error}
|
|
*/
|
|
this.updateExistingEdit = function(operation,layer,graphic, callback){
|
|
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var objectStore = this._db.transaction([objectStoreName],"readwrite").objectStore(objectStoreName);
|
|
|
|
//Let's get the entry associated with the graphic
|
|
var objectStoreGraphicRequest = objectStore.get(graphic.attributes.objectid);
|
|
objectStoreGraphicRequest.onsuccess = function() {
|
|
|
|
//Grab the data object returned as a result
|
|
var data = objectStoreGraphicRequest.result;
|
|
|
|
//Create a new update object
|
|
var update = {
|
|
id: layer + "/" + graphic.attributes.objectid,
|
|
operation: operation,
|
|
layer: layer,
|
|
graphic: graphic.toJson()
|
|
};
|
|
|
|
// Insert the update into the database
|
|
var updateGraphicRequest = objectStore.put(update);
|
|
|
|
updateGraphicRequest.onsuccess = function(){
|
|
callback(true);
|
|
}
|
|
|
|
updateGraphicRequest.onerror = function(err){
|
|
callback(false,err);
|
|
};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Delete a pending edit's record from the database.
|
|
* IMPORTANT: Be aware of false negatives. See Step 4 in this function.
|
|
*
|
|
* @param layerUrl
|
|
* @param graphic Graphic
|
|
* @param callback {boolean, error}
|
|
*/
|
|
this.delete = function(layerUrl, graphic, callback){
|
|
|
|
// NOTE: the implementation of the IndexedDB spec has a design fault with respect to
|
|
// handling deletes. The result of a delete operation is always designated as undefined.
|
|
// What this means is that there is no way to tell if an operation was successful or not.
|
|
// And, it will always return 'true.'
|
|
//
|
|
// In order to get around this we have to verify if after the attempted deletion operation
|
|
// if the record is or is not in the database. Kinda dumb, but that's how IndexedDB works.
|
|
//http://stackoverflow.com/questions/17137879/is-there-a-way-to-get-information-on-deleted-record-when-calling-indexeddbs-obj
|
|
|
|
var db = this._db;
|
|
var deferred = null;
|
|
var self = this;
|
|
|
|
var id = layerUrl + "/" + graphic.attributes.objectid;
|
|
|
|
require(["dojo/Deferred"], function(Deferred){
|
|
deferred = new Deferred();
|
|
|
|
// Step 1 - lets see if record exits. If it does then return callback.
|
|
self.editExists(id).then(function(result){
|
|
if(result.success){
|
|
// Step 4 - Then we check to see if the record actually exists or not.
|
|
deferred.then(function(result){
|
|
|
|
// IF the delete was successful, then the record should return 'false' because it doesn't exist.
|
|
self.editExists(id).then(function(results){
|
|
results.success == false ? callback(true) : callback(false);
|
|
},
|
|
function(err){
|
|
callback(true); //because we want this test to throw an error. That means item deleted.
|
|
})
|
|
},
|
|
// There was a problem with the delete operation on the database
|
|
function(err){
|
|
callback(false,err);
|
|
});
|
|
|
|
var objectStore = db.transaction([objectStoreName],"readwrite").objectStore(objectStoreName);
|
|
|
|
// Step 2 - go ahead and delete graphic
|
|
var objectStoreDeleteRequest = objectStore.delete(id);
|
|
|
|
// Step 3 - We know that the onsuccess will always fire unless something serious goes wrong.
|
|
// So we go ahead and resolve the deferred here.
|
|
objectStoreDeleteRequest.onsuccess = function() {
|
|
deferred.resolve(true);
|
|
};
|
|
|
|
objectStoreDeleteRequest.onerror = function(msg){
|
|
deferred.reject({success:false,error:msg});
|
|
}
|
|
}
|
|
},
|
|
// If there is an error in editExists()
|
|
function(err){
|
|
callback(false);
|
|
});
|
|
});
|
|
};
|
|
|
|
this.resetEditsQueue = function(callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var request = this._db.transaction([objectStoreName],"readwrite")
|
|
.objectStore(objectStoreName)
|
|
.clear();
|
|
request.onsuccess = function(event){
|
|
setTimeout(function(){callback(true);},0);
|
|
};
|
|
request.onerror = function(err){
|
|
callback(false,err);
|
|
};
|
|
};
|
|
|
|
this.pendingEditsCount = function(callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var count = 0;
|
|
|
|
var objectStore = this._db.transaction([objectStoreName]).objectStore(objectStoreName);
|
|
objectStore.openCursor().onsuccess = function(evt)
|
|
{
|
|
var cursor = evt.target.result;
|
|
if(cursor)
|
|
{
|
|
count++;
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(count);
|
|
}
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Verify is an edit already exists in the database. Checks the objectId and layerId.
|
|
* @param id
|
|
* @returns {deferred} {success: boolean, error: message}
|
|
* @private
|
|
*/
|
|
this.editExists = function(id){
|
|
|
|
var db = this._db;
|
|
var deferred = null;
|
|
|
|
require(["dojo/Deferred"], function(Deferred){
|
|
deferred = new Deferred();
|
|
|
|
var objectStore = db.transaction([objectStoreName],"readwrite").objectStore(objectStoreName);
|
|
|
|
//Get the entry associated with the graphic
|
|
var objectStoreGraphicRequest = objectStore.get(id);
|
|
|
|
objectStoreGraphicRequest.onsuccess = function() {
|
|
var graphic = objectStoreGraphicRequest.result;
|
|
if(graphic && (graphic.id == id)){
|
|
deferred.resolve({success:true,error:null});
|
|
}
|
|
else{
|
|
deferred.reject({success:false,error:"Layer id is not a match."});
|
|
}
|
|
};
|
|
|
|
objectStoreGraphicRequest.onerror = function(msg){
|
|
deferred.reject({success:false,error:msg});
|
|
}
|
|
});
|
|
|
|
//We return a deferred object so that when calling this function you can chain it with a then() statement.
|
|
return deferred;
|
|
};
|
|
|
|
/**
|
|
* Returns the approximate size of the database in bytes
|
|
* @param callback {usage, error} Whereas, the usage Object is {sizeBytes: number, editCount: number}
|
|
*/
|
|
this.getUsage = function(callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var usage = { sizeBytes: 0, editCount: 0 };
|
|
|
|
var transaction = this._db.transaction([objectStoreName])
|
|
.objectStore(objectStoreName)
|
|
.openCursor();
|
|
|
|
console.log("dumping keys");
|
|
|
|
transaction.onsuccess = function(event)
|
|
{
|
|
var cursor = event.target.result;
|
|
if(cursor)
|
|
{
|
|
var storedObject = cursor.value;
|
|
var json = JSON.stringify(storedObject);
|
|
usage.sizeBytes += json.length;
|
|
usage.editCount += 1;
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(usage,null);
|
|
}
|
|
};
|
|
transaction.onerror = function(err)
|
|
{
|
|
callback(null,err);
|
|
};
|
|
};
|
|
|
|
// internal methods
|
|
|
|
/**
|
|
* Save space in the database...don't need to store the entire Graphic object just its public properties!
|
|
* @param graphic
|
|
* @returns {*}
|
|
* @private
|
|
*/
|
|
this._serialize = function(graphic)
|
|
{
|
|
// see http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#/Apply_Edits_Feature_Service_Layer/02r3000000r6000000/
|
|
// use graphic's built-in serializing method
|
|
var json = graphic.toJson();
|
|
var jsonClean =
|
|
{
|
|
attributes: json.attributes,
|
|
geometry: json.geometry,
|
|
infoTemplate: json.infoTemplate,
|
|
symbol: json.symbol
|
|
};
|
|
return JSON.stringify(jsonClean);
|
|
};
|
|
|
|
this._deserialize = function(json)
|
|
{
|
|
var graphic;
|
|
|
|
require(["esri/graphic"],function(Graphic){
|
|
graphic = new Graphic(JSON.parse(json));
|
|
});
|
|
|
|
return graphic;
|
|
};
|
|
|
|
this.init = function(callback)
|
|
{
|
|
console.log("init editsStore.js");
|
|
|
|
var request = indexedDB.open(dbName, 11);
|
|
callback = callback || function(success) { console.log("EditsStore::init() success:", success); }.bind(this);
|
|
|
|
request.onerror = function(event)
|
|
{
|
|
console.log("indexedDB error: " + event.target.errorCode);
|
|
callback(false,event.target.errorCode);
|
|
}.bind(this);
|
|
|
|
request.onupgradeneeded = function(event)
|
|
{
|
|
var db = event.target.result;
|
|
|
|
if( db.objectStoreNames.contains(objectStoreName))
|
|
{
|
|
db.deleteObjectStore(objectStoreName);
|
|
}
|
|
|
|
var objectStore = db.createObjectStore(objectStoreName, { keyPath: "id" });
|
|
objectStore.createIndex(dbIndex,dbIndex, {unique: false});
|
|
}.bind(this);
|
|
|
|
request.onsuccess = function(event)
|
|
{
|
|
this._db = event.target.result;
|
|
console.log("database opened successfully");
|
|
callback(true);
|
|
}.bind(this);
|
|
};
|
|
|
|
///
|
|
/// DEPRECATED
|
|
///
|
|
|
|
/**
|
|
* Deprecated @ v2.5. Use pendingEditsCount() instead.
|
|
*/
|
|
this.hasPendingEdits = function()
|
|
{
|
|
return "DEPRECATED at v2.5!";
|
|
};
|
|
|
|
/**
|
|
* Deprecated @ v2.5. Use public function editExists() instead.
|
|
*/
|
|
this._isEditDuplicated = function(newEdit,edits){
|
|
return "DEPRECATED at v2.5!";
|
|
};
|
|
};
|
|
|
|
|
|
|
|
/*global IDBKeyRange,indexedDB */
|
|
|
|
"use strict";
|
|
O.esri.Edit.AttachmentsStore = function()
|
|
{
|
|
this._db = null;
|
|
|
|
var DB_NAME = "attachments_store";
|
|
var OBJECT_STORE_NAME = "attachments";
|
|
|
|
this.isSupported = function()
|
|
{
|
|
if(!window.indexedDB){
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
this.store = function(featureLayerUrl, attachmentId, objectId, attachmentFile, callback)
|
|
{
|
|
try
|
|
{
|
|
// first of all, read file content
|
|
this._readFile(attachmentFile, function(fileContent)
|
|
{
|
|
// now, store it in the db
|
|
var newAttachment =
|
|
{
|
|
id: attachmentId,
|
|
objectId: objectId,
|
|
featureId: featureLayerUrl + "/" + objectId,
|
|
contentType: attachmentFile.type,
|
|
name: attachmentFile.name,
|
|
size: attachmentFile.size,
|
|
url: this._createLocalURL(attachmentFile),
|
|
content: fileContent
|
|
};
|
|
|
|
var transaction = this._db.transaction([OBJECT_STORE_NAME],"readwrite");
|
|
|
|
transaction.oncomplete = function(event)
|
|
{
|
|
callback(true, newAttachment);
|
|
};
|
|
|
|
transaction.onerror = function(event)
|
|
{
|
|
callback(false,event.target.error.message);
|
|
};
|
|
|
|
var objectStore = transaction.objectStore(OBJECT_STORE_NAME);
|
|
var request = objectStore.put(newAttachment);
|
|
request.onsuccess = function(event)
|
|
{
|
|
//console.log("item added to db " + event.target.result);
|
|
};
|
|
|
|
}.bind(this));
|
|
}
|
|
catch(err)
|
|
{
|
|
console.log("AttachmentsStore: " + err.stack);
|
|
callback(false,err.stack);
|
|
}
|
|
};
|
|
|
|
this.retrieve = function(attachmentId, callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var objectStore = this._db.transaction([OBJECT_STORE_NAME]).objectStore(OBJECT_STORE_NAME);
|
|
var request = objectStore.get(attachmentId);
|
|
request.onsuccess = function(event)
|
|
{
|
|
var result = event.target.result;
|
|
if(!result){
|
|
callback(false,"not found");
|
|
}
|
|
else{
|
|
callback(true,result);
|
|
}
|
|
};
|
|
request.onerror = function(err)
|
|
{
|
|
console.log(err);
|
|
callback(false,err);
|
|
};
|
|
};
|
|
|
|
this.getAttachmentsByFeatureId = function(featureLayerUrl,objectId,callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var featureId = featureLayerUrl + "/" + objectId;
|
|
var attachments = [];
|
|
|
|
var objectStore = this._db.transaction([OBJECT_STORE_NAME]).objectStore(OBJECT_STORE_NAME);
|
|
var index = objectStore.index("featureId");
|
|
var keyRange = IDBKeyRange.only(featureId);
|
|
index.openCursor(keyRange).onsuccess = function(evt)
|
|
{
|
|
var cursor = evt.target.result;
|
|
if(cursor)
|
|
{
|
|
attachments.push( cursor.value );
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(attachments);
|
|
}
|
|
};
|
|
};
|
|
|
|
this.getAttachmentsByFeatureLayer = function(featureLayerUrl,callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var attachments = [];
|
|
|
|
var objectStore = this._db.transaction([OBJECT_STORE_NAME]).objectStore(OBJECT_STORE_NAME);
|
|
var index = objectStore.index("featureId");
|
|
var keyRange = IDBKeyRange.bound(featureLayerUrl + "/", featureLayerUrl + "/A");
|
|
index.openCursor(keyRange).onsuccess = function(evt)
|
|
{
|
|
var cursor = evt.target.result;
|
|
if(cursor)
|
|
{
|
|
attachments.push( cursor.value );
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(attachments);
|
|
}
|
|
};
|
|
};
|
|
|
|
this.getAllAttachments = function(callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var attachments = [];
|
|
|
|
var objectStore = this._db.transaction([OBJECT_STORE_NAME]).objectStore(OBJECT_STORE_NAME);
|
|
objectStore.openCursor().onsuccess = function(evt)
|
|
{
|
|
var cursor = evt.target.result;
|
|
if(cursor)
|
|
{
|
|
attachments.push( cursor.value );
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(attachments);
|
|
}
|
|
};
|
|
};
|
|
|
|
this.deleteAttachmentsByFeatureId = function(featureLayerUrl,objectId,callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var featureId = featureLayerUrl + "/" + objectId;
|
|
|
|
var objectStore = this._db.transaction([OBJECT_STORE_NAME],"readwrite").objectStore(OBJECT_STORE_NAME);
|
|
var index = objectStore.index("featureId");
|
|
var keyRange = IDBKeyRange.only(featureId);
|
|
var deletedCount = 0;
|
|
index.openCursor(keyRange).onsuccess = function(evt)
|
|
{
|
|
var cursor = evt.target.result;
|
|
if(cursor)
|
|
{
|
|
var attachment = cursor.value;
|
|
this._revokeLocalURL(attachment);
|
|
objectStore.delete(cursor.primaryKey);
|
|
deletedCount++;
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
setTimeout(function(){callback(deletedCount);},0);
|
|
}
|
|
}.bind(this);
|
|
};
|
|
|
|
this.delete = function(attachmentId, callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
// before deleting an attachment we must revoke the blob URL that it contains
|
|
// in order to free memory in the browser
|
|
this.retrieve(attachmentId, function(success, attachment)
|
|
{
|
|
if( !success )
|
|
{
|
|
callback(false,"attachment " + attachmentId + " not found");
|
|
return;
|
|
}
|
|
|
|
this._revokeLocalURL(attachment);
|
|
|
|
var request = this._db.transaction([OBJECT_STORE_NAME],"readwrite")
|
|
.objectStore(OBJECT_STORE_NAME)
|
|
.delete(attachmentId);
|
|
request.onsuccess = function(event)
|
|
{
|
|
setTimeout(function(){callback(true);},0);
|
|
};
|
|
request.onerror = function(err)
|
|
{
|
|
callback(false,err);
|
|
};
|
|
}.bind(this));
|
|
};
|
|
|
|
this.deleteAll = function(callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
this.getAllAttachments(function(attachments)
|
|
{
|
|
attachments.forEach(function(attachment)
|
|
{
|
|
this._revokeLocalURL(attachment);
|
|
},this);
|
|
|
|
var request = this._db.transaction([OBJECT_STORE_NAME],"readwrite")
|
|
.objectStore(OBJECT_STORE_NAME)
|
|
.clear();
|
|
request.onsuccess = function(event)
|
|
{
|
|
setTimeout(function(){callback(true);},0);
|
|
};
|
|
request.onerror = function(err)
|
|
{
|
|
callback(false,err);
|
|
};
|
|
}.bind(this));
|
|
};
|
|
|
|
this.replaceFeatureId = function(featureLayerUrl, oldId, newId, callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var featureId = featureLayerUrl + "/" + oldId;
|
|
|
|
var objectStore = this._db.transaction([OBJECT_STORE_NAME],"readwrite").objectStore(OBJECT_STORE_NAME);
|
|
var index = objectStore.index("featureId");
|
|
var keyRange = IDBKeyRange.only(featureId);
|
|
var replacedCount = 0;
|
|
index.openCursor(keyRange).onsuccess = function(evt)
|
|
{
|
|
var cursor = evt.target.result;
|
|
if(cursor)
|
|
{
|
|
var newFeatureId = featureLayerUrl + "/" + newId;
|
|
var updated = cursor.value;
|
|
updated.featureId = newFeatureId;
|
|
updated.objectId = newId;
|
|
objectStore.put(updated);
|
|
replacedCount++;
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
// allow time for all changes to persist...
|
|
setTimeout( function() { callback(replacedCount); }, 1 );
|
|
}
|
|
};
|
|
};
|
|
|
|
this.getUsage = function(callback)
|
|
{
|
|
console.assert(this._db !== null, "indexeddb not initialized");
|
|
|
|
var usage = { sizeBytes: 0, attachmentCount: 0 };
|
|
|
|
var transaction = this._db.transaction([OBJECT_STORE_NAME])
|
|
.objectStore(OBJECT_STORE_NAME)
|
|
.openCursor();
|
|
|
|
console.log("dumping keys");
|
|
|
|
transaction.onsuccess = function(event)
|
|
{
|
|
var cursor = event.target.result;
|
|
if(cursor)
|
|
{
|
|
console.log(cursor.value.id, cursor.value.featureId, cursor.value.objectId);
|
|
var storedObject = cursor.value;
|
|
var json = JSON.stringify(storedObject);
|
|
usage.sizeBytes += json.length;
|
|
usage.attachmentCount += 1;
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(usage,null);
|
|
}
|
|
}.bind(this);
|
|
transaction.onerror = function(err)
|
|
{
|
|
callback(null,err);
|
|
};
|
|
};
|
|
|
|
// internal methods
|
|
|
|
this._readFile = function(attachmentFile, callback)
|
|
{
|
|
var reader = new FileReader();
|
|
reader.onload = function(evt)
|
|
{
|
|
callback(evt.target.result);
|
|
};
|
|
reader.readAsBinaryString(attachmentFile);
|
|
};
|
|
|
|
this._createLocalURL = function(attachmentFile)
|
|
{
|
|
return window.URL.createObjectURL(attachmentFile);
|
|
};
|
|
|
|
this._revokeLocalURL = function(attachment)
|
|
{
|
|
window.URL.revokeObjectURL(attachment.url);
|
|
};
|
|
|
|
this.init = function(callback)
|
|
{
|
|
console.log("init AttachmentStore");
|
|
|
|
var request = indexedDB.open(DB_NAME, 11);
|
|
callback = callback || function(success) { console.log("AttachmentsStore::init() success:", success); }.bind(this);
|
|
|
|
request.onerror = function(event)
|
|
{
|
|
console.log("indexedDB error: " + event.target.errorCode);
|
|
callback(false,event.target.errorCode);
|
|
}.bind(this);
|
|
|
|
request.onupgradeneeded = function(event)
|
|
{
|
|
var db = event.target.result;
|
|
|
|
if( db.objectStoreNames.contains(OBJECT_STORE_NAME))
|
|
{
|
|
db.deleteObjectStore(OBJECT_STORE_NAME);
|
|
}
|
|
|
|
var objectStore = db.createObjectStore(OBJECT_STORE_NAME, { keyPath: "id" });
|
|
objectStore.createIndex("featureId","featureId", {unique: false});
|
|
}.bind(this);
|
|
|
|
request.onsuccess = function(event)
|
|
{
|
|
this._db = event.target.result;
|
|
console.log("database opened successfully");
|
|
callback(true);
|
|
}.bind(this);
|
|
};
|
|
};
|
|
|