Autentikasi aplikasi dan akun¶

Proses autentikasi Open API cTrader didasarkan pada standar OAuth 2.0.

Kerangka kerja ini memungkinkan aplikasi pihak ketiga untuk mendapatkan akses terbatas ke suatu layanan baik atas nama pemilik sumber daya, dengan mengatur interaksi persetujuan antara pemilik sumber daya dan layanan, atau dengan mengizinkan aplikasi pihak ketiga untuk mendapatkan akses atas namanya sendiri.

Alur autentikasi ¶

Sesuai dengan standar OAuth 2.0, autentikasi akun memerlukan kode otorisasi dan token akses.

Biasanya, proses seseorang yang baru mulai menggunakan aplikasi Anda untuk pertama kalinya terlihat sebagai berikut:

1. Pengguna dengan cTID tertentu mengakses aplikasi Anda di mana pun itu di-deploy; pengguna berinteraksi dengan tombol aksi atau yang setara.

2. Aplikasi menggunakan browser yang disematkan (atau cara lain yang sesuai) untuk mengarahkan pengguna ke URI tertentu di mana mereka akan memberikan izin yang diperlukan kepada aplikasi.

3. Pengguna dialihkan ke URL pengalihan yang telah ditentukan. URL ini berisi token akses sebagai nilai dari parameter kueri code.

4. Pengguna dialihkan kembali ke aplikasi baik secara otomatis maupun atas kemauan mereka sendiri. Aplikasi diberitahu tentang nilai parameter code.

5. Aplikasi mengirim permintaan untuk menukar kode otorisasi dengan token akses ke endpoint tertentu.

6. Aplikasi menerima respons yang berisi token akses sebagai nilai dari kunci accessToken.

7. Aplikasi mengirim pesan ProtoOAApplicationAuthReq yang berisi bidang clientId dan clientSecret.

8. Aplikasi mengirim pesan ProtoOAGetAccountListByAccessTokenReq yang berisi bidang accessToken. Respons (ProtoOAGetAccountListByAccessTokenRes) berisi bidang ctidTraderAccountId yang berulang.

9. Setelah menerima respons, aplikasi mengirim pesan ProtoOAAccountAuthReq yang berisi bidang ctidTraderAccountId dan accessToken.

Setelah itu, pengguna harus diautentikasi di bawah akun yang ctidTraderAccountId-nya cocok dengan ctidTraderAccountId yang diberikan selama langkah 8.

Diagram di bawah ini menjelaskan bagaimana alur autentikasi dasar bekerja dari perspektif aplikasi Open API Anda.

graph TB
  A([Mengarahkan pengguna <br/> ke URI tertentu]) ==> B([Menerima kode <br/> otorisasi]);
  B ==> C([Mengirim permintaan untuk <br/> mendapatkan kode akses]);
  C ==> D([Mengirim pesan <br/> ProOAApplicationAuthReq <br/>]);
  D ==> E([Mengirim pesan <br/> ProtoOAAccountAuthReq <br/>]);

Di sub-bagian di bawah ini, kami menjelaskan langkah-langkah kunci dari alur autentikasi secara detail.

Tambahkan URI pengalihan ¶

Seperti yang ditunjukkan sebelumnya, aplikasi Anda perlu mendapatkan kode otorisasi setelah pengguna dikirim ke URI pengalihan tertentu. URI ini akan menyertakan kode otorisasi sebagai nilai dari parameter kueri code.

Untuk menambahkan URI pengalihan baru, lakukan hal berikut:

1. Buka halaman Aplikasi di portal Open API.

2. Pilih tombol Edit di baris dengan aplikasi yang ingin Anda tambahkan URL pengalihan.

3. Di layar yang baru muncul, gulir ke bawah ke bagian URI Pengalihan.

4. Tambahkan URL pengalihan di bidang teks kosong yang tersedia. Jika tidak ada bidang yang tersedia, pilih tombol Tambahkan URI pengalihan.

5. Pilih tombol Simpan di bagian bawah halaman untuk menerapkan perubahan Anda.

Dapatkan kode otorisasi ¶

Untuk menerima kode otorisasi untuk cTID tertentu, aplikasi Anda perlu mengirim pengguna ke URI berikut.

https://id.ctrader.com/my/settings/openapi/grantingaccess/?client_id={clientId}&redirect_uri={your_redirectURI}&scope={scope}&product=web

URI ini memiliki parameter kueri berikut.

Untuk melihat client_id Anda, buka halaman Aplikasi dan pilih tombol Lihat di kolom Kredensial.

Setelah pengguna dikirim ke URI di atas (dan selama kedua parameter valid), mereka akan melihat layar login/pendaftaran yang meminta mereka untuk mengotorisasi di bawah cTID mereka. Setelah itu, pengguna akan ditampilkan dialog di mana mereka dapat mengizinkan aplikasi untuk mendapatkan akses ke satu atau lebih akun yang terhubung dengan cTID mereka.

Ketika pengguna memilih tombol Izinkan akses, mereka akan dialihkan ke redirect_uri yang Anda tentukan sebelumnya. Seperti yang ditunjukkan dalam contoh di bawah, kode otorisasi akan ditambahkan ke URI ini sebagai parameter kueri.

https://my-redirect-uri.com/?code=123ASDASffdg_as234_GCllkoq14adRB7_tvN

Pada titik ini, aplikasi Anda perlu mengakses dan menyimpan nilai parameter code. Ini harus segera ditukar dengan token akses sebelum kode otorisasi kedaluwarsa.

Dapatkan token akses ¶

Untuk mendapatkan token akses, lakukan panggilan REST API berikut.

Permintaan ini mencakup parameter kueri berikut.

Contoh permintaan dapat ditemukan di bawah.

curl -X GET 'https://openapi.ctrader.com/apps/token?grant_type=authorization_code&code=0ssdgds98as9_QSF56FVC_22dfdf&redirect_uri=https://spotware.com&client_id=5430012&client_secret=012sds23dlkjQsd' -H 'Accept: application/json' -H 'Content-Type: application/json'

Untuk melihat client_secret Anda, kembali ke halaman Aplikasi dan pilih tombol Lihat di kolom Kredensial.

Setelah permintaan berhasil, Anda harus menerima respons dengan kunci berikut.

Untuk contoh respons yang berhasil, lihat cuplikan di bawah.

{
    "accessToken":"mos8Bw3D4EG0fRPd4Eqq0JxaFT4zjd8e4YijNezh_ag",
    "tokenType":"bearer",
    "expiresIn":2628000,
    "refreshToken":"VCuafFhy81AFZjsWkbuEzdOhhRj5YTWz8fWUwHam7KM",
    "errorCode":null,
    "description":null,
}

Kirim pesan ProtoBuf yang diperlukan ¶

Setelah menerima kode akses yang valid, aplikasi Anda perlu mengirim pesan ProtoOAApplicationAuthReq, ProtoOAGetAccountListByAccessTokenReq dan ProtoOAAccountAuthReq. Ini dapat dilakukan sebagai berikut.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

private static RepeatedField<ProtoOACtidTraderAccount> _ctidTraderAccounts;

List<IDisposable> _disposables = new();
_disposables.Add(_client.OfType<ProtoOAGetAccountListByAccessTokenRes>().Subscribe(OnAccountIdReceived));

private static void OnAccountIdReceived(ProtoOAGetAccountListByAccessTokenRes response)
{

    Console.WriteLine($"\nMessage Received:\n{response}");

    _ctidTraderAccounts = response.CtidTraderAccount;

    var accountAuthReq = new ProtoOAAccountAuthReq
    {
        CtidTraderAccountId = (long)_ctidTraderAccounts[0].CtidTraderAccountId,
        AccessToken = _token.AccessToken,
    };

    _client.SendMessage(accountAuthReq);

}

var _client = new OpenClient(host, ApiInfo.Port, TimeSpan.FromSeconds(10), useWebSocket: false);
var applicationAuthReq = new ProtoOAApplicationAuthReq
{
    ClientId = {your_client_id}, // Add your client ID here
    ClientSecret = {your_app_secret}, // Add your app secret here
};
await _client.SendMessage(applicationAuthReq);
await Task.Delay(5000);
var getAccountListByAccessToken = new ProtoOAGetAccountListByAccessTokenReq 
{
    AccessToken = {access_token} // Add your access token here
}
var accountAuthReq = new ProtoOAAccountAuthReq 
{
    ctidTraderAccountId = {account_id}, // Add the ctidTraderAccountId of the account you want to authorize here
    AccessToken = {access_token} // Add your access token here
};
await _client.SendMessage(accountAuthReq);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

currentAccountId = None
client = Client(EndPoints.PROTOBUF_LIVE_HOST if hostType.lower() == "live" else EndPoints.PROTOBUF_DEMO_HOST, EndPoints.PROTOBUF_PORT, TcpProtocol)

def connected(client): # Callback for client connection
    print("\nConnected")
    request = ProtoOAApplicationAuthReq()
    request.clientId = appClientId
    request.clientSecret = appClientSecret
    deferred = client.send(request)



def disconnected(client, reason): # Callback for client disconnection
    print("\nDisconnected: ", reason)

def onMessageReceived(client, message): # Callback for receiving all messages
    global currentAccountId
    if message.payloadType in [ProtoOASubscribeSpotsRes().payloadType, ProtoOAAccountLogoutRes().payloadType, ProtoHeartbeatEvent().payloadType]:
        return
    elif message.payloadType == ProtoOAApplicationAuthRes().payloadType:
        print("API Application authorized\n")
        if currentAccountId is not None:
            sendProtoOAAccountAuthReq()
            return
        accountListReq = ProtoOAGetAccountListByAccessTokenReq()
        accountListReq.accessToken = accessToken
        deferred = client.send(accountListReq)
    elif message.payloadType == ProtoOAGetAccountListByAccessTokenRes().payloadType:
        protoOAGetAccountListByAccessTokenRes = Protobuf.extract(message)
        currentAccountId = int(protoOAGetAccountListByAccessTokenRes.ctidTraderAccount[0].ctidTraderAccountId)
        accountAuthReq = ProtoOAAccountAuthReq()
        accountAuthReq.ctidTraderAccountId = currentAccountId
        accountAuthReq.accessToken = accessToken
        deferred = client.send(accountAuthReq)
    elif message.payloadType == ProtoOAAccountAuthRes().payloadType:
        protoOAAccountAuthRes = Protobuf.extract(message)
        print(f"Account {protoOAAccountAuthRes.ctidTraderAccountId} has been authorized\n")
        print("This acccount will be used for all future requests\n")
    else:
        print("Message received: \n", Protobuf.extract(message))
    reactor.callLater(3, callable=executeUserCommand)

def onError(failure): # Call back for errors
    print("Message Error: ", failure)
    reactor.callLater(3, callable=executeUserCommand)

Perbarui token akses ¶

Setelah token akses kedaluwarsa, Anda harus memperbaruinya menggunakan refreshToken yang Anda terima sebelumnya. Anda dapat melakukan tindakan ini melalui dua metode berbeda.

Kirim permintaan HTTP¶

Untuk mendapatkan token akses baru (dan, selanjutnya, token pembaruan baru), Anda dapat melakukan permintaan HTTP yang sama yang telah dibahas di atas. Seperti yang ditunjukkan dalam contoh di bawah, Anda harus mengatur parameter query grant_type ke refresh_token.

curl -X POST 'https://openapi.ctrader.com/apps/token?grant_type=refresh_token&refresh_token=asdXCVCVAS_218kjashf_asdasd2ASD_223x&client_id=5430012&client_secret=012sds23dlkjQsd' -H 'Accept: application/json' -H 'Content-Type: application/json'

Anda akan menerima respons yang berisi nilai baru dari kunci accessToken dan refreshToken. Anda dapat menggunakan nilai baru ini dengan aman sementara nilai lama dari kunci yang sama secara otomatis tidak valid.

Kirim pesan Protobuf¶

Sebagai alternatif, Anda dapat mengirim pesan ProtoOARefreshTokenReq dan menerima pesan ProtoOARefreshTokenRes yang berisi token baru yang valid.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

_disposables.Add(_client.OfType<ProtoOARefreshTokenRes>().Subscribe(OnRefreshTokenResponse));
private static void OnRefreshTokenResponse(ProtoOARefreshTokenRes response) 
{
    _token = new Token 
    {
        AccessToken = response.AccessToken,
        RefreshToken = response.RefreshToken,
        ExpiresIn = DateTimeOffset.FromUnixTimeMilliseconds(response.ExpiresIn),
        TokenType = response.TokenType,
    }
}
var refreshTokenReq = new ProtoOARefreshTokenReq
    {
        refreshToken = {your_refresh_token}, // Add your refresh token here
    };
await _client.SendMessage(applicationAuthReq);

1

newToken = auth.refreshToken("refresh_Token")

Gunakan Playground ¶

Playground menyediakan cara cepat untuk mendapatkan token akses untuk cTID Anda sendiri, memungkinkan Anda untuk dengan cepat dan mudah mengembangkan dan menguji aplikasi Anda sebelum mendistribusikannya ke audiens target.

Untuk mengakses Playground, buka halaman Applications dan pilih tombol Playground. Di jendela yang baru muncul, pilih cakupan aplikasi dan klik tombol Get token.

Setelah itu, Anda akan melihat halaman berikut.

Anda dapat menggunakan token akses dan token pembaruan untuk mengirim pesan ke API saat diautentikasi di bawah cTID Anda sendiri.