My answer was, of course, “Let me have a look and get back to you.”

I went to my favourite dev tool, Xojo, and went through the process of developing a solution. The connection is a REST API, so I’ll start with a web project and use the HandleURL event. And I’ll use a URLConnection to pass on the request.  Wait … could it be that simple?

Function HandleURL(request As WebRequest, response As WebResponse) Handles HandleURL as Boolean

  // Create the outbound connection
  Var connector As New URLConnection
 
  // Copy the content of the request
  connector.SetRequestContent(request.Body, request.MIMEType)

  // Send the request
  Var result As String
  Try
    result = connector.SendSync("POST", kAddress + request.Path)
  Catch err As RuntimeException
    // Catch DNS, Certificate & Timeout errors
    response.Status = 500
    response.Write(err.Message)
    Return True
  End

  // Return the result of the request
  response.Status = connector.HTTPStatusCode
  response.Write(result)

  Return True

End Function

The answer is, “Yes!”  This is all the code in the entire project.

You will notice that there is no security, but in this instance that is fine as the virtual machine is running this is on the same network as the client server and the firewall is configured to only allow connections from that server.

After processing over 60 thousand requests, memory use is 7.3MB and never exceeded 13MB. CPU usage was at the maximum 1.5%.

Even after using Xojo for 20 years this still blows my mind.

Wayne Golding has been a Xojo developer since 2005 and is a Xojo MVP. He operates the IT Company Axis Direct Ltd which primarily develops applications using Xojo that integrate with Xero www.xero.com. Wayne’s hobby is robotics where he uses Xojo to build applications for his Raspberry Pi, often implementing IoT for remote control.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Downloading the Xojo Project

The Xojo project that I demonstrated can be downloaded here. In the zip file, you’ll find the Xojo project file and a “Readme” file. The Readme file includes step-by-step instructions on setting up SuiteTalk REST, a custom NetSuite role, an integration record, and more.

The SuiteQL Query

During the webinar, I spent some time discussing the SuiteQL query that’s used to lookup items based on the keywords that a user enters. I mentioned that there’s a lot of variation between NetSuite instances, both in terms of how they’re configured and customized. That makes NetSuite development both challenging and interesting.

As a result of the variation between NetSuite instances, you may need to modify the SuiteQL query based on how your NetSuite instance is configured. In the Xojo project, you’ll find that the query is stored as a constant named “SuiteQLQuery,” and it’s an attribute of the ListView screen.

The query uses the REGEXP_LIKE condition, which I discussed recently in this blog post. If you’re not already familiar with REGEXP_LIKE, then you might want to read up on it. Also, in the query I’m using the TO_CHAR function to format the “first column Base Price” as currency. Specifically, in the query, you’ll see this: TO_CHAR ( COALESCE( MAX( Price ), 0 ), ‘fmL99G999D00’ ). If you’d like to learn more about the TO_CHAR function and the format model modifiers that it supports, visit: https://docs.oracle.com/cd/B19306_01/server.102/b14200/sql_elements004.htm#SQLRF00216

Our Next Webinar

Our next Xojo / NetSuite webinar will be held on Thursday, February 22nd at 1PM CT (US). I’ll demonstrate how you can use Xojo to develop a Web app that integrates with NetSuite. To signup, please visit Xojo’s Webinar page. And finally, I want to thank everyone that attended the webinar, as well as Geoff and the entire Xojo team for the opportunity to present.

Tim Dietrich develops custom software for businesses that are running on NetSuite. He makes extensive use of Xojo to develop mobile, desktop, Web apps, and more – all of which integrate seamlessly with NetSuite. To learn more, visit: https://timdietrich.me

This blog post is intended as a follow-up to that webinar. In it, I hope to provide some additional information that we didn’t have time to cover, answer some of the questions that came up during and after the webinar, and also provide a link to the Xojo project that we created during the webinar.

Downloading the Xojo Project

The Xojo project that we developed during the webinar is available for download here. In the zip file, you’ll find the project and a “Readme” file that includes instructions on how to set things up (including SuiteTalk REST, a custom NetSuite role, an integration record, etc).

My advice is to download the project, setup NetSuite, and run the project. Then look at how the project was built -the screens, methods, and so on. After you’re familiar with the project file, experiment with it. Perhaps try modifying the project so that instead of providing access to Items it provides access to Employees instead.

If you run into any problems, or have questions, please feel free to email me (timdietrich@me.com). Another great resource for your general Xojo questions is the Xojo Programming Forum.

Have fun!

Questions & Answers

Do you prefer to use RESTlets instead of SuiteTalk REST? If so, why?

Yes, I much prefer using RESTlets in all of my NetSuite integration projects. With RESTlets I have more control over the functionality that the API provides, and more control over how the responses are formatted. Also, my experience has been that RESTlets are slightly faster than SuiteTalk REST.

That being said, SuiteTalk REST does have some advantages over RESTlets. For example, SuiteTalk REST provides endpoints that you can use to get metadata, which is something that is often difficult to do with a RESTlet. But perhaps the biggest advantage of SuiteTalk REST is that, unlike RESTlets, there is nothing extra that needs to be installed in your NetSuite account. It’s simply a matter of enabling it.

You mentioned some NetSuite customer statistics in your presentation. Can you repeat those?

Sure. During his SuiteWorld keynote presentation this year, Gary Wiessinger (SVP of NetSuite Application Development) mentioned NetSuite’s growth in terms of the number of customers that are using NetSuite. So as of October 2023, 37,000 customers are using NetSuite, and that represents 324,000 organizations. And those customers are located in 219 countries and territories.

As a Xojo developer, how can I get started with NetSuite?

You should first try to get access to a NetSuite account that you can experiment with. Unfortunately, that’s not as easy as it is with other platforms (such as Salesforce or ServiceNow), where they provide developers with test accounts. My advice would be to reach out to a local NetSuite partner, and see if you can build a relationship with them, and try to get their help in getting started.

After the demo, you mentioned another Xojo project that extends the Android functionality. What was that?

It’s called Android Design Extensions, and there’s a great blog post about it here. Read multiple posts about Android Design Extensions on the Xojo Blog.

Wrapping Up

Thanks again for your interest in Xojo and in using it to develop apps that integrate with NetSuite. I hope you’ve found the webinar and the Xojo project to be helpful.

Happy holidays!

Tim Dietrich develops custom software for businesses that are running on NetSuite. He makes extensive use of Xojo to develop mobile, desktop, Web apps, and more – all of which integrate seamlessly with NetSuite. To learn more, visit: https://timdietrich.me

RESTy uses the URLConnection class to send a request to a web service and get a result. If the result is text (JSON, for example) it displays in the Response tab. Here, I am calling the Eddie’s Electronics web service to return a list of all the customers by specifying the URL and clicking the Fetch button:

For other data (binary data such as pictures) you can use the Fetch to File button to save the request to a file.

The Authentication tab is used to provide Basic Authentication should the web service require it.

The Request Content tab can be used to provide Content data that the request might need. For example, the Eddie’s Electronics web service also lets you request the details for a specific customer by providing simple JSON containing the customer ID. To try this using RESTy app:

1. Click on the Request Content Tab.
2. To indicate the customer you wish to retrieve, enter the following JSON into the field on that tab: {"ID": 10039}
3. Select POST from the Send Method popup menu.
4. In the URL field, enter: https://eews-demos.xojo.com/GetCustomer
5. Press the Fetch button.

If you have entered everything correctly, will see the data for Caleb Horn in JSON format:

And to see the JSON formatted nicely, click the Format JSON button:

This will let you you explore calling various REST API services. You can explore the source code to see how it uses URLConnection to do so.

To be sure, RESTy is very basic, but you have the source code so you and add features to it and modify it for your own testing needs.

In this two part tutorial you will see how easy it is to create a basic web service using Xojo Web. In the second part, we will create a Desktop client to talk with the web service (you may want to add iOS to the list).

Before we start, let me point out that this tutorial leaves out some details related to error checking, validation, data sanitizing and other specifics related to inputs and outputs in order to focus on the central topic. In addition, if you want to follow and reproduce the steps of this tutorial, then you need to download the Chinook Database, named “test.sqlite” in this tutorial.

Services in practice

Let’s start creating a web service! Open the Xojo IDE, create a new Web project, and name it WebService. The first thing you’ll notice is that Xojo adds a web page to the project by default – even when our web service does not display a UI. The good part is that you can mix both worlds, adding the webservice part to your regular Web app!.

In fact this tutorial will put all the logic in the App object. Start by adding a new property in charge of the reference to our SQLite database (of course, it will work also with PostgreSQL or MySQL engines). Select the App object from the Navigator (the left panel in the Xojo IDE), choosing the Insert > Property option from the contextual menu. With the new property selected, go to the Inspector to set the name, type and scope using these values:

• Name: Database
• Type: SQLiteDatabase
• Scope: Private

Next, we will add the Chinook Database to the Resources folder of our Web App. For that, select the deployment target under Build Settings (it can be macOS, Windows, Linux or Xojo Cloud, for example), and add a Copy Files build step to it. In the resulting Editor, add the Chinook database SQLite file and make sure you select the “Resources Folder” entry in the Destination popup menu, and the “Both” entry in the Applies To popup menu.

Now is time to create a new SQLiteDatabase instance and assign it to this property, so it will point to the SQLite database file when the app is running. For that, make sure the App object is selected and add the Opening Event Handler to it using the Insert > Event option. Write the following code in the resulting Code Editor:

#Pragma Unused args

Var f As FolderItem = SpecialFolder.Resource("Chinook_Sqlite.sqlite")

If f.Exists Then
  
  Try
    database = New SQLiteDatabase
    database.DatabaseFile = f
    
    Call database.Connect
  Catch e As DatabaseException
    MessageBox "Error connecting to the database"
  End Try
  
End If

As you can see, it is pretty much the same code we already use when creating SQLiteDatabase instances in our Desktop apps, linking to our SQLite database file and stablishing the connection so we can operate with the database engine from our app.

All the Magic of HandleURL

Xojo Web projects offer a simple way to handle the request received. It is using the HandleURL event. This is the one that fires every time a client app (it may be a Web Browser, desktop or mobile app) connects to the URL associated with the IP address and port combination that is listening for incoming requests.

For example, a valid URL that can be trapped and processed by HandleURL is:

http://www.nice-web-domain.com/getCustomers

Where getCustomers is in this case one of our API methods.

So, with the App object selectd, choose Insert > Event in order to add the HandleURL event.

As we will see, once the event has been added to a web app, it will receive the Request parameter (a WebRequest data type), waiting from us to send back a Boolean value as response: True to process the request or False (the default value) to ignore the response.

Introducing Request, where the information lives!

In fact, we will find in the Request object everything we need to process and (if it is the case) respond to the request from our Web service. For example, through we can get the interesting component from the Path property. If we consider this URL:

http://www.nice-web-domain.com/getCustomers?spain

The Request.Path property will return the getCustomers string; so our web service can process it acordingly from this point on.

Receiving and Sending JSON data

In order to keep this tutorial brief, our web API only has two methods in it: GetAll and AddAlbum. Using the first one, the client app will get the album name in the database wrapped in JSON format. With the second method, our client app will ask the web service to add a new record (a new album) to the right table on our example database.

How can we process the request associated data inside the HandleURL event? Here is where we will find very useful another of the Request object properties. The Body property includes the sent data as part of the request that are not already present in the headers. Generally speaking, it includes additional data via the PUT and POST verbs.

Now we can put the following code into our HandleURL Event Handler:

Select Case Request.Path // What is the method received as part of the request? (URL)
Case "GetAll"
  Var output As JSONItem = GetAllAlbums // Assign the processed data to the output variable, if the received method is 'GetAllAlbums'
  
  Response.Header("charset") = "utf-8"
  Response.MIMEType = "application/json"
  Response.Status = 200
  response.write( output.ToString ) // And send it back to the client that made the request, converting the JSON to a String in first place
  
Case "AddAlbum"
  Var data As String = Request.Body.DefineEncoding(encodings.UTF8) // We have to apply the right encoding to the received data
  Var Input As JSONItem = New JSONItem( data ) // Creating a new JSON object from it
  addNewAlbum( Input.Value("newAlbum") ) // In this case, the request is to add a new Album to the database; passing thus the received data as part of the input
End Select

Return True

The main point here is that we assign the received data to the data variable (if any), and define a known encoding to them so we won’t get into trouble while processing them afterwards. Of course, our example always expects to receive the additional data in JSON format, so this is why we create a new JSON instance from this data.

We use the Select…Case command to decide what method has to execute the web service, and that is based on the component stored in the Path property as you recall. So, if the request uses the GetAll method in the URL, we will call the real method GetAllAlbums in our Xojo code. After processing the information it will return a new JSONItem as the response we will send to the client.

How can we send the response to the request? Really simple: calling the Write method on the Response object, passing as parameter the text we want to send back. In our example, this is the JSONItem referenced by the Output variable. We also use the Response object to set the character encoding to UTF-8 and the MIME type to “Application/json”, in addition of setting the status value to 200 (that is, the request has been successfully handled).

If we receive a request with the AddAlbum method of our API, then we call the real addNewAlbum method in our Xojo code, passing as parameter the JSONItem object in charge of store the received data from the request (this is the one referenced by the input variable). In fact, the record structure is stored inside the newAlbum root node of the JSONItem.

When it comes to the Database

While HandleURL is in charge of processing the received request, we will use a couple of methods in our example app that will act as a link between the API and the database in the backend, both for retrieving and storing the requested information. (In a real world app it is very advisable to introduce checks and data sanitization before dealing with the database!)

Choose the App object again and use the Insert > Method option in order to add the GetAllAlbums method, using the following method signature for that:

• • Method Name: getAllAlbums
  • Return Type: JSONItem
  • Scope: Private

This is the code in charge of generating the JSONitem that we will write as part of the request response, including the node for every expected database record from the Album table in our example database:

Var rc As RowSet = database.SelectSQL("Select * from album order by title asc") // Get the Recordset as result of the SQL selection: all the records
Var item As New JSONItem

If rc.RowCount > 0 Then // We have records on the RecordSet
  
  While Not rc.AfterLastRow // so lets iterate them!
    Var d As New Dictionary // creating a new dictionary for each record, and that we will convert in a node
    d.Value("artistid") = rc.Column("artistid").StringValue // assingning the record ID to the name 'ArtistId' of the JSONItem
    d.Value("title") = rc.Column("title").StringValue // and the Title value to the 'Title' field of the JSONItem
    item.Value(rc.Column("albumid").StringValue) = d // You know you can assign a Dictionary as the value for a JSONItem node. Very useful!
    
    rc.MoveToNextRow
  Wend
  
  rc.Close
  
End If

var output As New JSONItem

output.Value("AllAlbums") = item // Then let's hang all these records form a main Node

Return output // And return it to the caller

Next, create a new method named addNewAlbum. This is the one our web service will use to add a new record to the database, using for that the received data as part of the request. Use the following signature for the method definition:

• • • Method Name: addNewAlbum
    • Paramters: item as JSONItem
    • Scope: Private

And put the following code in the associated Code Editor:

Var title As String = item.Value("Title") // get the data associated to the "Title" field
Var artistid As String = item.Value("ArtistId") // and the 'ArtistID'

database.ExecuteSQL("insert into album(title,artistid) values(?, ?)", title, artistid ) // and insert that data as a new record into the database table

As you can see, the code is very simple: it gets the values for the received keys in the JSONitem nodes and uses them as part of the SQL sentence in order to add a new record to the database.

A Web service… ready to serve!

As you have seen, the code and app structure are really minimal! Of course, this is just a simple example but it gives you a good idea of the kind of possibilities web services offer and how fast you can put it together using Xojo and OOP concepts you already know! Of course, you can run your web app (and services) right from the IDE (just make sure to select 8081 as the Debug Port)… what is probably the recommended way to follow this simple example. For other more complex web apps, remember that you can use the one click solution Xojo Cloud and of course any compatible Linux, Windows or Mac server.

Javier Rodri­guez has been the Xojo Spanish Evangelist since 2008, he’s also a Developer, Consultant and Trainer who has be using Xojo since 1998. He manages AprendeXojo.com and is the developer behind the GuancheMOS plug-in for Xojo Developers, Markdown Parser for Xojo, HTMLColorizer for Xojo and the Snippery app, among others

*Read this post in Spanish

I’m going to show you how to connect to IBM’s Watson services with REST APIs and how to use them with Xojo projects to identify images. This is just one example, of course, of the many ways to utilize Watson and AI in your Xojo apps.

IBM Watson

IBM’s Watson services have been online for several years and are continuously updated. They are paid services but you can create a Lite user to test and evaluate them. The documentation and variety of services are huge and includes (among other things) image identification services.

Identify images with Watson

This service mainly offers two possibilities: identifying the faces in an image (returning the position, the probable gender of the subject and the probable age range) and the classification (i.e. the recognition of possible tags that can be associated with the image).

Watson’s Natural Language Classifier, is a service that “applies cognitive computing techniques to return best matching predefined classes for short text inputs, such as a sentence or phrase”. It is really large (and the definitions are localized in many languages); moreover you can create your own classifiers specific to projects. The Lite user can create only one classifier at a time that is replaceable but not updatable. Another limit is the number and total size of the images that you can use to address your classifier.

Watson’s documentation is complete and easy to use. After creating the service in your account, you can start using them with the terminal or through the web page relative to the selected service.

How to use Watson with Xojo

The services use a REST API so you’ll use Xojo.Net.HTTPSocket as the base class to create the object that will consume these services. To learn more about using Xojo with a REST API, you should read up on that before continuing: Cats Up: Using the HTTPSocket with the Cat REST API, PDF File Generation? There is an API for that and Web Services Video Playlist.

In this example, the base class is called “WatsonAPI”. This class will deal with the communication with the API (sending and initial interpretation of the answer) and will have some common features (such as zipping several images so they can be sent all at once). Moreover, since the interaction with the service is asynchronous, the class will have to manage the serialization of the different requests and take care to return the result to the correct call.

Next, you’ll define a delegate who will have as an argument the answer (positive, negative or error) that will have as its signature a Xojo.Core.Dictionary:

WatsonReplyFunction(reply as Xojo.Core.Dictionary)

Now you’ll define two private properties: id and callback. You’ll use id to distinguish the various call, and callback will be the function to call when there’s a the result.

Private Property id as Text
Private Property callback as WatsonReplyFunction

The constructor (protected because the subclasses will call it) can be of this kind:

Protected Sub Constructor( cb as WatsonAPI.WatsonReplyFunction)
  // Register the callback
  callback=cb
  Super.Constructor
  register Me
End Sub

Register is a private shared function that assigns the identifier to the object and saves the pair id, object in a shared dictionary. There’s also a deRegister function that will delete the object whose identifier is passed.

As noted before, you’ll use a dictionary to represent the API result because it’s the format used for positive or negative API replies. Moreover, we can use the same format for network error replies. The dictionary will contain at least 3 values: success as boolean for a positive or negative reply, status as integer for the reply http status and result as text or dictionary to represent the current reply. Since it’s a dictionary, we can easly add more information as needed. Subclasses or consumer classes can transform this data structure in a more specific way (class, record or whatever).

Now you will implement the major events:

Sub Error(err as RuntimeException) Handles Error
  //All replies will have the same structure
  //In the event of an error, the returned dictionary must be structured as correct one
  Dim d As New Xojo.Core.Dictionary
  d.Value("success")=False
  d.Value("status")=0
  d.Value("result")=err.Reason
  //Delete the object from the dictionary
  deRegister(Me)
  //return the reply
  callback.Invoke(d)
End Sub


Sub PageReceived(URL as Text, HTTPStatus as Integer, Content as Xojo.Core.MemoryBlock>) Handles PageReceived
  #Pragma Unused url

  //evaluate the reply
  Dim d As Xojo.Core.Dictionary
  Dim t As Text
  Try
    t=Xojo.Core.TextEncoding.UTF8.ConvertDataToText(Content)
  Catch
    t=""
  End Try
  If Not t.Empty Then
    Try
      d=Xojo.Data.ParseJSON(t)
    Catch
      d=Nil
    End Try
  End If
  Dim reply As New Xojo.Core.Dictionary
  reply.Value("success")=HTTPStatus=200 And d<>Nil
  reply.Value("status")=HTTPStatus
  If d=Nil Then
    reply.Value("result")=t
  Else
    reply.Value("result")=d
  End If
  //Delete the object from the dictionary
  deRegister(Me)
  //return the reply
  callback.Invoke(reply)
End Sub

Now you can create a subclass to classify the images: WatsonVisualRecognition as subclass of WastonAPI.

For the image classification you can use one or more of the classifiers and/or the default one or even those in beta (currently Food and Explicit). So let’s define the constants related to these classifiers:

Public Const IBMDefault as Text =default
Public Const IBMExplicit as Text = explicit
Public Const IBMFood As Text = food

… and the ones related to the services:

//The current version of the service
Private Const version As Text = 2016-05-20

//The address actually depends on the user settings
Private Const kBaseUrl As Text = https://gateway.watsonplatform.net/visual-recognition/api/v3/

//The key to use the service
Private Const keyVision As Text = •••••••

You can now define a public shared method for analyzing an image on the web:

Public Shared Sub classifyImage(cb As WastonAPI.WatsonReplyFunction, imageUrl As Text, threshold As Single=0.5, paramArray classifiers As Text)
  //The method requires a method to be called to return the results,
  // the address of the image to be analyzed
  // the minimum value to be considered for recognition
  // a list of classifiers to use

  //Let's create the instance linking it to the callback
  Dim w As New WatsonVisualRecognition(cb)

  //threshold is the minimum acceptable value for classification
  //  must be between 0 and 1
  If threshold<0.0 Then threshold=0.0
  If threshold>1.0 Then threshold=1.0

  //For classifiers I can use both the ones provided and mine
  //none means the default one
  Dim useIBM As Boolean
  Dim usePersonal As Boolean
  Dim usedClassifiers() As Text
  For i As Integer=0 To classifiers.Ubound
    Select Case classifiers(i)
    Case IBMDefault
      useIBM=True
    Case IBMExplicit, IBMFood
      useIBM=True
      //These classifiers are in English only 
      w.RequestHeader("Accept-Language")="en"
    Else
      usePersonal=True
    End Select
    If usedClassifiers.IndexOf(classifiers(i))=-11 Then usedClassifiers.Append  classifiers(i)
  Next
  Dim classifierIds As Text=Text.Join(usedClassifiers, ",")

  //Set the kind of the classifiers used
  Dim usedOwners() As Text
  If useIBM Then usedOwners.Append "IBM"
  If usePersonal Then usedOwners.Append "me"
  Dim owners As Text=Text.Join(usedOwners, ",")

  //Create the URL to be called
  Dim url As Text=kBaseUrl+"classify"

  //I create the list of arguments
  Dim args() As Text
  args.Append "api_key="+keyVision
  args.Append "version="+version
  args.Append "url="+imageUrl
  If Not owners.Empty Then args.Append "owners="+owners
  If Not classifierIds.Empty Then args.Append "classifier_ids="+classifierIds
  If threshold>0 Then args.Append "threshold="+threshold.ToText
  Dim parameters As Text=Text.>Join(args, "&")

  w.Send "GET", url+If(parameters.Empty, "", "?"+parameters)
End Sub

Finally, you can request the classification of an image. For example, put a button in a Window and in the Action event put the following code:

WatsonVisualRecognition.classifyImage(WeakAddressOf analyzeResponse, "https://watson-developer-cloud.github.io/doc-tutorial-downloads/visual-recognition/fruitbowl.jpg", .3)

Where analyzeResponse is the method that will read the results translating the Dictionary into something useful like actions for a database, a textual list or a simple text message.

Starting from this simple method, it is possible to create all the others, adding a bit of utility functions to the WatsonAPI base class.

As an example, it is possible to obtain the basic information about the people in this image and display it as an overlay:

Or update a database of images with classifications to then find the images of a specific type:

Create your own classifiers

Starting from this object it is easy to create an application to generate, update, and verify a classifier that is specific to this solution. While you can do it with the provided web interface, you can create a Xojo app that can return the feedback in a much easier and manageable way; and you can add some methods to automate the process of automatically discarding bad images and adding new ones in order to refine your classifier better.

Conclusions

Watson’s API services allow you to add a bit of artificial intelligence to your Xojo projects. The simplicity of the classes required to do this are clear proof of Xojo’s versatility.

It’s important to keep in mind that this service is not instantaneous. This is due in large part to network traffic; generally for sending the data and receiving the answer.

A really interesting option if you develop for MacOS would be to download your classifier in CoreML format and use it offline with MBS Core ML plugin.

Antonio Rinaldi is a professional engineer, Xojo developer for almost twenty years, Xojo evangelist for Italy since 2014, consultant and teacher. He develops extensions for Xojo iOS that you can find in the Xojo Store, and manages XojoItaliaBlog.com. Musician, composer, lover of good food, traveler and constantly curious, he is always looking for new ideas to expand his knowledge.

Recently they just announced a web services API for accessing their articles and other information. And as I’ve talked about in other posts and webinars, it’s often quite easy to use web services with Xojo apps.

I’ll show you how you can quickly create an iOS app that shows the most recent TDWTF posts and then displays them when you tap on their title.

To start, create a Xojo iOS project.

On the default View (View1), use the Inspector to set a couple properties:

• BackButtonTitle: Articles
• Title: The Daily WTF

Now drag a Table from the Library onto the View and stretch it to fit the entire layout area. Name the table ArticleTable. This Table will be used to display the list of recent articles.

To get the articles, you just have to make the appropriate API call. Looking at the API docs, there is an API command called /articles/recent which returns a JSON document of the recent articles and related information. This is the actual API call. To see its JSON results, use a tool like Paw (now with Xojo extensions) or RESTy with this URL (a browser will also show the unformatted JSON):

http://thedailywtf.com/api/articles/recent

If you look at the JSON results, you’ll see that it returns an array of articles with a “Title” entry containing the title of the article and a “Url” entry containing the URL of the article.

To call this in the Xojo app, I’ll use an HTTPSocket. In the Library, drag the item called “Generic Object” onto the Layout. It will appear in the Shelf at the bottom. In its Inspector, change the name to WTFSocket and set its super to “Xojo.Net.HTTPSocket”.

Now add an event handler to the socket, right->click on the socket, select “Add To” and then “Event Handler”. Add the PageReceived event handler. In it, put this code to request the articles:

// Convert the binary Content data to JSON text and then
// parse it to an array.
Dim jsonText As Text = TextEncoding.UTF8.ConvertDataToText(Content)
Dim jsonArray() As Auto = Data.ParseJSON(jsonText)

// Loop through the array and add each article to
// the table.
ArticleTable.AddSection("")
For i As Integer = 0 To jsonArray.Ubound
  Dim article As Dictionary = jsonArray(i)

  Dim cell As iOSTableCellData = ArticleTable.CreateCell
  cell.Text = article.Value("Title")
  cell.Tag = article.Value("Url")

  Dim author As Dictionary = article.Value("Author")
  cell.DetailText = article.Value("DisplayDate") + " by " + author.Value("Name")
  ArticleTable.AddRow(0, cell)
Next

The URL is being put into the Tag for the cell so that it can be used later to display the article when its row is tapped.

You’ll also see I’m also accessing the “DisplayDate” value and grabbing the “Name” from the “Author” object in the JSON.

Now you’ll want to call the web service. Add the Open event handler to the View with this code:

// Call the /articles/recent web service
WTFSocket.Send("GET", "http://thedailywtf.com/api/articles/recent")

Run the project and you’ll see the list of recent article appear:

The final step is to display the article when it is tapped in the list. You’ll want another View to display the article (Insert->View). Name the view ArticleView. On this View, set the NavigationBarVisible property to ON and drag an HTML Viewer onto it. Make the HTML Viewer fill the entire View layout and name it ArticleViewer.

Add a method to ArticleView called ShowArticle(url As Text) with this code:

ArticleViewer.LoadURL(url)

This method loads the URL into the HTML Viewer and is called when its row is tapped in the list of articles.

Speaking of which, back on View1 add the Action event handler to the table with this code:

// Get the URL from the tag for the tapped row
Dim url As Text = Me.RowData(section, row).Tag

// Display the article on the new view and show it
Dim v As New ArticleView
v.ShowArticle(url)
PushTo(v)

Now run the project. You’ll see the list of article as before. Tap on an article to show the new view with the article.

Take a look at the full API to see what other cool features you can add to the app. Here are some suggestions:

• Display a random article
• Display more than the last 8 recent articles
• Cache the article contents on the device and use the cache when the article is displayed again
• Display articles by month/year

When we created the iOS app for XDC 2015 last spring, I decided to take a different route and try out a few of the commercial REST API clients to see if any of them would make my life easier. The one I settled on was Paw from LuckyMarmot, primarily for its support of extensions written in JavaScript.

There is a small library of extensions available on the Paw website, most of which are for code examples and that got me thinking… why not have examples of the request in Xojo code, both old and new framework so that I don’t need to do that by hand every time.

Examples

For the sake of this example, let’s say that we’re making a request to login to a fictitious API. The URL of this request is https://www.example.com/api/login, it expects that you will pass the username (name) and password (1234) as URL parameters and that a preshared key is to be included in the body of the request as JSON.

Paw comes with an extension for creating cURL requests and the output of that extension looks like this:

curl -X "GET" "https://www.example.com/api/login?username=name&password=1234" 
 -H "Content-Type: application/json" 
 -d "{"preshared-key":"QU^k9h36zdF8nx7Y"}"

Using our Paw extensions, the Old Framework Xojo extension generates code that looks like this:

// Login (Old Framework)

// Set up the socket
dim h as new HTTPSecureSocket
h.Secure = True
h.ConnectionType = h.TLSv12
h.setRequestHeader("Content-Type","application/json")

// JSON
Dim js As New JSONItem
js.Value("preshared-key") = "QU^k9h36zdF8nx7Y"

// Convert Dictionary to JSON Text
Dim data As String = js.toString()

// Assign to the Request's Content
h.SetRequestContent(data,"application/json")

// Set the URL
dim url as string = "https://www.example.com/api/login?username=name&password=1234"

// Send Synchronous Request
dim s as string = h.SendRequest("GET",url,30)

If you’re using the new framework extension, it generates code that looks like this:

// Login (New Framework)

// Set up the socket
// "mySocket" should be a property stored elsewhere so it will not go out of scope
mySocket = new Xojo.Net.HTTPSocket
mySocket.RequestHeader("Content-Type") = "application/json"

// JSON
Dim d As New Dictionary
d.Value("preshared-key") = "QU^k9h36zdF8nx7Y"

// Convert Dictionary to JSON Text
Dim json As Text = Xojo.Data.GenerateJSON(d)

// Convert Text to Memoryblock
Dim data As Xojo.Core.MemoryBlock = Xojo.Core.TextEncoding.UTF8.ConvertTextToData(json)

// Assign to the Request's Content
mySocket.SetRequestContent(data,"application/json")

// Set the URL
dim url as Text = "https://www.example.com/api/login?username=name&password=1234"

// Send Asynchronous Request
mySocket.Send("GET",url)

These extensions are available for download using the link below. Once downloaded, extract the folders into the Paw Extensions folder which you can reach by going to the Paw menu and selecting Extensions->Open Extensions Directory. Once they’re in there, you can make them available by selecting Extensions->Reload All Extensions.

Versions for the Classic Framework and Xojo Framework are available on GitHub:

• Paw Extension for HTTPSocket
• Paw Extension for Xojo.Net.HTTPSocket
• Paw Extension for URLConnection

CONCLUSION:

Paw is an excellent tool for storing and managing API configurations and examples, plus adding the ability to copy and paste Xojo HTTP socket code makes it an even better part of your library if you work with a lot of HTTP RESTful APIs.

Communicating with web services is fun and easy with Xojo. But sometimes it’s not so easy to test the actual REST API calls. As part of preparing materials for the HTTPSocket webinar, I created a simple app in Xojo that lets you test REST APIs. I call it RESTy.

RESTy uses Xojo.Net.HTTPSocket to send a request to a web service and get a result. If the result is text (JSON, for example) it displays in the Response tab. Here, I am calling the Eddie’s Electronics web service to return a list of all the customers by specifying the URL and clicking the Fetch button:

For other data (binary data such as pictures) you can use the Fetch to File button to save the request to a file.

The Authentication tab is used to provide Basic Authentication should the web service require it.

The Request Content tab can be used to provide Content data that the request might need. For example, the Eddie’s Electronics web service also lets you request the details for a specific customer by providing simple JSON containing the customer ID. For example:

{"ID": 10039}

You can put this JSON in the Request Content tab and then call the web service to get the customer information using this URL (be sure to select POST as the method type):

http://demos.xojo.com/EEWS/index.cgi/special/GetCustomer

To be sure, RESTy is very simple, but you have the source code so feel free to add features to it!

• Download RESTy Project

If you’re looking for something with more features, there are also commercial products to test REST web services. Here are a few:

• Paw
• Do Http
• REST Scratchpad

If you know of others, let me know in the comments.

Want to learn more about Xojo.Net.HTTPSocket and web services?