Lua Requires Chilkat v11.0.0+

Trello OAuth1 Authorization

See more OAuth1 Examples

Demonstrates OAuth1 authentication for Trello. Lua

    -- In the following call to loadlib, change the path (./chilkat.dll) to the relative or absolute directory where the chilkat.dll, chilkat.so, or chilkat.dylib is located.
    chilkat = assert(package.loadlib("./chilkat.dll", "luaopen_chilkat"))()
    print(chilkat._VERSION)

    local success = false

    --  This example requires the Chilkat API to have been previously unlocked.
    --  See Global Unlock Sample for sample code.

    local consumerKey = "TRELLO_CONSUMER_KEY"
    local consumerSecret = "TRELLO_CONSUMER_SECRET"

    local requestTokenUrl = "https://trello.com/1/OAuthGetRequestToken"
    local authorizeUrl = "https://trello.com/1/OAuthAuthorizeToken"
    local accessTokenUrl = "https://trello.com/1/OAuthGetAccessToken"

    --  The port number is picked at random. It's some unused port that won't likely conflict with anything else..
    local callbackUrl = "http://localhost:3017/"
    local callbackLocalPort = 3017

    --  The 1st step in 3-legged OAuth1.0a is to send a POST to the request token URL to obtain an OAuth Request Token
    local http = chilkat.newHttp{}

    http:setOAuth1(true)
    http:setOAuthConsumerKey(consumerKey)
    http:setOAuthConsumerSecret(consumerSecret)
    http:setOAuthCallback(callbackUrl)

    local req = chilkat.newHttpRequest{}
    req:setHttpVerb("POST")
    req:setContentType("application/x-www-form-urlencoded")

    local resp = chilkat.newHttpResponse{}
    success = http:HttpReq(requestTokenUrl,req,resp)
    if success == false then
        print(http:LastErrorText())

    end

    --  If successful, the resp.BodyStr contains something like this:  
    --  oauth_token=c173ff088a09a67389a42b1ee22366a4&oauth_token_secret=717e6015c6749fe050a923516e739dbb&oauth_callback_confirmed=true
    print(resp:BodyStr())

    local hashTab = chilkat.newHashtable{}
    hashTab:AddQueryParams(resp:BodyStr())

    local requestToken = hashTab:LookupStr("oauth_token")
    local requestTokenSecret = hashTab:LookupStr("oauth_token_secret")
    http:setOAuthTokenSecret(requestTokenSecret)

    print("oauth_token = ", requestToken)
    print("oauth_token_secret = ", requestTokenSecret)

    --  ---------------------------------------------------------------------------
    --  The next step is to form a URL to send to the authorizeUrl
    --  This is an HTTP GET that we load into a popup browser.
    local sbUrlForBrowser = chilkat.newStringBuilder{}
    sbUrlForBrowser:Append(authorizeUrl)
    sbUrlForBrowser:Append("?oauth_token=")
    sbUrlForBrowser:Append(requestToken)
    sbUrlForBrowser:Append("&scope=read,write,account")

    local url = sbUrlForBrowser:GetAsString()

    print("url = ", url)

    --  When the urlForBrowser is loaded into a browser, the response from Trello will redirect back to localhost:3017
    --  We'll need to start a socket that is listening on port 3017 for the callback from the browser.
    local listenSock = chilkat.newSocket{}

    local backLog = 5
    success = listenSock:BindAndListen(callbackLocalPort,backLog)
    if success == false then
        print(listenSock:LastErrorText())

    end

    --  Wait for the browser's connection in a background thread.
    --  (We'll send load the URL into the browser following this..)
    --  Wait a max of 60 seconds before giving up.
    local sock = chilkat.newSocket{}
    local maxWaitMs = 60000
    local task = listenSock:AcceptNextAsync(maxWaitMs,sock)
    task:Run()

    --  Launch the system's default browser navigated to the URL.
    local oauth2 = chilkat.newOAuth2{}
    success = oauth2:LaunchBrowser(url)
    if success == false then
        print(oauth2:LastErrorText())

    end

    --  Wait for the listenSock's task to complete.
    success = task:Wait(maxWaitMs)
    if !success || (task:StatusInt() ~= 7) || (task:TaskSuccess() ~= true) then
        if !success then
            --  The task.LastErrorText applies to the Wait method call.
            print(task:LastErrorText())
        else
            --  The ResultErrorText applies to the underlying task method call (i.e. the AcceptNextConnection)
            print(task:Status())
            print(task:ResultErrorText())
        end

    end

    --  If we get to this point, the connection from the browser arrived and was accepted.

    --  We no longer need the listen socket...
    --  Stop listening on port 3017.
    listenSock:Close(10)

    --  Read the start line of the request..
    local startLine = sock:ReceiveUntilMatch("\r\n")
    if sock:LastMethodSuccess() == false then
        print(sock:LastErrorText())

    end

    --  Read the request header.
    local requestHeader = sock:ReceiveUntilMatch("\r\n\r\n")
    if sock:LastMethodSuccess() == false then
        print(sock:LastErrorText())

    end

    --  The browser SHOULD be sending us a GET request, and therefore there is no body to the request.
    --  Once the request header is received, we have all of it.
    --  We can now send our HTTP response.
    local sbResponseHtml = chilkat.newStringBuilder{}
    sbResponseHtml:Append("<html><body><p>Chilkat thanks you!</b></body</html>")

    local sbResponse = chilkat.newStringBuilder{}
    sbResponse:Append("HTTP/1.1 200 OK\r\n")
    sbResponse:Append("Content-Length: ")
    sbResponse:AppendInt(sbResponseHtml:Length())
    sbResponse:Append("\r\n")
    sbResponse:Append("Content-Type: text/html\r\n")
    sbResponse:Append("\r\n")
    sbResponse:AppendSb(sbResponseHtml)

    sock:SendString(sbResponse:GetAsString())
    sock:Close(50)

    --  The information we need is in the startLine.
    --  For example, the startLine will look something like this:
    --   GET /?oauth_token=c173ff088a09a67389b42b1ee32366a4&oauth_verifier=c65bc8eed882e04bb94023bb12c0dbef HTTP/1.1
    local sbStartLine = chilkat.newStringBuilder{}
    sbStartLine:Append(startLine)
    local numReplacements = sbStartLine:Replace("GET /?","")
    numReplacements = sbStartLine:Replace(" HTTP/1.1","")
    sbStartLine:Trim()

    --  oauth_token=c173ff088a09a67389b42b1ee32366a4&oauth_verifier=c65bc8eed882e04bb94023bb12c0dbef
    print("startline: ", sbStartLine:GetAsString())

    hashTab:Clear()
    hashTab:AddQueryParams(sbStartLine:GetAsString())

    requestToken = hashTab:LookupStr("oauth_token")
    local authVerifier = hashTab:LookupStr("oauth_verifier")

    --  ------------------------------------------------------------------------------
    --  Finally , we must exchange the OAuth Request Token for an OAuth Access Token.

    http:setOAuthToken(requestToken)
    http:setOAuthVerifier(authVerifier)    req:setHttpVerb("POST")

    req:setHttpVerb("POST")
    req:setContentType("application/x-www-form-urlencoded")

    success = http:HttpReq(accessTokenUrl,req,resp)
    if success == false then
        print(http:LastErrorText())

    end

    --  Make sure a successful response was received.
    if resp:StatusCode() ~= 200 then
        print(resp:StatusLine())
        print(resp:Header())
        print(resp:BodyStr())

    end

    --  If successful, the resp.BodyStr contains something like this:
    --  oauth_token=4618e19f5101b7199f75aA9e678d1585576ad84fb89fa40c85c4da13589010d5&oauth_token_secret=64a997b26ea1f47105eca36ce1a5d22e
    print("response BodyStr = ", resp:BodyStr())

    hashTab:Clear()
    hashTab:AddQueryParams(resp:BodyStr())

    local accessToken = hashTab:LookupStr("oauth_token")
    local accessTokenSecret = hashTab:LookupStr("oauth_token_secret")

    --  The access token + secret is what should be saved and used for
    --  subsequent REST API calls.
    print("Access Token = ", accessToken)
    print("Access Token Secret = ", accessTokenSecret)

    --  Save the access token for subsequent REST API calls.
    local json = chilkat.newJsonObject{}
    json:AppendString("oauth_token",accessToken)
    json:AppendString("oauth_token_secret",accessTokenSecret)

    local fac = chilkat.newFileAccess{}
    fac:WriteEntireTextFile("qa_data/tokens/trello.json",json:Emit(),"utf-8",false)

    print("Success.")