Slack has an API called “slash commands” that lets a user type a slash (/) followed by a command name in order to perform a special action. For example, Slack has many built-in slash commands, one example is /help. Here’s how you can easily add your own slash commands using a Xojo web app and the HandleSpecialURL (or HandleURL) method.

Your slash command makes an HTTP request to your Xojo web service app. The web services does its thing and then returns the result back to Slack to display.

A Xojo Web Service

For demonstration, I’m going to show you how to create a Slackbot that returns a “cat fact”. The slash command will be /catfact. When you use the /catfact command, Slack calls a Xojo web service which then makes a call to the Cat Fact API, parses the resulting JSON and returns an interesting cat fact back to Slack to display in your channel.

As I’ve covered in a couple Web Services webinars last year, it is pretty easy to make a web service using Xojo. For this example, create a new web project and name it CatFact.

First you will create a simple method that will fetch a Cat Fact. Create a method on the App object, GetCatFact As String, with this code:

// New request came in, so create a new HTTPSocket
Dim catSocket As New HTTPSocket

// Get a cat fact and wait for it to be returned
Dim factData As String = catSocket.Get("http://catfacts-api.appspot.com/api/facts?number=1", 30)

// Once the cat fact is returned, parse the JSON and send it to the original requester.
Dim jsonText As Text = DefineEncoding(factData, Encodings.UTF8).ToText
Dim jsonDict As Xojo.Core.Dictionary = Xojo.Data.ParseJSON(jsonText)
Dim facts() As Auto = jsonDict.Value("facts")

// Extract the fact text from the JSON
Dim fact As Text
If facts.Ubound >= 0 Then
  fact = facts(0)
End If

Return fact

In this Xojo project you’ll now create a simple web page UI to test that calling the Cat Fact API works. On the default page (WebPage1), add a Button and a TextField. In the Button’s Action event handler, add this code:

CatFactArea.Text = App.GetCatFact

Run the web app and on click the button. You should see a cat fact appear in the Text Area. The fact I got was:

The cat has 500 skeletal muscles (humans have 650).

Now you can add the code to process the web service request. Add the HandleSpecialURL event to the App object and use this code:

If Request.Path = "CatFact" Then
  Request.Print(GetCatFact)
  Return True
End If

You can test this by running the web project and then in a new tab entering the API URL, which displays a cat fact in the browser:

http://127.0.0.1:8080/api/CatFact

Hook Up Web Service to Slack

Now that you know the web service works, the next step is to hook it up to Slack. But before you can do that, you have to host the web app somewhere on the Internet; Slack can’t see your local web app! For this example, I’ve published the Cat Fact web service to Xojo Cloud because it’s fast and easy. This is the URL to the Cat Fact web service on Xojo Cloud:

http://demos.xojo.com/CatFacts/index.cgi/api/CatFact

Now you need to go to your Slack team settings to add a slash command. On that screen you’ll want to set the name of the Command to “/catfact” and the URL to “http://demos.xojo.com/CatFacts/index.cgi/api/CatFact” (the URL from above). Also change the Customize Name field to “CatFact”. You can ignore all the other fields and click the Save Integration button at the bottom.

That’s it. The slash command is now active. Head on over to your Slack team and type /catfact into a channel. You’ll get back a fact from “CatFact”.

And it took less than 20 lines of code! You can now use this technique to integrate your own web services into Slack.

By default, only you will see the cat fact returned by the Slashbot; it is not broadcast to the entire channel. You can change this by returning specifically formatted JSON rather than just a text string (as described on the Slack Commands API page).

If you come up with a great slash command and want to make it available to the world, you can attach it to a Slack app and publish it to the App Directory. The steps for this are also in the Slash Commands API page.

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.

I did a little Google searching and found this one which seems to work well: https://github.com/sqlparser/sql-pretty-printer/wiki/SQL-FaaS-API-manual

To use it with Xojo, create a subclass of Xojo.Net.HttpSocket and drag it onto a window

This code in a button takes unformatted SQL from a TextArea and sends it to the web service, asking that it be formatted for Oracle (rqst_db_vendor=1):

 Dim sql As Text = SQLArea.Text.ToText
 Dim postText As Text = "rqst_input_sql=" + _
  EncodeURLComponent(sql).ToText + _
  "&rqst_db_vendor=1"

 Dim postData As Xojo.Core.MemoryBlock
 postData = Xojo.Core.TextEncoding.UTF8.ConvertTextToData(postText)

 SQLFormatter1.SetRequestContent(postData, _
  "application/x-www-form-urlencoded")
 SQLFormatter1.Send("POST", _
  "http://www.gudusoft.com/format.php")

This code in the PageReceived event handler of your HttpSocket subclass parses the resulting JSON and displays the formatted SQL:

Dim jsonText As Text
jsontText = Xojo.Core.TextEncoding.UTF8.ConvertDataToText(Content)
Dim json As Xojo.Core.Dictionary = Xojo.Data.ParseJSON(jsonText)
FormattedSQLArea.Text = json.Value("rspn_formatted_sql")

Download Sample Project

Looking for something to try next? Watch the video below and learn how to use HTTPSocket in the Xojo Framework.

When preparing materials for the HTTPSocket webinar I came across The Cat API. This wonderful site provides a REST (web services) API that sends you random cat pictures. What a perfect way to demonstrate HTTPSocket!

With just a few lines of code, I’m going to show you how to create an iPhone app that will show you a new cat picture each time you launch it. I call this app “Cats Up”.

Set up the iOS Project

Launch Xojo and create a new iOS project called “CatsUp”. Drag an ImageView control onto the View and make it fill most of the area. Drag a Button to the View and place it at the bottom with the title “Cats Up!”. The result should look like this:

View the Cat API

The Cat API documentation page describes the full API, but this project only needs to use the get method to get you “all the fancy cat images you can handle”. The URL for this method is:

http://thecatapi.com/api/images/get

Add Code

It is time to add a tiny amount of code. First, you need to create an HTTPSocket subclass.

1. Click the Insert button on the toolbar and select Class. Name the class CatCloud.
2. Set the class Super to “Xojo.Net.HTTPSocket”.
3. Add a method to the class called GetCat with this code:

Try
  Self.Send("GET","http://thecatapi.com/api/images/get")
Catch t As UnsupportedOperationException
  Return
End Try

Now select your view (View1) and drag the CatCloud class onto it. This adds it to the Shelf at the bottom on the layout editor. It will automatically be named CatCloud1.

Double-click CatCloud1 to add the PageReceived event handler and add this code:

Dim catPic As iOSImage 
catPic = iOSImage.FromData(content)
ImageView1.Image = catPic

Next double-click the button to add the Action event handler and add this code:

CatCloud1.GetCat

Lastly, add an Open event handler to the View and add this code:

CatCloud1.GetCat

Test

Run your project to launch it in the iOS Simulator. An initial cat picture should appear. Click the “Cats Up!” to show a new picture.

May the cat be with you.

• Download the iOS project

March 2022 UPDATE: Get Cats Up! for Android in the Google Play Store!

Text

The new Text data type is a substitute for String and has the benefit of making encodings easier to work with. Essentially if you use Text, you don’t have to worry about the encoding. When you get data from an outside source (a file, a database or even a String), you specify the encoding so it can be stored as Text. Once it is in Text, you don’t worry about the encoding. When you need to send the Text to a file, DB or elsewhere, you convert it to data using whatever encoding is appropriate- usually UTF8.

You can easily use Text with your existing projects as a Text value converts back to a String automatically. For example, you can set a button Caption using a Text variable:

Dim t As Text = "Hello"
MyButton.Caption = t // converts automatically to String

If you have a String (such as a property of a UI control) you can easily convert it to Text by calling the ToText method. For example, you store the Caption of a button as Text:

Dim t As Text = MyButton.Caption.ToText

Dictionary

I prefer Xojo.Core.Dictionary because it is has an easy-to-use iterator, making it crazy-simply to loop through the items in the Dictionary:

Dim myDictionary As New Xojo.Core.Dictionary
myDictionary.Value("Name") = "Bob Roberts"
myDictionary.Value("City") = "Boston"
For Each entry As Xojo.Core.DictionaryEntry In myDictionary
  Dim key As Text = entry.Key
  Dim value As Text = entry.Value
Next

Xojo.Core.Dictionary can also be case-sensitive which is not even an option with the classic Dicitonary class! You just have to subclass (or use AddHandler) and implement the CompareKeys event handler:

Dim leftText As Text = lhs
Dim rightText As Text = rhs
Return leftText.Compare(rightText, Text.CompareCaseSensitive)

JSON

In the new framework, JSON is handled by two methods (Xojo.Data.ParseJSON and Xojo.Data.GenerateJSON), typically with Xojo.Core.Dictionary. Creating JSON text from a Dictionary is one line of code:

Dim jsonText As Text = Xojo.Data.GenerateJSON(myDictionary)

And converting JSON text to a Dictionary is also one line of code:

Dim jsonDict As Xojo.Core.Dictionary = Xojo.Data.ParseJSON(jsonText)

Both of these methods are much faster than using JSONItem in the classic framework.

HTTPSocket

Xojo.Net.HTTPSocket uses HTTP 1.1. This is a big advantage over the classic HTTPSocket which only supports HTTP 1.0 making it not always compatible with some sites.

I recently did a webinar that shows how to use HTTPSocket with a variety of web services.

TextInputStream/TextOutputStream

Lastly, I often work with Text files which means I have to deal with encodings. The TextInputStream and TextOutputStream make it easy to deal with encodings because the encoding is part of the method calls.

You can even use these classes with classic FolderItems by first converting them to Xojo.IO.FolderItem. For example, this prompts the user for a file and then opens it using a TextInputStream:

Dim f As FolderItem = GetOpenFolderItem("")
If f <> Nil Then
  Dim openFile As New Xojo.IO.FolderItem(f.NativePath.ToText)
  Dim input As Xojo.IO.TextInputStream
  input = Xojo.IO.TextInputStream.Open(openFile, Xojo.Core.TextEncoding.UTF8)
End If

If you have not already, try these new Xojo Framework classes in your projects. You’ll appreciate it!

Update (June 2020):

Since this was posted, there have been many updates to Xojo. In particular you should check out these equivalent API 2.0 features:

• Dictionary now also has an iterator.
• GenerateJSON and ParseJSON.
• URLConnection

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?