On 09/13/2010 02:44 PM, Endi Sukma Dewata wrote:
----- "Adam Young"<[email protected]> wrote:
IPA class:
- IPA(path, type): Construct IPA object given a path to server's JSON-RPC or
static files.
- success(): Default success handler.
- error(): Default error handler.
- failure(): Default failure handler.
- execute(methodName, params, options, [success], [error], [failure]):
Execute a method with optional handlers. The methodName should include
the object name.
For the Web UI we could create a global IPA object that points to JSON-RPC
or sample data based on the current URL. The IPA object can be reused, each
entity only needs to invoke the execute() method and provides necessary
handlers.
This class could still be used in addition to your class below to provide
global settings for the entire application or test suite. For example we can
implement a default handler for insufficient access error.
execute has a lot of parameters. I think I would prefer a simple
execute(args, options,caller)
It could then be called
cmd.execute(args, options,this)
The constructor can take a spec like this
var cmd = command({entity: e, method:m, succes:s , error: e,
failure f});
and then we can check for the presence of each of the parameters.
The inline case would be
command({entity: e, method:m, succes:s , error: e, failure
f}).execute(args, options);
I guess this class probably can be called IPACommand or something like
that. This class could be instantiated by invoking createCommand()
in the above IPA class. I'd ask though that the entity& method be
combined into a single parameter. This is just in case in the future
we will have a command that doesn't have an associated entity.
We'll keep the current logic which is that entity is only appended to
the method if it is set, otherwise, use method as is.
There are no classes in JavaScript, just objects. Either we create it
through
new Command(){...}
or using the functional approach var addUserComand = command(){
that = {}; ...; return that ;}
There is a lot to recommend the second approach.
caller would be an object that respects the contract
{
on _error = function(){...}
on_success = function(){...}
on_failure= function(){...}
}
With each of these functions being optional. If set, they get called
in place of the Command members.
I'm not sure about this, there's a potential of conflict if the caller
wants to use several different IPA commands.
Should not be too hard in the case where one caller wants to have
multiple commands to write a simple adapter that calls the appropriate
methods on the caller, or to split the caller along appropriate lines.
The prototype for command should have a default implementation for
error, success, and failure. New instance should be created using a
clone, with the default as the prototype.
I'd rather override the default function with a custom one as needed.
So in the application initialization we could do this:
var ipa;
if (window.location.protocol == "file:") {
ipa = new IPA("sampledata", IPA_JSON_FOLDER);
} else {
ipa = new IPA("/ipa/json", IPA_JSON_RPC);
}
ipa.error = function() {
if (insufficient access) {
do something
}
}
In the entity initialization we could do this:
var addCmd = ipa.createCommand("user-add");
addCmd.success = function() {...};
addCmd.error = function() {...};
There is a slightly better way to do this.
A trick from Javascript: the good parts:
Object.beget = function(o){
ar F = function(){
F.prototype = o;
return new F();
};
Bascially a clone function, which set up the prototype, and thus the
default behavior. Then, we have a Default command object:
IPA.command = function(){
var that = {};
execute(args, params){
//pretty much the same logic we have now;
}
function set_error(on_error){
this.error = error;
return this;
}
function set_success(on_success){
this.success = on_success;
return this;
}
function set_failure(on_fail){
this.success = on_fail;
return this;
}
function clone(){
return Object.beget(that);
}
//THis is the public interface
that.execute = execute;
that.set_failure = set_error;
that.set_success = set_error;
that.set_error= set_error;
return that;
}
TO make new command that over rides just the success method:
IPA.command.clone().
set_success(funcion(){...});
Over ride sucess and failure:
IPA.command.clone().
set_success(function(){...}).
set_failure(function(){...});
In the button handler we could do this:
addCmd.execute(params, options);
Just my $.02. Thanks.
--
Endi S. Dewata
_______________________________________________
Freeipa-devel mailing list
[email protected]
https://www.redhat.com/mailman/listinfo/freeipa-devel
