Jason’s postings and stuff

Ext.override(Ext.data.HttpProxy, {
    doRequest : function(action, rs, params, reader, cb, scope, arg) {
        var  o = {
            method: (this.api[action]) ? this.api[action]['method'] : undefined,
            request: {
                callback : cb,
                scope : scope,
                arg : arg
            },
            reader: reader,
            callback : this.createCallback(action, rs),
            scope: this
        };
 
        // Always do this.
        o.jsonData = params;
 
        // Set the connection url.  If this.conn.url is not null here,
        // the user may have overridden the url during a beforeaction event-handler.
        // this.conn.url is nullified after each request.
        if (this.conn.url === null) {
            this.conn.url = this.buildUrl(action, rs);
        }
        else if (this.restful === true && rs instanceof Ext.data.Record && !rs.phantom) {
            this.conn.url += '/' + rs.id;
        }
        if(this.useAjax){
 
            Ext.applyIf(o, this.conn);
 
            // If a currently running request is found for this action, abort it.
            if (this.activeRequest[action]) {
                // Disabled aborting activeRequest while implementing REST.  activeRequest[action] will have to become an array
                //Ext.Ajax.abort(this.activeRequest[action]);
            }
            this.activeRequest[action] = Ext.Ajax.request(o);
        }else{
            this.conn.request(o);
        }
        // request is sent, nullify the connection url in preparation for the next request
        this.conn.url = null;
    }
}

Ext.override(Ext.data.JsonReader, {
	readResponse : function(action, response) {
		var o = {};
 
		if(response.status >= 200 && response.status <=300) {
			o[this.meta.successProperty] = true;
		}
		else if(response.status == 403) {
			o[this.meta.successProperty] = false;
		}
 
		// Avoid No Content
		if(response.status !== 204) {
			o[this.meta.root] = (response.responseText !== undefined) ? Ext.decode(response.responseText) : response;
			if(!o[this.meta.root]) {
				throw new Ext.data.JsonReader.Error('response');
			}
		}
 
		// These cause trouble.
		// Persevere uses HTTP status codes for success and uses no root.
		/*
		if (Ext.isEmpty(o[this.meta.successProperty])) {
			throw new Ext.data.JsonReader.Error('successProperty-response', this.meta.successProperty);
		}
		// make sure extraction functions are defined.
		// Nonsense for 204, don't do it
		this.ef = this.buildExtractors();
		// Need to return additional status code
		return o;
	}
});

Ext.override(Ext.data.JsonWriter, {
 
	render:function(action, rs, params, data) {
		var f = rs.fields, fi = f.items, fl = f.length, field, val;
		for(var j = 0; j < fl; j++){
			field = fi[j];
			if(field.type == 'int') {
				val = parseInt(rs.data[field.name]);
				data[field.name] = isNaN(val) ? null : val;
			}
		}
		Ext.apply(params, data);
	},
 
	update:function(rs) {
 
		var params = {};
 
		if (Ext.isArray(rs)) {
			var data = [];
			Ext.each(rs, function(val){
				data.push(this.updateRecord(val));
			}, this);
			Ext.apply(params, data);
		}
		else if (rs instanceof Ext.data.Record) {
			Ext.apply(params, this.updateRecord(rs));
		}
		return params;
	},
 
	create:function(rs) {
 
		var params = {};
 
		if (Ext.isArray(rs)) {
			var data = [];
			Ext.each(rs, function(val){
				data.push(this.updateRecord(val));
			}, this);
			Ext.apply(params, data);
		}
		else if (rs instanceof Ext.data.Record) {
			Ext.apply(params, this.updateRecord(rs));
		}
		return params;
	},
 
	toHash:function(rec) {
		var map = rec.fields.map,
			data = {},
			raw = (this.writeAllFields === false && rec.phantom === false) ? rec.getChanges() : rec.data,
			m;
		Ext.iterate(raw, function(prop, value){
			if((m = map[prop])){
				data[m.mapping ? m.mapping : m.name] = value;
			}
		});
		// Blows up sending phantom to persevere
		if(rec.phantom === false) {
			data[this.meta.idProperty] = rec.id;
		}
		return data;
	}
});

this.path = '/Sometable';
this.store = {
	autoDestroy:true,
	autoSave:false,
	restful:true,
	reader:new Ext.data.JsonReader(
		{
			totalProperty:'totalCount',
			idProperty:'id',
			root:'items',
		},
		Ext.data.Record.create([
			{name:'size', type:'int'},
			{name:'type'},
			{name:'speed', type:'int'}
		])),
	proxy:new Ext.data.HttpProxy({
		url:this.path,
		method:'GET',
		headers:{'Accept':'application/json; collection=items'},
		// bulk PUT && POST are allowed by persevere
		// the update path needs a trailing / for that or
		// the ids come back as id:object/id instead of id
		api:{
			update:this.path,
			read:this.path+'/',
			create:this.path+'/',
			destroy:this.path
		}
	}),
	writer:new Ext.data.JsonWriter({encode:false, writeAllFields:true})
};

js>serialize(load('/Item')); 
[
{"id":"Item/3",
        "sn":"abc123aazzzaa",
        "pn":"aa"
},
...]