using System;
using System.Net;
using System.Text;
using System.IO;
using AesEverywhere;

namespace Transfer
{
    class Members
    {
        public static string apiUrl = "<url>"; // This is a example url, please fill in the right url from the MIF
        public static string aesKey = "HJwMgszptPW8YybZGFluBTm569crSxhd"; // This is a example aes_key, please fill in the right aes_key from the MIF
        public static string signKey = "AbKmLhGTkHpoPzj6fWFS4e5BtI3xuvEJ"; // This is a example sign_key, please fill in the right sign_key from the MIF
        public static string channel = "01234567"; // This is a example Channel, please fill in the right Channel from the MIF
        public static string agent = "exampleAg001"; // This is a example Agent, please fill in the right Agent from the MIF
        public static string account = "exampleAct001"; // This is a example Account, please fill in the right Account from the MIF
        public static void CreateMember()
        {
            String d = "{\"agent\":\"" + agent + "\",\"account\":\"" + account + "\"}";
            String req = Encryption(d);
            String url = "https://" + apiUrl + "/v1/member/create";
            Post(req, url);
        }
        public static string Encryption(string d)
        {
            String data = AESKeyEncryption(d);
            String sign = SignKeyEncryption(data);

            return "{\"channel\":\"" + channel + "\",\"data\":\"" + data + "\",\"sign\":\"" + sign + "\"}";
        }
        public static string AESKeyEncryption(string d)
        {
            AES256 aes256 = new AES256();
            return aes256.Encrypt(d, aesKey);
        }
        public static string SignKeyEncryption(string d)
        {
            using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create())
            {
                byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(d + signKey);
                byte[] hashBytes = md5.ComputeHash(inputBytes);
                // Convert the byte array to hexadecimal string
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < hashBytes.Length; i++)
                {
                    sb.Append(hashBytes[i].ToString("x2"));
                }
                return sb.ToString();
            }
        }
        public static void Post(string d, string url)
        {
            byte[] b = Encoding.UTF8.GetBytes(d);

            var r = (HttpWebRequest)WebRequest.Create(url); // This is a example url, please fill in the right url from the MIF
            r.Method = "POST";
            r.ContentType = "application/json";
            r.ContentLength = b.Length;

            using (var stream = r.GetRequestStream())
            {
                stream.Write(b, 0, b.Length);
            }
            var resp = (HttpWebResponse)r.GetResponse();
            var res = new StreamReader(resp.GetResponseStream()).ReadToEnd();

            Console.WriteLine(res);
        }
        public static void Main(string[] args)
        {
            CreateMember();
        }
    }
}

// aes256.cs
// This file is part of AES-everywhere project (https://github.com/mervick/aes-everywhere)
//
// This is an implementation of the AES algorithm, specifically CBC mode,
// with 256 bits key length and PKCS7 padding.
//
// Copyright Andrey Izman (c) 2018-2019 <izmanw@gmail.com>
// Licensed under the MIT license
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// <summary>AES256 class implements the OpenSSL compatible cipher AES/256/CBC/PKCS7</summary>
// <copyright file="aes256.cs" company="Andrey Izman">
// Copyright (c) 2018 All Rights Reserved
// </copyright>
// <author>Andrey Izman</author>
// <email>izmanw@gmail.com</email>
// <link>https://github.com/mervick/aes-everywhere</link>
// <license>MIT</license>

using System;
using System.Security.Cryptography;
using System.IO;
using System.Text;

namespace AesEverywhere
{
    /// <summary>
    /// AES256 class implements the OpenSSL compatible cipher AES/256/CBC/PKCS7
    /// </summary>
    public class AES256
    {
        public const int BlockSize = 16;
        public const int KeyLen = 32;
        public const int IvLen = 16;

        private byte[] key;
        private byte[] iv;

        /// <summary>
        /// Encrypt input text with the password using random salt.
        /// Returns base64 decoded encrypted string.
        /// </summary>
        /// <param name="text">Input text to encrypt</param>
        /// <param name="passphrase">Passphrase</param>
        public string Encrypt(string text, string passphrase)
        {
            return Encrypt(Encoding.UTF8.GetBytes(text), passphrase);
        }

        /// <summary>
        /// Encrypt input bytes with the password using random salt.
        /// Returns base64 decoded encrypted string.
        /// </summary>
        /// <param name="data">Input data (in bytes) to encrypt</param>
        /// <param name="passphrase">Passphrase</param>
        public string Encrypt(byte[] data, string passphrase)
        {
            using (var random = new RNGCryptoServiceProvider())
            {
                byte[] salt = new byte[8];
                random.GetBytes(salt);

                DeriveKeyAndIv(passphrase, salt);

                byte[] encrypted;
                using (var aes = new RijndaelManaged())
                {
                    aes.BlockSize = BlockSize * 8;
                    aes.Mode = CipherMode.CBC;
                    aes.Padding = PaddingMode.PKCS7;
                    aes.Key = key;
                    aes.IV = iv;
                    ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
                    using (var msEncrypt = new MemoryStream())
                    {
                        using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                        {
                            csEncrypt.Write(data, 0, data.Length);
                            csEncrypt.FlushFinalBlock();
                            encrypted = msEncrypt.ToArray();
                        }
                    }
                }

                return System.Convert.ToBase64String(Concat(Concat("Salted__", salt), encrypted));
            }
        }

        /// <summary>
        /// Derypt encrypted text with the password using random salt.
        /// Returns the decrypted string.
        /// </summary>
        /// <param name="encrypted">Encrypted text to decrypt</param>
        /// <param name="passphrase">Passphrase</param>
        public string Decrypt(string encrypted, string passphrase)
        {
            return Encoding.UTF8.GetString(DecryptToBytes(encrypted, passphrase));
        }

        /// <summary>
        /// Derypt encrypted data with the password using random salt.
        /// Returns the decrypted bytes.
        /// </summary>
        /// <param name="encrypted">Encrypted data to decrypt</param>
        /// <param name="passphrase">Passphrase</param>
        public byte[] DecryptToBytes(string encrypted, string passphrase)
        {
            byte[] ct = System.Convert.FromBase64String(encrypted);
            if (ct == null || ct.Length <= 0) {
                return new byte[0];
            }

            byte[] salted = new byte[8];
            Array.Copy(ct, 0, salted, 0, 8);

            if (Encoding.UTF8.GetString(salted) != "Salted__") {
                return new byte[0];
            }

            byte[] salt = new byte[8];
            Array.Copy(ct, 8, salt, 0, 8);

            byte[] cipherText = new byte[ct.Length - 16];
            Array.Copy(ct, 16, cipherText, 0, ct.Length - 16);

            DeriveKeyAndIv(passphrase, salt);

            byte[] decrypted;
            using (var aes = new RijndaelManaged())
            {
                aes.BlockSize = BlockSize * 8;
                aes.Mode = CipherMode.CBC;
                aes.Padding = PaddingMode.PKCS7;
                aes.Key = key;
                aes.IV = iv;
                ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
                using (var msDecrypt = new MemoryStream())
                {
                    using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Write))
                    {
                        csDecrypt.Write(cipherText, 0, cipherText.Length);
                        csDecrypt.FlushFinalBlock();
                        decrypted = msDecrypt.ToArray();
                    }
                }
            }

            return decrypted;
        }

        /// <summary>
        /// Derive key and iv.
        /// </summary>
        /// <param name="passphrase">Passphrase</param>
        /// <param name="salt">Salt</param>
        protected void DeriveKeyAndIv(string passphrase, byte[] salt)
        {
            MD5 md5 = MD5.Create();

            key = new byte[KeyLen];
            iv = new byte[IvLen];

            byte[] dx = new byte[] {};
            byte[] salted = new byte[] {};
            byte[] pass = Encoding.UTF8.GetBytes(passphrase);

            for (int i = 0; i < (KeyLen + IvLen / 16); i++) {
                dx = Concat(Concat(dx, pass), salt);
                dx = md5.ComputeHash(dx);
                salted = Concat(salted, dx);
            }

            Array.Copy(salted, 0, key, 0, KeyLen);
            Array.Copy(salted, KeyLen, iv, 0, IvLen);
        }

        private static byte[] Concat(byte[] a, byte[] b)
        {
            byte[] output = new byte[a.Length + b.Length];

            for (int i = 0; i < a.Length; i++)
                output[i] = a[i];
            for (int j = 0; j < b.Length; j++)
                output[a.Length+j] = b[j];

            return output;
        }

        private static byte[] Concat(string a, byte[] b)
        {
            return Concat(Encoding.UTF8.GetBytes(a), b);
        }
    }
}

package main

import (
    "bytes"
    "crypto/md5"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"

    "github.com/mervick/aes-everywhere/go/aes256"
)

var (
    apiUrl      = "<url>"                            // This is a example url, please fill in the right url from the MIF
    aesKey      = "HJwMgszptPW8YybZGFluBTm569crSxhd" // This is a example aes_key, please fill in the right aes_key from the MIF
    signKey     = "AbKmLhGTkHpoPzj6fWFS4e5BtI3xuvEJ" // This is a example sign_key, please fill in the right sign_key from the MIF
    channel     = "01234567"                         // This is a example Channel, please fill in the right Channel from the MIF
    agent       = "exampleAg001"                     // This is a example Agent, please fill in the right Agent from the MIF
    account     = "exampleAct001"                    // This is a example Account, please fill in the right Account from the MIF
    accountData = map[string]interface{}{
        "agent":   agent,
        "account": account,
    }
)

func AESKeyEncryption(d string) string {
    return aes256.Encrypt(string(d), aesKey)
}

func SignKeyEncryption(d string) string {
    h := md5.New()
    h.Write([]byte(d))
    cipherStr := h.Sum(nil)
    return hex.EncodeToString(cipherStr)
}

func CreateMember(a string, s string) {
    data := map[string]interface{}{
        "channel": channel,
        "data":    a,
        "sign":    s,
    }

    req, err := json.Marshal(&data)
    if err != nil {
        log.Fatalf("json.Marshal err: %s. data: %+v", err.Error(), data)
        return
    }

    Post(fmt.Sprintf("https://%s/v1/member/create", apiUrl), req)
}

func Post(url string, req []byte) {
    r, err := http.NewRequest("POST", url, bytes.NewBuffer(req))
    if err != nil {
        log.Fatalf("http.NewRequest err: %s. url: %s, req: %+v", err.Error(), url, string(req))
        return
    }
    r.Header.Set("Content-Type", "application/json")

    c := &http.Client{}
    resp, err := c.Do(r)
    if err != nil {
        log.Fatalf("client.Do err: %s. url: %s, req: %+v", err.Error(), url, string(req))
        return
    }
    defer resp.Body.Close()

    fmt.Println("response Status:", resp.Status)
    fmt.Println("response StatusCode:", resp.StatusCode)

    res, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("response Body:", string(res))
}

func main() {
    d, err := json.Marshal(accountData)
    if err != nil {
        log.Fatalf("json.Marshal err: %s. accountData: %+v", err.Error(), accountData)
        return
    }

    a := AESKeyEncryption(string(d))
    s := SignKeyEncryption(fmt.Sprintf("%s%s", a, signKey))
    CreateMember(a, s)
}

package com.transfer;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import net.sf.json.JSONObject;
import com.github.mervick.aes_everywhere.Aes256;

public class Transfer {
    public static final String apiUrl = "<url>"; // This is a example url, please fill in the right url from the
                                                 // MIF
    public static final String aesKey = "HJwMgszptPW8YybZGFluBTm569crSxhd"; // This is a example aes_key, please fill in
                                                                            // the right aes_key from the MIF
    public static final String signKey = "AbKmLhGTkHpoPzj6fWFS4e5BtI3xuvEJ"; // This is a example sign_key, please fill
                                                                             // in the right sign_key from the
    // MIF
    public static final String channel = "01234567"; // This is a example Channel, please fill in the right Channel from
                                                     // the MIF
    public static final String agent = "exampleAg001"; // This is a example Agent, please fill in the right Agent from
                                                       // the MIF
    public static final String account = "exampleAct001"; // This is a example Account, please fill in the right Account
                                                          // from
    // the MIF
    public static final JSONObject actData = new JSONObject();

    public static String AESKeyEncryption(String d) {
        try {
            String a = Aes256.encrypt(d, aesKey);
            return a;
        } catch (Exception e) {
            System.out.println(e);
        }
        return "";
    }

    public static String SignKeyEncryption(String d) {
        try {
            java.security.MessageDigest h = java.security.MessageDigest.getInstance("MD5");
            byte[] cipherStr = h.digest(d.getBytes());
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < cipherStr.length; ++i) {
                sb.append(Integer.toHexString((cipherStr[i] & 0xFF) | 0x100).substring(1, 3));
            }
            return sb.toString();
        } catch (Exception e) {
            System.out.println(e);
        }
        return "";
    }

    public static void CreateMember(String data, String sign) {
        try {
            JSONObject req = new JSONObject();
            req.put("channel", channel);
            req.put("data", data);
            req.put("sign", sign);

            URL url = new URL("https://" + apiUrl + "/v1/member/create");
            Post(url, req.toString().getBytes("UTF-8"));
        } catch (Exception e) {
            System.out.println(e);
        }
    }

    public static void Post(URL url, byte[] req) {
        try {
            HttpURLConnection c = (HttpURLConnection) url.openConnection();
            c.setDoOutput(true);
            c.setDoInput(true);
            c.setRequestMethod("POST");
            c.setUseCaches(false);
            c.setInstanceFollowRedirects(true);
            c.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
            c.connect();

            DataOutputStream o = new DataOutputStream(c.getOutputStream());
            o.write(req);
            o.flush();
            o.close();

            BufferedReader r = new BufferedReader(new InputStreamReader(c.getInputStream()));
            String lines;
            StringBuffer sb = new StringBuffer("");
            while ((lines = r.readLine()) != null) {
                lines = new String(lines.getBytes(), "utf-8");
                sb.append(lines);
            }

            System.out.println(sb);

            // 斷開連線
            r.close();
            c.disconnect();

        } catch (Exception e) {
            System.out.println(e);
        }
    }

    public static void main(String[] args) {
        try {
            actData.put("agent", agent);
            actData.put("account", account);
            String a = AESKeyEncryption(actData.toString());
            String s = SignKeyEncryption(a + signKey);
            CreateMember(a, s);
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

<?php
// php example

class Authentication {
    protected $apiUrl = '<url>'; // This is a example url, please fill in the right url from the MIF
    protected $aesKey = 'HJwMgszptPW8YybZGFluBTm569crSxhd'; // This is a example aes_key, please fill in the right aes_key from the MIF
    protected $signKey = 'AbKmLhGTkHpoPzj6fWFS4e5BtI3xuvEJ'; // This is a example sign_key, please fill in the right sign_key from the MIF
    protected $channel = '01234567'; // This is a example Channel, please fill in the right Channel from the MIF
    protected $accountData = [
        "agent" => 'exampleAg001', // This is a example Agent, please fill in the right Agent from the MIF
        "account" => 'exampleAct001', // This is a example Account, please fill in the right Account from the MIF
    ];

    public function AESKeyEncryption($d, $a)
    {
        $salt = openssl_random_pseudo_bytes(8);
        $salted = $dx = '';
        while (strlen($salted) < 48) {
            $dx = md5($dx . $a . $salt, true);
            $salted .= $dx;
        }
        $key = substr($salted, 0, 32);
        $iv = substr($salted, 32, 16);
        return base64_encode('Salted__' . $salt . openssl_encrypt($d . '', 'aes-256-cbc', $key, OPENSSL_RAW_DATA, $iv));
    }

    public function SignKeyEncryption($a)
    {
        return md5($a.$this->signKey, false);
    }

    public function CreateMember($a, $s)
    {
        $data = ["channel" => $this->channel, "data" => $a, "sign" => $s];
        $req = json_encode($data);
        $this->Curl($req);
    }

    public function Curl($req)
    {
        $curl = curl_init('https://'.$this->apiUrl.'/v1/member/create');
        curl_setopt($curl, CURLOPT_HEADER, false);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_HTTPHEADER, ['Content-type: application/json']);
        curl_setopt($curl, CURLOPT_POST, true);
        curl_setopt($curl, CURLOPT_POSTFIELDS, $req);
        $ret = curl_exec($curl);

        $status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
        if ( $status != 200 ) {
            die("Error: call to URL $curl failed with status $status, response $ret, curl_error " . curl_error($curl) . ", curl_errno " . curl_errno($curl));
        }
        curl_close($curl);

        $res = json_decode($ret, true);
        print_r($res);
    }

    public function Start()
    {
        $d = json_encode($this->accountData);
        $a = $this->AESKeyEncryption($d, $this->aesKey);
        $s = $this->SignKeyEncryption($a);
        $this->CreateMember($a, $s);
    }
}

$auth = new Authentication();
$auth->Start();
?>

import json
import hashlib
import requests
from AesEverywhere import aes256 # pip install aes-everywhere

apiUrl = '<url>' # This is a example url, please fill in the right url from the MIF
aesKey = 'HJwMgszptPW8YybZGFluBTm569crSxhd' # This is a example aes_key, please fill in the right aes_key from the MIF
signKey = 'AbKmLhGTkHpoPzj6fWFS4e5BtI3xuvEJ' # This is a example sign_key, please fill in the right sign_key from the MIF
channel = '01234567' # This is a example Channel, please fill in the right Channel from the MIF
accountData = {
    'agent': 'exampleAg001', # This is a example Agent, please fill in the right Agent from the MIF
    'account': 'exampleAct001' # This is a example Account, please fill in the right Account from the MIF
}

def AESKeyEncryption(d):
    return aes256.encrypt(d, aesKey)

def SignKeyEncryption(d):
    m = hashlib.md5()
    m.update(d.encode())
    return m.hexdigest()

def CreateMember(a, s):
    data = {
        'channel': channel,
        'data': a,
        'sign': s
    }
    resp = requests.request("POST", 'https://' + apiUrl + '/v1/member/create', headers={'content-type': "application/json"}, json=data)
    print(resp.text)

def Start():
    a = AESKeyEncryption(json.dumps(accountData))
    s = SignKeyEncryption(a.decode() + signKey)
    CreateMember(a.decode('utf-8'), s)

Start()

// nodejs example

var AES256 = require("aes-everywhere");
var crypto = require("crypto");
const request = require("request").defaults({});

var apiUrl = "<url>";
var aesKey = "HJwMgszptPW8YybZGFluBTm569crSxhd"; // This is a example aes_key, please fill in the right aes_key from the MIF
var signKey = "AbKmLhGTkHpoPzj6fWFS4e5BtI3xuvEJ"; // This is a example sign_key, please fill in the right sign_key from the MIF
var channel = "01234567"; // This is a example Channel, please fill in the right Channel from the MIF
var accountData = {
  agent: "exampleAg001", // This is a example Agent, please fill in the right Agent from the MIF
  account: "exampleAct001", // This is a example Account, please fill your member account
};

function AESKeyEncryption(d) {
  return AES256.encrypt(d, aesKey);
}

function SignKeyEncryption(d) {
  return crypto.createHash("md5").update(d).digest("hex");
}

function CreateMember(a, s) {
  return new Promise((done) => {
    var options = {
      url: "https://" + apiUrl + "/v1/member/create",
      method: "Post",
      json: {
        channel: channel,
        data: a,
        sign: s,
      },
    };

    request(options, (err, res, body) => {
      console.log("err: ", err);
      console.log("body: ", body);
    });
  });
}

function Start() {
  a = AESKeyEncryption(JSON.stringify(accountData));
  s = SignKeyEncryption(a + signKey);
  CreateMember(a, s);
}

Start();

POST /v1/member/create HTTP/1.1
Content-Type: application/json

{
  "channel": "7878778",
  "data": "U2FsdGVkX18agQleI7fP+eJ1l2WmCNZMRajMNRrlkydQRjbHm0LlIBLC1oxdLPWtJgXqcRyg/gEgKDJgpM7sEg==",
  "sign": "75ad8c8d3fc993885f7f8f9470e70227"
}

{
  "agent": "DEMO00001",
  "account": "Username002",
  "password": "2788b26f9845bf9276b0aa45de7"
}

{
  "result": {
    "code": 1,
    "msg": "success"
  }
}

{
  "game_id": "1001",
  "lang": "zh_cn",
  "is_demo": true
}

{
  "result": {
    "code": 1,
    "msg": "success"
  },
  "url": "https://game_server_url/h5/1001/?token=d01e14944dcd4a0e9e207f4438bb37da&lang=zh_cn&oper=ds&backurl=https://backurl.com"
}

{
  "result": {
    "code": 1,
    "msg": "UNDER MAINTENANCE"
  },
  "static": "",
  "dynamic": "",
  "token": "",
  "url": "https://www.dragoonsoft.com/maintenace.html"
}

{
  "agent": "AG000001",
  "account": "Username002"
}

{
  "result": {
    "code": 1,
    "msg": "success"
  }
}

{
  "agent": "AG000001",
  "account": "Username002"
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "login_info": {
    "online": 2
  }
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "list": [
    {
      "agent": "AG000001",
      "account": "Username002",
      "game_id": "1001",
      "login_time": "2019-05-08T12:40:52.036394384Z"
    },
    {
      "agent": "AG000001",
      "account": "Username001",
      "game_id": "2001",
      "login_time": "2019-05-08T12:28:25.086438394Z"
    },
    {
      "agent": "AG000002",
      "account": "Username055",
      "game_id": "3011",
      "login_time": "2019-05-08T12:41:42.026213394Z"
    }
  ]
}

{
  "agent": "AG000001"
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "list": [
    {
      "agent": "AG000001",
      "account": "Username002",
      "game_id": "1001",
      "login_time": "2019-05-08T12:40:52.036394384Z",
      "balance": 99999.99
    },
    {
      "agent": "AG000001",
      "account": "Username001",
      "game_id": "2001",
      "login_time": "2019-05-08T12:28:25.086438394Z",
      "balance": 2.22
    },
    {
      "agent": "AG000002",
      "account": "Username055",
      "game_id": "3011",
      "login_time": "2019-05-08T12:41:42.026213394Z",
      "balance": 1
    }
  ]
}

{
  "serial": "1536140284868",
  "agent": "AG000001",
  "account": "Username002",
  "amount": "10000",
  "oper_type": 1
}

{
  "result": {
    "code": 1,
    "msg": "success",
    "timestamp": "2018-11-12T03:03:53.174604283Z"
  },
  "trans_id": "109668",
  "serial": "1536133443167",
  "balance": "582427.70"
}

{
  "agent": "develop01c02",
  "account": "user0002",
  "serial": "1531839120967"
}

{
  "result": {
    "code": 1,
    "msg": "success",
    "timestamp": "2018-11-12T03:03:53.174604283Z"
  },
  "serial": "1531839120967",
  "amount": "10.00",
  "trans_id": "abcd1234"
}

{
  "agent": "develop01c02",
  "account": "Username002"
}

{
  "result": {
    "code": 1,
    "msg": "success",
    "timestamp": "2018-11-12T03:03:53.174604283Z"
  },
  "balance": "449862.90"
}

{
  "finish_time": {
    "start_time": "2018-10-19T08:54:14+01:00",
    "end_time": "2018-10-19T08:57:08+01:00"
  },
  "index": 0,
  "limit": 10
}

{
  "result": {
    "code": 1,
    "msg": "success",
    "timestamp": "2018-11-12T04:03:53.174604283Z"
  },
  "total": "8870",
  "rows": [
    {
      "id": "1",
      "bet_at": "2018-10-18T05:47:51Z",
      "finish_at": "2018-10-18T05:47:51Z",
      "agent": "AG0000001",
      "member": "MB03",
      "game_id": "1001",
      "game_serial": "324823745",
      "game_type": 1,
      "round_id": "1",
      "bet_amount": "1200",
      "payout_amount": "0",
      "valid_amount": "1200",
      "status": 1,
      "fee_amount": "10",
      "jp_amount": "10",
      "event_id": "",
      "event_amount": 0,
      "feature_buy": ""
    },
    {
      "id": "2",
      "bet_at": "2018-10-18T05:47:51Z",
      "finish_at": "2018-10-18T05:47:51Z",
      "agent": "AG0000001",
      "member": "MB03",
      "game_id": "1001",
      "game_serial": "38427123",
      "game_type": 1,
      "round_id": "1",
      "bet_amount": "3600",
      "payout_amount": "0",
      "valid_amount": "3600",
      "status": 1,
      "fee_amount": "10",
      "jp_amount": "10",
      "event_id": "",
      "event_amount": 0,
      "feature_buy": "FG1:2"
    }
  ]
}

{
  "game_id": "2001",
  "game_serial": "23134242",
  "lang": "zh_cn"
}

{
  "result": {
    "code": 1,
    "msg": "success"
  },
  "url": "https://<record.page>/bet_detail/?token=3fd0e97e-198b-4d34-9ab0-cd3f82f79ba3&lang=zh_cn"
}

{
  "agent": "AG0000001",
  "account": "MB03",
  "game_id": "2001",
  "lang": "zh_cn"
}

{
  "result": {
    "code": 1,
    "msg": "success"
  },
  "url": "https://<record.page>/auth/eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0IjoiODc3MjZjOTg3M2NlNGRmNWI4YTM4MTdiZTc2YjU5NTQifQ.qzLt51idNxxsZV4nXfO0wui-moVDeRdolhlNNdZp7go?g=1&gid=1001&lang=en_us"
}

{
  "start_time": "2018-10-19T13:00:00+01:00",
  "end_time": "2018-10-19T13:59:59+01:00",
  "index": 0,
  "limit": 10
}

{
  "result": {
    "code": 1,
    "msg": "success"
  },
  "rows": [
    {
      "statistics_date": "2018-10-19T13:00:00+01:00",
      "bet_count": 0,
      "bet_amount": 0,
      "real_bet_amount": 0,
      "payout_amount": 0,
      "valid_amount": 0,
      "fee_amount": 0,
      "jp_amount": 0,
      "win_loss_amount": 0
    }
  ]
}

{
  "finish_time": {
    "start_time": "2018-10-19T08:54:14+01:00",
    "end_time": "2018-10-19T08:57:08+01:00"
  }
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "rows": [
    {
      "agent": "cstest00",
      "bet_count": "246",
      "bet_amount": 9541.8,
      "payout_amount": 9472.12,
      "valid_amount": 9541.8,
      "fee_amount": 0,
      "jp_amount": 0
    }
  ]
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "game_info_state_list": [
    {
      "id": "1001",
      "type": "1",
      "active": true,
      "names": {
        "en_us": "Ocean Lord",
        "th_th": "จ้าวมหาสมุทร",
        "vi_vn": "Chúa tể đại dương",
        "zh_cn": "海霸王"
      },
      "latest": false,
      "hot": true,
      "weight": "3002"
    },
    {
      "id": "1002",
      "type": "1",
      "active": true,
      "names": {
        "en_us": "Let's Shoot",
        "th_th": "มายิงกัน",
        "vi_vn": "Hãy Bắn",
        "zh_cn": "吃我一炮"
      },
      "latest": false,
      "hot": true,
      "weight": "3003"
    }
  ]
}