PowerBuilder Requires Chilkat v11.0.0+

Get E-way Bill System Access Token

See more HTTP Misc Examples

Sends a request to get an E-way bill system access token. PowerBuilder

integer li_rc
integer li_Success
oleobject loo_Pubkey
string ls_Password
oleobject loo_Rsa
string ls_EncPassword
oleobject loo_Prng
string ls_App_key
string ls_EncAppKey
oleobject loo_JsonBody
oleobject loo_Http
oleobject loo_Resp
integer li_RespStatusCode
oleobject loo_Json
integer li_Status
oleobject loo_SbError
string ls_AuthToken
oleobject loo_Crypt
oleobject loo_BdSek
oleobject loo_JsonEwayAuth
oleobject loo_Fac

li_Success = 0

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

//  First load the public key provided by the E-way bill System
loo_Pubkey = create oleobject
li_rc = loo_Pubkey.ConnectToNewObject("Chilkat.PublicKey")
if li_rc < 0 then
    destroy loo_Pubkey
    MessageBox("Error","Connecting to COM object failed")
    return
end if
li_Success = loo_Pubkey.LoadFromFile("qa_data/pem/eway_publickey.pem")
if li_Success = 0 then
    Write-Debug loo_Pubkey.LastErrorText
    destroy loo_Pubkey
    return
end if

//  Encrypt the password using the RSA public key provided by eway..
ls_Password = "my_wepgst_password"
loo_Rsa = create oleobject
li_rc = loo_Rsa.ConnectToNewObject("Chilkat.Rsa")

loo_Rsa.Charset = "utf-8"
loo_Rsa.EncodingMode = "base64"

li_Success = loo_Rsa.UsePublicKey(loo_Pubkey)
if li_Success = 0 then
    Write-Debug loo_Rsa.LastErrorText
    destroy loo_Pubkey
    destroy loo_Rsa
    return
end if

//  Returns the encrypted password as base64 (because the EncodingMode = "base64")
ls_EncPassword = loo_Rsa.EncryptStringENC(ls_Password,0)
if loo_Rsa.LastMethodSuccess = 0 then
    Write-Debug loo_Rsa.LastErrorText
    destroy loo_Pubkey
    destroy loo_Rsa
    return
end if

//  Generate a random app_key.  This should be 32 bytes (us-ascii chars)
//  We need 32 bytes because we'll be doing 256-bit AES ECB encryption, and 32 bytes = 256 bits.
loo_Prng = create oleobject
li_rc = loo_Prng.ConnectToNewObject("Chilkat.Prng")

//  Generate a random string containing some numbers, uppercase, and lowercase.
ls_App_key = loo_Prng.RandomString(32,1,1,1)

Write-Debug "app_key = " + ls_App_key

//  RSA encrypt the app_key.
ls_EncAppKey = loo_Rsa.EncryptStringENC(ls_App_key,0)
if loo_Rsa.LastMethodSuccess = 0 then
    Write-Debug loo_Rsa.LastErrorText
    destroy loo_Pubkey
    destroy loo_Rsa
    destroy loo_Prng
    return
end if

//  Prepare the JSON body for the HTTP POST that gets the access token.
loo_JsonBody = create oleobject
li_rc = loo_JsonBody.ConnectToNewObject("Chilkat.JsonObject")

loo_JsonBody.UpdateString("action","ACCESSTOKEN")
//  Use your username instead of "09ABDC24212B1FK".
loo_JsonBody.UpdateString("username","09ABDC24212B1FK")
loo_JsonBody.UpdateString("password",ls_EncPassword)
loo_JsonBody.UpdateString("app_key",ls_EncAppKey)

loo_Http = create oleobject
li_rc = loo_Http.ConnectToNewObject("Chilkat.Http")

//  Add required headers.
//  Use your ewb-user-id instead of "03AEXPR16A9M010"
loo_Http.SetRequestHeader("ewb-user-id","03AEXPR16A9M010")
//  The Gstin should be the same as the username in the jsonBody above.
loo_Http.SetRequestHeader("Gstin","09ABDC24212B1FK")
loo_Http.Accept = "application/json"

//  POST the JSON...
loo_Resp = create oleobject
li_rc = loo_Resp.ConnectToNewObject("Chilkat.HttpResponse")

li_Success = loo_Http.HttpJson("POST","http://ewb.wepgst.com/api/Authenticate",loo_JsonBody,"application/json",loo_Resp)
if li_Success = 0 then
    Write-Debug loo_Http.LastErrorText
    destroy loo_Pubkey
    destroy loo_Rsa
    destroy loo_Prng
    destroy loo_JsonBody
    destroy loo_Http
    destroy loo_Resp
    return
end if

li_RespStatusCode = loo_Resp.StatusCode
Write-Debug "response status code =" + string(li_RespStatusCode)
Write-Debug "response body:"
Write-Debug loo_Resp.BodyStr

if li_RespStatusCode <> 200 then
    Write-Debug "Failed in some unknown way."
    destroy loo_Pubkey
    destroy loo_Rsa
    destroy loo_Prng
    destroy loo_JsonBody
    destroy loo_Http
    destroy loo_Resp
    return
end if

//  When the response status code = 200, we'll have either
//  success response like this:
//   {"status":"1","authtoken":"...","sek":"..."}
//  
//  or a failed response like this:
//  
//  {"status":"0","error":"eyJlcnJvckNvZGVzIjoiMTA4In0="}

//  Load the response body into a JSON object.
loo_Json = create oleobject
li_rc = loo_Json.ConnectToNewObject("Chilkat.JsonObject")

loo_Json.Load(loo_Resp.BodyStr)

li_Status = loo_Json.IntOf("status")
Write-Debug "status = " + string(li_Status)

if li_Status <> 1 then
    //  Failed.  Base64 decode the error
    //  {"status":"0","error":"eyJlcnJvckNvZGVzIjoiMTA4In0="}
    //  For an invalid password, the error is: {"errorCodes":"108"}
    loo_SbError = create oleobject
    li_rc = loo_SbError.ConnectToNewObject("Chilkat.StringBuilder")

    loo_Json.StringOfSb("error",loo_SbError)
    loo_SbError.Decode("base64","utf-8")
    Write-Debug "error: " + loo_SbError.GetAsString()
    destroy loo_Pubkey
    destroy loo_Rsa
    destroy loo_Prng
    destroy loo_JsonBody
    destroy loo_Http
    destroy loo_Resp
    destroy loo_Json
    destroy loo_SbError
    return
end if

//  At this point, we know the request was entirely successful.
ls_AuthToken = loo_Json.StringOf("authtoken")

//  Decrypt the sek key using our app_key.
loo_Crypt = create oleobject
li_rc = loo_Crypt.ConnectToNewObject("Chilkat.Crypt2")

loo_Crypt.CryptAlgorithm = "aes"
loo_Crypt.CipherMode = "ecb"
loo_Crypt.KeyLength = 256
loo_Crypt.SetEncodedKey(ls_App_key,"us-ascii")
loo_Crypt.EncodingMode = "base64"

loo_BdSek = create oleobject
li_rc = loo_BdSek.ConnectToNewObject("Chilkat.BinData")

loo_BdSek.AppendEncoded(loo_Json.StringOf("sek"),"base64")
loo_Crypt.DecryptBd(loo_BdSek)

//  bdSek now contains the decrypted symmetric encryption key...
//  We'll use it to encrypt the JSON payloads we send.

//  Let's persist our authtoken and decrypted sek (symmetric encryption key).
//  To send EWAY requests (such as to create an e-way bill), we'll just load 
//  and use these pre-obtained credentials.
loo_JsonEwayAuth = create oleobject
li_rc = loo_JsonEwayAuth.ConnectToNewObject("Chilkat.JsonObject")

loo_JsonEwayAuth.UpdateString("authToken",ls_AuthToken)
loo_JsonEwayAuth.UpdateString("decryptedSek",loo_BdSek.GetEncoded("base64"))
loo_JsonEwayAuth.EmitCompact = 0

loo_Fac = create oleobject
li_rc = loo_Fac.ConnectToNewObject("Chilkat.FileAccess")

loo_Fac.WriteEntireTextFile("qa_data/tokens/ewayAuth.json",loo_JsonEwayAuth.Emit(),"utf-8",0)

Write-Debug "Saved:"
Write-Debug loo_JsonEwayAuth.Emit()

//  Sample output:
//  {
//    "authToken": "IBTeFtxNfVurg71LTzZ2r0xK7",
//    "decryptedSek": "5g1TyTie7yoslU3DrbYATa7mWyPazlODE7cEh5Vy4Ho="
//  }


destroy loo_Pubkey
destroy loo_Rsa
destroy loo_Prng
destroy loo_JsonBody
destroy loo_Http
destroy loo_Resp
destroy loo_Json
destroy loo_SbError
destroy loo_Crypt
destroy loo_BdSek
destroy loo_JsonEwayAuth
destroy loo_Fac