How we get and post api in Titanium alloy?

How can we get and post api in Titanium alloy?

I am having the api of userDetails, I just want that how can i code to get the data from api.

function getUserDetails(){

}

Thanks in advance.

回答1:

this is the solution for your problem:-

    var request = Titanium.Network.createHTTPClient();
    var done=false;
    request.onload = function() {
    try {
    if (this.readyState == 4 &amp;&amp; !done) {
       done=true;
    if(this.status===200){
        var content = JSON.parse(this.responseText);
      }else{
        alert('error code' + this.status);
      }
     }
     } catch (err) {
    Titanium.API.error(err);
    Titanium.UI.createAlertDialog({
        message : err,
        title : &quot;Remote Server Error&quot;
    });
}

};

request.onerror = function(e) {

Ti.API.info(e.error);

};

request.open("POST", "http://test.com");

request.setRequestHeader("Content-Type","application/x-www-form-urlencoded");

request.send({ test: 'test'});

if you don't get your answer please let me know.

Thanks

回答2:

As you mentioned, you are using Titanium alloy.

So another approach be to extend the Alloy's Model and Collection ( which are based on backbone.js concept ).

There are already some implementation at RestAPI Sync Adapter also proper description/usage at Titanium RestApi sync.

I also provide the description and methodology used, in-case link gets broken:

Create a Model : Alloy Models are extensions of Backbone.js Models, so when you're defining specific information about your data, you do it by implementing certain methods common to all Backbone Models, therefor overriding the parent methods. Here we will override the url() method of backbone to allow our custom url endpoint.

Path :/app/models/node.js

exports.definition = {
  config: {
    adapter: {
      type: "rest",
      collection_name: "node"
    }
  },
  extendCollection: function(Collection) {
    _.extend(Collection.prototype, {
      url: function() {
        return "http://www.example.com/ws/node";
      },
    });
    return Collection;
  }
};

Configure a REST sync adapter : The main purpose of a sync adapter is to override Backbone's default sync method with something that fetches your data. In our example, we'll run through a few integrity checks before calling a function to fetch our data using a Ti.Network.createHTTPClient() call. This will create an object that we can attach headers and handlers to and eventually open and send an xml http request to our server so we can then fetch the data and apply it to our collection.

Path :/app/assets/alloy/sync/rest.js (you may have to create alloy/sync folders first)

// Override the Backbone.sync method with our own sync 
functionmodule.exports.sync = function (method, model, opts)
{
  var methodMap = {
  'create': 'POST',
  'read': 'GET',
  'update': 'PUT',
  'delete': 'DELETE'
  };
  var type = methodMap[method];
  var params = _.extend(
  {}, opts);
  params.type = type;
  //set default headers    
  params.headers = params.headers || {};
  // We need to ensure that we have a base url.    
  if (!params.url)
  {
    params.url = model.url();
    if (!params.url)
    {
      Ti.API.error("[REST API] ERROR: NO BASE URL");
      return;
    }
  }
  //json data transfers    
  params.headers['Content-Type'] = 'application/json';
  switch (method)
  {
    case 'delete':
    case 'create':
    case 'update':
      throw "Not Implemented";
    break;
    case 'read':
      fetchData(params, function (_response)
      {
        if (_response.success)
        {
          var data = JSON.parse(_response.responseText);
          params.success(data, _response.responseText);
        }
        else
        {
          params.error(JSON.parse(_response.responseText), _response.responseText);
          Ti.API.error('[REST API] ERROR: ' + _response.responseText);
        }
      });
    break;
  }
};

function fetchData(_options, _callback)
{
  var xhr = Ti.Network.createHTTPClient(
  {
    timeout: 5000
  });
  //Prepare the request    
  xhr.open(_options.type, _options.url);
  xhr.onload = function (e)
  {
    _callback(
    {
      success: true,
      responseText: this.responseText || null,
      responseData: this.responseData || null
    });
  };
  //Handle error    
  xhr.onerror = function (e)
  {
    _callback(
    {
      'success': false,
      'responseText': e.error
    });
    Ti.API.error('[REST API] fetchData ERROR: ' + xhr.responseText);
  };
  for (var header in _options.headers)
  {
    xhr.setRequestHeader(header, _options.headers[header]);
  }
  if (_options.beforeSend)
  {
    _options.beforeSend(xhr);
  }
  xhr.send(_options.data || null);
}

//we need underscore
var _ = require("alloy/underscore")._;

Setup your View for Model-view binding : Titanium has a feature called Model-View binding, which allows you to create repeatable objects in part of a view for each model in a collection. In our example we'll use a TableView element with the dataCollection property set to node, which is the name of our model, and we'll create a TableViewRow element inside. The row based element will magically repeat for every item in the collection.

Path :/app/views/index.xml

<Alloy>
  <Collection src="node">
    <Window class="container">
      <TableView id="nodeTable" dataCollection="node">
        <TableViewRow title="{title}" color="black" />
      </TableView>
    </Window>
</Alloy>

Finally Controller : Binding the Model to the View requires almost no code at the controller level, the only thing we have to do here is load our collection and initiate a fetch command and the data will be ready to be bound to the view.

Path :/app/controllers/index.js

$.index.open();
var node = Alloy.Collections.node;
node.fetch();