<!-- Dependency -->
<script src="http://yui.yahooapis.com/2.9.0/build/yahoo/yahoo-min.js"></script>
 
<!-- Used for Custom Events and event listener bindings -->
<script src="http://yui.yahooapis.com/2.9.0/build/event/event-min.js"></script>
 
<!-- Source file -->
<!--
	If you require only basic HTTP transaction support, use the
	connection_core.js file.
-->
<script src="http://yui.yahooapis.com/2.9.0/build/connection/connection_core-min.js"></script>
 
<!--
	Use the full connection.js if you require the following features:
	- Form serialization.
	- File Upload using the iframe transport.
	- Cross-domain(XDR) transactions.
-->
<script src="http://yui.yahooapis.com/2.9.0/build/connection/connection-min.js"></script>
 

var transaction = YAHOO.util.Connect.asyncRequest('GET', sUrl, callback, null);
 

/*
 * This is an example callback object with success
 * and failure members defined inline.  The argument
 * property demonstrates how to pass multiple values
 * to the callback as an array.
 */
var callback = {
  success: function(o) {/*success handler code*/},
  failure: function(o) {/*failure handler code*/},
  argument: [argument1, argument2, argument3]
};
 

// Passing an example of array of arguments to both
// the success and failure callback handlers.
var args = ['foo','bar'];
 
var responseSuccess = function(o) {
/* Please see the Success Case section for more
 * details on the response object's properties.
 * o.tId
 * o.status
 * o.statusText
 * o.getResponseHeader[ ]
 * o.getAllResponseHeaders
 * o.responseText
 * o.responseXML
 * o.argument
 */
};
 
var responseFailure = function(o) {
// Access the response object's properties in the
// same manner as listed in responseSuccess( ).
// Please see the Failure Case section and
// Communication Error sub-section for more details on the
// response object's properties.
};
 
var callback = {
  success:responseSuccess,
  failure:responseFailure,
  argument:args
};
 

/*
 * Set callback.cache to false to override HTTP GET caching.
 * A key-value of rnd=timestamp will be added to the
 * querystring.
 */
var callback = {
  cache:false
};
 

/*
 * This is an example callback object with upload
 * and argument members defined inline.  The argument
 * property demonstrates how to pass multiple values
 * to the upload handler as an array.
 */
var callback = {
  upload: function(o) {/*upload handler code*/},
  argument: [argument1, argument2, argument3]
};
 

/*
 * AjaxObject is a hypothetical object that encapsulates the transaction
 *     request and callback logic.
 *
 * handleSuccess( ) provides success case logic
 * handleFailure( ) provides failure case logic
 * processResult( ) displays the results of the response from both the
 * success and failure handlers
 * call( ) calling this member starts the transaction request.
 */
 
var AjaxObject = {
 
	handleSuccess:function(o) {
		// This member handles the success response
		// and passes the response object o to AjaxObject's
		// processResult member.
		this.processResult(o);
	},
 
	handleFailure:function(o) {
		// Failure handler
	},
 
	processResult:function(o) {
		// This member is called by handleSuccess
	},
 
	startRequest:function() {
	   YAHOO.util.Connect.asyncRequest('POST', 'php/post.php', callback, "new=1&old=2");
	}
 
};
 
/*
 * Define the callback object for success and failure
 * handlers as well as object scope.
 */
var callback = {
	success:AjaxObject.handleSuccess,
	failure:AjaxObject.handleFailure,
	scope: AjaxObject
};
 
// Start the transaction.
AjaxObject.startRequest();
 

	/*
	 * In this example, the callback object has a new property:
	 * timeout.  This property is defined with a value,
	 * in milliseconds, of 5000 as the abort threshold.  If
	 * the transaction has not completed by 5000ms, the
	 * transaction will abort.
	 */
	var callback = {
	  success: function(o) {/*success handler code*/},
	  failure: function(o) {/*failure handler code*/},
	  timeout: 5000,
	  argument: [argument1, argument2, argument3]
	};
 

// argument formId can be the id or name attribute value of the
// HTML form, or an HTML form object.
var formObject = document.getElementById('aForm');
YAHOO.util.Connect.setForm(formObject);
// This example facilitates a POST transaction.  The POST data(HTML form)
// are initialized when calling setForm(), and it is automatically
// included when calling asyncRequest.
var cObj = YAHOO.util.Connect.asyncRequest('POST', 'http://www.yahoo.com', callback);
 

   // argument formId can be the id or name attribute value of the
   // HTML form, or an HTML form object.
   var formObject = document.getElementById('aForm');
 
   // the second argument is true to indicate file upload.
   YAHOO.util.Connect.setForm(formObject, true);
 
   var cObj = YAHOO.util.Connect.asyncRequest('POST', 'http://www.yahoo.com', callback);
 

// the third argument is set true to have Connection Manager
// set the iframe source to "javascript:false".
YAHOO.util.Connect.setForm(formObject, true, true);
 

<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy SYSTEM
"http://www.adobe.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
	<allow-access-from domain="*.yahoo.com"/>
</cross-domain-policy>
 

var YCM = YAHOO.util.Connect,
	// The resource is Yahoo! Pipes, returning JSON data.
	uri = "http://pipes.yahooapis.com/pipes/pipe.run?_id=giWz8Vc33BG6rQEQo_NLYQ&_render=json",
	request, callback, responseSuccess, responseFailure;
 
responseSuccess = function(o){
  * The argument 'o' is the response object.  Its
  * properties are:
  *
  * - tId
  * - responseText
  * - argument
};
 
responseFailure = function(o){
  // See the comments for responseSuccess.
};
 
// Create a callback object that defines success and failure
// handlers, and instructs Connection Manager to use the
// Flash transport by defining the xdr property and setting
// it to true.
callback = {
  success:responseSuccess,
  failure:responseFailure,
  xdr: true, // Use the Flash transport instead of XMLHttpRequest
  argument:['foo', 'bar']
};
 
function makeRequest() {
	// Send request to xml.weather.yahoo.com
	request = YCM.asyncRequest('GET', uri, callback);
}
 
// Initialize the Flash transport for XDR
YCM.transport('connection.swf');
 
// Subscribe to xdrReadyEvent, which is fired
// when connection.swf's finishes loading, and
// call function request().
YCM.xdrReadyEvent.subscribe(makeRequest);
 

// Create a shorthand for YAHOO.util.Connect
var YUC = YAHOO.util.Connect;
 
/*
 * Create an object to handle all of the Connection Manager custom events.
 *
 * NOTE: You can also choose to represent your event handlers as global
 * functions instead of object members, and omit the scope argument from
 * subscribe().
 */
var handleEvents = {
	start: function(eventType, args) {
	// do something when startEvent fires.
	// Argument eventType will have a string value of: startEvent
	// Argument args is an array, and the response object will be the
    // first element in the array.  The response object will have one
    // property: tId (the transaction ID).
    },
 
	complete: function(eventType, args) {
	// do something when completeEvent fires.
	},
 
	success: function(eventType, args) {
	// do something when successEvent fires.
	},
 
	failure: function(eventType, args) {
	// do something when failureEvent fires.
	},
 
	// Define this event handler for file upload transactions *only*.
	// This handler will not be used for any other transaction cases.
	upload: function(eventType, args) {
	// do something when uploadEvent fires.
	},
 
	abort: function(eventType, args) {
	// do something when abortEvent fires.
	}
};
 
/*
 * This example shows how to subscribe to all custom events fired at the
 * Connection Manager level.  When subscribed, the custom event will fire
 * for all transactions.
 */
 
// Subscribe to all custom events fired by Connection Manager.
// Pass in the *globalEvents* object as the second argument to provide
// the necessary scope correction for any usage of the *this* keyword
// in any of the handler functions.
YUC.startEvent.subscribe(handleEvents.start, handleEvents);
YUC.completeEvent.subscribe(handleEvents.complete, handleEvents);
 
// This event will not fire for file upload transactions.  Instead,
// subscribe to the uploadEvent.
YUC.successEvent.subscribe(handleEvents.success, handleEvents);
 
// This event will not fire for file upload transactions.  Instead,
// subscribe to the uploadEvent.
YUC.failureEvent.subscribe(handleEvents.failure, handleEvents);
 
// This event is fired only for file upload transactions in place of
// successEvent and failureEvent
YUC.uploadEvent.subscribe(handleEvents.upload, handleEvents);
YUC.abortEvent.subscribe(handleEvents.abort, handleEvents);
 
/*
 * NOTE: You do not need to pass a callback object to asyncRequest()
 * since your handlers are already subscribed at the Connection
 * Manager level.  The callback object omits any success or failure
 * logic since those cases are already available and subscribed to as
 * custom events.  You can still include callback.success and
 * callback.failure, and they will be processed; but, it will also be
 * a redundant action.
 */
 
var transaction = YUC.asyncRequest('GET', sUrl, { timeout: 3000 });
 

var callback = {
	customevents:{
		onStart: function(eventType, args) {
		  // eventType has a string value of "startEvent".
		  // args[0].tId is the integer transaction ID.
		  // args[1] contains the value of <code>callback.argument</code>, if callback.argument is defined.
		},
		onComplete: function(eventType, args) {
		  // eventType has a string value of "completeEvent".
		  // args[0].tId is the integer transaction ID.
		  // args[1] contains the value of <code>callback.argument</code>, if callback.argument is defined.
		},
		onSuccess: function(eventType, args) {
		  /*
		   * eventType has a string value of "successEvent".
		   * args[0] is the response object, which has the
		   * following properties:
		   *
		   * args[0].tId
		   * args[0].status
		   * args[0].statusText
		   * args[0].getResponseHeader[ ]
		   * args[0].getAllResponseHeaders
		   * args[0].responseText
		   * args[0].responseXML
		   * args[0].argument
		   */
		},
		onFailure: function(eventType, args) {
		  // eventType has a string value of "failureEvent".
		  // args[0] is the response object.
		},
 
        // Define this event handler for file upload transactions *only*.
        // This handler will not be used for any other transaction cases.
		onUpload: function(eventType, args) {
		  // eventType has a string value of "uploadEvent".
		  // args[0] is the response object.
		},
		onAbort: function(eventType, args) {
		  // eventType has a string value of "abortEvent".
		  // args[0].tId is the integer transaction ID.
		  // args[1] contains the value of <code>callback.argument</code>, if callback.argument is defined.
		}
	}
};
 

/*
 * Create an event handler object to handle a transaction's custom events.
 *
 * NOTE: You can also choose to represent your event handlers as global
 * functions instead of object members, and omit the scope argument from
 * the callback.
 *
 * This example demonstrates a non-file upload transaction, hence the
 * handler onUpload is not defined.
 */
var handleEvent = {
	start: function(eventType, args) {
	// do something when startEvent fires.
	},
 
	complete: function(eventType, args) {
	// do something when completeEvent fires.
	},
 
	success: function(eventType, args) {
	// do something when successEvent fires.
	},
 
	failure: function(eventType, args) {
	// do something when failureEvent fires.
	},
 
	abort: function(eventType, args) {
	// do something when abortEvent fires.
	}
};
 
/*
 * This example shows how to subscribe to all custom events.
 * Pass the *handleEvent* object as the second argument to provide
 * the necessary scope correction for any usage of the *this* keyword
 * in any of the handler functions.
 *
 * NOTE: All events are subscribed in this example, but you can choose
 * to subscribe to any combination of custom events desired.  None are
 * mandatory.
 */
 
// Define the scope property with a value of *handleEvent* to provide
// the necessary scope correction for any usage of the *this* keyword
// in any of the handler functions.
 
/* Callback object with custom events defined */
var callback = {
	customevents: {
		onStart: handleEvent.start,
		onComplete: handleEvent.complete,
		onSuccess: handleEvent.success,
		onFailure: handleEvent.failure,
		onAbort: handleEvent.abort
	},
	scope:handleEvent,
 	argument: ["foo", "bar", "baz"]
};
 
var transaction = YAHOO.util.Connect.asyncRequest('GET', sUrl, callback);
 

 
// $deleteRecordToken can be any additional, random sequence concatenated onto $username.
// to salt the string which is converted to an MD5 hash.
$transaction_signature = md5($username . $deleteRecordToken);
 

/*
 * Create a custom header -- in this case "X-Signature" -- using
 * connection manager with the signature as its value, and initiate
 * the transaction.  The transaction is sent to "/delete_record.php".
 */
YAHOO.util.Connect.initHeader('X-Signature', '<? echo $transaction_signature ?>');
var request = YAHOO.util.Connect.asyncRequest('GET', '/delete_record.php', callback);
 

 
$transaction_signature = md5($username . $deleteRecordToken);
 
if ($_SERVER['HTTP_X_SIGNATURE']  === $transaction_signature) {
  // proceed with delete operation
  // ...
} else {
  // there is a problem
  // ...
}
 
 

 
$transaction_signature = md5($username . $deleteRecordToken);
 
// $uri is the resource and the querystring includes the
// signature.
$uri = '/delete_record.php?signature=' . $transaction_signature;
 
 

var request = YAHOO.util.Connect.asyncRequest('GET', '<? echo $uri ?>', callback);
 

 
$transaction_signature = md5($username . $updateRecordToken);
 
 

// postData represents the data sent in the POST request,
// and the signature is sent as part of the POST message.
var request = YAHOO.util.Connect.asyncRequest('POST', '/update_record.php', callback, postData +
'&signature=<? echo $transaction_signature ?>');
 

//Initiate an asynchronous transaction.
var cObj = YAHOO.util.Connect.asyncRequest('GET','http://www.yahoo.com',callback);
 
//isCallInProgress will return true if the transaction has not been completed.
var callStatus = YAHOO.util.Connect.isCallInProgress(cObj);
 

//Initiate an asynchronous transaction.
var cObj = YAHOO.util.Connect.asyncRequest('GET', sUrl, callback);
 
//Abort the transaction if it isn't completed in ten seconds.
setTimeout(function() { YAHOO.util.Connect.abort(cObj) },10000);
 

/*
 * Abort the transaction if it isn't completed in ten seconds,
 * and pass the callback with a defined failure handler as the
 * second argument.  The failure callback will receive a response
 * object with properties as described in the abort subsection of
 * Failure Case.
 *
 * abort() will return true if the transaction was successfully
 * aborted.  Otherwise, it will return false.
 *
 */
setTimeout(function() { YAHOO.util.Connect.abort(cObj, callback) },10000);