(PowerBuilder) Get E-way Bill System Access Token

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

Chilkat ActiveX Downloads ActiveX for 32-bit and 64-bit Windows

integer li_rc
oleobject loo_Pubkey
integer li_Success
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

// 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
// Use "Chilkat_9_5_0.PublicKey" for versions of Chilkat < 10.0.0
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 <> 1 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
// Use "Chilkat_9_5_0.Rsa" for versions of Chilkat < 10.0.0
li_rc = loo_Rsa.ConnectToNewObject("Chilkat.Rsa")

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

li_Success = loo_Rsa.ImportPublicKeyObj(loo_Pubkey)
if li_Success <> 1 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 <> 1 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
// Use "Chilkat_9_5_0.Prng" for versions of Chilkat < 10.0.0
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 <> 1 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
// Use "Chilkat_9_5_0.JsonObject" for versions of Chilkat < 10.0.0
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
// Use "Chilkat_9_5_0.Http" for versions of Chilkat < 10.0.0
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 = loo_Http.PostJson2("http://ewb.wepgst.com/api/Authenticate","application/json",loo_JsonBody.Emit())
if loo_Http.LastMethodSuccess <> 1 then
    Write-Debug loo_Http.LastErrorText
    destroy loo_Pubkey
    destroy loo_Rsa
    destroy loo_Prng
    destroy loo_JsonBody
    destroy loo_Http
    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
    destroy loo_Resp
    Write-Debug "Failed in some unknown way."
    destroy loo_Pubkey
    destroy loo_Rsa
    destroy loo_Prng
    destroy loo_JsonBody
    destroy loo_Http
    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
// Use "Chilkat_9_5_0.JsonObject" for versions of Chilkat < 10.0.0
li_rc = loo_Json.ConnectToNewObject("Chilkat.JsonObject")

loo_Json.Load(loo_Resp.BodyStr)
destroy loo_Resp

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
    // Use "Chilkat_9_5_0.StringBuilder" for versions of Chilkat < 10.0.0
    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_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
// Use "Chilkat_9_5_0.Crypt2" for versions of Chilkat < 10.0.0
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
// Use "Chilkat_9_5_0.BinData" for versions of Chilkat < 10.0.0
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
// Use "Chilkat_9_5_0.JsonObject" for versions of Chilkat < 10.0.0
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
// Use "Chilkat_9_5_0.FileAccess" for versions of Chilkat < 10.0.0
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_Json
destroy loo_SbError
destroy loo_Crypt
destroy loo_BdSek
destroy loo_JsonEwayAuth
destroy loo_Fac